【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（四）用户管理、部门管理模块

雨点打透心脏的1/2处 2024-02-05 14:25 73阅读 0赞

第一篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（一）搭建项目

第二篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（二）日志输出中间件、校验token中间件、配置路由、基础工具函数。

第三篇：【Go】基于GoFiber从零开始搭建一个GoWeb后台管理系统（三）日志管理（登录日志、操作日志）、用户登录模块

碎碎念：最近脖子一直好痛啊，已经持续有一段时间了，从早痛到晚，早上起床就痛，到晚上睡觉都还在痛，导致我经常睡不着觉。之前也会脖子痛，但都是痛一两天就好了。真的坐着痛、躺着痛，普通枕头痛、U型枕痛、不枕枕头也痛。。。大家有什么办法可以缓解一下吗？是要去按摩？

接收参数

gofiber中，接收前端传过来的参数，有以下几种传参方式及接收方式：

  • 用问号拼接在地址后面的参数，我们一般用 c.Query("参数名") 获取；
  • 路径参数（直接拼接在地址后面，比如：/sys/user/getById/1，这里的 1 就是路径参数），用 c.Params("参数名")；
  • FormData参数，用 c.FormValue("参数名") 接收；
  • FormData传的文件参数，用 c.MultipartForm() 获取；
  • JSON参数，用 c.BodyParser(结构体指针) 接收，就是将json转为具体的某个结构体。

数据库操作

  • 新增：用 Create() ，新增单条数据和批量新增都是用这个方法：db.Create(&user)、db.Create(&list) 。
  • 修改：
    • Update() 、UpdateColumn() ：更新指定的列，每次只更新一个字段。
    • Updates() 、UpdateColumns()：更新整个结构体或map，但是注意这两个方法不会更新零值。
    • Save() ：插入或更新，传结构体或map，可以插入、更新零值。根据主键进行更新，如果主键不存在则插入。
  • 删除：Delete() 默认根据主键删除或批量删除，也可以在 Delete() 前面使用 Where() ，指定条件删除。
  • 查询：可以使用 Find() 查询单条数据或多条数据。

Update() 、UpdateColumn() 和 Updates() 、UpdateColumns() 其实是有一点区别的，具体我们可以看看源码：

在这里插入图片描述

tx.Statement.SkipHooks = true 这句代码是关于事务（transaction）的设置。当这个设置被设置为 true 时，GORM 将跳过与该事务相关的所有钩子。

然后更新时，可以使用 Select() 指定要更新的字段，更新或新增时，可以使用 Omit() 忽略指定字段。

具体怎么操作数据库，我们直接看下面的代码。

用户管理

首先是用户管理模块，有这几个接口：

在这里插入图片描述

废话不多说，我们直接上代码

