// internal/model/user.go
package model

import (
    "myapp/internal/model/entity"
)

type UserModel struct {
    entity.User
}

type UserAddReq struct {
}

type UserDeleteReq struct {
    UserId uint64 `json:"user_id"`
}

type UserUpdateReq struct {
    UserId uint64 `json:"user_id"`
}

type UserListReq struct {
    PageNum  int `json:"page_num"`
    PageSize int `json:"page_size"`
}

type UserGetReq struct {
    UserId uint64 `json:"user_id"`
}

type UserItem struct {
}

func (m *UserModel) ToItem() *UserItem {

    return &UserItem{}
}

// internal/dao/user.go

func (d *userDao) GetByUserId(ctx context.Context, req *model.UserGetReq) (*model.UserModel, error) {
    var item *model.UserModel
    if err := d.Ctx(ctx).
        Where(d.Columns().UserId, req.UserId).
        Scan(&item); err != nil {
        return nil, err
    }
    return item, nil
}

// UpdateByUserId
func (d *userDao) UpdateByUserId(ctx context.Context, req *model.UserUpdateReq) error {
    updater := g.Map{
        // TODO
    }
    if _, err := d.Ctx(ctx).
        Where(d.Columns().UserId, req.UserId).
        UpdateAndGetAffected(updater); err != nil {
        return err
    }
    return nil
}

// DeleteByUserId
func (d *userDao) DeleteByUser(ctx context.Context, req *model.UserDeleteReq) error {
    updater := g.Map{
        d.Columns().DeletedAt: gtime.Now().Unix(),
    }
    if _, err := d.Ctx(ctx).
        Where(d.Columns().UserId, req.UserId).
        UpdateAndGetAffected(updater); err != nil {
        return err
    }
    return nil
}

// UserList
func (d *userDao) UserList(ctx context.Context, req *model.UserListReq) ([]*model.UserModel, int, error) {
    db := d.Ctx(ctx)
    count, err := db.Count()
    if err != nil {
        return nil, 0, err
    }
    if count == 0 {
        return nil, 0, nil
    }
    var items []*model.UserModel
    // TODO order
    if err = db.Page(req.PageNum, req.PageSize).
        Scan(&items); err != nil {
        return nil, 0, err
    }

    return items, count, nil
}

// api/user/v1/user.go
package v1

import (
    "github.com/gogf/gf/v2/frame/g"

    "myapp/internal/model"
)

type UserAddReq struct {
    g.Meta `path:"/user" tags:"User" method:"post" sm:"新增"`
    *model.UserAddReq
}
type UserAddRes struct {
}

type UserGetReq struct {
    g.Meta `path:"/user" tags:"User" method:"get" sm:"单条"`
    *model.UserGetReq
}
type UserGetRes struct {
    *model.UserItem
}

type UserListReq struct {
    g.Meta `path:"/users" tags:"User" method:"get" sm:"列表"`
    *model.UserListReq
}
type UserListRes struct {
    Items []*model.UserItem `json:"items"`
    Total int               `json:"total"`
}

type UserUpdateReq struct {
    g.Meta `path:"/user" tags:"User" method:"put" sm:"更新"`
    *model.UserUpdateReq
}
type UserUpdateRes struct {
}

type UserDeleteReq struct {
    g.Meta `path:"/user" tags:"User" method:"delete" sm:"删除"`
    *model.UserDeleteReq
}
type UserDeleteRes struct {
}

// internal/controller/user/user_v1_user_get.go
func (c *ControllerV1) UserGet(ctx context.Context, req *v1.UserGetReq) (res *v1.UserGetRes, err error) {
    // 这里可能要处理 req 中的 userId 的来源问题. 比如登录时注入到 ctx 中
    // req.UserId = 1
    item, err := service.User().UserGet(ctx, req.UserGetReq)
    if err != nil {
        return nil, err
    }

    return &v1.UserGetRes{UserItem: item}, nil
}

// internal/cmd/cmd.go

import (

    // ...
    // 引入 mysql 驱动包. 或者在外层的 main.go 中引入
    _ "github.com/gogf/gf/contrib/drivers/mysql/v2"
    // _ "github.com/gogf/gf/contrib/nosql/redis/v2"

    "myapp/internal/controller/user" // 智能补全别补错, 需要是 controller 包下的
    // ...
)

// ...
s := g.Server()
// xxx 用于区分业务
// v1Group := s.Group("/api/xxx/v1")
v1Group := s.Group("/api/v1")
v1Group.Middleware(
    // ...
)
v1Group.Bind(
    user.NewV1(), // 批量注册路由
    
)

s.Run()
// ...