It is well known that the framework’s built-in development tools can generate do object code, primarily used for operations such as query, modification, and writing that automatically filter nil operation fields.

Today, I will teach you a new way to quickly implement flexible and convenient modification operations API implementation using pointers in combination with do objects.

Data Structure

Here is the data structure of the user table we are using:

  1. CREATE TABLE `user` (
  2.     `id`        int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'User ID',
  3.     `passport`  varchar(32) NOT NULL COMMENT 'Account',
  4.     `password`  varchar(32) NOT NULL COMMENT 'Password',
  5.     `nickname`  varchar(32) NOT NULL COMMENT 'Nickname',
  6.     `status`    varchar(32) NOT NULL COMMENT 'Status',
  7.     `brief`     varchar(512) NOT NULL COMMENT 'Remarks',
  8.     `create_at` datetime DEFAULT NULL COMMENT 'Creation Time',
  9.     `update_at` datetime DEFAULT NULL COMMENT 'Modification Time',
  10.     PRIMARY KEY (`id`),
  11.     UNIQUE KEY `uniq_passport` (`passport`)
  12. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

For the user status, we use a separate type definition to implement enumeration values:

  1. type Status string
  3. const (
  4.     StatusEnabled  = "enabled"
  5.     StatusDisabled = "disabled"
  6. )

Using the gf gen dao command, the automatically generated do objects are as follows:

  1. type User struct {
  2.     g.Meta    `table:"user" orm:"do:true"`
  3.     Id        interface{}
  4.     Passport  interface{}
  5.     Password  interface{}
  6.     Nickname  interface{}
  7.     Status    interface{}
  8.     Brief     interface{}
  9.     CreatedAt interface{}
  10.     UpdatedAt interface{}
  11. }

Request API Definition

Let’s implement an API interface for modifying user information, which is a maintenance management interface that can modify user information through the user account name. The definition of this API is as follows:

  1. type UpdateReq struct {
  2.     g.Meta   `path:"/user/{Id}" method:"post" summary:"Modify user information"`
  3.     Passport string  `v:"required" dc:"User account"`
  4.     Password *string `dc:"Modify user password"`
  5.     Nickname *string `dc:"Modify user nickname"`
  6.     Status   *Status `dc:"Modify user status"`
  7.     Brief    *string `dc:"Modify user description"`
  8. }

Here, the user’s modifiable information includes password, nickname, status, and description, which may be modified individually or in combination. Pointer-type attribute parameters are used here to implement: execute modification when the parameter is passed, do not modify when it is not passed.

Business Logic Implementation

For simplicity, we directly pass pointer parameters to the do object within the controller. We know that when the parameter is not passed by the caller, the parameter is nil. Therefore, when the field is passed to the do object, it is still nil, and during the database update operation, the nil field in the do object will be automatically filtered out.

  1. func (c *Controller) Update(ctx context.Context, req *v1.UpdateReq) (res *v1.UpdateRes, err error) {
  2.     _, err = dao.User.Ctx(ctx).Data(do.User{
  3.         Password: req.Password,
  4.         Nickname: req.Nickname,
  5.         Status:   req.Status,
  6.         Brief:    req.Brief,
  7.     }).Where(do.User{
  8.         Passport: req.Passport,
  9.     }).Update()
  10.     return
  11. }