controller层：sys_user.go

  1. package sys
  3. import (
  4.     "fmt"
  5.     "github.com/gofiber/fiber/v2"
  6.     "go-web2/app/common/config"
  7.     "go-web2/app/common/util"
  8.     "go-web2/app/model/sys"
  9.     "path/filepath"
  10.     "strings"
  11.     "time"
  12. )
  14. type UserController struct{
  15.     }
  17. // 获取当前登录的用户
  18. func (UserController) GetLoginUser(c *fiber.Ctx) error {
  20.     // 获取请求中的 Token
  21.     token := c.Get(config.TokenHeader)
  22.     user := sys.GetLoginUser(token)
  23.     result := map[string]any{
  24.     }
  25.     result["user"] = user
  26.     result["roles"] = user.RoleId
  27.     result["permissions"] = sys.GetPermsMenuByRoleId(user.RoleId)
  28.     return c.Status(200).JSON(config.Success(result))
  29. }
  31. // 用户列表
  32. func (UserController) GetPage(c *fiber.Ctx) error {
  34.     user := sys.SysUserView{
  35.     }
  36.     user.UserName = c.Query("code")
  37.     user.RealName = c.Query("name")
  38.     user.AncestorId = c.Query("parentId")
  39.     user.Token = c.Get(config.TokenHeader)
  40.     pageSize := c.QueryInt("pageSize", 10)
  41.     pageNum := c.QueryInt("pageNum", 1)
  42.     return c.Status(200).JSON(config.Success(user.GetPage(pageSize, pageNum)))
  43. }
  45. // 根据id获取用户
  46. func (UserController) GetById(c *fiber.Ctx) error {
  48.     user := sys.SysUser{
  49.     }
  50.     user.Id = c.Params("id")
  51.     user.Token = c.Get(config.TokenHeader)
  52.     err := user.GetUser()
  53.     if err != nil {
  55.         return c.Status(200).JSON(config.Error("获取用户失败，或没有查看权限"))
  56.     }
  57.     return c.Status(200).JSON(config.Success(user))
  58. }
  60. // 新增用户
  61. func (UserController) Insert(c *fiber.Ctx) error {
  63.     var user sys.SysUser
  64.     if err := c.BodyParser(&user); err != nil {
  66.         return c.Status(200).JSON(config.Error(err.Error()))
  67.     }
  68.     pwd, err := util.GetEncryptedPassword(user.Password)
  69.     if err != nil {
  71.         return c.Status(200).JSON(config.Error("密码加密失败"))
  72.     }
  73.     user.Password = pwd
  74.     user.Token = c.Get(config.TokenHeader)
  75.     err = user.Insert()
  76.     if err != nil {
  78.         return c.Status(200).JSON(config.Error(err.Error()))
  79.     }
  80.     return c.Status(200).JSON(config.Success(nil))
  81. }
  83. // 修改用户
  84. func (UserController) Update(c *fiber.Ctx) error {
  86.     var user sys.SysUser
  87.     if err := c.BodyParser(&user); err != nil {
  89.         return c.Status(200).JSON(config.Error(err.Error()))
  90.     }
  91.     user.Token = c.Get(config.TokenHeader)
  92.     err := user.Update()
  93.     if err != nil {
  95.         return c.Status(200).JSON(config.Error(err.Error()))
  96.     }
  97.     return c.Status(200).JSON(config.Success(nil))
  98. }
  100. // 删除用户
  101. func (UserController) Delete(c *fiber.Ctx) error {
  103.     var user sys.SysUser
  104.     if err := c.BodyParser(&user); err != nil {
  106.         return c.Status(200).JSON(config.Error(err.Error()))
  107.     }
  108.     user.Token = c.Get(config.TokenHeader)
  109.     ids := strings.Split(user.Id, ",")
  110.     if err := user.Delete(ids); err != nil {
  112.         return c.Status(200).JSON(config.Error("删除用户失败"))
  113.     }
  114.     return c.Status(200).JSON(config.Success(nil))
  115. }
  117. // 修改密码
  118. func (UserController) UpdatePassword(c *fiber.Ctx) error {
  120.     // 正常是需要加解密的（没有前端就暂时不先加密解密）
  121.     //newPassword := util.RSADecrypt(c.FormValue("newPassword"))
  122.     //oldPassword := util.RSADecrypt(c.FormValue("oldPassword"))
  123.     //id := util.RSADecrypt(c.FormValue("id"))
  124.     newPassword := c.FormValue("newPassword")
  125.     oldPassword := c.FormValue("oldPassword")
  126.     id := c.FormValue("id")
  127.     var password sys.Password
  128.     password.Id = id
  129.     password.OldPassword = oldPassword
  130.     password.NewPassword = newPassword
  131.     password.Token = c.Get(config.TokenHeader)
  132.     err := password.UpdatePassword()
  133.     if err != nil {
  135.         return c.Status(200).JSON(config.Error(err.Error()))
  136.     }
  137.     return c.Status(200).JSON(config.Success(nil))
  138. }
  140. // 重置密码
  141. func (UserController) ResetPassword(c *fiber.Ctx) error {
  143.     var user sys.SysUser
  144.     user.Id = c.FormValue("id")
  145.     if user.Id == "" {
  147.         return c.Status(200).JSON(config.Error("用户id不可为空"))
  148.     }
  149.     user.Token = c.Get(config.TokenHeader)
  150.     err := user.ResetPassword()
  151.     if err != nil {
  153.         return c.Status(200).JSON(config.Error(err.Error()))
  154.     }
  155.     return c.Status(200).JSON(config.Success(nil))
  156. }
  158. // 上传头像
  159. func (UserController) Upload(c *fiber.Ctx) error {
  161.     form, err := c.MultipartForm()
  162.     if err != nil {
  164.         fmt.Println(err)
  165.         return c.Status(200).JSON(config.Error("头像上传失败"))
  166.     }
  167.     // 获取新的文件名
  168.     name := form.File["file"][0].Filename                           // 获取文件名
  169.     suffix := name[strings.LastIndex(name, "."):]                   // 文件后缀：.jpg
  170.     fileName := fmt.Sprintf("%d%s", time.Now().UnixMilli(), suffix) // 新文件名
  171.     // 相对路径：/upload/20231208
  172.     relative := filepath.Join(config.FilePath, time.Now().Format("20060102"))
  173.     // 保存文件
  174.     err = util.SaveFile(form, relative, fileName)
  175.     if err != nil {
  177.         return c.Status(200).JSON(config.Error(err.Error()))
  178.     }
  179.     var user sys.SysUser
  180.     user.Token = c.Get(config.TokenHeader)
  181.     relative = filepath.Join(relative, fileName)
  182.     user.Picture = &relative // 数据库保存相对路径
  183.     user.Upload()            // 保存头像到数据库
  184.     return c.Status(200).JSON(config.Success(relative))
  185. }

