practiceGit/周新忠学习笔记/4.1/gf_demo_02/internal/logic/user/user.go

package user

import (
	"context"
	"gf_demo_02/api/user/v1"
	"gf_demo_02/internal/model/entity"
	"gf_demo_02/internal/service"
	"github.com/gogf/gf/v2/database/gdb"
	"github.com/gogf/gf/v2/errors/gcode"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"golang.org/x/crypto/bcrypt"
	"strings"
)

type sUser struct {
}

func init() {
	service.RegisterUser(&sUser{})
}

func (u *sUser) GetUser(cond g.Map) (user *entity.User, err error) {
	model := g.Model("user")
	if cond["id"] != nil && gconv.Uint(cond["id"]) != 0 {
		model = model.Where("id", cond["id"])
	} else if cond["name"] != nil && gconv.String(cond["name"]) != "" {
		model = model.Where("name", cond["name"])
	} else {
		return nil, gerror.NewCode(gcode.New(88, "缺少查询条件", nil))
	}
	err = model.Scan(&user)
	if err != nil {
		return nil, err
	}
	if user == nil {
		return nil, gerror.NewCode(gcode.New(483, "用户不存在！", nil))
	}
	return user, nil
}

func (*sUser) GetUserList(ctx context.Context) (users []entity.User, err error) {
	all, err := g.DB().Model("user").All()
	if err != nil {
		return nil, gerror.NewCode(gcode.New(599, "数据库error", nil))
	}
	err = all.Structs(&users)
	if err != nil {
		return nil, err
	}
	return users, nil
}

func (*sUser) AddUser(ctx context.Context, req *user.EditUserReq) error {
	u := entity.User{
		Id:       req.Id,
		Name:     req.Name,
		Pass:     req.Pass,
		Property: req.Property,
	}
	one, _ := g.Model("user").Where("name", req.Name).One()
	if one != nil {
		return gerror.NewCode(gcode.New(480, "用户名重复", nil))
	}
	if len(req.Pass) < 6 {
		return gerror.NewCode(gcode.New(481, "密码过短，至少6位", nil))
	}
	password, err := bcrypt.GenerateFromPassword([]byte(u.Pass), 10)
	if err != nil {
		return err
	}
	u.Pass = string(password)
	return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		_, err = tx.Model("user").Insert(u)
		return err
	})
}

func (*sUser) UpdateUser(ctx context.Context, req *user.EditUserReq) error {
	u := entity.User{
		Id:       req.Id,
		Name:     req.Name,
		Pass:     req.Pass,
		Property: req.Property,
	}
	one, _ := g.Model("user").Where("id", req.Id).One()
	if one == nil {
		return gerror.NewCode(gcode.New(483, "用户不存在！", nil))
	}
	one, _ = g.Model("user").Where("name", req.Name).WhereNot("id", u.Id).One()
	if one != nil {
		return gerror.NewCode(gcode.New(480, "用户名重复", nil))
	}
	if len(req.Pass) < 6 && req.Pass != "" {
		return gerror.NewCode(gcode.New(481, "密码过短，至少6位", nil))
	}
	if req.Pass != "" {
		password, err := bcrypt.GenerateFromPassword([]byte(u.Pass), 10)
		if err != nil {
			return err
		}
		u.Pass = string(password)
	}
	return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		model := tx.Model("user").OmitEmptyData()
		result, err := model.Where("id", u.Id).Update(u)
		if err != nil {
			return err
		}
		if affected, err := result.RowsAffected(); affected < 1 || err != nil {
			return gerror.NewCode(gcode.New(500, "服务器错误", nil))
		}
		return nil
	})
}

func (*sUser) DeleteUser(ctx context.Context, req *user.DeleteUserReq) error {
	one, _ := g.DB().Model("user").Where("id", req.Id).One()
	if one == nil {
		return gerror.NewCode(gcode.New(483, "用户不存在！", nil))
	}
	tokenStr := g.RequestFromCtx(ctx).GetCtxVar("Authorization").String()
	tokenStr = strings.TrimSpace(tokenStr)
	tokenStr = strings.TrimPrefix(tokenStr, "Bearer ")
	return g.DB().Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
		_, err := tx.Model("user").Where("id", req.Id).Delete()
		return err
	})
}

func (*sUser) SearchUser(ctx context.Context, keyword string) ([]entity.User, error) {
	all, err := g.Model("user").WhereLike("name", "%"+keyword+"%").All()
	if err != nil {
		return nil, err
	}
	users := make([]entity.User, 0)
	err = all.Structs(&users)
	if err != nil {
		return nil, err
	}
	return users, nil
}