Golang Context.BindWith方法代码示例

// 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
}

// 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
}

func (s *Server) CommentDeleteHandler(c *gin.Context) {
	var form struct {
		Entry   string `form:"entry" binding:"required"`
		Comment string `form:"comment" binding:"required"`
	}
	c.BindWith(&form, binding.Form)

	// TODO: check perm
	profile, _ := s.CurrentUser(c)
	graph, _ := s.CurrentGraph(c)
	req := &pb.CommentDeleteRequest{
		Entry:   form.Entry,
		Comment: form.Comment,
		User:    profile.Id,
	}

	ctx, cancel := DefaultTimeoutContext()
	defer cancel()

	entry, err := s.client.DeleteComment(ctx, req)
	if RequestError(c, err) {
		return
	}

	entry.FormatComments(int32(0))
	entry.RebuildCommentsCommand(profile, graph)
	c.JSON(200, entry.Comments)
}

func addUser(c *gin.Context) {
	var (
		user     User
		err      error
		passHash []byte
	)
	err = c.BindWith(&user, binding.JSON)
	if err != nil {
		c.JSON(404, "Couldn't bind!")
	} else {
		if db.NewRecord(user) {
			user.CreatedAt = time.Now().UTC()
			user.UpdatedAt = time.Now().UTC()

			// Create password hash
			originalPass := []byte(user.PasswordHash)
			if passHash, err = bcrypt.GenerateFromPassword(originalPass, bcrypt.DefaultCost); err != nil {
				fmt.Printf("%v", err)
			}
			user.PasswordHash = string(passHash)

			db.Create(&user)
			c.JSON(201, user)
		} else {
			c.JSON(400, "This user already exist")
		}
	}
}

func (ac *AdminController) SaveBlogEditCtr(c *gin.Context) {
	session := sessions.Default(c)
	username := session.Get("username")
	if username == nil {
		(&umsg{"You have no permission", "/"}).ShowMessage(c)
		return
	}
	var BI EditBlogItem
	c.BindWith(&BI, binding.Form)
	if BI.Aid == "" {
		(&umsg{"Can not find the blog been edit", "/"}).ShowMessage(c)
		return
	}
	if BI.Title == "" {
		(&umsg{"Title can not empty", "/"}).ShowMessage(c)
		return
	}
	if BI.Content == "" {
		(&umsg{"Content can not empty", "/"}).ShowMessage(c)
		return
	}
	_, err := DB.Exec("update top_article set title=?, content=? where aid = ?", BI.Title, BI.Content, BI.Aid)
	if err == nil {
		Cache = lru.New(8192)
		(&umsg{"Success", "/"}).ShowMessage(c)
	} else {
		(&umsg{"Failed to save blog", "/"}).ShowMessage(c)
	}

}

func commonDeploy(ginCtx *gin.Context) (DeployRequest, error) {
	ginCtx.Request.ParseForm()
	var givenDeploy DeployRequest
	ginCtx.BindWith(&givenDeploy, binding.JSON)
	glog.Infof("given %+v", givenDeploy)
	return givenDeploy, 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
}

// 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
}

func (ac *AdminController) SaveBlogAddCtr(c *gin.Context) {
	session := sessions.Default(c)
	username := session.Get("username")
	if username == nil {
		(&umsg{"You have no permission", "/"}).ShowMessage(c)
		return
	}
	var BI BlogItem
	c.BindWith(&BI, binding.Form)
	if BI.Title == "" {
		(&umsg{"Title can not empty", "/"}).ShowMessage(c)
		return
	}
	if BI.Content == "" {
		(&umsg{"Content can not empty", "/"}).ShowMessage(c)
		return
	}
	_, err := DB.Exec(
		"insert into top_article (title, content, publish_time, publish_status) values (?, ?, ?, 1)",
		BI.Title, BI.Content, time.Now().Format("2006-01-02 15:04:05"))
	if err == nil {
		Cache = lru.New(8192)
		(&umsg{"Success", "/"}).ShowMessage(c)
	} else {
		(&umsg{"Failed to save blog", "/"}).ShowMessage(c)
	}

}