上面这几个接口，就用到了 c.Query()、c.Params()、c.FormValue()、c.MultipartForm()、 c.BodyParser() 这几种方式。

model层：sys_user.go

接口有了，那接下来就是获取数据了，数据从数据库来的，所以下面就是来操作数据库了。

  1. package sys
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "github.com/google/uuid"
  7.     "go-web2/app/common/config"
  8.     "go-web2/app/common/util"
  9.     "strings"
  10.     "time"
  11. )
  13. // 用户信息model，对应数据库的 sys_user 表
  14. type SysUser struct {
  16.     config.BaseModel // 嵌套公共的model，这样就可以使用 BaseModel 的字段了
  17.     SysUserView
  18.     Password string `gorm:"password" json:"password" form:"password"` // 加密密码
  19. }
  21. // 用户信息model，用于展示给前端
  22. type SysUserView struct {
  24.     config.BaseModel         // 嵌套公共的model，这样就可以使用 BaseModel 的字段了
  25.     UserName         string  `json:"userName" form:"userName"`         // 用户名称
  26.     RealName         string  `json:"realName" form:"realName"`         // 真实姓名
  27.     DeptId           string  `json:"deptId" form:"deptId"`             // 部门id
  28.     DeptName         string  `json:"deptName" form:"deptName"`         // 部门名称
  29.     AncestorId       string  `json:"ancestorId" form:"ancestorId"`     // 祖级id
  30.     AncestorName     string  `json:"ancestorName" form:"ancestorName"` // 祖级名称
  31.     ChildId          string  `json:"childId" form:"childId"`           // 部门id及子级id
  32.     ChildName        string  `json:"childName" form:"childName"`       // 部门名称及子级名称
  33.     RoleId           string  `json:"roleId" form:"roleId"`             // 角色id
  34.     RoleKey          string  `json:"roleKey" form:"roleKey"`           // 角色代码
  35.     RoleName         string  `json:"roleName" form:"roleName"`         // 角色名称
  36.     Phone            *string `json:"phone" form:"phone"`               // 联系电话 这里用指针，是因为可以传空（这个空不是指空字符串，而是null）
  37.     State            int     `json:"state" form:"state"`               // 状态（1 启用 2 停用）
  38.     Picture          *string `json:"picture" form:"picture"`           // 头像地址
  39. }
  41. // 密码结构体，用于修改密码
  42. type Password struct {
  44.     config.BaseModel        // 嵌套公共的model，这样就可以使用 BaseModel 的字段了
  45.     OldPassword      string `json:"oldPassword" form:"oldPassword"` // 旧密码
  46.     NewPassword      string `json:"newPassword" form:"newPassword"` // 新密码
  47. }
  49. // 新增、更新用户信息时，要忽略的字段
  50. var omit = "dept_name,ancestor_id,ancestor_name,child_id,child_name,role_key,role_name"
  52. // 获取用户管理的表名
  53. func (SysUserView) TableName() string {
  55.     return "sys_user"
  56. }
  58. // 列表
  59. func (e *SysUserView) GetPage(pageSize int, pageNum int) config.PageInfo {
  61.     var list []SysUserView // 查询结果
  62.     var total int64        // 总数
  63.     query := config.DB.Table(e.TableName())
  64.     if e.UserName != "" {
  66.         query.Where("user_name like ?", fmt.Sprintf("%%%s%%", e.UserName))
  67.     }
  68.     if e.RealName != "" {
  70.         query.Where("real_name like ?", fmt.Sprintf("%%%s%%", e.RealName))
  71.     }
  72.     if e.AncestorId != "" {
  74.         ids, _ := GetDeptChild(e.AncestorId) // 获取当前 parentId 的所有子节点包括它本身
  75.         query.Where("FIND_IN_SET(dept_id,?)", ids)
  76.     }
  77.     // 数据过滤
  78.     scope := AppendQueryDataScope(e.Token, "dept_id", "2", false, true)
  79.     if scope != "" {
  81.         query.Where(scope)
  82.     }
  83.     // 关联部门和角色表查询
  84.     offset := (pageNum - 1) * pageSize // 计算跳过的记录数
  85.     query.Debug().Order("sys_user.create_time desc").
  86.         Select("sys_user.*, b.name as dept_name,role_key,role_name").
  87.         Joins("left join sys_dept b on b.id = sys_user.dept_id").
  88.         Joins("left join sys_role c on c.id = sys_user.role_id").
  89.         Offset(offset).Limit(pageSize).Find(&list) // 分页查询，根据offset和limit来查询
  90.     query.Count(&total) // 查询总数用Count，注意查总数不能直接连在Find()后面，需要分开来单独一句才能正确查询到总数。
  91.     return config.PageInfo{
  92.     list, total}
  93. }
  95. // 详情
  96. func (e *SysUser) GetUser() (err error) {
  98.     query := config.DB.Table(e.TableName())
  99.     sql := `
  100.         SELECT a.*,b.name dept_name,role_key,role_name
  101.         FROM sys_user a
  102.         LEFT JOIN sys_dept b on FIND_IN_SET(b.id,a.dept_id)
  103.         LEFT JOIN sys_role c on a.role_id=c.id
  104.     `
  105.     args := []interface{
  106.     }{
  107.     }
  108.     if e.Id != "" {
  110.         sql = sql + "WHERE a.id = ?"
  111.         args = append(args, e.Id)
  112.     }
  113.     if e.UserName != "" {
  115.         sql = sql + "WHERE user_name = ?"
  116.         args = append(args, e.UserName)
  117.     }
  118.     // 数据过滤
  119.     scope := AppendQueryDataScope(e.Token, "dept_id", "2", false, true)
  120.     if scope != "" {
  122.         sql = sql + " AND " + scope
  123.     }
  124.     if err = query.Raw(sql, args...).Find(e).Error; err != nil {
  126.         return
  127.     }
  128.     if e.Id == "" || e.UserName == "" {
  130.         err = errors.New("没有查看权限！")
  131.         return
  132.     }
  133.     return
  134. }
  136. // 新增
  137. func (e *SysUser) Insert() (err error) {
  139.     // 校验新增的用户和当前用户是否是同一部门或子部门
  140.     if !CheckDataScope(e.Token, e.DeptId, false, true) {
  142.         err = errors.New("没有操作权限！")
  143.         return
  144.     }
  145.     // 校验用户名和手机号码
  146.     var count int64
  147.     db := config.DB.Table(e.TableName())
  148.     db.Where("user_name = ?", e.UserName).Count(&count)
  149.     if count > 0 {
  151.         err = errors.New("用户名称已存在！")
  152.         return
  153.     }
  154.     if e.Phone != nil {
  156.         db.Where("phone = ?", e.Phone).Count(&count)
  157.         if count > 0 {
  159.             err = errors.New("手机号码已存在！")
  160.             return
  161.         }
  162.     }
  163.     e.Id = strings.ReplaceAll(uuid.NewString(), "-", "")
  164.     e.CreatorId = GetLoginId(e.Token)
  165.     e.CreateTime = time.Now()
  166.     config.DB.Table(e.TableName()).Omit(omit).Create(e)
  167.     return
  168. }
  170. // 修改
  171. func (e *SysUser) Update() (err error) {
  173.     // 校验修改的用户和当前用户是否是同一部门或子部门
  174.     if !CheckDataScope(e.Token, e.DeptId, false, true) {
  176.         err = errors.New("没有操作权限！")
  177.         return
  178.     }
  179.     var byId SysUser
  180.     config.DB.Table(e.TableName()).Where("id = ?", e.Id).Find(&byId)
  181.     if byId.DeptId != e.DeptId && !CheckDataScope(e.Token, byId.DeptId, false, true) {
  183.         err = errors.New("没有操作权限！")
  184.         return
  185.     }
  186.     // 校验用户名和手机号码
  187.     var count int64
  188.     db := config.DB.Table(e.TableName())
  189.     db.Where("user_name = ? and id <> ?", e.UserName, e.Id).Count(&count)
  190.     if count > 0 {
  192.         err = errors.New("用户名称已存在！")
  193.         return
  194.     }
  195.     if e.Phone != nil {
  197.         db.Where("phone = ? and id <> ?", e.Phone, e.Id).Count(&count)
  198.         if count > 0 {
  200.             err = errors.New("手机号码已存在！")
  201.             return
  202.         }
  203.     }
  204.     config.DB.Table(e.TableName()).Omit(omit).Model(&SysUser{
  205.     }).Where("id = ?", e.Id).Updates(e)
  206.     return
  207. }
  209. // 删除
  210. func (e *SysUser) Delete(ids []string) (err error) {
  212.     // 先查询要删除的用户
  213.     scope := GetDataScope(e.Token, false, true)
  214.     if scope != "" {
  216.         var list []SysUser
  217.         config.DB.Table(e.TableName()).Where("id in (?)", ids).Find(&list)
  218.         split := strings.Split(scope, ",")
  219.         for _, user := range list {
  221.             if !util.IsContain(split, user.DeptId) {
  223.                 err = errors.New("没有操作权限！")
  224.                 return
  225.             }
  226.         }
  227.     }
  228.     config.DB.Table(e.TableName()).Delete(&SysUser{
  229.     }, ids)
  230.     return
  231. }
  233. // 修改密码
  234. func (e *Password) UpdatePassword() (err error) {
  236.     if e.NewPassword == "" || e.OldPassword == "" || e.Id == "" {
  238.         err = errors.New("数据解密失败")
  239.         return
  240.     }
  241.     var user SysUser
  242.     config.DB.Table(user.TableName()).Where("id = ?", e.Id).Find(&user)
  243.     if !CheckDataScope(e.Token, user.DeptId, false, true) {
  245.         err = errors.New("没有操作权限！")
  246.         return
  247.     }
  248.     if e.NewPassword == e.OldPassword {
  250.         err = errors.New("新密码不可于旧密码相同")
  251.         return
  252.     }
  253.     if e.NewPassword == config.InitPassword {
  255.         err = errors.New("新密码不可于初始密码相同")
  256.         return
  257.     }
  258.     // 正则表达式我去你大爷！！！不校验了，我校验你大爷！！！从别的项目复制过来的正则，为什么你就死活校验不上！！
  259.     // 同样的正则，我一模一样复制到校验工具去验证都可以匹配上，就你不行，我去你大爷，不校验了，校验你爹！！！
  260.     /*reg := "^(?=.*?[A-Z])(?=.*?[a-z])(?=.*?[0-9])(?=.*?[_#?!@$%^&*-]).{8,}$"
  261.     m, _ := regexp.MatchString(reg, e.NewPassword)
  262.     if !m {
  263.         err = errors.New("密码长度大于7,且必须由数字、大小写字母、特殊字符组成")
  264.         return
  265.     }*/
  266.     b := util.AuthenticatePassword(e.OldPassword, user.Password)
  267.     if !b {
  269.         err = errors.New("旧密码错误")
  270.         return
  271.     }
  272.     newPassword, err := util.GetEncryptedPassword(e.NewPassword)
  273.     if err = config.DB.Table(user.TableName()).Where("id = ?", e.Id).Update("password", newPassword).Error; err != nil {
  275.         err = errors.New("密码修改失败")
  276.         return
  277.     }
  278.     return
  279. }
  281. // 重置密码为初始密码
  282. func (e *SysUser) ResetPassword() (err error) {
  284.     var user SysUser
  285.     config.DB.Table(e.TableName()).Where("id = ?", e.Id).Find(&user)
  286.     if !CheckDataScope(e.Token, user.DeptId, false, true) {
  288.         err = errors.New("没有操作权限！")
  289.         return
  290.     }
  291.     password, err := util.GetEncryptedPassword(config.InitPassword)
  292.     if err = config.DB.Table(e.TableName()).Where("id = ?", e.Id).Update("password", password).Error; err != nil {
  294.         err = errors.New("密码重置失败")
  295.         return
  296.     }
  297.     return
  298. }
  300. // 上传头像
  301. func (e *SysUser) Upload() {
  303.     id := GetLoginId(e.Token)
  304.     config.DB.Table(e.TableName()).Where("id = ?", id).Update("picture", e.Picture)
  305. }
  307. // 根据部门id校验是否存在用户
  308. func CheckDeptExistUser(deptId string) bool {
  310.     var count int64
  311.     query := config.DB.Table(SysUserView{
  312.     }.TableName())
  313.     query.Where("dept_id = ?", deptId).Count(&count)
  314.     return count > 0
  315. }
  317. // 根据角色id校验是否存在用户
  318. func CheckRoleExistUser(roleId string) bool {
  320.     var count int64
  321.     query := config.DB.Table(SysUserView{
  322.     }.TableName())
  323.     query.Where("role_id = ?", roleId).Count(&count)
  324.     return count > 0
  325. }

