// ResetPassword resets a password of user. func ResetPassword(c *gin.Context) (int, error) { var user model.User var passwordResetForm PasswordResetForm c.BindWith(&passwordResetForm, binding.Form) if db.ORM.Where(&model.User{PasswordResetToken: passwordResetForm.PasswordResetToken}).First(&user).RecordNotFound() { return http.StatusNotFound, errors.New("User is not found.") } isExpired := timeHelper.IsExpired(user.PasswordResetUntil) log.Debugf("passwordResetUntil : %s", user.PasswordResetUntil.UTC()) log.Debugf("expired : %t", isExpired) if isExpired { return http.StatusForbidden, errors.New("token not valid.") } newPassword, err := bcrypt.GenerateFromPassword([]byte(passwordResetForm.Password), 10) if err != nil { return http.StatusInternalServerError, errors.New("User is not updated. Password not Generated.") } passwordResetForm.Password = string(newPassword) log.Debugf("user password before : %s ", user.Password) modelHelper.AssignValue(&user, &passwordResetForm) user.PasswordResetToken = "" user.PasswordResetUntil = time.Now() log.Debugf("user password after : %s ", user.Password) status, err := UpdateUserCore(&user) if err != nil { return status, err } status, err = SetCookie(c, user.Token) return status, err }
// CreateFiles creates files. func CreateFiles(c *gin.Context) (int, error) { var forms FilesForm start := time.Now() c.BindWith(&forms, binding.JSON) log.Debugf("CreateFiles c form : %v", forms) user, _ := userService.CurrentUser(c) sqlStrBuffer := new(bytes.Buffer) stringHelper.Concat(sqlStrBuffer, "INSERT INTO file(user_id, name, size, created_at) VALUES ") values := []interface{}{} for _, file := range forms.Files { stringHelper.Concat(sqlStrBuffer, "(?, ?, ?, ?),") values = append(values, user.Id, file.Name, file.Size, time.Now()) } // sqlStrBuffer.Truncate(sqlStrBuffer.Len() - 1) is slower than slice. if len(values) > 0 { sqlStr := sqlStrBuffer.String() sqlStr = sqlStr[0 : len(sqlStr)-1] log.Debugf("sqlStr for File : %s", sqlStr) db.ORM.Exec(sqlStr, values...) elapsed := time.Since(start) log.Debugf("CreateFiles elapsed : %s", elapsed) } return http.StatusCreated, nil }
// SendPasswordResetToken sends a password reset token. func SendPasswordResetToken(c *gin.Context) (int, error) { var user model.User var sendPasswordResetForm SendPasswordResetForm var err error log.Debugf("c.Params : %v", c.Params) c.BindWith(&sendPasswordResetForm, binding.Form) if db.ORM.Where(&model.User{Email: sendPasswordResetForm.Email}).First(&user).RecordNotFound() { return http.StatusNotFound, errors.New("User is not found. Please Check the email.") } user.PasswordResetUntil = timeHelper.TwentyFourHoursLater() user.PasswordResetToken, err = crypto.GenerateRandomToken16() if err != nil { return http.StatusInternalServerError, err } log.Debugf("generated token : %s", user.PasswordResetToken) status, err := UpdateUserCore(&user) if err != nil { return status, err } err = SendEmailPasswordResetToken(user.Email, user.PasswordResetToken, "en-us") if err != nil { return http.StatusInternalServerError, err } return http.StatusOK, nil }
// RetrieveLocations retrieves locations. func RetrieveLocations(c *gin.Context) ([]model.Location, bool, int, bool, bool, int, error) { var locations []model.Location var locationCount, locationPerPage int filterQuery := c.Request.URL.Query().Get("filter") locationPerPage = config.LocationPerPage filter := &LocationFilter{} whereBuffer := new(bytes.Buffer) whereValues := []interface{}{} if len(filterQuery) > 0 { log.Debugf("retrieve Locations filter : %s\n", filterQuery) json.Unmarshal([]byte(filterQuery), &filter) if filter.UserId > 0 { stringHelper.Concat(whereBuffer, "user_id = ?") whereValues = append(whereValues, filter.UserId) log.Debugf("userId : %d\n", filter.UserId) } if filter.LocationPerPage > 0 { locationPerPage = filter.LocationPerPage log.Debugf("locationPerPage : %d\n", filter.LocationPerPage) } } else { log.Debug("no filters found.\n") } log.Debugf("filterQuery %v.\n", filterQuery) log.Debugf("filter %v.\n", filter) whereStr := whereBuffer.String() db.ORM.Model(model.Location{}).Where(whereStr, whereValues...).Count(&locationCount) offset, currentPage, hasPrev, hasNext := pagination.Paginate(filter.CurrentPage, locationPerPage, locationCount) db.ORM.Limit(locationPerPage).Offset(offset).Order(config.LocationOrder).Where(whereStr, whereValues...).Find(&locations) return locations, canUserWrite(c), currentPage, hasPrev, hasNext, http.StatusOK, nil }
// LoginOrCreateOauthUser login or create with oauthUser func LoginOrCreateOauthUser(c *gin.Context, oauthUser *OauthUser, providerID int64, token *oauth2.Token) (int, error) { var connection model.Connection var count int db.ORM.Where("provider_id = ? and provider_user_id = ?", providerID, oauthUser.Id).First(&connection).Count(&count) connection.ProviderId = providerID connection.ProviderUserId = oauthUser.Id connection.AccessToken = token.AccessToken connection.ProfileUrl = oauthUser.ProfileUrl connection.ImageUrl = oauthUser.ImageUrl log.Debugf("connection count : %v", count) if count == 1 { var user model.User if db.ORM.First(&user, "id = ?", connection.UserId).RecordNotFound() { return http.StatusNotFound, errors.New("User is not found.") } log.Debugf("user : %v", user) if db.ORM.Save(&connection).Error != nil { return http.StatusInternalServerError, errors.New("Connection is not updated.") } status, err := LoginWithOauthUser(c, user.Token) return status, err } log.Debugf("Connection is not exist.") user, status, err := CreateOauthUser(c, oauthUser, &connection) if err != nil { return status, err } status, err = LoginWithOauthUser(c, user.Token) return status, err }
// OauthGithub link connection and user. func OauthGithub(c *gin.Context) (int, error) { var authResponse oauth2.AuthResponse var oauthUser OauthUser c.BindWith(&authResponse, binding.Form) log.Debugf("oauthRedirect form: %v", authResponse) response, token, err := oauth2.OauthRequest(github.RequestURL, github.Config, authResponse) if err != nil { log.Error("get response error") return http.StatusInternalServerError, err } githubUser, err := SetGithubUser(response) if err != nil { log.Error("SetGithubUser error") return http.StatusInternalServerError, err } modelHelper.AssignValue(&oauthUser, githubUser) oauthUser.Id = strconv.Itoa(githubUser.UserId) log.Debugf("\noauthUser item : %v", oauthUser) status, err := LoginOrCreateOauthUser(c, &oauthUser, github.ProviderId, token) if err != nil { log.Errorf("LoginOrCreateOauthUser error: %d", status) return status, err } return http.StatusSeeOther, nil }
// RetrieveArticle retrieve an article. func RetrieveArticle(c *gin.Context) (model.Article, bool, int64, int, error) { var article model.Article var count int var currentUserId int64 var isAuthor bool id := c.Params.ByName("id") if db.ORM.First(&article, "id = ?", id).RecordNotFound() { return article, isAuthor, currentUserId, http.StatusNotFound, errors.New("Article is not found.") } log.Debugf("Article : %s\n", article) log.Debugf("Count : %s\n", count) currentUser, err := userService.CurrentUser(c) if err == nil { currentUserId = currentUser.Id isAuthor = currentUser.Id == article.UserId } assignRelatedUser(&article) var commentList model.CommentList comments, currentPage, hasPrev, hasNext, _ := commentService.RetrieveComments(article) commentList.Comments = comments commentService.SetCommentPageMeta(&commentList, currentPage, hasPrev, hasNext, article.CommentCount) article.CommentList = commentList var likingList model.LikingList likings, currentPage, hasPrev, hasNext, _ := likingRetriever.RetrieveLikings(article) likingList.Likings = likings currentUserlikedCount := db.ORM.Model(&article).Where("id =?", currentUserId).Association("Likings").Count() log.Debugf("Current user like count : %d", currentUserlikedCount) likingMeta.SetLikingPageMeta(&likingList, currentPage, hasPrev, hasNext, article.LikingCount, currentUserlikedCount) article.LikingList = likingList return article, isAuthor, currentUserId, http.StatusOK, nil }
// RetrieveOauthStatus retrieves ouath status that provider connected or not. func RetrieveOauthStatus(c *gin.Context) (oauthStatusMap, int, error) { var oauthStatus oauthStatusMap var connections []model.Connection oauthStatus = make(oauthStatusMap) currentUser, err := userService.CurrentUser(c) if err != nil { return oauthStatus, http.StatusUnauthorized, err } db.ORM.Model(¤tUser).Association("Connections").Find(&connections) for _, connection := range connections { log.Debugf("connection.ProviderId : %d", connection.ProviderId) switch connection.ProviderId { case google.ProviderId: oauthStatus["google"] = true case github.ProviderId: oauthStatus["github"] = true case yahoo.ProviderId: oauthStatus["yahoo"] = true case facebook.ProviderId: oauthStatus["facebook"] = true case twitter.ProviderId: oauthStatus["twitter"] = true case linkedin.ProviderId: oauthStatus["linkedin"] = true case kakao.ProviderId: oauthStatus["kakao"] = true case naver.ProviderId: oauthStatus["naver"] = true } } log.Debugf("oauthStatus : %v", oauthStatus) return oauthStatus, http.StatusOK, nil }
// EmailVerification verifies an email of user. func EmailVerification(c *gin.Context) (int, error) { var user model.User var verifyEmailForm VerifyEmailForm c.BindWith(&verifyEmailForm, binding.Form) log.Debugf("verifyEmailForm.ActivationToken : %s", verifyEmailForm.ActivationToken) if db.ORM.Where(&model.User{ActivationToken: verifyEmailForm.ActivationToken}).First(&user).RecordNotFound() { return http.StatusNotFound, errors.New("User is not found.") } isExpired := timeHelper.IsExpired(user.ActivateUntil) log.Debugf("passwordResetUntil : %s", user.ActivateUntil.UTC()) log.Debugf("expired : %t", isExpired) if isExpired { return http.StatusForbidden, errors.New("token not valid.") } user.ActivationToken = "" user.ActivateUntil = time.Now() user.ActivatedAt = time.Now() user.Activation = true status, err := UpdateUserCore(&user) if err != nil { return status, err } status, err = SetCookie(c, user.Token) return status, err }
func FewDurationLater(duration time.Duration) time.Time { // When Save time should considering UTC baseTime := time.Now() log.Debugf("basetime : %s", baseTime) fewDurationLater := baseTime.Add(duration) log.Debugf("time : %s", fewDurationLater) return fewDurationLater }
// RegisterHanderFromForm sets cookie from a RegistrationForm. func RegisterHanderFromForm(c *gin.Context, registrationForm RegistrationForm) (int, error) { email := registrationForm.Email pass := registrationForm.Password log.Debugf("RegisterHandler UserEmail : %s", email) log.Debugf("RegisterHandler UserPassword : %s", pass) status, err := SetCookieHandler(c, email, pass) return status, err }
func IsExpired(expirationTime time.Time) bool { baseTime := time.Now() log.Debugf("basetime : %s", baseTime) log.Debugf("expirationTime : %s", expirationTime) elapsed := time.Since(expirationTime) log.Debugf("elapsed : %s", elapsed) after := time.Now().After(expirationTime) log.Debugf("after : %t", after) return after }
// SetNaverUser set naver user. func SetNaverUser(response *http.Response) (*NaverUser, error) { naverUser := &NaverUser{} defer response.Body.Close() log.Debugf("response.Body: %v\n", response.Body) body, err := ioutil.ReadAll(response.Body) if err != nil { return naverUser, err } json.Unmarshal(body, &naverUser) log.Debugf("\nnaverUser: %v\n", naverUser) return naverUser, err }
// SetKakaoUser set kakao user. func SetKakaoUser(response *http.Response) (*KakaoUser, error) { kakaoUser := &KakaoUser{} defer response.Body.Close() log.Debugf("response.Body: %v\n", response.Body) body, err := ioutil.ReadAll(response.Body) if err != nil { return kakaoUser, err } json.Unmarshal(body, &kakaoUser) log.Debugf("\nkakaoUser: %v\n", kakaoUser) return kakaoUser, err }
// imageUploader is a uploader that uploading files. func imageUploader() concurrency.ConcurrencyManager { return func(reader *multipart.Reader) concurrency.Result { atomic.AddInt32(concurrency.BusyWorker, 1) var result concurrency.Result result.Code = http.StatusOK for { part, err := reader.NextPart() uploadedNow := atomic.AddUint32(concurrency.Done, 1) log.Debugf("count %d", uploadedNow) if err == io.EOF { log.Debug("End of file.") break } if part.FileName() == "" { log.Debug("File name is empty.") continue } err = upload.UploadImageFile(s3UploadPath, part) if err != nil { log.Error("Image uploading failed. : " + err.Error()) result.Code = http.StatusBadRequest result.Error = err return result } log.Debug("File uploaded.") } log.Debug("Iteration concurrency.Done.") return result } }
// RetrieveLikingsOnArticles retrieves likings on article. func RetrieveLikingsOnArticles(c *gin.Context) ([]model.User, int, bool, bool, int, int, error) { var article model.Article var likings []model.User var retrieveListForm form.RetrieveListForm var hasPrev, hasNext bool var currentPage, count int articleId := c.Params.ByName("id") log.Debugf("Liking params : %v", c.Params) c.BindWith(&retrieveListForm, binding.Form) log.Debugf("retrieveListForm %+v\n", retrieveListForm) if db.ORM.First(&article, articleId).RecordNotFound() { return likings, currentPage, hasPrev, hasNext, count, http.StatusNotFound, errors.New("Article is not found.") } likings, currentPage, hasPrev, hasNext, count = likingRetriever.RetrieveLikings(article, retrieveListForm.CurrentPage) return likings, currentPage, hasPrev, hasNext, count, http.StatusOK, nil }
// RetrieveLikingsOnLocations retrieves likings on location. func RetrieveLikingsOnLocations(c *gin.Context) ([]*model.PublicUser, int, bool, bool, int, int, error) { var location model.Location var likings []*model.PublicUser var retrieveListForm form.RetrieveListForm var hasPrev, hasNext bool var currentPage, count int locationId := c.Params.ByName("id") log.Debugf("Liking params : %v", c.Params) c.BindWith(&retrieveListForm, binding.Form) log.Debugf("retrieveListForm %+v\n", retrieveListForm) if db.ORM.First(&location, locationId).RecordNotFound() { return likings, currentPage, hasPrev, hasNext, count, http.StatusNotFound, errors.New("Location is not found.") } likings, currentPage, hasPrev, hasNext, count = likingRetriever.RetrieveLikings(location, retrieveListForm.CurrentPage) return likings, currentPage, hasPrev, hasNext, count, http.StatusOK, nil }
// RetrieveUser retrieves a user. func RetrieveUser(c *gin.Context) (*model.PublicUser, bool, int64, int, error) { var user model.User var currentUserId int64 var isAuthor bool // var publicUser *model.PublicUser // publicUser.User = &user id := c.Params.ByName("id") if db.ORM.Select(config.UserPublicFields).First(&user, id).RecordNotFound() { return &model.PublicUser{User: &user}, isAuthor, currentUserId, http.StatusNotFound, errors.New("User is not found.") } currentUser, err := CurrentUser(c) if err == nil { currentUserId = currentUser.Id isAuthor = currentUser.Id == user.Id } var likingList model.LikingList likings, currentPage, hasPrev, hasNext, _ := likingRetriever.RetrieveLikings(user) likingList.Likings = likings currentUserlikedCount := db.ORM.Model(&user).Where("id =?", currentUserId).Association("Likings").Count() log.Debugf("Current user like count : %d", currentUserlikedCount) likingMeta.SetLikingPageMeta(&likingList, currentPage, hasPrev, hasNext, user.LikingCount, currentUserlikedCount) user.LikingList = likingList var likedList model.LikedList liked, currentPage, hasPrev, hasNext, _ := likingRetriever.RetrieveLiked(user) likedList.Liked = liked likingMeta.SetLikedPageMeta(&likedList, currentPage, hasPrev, hasNext, user.LikedCount) user.LikedList = likedList return &model.PublicUser{User: &user}, isAuthor, currentUserId, http.StatusOK, nil }
// Upload uploads file to a storage. func Upload(reader *multipart.Reader, kind int) { c := make(chan UploadStatus) switch kind { case KindUploaderBasic: go func() { c <- UploadAgent(reader, 업로더, BasicUploader, Cargador, Shàngchuán, загрузчик) }() case KindUploaderArticle: go func() { c <- UploadAgent(reader, Article업로더, ArticleUploader, ArticleCargador, ArticleShàngchuán, Articleзагрузчик) }() default: go func() { c <- UploadAgent(reader, 업로더, BasicUploader, Cargador, Shàngchuán, загрузчик) }() } timeout := time.After(config.UploadTimeout) select { case <-c: workingNow := atomic.AddInt32(workingUploader, -1) log.Debugf("All files are uploaded. Working uploader count : %d", workingNow) return case <-timeout: fmt.Println("timed out") return } }
// DeleteFile deletes a file. func DeleteFile(c *gin.Context) (int, error) { log.Debug("deleteFile performed") var targetFile model.File id := c.Params.ByName("id") if db.ORM.First(&targetFile, id).RecordNotFound() { return http.StatusNotFound, errors.New("File is not found.") } status, err := userPermission.CurrentUserIdentical(c, targetFile.UserId) if err != nil { return status, err } switch config.UploadTarget { case "S3": s3UploadPath := config.UploadS3Path + strconv.FormatInt(targetFile.UserId, 10) + "/" log.Debugf("s3UploadPath %s", s3UploadPath) err = aws.DelFromMyBucket(s3UploadPath, targetFile.Name) if err != nil { return http.StatusInternalServerError, err } case "LOCAL": err = file.DeleteLocal(targetFile.Name) if err != nil { return http.StatusInternalServerError, err } } if db.ORM.Delete(&targetFile).Delete(targetFile).Error != nil { return http.StatusInternalServerError, errors.New("File is not deleted.") } return http.StatusOK, nil }
// RetrieveLocation retrieves a location. func RetrieveLocation(c *gin.Context) (model.Location, bool, int64, int, error) { var location model.Location var currentUserId int64 isAuthor := false id := c.Params.ByName("id") if db.ORM.First(&location, "id = ?", id).RecordNotFound() { return location, isAuthor, currentUserId, http.StatusNotFound, errors.New("Location is not found.") } currentUser, err := userService.CurrentUser(c) if err == nil { currentUserId = currentUser.Id isAuthor = currentUser.Id == location.UserId } assignRelatedUser(&location) var commentList model.CommentList comments, currentPage, hasPrev, hasNext, _ := commentService.RetrieveComments(location) commentList.Comments = comments commentService.SetCommentPageMeta(&commentList, currentPage, hasPrev, hasNext, location.CommentCount) location.CommentList = commentList var likingList model.LikingList likings, currentPage, hasPrev, hasNext, _ := likingRetriever.RetrieveLikings(location) likingList.Likings = likings currentUserlikedCount := db.ORM.Model(&location).Where("id =?", currentUserId).Association("Likings").Count() log.Debugf("Current user like count : %d", currentUserlikedCount) likingMeta.SetLikingPageMeta(&likingList, currentPage, hasPrev, hasNext, location.LikingCount, currentUserlikedCount) location.LikingList = likingList return location, isAuthor, currentUserId, http.StatusOK, nil }
// SetCookieHandler sets a cookie with email and password. func SetCookieHandler(c *gin.Context, email string, pass string) (int, error) { if email != "" && pass != "" { log.Debugf("User email : %s , password : %s", email, pass) var user model.User isValidEmail := validation.EmailValidation(email) if isValidEmail { log.Debug("User entered valid email.") if db.ORM.Where("email = ?", email).First(&user).RecordNotFound() { return http.StatusNotFound, errors.New("User is not found.") } } else { log.Debug("User entered username.") if db.ORM.Where("username = ?", email).First(&user).RecordNotFound() { return http.StatusNotFound, errors.New("User is not found.") } } err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(pass)) if err != nil { return http.StatusUnauthorized, errors.New("Password incorrect.") } status, err := SetCookie(c, user.Token) if err != nil { return status, err } c.Writer.Header().Set("X-Auth-Token", user.Token) return http.StatusOK, nil } else { return http.StatusNotFound, errors.New("User is not found.") } }
// Your credentials should be obtained from the Google // Developer Console (https://console.developers.google.com). func OauthURL(conf *oauth2.Config) string { // Redirect user to Google's consent page to ask for permission // for the scopes specified above. url := conf.AuthCodeURL("state") log.Debugf("\nVisit the URL for the auth dialog: %v\n", url) return url }
// CreateUserFromForm creates a user from a registration form. func CreateUserFromForm(registrationForm RegistrationForm) (model.User, error) { var user model.User log.Debugf("registrationForm %+v\n", registrationForm) modelHelper.AssignValue(&user, ®istrationForm) user.Md5 = crypto.GenerateMD5Hash(user.Email) token, err := crypto.GenerateRandomToken32() if err != nil { return user, errors.New("Token not generated.") } user.Token = token user.TokenExpiration = timeHelper.FewDaysLater(config.AuthTokenExpirationDay) log.Debugf("user %+v\n", user) if db.ORM.Create(&user).Error != nil { return user, errors.New("User is not created.") } return user, nil }
// RetrieveArticles retrieves articles. func RetrieveArticles(c *gin.Context) ([]model.Article, bool, int, int, bool, bool, int, error) { var articles []model.Article var category int var articleCount, articlePerPage int filterQuery := c.Request.URL.Query().Get("filter") articlePerPage = config.ArticlePerPage filter := &ArticleFilter{} whereBuffer := new(bytes.Buffer) whereValues := []interface{}{} if len(filterQuery) > 0 { log.Debugf("retrieve Articles filter : %s\n", filterQuery) json.Unmarshal([]byte(filterQuery), &filter) if filter.UserId > 0 { stringHelper.Concat(whereBuffer, "user_id = ?") whereValues = append(whereValues, filter.UserId) log.Debugf("userId : %d\n", filter.UserId) } if len(filter.Categories) > 0 { if len(whereValues) == 1 { stringHelper.Concat(whereBuffer, " and ") } stringHelper.Concat(whereBuffer, "category_id = ?") whereValues = append(whereValues, filter.Categories[0]) log.Debugf("categories : %d\n", filter.Categories[0]) category = filter.Categories[0] } if filter.ArticlePerPage > 0 { articlePerPage = filter.ArticlePerPage log.Debugf("articlePerPage : %d\n", filter.ArticlePerPage) } } else { log.Debug("no filters found.\n") } log.Debugf("filterQuery %v.\n", filterQuery) log.Debugf("filter %v.\n", filter) whereStr := whereBuffer.String() log.Debugf("whereStr %s.\n", whereStr) log.Debugf("whereValues %v.\n", whereValues) db.ORM.Model(model.Article{}).Where(whereStr, whereValues...).Count(&articleCount) offset, currentPage, hasPrev, hasNext := pagination.Paginate(filter.CurrentPage, articlePerPage, articleCount) log.Debugf("currentPage, perPage, total : %d, %d, %d", filter.CurrentPage, articlePerPage, articleCount) log.Debugf("offset, currentPage, hasPrev, hasNext : %d, %d, %t, %t", offset, currentPage, hasPrev, hasNext) db.ORM.Limit(articlePerPage).Offset(offset).Order(config.ArticleOrder).Where(whereStr, whereValues...).Find(&articles) return articles, canUserWrite(c, category), category, currentPage, hasPrev, hasNext, http.StatusOK, nil }
func SendEmailFromAdmin(to string, subject string, body string, bodyHTML string) error { msg := gomail.NewMessage() msg.SetHeader("From", config.EmailFrom) msg.SetHeader("To", to, config.EmailTestTo) msg.SetHeader("Subject", subject) msg.SetBody("text/plain", body) msg.AddAlternative("text/html", bodyHTML) log.Debugf("to : %s", to) log.Debugf("subject : %s", subject) log.Debugf("body : %s", body) log.Debugf("bodyHTML : %s", bodyHTML) if config.SendEmail { log.Debug("SendEmail performed.") err := SendEmail(msg) return err } return nil }
// HasAdmin checks that user has an admin permission. func HasAdmin(user *model.User) bool { name := "admin" for _, role := range user.Roles { log.Debugf("HasAdmin role.Name : %s", role.Name) if role.Name == name { return true } } return false }
// SetFacebookUser set facebook user. func SetFacebookUser(response *http.Response) (*FacebookUser, error) { facebookUser := &FacebookUser{} defer response.Body.Close() body, err := ioutil.ReadAll(response.Body) if err != nil { return facebookUser, err } json.Unmarshal(body, &facebookUser) log.Debugf("\nfacebookUser: %v\n", facebookUser) return facebookUser, nil }
// RemoveRoleFromUser removes a role from a user. func RemoveRoleFromUser(c *gin.Context) (int, error) { var user model.User var role model.Role log.Debugf("params : %v\n", c.Params) userId := c.Params.ByName("id") roleId := c.Params.ByName("roleId") if db.ORM.First(&user, userId).RecordNotFound() { return http.StatusNotFound, errors.New("User is not found.") } if db.ORM.First(&role, roleId).RecordNotFound() { return http.StatusNotFound, errors.New("Role is not found.") } log.Debugf("user : %v\n", user) log.Debugf("role : %v\n", role) if db.ORM.Model(&user).Association("Roles").Delete(role).Error != nil { return http.StatusInternalServerError, errors.New("Role is not deleted from user.") } return http.StatusOK, nil }
// SetYahooUser set yahoo user. func SetYahooUser(response *http.Response) (*YahooUser, error) { yahooUser := &YahooUser{} defer response.Body.Close() body, err := ioutil.ReadAll(response.Body) if err != nil { return yahooUser, err } json.Unmarshal(body, &yahooUser) log.Debugf("\nyahooUser: %v\n", yahooUser) return yahooUser, err }