格式怎么获取？

package handler

import (
    "context"
    "crypto/md5"
    "fmt"
    "github.com/anaskhan96/go-password-encoder"
    "github.com/golang/protobuf/ptypes/empty"
    "godemo/3/user_srv/global"
    "godemo/3/user_srv/model"
    "godemo/3/user_srv/proto"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/status"
    "gorm.io/gorm"
    "strings"
    "time"
)

type UserServer struct {
}

func ModelToResponse(user model.User) *proto.UserInfoResponse {
    // 在grpc的messages中字段有默认值，不能随便赋值nil进去
    UserInfoRsp := &proto.UserInfoResponse{
       Id:       user.ID,
       Mobile:   user.Mobile,
       Password: user.Password,
       NickName: user.NickName,
       Gender:   user.Gender,
       Role:     int32(user.Role),
    }
    if user.Birthday != nil {
       UserInfoRsp.Birthday = uint64(user.Birthday.Unix())
    }
    return UserInfoRsp
}

func Paginate(page, pageSize int) func(db *gorm.DB) *gorm.DB {
    return func(db *gorm.DB) *gorm.DB {
       if page <= 0 {
          page = 1
       }

       switch {
       case pageSize > 100:
          pageSize = 100
       case pageSize <= 0:
          pageSize = 10
       }

       offset := (page - 1) * pageSize
       return db.Offset(offset).Limit(pageSize)
    }
}

func (s *UserServer) GetUserList(ctx context.Context, req *proto.PageInfo) (*proto.UserListResponse, error) {
    // 获取用户列表
    var users []model.User
    result := global.DB.Find(&users)
    if result.Error != nil {
       return nil, result.Error
    }
    rsp := &proto.UserListResponse{}
    rsp.Total = int32(result.RowsAffected)

    global.DB.Scopes(Paginate(int(req.Page), int(req.PageSize))).Find(&users)

    for _, user := range users {
       userInfoRsp := ModelToResponse(user)
       rsp.Data = append(rsp.Data, userInfoRsp)
    }
    return rsp, nil
}

func (s *UserServer) GetUserByMobile(ctx context.Context, req *proto.MobileRequest) (*proto.UserInfoResponse, error) {
    // 根据手机号获取用户信息
    var user model.User
    result := global.DB.Where(&model.User{Mobile: req.Mobile}).First(&user)
    if result.RowsAffected == 0 {
       return nil, status.Errorf(codes.NotFound, "用户不存在")
    }
    if result.Error != nil {
       return nil, result.Error
    }
    userInfoRsp := ModelToResponse(user)
    return userInfoRsp, nil
}

func (s *UserServer) GetUserById(ctx context.Context, req *proto.IdRequest) (*proto.UserInfoResponse, error) {
    // 根据用户ID获取用户信息
    var user model.User
    result := global.DB.First(&user, req.Id)
    if result.RowsAffected == 0 {
       return nil, status.Errorf(codes.NotFound, "用户不存在")
    }
    if result.Error != nil {
       return nil, result.Error
    }

    userInfoRsp := ModelToResponse(user)
    return userInfoRsp, nil
}

func (s *UserServer) CreateUser(ctx context.Context, req *proto.CreateUserInfo) (*proto.UserInfoResponse, error) {
    // 创建用户
    var user model.User
    result := global.DB.Where(&model.User{Mobile: req.Mobile}).First(&user)
    if result.RowsAffected == 1 {
       return nil, status.Errorf(codes.AlreadyExists, "用户已存在")
    }
    user.Mobile = req.Mobile
    user.NickName = req.NickName

    options := &password.Options{SaltLen: 16, Iterations: 100, KeyLen: 32, HashFunction: md5.New}
    salt, encodedPwd := password.Encode("generic password", options)
    user.Password = fmt.Sprintf("$pbkdf2-sha512$%s$%s", salt, encodedPwd)
    result = global.DB.Create(&user)
    if result.Error != nil {
       return nil, status.Errorf(codes.Internal, result.Error.Error())
    }
    return ModelToResponse(user), nil
}