通过上面controller、model层的方法、函数，不难看出，我很多函数都绑定了结构体，controller层绑定的结构体是 UserController ，model层也绑定了对应的结构体。像这种绑定了具体的数据类型的函数我们称为方法。

在这里插入图片描述

将函数绑定数据类型，这样子就可以让函数只属于这个数据类型了。我们知道，在go中，同一个包下函数名是不可以重复的，但我们给那些重名的函数绑定不同数据类型，就可以了。这样可以省去好多命名的烦恼。

假如某个函数是专门用来处理某个结构体的业务时，那就可以给这个函数绑定对应的结构体（不绑定也可以，就是函数命名的时候需要注意）。

部门管理

接下来是部门管理模块，有以下几个接口：

在这里插入图片描述

controller层：sys_dept.go

  1. package sys
  3. import (
  4.     "github.com/gofiber/fiber/v2"
  5.     "go-web2/app/common/config"
  6.     "go-web2/app/model/sys"
  7. )
  9. type DeptController struct{
  10.     }
  12. // 部门树列表
  13. func (DeptController) GetList(c *fiber.Ctx) error {
  15.     dept := sys.SysDept{
  16.     }
  17.     dept.Token = c.Get(config.TokenHeader)
  18.     return c.Status(200).JSON(config.Success(dept.GetListTree()))
  19. }
  21. // 根据id获取部门
  22. func (DeptController) GetById(c *fiber.Ctx) error {
  24.     dept := sys.SysDept{
  25.     }
  26.     dept.Id = c.Params("id")
  27.     dept.Token = c.Get(config.TokenHeader)
  28.     err := dept.GetById()
  29.     if err != nil {
  31.         return c.Status(200).JSON(config.Error(err.Error()))
  32.     }
  33.     return c.Status(200).JSON(config.Success(dept))
  34. }
  36. // 新增部门
  37. func (DeptController) Insert(c *fiber.Ctx) error {
  39.     var dept sys.SysDept
  40.     if err := c.BodyParser(&dept); err != nil {
  42.         //log.Error(err.Error())
  43.         return c.Status(200).JSON(config.Error(err.Error()))
  44.     }
  45.     dept.Token = c.Get(config.TokenHeader)
  46.     err := dept.Insert()
  47.     if err != nil {
  49.         return c.Status(200).JSON(config.Error(err.Error()))
  50.     }
  51.     return c.Status(200).JSON(config.Success(nil))
  52. }
  54. // 修改部门
  55. func (DeptController) Update(c *fiber.Ctx) error {
  57.     var dept sys.SysDept
  58.     if err := c.BodyParser(&dept); err != nil {
  60.         //log.Error(err.Error())
  61.         return c.Status(200).JSON(config.Error(err.Error()))
  62.     }
  63.     dept.Token = c.Get(config.TokenHeader)
  64.     err := dept.Update()
  65.     if err != nil {
  67.         return c.Status(200).JSON(config.Error(err.Error()))
  68.     }
  69.     return c.Status(200).JSON(config.Success(nil))
  70. }
  72. // 删除部门
  73. func (DeptController) Delete(c *fiber.Ctx) error {
  75.     var dept sys.SysDept
  76.     dept.Id = c.Params("id")
  77.     dept.Token = c.Get(config.TokenHeader)
  78.     if err := dept.Delete(); err != nil {
  80.         return c.Status(200).JSON(config.Error(err.Error()))
  81.     }
  82.     return c.Status(200).JSON(config.Success(nil))
  83. }
  85. // 部门下拉树列表
  86. func (DeptController) GetSelectList(c *fiber.Ctx) error {
  88.     dept := sys.SysDept{
  89.     }
  90.     dept.Token = c.Get(config.TokenHeader)
  91.     return c.Status(200).JSON(config.Success(dept.GetListTree()))
  92. }

