// 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 }
// 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 }
// CreateLocation creates a location. func CreateLocation(c *gin.Context) (model.Location, int, error) { var form LocationForm c.BindWith(&form, binding.Form) log.Debugf("struct map : %s\n", form) user, _ := userService.CurrentUser(c) form.UserId = user.Id location := model.Location{} modelHelper.AssignValue(&location, &form) if db.ORM.Create(&location).Error != nil { return location, http.StatusInternalServerError, errors.New("User is not created.") } return location, http.StatusCreated, nil }
// CreateArticle creates an article. func CreateArticle(c *gin.Context) (model.Article, int, error) { var form ArticleForm c.BindWith(&form, binding.Form) log.Debugf("struct map : %s\n", form) user, _ := userService.CurrentUser(c) form.UserId = user.Id article := model.Article{} modelHelper.AssignValue(&article, &form) if db.ORM.Create(&article).Error != nil { return article, http.StatusInternalServerError, errors.New("User is not created.") } return article, http.StatusCreated, nil }
// UpdateUser updates a user. func UpdateUser(c *gin.Context) (*model.User, int, error) { id := c.Params.ByName("id") var user model.User if db.ORM.First(&user, id).RecordNotFound() { return &user, http.StatusNotFound, errors.New("User is not found.") } switch c.Request.FormValue("type") { case "password": var passwordForm PasswordForm c.BindWith(&passwordForm, binding.Form) log.Debugf("form %+v\n", passwordForm) err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(passwordForm.CurrentPassword)) if err != nil { log.Error("Password Incorrect.") return &user, http.StatusInternalServerError, errors.New("User is not updated. Password Incorrect.") } else { newPassword, err := bcrypt.GenerateFromPassword([]byte(passwordForm.Password), 10) if err != nil { return &user, http.StatusInternalServerError, errors.New("User is not updated. Password not Generated.") } else { passwordForm.Password = string(newPassword) modelHelper.AssignValue(&user, &passwordForm) } } default: var form UserForm c.BindWith(&form, binding.Form) log.Debugf("form %+v\n", form) modelHelper.AssignValue(&user, &form) } log.Debugf("params %+v\n", c.Params) status, err := UpdateUserCore(&user) if err != nil { return &user, status, err } status, err = SetCookie(c, user.Token) return &user, status, err }
// CreateFile creates a file. func CreateFile(c *gin.Context) (int, error) { var form FileForm c.BindWith(&form, binding.Form) log.Debugf("CreateFile form : %v", form) // err = json.Unmarshal(formDataBuffer[:n], &articles) // file := model.File{Name: form.Name, Size: form.Size} user, _ := userService.CurrentUser(c) form.UserId = user.Id file := model.File{} modelHelper.AssignValue(&file, &form) if db.ORM.Create(&file).Error != nil { return http.StatusInternalServerError, errors.New("File is not created.") } return http.StatusCreated, nil }
// CreateComment creates a comment. func CreateComment(c *gin.Context, item interface{}) (int, error) { var form CreateCommentForm var comment model.Comment c.BindWith(&form, binding.Form) log.Debugf("comment_form : %v", form) status, err := userPermission.CurrentUserIdentical(c, form.UserId) if err != nil { return status, err } if db.ORM.First(item, form.ParentId).RecordNotFound() { return http.StatusNotFound, errors.New("Item is not found.") } modelHelper.AssignValue(&comment, &form) db.ORM.Model(item).Association("Comments").Append(comment) return http.StatusOK, nil }
// 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 }
// OauthFacebook link connection and user. func OauthFacebook(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(facebook.RequestURL, facebook.Config, authResponse) if err != nil { return http.StatusInternalServerError, err } facebookUser, err := SetFacebookUser(response) modelHelper.AssignValue(&oauthUser, facebookUser) log.Debugf("\noauthUser item : %v", oauthUser) if err != nil { return http.StatusInternalServerError, err } status, err := LoginOrCreateOauthUser(c, &oauthUser, facebook.ProviderId, token) if err != nil { return status, err } return http.StatusSeeOther, nil }
// OauthGoogle link connection and user. func OauthGoogle(c *gin.Context) (int, error) { log.Debugf("c.Request.URL : %s", c.Request.URL) var authResponse oauth2.AuthResponse var oauthUser OauthUser c.BindWith(&authResponse, binding.Form) log.Debugf("oauthRedirect form: %v", authResponse) response, token, err := oauth2.OauthRequest(google.RequestURL, google.Config, authResponse) if err != nil { return http.StatusInternalServerError, err } googleUser, err := SetGoogleUser(response) if err != nil { return http.StatusInternalServerError, err } modelHelper.AssignValue(&oauthUser, googleUser) oauthUser.Email = googleUser.Emails[0].Value oauthUser.ImageUrl = googleUser.Image.URL status, err := LoginOrCreateOauthUser(c, &oauthUser, google.ProviderId, token) if err != nil { return status, err } return http.StatusSeeOther, nil }
// CreateOauthUser creates oauth user. func CreateOauthUser(c *gin.Context, oauthUser *OauthUser, connection *model.Connection) (model.User, int, error) { var registrationForm userService.RegistrationForm var user model.User modelHelper.AssignValue(®istrationForm, oauthUser) registrationForm.Password = random.GenerateRandomString(12) if len(registrationForm.Username) == 0 { if len(registrationForm.Email) > 0 { registrationForm.Username = strings.Split(registrationForm.Email, "@")[0] } else { registrationForm.Username = "******" } } registrationForm.Username = userService.SuggestUsername(registrationForm.Username) generatedPassword, err := bcrypt.GenerateFromPassword([]byte(registrationForm.Password), 10) if err != nil { return user, http.StatusInternalServerError, errors.New("Password not generated.") } registrationForm.Password = string(generatedPassword) currentUser, err := userService.CurrentUser(c) if err != nil { log.Errorf("currentUser : %v", currentUser) user, err = userService.CreateUserFromForm(registrationForm) if err != nil { return user, http.StatusInternalServerError, errors.New("User is not created.") } } else { if db.ORM.Where("id = ?", currentUser.Id).First(&user).RecordNotFound() { return user, http.StatusInternalServerError, errors.New("User is not found.") } } db.ORM.Model(&user).Association("Connections").Append(connection) if db.ORM.Save(&user).Error != nil { return user, http.StatusInternalServerError, errors.New("Connection not appended to user.") } return user, http.StatusOK, nil }