func (s *UserServer) UpdateUser(ctx context.Context, req *proto.UpdateUserInfo) (*empty.Empty, error) {
    // 更新用户
    var user model.User
    result := global.DB.First(&user, req.Id)
    if result.RowsAffected == 0 {
       return nil, status.Errorf(codes.NotFound, "用户不存在")
    }

    birthday := time.Unix(int64(req.Birthday), 0)

    user.NickName = req.NickName
    user.Gender = req.Gender
    user.Birthday = &birthday

    result = global.DB.Save(&user)
    if result.Error != nil {
       return nil, status.Errorf(codes.Internal, result.Error.Error())
    }

    return &empty.Empty{}, nil
}

func (s *UserServer) CheckPassWord(ctx context.Context, req *proto.PassWordCheckInfo) (*proto.CheckResponse, error) {
    // 校验密码
    options := &password.Options{SaltLen: 16, Iterations: 100, KeyLen: 32, HashFunction: md5.New}
    passwordInfo := strings.Split(req.EncryptedPassword, "$")
    check := password.Verify(req.Password, passwordInfo[2], passwordInfo[3], options)
    return &proto.CheckResponse{Success: check}, nil
}

(
    )

(err , c *.) {
    err != {
       e, ok := .(err); ok {
          e.() {
          .:
             c.(., .{
                : e.(),
             })
          .:
             c.(., .{
                : ,
             })
          .:
             c.(., .{
                : ,
             })
          .:
             c.(., .{
                : ,
             })
          :
             c.(., .{
                : ,
             })
          }
          }
    }
}

(ctx *., err ) {
    errs, ok := err.(.)
    !ok {
       ctx.(., .{
          : err.(),
       })
    }
    ctx.(., .{
       : .(errs.(.Trans)),
    })
    }

(ctx *.) {
    opts [].opts = (opts, .(.()))
    userConn, err := .(.(,
       .ServerConfig.UserServerConfig.Host, .ServerConfig.UserServerConfig.Port), opts...)
    err != {
       .().(
          ,
          , err.(),
       )
    }
    userSrvClient := .(userConn)

    page := ctx.(, )
    pageInt, _ := .(page)
    pageSize := ctx.(, )
    pageSizeInt, _ := .(pageSize)
    rsp, err := userSrvClient.(.(), &.{
       Page:     (pageInt),
       PageSize: (pageSizeInt),
    })
    err != {
       .().(
          ,
       )
       (err, ctx)
       }
    .().(
       ,
       , rsp,
    )
    result := ([]{}, )
    _, value := rsp.Data {
       user := .{
          Id:       value.Id,
          Mobile:   value.Mobile,
          Nickname: value.NickName,
          Gender:   value.Gender,
          Birthday: .(.((value.Birthday), )),
       }
       result = (result, user)
    }
    ctx.(., result)
}

(ctx *.) {
    passwordLogin := .{}
    err := ctx.(&passwordLogin); err != {
       (ctx, err)
       }

    opts [].opts = (opts, .(.()))
    userConn, err := .(.(,
       .ServerConfig.UserServerConfig.Host, .ServerConfig.UserServerConfig.Port), opts...)
    err != {
       .().(
          ,
          , err.(),
       )
    }
    userSrvClient := .(userConn)

    userRsp, err := userSrvClient.(.(), &.{
       Mobile: passwordLogin.Mobile,
    })
    err != {
       .().(
          ,
       )
       e, ok := .(err); ok {
          e.() {
          .:
             ctx.(., .{
                : ,
             })
          :
             ctx.(., .{
                : ,
             })
          }
       }
    }
    passwordRsp, err := userSrvClient.(.(), &.{
       Password:          passwordLogin.Password,
       EncryptedPassword: userRsp.Password,
    })
    passwordRsp.Success != {
       .().(
          ,
       )
       ctx.(., .{
          : ,
       })
       }
    ctx.(., .{
       :     ,
       : passwordRsp.Success,
    })
}

测试