model层：sys_dept.go

  1. package sys
  3. import (
  4.     "github.com/google/uuid"
  5.     "github.com/pkg/errors"
  6.     "go-web2/app/common/config"
  7.     "strings"
  8.     "time"
  9. )
  11. // 部门管理
  12. type SysDept struct {
  14.     config.BaseModel
  15.     Name     string    `json:"name" form:"name"`         // 名称
  16.     ParentId string    `json:"parentId" form:"parentId"` // 上级部门id
  17.     Level    int       `json:"level" form:"level"`       // 层级（1 根目录 2 单位 3 部门 4 小组）
  18.     Sort     int       `json:"sort" form:"sort"`         // 序号
  19.     Children []SysDept `gorm:"-" json:"children"`        // 子级数据
  20. }
  22. // 获取表名
  23. func (SysDept) TableName() string {
  25.     return "sys_dept"
  26. }
  28. // 递归所有子节点
  29. func (e *SysDept) ChildList() []SysDept {
  31.     // 获取所以子节点包括它本身
  32.     sql := `
  33.         WITH RECURSIVE temp_dept AS (
  34.             SELECT id,name,parent_id FROM sys_dept WHERE id = ?
  35.             UNION ALL
  36.             SELECT d.id,d.name,d.parent_id FROM sys_dept d
  37.             JOIN temp_dept sd ON sd.id = d.parent_id
  38.         )
  39.         SELECT * FROM temp_dept
  40.     `
  41.     var childList []SysDept
  42.     config.DB.Raw(sql, e.ParentId).Find(&childList)
  43.     return childList
  44. }
  46. // 根据parentId得到所有子节点的id和name（包括它本身），以逗号分隔
  47. func GetDeptChild(parentId string) (string, string) {
  49.     dept := SysDept{
  50.     }
  51.     dept.ParentId = parentId
  52.     list := dept.ChildList()
  53.     if len(list) > 0 {
  55.         idList := []string{
  56.     }
  57.         nameList := []string{
  58.     }
  59.         for _, t := range list {
  61.             idList = append(idList, t.Id)
  62.             nameList = append(nameList, t.Name)
  63.         }
  64.         return strings.Join(idList, ","), strings.Join(nameList, ",")
  65.     }
  66.     return "", ""
  67. }
  69. // 递归所有父节点，获取获取祖级列表（不包括它本身）
  70. func (e *SysDept) GetAncestor() (string, string) {
  72.     sql := `
  73.         WITH RECURSIVE temp_dept(id,name,parent_id,level) AS (
  74.             SELECT id,name,parent_id,level
  75.             FROM sys_dept
  76.             WHERE id = ?
  77.             UNION ALL
  78.             SELECT d.id,d.name,d.parent_id,d.level
  79.             FROM sys_dept d
  80.             JOIN temp_dept c ON d.id = c.parent_id
  81.         )
  82.         SELECT id,name,parent_id,level
  83.         FROM temp_dept
  84.         WHERE id != ?
  85.         ORDER BY level,parent_id
  86.     `
  87.     var ancestorList []SysDept
  88.     config.DB.Raw(sql, e.Id, e.Id).Find(&ancestorList)
  89.     idList := []string{
  90.     }
  91.     nameList := []string{
  92.     }
  93.     for _, t := range ancestorList {
  95.         idList = append(idList, t.Id)
  96.         nameList = append(nameList, t.Name)
  97.     }
  98.     return strings.Join(idList, ","), strings.Join(nameList, ",")
  99. }
  101. // 树形列表
  102. func (e *SysDept) GetListTree() []SysDept {
  104.     var list []SysDept // 查询结果
  105.     sql := ""
  106.     args := []interface{
  107.     }{
  108.     }
  109.     loginUser := GetLoginUser(e.Token)
  110.     e.Id = loginUser.DeptId
  111.     if e.Id != "" {
  113.         // 这里用于递归 e.Id 的父级根节点，因为转为树结构时，是从根节点开始递归的（不包括e.Id本身）
  114.         sql = `WITH RECURSIVE temp_dept(id,parent_id,name,level,sort) AS (
  115.                 SELECT id,parent_id,name,level,sort
  116.                 FROM sys_dept
  117.                 WHERE id = ?
  118.                 UNION ALL
  119.                 SELECT d.id,d.parent_id,d.name,d.level,d.sort
  120.                 FROM sys_dept d
  121.                 JOIN temp_dept c ON d.id = c.parent_id
  122.             )
  123.             SELECT id,parent_id,name,level,sort
  124.             FROM temp_dept
  125.             WHERE id != ?
  126.             UNION ALL`
  127.         args = append(args, e.Id, e.Id)
  128.     }
  129.     sql += ` SELECT id,parent_id,name,level,sort FROM sys_dept`
  130.     // 设置数据范围查询
  131.     scope := AppendQueryDataScope(e.Token, "id", "2", false, true)
  132.     if scope != "" {
  134.         sql = sql + " WHERE " + scope
  135.     }
  136.     config.DB.Table(e.TableName()).Debug().Order("`level`,parent_id,sort asc").Raw(sql, args...).Find(&list)
  137.     return buildDeptTree(list, "ROOT")
  138. }
  140. // 获取详情
  141. func (e *SysDept) GetById() (err error) {
  143.     if !CheckDataScope(e.Token, e.Id, false, true) {
  145.         err = errors.New("没有操作权限！")
  146.         return
  147.     }
  148.     config.DB.Table(e.TableName()).Where("id = ?", e.Id).Find(e)
  149.     return
  150. }
  152. // 新增
  153. func (e *SysDept) Insert() (err error) {
  155.     // 新增部门时，只允许新增子部门（也就是只允许给当前用户所在部门新增子部门）
  156.     if !CheckDataScope(e.Token, e.ParentId, false, true) {
  158.         err = errors.New("没有操作权限！")
  159.         return
  160.     }
  161.     // 校验用户名和手机号码
  162.     var count int64
  163.     query := config.DB.Table(e.TableName())
  164.     query.Where("name = ? and parent_id = ?", e.Name, e.ParentId).Count(&count)
  165.     if count > 0 {
  167.         err = errors.New("名称已存在！")
  168.         return
  169.     }
  170.     err = e.getLevel()
  171.     if err != nil {
  173.         return err
  174.     }
  175.     e.Id = strings.ReplaceAll(uuid.NewString(), "-", "")
  176.     e.CreatorId = GetLoginId(e.Token)
  177.     e.CreateTime = time.Now()
  178.     config.DB.Table(e.TableName()).Create(e)
  179.     // 新增成功，更新数据权限缓存
  180.     exists, _ := config.RedisConn.Exists(config.DATA_SCOPE + e.ParentId).Result()
  181.     if exists > 0 {
  183.         childId := config.RedisConn.HGet(config.DATA_SCOPE+e.ParentId, "childId").Val()
  184.         childName := config.RedisConn.HGet(config.DATA_SCOPE+e.ParentId, "childName").Val()
  185.         config.RedisConn.HSet(config.DATA_SCOPE+e.ParentId, "childId", childId+","+e.Id)
  186.         config.RedisConn.HSet(config.DATA_SCOPE+e.ParentId, "childName", childName+","+e.Name)
  187.     }
  188.     return
  189. }
  191. // 修改
  192. func (e *SysDept) Update() (err error) {
  194.     // 修改部门时，只允许修改当前部门和子部门数据
  195.     if !CheckDataScope(e.Token, e.Id, false, true) {
  197.         err = errors.New("没有操作权限！")
  198.         return
  199.     }
  200.     // 校验用户名和手机号码
  201.     var count int64
  202.     query := config.DB.Table(e.TableName())
  203.     query.Where("name = ? and parent_id = ? and id <> ?", e.Name, e.ParentId, e.Id).Count(&count)
  204.     if count > 0 {
  206.         err = errors.New("名称已存在！")
  207.         return
  208.     }
  209.     err = e.getLevel()
  210.     if err != nil {
  212.         return err
  213.     }
  214.     config.DB.Table(e.TableName()).Model(&SysDept{
  215.     }).Where("id = ?", e.Id).Updates(e)
  216.     return
  217. }
  219. // 删除
  220. func (e *SysDept) Delete() (err error) {
  222.     // 修改部门时，只允许修改当前部门和子部门数据
  223.     if !CheckDataScope(e.Token, e.Id, false, true) {
  225.         err = errors.New("没有操作权限！")
  226.         return
  227.     }
  228.     // 1、校验是否存在下级
  229.     var count int64
  230.     query := config.DB.Table(e.TableName())
  231.     query.Where("parent_id = ?", e.Id).Count(&count)
  232.     if count > 0 {
  234.         err = errors.New("存在下级,不允许删除")
  235.         return
  236.     }
  237.     // 2、校验是否存在用户
  238.     if CheckDeptExistUser(e.Id) {
  240.         err = errors.New("该组织存在用户,不允许删除")
  241.         return
  242.     }
  243.     if err = config.DB.Table(e.TableName()).Delete(e).Error; err != nil {
  245.         return
  246.     }
  247.     return
  248. }
  250. // 新增或修改部门时，根据父级的level获取当前部门的level
  251. func (e *SysDept) getLevel() (err error) {
  253.     if e.ParentId == "ROOT" {
  255.         e.Level = 1
  256.     } else {
  258.         var parent SysDept
  259.         parent.Id = e.ParentId
  260.         parent.GetById()
  261.         if parent.Name == "" {
  263.             err = errors.New("上级不存在！")
  264.             return
  265.         }
  266.         e.Level = parent.Level + 1
  267.     }
  268.     return
  269. }
  271. // 构建树结构
  272. func (e *SysDept) BuildTree(list []SysDept, parentId string) []SysDept {
  274.     var tree []SysDept
  275.     for _, item := range list {
  277.         if item.ParentId == parentId {
  279.             children := e.BuildTree(list, item.Id)
  280.             if len(children) > 0 {
  282.                 item.Children = children
  283.             }
  284.             tree = append(tree, item)
  285.         }
  286.     }
  287.     return tree
  288. }

最后

其实上面的代码都没有什么特别需要注意的地方，都是一些业务代码来的。对新手来说，需要注意的地方，可能就是查询数据的时候，特别是用原生sql拼接查询条件时，要用占位符的形式（也就是用 “?” 表示）拼接，那些查询条件不要用加号或者是fmt.Sprintf() 去拼接，不然容易有sql注入的问题。

还有就是分页查询，需要查询总数时，Count() 方法需要分开单独一句写，不然查的就不是总数，而是每一页的数量。

好啦，以上就是本篇文章的全部内容辣，等我更完这个项目的全部文章，我会放出完整代码的地址，欢迎大家多多点赞支持下，最后可以关注我不迷路~

发表评论

表情：
评论列表 （有 0 条评论，73人围观）

还没有评论，来说两句吧...

相关阅读