func (fc *AdminController) SaveBlogEditCtr(c *gin.Context) {
	var BI EditBlogItem
	config := GetConfig()
	c.BindWith(&BI, binding.Form)
	if BI.Aid == "" {
		(&msg{"Can not find the blog been edit"}).ShowMessage(c)
		return
	}
	if BI.Title == "" {
		(&msg{"Title can not empty"}).ShowMessage(c)
		return
	}
	if BI.Content == "" {
		(&msg{"Content can not empty"}).ShowMessage(c)
		return
	}
	db := GetDB(config)
	_, err := db.Exec("update top_article set title=?, content=? where aid = ?", BI.Title, BI.Content, BI.Aid)
	if err == nil {
		(&msg{"Success"}).ShowMessage(c)
	} else {
		(&msg{"Failed to save blog"}).ShowMessage(c)
	}

}

func updateUser(c *gin.Context) {
	var (
		user      User
		changeset User
		err       error
		passHash  []byte
	)
	id := c.Params.ByName("id")
	db.First(&user, id)
	err = c.BindWith(&changeset, binding.JSON)
	if err != nil {
		c.JSON(404, "Couldn't bind!")
	} else {
		user.UpdatedAt = time.Now().UTC()
		user.Username = changeset.Username
		user.Email = changeset.Email
		if changeset.PasswordHash != "" && changeset.PasswordHash != user.PasswordHash {
			err = bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(changeset.PasswordHash))
			if err != nil {
				if passHash, err = bcrypt.GenerateFromPassword([]byte(changeset.PasswordHash), bcrypt.DefaultCost); err != nil {
					fmt.Printf("%v", err)
				}
				user.PasswordHash = string(passHash)
			}
		}
		db.Save(&user)
		c.JSON(201, user)
	}
}

// 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
}

func addPointToListHandler(c *gin.Context) {
	request := addPointToListRequest{}

	if err := c.Bind(&request.addPointToListRequestParams); err != nil {
		outputJSONErrorCheckType(c.Writer, err, http.StatusInternalServerError)
		return
	}

	if err := c.BindWith(&request.addPointToListRequestParams, binding.Form); err != nil {
		outputJSONErrorCheckType(c.Writer, err, http.StatusInternalServerError)
		return
	}

	request.list = c.Params.ByName("list")
	request.point = c.Params.ByName("point")

	if err := addPointToList(&request); err != nil {
		outputJSONErrorCheckType(c.Writer, err, http.StatusInternalServerError)
		return
	}
	if request.ReturnZone == false {
		c.Writer.Header().Set("Content-Type", "application/json")
		c.Writer.WriteHeader(http.StatusCreated)
	} else {
		listZoneModel := listZoneModel{}
		if err := db.Get(&listZoneModel, "select * from get_list_geohash_zones_for_point($1, $2, $3)", request.list, request.point, maxListZoneNPoints); err != nil {
			outputJSONErrorCheckType(c.Writer, err, http.StatusInternalServerError)
			return
		}

		c.JSON(http.StatusCreated, &listZoneModel)
	}

}

// CreateUserAuthentication creates user authentication.
func CreateUserAuthentication(c *gin.Context) (int, error) {
	var form LoginForm
	c.BindWith(&form, binding.Form)
	email := form.Email
	pass := form.Password
	status, err := SetCookieHandler(c, email, pass)
	return status, err
}

// CreateRole creates a role.
func CreateRole(c *gin.Context) (model.Role, int, error) {
	var form RoleForm
	c.BindWith(&form, binding.Form)
	name := form.Name
	description := form.Description
	role := model.Role{Name: name, Description: description}
	if db.ORM.Create(&role).Error != nil {
		return role, http.StatusInternalServerError, errors.New("Role is not created.")
	}
	return role, http.StatusCreated, nil
}