OMC/be.ems
1
0
Fork 0
Code Issues Releases 3 Activity

feat: 更新多个模块以支持新的数据结构和日志格式

Browse Source
This commit is contained in:
TsMask
2025-02-20 10:08:27 +08:00
parent 045a2b6b01
commit f3c33b31ac
272 changed files with 13246 additions and 15885 deletions
Download Patch File Download Diff File Expand all files Collapse all files

227
src/modules/system/controller/sys_config.go
View File

@@ -3,24 +3,22 @@ package controller
import (
"fmt"
"strconv"
"strings"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysConfigController 结构体
var NewSysConfig = &SysConfigController{
sysConfigService: service.NewSysConfigImpl,
sysConfigService: service.NewSysConfig,
}
// 参数配置信息
@@ -28,7 +26,7 @@ var NewSysConfig = &SysConfigController{
// PATH /system/config
type SysConfigController struct {
// 参数配置服务
sysConfigService service.ISysConfig
sysConfigService *service.SysConfig // 参数配置服务
}
// 参数配置列表
@@ -47,15 +45,14 @@ type SysConfigController struct {
// @Description Config Information List
// @Router /system/config/list [get]
func (s *SysConfigController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
querys := ctx.QueryMap(c)
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 多语言值转key查询
if v, ok := querys["configName"]; ok && v != "" {
querys["configName"] = i18n.TFindKeyPrefix(language, "config", v.(string))
if v, ok := query["configName"]; ok && v != "" {
query["configName"] = i18n.TFindKeyPrefix(language, "config", v)
}
data := s.sysConfigService.SelectConfigPage(querys)
rows := data["rows"].([]model.SysConfig)
rows, total := s.sysConfigService.FindByPage(query)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysConfig) {
@@ -67,187 +64,200 @@ func (s *SysConfigController) List(c *gin.Context) {
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 参数配置信息
//
// GET /:configId
func (s *SysConfigController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
configId := c.Param("configId")
if configId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
configId := parse.Number(c.Param("configId"))
if configId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: configId is empty"))
return
}
data := s.sysConfigService.SelectConfigById(configId)
if data.ConfigID == configId {
data := s.sysConfigService.FindById(configId)
if data.ConfigId == configId {
// 处理多语言
data.ConfigName = i18n.TKey(language, data.ConfigName)
data.ConfigValue = i18n.TKey(language, data.ConfigValue)
data.Remark = i18n.TKey(language, data.Remark)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 参数配置新增
//
// POST /
func (s *SysConfigController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysConfig
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.ConfigID != "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.ConfigId > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: configId not is empty"))
return
}
// 检查属性值唯一
uniqueConfigKey := s.sysConfigService.CheckUniqueConfigKey(body.ConfigKey, "")
uniqueConfigKey := s.sysConfigService.CheckUniqueByKey(body.ConfigKey, 0)
if !uniqueConfigKey {
// 参数配置新增【%s】失败，参数键名已存在
// msg := fmt.Sprintf("参数配置新增【%s】失败，参数键名已存在", body.ConfigKey)
msg := i18n.TTemplate(language, "config.errKeyExists", map[string]any{"name": body.ConfigKey})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysConfigService.InsertConfig(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
body.CreateBy = reqctx.LoginUserToUserName(c)
insertId := s.sysConfigService.Insert(body)
if insertId > 0 {
c.JSON(200, resp.OkData(insertId))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 参数配置修改
//
// PUT /
func (s *SysConfigController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysConfig
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.ConfigID == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 检查属性值唯一
uniqueConfigKey := s.sysConfigService.CheckUniqueConfigKey(body.ConfigKey, body.ConfigID)
if !uniqueConfigKey {
// 参数配置修改【%s】失败，参数键名已存在
msg := i18n.TTemplate(language, "config.errKeyExists", map[string]any{"name": body.ConfigKey})
c.JSON(200, result.ErrMsg(msg))
if body.ConfigId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: configId is empty"))
return
}
// 检查是否存在
configInfo := s.sysConfigService.SelectConfigById(body.ConfigID)
if configInfo.ConfigID != body.ConfigID {
// 没有可访问参数配置数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "config.noData")))
configInfo := s.sysConfigService.FindById(body.ConfigId)
if configInfo.ConfigId != body.ConfigId {
// c.JSON(200, resp.ErrMsg("没有权限访问参数配置数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "config.noData")))
return
}
// 检查属性值唯一
uniqueConfigKey := s.sysConfigService.CheckUniqueByKey(body.ConfigKey, body.ConfigId)
if !uniqueConfigKey {
// msg := fmt.Sprintf("参数配置修改【%s】失败，参数键名已存在", body.ConfigKey)
msg := i18n.TTemplate(language, "config.errKeyExists", map[string]any{"name": body.ConfigKey})
c.JSON(200, resp.ErrMsg(msg))
return
}
// 多语言非原始值
i18nValue := i18n.TKey(language, configInfo.ConfigName)
if i18nValue != configInfo.ConfigName {
i18n.UpdateKeyValue(language, configInfo.ConfigName, body.ConfigName)
service.NewSysI18n.UpdateKeyValue(language, configInfo.ConfigName, body.ConfigName)
body.ConfigName = configInfo.ConfigName
}
// 多语言非原始值
i18nValue2 := i18n.TKey(language, configInfo.ConfigValue)
if i18nValue2 != configInfo.ConfigValue {
i18n.UpdateKeyValue(language, configInfo.ConfigValue, body.ConfigValue)
service.NewSysI18n.UpdateKeyValue(language, configInfo.ConfigValue, body.ConfigValue)
body.ConfigValue = configInfo.ConfigValue
}
// 多语言非原始值
i18nValue3 := i18n.TKey(language, configInfo.Remark)
if i18nValue3 != configInfo.Remark {
i18n.UpdateKeyValue(language, configInfo.Remark, body.Remark)
service.NewSysI18n.UpdateKeyValue(language, configInfo.Remark, body.Remark)
body.Remark = configInfo.Remark
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysConfigService.UpdateConfig(body)
configInfo.ConfigType = body.ConfigType
configInfo.ConfigName = body.ConfigName
configInfo.ConfigKey = body.ConfigKey
configInfo.ConfigValue = body.ConfigValue
configInfo.Remark = body.Remark
configInfo.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysConfigService.Update(configInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 参数配置删除
// Remove 参数配置删除
//
// DELETE /:configIds
func (s *SysConfigController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
configIds := c.Param("configIds")
if configIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// DELETE /:configId
func (s SysConfigController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
configId := c.Param("configId")
if configId == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: configId is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(configIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(configId, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.sysConfigService.DeleteConfigByIds(uniqueIDs)
rows, err := s.sysConfigService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(i18n.TKey(language, err.Error())))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// msg := fmt.Sprintf("删除成功：%d", rows)
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
}
// 参数配置刷新缓存
// Refresh 参数配置刷新缓存
//
// PUT /refreshCache
func (s *SysConfigController) RefreshCache(c *gin.Context) {
s.sysConfigService.ResetConfigCache()
c.JSON(200, result.Ok(nil))
// PUT /refresh
func (s SysConfigController) Refresh(c *gin.Context) {
s.sysConfigService.CacheClean("*")
s.sysConfigService.CacheLoad("*")
c.JSON(200, resp.Ok(nil))
}
// 参数配置根据参数键名
// ConfigKey 参数配置根据参数键名
//
// GET /configKey/:configKey
func (s *SysConfigController) ConfigKey(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// GET /config-key/:configKey
func (s SysConfigController) ConfigKey(c *gin.Context) {
configKey := c.Param("configKey")
if configKey == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
c.JSON(400, resp.CodeMsg(40010, "bind err: configKey is empty"))
return
}
key := s.sysConfigService.SelectConfigValueByKey(configKey)
key := s.sysConfigService.FindValueByKey(configKey)
if key != "" {
c.JSON(200, result.OkData(i18n.TKey(language, key)))
c.JSON(200, resp.OkData(key))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 导出参数配置信息
// Export 导出参数配置信息
//
// POST /export
func (s *SysConfigController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// GET /export
func (s SysConfigController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
data := s.sysConfigService.SelectConfigPage(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
query := reqctx.QueryMap(c)
rows, total := s.sysConfigService.FindByPage(query)
if total == 0 {
// c.JSON(200, resp.CodeMsg(40016, "export data record as empty"))
c.JSON(200, resp.CodeMsg(40016, i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysConfig)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysConfig) {
@@ -279,7 +289,7 @@ func (s *SysConfigController) Export(c *gin.Context) {
typeValue = i18n.TKey(language, "dictData.yes")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ConfigID,
"A" + idx: row.ConfigId,
"B" + idx: row.ConfigName,
"C" + idx: row.ConfigKey,
"D" + idx: row.ConfigValue,
@@ -291,7 +301,7 @@ func (s *SysConfigController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
@@ -302,21 +312,22 @@ func (s *SysConfigController) Export(c *gin.Context) {
//
// PUT /changeValue
func (s *SysConfigController) ConfigValue(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
Key string `json:"key" binding:"required"`
Value string `json:"value" binding:"required"`
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 检查是否存在
info := s.sysConfigService.SelectConfigByKey(body.Key)
info := s.sysConfigService.FindByKey(body.Key)
if info.ConfigKey != body.Key {
// 无效 key
c.JSON(200, result.ErrMsg(i18n.TKey(language, "config.errKey")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "config.errKey")))
return
}
@@ -324,22 +335,22 @@ func (s *SysConfigController) ConfigValue(c *gin.Context) {
i18nValue := i18n.TKey(language, info.ConfigValue)
if i18nValue == body.Value {
// 变更状态与旧值相等！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "config.errValueEq")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "config.errValueEq")))
return
}
// 多语言非原始值
if i18nValue != info.ConfigValue {
i18n.UpdateKeyValue(language, info.ConfigValue, body.Value)
service.NewSysI18n.UpdateKeyValue(language, info.ConfigValue, body.Value)
} else {
info.ConfigValue = body.Value
}
info.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysConfigService.UpdateConfig(info)
info.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysConfigService.Update(info)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}

340
src/modules/system/controller/sys_dept.go
View File

@@ -1,31 +1,31 @@
package controller
import (
"fmt"
"strings"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/vo"
"be.ems/src/framework/vo/result"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/model/vo"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysDeptController 结构体
var NewSysDept = &SysDeptController{
sysDeptService: service.NewSysDeptImpl,
sysDeptService: service.NewSysDept,
}
// 部门信息
//
// PATH /system/dept
type SysDeptController struct {
// 部门服务
sysDeptService service.ISysDept
sysDeptService *service.SysDept // 部门服务
}
// 部门列表
@@ -45,36 +45,32 @@ type SysDeptController struct {
// @Description Dept Information List
// @Router /system/dept/list [get]
func (s *SysDeptController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var querys struct {
// 部门ID
DeptID string `form:"deptId"`
// 父部门ID
ParentID string `form:"parentId" `
// 部门名称
DeptName string `form:"deptName" `
// 部门状态（0正常 1停用）
Status string `form:"status"`
language := reqctx.AcceptLanguage(c)
var query struct {
DeptId int64 `form:"deptId"` // 部门ID
ParentId int64 `form:"parentId"` // 父部门ID
DeptName string `form:"deptName"` // 部门名称
Status string `form:"status"` // 部门状态（0正常 1停用）
}
err := c.ShouldBindQuery(&querys)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 多语言值转key查询
if querys.DeptName != "" {
querys.DeptName = i18n.TFindKeyPrefix(language, "dept", querys.DeptName)
if query.DeptName != "" {
query.DeptName = i18n.TFindKeyPrefix(language, "dept", query.DeptName)
}
SysDeptController := model.SysDept{
DeptID: querys.DeptID,
ParentID: querys.ParentID,
DeptName: querys.DeptName,
Status: querys.Status,
sysDept := model.SysDept{
DeptId: query.DeptId,
ParentId: query.ParentId,
DeptName: query.DeptName,
StatusFlag: query.Status,
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysDeptService.SelectDeptList(SysDeptController, dataScopeSQL)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_dept", "")
data := s.sysDeptService.Find(sysDept, dataScopeSQL)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysDept) {
@@ -84,137 +80,145 @@ func (s *SysDeptController) List(c *gin.Context) {
}
converI18n(language, &data)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
}
// 部门信息
// Info 部门信息
//
// GET /:deptId
func (s *SysDeptController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
deptId := c.Param("deptId")
if deptId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
func (s SysDeptController) Info(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
deptId := parse.Number(c.Param("deptId"))
if deptId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: deptId is empty"))
return
}
data := s.sysDeptService.SelectDeptById(deptId)
if data.DeptID == deptId {
data := s.sysDeptService.FindById(deptId)
if data.DeptId == deptId {
// 处理多语言
data.DeptName = i18n.TKey(language, data.DeptName)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 部门新增
// Add 部门新增
//
// POST /
func (s *SysDeptController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
func (s SysDeptController) Add(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body model.SysDept
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DeptID != "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.DeptId > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: deptId not is empty"))
return
}
// 父级ID不为0是要检查
if body.ParentID != "0" {
deptParent := s.sysDeptService.SelectDeptById(body.ParentID)
if deptParent.DeptID != body.ParentID {
// 没有可访问部门数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "dept.noData")))
if body.ParentId > 0 {
deptParent := s.sysDeptService.FindById(body.ParentId)
if deptParent.DeptId != body.ParentId {
c.JSON(200, resp.ErrMsg("没有权限访问部门数据！"))
return
}
if deptParent.Status == common.STATUS_NO {
// 上级部门【%s】停用，不允许新增
if deptParent.StatusFlag == constants.STATUS_NO {
// msg := fmt.Sprintf("上级部门【%s】停用，不允许新增", deptParent.DeptName)
msg := i18n.TTemplate(language, "dept.errParentStatus", map[string]any{"name": deptParent.DeptName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
if deptParent.DelFlag == common.STATUS_YES {
// 上级部门【%s】已删除，不允许新增
if deptParent.DelFlag == constants.STATUS_YES {
// msg := fmt.Sprintf("上级部门【%s】已删除，不允许新增", deptParent.DeptName)
msg := i18n.TTemplate(language, "dept.errParentDelFlag", map[string]any{"name": deptParent.DeptName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
body.Ancestors = deptParent.Ancestors + "," + body.ParentID
body.Ancestors = fmt.Sprintf("%s,%d", deptParent.Ancestors, body.ParentId)
} else {
body.Ancestors = "0"
}
// 检查同级下名称唯一
uniqueDeptName := s.sysDeptService.CheckUniqueDeptName(body.DeptName, body.ParentID, "")
if !uniqueDeptName {
// 部门新增【%s】失败，部门名称已存在
uniqueName := s.sysDeptService.CheckUniqueParentIdByDeptName(body.ParentId, body.DeptName, 0)
if !uniqueName {
// msg := fmt.Sprintf("部门新增【%s】失败，部门名称已存在", body.DeptName)
msg := i18n.TTemplate(language, "dept.errNameExists", map[string]any{"name": body.DeptName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysDeptService.InsertDept(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
body.CreateBy = reqctx.LoginUserToUserName(c)
insertId := s.sysDeptService.Insert(body)
if insertId > 0 {
c.JSON(200, resp.OkData(insertId))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 部门修改
// Edit 部门修改
//
// PUT /
func (s *SysDeptController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
func (s SysDeptController) Edit(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body model.SysDept
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DeptID == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.DeptId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: deptId is empty"))
return
}
// 上级部门不能选自己
if body.DeptID == body.ParentID {
// 部门修改【%s】失败，上级部门不能是自己
if body.DeptId == body.ParentId {
// msg := fmt.Sprintf("部门修改【%s】失败，上级部门不能是自己", body.DeptName)
msg := i18n.TTemplate(language, "dept.errParentID", map[string]any{"name": body.DeptName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查数据是否存在
deptInfo := s.sysDeptService.SelectDeptById(body.DeptID)
if deptInfo.DeptID != body.DeptID {
// 没有可访问部门数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "dept.noData")))
deptInfo := s.sysDeptService.FindById(body.DeptId)
if deptInfo.DeptId != body.DeptId {
// c.JSON(200, resp.ErrMsg("没有权限访问部门数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "dept.noData")))
return
}
// 父级ID不为0是要检查
if body.ParentID != "0" {
deptParent := s.sysDeptService.SelectDeptById(body.ParentID)
if deptParent.DeptID != body.ParentID {
// 没有可访问部门数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "dept.noData")))
if body.ParentId > 0 {
deptParent := s.sysDeptService.FindById(body.ParentId)
if deptParent.DeptId != body.ParentId {
// c.JSON(200, resp.ErrMsg("没有权限访问部门数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "dept.noData")))
return
}
}
// 检查同级下名称唯一
uniqueDeptName := s.sysDeptService.CheckUniqueDeptName(body.DeptName, body.ParentID, body.DeptID)
uniqueDeptName := s.sysDeptService.CheckUniqueParentIdByDeptName(body.ParentId, body.DeptName, body.DeptId)
if !uniqueDeptName {
// 部门修改【%s】失败，部门名称已存在
// msg := fmt.Sprintf("部门修改【%s】失败，部门名称已存在", body.DeptName)
msg := i18n.TTemplate(language, "dept.errNameExists", map[string]any{"name": body.DeptName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 上级停用需要检查下级是否有在使用
if body.Status == common.STATUS_NO {
hasChild := s.sysDeptService.HasChildByDeptId(body.DeptID)
if body.StatusFlag == constants.STATUS_NO {
hasChild := s.sysDeptService.ExistChildrenByDeptId(body.DeptId)
if hasChild > 0 {
// 该部门包含未停用的子部门数量：%d
// msg := fmt.Sprintf("该部门包含未停用的子部门数量：%d", hasChild)
msg := i18n.TTemplate(language, "dept.errHasChildUse", map[string]any{"num": hasChild})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
}
@@ -222,128 +226,124 @@ func (s *SysDeptController) Edit(c *gin.Context) {
// 多语言非原始值
i18nValue := i18n.TKey(language, deptInfo.DeptName)
if i18nValue != deptInfo.DeptName {
i18n.UpdateKeyValue(language, deptInfo.DeptName, body.DeptName)
service.NewSysI18n.UpdateKeyValue(language, deptInfo.DeptName, body.DeptName)
body.DeptName = deptInfo.DeptName
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysDeptService.UpdateDept(body)
deptInfo.DeptName = body.DeptName
deptInfo.ParentId = body.ParentId
deptInfo.DeptSort = body.DeptSort
deptInfo.Leader = body.Leader
deptInfo.Phone = body.Phone
deptInfo.Email = body.Email
deptInfo.StatusFlag = body.StatusFlag
deptInfo.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysDeptService.Update(deptInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 部门删除
// Remove 部门删除
//
// DELETE /:deptId
func (s *SysDeptController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
deptId := c.Param("deptId")
if deptId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
func (s SysDeptController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
deptId := parse.Number(c.Param("deptId"))
if deptId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: deptId is empty"))
return
}
// 检查数据是否存在
dept := s.sysDeptService.SelectDeptById(deptId)
if dept.DeptID != deptId {
// 没有可访问部门数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "dept.noData")))
dept := s.sysDeptService.FindById(deptId)
if dept.DeptId != deptId {
// c.JSON(200, resp.ErrMsg("没有权限访问部门数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "dept.noData")))
return
}
// 检查是否存在子部门
hasChild := s.sysDeptService.HasChildByDeptId(deptId)
hasChild := s.sysDeptService.ExistChildrenByDeptId(deptId)
if hasChild > 0 {
// 不允许删除，存在子部门数：%d
// msg := fmt.Sprintf("不允许删除，存在子部门数：%d", hasChild)
msg := i18n.TTemplate(language, "dept.errHasChildUse", map[string]any{"num": hasChild})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查是否分配给用户
existUser := s.sysDeptService.CheckDeptExistUser(deptId)
existUser := s.sysDeptService.ExistUserByDeptId(deptId)
if existUser > 0 {
// 不允许删除，部门已分配给用户数：%d
// msg := fmt.Sprintf("不允许删除，部门已分配给用户数：%d", existUser)
msg := i18n.TTemplate(language, "dept.errHasUserUse", map[string]any{"num": existUser})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
rows := s.sysDeptService.DeleteDeptById(deptId)
rows := s.sysDeptService.DeleteById(deptId)
if rows > 0 {
// 删除成功：%d
// msg := fmt.Sprintf("删除成功：%d", rows)
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 部门列表（排除节点）
//
// GET /list/exclude/:deptId
func (s *SysDeptController) ExcludeChild(c *gin.Context) {
language := ctx.AcceptLanguage(c)
deptId := c.Param("deptId")
if deptId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
deptIdStr := c.Param("deptId")
if deptIdStr == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: deptId is empty"))
return
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysDeptService.SelectDeptList(model.SysDept{}, dataScopeSQL)
deptId := parse.Number(deptIdStr)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_dept", "")
data := s.sysDeptService.Find(model.SysDept{}, dataScopeSQL)
// 过滤排除节点
filtered := make([]model.SysDept, 0)
for _, dept := range data {
hasAncestor := false
ancestorList := strings.Split(dept.Ancestors, ",")
for _, ancestor := range ancestorList {
if ancestor == deptId {
hasAncestor = true
break
}
if dept.DeptId == deptId {
continue
}
if !(dept.DeptID == deptId || hasAncestor) {
dept.DeptName = i18n.TKey(language, dept.DeptName)
// 如果当前部门的ancestors不包含要排除的deptId，则添加到filtered中
if !strings.Contains(dept.Ancestors, deptIdStr) {
filtered = append(filtered, dept)
}
}
c.JSON(200, result.OkData(filtered))
c.JSON(200, resp.OkData(filtered))
}
// 部门树结构列表
//
// GET /treeSelect
func (s *SysDeptController) TreeSelect(c *gin.Context) {
language := ctx.AcceptLanguage(c)
var querys struct {
// 部门ID
DeptID string `json:"deptId"`
// 父部门ID
ParentID string `json:"parentId" `
// 部门名称
DeptName string `json:"deptName" `
// 部门状态（0正常 1停用）
Status string `json:"status"`
// GET /tree
func (s *SysDeptController) Tree(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var query struct {
DeptId int64 `form:"deptId"` // 部门ID
ParentId int64 `form:"parentId"` // 父部门ID
DeptName string `form:"deptName"` // 部门名称
StatusFlag string `form:"statusFlag"` // 部门状态（0正常 1停用）
}
err := c.ShouldBindQuery(&querys)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindQuery(&query); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
SysDeptController := model.SysDept{
DeptID: querys.DeptID,
ParentID: querys.ParentID,
DeptName: querys.DeptName,
Status: querys.Status,
sysDept := model.SysDept{
DeptId: query.DeptId,
ParentId: query.ParentId,
DeptName: query.DeptName,
StatusFlag: query.StatusFlag,
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
deptTreeSelect := s.sysDeptService.SelectDeptTreeSelect(SysDeptController, dataScopeSQL)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_dept", "")
data := s.sysDeptService.BuildTreeSelect(sysDept, dataScopeSQL)
// 闭包函数处理多语言
var converI18n func(language string, arr *[]vo.TreeSelect)
@@ -355,25 +355,25 @@ func (s *SysDeptController) TreeSelect(c *gin.Context) {
}
}
}
converI18n(language, &deptTreeSelect)
converI18n(language, &data)
c.JSON(200, result.OkData(deptTreeSelect))
c.JSON(200, resp.OkData(data))
}
// 部门树结构列表（指定角色）
//
// GET /roleDeptTreeSelect/:roleId
func (s *SysDeptController) RoleDeptTreeSelect(c *gin.Context) {
language := ctx.AcceptLanguage(c)
roleId := c.Param("roleId")
if roleId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// GET /tree/role/:roleId
func (s *SysDeptController) TreeRole(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
roleId := parse.Number(c.Param("roleId"))
if roleId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: roleId is empty"))
return
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
deptTreeSelect := s.sysDeptService.SelectDeptTreeSelect(model.SysDept{}, dataScopeSQL)
checkedKeys := s.sysDeptService.SelectDeptListByRoleId(roleId)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_dept", "")
deptTreeSelect := s.sysDeptService.BuildTreeSelect(model.SysDept{}, dataScopeSQL)
checkedKeys := s.sysDeptService.FindDeptIdsByRoleId(roleId)
// 闭包函数处理多语言
var converI18n func(language string, arr *[]vo.TreeSelect)
@@ -387,7 +387,7 @@ func (s *SysDeptController) RoleDeptTreeSelect(c *gin.Context) {
}
converI18n(language, &deptTreeSelect)
c.JSON(200, result.OkData(map[string]any{
c.JSON(200, resp.OkData(map[string]any{
"depts": deptTreeSelect,
"checkedKeys": checkedKeys,
}))

270
src/modules/system/controller/sys_dict_data.go
View File

@@ -7,15 +7,14 @@ import (
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysDictDataController 结构体
@@ -48,15 +47,14 @@ type SysDictDataController struct {
// @Description Dictionary Data List
// @Router /system/dict/data/list [get]
func (s *SysDictDataController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
querys := ctx.QueryMap(c)
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 多语言值转key查询
if v, ok := querys["dictLabel"]; ok && v != "" {
querys["dictLabel"] = i18n.TFindKeyPrefix(language, "dictData", v.(string))
if v, ok := query["dataLabel"]; ok && v != "" {
query["dataLabel"] = i18n.TFindKeyPrefix(language, "dictData", v)
}
data := s.sysDictDataService.SelectDictDataPage(querys)
rows := data["rows"].([]model.SysDictData)
rows, total := s.sysDictDataService.FindByPage(query)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysDictData) {
@@ -64,208 +62,234 @@ func (s *SysDictDataController) List(c *gin.Context) {
if strings.Contains((*arr)[i].DictType, "i18n") {
continue
}
(*arr)[i].DictLabel = i18n.TKey(language, (*arr)[i].DictLabel)
(*arr)[i].DataLabel = i18n.TKey(language, (*arr)[i].DataLabel)
(*arr)[i].Remark = i18n.TKey(language, (*arr)[i].Remark)
}
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 字典数据详情
// Info 字典数据详情
//
// GET /:dictCode
func (s *SysDictDataController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
dictCode := c.Param("dictCode")
if dictCode == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// GET /:dataId
func (s SysDictDataController) Info(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
dataId := parse.Number(c.Param("dataId"))
if dataId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: deptId is empty"))
return
}
data := s.sysDictDataService.SelectDictDataByCode(dictCode)
if data.DictCode == dictCode {
data := s.sysDictDataService.FindById(dataId)
if data.DataId == dataId {
// 处理多语言
if !strings.Contains(data.DictType, "i18n") {
data.DictLabel = i18n.TKey(language, data.DictLabel)
data.DataLabel = i18n.TKey(language, data.DataLabel)
data.Remark = i18n.TKey(language, data.Remark)
}
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 字典数据新增
// Add 字典数据新增
//
// POST /
func (s *SysDictDataController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
func (s SysDictDataController) Add(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body model.SysDictData
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DictCode != "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.DataId > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: dataId not is empty"))
return
}
// 检查字典类型是否存在
sysDictType := s.sysDictTypeService.SelectDictTypeByType(body.DictType)
if sysDictType.DictType != body.DictType {
// 没有可访问字典类型数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "dictType.noData")))
dictType := s.sysDictTypeService.FindByType(body.DictType)
if dictType.DictType != body.DictType {
// c.JSON(200, resp.ErrMsg("没有权限访问字典类型数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "dictType.noData")))
return
}
// 检查字典标签唯一
uniqueDictLabel := s.sysDictDataService.CheckUniqueDictLabel(body.DictType, body.DictLabel, "")
if !uniqueDictLabel {
// 数据新增【%s】失败，该字典类型下标签名已存在
msg := i18n.TTemplate(language, "dictType.errLabelExists", map[string]any{"name": body.DictLabel})
c.JSON(200, result.ErrMsg(msg))
uniqueLabel := s.sysDictDataService.CheckUniqueTypeByLabel(body.DictType, body.DataLabel, 0)
if !uniqueLabel {
// msg := fmt.Sprintf("数据新增【%s】失败，该字典类型下标签名已存在", body.DataLabel)
msg := i18n.TTemplate(language, "dictType.errLabelExists", map[string]any{"name": body.DataLabel})
c.JSON(200, resp.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysDictDataService.InsertDictData(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
// 检查字典键值唯一
uniqueValue := s.sysDictDataService.CheckUniqueTypeByValue(body.DictType, body.DataValue, 0)
if !uniqueValue {
// msg := fmt.Sprintf("数据新增【%s】失败，该字典类型下标签值已存在", body.DataValue)
msg := i18n.TTemplate(language, "dictType.errLabelExists", map[string]any{"name": body.DataLabel})
c.JSON(200, resp.ErrMsg(msg))
return
}
c.JSON(200, result.Err(nil))
body.CreateBy = reqctx.LoginUserToUserName(c)
insertId := s.sysDictDataService.Insert(body)
if insertId > 0 {
c.JSON(200, resp.OkData(insertId))
return
}
c.JSON(200, resp.Err(nil))
}
// 字典类型修改
// Edit 字典类型修改
//
// PUT /
func (s *SysDictDataController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
func (s SysDictDataController) Edit(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body model.SysDictData
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DictCode == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.DataId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: dataId is empty"))
return
}
// 检查字典类型是否存在
sysDictType := s.sysDictTypeService.SelectDictTypeByType(body.DictType)
if sysDictType.DictType != body.DictType {
// 没有可访问字典类型数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "dictType.noData")))
dictType := s.sysDictTypeService.FindByType(body.DictType)
if dictType.DictType != body.DictType {
// c.JSON(200, resp.ErrMsg("没有权限访问字典类型数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "dictType.noData")))
return
}
// 检查字典编码是否存在
sysDictData := s.sysDictDataService.SelectDictDataByCode(body.DictCode)
if sysDictData.DictCode != body.DictCode {
// 没有可访问字典编码数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "dictData.noData")))
dictData := s.sysDictDataService.FindById(body.DataId)
if dictData.DataId != body.DataId {
// c.JSON(200, resp.ErrMsg("没有权限访问字典编码数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "dictData.noData")))
return
}
// 检查字典标签唯一
uniqueDictLabel := s.sysDictDataService.CheckUniqueDictLabel(body.DictType, body.DictLabel, body.DictCode)
if !uniqueDictLabel {
// 数据修改【%s】失败，该字典类型下标签名已存在
msg := i18n.TTemplate(language, "dictType.errLabelExists", map[string]any{"name": body.DictLabel})
c.JSON(200, result.ErrMsg(msg))
uniqueLabel := s.sysDictDataService.CheckUniqueTypeByLabel(body.DictType, body.DataLabel, body.DataId)
if !uniqueLabel {
// msg := fmt.Sprintf("数据修改【%s】失败，该字典类型下标签名已存在", body.DataLabel)
msg := i18n.TTemplate(language, "dictType.errLabelExists", map[string]any{"name": body.DataLabel})
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查字典键值唯一
uniqueValue := s.sysDictDataService.CheckUniqueTypeByValue(body.DictType, body.DataValue, body.DataId)
if !uniqueValue {
// msg := fmt.Sprintf("数据修改【%s】失败，该字典类型下标签值已存在", body.DataLabel)
msg := i18n.TTemplate(language, "dictType.errLabelExists", map[string]any{"name": body.DataLabel})
c.JSON(200, resp.ErrMsg(msg))
return
}
// 多语言非原始值
i18nValue := i18n.TKey(language, sysDictData.DictLabel)
if i18nValue != sysDictData.DictLabel {
i18n.UpdateKeyValue(language, sysDictData.DictLabel, body.DictLabel)
body.DictLabel = sysDictData.DictLabel
i18nValue := i18n.TKey(language, dictData.DataLabel)
if i18nValue != dictData.DataLabel {
service.NewSysI18n.UpdateKeyValue(language, dictData.DataLabel, body.DataLabel)
body.DataLabel = dictData.DataLabel
}
// 多语言非原始值
i18nValue2 := i18n.TKey(language, sysDictData.Remark)
if i18nValue2 != sysDictData.Remark {
i18n.UpdateKeyValue(language, sysDictData.Remark, body.Remark)
body.Remark = sysDictData.Remark
i18nValue2 := i18n.TKey(language, dictData.Remark)
if i18nValue2 != dictData.Remark {
service.NewSysI18n.UpdateKeyValue(language, dictData.Remark, body.Remark)
body.Remark = dictData.Remark
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysDictDataService.UpdateDictData(body)
dictData.DictType = body.DictType
dictData.DataLabel = body.DataLabel
dictData.DataValue = body.DataValue
dictData.DataSort = body.DataSort
dictData.TagClass = body.TagClass
dictData.TagType = body.TagType
dictData.StatusFlag = body.StatusFlag
dictData.Remark = body.Remark
dictData.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysDictDataService.Update(dictData)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 字典数据删除
// Remove 字典数据删除
//
// DELETE /:dictCodes
func (s *SysDictDataController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
dictCodes := c.Param("dictCodes")
if dictCodes == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// DELETE /:dataId
func (s SysDictDataController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
dataId := c.Param("dataId")
if dataId == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: dataId is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(dictCodes, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(dataId, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.sysDictDataService.DeleteDictDataByCodes(uniqueIDs)
rows, err := s.sysDictDataService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// 删除成功：%d
// msg := fmt.Sprintf("删除成功：%d", rows)
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
}
// 字典数据列表（指定字典类型）
// DictType 字典数据列表（指定字典类型）
//
// GET /type/:dictType
func (s *SysDictDataController) DictType(c *gin.Context) {
language := ctx.AcceptLanguage(c)
func (s SysDictDataController) DictType(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
dictType := c.Param("dictType")
if dictType == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
c.JSON(400, resp.CodeMsg(40010, "bind err: dictType is empty"))
return
}
data := s.sysDictDataService.SelectDictDataByType(dictType)
data := s.sysDictDataService.FindByType(dictType)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysDictData) {
for i := range *arr {
(*arr)[i].DictLabel = i18n.TKey(language, (*arr)[i].DictLabel)
(*arr)[i].DataLabel = i18n.TKey(language, (*arr)[i].DataLabel)
(*arr)[i].Remark = i18n.TKey(language, (*arr)[i].Remark)
}
}
converI18n(language, &data)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
}
// 字典数据列表导出
// Export 字典数据列表导出
//
// POST /export
func (s *SysDictDataController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// GET /export
func (s SysDictDataController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
data := s.sysDictDataService.SelectDictDataPage(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysDictData)
// rows := s.sysDictDataService.SelectDictDataList(model.SysDictData{})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
query := reqctx.QueryMap(c)
rows, total := s.sysDictDataService.FindByPage(query)
if total == 0 {
// c.JSON(200, resp.CodeMsg(40016, "export data record as empty"))
c.JSON(200, resp.CodeMsg(40016, i18n.TKey(language, "app.common.exportEmpty")))
return
}
@@ -275,7 +299,7 @@ func (s *SysDictDataController) Export(c *gin.Context) {
if strings.Contains((*arr)[i].DictType, "i18n") {
continue
}
(*arr)[i].DictLabel = i18n.TKey(language, (*arr)[i].DictLabel)
(*arr)[i].DataLabel = i18n.TKey(language, (*arr)[i].DataLabel)
(*arr)[i].Remark = i18n.TKey(language, (*arr)[i].Remark)
}
}
@@ -296,14 +320,14 @@ func (s *SysDictDataController) Export(c *gin.Context) {
for i, row := range rows {
idx := strconv.Itoa(i + 2)
statusValue := i18n.TKey(language, "dictData.disable")
if row.Status == "1" {
if row.StatusFlag == "1" {
statusValue = i18n.TKey(language, "dictData.normal")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.DictCode,
"B" + idx: row.DictLabel,
"C" + idx: row.DictValue,
"D" + idx: row.DictSort,
"A" + idx: row.DataId,
"B" + idx: row.DataLabel,
"C" + idx: row.DataValue,
"D" + idx: row.DataSort,
"E" + idx: statusValue,
})
}
@@ -311,7 +335,7 @@ func (s *SysDictDataController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

232
src/modules/system/controller/sys_dict_type.go
View File

@@ -3,20 +3,17 @@ package controller
import (
"fmt"
"strconv"
"strings"
"time"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysDictTypeController 结构体
@@ -47,15 +44,15 @@ type SysDictTypeController struct {
// @Description Dictionary Type List
// @Router /system/dict/type/list [get]
func (s *SysDictTypeController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
querys := ctx.QueryMap(c)
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 多语言值转key查询
if v, ok := querys["dictName"]; ok && v != "" {
querys["dictName"] = i18n.TFindKeyPrefix(language, "dictType", v.(string))
if v, ok := query["dictName"]; ok && v != "" {
query["dictName"] = i18n.TFindKeyPrefix(language, "dictType", v)
}
data := s.sysDictTypeService.SelectDictTypePage(querys)
rows := data["rows"].([]model.SysDictType)
rows, total := s.sysDictTypeService.FindByPage(query)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysDictType) {
@@ -66,210 +63,213 @@ func (s *SysDictTypeController) List(c *gin.Context) {
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 字典类型信息
//
// GET /:dictId
func (s *SysDictTypeController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
dictId := c.Param("dictId")
if dictId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
dictId := parse.Number(c.Param("dictId"))
if dictId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: dictId is empty"))
return
}
data := s.sysDictTypeService.SelectDictTypeByID(dictId)
if data.DictID == dictId {
data := s.sysDictTypeService.FindById(dictId)
if data.DictId == dictId {
// 处理多语言
data.DictName = i18n.TKey(language, data.DictName)
data.Remark = i18n.TKey(language, data.Remark)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 字典类型新增
//
// POST /
func (s *SysDictTypeController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysDictType
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DictID != "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.DictId > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: dictId not is empty"))
return
}
// 检查字典名称唯一
uniqueDictName := s.sysDictTypeService.CheckUniqueDictName(body.DictName, "")
if !uniqueDictName {
// 字典新增【%s】失败，字典名称已存在
uniqueName := s.sysDictTypeService.CheckUniqueByName(body.DictName, 0)
if !uniqueName {
// msg := fmt.Sprintf("字典新增【%s】失败，字典名称已存在", body.DictName)
msg := i18n.TTemplate(language, "dictType.errNameExists", map[string]any{"name": body.DictName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查字典类型唯一
uniqueDictType := s.sysDictTypeService.CheckUniqueDictType(body.DictType, "")
if !uniqueDictType {
// 字典新增【%s】失败，字典类型已存在
uniqueType := s.sysDictTypeService.CheckUniqueByType(body.DictType, 0)
if !uniqueType {
// msg := fmt.Sprintf("字典新增【%s】失败，字典类型已存在", body.DictName)
msg := i18n.TTemplate(language, "dictType.errTypeExists", map[string]any{"name": body.DictName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysDictTypeService.InsertDictType(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
body.CreateBy = reqctx.LoginUserToUserName(c)
insertId := s.sysDictTypeService.Insert(body)
if insertId > 0 {
c.JSON(200, resp.OkData(insertId))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 字典类型修改
//
// PUT /
func (s *SysDictTypeController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysDictType
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DictID == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.DictId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: dictId is empty"))
return
}
// 检查数据是否存在
dictInfo := s.sysDictTypeService.SelectDictTypeByID(body.DictID)
if dictInfo.DictID != body.DictID {
// 没有可访问字典类型数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "dictType.noData")))
dictTypeInfo := s.sysDictTypeService.FindById(body.DictId)
if dictTypeInfo.DictId != body.DictId {
// c.JSON(200, resp.ErrMsg("没有权限访问字典类型数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "dictType.noData")))
return
}
// 检查字典名称唯一
uniqueDictName := s.sysDictTypeService.CheckUniqueDictName(body.DictName, body.DictID)
if !uniqueDictName {
// 字典修改【%s】失败，字典名称已存在
uniqueName := s.sysDictTypeService.CheckUniqueByName(body.DictName, body.DictId)
if !uniqueName {
// msg := fmt.Sprintf("字典修改【%s】失败，字典名称已存在", body.DictName)
msg := i18n.TTemplate(language, "dictType.errNameExists", map[string]any{"name": body.DictName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查字典类型唯一
uniqueDictType := s.sysDictTypeService.CheckUniqueDictType(body.DictType, body.DictID)
if !uniqueDictType {
// 字典修改【%s】失败，字典类型已存在
uniqueType := s.sysDictTypeService.CheckUniqueByType(body.DictType, body.DictId)
if !uniqueType {
// msg := fmt.Sprintf("字典修改【%s】失败，字典类型已存在", body.DictName)
msg := i18n.TTemplate(language, "dictType.errTypeExists", map[string]any{"name": body.DictName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 多语言非原始值
i18nValue := i18n.TKey(language, dictInfo.DictName)
if i18nValue != dictInfo.DictName {
i18n.UpdateKeyValue(language, dictInfo.DictName, body.DictName)
body.DictName = dictInfo.DictName
i18nValue := i18n.TKey(language, dictTypeInfo.DictName)
if i18nValue != dictTypeInfo.DictName {
service.NewSysI18n.UpdateKeyValue(language, dictTypeInfo.DictName, body.DictName)
body.DictName = dictTypeInfo.DictName
}
// 多语言非原始值
i18nValue2 := i18n.TKey(language, dictInfo.Remark)
if i18nValue2 != dictInfo.Remark {
i18n.UpdateKeyValue(language, dictInfo.Remark, body.Remark)
body.Remark = dictInfo.Remark
i18nValue2 := i18n.TKey(language, dictTypeInfo.Remark)
if i18nValue2 != dictTypeInfo.Remark {
service.NewSysI18n.UpdateKeyValue(language, dictTypeInfo.Remark, body.Remark)
body.Remark = dictTypeInfo.Remark
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysDictTypeService.UpdateDictType(body)
dictTypeInfo.DictName = body.DictName
dictTypeInfo.DictType = body.DictType
dictTypeInfo.StatusFlag = body.StatusFlag
dictTypeInfo.Remark = body.Remark
dictTypeInfo.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysDictTypeService.Update(dictTypeInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 字典类型删除
// Remove 字典类型删除
//
// DELETE /:dictIds
func (s *SysDictTypeController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
dictIds := c.Param("dictIds")
if dictIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// DELETE /:dictId
func (s SysDictTypeController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
dictId := c.Param("dictId")
if dictId == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: dictId is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(dictIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(dictId, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.sysDictTypeService.DeleteDictTypeByIDs(uniqueIDs)
rows, err := s.sysDictTypeService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// msg := fmt.Sprintf("删除成功：%d", rows)
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
}
// 字典类型刷新缓存
// Refresh 字典类型刷新缓存
//
// PUT /refreshCache
func (s *SysDictTypeController) RefreshCache(c *gin.Context) {
s.sysDictTypeService.ResetDictCache()
i18n.ClearLocaleData() // 清空国际化数据
c.JSON(200, result.Ok(nil))
// PUT /refresh
func (s SysDictTypeController) Refresh(c *gin.Context) {
s.sysDictTypeService.CacheClean("*")
s.sysDictTypeService.CacheLoad("*")
c.JSON(200, resp.Ok(nil))
}
// 字典类型选择框列表
//
// GET /getDictOptionselect
func (s *SysDictTypeController) DictOptionselect(c *gin.Context) {
data := s.sysDictTypeService.SelectDictTypeList(model.SysDictType{
Status: common.STATUS_YES,
})
// GET /options
func (s *SysDictTypeController) Options(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
data := s.sysDictTypeService.Find(model.SysDictType{})
type labelValue struct {
Label string `json:"label"`
Value string `json:"value"`
}
language := ctx.AcceptLanguage(c)
// 数据组
arr := []labelValue{}
arr := make([]labelValue, 0)
for _, v := range data {
arr = append(arr, labelValue{
Label: i18n.TKey(language, v.DictName),
Value: v.DictType,
})
}
c.JSON(200, result.OkData(arr))
c.JSON(200, resp.OkData(arr))
}
// 字典类型列表导出
// Export 字典类型列表导出
//
// POST /export
func (s *SysDictTypeController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// GET /export
func (s SysDictTypeController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
data := s.sysDictTypeService.SelectDictTypePage(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysDictType)
// rows := s.sysDictTypeService.SelectDictTypeList(model.SysDictType{})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
query := reqctx.QueryMap(c)
rows, total := s.sysDictTypeService.FindByPage(query)
if total == 0 {
// c.JSON(200, resp.CodeMsg(40016, "export data record as empty"))
c.JSON(200, resp.CodeMsg(40016, i18n.TKey(language, "app.common.exportEmpty")))
return
}
@@ -296,11 +296,11 @@ func (s *SysDictTypeController) Export(c *gin.Context) {
for i, row := range rows {
idx := strconv.Itoa(i + 2)
statusValue := i18n.TKey(language, "dictData.disable")
if row.Status == "1" {
if row.StatusFlag == "1" {
statusValue = i18n.TKey(language, "dictData.normal")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.DictID,
"A" + idx: row.DictId,
"B" + idx: row.DictName,
"C" + idx: row.DictType,
"D" + idx: statusValue,
@@ -310,7 +310,7 @@ func (s *SysDictTypeController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

113
src/modules/system/controller/sys_log_login.go
View File

@@ -3,15 +3,13 @@ package controller
import (
"fmt"
"strconv"
"strings"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
commonService "be.ems/src/modules/common/service"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/service"
@@ -21,7 +19,7 @@ import (
// 实例化控制层 SysLogLoginController 结构体
var NewSysLogLogin = &SysLogLoginController{
sysLogLoginService: service.NewSysLogLoginImpl,
sysLogLoginService: service.NewSysLogLogin,
accountService: commonService.NewAccount,
}
@@ -29,8 +27,7 @@ var NewSysLogLogin = &SysLogLoginController{
//
// PATH /system/log/login
type SysLogLoginController struct {
// 系统登录日志服务
sysLogLoginService service.ISysLogLogin
sysLogLoginService *service.SysLogLogin // 系统登录日志服务
accountService *commonService.Account // 账号身份操作服务
}
@@ -50,13 +47,12 @@ type SysLogLoginController struct {
// @Description System Login Log List
// @Router /system/log/login/list [get]
func (s *SysLogLoginController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "u")
data := s.sysLogLoginService.SelectSysLogLoginPage(querys, dataScopeSQL)
query := reqctx.QueryMap(c)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_user", "sys_user")
rows, total := s.sysLogLoginService.FindByPage(query, dataScopeSQL)
rows := data["rows"].([]model.SysLogLogin)
// 闭包函数处理多语言
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
converI18n := func(language string, arr *[]model.SysLogLogin) {
for i := range *arr {
(*arr)[i].LoginLocation = i18n.TKey(language, (*arr)[i].LoginLocation)
@@ -67,88 +63,47 @@ func (s *SysLogLoginController) List(c *gin.Context) {
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 系统登录日志删除
//
// DELETE /:loginIds
func (s *SysLogLoginController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
loginIds := c.Param("loginIds")
if loginIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 处理字符转id数组后去重
ids := strings.Split(loginIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows := s.sysLogLoginService.DeleteSysLogLoginByIds(uniqueIDs)
if rows > 0 {
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
}
// 系统登录日志清空
// Clean 系统登录日志清空
//
// DELETE /clean
func (s *SysLogLoginController) Clean(c *gin.Context) {
err := s.sysLogLoginService.CleanSysLogLogin()
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.Ok(nil))
func (s SysLogLoginController) Clean(c *gin.Context) {
rows := s.sysLogLoginService.Clean()
c.JSON(200, resp.OkData(rows))
}
// 系统登录日志账户解锁
// Unlock 系统登录日志账户解锁
//
// PUT /unlock/:userName
func (s *SysLogLoginController) Unlock(c *gin.Context) {
language := ctx.AcceptLanguage(c)
func (s SysLogLoginController) Unlock(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
userName := c.Param("userName")
if userName == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
c.JSON(400, resp.CodeMsg(40010, "bind err: userName is empty"))
return
}
ok := s.accountService.ClearLoginRecordCache(userName)
ok := s.accountService.CleanLoginRecordCache(userName)
if ok {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.errUnlock")))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.errUnlock")))
}
// 导出系统登录日志信息
// Export 导出系统登录日志信息
//
// POST /export
func (s *SysLogLoginController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// GET /export
func (s SysLogLoginController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "u")
data := s.sysLogLoginService.SelectSysLogLoginPage(querys, dataScopeSQL)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysLogLogin)
// rows := s.sysLogLoginService.SelectSysLogLoginList(model.SysLogLogin{})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
query := reqctx.QueryMap(c)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_user", "sys_user")
rows, total := s.sysLogLoginService.FindByPage(query, dataScopeSQL)
if total == 0 {
// c.JSON(200, resp.CodeMsg(40016, "export data record as empty"))
c.JSON(200, resp.CodeMsg(40016, i18n.TKey(language, "app.common.exportEmpty")))
return
}
@@ -183,13 +138,13 @@ func (s *SysLogLoginController) Export(c *gin.Context) {
idx := strconv.Itoa(i + 2)
// 状态
statusValue := i18n.TKey(language, "dictData.fail")
if row.Status == "1" {
if row.StatusFlag == "1" {
statusValue = i18n.TKey(language, "dictData.success")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.LoginID,
"A" + idx: row.ID,
"B" + idx: row.UserName,
"C" + idx: row.IPAddr,
"C" + idx: row.LoginIp,
"D" + idx: row.LoginLocation,
"E" + idx: row.OS,
"F" + idx: row.Browser,
@@ -202,7 +157,7 @@ func (s *SysLogLoginController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

113
src/modules/system/controller/sys_log_operate.go
View File

@@ -3,15 +3,13 @@ package controller
import (
"fmt"
"strconv"
"strings"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/service"
@@ -20,15 +18,14 @@ import (
// 实例化控制层 SysLogOperateController 结构体
var NewSysLogOperate = &SysLogOperateController{
SysLogOperateService: service.NewSysLogOperateImpl,
sysLogOperateService: service.NewSysLogOperate,
}
// 操作日志记录信息
//
// PATH /system/log/operate
type SysLogOperateController struct {
// 操作日志服务
SysLogOperateService service.ISysLogOperate
sysLogOperateService *service.SysLogOperate // 操作日志服务
}
// 操作日志列表
@@ -47,90 +44,48 @@ type SysLogOperateController struct {
// @Description System Operation Log List
// @Router /system/log/operate/list [get]
func (s *SysLogOperateController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
querys := ctx.QueryMap(c)
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 多语言值转key查询
if v, ok := querys["title"]; ok && v != "" {
querys["title"] = i18n.TFindKeyPrefix(language, "log.operate.title", v.(string))
if v, ok := query["title"]; ok && v != "" {
query["title"] = i18n.TFindKeyPrefix(language, "log.operate.title", v)
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "u")
data := s.SysLogOperateService.SelectSysLogOperatePage(querys, dataScopeSQL)
rows := data["rows"].([]model.SysLogOperate)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_user", "sys_user")
rows, total := s.sysLogOperateService.FindByPage(query, dataScopeSQL)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysLogOperate) {
for i := range *arr {
(*arr)[i].Title = i18n.TKey(language, (*arr)[i].Title)
(*arr)[i].OperLocation = i18n.TKey(language, (*arr)[i].OperLocation)
(*arr)[i].OperaLocation = i18n.TKey(language, (*arr)[i].OperaLocation)
}
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 操作日志删除
//
// DELETE /:operIds
func (s *SysLogOperateController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
operIds := c.Param("operIds")
if operIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 处理字符转id数组后去重
ids := strings.Split(operIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows := s.SysLogOperateService.DeleteSysLogOperateByIds(uniqueIDs)
if rows > 0 {
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
}
// 操作日志清空
// Clean 操作日志清空
//
// DELETE /clean
func (s *SysLogOperateController) Clean(c *gin.Context) {
err := s.SysLogOperateService.CleanSysLogOperate()
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.JSON(200, result.Ok(nil))
func (s SysLogOperateController) Clean(c *gin.Context) {
rows := s.sysLogOperateService.Clean()
c.JSON(200, resp.OkData(rows))
}
// 导出操作日志
// Export 导出操作日志
//
// POST /export
func (s *SysLogOperateController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// GET /export
func (s SysLogOperateController) Export(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "u")
data := s.SysLogOperateService.SelectSysLogOperatePage(querys, dataScopeSQL)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysLogOperate)
// rows := s.SysLogOperateService.SelectSysLogOperateList(model.SysLogOperate{})
if len(rows) <= 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
query := reqctx.QueryMap(c)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_user", "sys_user")
rows, total := s.sysLogOperateService.FindByPage(query, dataScopeSQL)
if total == 0 {
// c.JSON(200, resp.CodeMsg(40016, "export data record as empty"))
c.JSON(200, resp.CodeMsg(40016, i18n.TKey(language, "app.common.exportEmpty")))
return
}
@@ -138,7 +93,7 @@ func (s *SysLogOperateController) Export(c *gin.Context) {
converI18n := func(language string, arr *[]model.SysLogOperate) {
for i := range *arr {
(*arr)[i].Title = i18n.TKey(language, (*arr)[i].Title)
(*arr)[i].OperLocation = i18n.TKey(language, (*arr)[i].OperLocation)
(*arr)[i].OperaLocation = i18n.TKey(language, (*arr)[i].OperaLocation)
}
}
converI18n(language, &rows)
@@ -195,18 +150,18 @@ func (s *SysLogOperateController) Export(c *gin.Context) {
// 状态
statusValue := i18n.TKey(language, "dictData.fail")
if row.Status == "1" {
if row.StatusFlag == "1" {
statusValue = i18n.TKey(language, "dictData.success")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.OperID,
"A" + idx: row.ID,
"B" + idx: row.Title,
"C" + idx: businessType,
"D" + idx: row.OperName,
"E" + idx: row.RequestMethod,
"F" + idx: row.OperIP,
"D" + idx: row.OperaBy,
"E" + idx: row.OperaUrlMethod,
"F" + idx: row.OperaIp,
"G" + idx: statusValue,
"H" + idx: date.ParseDateToStr(row.OperTime, date.YYYY_MM_DDTHH_MM_SSZ),
"H" + idx: date.ParseDateToStr(row.OperaTime, date.YYYY_MM_DDTHH_MM_SSZ),
"I" + idx: row.CostTime,
})
}
@@ -214,7 +169,7 @@ func (s *SysLogOperateController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

296
src/modules/system/controller/sys_menu.go
View File

@@ -1,32 +1,32 @@
package controller
import (
"fmt"
"be.ems/src/framework/config"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/constants/menu"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/regular"
"be.ems/src/framework/vo"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/model/vo"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysMenuController 结构体
var NewSysMenu = &SysMenuController{
sysMenuService: service.NewSysMenuImpl,
sysMenuService: service.NewSysMenu,
}
// 菜单信息
//
// PATH /system/menu
type SysMenuController struct {
// 菜单服务
sysMenuService service.ISysMenu
sysMenuService *service.SysMenu // 菜单服务
}
// 菜单列表
@@ -44,20 +44,20 @@ type SysMenuController struct {
// @Description Menu Information List
// @Router /system/menu/list [get]
func (s *SysMenuController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
query := model.SysMenu{}
if v, ok := c.GetQuery("menuName"); ok && v != "" {
if v, ok := c.GetQuery("menuName"); ok {
query.MenuName = i18n.TFindKeyPrefix(language, "menu", v)
}
if v, ok := c.GetQuery("status"); ok && v != "" {
query.Status = v
if v, ok := c.GetQuery("statusFlag"); ok {
query.StatusFlag = v
}
userId := ctx.LoginUserToUserID(c)
if config.IsAdmin(userId) {
userId = "*"
userId := reqctx.LoginUserToUserID(c)
if config.IsSystemUser(userId) {
userId = 0
}
data := s.sysMenuService.SelectMenuList(query, userId)
data := s.sysMenuService.Find(query, userId)
// 闭包函数处理多语言
var converI18n func(language string, arr *[]model.SysMenu)
@@ -72,157 +72,166 @@ func (s *SysMenuController) List(c *gin.Context) {
}
converI18n(language, &data)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
}
// 菜单信息
//
// GET /:menuId
func (s *SysMenuController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
menuId := c.Param("menuId")
if menuId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
menuId := parse.Number(c.Param("menuId"))
if menuId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: menuId is empty"))
return
}
data := s.sysMenuService.SelectMenuById(menuId)
if data.MenuID == menuId {
data := s.sysMenuService.FindById(menuId)
if data.MenuId == menuId {
// 处理多语言
data.MenuName = i18n.TKey(language, data.MenuName)
data.Remark = i18n.TKey(language, data.Remark)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 菜单新增
//
// POST /
func (s *SysMenuController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysMenu
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.MenuID != "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.MenuId > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: menuId not is empty"))
return
}
// 目录和菜单检查地址唯一
if menu.TYPE_DIR == body.MenuType || menu.TYPE_MENU == body.MenuType {
uniqueNenuPath := s.sysMenuService.CheckUniqueMenuPath(body.Path, body.ParentID, "")
if !uniqueNenuPath {
// 菜单新增【%s】失败，菜单路由地址已存在
if constants.MENU_TYPE_DIR == body.MenuType || constants.MENU_TYPE_MENU == body.MenuType {
uniqueMenuPath := s.sysMenuService.CheckUniqueParentIdByMenuPath(body.ParentId, body.MenuPath, 0)
if !uniqueMenuPath {
// msg := fmt.Sprintf("菜单新增【%s】失败，菜单路由地址已存在", body.MenuName)
msg := i18n.TTemplate(language, "menu.errPathExists", map[string]any{"name": body.MenuName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
}
// 检查名称唯一
uniqueNenuName := s.sysMenuService.CheckUniqueMenuName(body.MenuName, body.ParentID, "")
if !uniqueNenuName {
// 菜单新增【%s】失败，菜单名称已存在
uniqueMenuName := s.sysMenuService.CheckUniqueParentIdByMenuName(body.ParentId, body.MenuName, 0)
if !uniqueMenuName {
// msg := fmt.Sprintf("菜单新增【%s】失败，菜单名称已存在", body.MenuName)
msg := i18n.TTemplate(language, "menu.errNameExists", map[string]any{"name": body.MenuName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 外链菜单需要符合网站http(s)开头
if body.IsFrame == common.STATUS_NO && !regular.ValidHttp(body.Path) {
// 操作菜单【{name}】失败，非内部地址请以http(s)://开头
if body.FrameFlag == constants.STATUS_NO && !regular.ValidHttp(body.MenuPath) {
// msg := fmt.Sprintf("菜单新增【%s】失败，非内部地址必须以http(s)://开头", body.MenuName)
msg := i18n.TTemplate(language, "menu.errFramePath", map[string]any{"name": body.MenuName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysMenuService.InsertMenu(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
body.CreateBy = reqctx.LoginUserToUserName(c)
insertId := s.sysMenuService.Insert(body)
if insertId > 0 {
c.JSON(200, resp.OkData(insertId))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 菜单修改
//
// PUT /
func (s *SysMenuController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysMenu
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.MenuID == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.MenuId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: menuId is empty"))
return
}
// 上级菜单不能选自己
if body.MenuID == body.ParentID {
// 菜单修改【%s】失败，上级菜单不能选择自己
if body.MenuId == body.ParentId {
// msg := fmt.Sprintf("菜单修改【%s】失败，上级菜单不能选择自己", body.MenuName)
msg := i18n.TTemplate(language, "menu.errPathExists", map[string]any{"name": body.MenuName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查数据是否存在
menuInfo := s.sysMenuService.SelectMenuById(body.MenuID)
if menuInfo.MenuID != body.MenuID {
// 没有可访问菜单数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "menu.noData")))
menuInfo := s.sysMenuService.FindById(body.MenuId)
if menuInfo.MenuId != body.MenuId {
// c.JSON(200, resp.ErrMsg("没有权限访问菜单数据"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "menu.noData")))
return
}
// 父级ID不为0是要检查
if body.ParentID != "0" {
menuParent := s.sysMenuService.SelectMenuById(body.ParentID)
if menuParent.MenuID != body.ParentID {
// 没有可访问菜单数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "menu.noData")))
if body.ParentId > 0 {
menuParent := s.sysMenuService.FindById(body.ParentId)
if menuParent.MenuId != body.ParentId {
// c.JSON(200, resp.ErrMsg("没有权限访问菜单数据"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "menu.noData")))
return
}
// 禁用菜单时检查父菜单是否使用
if body.Status == common.STATUS_YES && menuParent.Status == common.STATUS_NO {
// 上级菜单未启用！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "menu.errParentStatus")))
if body.StatusFlag == constants.STATUS_YES && menuParent.StatusFlag == constants.STATUS_NO {
// c.JSON(200, resp.ErrMsg("上级菜单未启用！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "menu.errParentStatus")))
return
}
}
// 目录和菜单检查地址唯一
if menu.TYPE_DIR == body.MenuType || menu.TYPE_MENU == body.MenuType {
uniqueNenuPath := s.sysMenuService.CheckUniqueMenuPath(body.Path, body.ParentID, body.MenuID)
if !uniqueNenuPath {
// 菜单修改【%s】失败，菜单路由地址已存在
if constants.MENU_TYPE_DIR == body.MenuType || constants.MENU_TYPE_MENU == body.MenuType {
uniqueMenuPath := s.sysMenuService.CheckUniqueParentIdByMenuPath(body.ParentId, body.MenuPath, body.MenuId)
if !uniqueMenuPath {
// msg := fmt.Sprintf("菜单修改【%s】失败，菜单路由地址已存在", body.MenuName)
msg := i18n.TTemplate(language, "menu.errPathExists", map[string]any{"name": body.MenuName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
}
// 检查名称唯一
uniqueNenuName := s.sysMenuService.CheckUniqueMenuName(body.MenuName, body.ParentID, body.MenuID)
if !uniqueNenuName {
// 菜单修改【%s】失败，菜单名称已存在
uniqueMenuName := s.sysMenuService.CheckUniqueParentIdByMenuName(body.ParentId, body.MenuName, body.MenuId)
if !uniqueMenuName {
// msg := fmt.Sprintf("菜单修改【%s】失败，菜单名称已存在", body.MenuName)
msg := i18n.TTemplate(language, "menu.errNameExists", map[string]any{"name": body.MenuName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 外链菜单需要符合网站http(s)开头
if body.IsFrame == common.STATUS_NO && !regular.ValidHttp(body.Path) {
// 菜单修改【%s】失败，非内部地址必须以http(s)://开头
if body.FrameFlag == constants.STATUS_NO && !regular.ValidHttp(body.MenuPath) {
// msg := fmt.Sprintf("菜单修改【%s】失败，非内部地址必须以http(s)://开头", body.MenuName)
msg := i18n.TTemplate(language, "menu.errFramePath", map[string]any{"name": body.MenuName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 禁用菜单时检查子菜单是否使用
if body.Status == common.STATUS_NO {
hasStatus := s.sysMenuService.HasChildByMenuIdAndStatus(body.MenuID, common.STATUS_YES)
if body.StatusFlag == constants.STATUS_NO {
hasStatus := s.sysMenuService.ExistChildrenByMenuIdAndStatus(body.MenuId, constants.STATUS_YES)
if hasStatus > 0 {
// 操作菜单【%s】失败，存在使用子菜单数：%d
// msg := fmt.Sprintf("不允许禁用，存在使用子菜单数：%d", hasStatus)
msg := i18n.TTemplate(language, "menu.errHasChildUse", map[string]any{"name": body.MenuName, "num": hasStatus})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
}
@@ -230,91 +239,104 @@ func (s *SysMenuController) Edit(c *gin.Context) {
// 多语言非原始值
i18nValue := i18n.TKey(language, menuInfo.MenuName)
if i18nValue != menuInfo.MenuName {
i18n.UpdateKeyValue(language, menuInfo.MenuName, body.MenuName)
service.NewSysI18n.UpdateKeyValue(language, menuInfo.MenuName, body.MenuName)
body.MenuName = menuInfo.MenuName
}
// 多语言非原始值
i18nValue2 := i18n.TKey(language, menuInfo.Remark)
if i18nValue2 != menuInfo.Remark {
i18n.UpdateKeyValue(language, menuInfo.Remark, body.Remark)
service.NewSysI18n.UpdateKeyValue(language, menuInfo.Remark, body.Remark)
body.Remark = menuInfo.Remark
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysMenuService.UpdateMenu(body)
menuInfo.ParentId = body.ParentId
menuInfo.MenuName = body.MenuName
menuInfo.MenuType = body.MenuType
menuInfo.MenuSort = body.MenuSort
menuInfo.MenuPath = body.MenuPath
menuInfo.Component = body.Component
menuInfo.FrameFlag = body.FrameFlag
menuInfo.CacheFlag = body.CacheFlag
menuInfo.VisibleFlag = body.VisibleFlag
menuInfo.StatusFlag = body.StatusFlag
menuInfo.Perms = body.Perms
menuInfo.Icon = body.Icon
menuInfo.Remark = body.Remark
menuInfo.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysMenuService.Update(menuInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 菜单删除
// Remove 菜单删除
//
// DELETE /:menuId
func (s *SysMenuController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
menuId := c.Param("menuId")
if menuId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
func (s SysMenuController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
menuId := parse.Number(c.Param("menuId"))
if menuId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: menuId is empty"))
return
}
// 检查数据是否存在
menu := s.sysMenuService.SelectMenuById(menuId)
if menu.MenuID != menuId {
// 没有可访问菜单数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "menu.noData")))
menu := s.sysMenuService.FindById(menuId)
if menu.MenuId != menuId {
// c.JSON(200, resp.ErrMsg("没有权限访问菜单数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "menu.noData")))
return
}
// 检查是否存在子菜单
hasChild := s.sysMenuService.HasChildByMenuIdAndStatus(menuId, "")
hasChild := s.sysMenuService.ExistChildrenByMenuIdAndStatus(menuId, "")
if hasChild > 0 {
// 不允许删除，存在子菜单数：%d
// msg := fmt.Sprintf("不允许删除，存在子菜单数：%d", hasChild)
msg := i18n.TTemplate(language, "menu.errHasChildUse", map[string]any{"name": menu.MenuName, "num": hasChild})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查是否分配给角色
existRole := s.sysMenuService.CheckMenuExistRole(menuId)
existRole := s.sysMenuService.ExistRoleByMenuId(menuId)
if existRole > 0 {
// 不允许删除，菜单已分配给角色数：%d
// msg := fmt.Sprintf("不允许删除，菜单已分配给角色数：%d", existRole)
msg := i18n.TTemplate(language, "menu.errHasRoleUse", map[string]any{"name": menu.MenuName, "num": existRole})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
rows := s.sysMenuService.DeleteMenuById(menuId)
rows := s.sysMenuService.DeleteById(menuId)
if rows > 0 {
// msg := fmt.Sprintf("删除成功：%d", rows)
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 菜单树结构列表
//
// GET /treeSelect
func (s *SysMenuController) TreeSelect(c *gin.Context) {
// GET /tree
func (s *SysMenuController) Tree(c *gin.Context) {
query := model.SysMenu{}
if v, ok := c.GetQuery("menuName"); ok && v != "" {
if v, ok := c.GetQuery("menuName"); ok {
query.MenuName = v
}
if v, ok := c.GetQuery("status"); ok && v != "" {
query.Status = v
if v, ok := c.GetQuery("statusFlag"); ok {
query.StatusFlag = v
}
userId := ctx.LoginUserToUserID(c)
if config.IsAdmin(userId) {
userId = "*"
userId := reqctx.LoginUserToUserID(c)
if config.IsSystemUser(userId) {
userId = 0
}
data := s.sysMenuService.SelectMenuTreeSelectByUserId(query, userId)
trees := s.sysMenuService.BuildTreeSelectByUserId(query, userId)
// 闭包函数处理多语言
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var converI18n func(language string, arr *[]vo.TreeSelect)
converI18n = func(language string, arr *[]vo.TreeSelect) {
for i := range *arr {
@@ -324,37 +346,37 @@ func (s *SysMenuController) TreeSelect(c *gin.Context) {
}
}
}
converI18n(language, &data)
converI18n(language, &trees)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(trees))
}
// 菜单树结构列表（指定角色）
//
// GET /roleMenuTreeSelect/:roleId
func (s *SysMenuController) RoleMenuTreeSelect(c *gin.Context) {
language := ctx.AcceptLanguage(c)
roleId := c.Param("roleId")
if roleId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// GET /tree/role/:roleId
func (s *SysMenuController) TreeRole(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
roleId := parse.Number(c.Param("roleId"))
if roleId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: roleId is empty"))
return
}
query := model.SysMenu{}
if v, ok := c.GetQuery("menuName"); ok && v != "" {
query.MenuName = v
sysMenu := model.SysMenu{}
if v, ok := c.GetQuery("menuName"); ok {
sysMenu.MenuName = v
}
if v, ok := c.GetQuery("status"); ok && v != "" {
query.Status = v
if v, ok := c.GetQuery("statusFlag"); ok {
sysMenu.StatusFlag = v
}
userId := ctx.LoginUserToUserID(c)
if config.IsAdmin(userId) {
userId = "*"
userId := reqctx.LoginUserToUserID(c)
if config.IsSystemUser(userId) {
userId = 0
}
menuTreeSelect := s.sysMenuService.SelectMenuTreeSelectByUserId(query, userId)
checkedKeys := s.sysMenuService.SelectMenuListByRoleId(roleId)
menuTreeSelect := s.sysMenuService.BuildTreeSelectByUserId(sysMenu, userId)
checkedKeys := s.sysMenuService.FindByRoleId(roleId)
// 闭包函数处理多语言
var converI18n func(language string, arr *[]vo.TreeSelect)
@@ -368,7 +390,7 @@ func (s *SysMenuController) RoleMenuTreeSelect(c *gin.Context) {
}
converI18n(language, &menuTreeSelect)
c.JSON(200, result.OkData(map[string]any{
c.JSON(200, resp.OkData(map[string]any{
"menus": menuTreeSelect,
"checkedKeys": checkedKeys,
}))

187
src/modules/system/controller/sys_post.go
View File

@@ -3,33 +3,30 @@ package controller
import (
"fmt"
"strconv"
"strings"
"time"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysPostController 结构体
var NewSysPost = &SysPostController{
sysPostService: service.NewSysPostImpl,
sysPostService: service.NewSysPost,
}
// 岗位信息
//
// PATH /system/post
type SysPostController struct {
// 岗位服务
sysPostService service.ISysPost
sysPostService *service.SysPost // 岗位服务
}
// 岗位列表
@@ -48,15 +45,14 @@ type SysPostController struct {
// @Description Post Information List
// @Router /system/post/list [get]
func (s *SysPostController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
querys := ctx.QueryMap(c)
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 多语言值转key查询
if v, ok := querys["postName"]; ok && v != "" {
querys["postName"] = i18n.TFindKeyPrefix(language, "post", v.(string))
if v, ok := query["postName"]; ok && v != "" {
query["postName"] = i18n.TFindKeyPrefix(language, "post", v)
}
data := s.sysPostService.SelectPostPage(querys)
rows := data["rows"].([]model.SysPost)
rows, total := s.sysPostService.FindByPage(query)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysPost) {
@@ -67,171 +63,184 @@ func (s *SysPostController) List(c *gin.Context) {
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 岗位信息
// Info 岗位信息
//
// GET /:postId
func (s *SysPostController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
postId := c.Param("postId")
if postId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
postId := parse.Number(c.Param("postId"))
if postId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: postId is empty"))
return
}
data := s.sysPostService.SelectPostById(postId)
if data.PostID == postId {
data := s.sysPostService.FindById(postId)
if data.PostId == postId {
// 处理多语言
data.PostName = i18n.TKey(language, data.PostName)
data.Remark = i18n.TKey(language, data.Remark)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 岗位新增
// Add 岗位新增
//
// POST /
func (s *SysPostController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysPost
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.PostID != "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.PostId > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: postId not is empty"))
return
}
// 检查名称唯一
uniqueuPostName := s.sysPostService.CheckUniquePostName(body.PostName, "")
if !uniqueuPostName {
// 岗位新增【%s】失败，岗位名称已存在
uniqueuName := s.sysPostService.CheckUniqueByName(body.PostName, 0)
if !uniqueuName {
// msg := fmt.Sprintf("岗位新增【%s】失败，岗位名称已存在", body.PostName)
msg := i18n.TTemplate(language, "post.errNameExists", map[string]any{"name": body.PostName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查编码属性值唯一
uniquePostCode := s.sysPostService.CheckUniquePostCode(body.PostCode, "")
if !uniquePostCode {
// 岗位新增【%s】失败，岗位编码已存在
uniqueCode := s.sysPostService.CheckUniqueByCode(body.PostCode, 0)
if !uniqueCode {
// msg := fmt.Sprintf("岗位新增【%s】失败，岗位编码已存在", body.PostCode)
msg := i18n.TTemplate(language, "post.errCodeExists", map[string]any{"name": body.PostCode})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysPostService.InsertPost(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
body.CreateBy = reqctx.LoginUserToUserName(c)
insertId := s.sysPostService.Insert(body)
if insertId > 0 {
c.JSON(200, resp.OkData(insertId))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 岗位修改
//
// PUT /
func (s *SysPostController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysPost
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.PostID == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.PostId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: postId is empty"))
return
}
// 检查是否存在
postInfo := s.sysPostService.SelectPostById(body.PostID)
if postInfo.PostID != body.PostID {
// 没有可访问岗位数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "post.noData")))
postInfo := s.sysPostService.FindById(body.PostId)
if postInfo.PostId != body.PostId {
// c.JSON(200, resp.ErrMsg("没有权限访问岗位数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "post.noData")))
return
}
// 检查名称唯一
uniqueuPostName := s.sysPostService.CheckUniquePostName(body.PostName, body.PostID)
if !uniqueuPostName {
// 岗位修改【%s】失败，岗位名称已存在
uniquePostName := s.sysPostService.CheckUniqueByName(body.PostName, body.PostId)
if !uniquePostName {
// msg := fmt.Sprintf("岗位修改【%s】失败，岗位名称已存在", body.PostName)
msg := i18n.TTemplate(language, "post.errNameExists", map[string]any{"name": body.PostName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 检查编码属性值唯一
uniquePostCode := s.sysPostService.CheckUniquePostCode(body.PostCode, body.PostID)
uniquePostCode := s.sysPostService.CheckUniqueByCode(body.PostCode, body.PostId)
if !uniquePostCode {
// 岗位修改【%s】失败，岗位编码已存在
// msg := fmt.Sprintf("岗位修改【%s】失败，岗位编码已存在", body.PostCode)
msg := i18n.TTemplate(language, "post.errCodeExists", map[string]any{"name": body.PostCode})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 多语言非原始值
i18nValue := i18n.TKey(language, postInfo.PostName)
if i18nValue != postInfo.PostName {
i18n.UpdateKeyValue(language, postInfo.PostName, body.PostName)
service.NewSysI18n.UpdateKeyValue(language, postInfo.PostName, body.PostName)
body.PostName = postInfo.PostName
}
// 多语言非原始值
i18nValue2 := i18n.TKey(language, postInfo.Remark)
if i18nValue2 != postInfo.Remark {
i18n.UpdateKeyValue(language, postInfo.Remark, body.Remark)
service.NewSysI18n.UpdateKeyValue(language, postInfo.Remark, body.Remark)
body.Remark = postInfo.Remark
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysPostService.UpdatePost(body)
postInfo.PostCode = body.PostCode
postInfo.PostName = body.PostName
postInfo.PostSort = body.PostSort
postInfo.StatusFlag = body.StatusFlag
postInfo.Remark = body.Remark
postInfo.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysPostService.Update(postInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 岗位删除
// Remove 岗位删除
//
// DELETE /:postIds
func (s *SysPostController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
postIds := c.Param("postIds")
if postIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// DELETE /:postId
func (s SysPostController) Remove(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
postId := c.Param("postId")
if postId == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: postId is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(postIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(postId, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
rows, err := s.sysPostService.DeletePostByIds(uniqueIDs)
rows, err := s.sysPostService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// msg := fmt.Sprintf("删除成功：%d", rows)
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
}
// 导出岗位信息
//
// POST /export
func (s *SysPostController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
data := s.sysPostService.SelectPostPage(querys)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
query := reqctx.QueryMap(c)
rows, total := s.sysPostService.FindByPage(query)
if total == 0 {
// c.JSON(200, resp.CodeMsg(40016, "export data record as empty"))
c.JSON(200, resp.CodeMsg(40016, i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysPost)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysPost) {
@@ -258,11 +267,11 @@ func (s *SysPostController) Export(c *gin.Context) {
for i, row := range rows {
idx := strconv.Itoa(i + 2)
statusValue := i18n.TKey(language, "dictData.disable")
if row.Status == "1" {
if row.StatusFlag == "1" {
statusValue = i18n.TKey(language, "dictData.normal")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.PostID,
"A" + idx: row.PostId,
"B" + idx: row.PostName,
"C" + idx: row.PostCode,
"D" + idx: row.PostSort,
@@ -274,7 +283,7 @@ func (s *SysPostController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

269
src/modules/system/controller/sys_profile.go
View File

@@ -1,44 +1,36 @@
package controller
import (
"be.ems/src/framework/config"
"be.ems/src/framework/constants/admin"
"be.ems/src/framework/constants/uploadsubpath"
"fmt"
"be.ems/src/framework/i18n"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/token"
"be.ems/src/framework/utils/crypto"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/regular"
"be.ems/src/framework/utils/token"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysProfileController 结构体
var NewSysProfile = &SysProfileController{
sysUserService: service.NewSysUserImpl,
sysRoleService: service.NewSysRoleImpl,
sysPostService: service.NewSysPostImpl,
sysMenuService: service.NewSysMenuImpl,
sysUserService: service.NewSysUser,
sysRoleService: service.NewSysRole,
sysPostService: service.NewSysPost,
sysMenuService: service.NewSysMenu,
}
// 个人信息
//
// PATH /system/user/profile
type SysProfileController struct {
// 用户服务
sysUserService service.ISysUser
// 角色服务
sysRoleService service.ISysRole
// 岗位服务
sysPostService service.ISysPost
// 菜单服务
sysMenuService service.ISysMenu
sysUserService *service.SysUser // 用户服务
sysRoleService *service.SysRole // 角色服务
sysPostService *service.SysPost // 岗位服务
sysMenuService *service.SysMenu // 菜单服务
}
// 个人信息
@@ -54,27 +46,23 @@ type SysProfileController struct {
// @Description Personal Information
// @Router /system/user/profile [get]
func (s *SysProfileController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
loginUser, err := ctx.LoginUser(c)
language := reqctx.AcceptLanguage(c)
loginUser, err := reqctx.LoginUser(c)
if err != nil {
c.JSON(401, result.CodeMsg(401, i18n.TKey(language, err.Error())))
c.JSON(401, resp.CodeMsg(401, i18n.TKey(language, err.Error())))
return
}
// 查询用户所属角色组
roleGroup := []string{}
roles := s.sysRoleService.SelectRoleListByUserId(loginUser.UserID)
roles := s.sysRoleService.FindByUserId(loginUser.User.UserId)
for _, role := range roles {
roleGroup = append(roleGroup, i18n.TKey(language, role.RoleName))
}
isAdmin := config.IsAdmin(loginUser.UserID)
if isAdmin {
roleGroup = append(roleGroup, i18n.TKey(language, "role.system"))
}
// 查询用户所属岗位组
postGroup := []string{}
posts := s.sysPostService.SelectPostListByUserId(loginUser.UserID)
posts := s.sysPostService.FindByUserId(loginUser.User.UserId)
for _, post := range posts {
postGroup = append(postGroup, i18n.TKey(language, post.PostName))
}
@@ -85,7 +73,7 @@ func (s *SysProfileController) Info(c *gin.Context) {
for ri := range loginUser.User.Roles {
loginUser.User.Roles[ri].RoleName = i18n.TKey(language, loginUser.User.Roles[ri].RoleName)
}
c.JSON(200, result.OkData(map[string]any{
c.JSON(200, resp.OkData(map[string]any{
"user": loginUser.User,
"roleGroup": parse.RemoveDuplicates(roleGroup),
"postGroup": parse.RemoveDuplicates(postGroup),
@@ -106,46 +94,43 @@ func (s *SysProfileController) Info(c *gin.Context) {
// @Description Personal Information Modification
// @Router /system/user/profile [put]
func (s *SysProfileController) UpdateProfile(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
// 昵称
NickName string `json:"nickName" binding:"required"`
// 性别
Sex string `json:"sex" binding:"required"`
// 手机号
PhoneNumber string `json:"phonenumber"`
// 邮箱
Email string `json:"email"`
NickName string `json:"nickName" binding:"required"` // 昵称
Sex string `json:"sex" binding:"required,oneof=0 1 2"` // 性别
Phone string `json:"phone"` // 手机号
Email string `json:"email"` // 邮箱
Avatar string `json:"avatar"` // 头像地址
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.Sex == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 登录用户信息
loginUser, err := ctx.LoginUser(c)
loginUser, err := reqctx.LoginUser(c)
if err != nil {
c.JSON(401, result.CodeMsg(401, i18n.TKey(language, err.Error())))
c.JSON(401, resp.CodeMsg(401, i18n.TKey(language, err.Error())))
return
}
userId := loginUser.UserID
userId := loginUser.UserId
userName := loginUser.User.UserName
// 检查手机号码格式并判断是否唯一
if body.PhoneNumber != "" {
if regular.ValidMobile(body.PhoneNumber) {
uniquePhone := s.sysUserService.CheckUniquePhone(body.PhoneNumber, userId)
if body.Phone != "" {
if regular.ValidMobile(body.Phone) {
uniquePhone := s.sysUserService.CheckUniqueByPhone(body.Phone, userId)
if !uniquePhone {
// 修改用户【%s】失败，手机号码已存在
// c.JSON(200, resp.CodeMsg(40018, "抱歉，手机号码已存在"))
msg := i18n.TTemplate(language, "user.errPhoneExists", map[string]any{"name": userName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
} else {
// 修改用户【%s】失败，手机号码格式错误
// c.JSON(200, resp.CodeMsg(40018, "抱歉，手机号码格式错误"))
msg := i18n.TTemplate(language, "user.errPhoneFormat", map[string]any{"name": userName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
}
@@ -153,55 +138,53 @@ func (s *SysProfileController) UpdateProfile(c *gin.Context) {
// 检查邮箱格式并判断是否唯一
if body.Email != "" {
if regular.ValidEmail(body.Email) {
uniqueEmail := s.sysUserService.CheckUniqueEmail(body.Email, userId)
uniqueEmail := s.sysUserService.CheckUniqueByEmail(body.Email, userId)
if !uniqueEmail {
// 修改用户【%s】失败，邮箱已存在
// c.JSON(200, resp.CodeMsg(40019, "抱歉，邮箱已存在"))
msg := i18n.TTemplate(language, "user.errEmailExists", map[string]any{"name": userName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
} else {
// 修改用户【%s】失败，邮箱格式错误
// c.JSON(200, resp.CodeMsg(40019, "抱歉，邮箱格式错误"))
msg := i18n.TTemplate(language, "user.errEmailFormat", map[string]any{"name": userName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
}
// 用户基本资料
sysUser := model.SysUser{
UserID: userId,
UpdateBy: userName,
NickName: body.NickName,
PhoneNumber: body.PhoneNumber,
Email: body.Email,
Sex: body.Sex,
Remark: loginUser.User.Remark,
// 查询当前登录用户信息
userInfo := s.sysUserService.FindById(userId)
if userInfo.UserId != userId {
// c.JSON(200, resp.ErrMsg("没有权限访问用户数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "user.noData")))
return
}
rows := s.sysUserService.UpdateUser(sysUser)
// 用户基本资料
userInfo.NickName = body.NickName
userInfo.Phone = body.Phone
userInfo.Email = body.Email
userInfo.Sex = body.Sex
userInfo.Avatar = body.Avatar
userInfo.Password = "" // 密码不更新
userInfo.UpdateBy = userInfo.UserName
rows := s.sysUserService.Update(userInfo)
if rows > 0 {
// 更新缓存用户信息
loginUser.User = s.sysUserService.SelectUserByUserName(userName)
// 用户权限组标识
isAdmin := config.IsAdmin(sysUser.UserID)
if isAdmin {
loginUser.Permissions = []string{admin.PERMISSION}
} else {
perms := s.sysMenuService.SelectMenuPermsByUserId(sysUser.UserID)
loginUser.Permissions = parse.RemoveDuplicates(perms)
}
loginUser.User = userInfo
// 刷新令牌信息
token.Cache(&loginUser)
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.ErrMsg("Modification of personal information exception"))
}
// 个人重置密码
//
// PUT /updatePwd
// PUT /password
//
// @Tags system/user/profile
// @Accept json
@@ -212,131 +195,55 @@ func (s *SysProfileController) UpdateProfile(c *gin.Context) {
// @Summary Personal Reset Password
// @Description Personal Reset Password
// @Router /system/user/profile/updatePwd [put]
func (s *SysProfileController) UpdatePwd(c *gin.Context) {
language := ctx.AcceptLanguage(c)
func (s *SysProfileController) UpdatePassword(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
// 旧密码
OldPassword string `json:"oldPassword" binding:"required"`
// 新密码
NewPassword string `json:"newPassword" binding:"required"`
OldPassword string `json:"oldPassword" binding:"required"` // 旧密码
NewPassword string `json:"newPassword" binding:"required"` // 新密码
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 登录用户信息
loginUser, err := ctx.LoginUser(c)
loginUser, err := reqctx.LoginUser(c)
if err != nil {
c.JSON(401, result.CodeMsg(401, i18n.TKey(language, err.Error())))
c.JSON(401, resp.CodeMsg(401, i18n.TKey(language, err.Error())))
return
}
userId := loginUser.UserID
userName := loginUser.User.UserName
userId := loginUser.UserId
// 查询当前登录用户信息得到密码值
user := s.sysUserService.SelectUserById(userId)
if user.UserID != userId {
// 没有可访问用户数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "user.noData")))
userInfo := s.sysUserService.FindById(userId)
if userInfo.UserId != userId {
// c.JSON(200, resp.ErrMsg("没有权限访问用户数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "user.noData")))
return
}
// 检查匹配用户密码
oldCompare := crypto.BcryptCompare(body.OldPassword, user.Password)
oldCompare := crypto.BcryptCompare(body.OldPassword, userInfo.Password)
if !oldCompare {
// 修改密码失败，旧密码错误
c.JSON(200, result.ErrMsg(i18n.TKey(language, "user.errPasswdOld")))
// c.JSON(200, resp.ErrMsg("修改密码失败，旧密码错误"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "user.errPasswdOld")))
return
}
newCompare := crypto.BcryptCompare(body.NewPassword, user.Password)
newCompare := crypto.BcryptCompare(body.NewPassword, userInfo.Password)
if newCompare {
// 新密码不能与旧密码相同
c.JSON(200, result.ErrMsg(i18n.TKey(language, "user.errPasswdEqOld")))
// c.JSON(200, resp.ErrMsg("新密码不能与旧密码相同"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "user.errPasswdEqOld")))
return
}
// 修改新密码
sysUser := model.SysUser{
UserID: userId,
UpdateBy: userName,
Password: body.NewPassword,
Sex: user.Sex,
PhoneNumber: user.PhoneNumber,
Email: user.Email,
Remark: user.Remark,
}
rows := s.sysUserService.UpdateUser(sysUser)
userInfo.Password = body.NewPassword
userInfo.UpdateBy = userInfo.UserName
rows := s.sysUserService.Update(userInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 个人头像上传
//
// POST /avatar
//
// @Tags system/user/profile
// @Accept multipart/form-data
// @Produce json
// @Param file formData file true "The file to upload."
// @Success 200 {object} object "Response Results"
// @Security TokenAuth
// @Summary Personal avatar upload
// @Description Personal avatar upload
// @Router /system/user/profile/avatar [post]
func (s *SysProfileController) Avatar(c *gin.Context) {
language := ctx.AcceptLanguage(c)
formFile, err := c.FormFile("file")
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
return
}
// 上传文件转存
filePath, err := file.TransferUploadFile(formFile, uploadsubpath.AVATART, []string{".jpg", ".jpeg", ".png"})
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
// 登录用户信息
loginUser, err := ctx.LoginUser(c)
if err != nil {
c.JSON(401, result.CodeMsg(401, i18n.TKey(language, err.Error())))
return
}
// 更新头像地址
sysUser := model.SysUser{
UserID: loginUser.UserID,
UpdateBy: loginUser.User.UserName,
Avatar: filePath,
Sex: loginUser.User.Sex,
PhoneNumber: loginUser.User.PhoneNumber,
Email: loginUser.User.Email,
Remark: loginUser.User.Remark,
}
rows := s.sysUserService.UpdateUser(sysUser)
if rows > 0 {
// 更新缓存用户信息
loginUser.User = s.sysUserService.SelectUserByUserName(loginUser.User.UserName)
// 用户权限组标识
isAdmin := config.IsAdmin(sysUser.UserID)
if isAdmin {
loginUser.Permissions = []string{admin.PERMISSION}
} else {
perms := s.sysMenuService.SelectMenuPermsByUserId(sysUser.UserID)
loginUser.Permissions = parse.RemoveDuplicates(perms)
}
// 刷新令牌信息
token.Cache(&loginUser)
c.JSON(200, result.OkData(filePath))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}

413
src/modules/system/controller/sys_role.go
View File

@@ -3,39 +3,33 @@ package controller
import (
"fmt"
"strconv"
"strings"
"time"
"be.ems/src/framework/constants/admin"
"be.ems/src/framework/constants"
"be.ems/src/framework/i18n"
"be.ems/src/framework/utils/ctx"
"be.ems/src/framework/reqctx"
"be.ems/src/framework/resp"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/vo/result"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysRoleController 结构体
var NewSysRole = &SysRoleController{
sysRoleService: service.NewSysRoleImpl,
sysUserService: service.NewSysUserImpl,
sysDictDataService: service.NewSysDictData,
sysRoleService: service.NewSysRole,
sysUserService: service.NewSysUser,
}
// 角色信息
//
// PATH /system/role
type SysRoleController struct {
// 角色服务
sysRoleService service.ISysRole
// 用户服务
sysUserService service.ISysUser
sysDictDataService *service.SysDictData // 字典数据服务
sysRoleService *service.SysRole // 角色服务
sysUserService *service.SysUser // 用户服务
}
// 角色列表
@@ -54,16 +48,13 @@ type SysRoleController struct {
// @Description Role Information List
// @Router /system/role/list [get]
func (s *SysRoleController) List(c *gin.Context) {
language := ctx.AcceptLanguage(c)
querys := ctx.QueryMap(c)
language := reqctx.AcceptLanguage(c)
query := reqctx.QueryMap(c)
// 多语言值转key查询
if v, ok := querys["roleName"]; ok && v != "" {
querys["roleName"] = i18n.TFindKeyPrefix(language, "role", v.(string))
if v, ok := query["roleName"]; ok && v != "" {
query["roleName"] = i18n.TFindKeyPrefix(language, "role", v)
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysRoleService.SelectRolePage(querys, dataScopeSQL)
rows := data["rows"].([]model.SysRole)
rows, total := s.sysRoleService.FindByPage(query)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysRole) {
@@ -74,367 +65,363 @@ func (s *SysRoleController) List(c *gin.Context) {
}
converI18n(language, &rows)
c.JSON(200, result.Ok(data))
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 角色信息详情
//
// GET /:roleId
func (s *SysRoleController) Info(c *gin.Context) {
language := ctx.AcceptLanguage(c)
roleId := c.Param("roleId")
if roleId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
roleId := parse.Number(c.Param("roleId"))
if roleId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: roleId is empty"))
return
}
data := s.sysRoleService.SelectRoleById(roleId)
if data.RoleID == roleId {
data := s.sysRoleService.FindById(roleId)
if data.RoleId == roleId {
data.RoleName = i18n.TKey(language, data.RoleName)
data.Remark = i18n.TKey(language, data.Remark)
c.JSON(200, result.OkData(data))
c.JSON(200, resp.OkData(data))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 角色信息新增
//
// POST /
func (s *SysRoleController) Add(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysRole
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.RoleID != "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.RoleId > 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: roleId not is empty"))
return
}
// 判断角色名称是否唯一
uniqueRoleName := s.sysRoleService.CheckUniqueRoleName(body.RoleName, "")
if !uniqueRoleName {
// 角色新增【%s】失败，角色名称已存在
uniqueName := s.sysRoleService.CheckUniqueByName(body.RoleName, 0)
if !uniqueName {
// msg := fmt.Sprintf("角色新增【%s】失败，角色名称已存在", body.RoleName)
msg := i18n.TTemplate(language, "role.errNameExists", map[string]any{"name": body.RoleName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 判断角色键值是否唯一
uniqueRoleKey := s.sysRoleService.CheckUniqueRoleKey(body.RoleKey, "")
if !uniqueRoleKey {
// 角色新增【%s】失败，角色键值已存在
uniqueKey := s.sysRoleService.CheckUniqueByKey(body.RoleKey, 0)
if !uniqueKey {
// msg := fmt.Sprintf("角色新增【%s】失败，角色键值已存在", body.RoleName)
msg := i18n.TTemplate(language, "role.errKeyExists", map[string]any{"name": body.RoleName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysRoleService.InsertRole(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
body.CreateBy = reqctx.LoginUserToUserName(c)
insertId := s.sysRoleService.Insert(body)
if insertId > 0 {
c.JSON(200, resp.OkData(insertId))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 角色信息修改
//
// PUT /
func (s *SysRoleController) Edit(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body model.SysRole
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.RoleID == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
if body.RoleId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: roleId is empty"))
return
}
// 检查是否管理员角色
if body.RoleID == admin.ROLE_ID {
// 不允许操作管理员角色
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.errOperateRole")))
// 检查是否系统管理员角色
if body.RoleId == constants.SYS_ROLE_SYSTEM_ID {
// c.JSON(200, resp.ErrMsg("不允许操作系统管理员角色"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.errOperateRole")))
return
}
// 检查是否存在
roleInfo := s.sysRoleService.SelectRoleById(body.RoleID)
if roleInfo.RoleID != body.RoleID {
// 没有可访问角色数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "role.noData")))
roleInfo := s.sysRoleService.FindById(body.RoleId)
if roleInfo.RoleId != body.RoleId {
// c.JSON(200, resp.ErrMsg("没有权限访问角色数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "role.noData")))
return
}
// 判断角色名称是否唯一
uniqueRoleName := s.sysRoleService.CheckUniqueRoleName(body.RoleName, body.RoleID)
if !uniqueRoleName {
// 操作角色【%s】失败，角色名称已存在
// msg := fmt.Sprintf("Character modification [%s] failed, character name already exists", body.RoleName)
uniqueName := s.sysRoleService.CheckUniqueByName(body.RoleName, body.RoleId)
if !uniqueName {
// msg := fmt.Sprintf("角色修改【%s】失败，角色名称已存在", body.RoleName)
msg := i18n.TTemplate(language, "role.errNameExists", map[string]any{"name": body.RoleName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 判断角色键值是否唯一
uniqueRoleKey := s.sysRoleService.CheckUniqueRoleKey(body.RoleKey, body.RoleID)
if !uniqueRoleKey {
// 角色修改【%s】失败，角色键值已存在
// msg := fmt.Sprintf("Character modification [%s] failed, character key already exists", body.RoleName)
uniqueKey := s.sysRoleService.CheckUniqueByKey(body.RoleKey, body.RoleId)
if !uniqueKey {
// msg := fmt.Sprintf("角色修改【%s】失败，角色键值已存在", body.RoleName)
msg := i18n.TTemplate(language, "role.errKeyExists", map[string]any{"name": body.RoleName})
c.JSON(200, result.ErrMsg(msg))
c.JSON(200, resp.ErrMsg(msg))
return
}
// 多语言非原始值
i18nValue := i18n.TKey(language, roleInfo.RoleName)
if i18nValue != roleInfo.RoleName {
i18n.UpdateKeyValue(language, roleInfo.RoleName, body.RoleName)
service.NewSysI18n.UpdateKeyValue(language, roleInfo.RoleName, body.RoleName)
body.RoleName = roleInfo.RoleName
}
// 多语言非原始值
i18nValue2 := i18n.TKey(language, roleInfo.Remark)
if i18nValue2 != roleInfo.Remark {
i18n.UpdateKeyValue(language, roleInfo.Remark, body.Remark)
service.NewSysI18n.UpdateKeyValue(language, roleInfo.Remark, body.Remark)
body.Remark = roleInfo.Remark
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysRoleService.UpdateRole(body)
roleInfo.Remark = body.Remark
roleInfo.RoleName = body.RoleName
roleInfo.RoleKey = body.RoleKey
roleInfo.RoleSort = body.RoleSort
roleInfo.DataScope = body.DataScope
roleInfo.MenuCheckStrictly = body.MenuCheckStrictly
roleInfo.DeptCheckStrictly = body.DeptCheckStrictly
roleInfo.StatusFlag = body.StatusFlag
roleInfo.UpdateBy = reqctx.LoginUserToUserName(c)
roleInfo.MenuIds = body.MenuIds
roleInfo.DeptIds = body.DeptIds
rows := s.sysRoleService.Update(roleInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 角色信息删除
// Remove 角色信息删除
//
// DELETE /:roleIds
// DELETE /:roleId
func (s *SysRoleController) Remove(c *gin.Context) {
language := ctx.AcceptLanguage(c)
roleIds := c.Param("roleIds")
if roleIds == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
language := reqctx.AcceptLanguage(c)
roleId := c.Param("roleId")
if roleId == "" {
c.JSON(400, resp.CodeMsg(40010, "bind err: roleId is empty"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(roleIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
uniqueIDs := parse.RemoveDuplicatesToArray(roleId, ",")
// 转换成int64数组类型
ids := make([]int64, 0)
for _, v := range uniqueIDs {
ids = append(ids, parse.Number(v))
}
// 检查是否管理员角色
for _, id := range uniqueIDs {
if id == admin.ROLE_ID {
// 不允许操作管理员角色
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.errOperateRole")))
// 检查是否系统管理员角色
for _, id := range ids {
if id == constants.SYS_ROLE_SYSTEM_ID {
// c.JSON(200, resp.ErrMsg("不允许操作系统管理员角色"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.errOperateRole")))
return
}
}
rows, err := s.sysRoleService.DeleteRoleByIds(uniqueIDs)
rows, err := s.sysRoleService.DeleteByIds(ids)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}
// msg := fmt.Sprintf("删除成功：%d", rows)
msg := i18n.TTemplate(language, "app.common.deleteSuccess", map[string]any{"num": rows})
c.JSON(200, result.OkMsg(msg))
c.JSON(200, resp.OkMsg(msg))
}
// 角色状态变更
// Status 角色状态变更
//
// PUT /changeStatus
func (s *SysRoleController) Status(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// PUT /status
func (s SysRoleController) Status(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
// 角色ID
RoleID string `json:"roleId" binding:"required"`
// 状态
Status string `json:"status" binding:"required"`
RoleID int64 `json:"roleId" binding:"required"` // 角色ID
StatusFlag string `json:"statusFlag" binding:"required,oneof=0 1"` // 状态
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 检查是否管理员角色
if body.RoleID == admin.ROLE_ID {
// 不允许操作管理员角色
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.errOperateRole")))
// 检查是否系统管理员角色
if body.RoleID == constants.SYS_ROLE_SYSTEM_ID {
// c.JSON(200, resp.ErrMsg("不允许操作系统管理员角色"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.errOperateRole")))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(body.RoleID)
if role.RoleID != body.RoleID {
// 没有可访问角色数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "role.noData")))
role := s.sysRoleService.FindById(body.RoleID)
if role.RoleId != body.RoleID {
// c.JSON(200, resp.ErrMsg("没有权限访问角色数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "role.noData")))
return
}
// 与旧值相等不变更
if role.Status == body.Status {
// 变更状态与旧值相等！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "role.statusEq")))
if role.StatusFlag == body.StatusFlag {
// c.JSON(200, resp.ErrMsg("变更状态与旧值相等！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "role.statusEq")))
return
}
// 更新状态不刷新缓存
userName := ctx.LoginUserToUserName(c)
SysRoleController := model.SysRole{
RoleID: body.RoleID,
Status: body.Status,
UpdateBy: userName,
}
rows := s.sysRoleService.UpdateRole(SysRoleController)
role.StatusFlag = body.StatusFlag
role.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysRoleService.Update(role)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 角色数据权限修改
// DataScope 角色数据权限修改
//
// PUT /dataScope
// PUT /data-scope
func (s *SysRoleController) DataScope(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
var body struct {
// 角色ID
RoleID string `json:"roleId"`
// 部门组（数据权限）
DeptIds []string `json:"deptIds"`
// 数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限 5：仅本人数据权限）
DataScope string `json:"dataScope"`
// 部门树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示）
DeptCheckStrictly string `json:"deptCheckStrictly"`
RoleId int64 `json:"roleId" binding:"required"` // 角色ID
DeptIds []int64 `json:"deptIds"` // 部门组（数据权限）
DataScope string `json:"dataScope" binding:"required,oneof=1 2 3 4 5"` // 数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限 5：仅本人数据权限）
DeptCheckStrictly string `json:"deptCheckStrictly" binding:"required,oneof=0 1"` // 部门树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示）
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 检查是否管理员角色
if body.RoleID == admin.ROLE_ID {
// 不允许操作管理员角色
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.errOperateRole")))
// 检查是否系统管理员角色
if body.RoleId == constants.SYS_ROLE_SYSTEM_ID {
// c.JSON(200, resp.ErrMsg("不允许操作系统管理员角色"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "app.common.errOperateRole")))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(body.RoleID)
if role.RoleID != body.RoleID {
// 没有可访问角色数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "role.noData")))
roleInfo := s.sysRoleService.FindById(body.RoleId)
if roleInfo.RoleId != body.RoleId {
// c.JSON(200, resp.ErrMsg("没有权限访问角色数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "role.noData")))
return
}
// 更新数据权限
userName := ctx.LoginUserToUserName(c)
SysRoleController := model.SysRole{
RoleID: body.RoleID,
DeptIds: body.DeptIds,
DataScope: body.DataScope,
DeptCheckStrictly: body.DeptCheckStrictly,
UpdateBy: userName,
}
rows := s.sysRoleService.AuthDataScope(SysRoleController)
roleInfo.DeptIds = body.DeptIds
roleInfo.DataScope = body.DataScope
roleInfo.DeptCheckStrictly = body.DeptCheckStrictly
roleInfo.UpdateBy = reqctx.LoginUserToUserName(c)
rows := s.sysRoleService.UpdateAndDataScope(roleInfo)
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 角色分配用户列表
// UserAuthList 角色分配用户列表
//
// GET /authUser/allocatedList
func (s *SysRoleController) AuthUserAllocatedList(c *gin.Context) {
language := ctx.AcceptLanguage(c)
querys := ctx.QueryMap(c)
roleId, ok := querys["roleId"]
if !ok || roleId == "" {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
// GET /user/list
func (s SysRoleController) UserAuthList(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
roleId := parse.Number(c.Query("roleId"))
if roleId <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: roleId is empty"))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(roleId.(string))
if role.RoleID != roleId {
// 没有可访问角色数据！
c.JSON(200, result.ErrMsg(i18n.TKey(language, "role.noData")))
role := s.sysRoleService.FindById(roleId)
if role.RoleId != roleId {
// c.JSON(200, resp.ErrMsg("没有权限访问角色数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "role.noData")))
return
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "u")
data := s.sysUserService.SelectAllocatedPage(querys, dataScopeSQL)
c.JSON(200, result.Ok(data))
query := reqctx.QueryMap(c)
dataScopeSQL := reqctx.LoginUserToDataScopeSQL(c, "sys_user", "sys_user")
rows, total := s.sysUserService.FindAuthUsersPage(query, dataScopeSQL)
c.JSON(200, resp.OkData(map[string]any{"rows": rows, "total": total}))
}
// 角色分配选择授权
// UserAuthChecked 角色分配选择授权
//
// PUT /authUser/checked
func (s *SysRoleController) AuthUserChecked(c *gin.Context) {
language := ctx.AcceptLanguage(c)
// PUT /user/auth
func (s SysRoleController) UserAuthChecked(c *gin.Context) {
language := reqctx.AcceptLanguage(c)
var body struct {
// 角色ID
RoleID string `json:"roleId" binding:"required"`
// 用户ID组
UserIDs string `json:"userIds" binding:"required"`
// 选择操作 添加true 取消false
Checked bool `json:"checked"`
RoleId int64 `json:"roleId" binding:"required"` // 角色ID
UserIds []int64 `json:"userIds" binding:"required"` // 用户ID组
Auth bool `json:"auth" binding:"required"` // 选择操作 添加true 取消false
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil {
c.JSON(400, result.CodeMsg(400, i18n.TKey(language, "app.common.err400")))
if err := c.ShouldBindBodyWithJSON(&body); err != nil {
errMsgs := fmt.Sprintf("bind err: %s", resp.FormatBindError(err))
c.JSON(422, resp.CodeMsg(40422, errMsgs))
return
}
// 处理字符转id数组后去重
ids := strings.Split(body.UserIDs, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
if len(body.UserIds) <= 0 {
c.JSON(400, resp.CodeMsg(40010, "bind err: userIds is empty"))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(body.RoleID)
if role.RoleID != body.RoleID {
c.JSON(200, result.ErrMsg(i18n.TKey(language, "role.noData")))
role := s.sysRoleService.FindById(body.RoleId)
if role.RoleId != body.RoleId {
// c.JSON(200, resp.ErrMsg("没有权限访问角色数据！"))
c.JSON(200, resp.ErrMsg(i18n.TKey(language, "role.noData")))
return
}
var rows int64
if body.Checked {
rows = s.sysRoleService.InsertAuthUsers(body.RoleID, uniqueIDs)
if body.Auth {
rows = s.sysRoleService.InsertAuthUsers(body.RoleId, body.UserIds)
} else {
rows = s.sysRoleService.DeleteAuthUsers(body.RoleID, uniqueIDs)
rows = s.sysRoleService.DeleteAuthUsers(body.RoleId, body.UserIds)
}
if rows > 0 {
c.JSON(200, result.Ok(nil))
c.JSON(200, resp.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
c.JSON(200, resp.Err(nil))
}
// 导出角色信息
//
// POST /export
func (s *SysRoleController) Export(c *gin.Context) {
language := ctx.AcceptLanguage(c)
language := reqctx.AcceptLanguage(c)
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
querys["pageNum"] = 1
querys["pageSize"] = 10000
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysRoleService.SelectRolePage(querys, dataScopeSQL)
if parse.Number(data["total"]) == 0 {
// 导出数据记录为空
c.JSON(200, result.ErrMsg(i18n.TKey(language, "app.common.exportEmpty")))
query := reqctx.QueryMap(c)
rows, total := s.sysRoleService.FindByPage(query)
if total == 0 {
// c.JSON(200, resp.CodeMsg(40016, "export data record as empty"))
c.JSON(200, resp.CodeMsg(40016, i18n.TKey(language, "app.common.exportEmpty")))
return
}
rows := data["rows"].([]model.SysRole)
// 闭包函数处理多语言
converI18n := func(language string, arr *[]model.SysRole) {
@@ -473,11 +460,11 @@ func (s *SysRoleController) Export(c *gin.Context) {
// }
// 角色状态
statusValue := i18n.TKey(language, "dictData.disable")
if row.Status == "1" {
if row.StatusFlag == "1" {
statusValue = i18n.TKey(language, "dictData.normal")
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.RoleID,
"A" + idx: row.RoleId,
"B" + idx: row.RoleName,
"C" + idx: row.RoleKey,
"D" + idx: row.RoleSort,
@@ -490,7 +477,7 @@ func (s *SysRoleController) Export(c *gin.Context) {
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
c.JSON(200, resp.ErrMsg(err.Error()))
return
}

674
src/modules/system/controller/sys_user.go
View File

File diff suppressed because it is too large Load Diff

38
src/modules/system/model/sys_config.go
View File

@@ -1,25 +1,21 @@
package model
// 参数配置对象 sys_config
// SysConfig 参数配置表
type SysConfig struct {
// 参数主键
ConfigID string `json:"configId"`
// 参数名称
ConfigName string `json:"configName" binding:"required"`
// 参数键名
ConfigKey string `json:"configKey" binding:"required"`
// 参数键值
ConfigValue string `json:"configValue" binding:"required"`
// 系统内置（Y是 N否）
ConfigType string `json:"configType"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
ConfigId int64 `json:"configId" gorm:"column:config_id;primaryKey;autoIncrement"` // 参数ID
ConfigName string `json:"configName" gorm:"column:config_name" binding:"required"` // 参数名称
ConfigKey string `json:"configKey" gorm:"column:config_key" binding:"required"` // 参数键名
ConfigValue string `json:"configValue" gorm:"column:config_value" binding:"required"` // 参数键值
ConfigType string `json:"configType" gorm:"column:config_type"` // 系统内置（Y是 N否）
DelFlag string `json:"-" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Remark string `json:"remark" gorm:"column:remark"` // 备注
}
// TableName 表名称
func (*SysConfig) TableName() string {
return "sys_config"
}

55
src/modules/system/model/sys_dept.go
View File

@@ -1,41 +1,28 @@
package model
// SysDept 部门对象 sys_dept
// SysDept 部门表
type SysDept struct {
// 部门ID
DeptID string `json:"deptId"`
// 父部门ID
ParentID string `json:"parentId" binding:"required"`
// 祖级列表
Ancestors string `json:"ancestors"`
// 部门名称
DeptName string `json:"deptName" binding:"required"`
// 显示顺序
OrderNum int `json:"orderNum"`
// 负责人
Leader string `json:"leader"`
// 联系电话
Phone string `json:"phone"`
// 邮箱
Email string `json:"email"`
// 部门状态（0正常 1停用）
Status string `json:"status"`
// 删除标志（0代表存在 1代表删除）
DelFlag string `json:"delFlag"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
DeptId int64 `json:"deptId" gorm:"column:dept_id;primaryKey;autoIncrement"` // 部门ID
ParentId int64 `json:"parentId" gorm:"column:parent_id" binding:"required"` // 父部门ID 默认0
Ancestors string `json:"ancestors" gorm:"column:ancestors"` // 祖级列表
DeptName string `json:"deptName" gorm:"column:dept_name" binding:"required"` // 部门名称
DeptSort int64 `json:"deptSort" gorm:"column:dept_sort"` // 显示顺序
Leader string `json:"leader" gorm:"column:leader"` // 负责人
Phone string `json:"phone" gorm:"column:phone"` // 联系电话
Email string `json:"email" gorm:"column:email"` // 邮箱
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 部门状态（0停用 1正常）
DelFlag string `json:"-" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
// ====== 非数据库字段属性 ======
// 子部门列表
Children []SysDept `json:"children,omitempty"`
// 父部门名称
ParentName string `json:"parentName,omitempty"`
Children []SysDept `json:"children,omitempty" gorm:"-"` // 子部门列表
}
// TableName 表名称
func (*SysDept) TableName() string {
return "sys_dept"
}

47
src/modules/system/model/sys_dict_data.go
View File

@@ -1,31 +1,24 @@
package model
// SysDictData 字典数据对象 sys_dict_data
// SysDictData 字典数据表
type SysDictData struct {
// 字典编码
DictCode string `json:"dictCode"`
// 字典排序
DictSort int `json:"dictSort"`
// 字典标签
DictLabel string `json:"dictLabel" binding:"required"`
// 字典键值
DictValue string `json:"dictValue" binding:"required"`
// 字典类型
DictType string `json:"dictType" binding:"required"`
// 样式属性（样式扩展）
TagClass string `json:"tagClass"`
// 标签类型（预设颜色）
TagType string `json:"tagType"`
// 状态（0停用 1正常）
Status string `json:"status"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
DataId int64 `json:"dataId" gorm:"column:data_id;primaryKey;autoIncrement"` // 数据ID
DictType string `json:"dictType" gorm:"column:dict_type" binding:"required"` // 字典类型
DataLabel string `json:"dataLabel" gorm:"column:data_label" binding:"required"` // 数据标签
DataValue string `json:"dataValue" gorm:"column:data_value" binding:"required"` // 数据键值
DataSort int64 `json:"dataSort" gorm:"column:data_sort"` // 数据排序
TagClass string `json:"tagClass" gorm:"column:tag_class"` // 样式属性（样式扩展）
TagType string `json:"tagType" gorm:"column:tag_type"` // 标签类型（预设颜色）
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 状态（0停用 1正常）
DelFlag string `json:"-" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Remark string `json:"remark" gorm:"column:remark"` // 备注
}
// TableName 表名称
func (*SysDictData) TableName() string {
return "sys_dict_data"
}

35
src/modules/system/model/sys_dict_type.go
View File

@@ -1,23 +1,20 @@
package model
// SysDictType 字典类型对象 sys_dict_type
// SysDictType 字典类型表
type SysDictType struct {
// 字典主键
DictID string `json:"dictId"`
// 字典名称
DictName string `json:"dictName" binding:"required"`
// 字典类型
DictType string `json:"dictType" binding:"required"`
// 状态（0停用 1正常）
Status string `json:"status"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
DictId int64 `json:"dictId" gorm:"column:dict_id;primaryKey;autoIncrement"` // 字典ID
DictName string `json:"dictName" gorm:"column:dict_name" binding:"required"` // 字典名称
DictType string `json:"dictType" gorm:"column:dict_type" binding:"required"` // 字典类型
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 状态（0停用 1正常）
DelFlag string `json:"-" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Remark string `json:"remark" gorm:"column:remark"` // 备注
}
// TableName 表名称
func (*SysDictType) TableName() string {
return "sys_dict_type"
}

19
src/modules/system/model/sys_i18n.go Normal file
View File

@@ -0,0 +1,19 @@
package model
// SysI18n 系统_多语言 sys_i18n
type SysI18n struct {
ID int64 `json:"id" gorm:"column:config_id;primaryKey;autoIncrement"` // ID
DelFlag string `json:"delFlag" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Key string `json:"key" gorm:"column:key"` // 多语言属性名
ValueZh string `json:"valueZh" gorm:"column:value_zh"` // 中文
ValueEn string `json:"valueEn" gorm:"column:value_en"` // 英文
}
// TableName 表名称
func (*SysI18n) TableName() string {
return "sys_i18n"
}

34
src/modules/system/model/sys_log_login.go
View File

@@ -1,23 +1,19 @@
package model
// SysLogLogin 系统登录日志表 sys_log_login
// SysLogLogin 系统登录日志表
type SysLogLogin struct {
// 登录ID
LoginID string `json:"loginId"`
// 用户账号
UserName string `json:"userName"`
// 登录IP地址
IPAddr string `json:"ipaddr"`
// 登录地点
LoginLocation string `json:"loginLocation"`
// 浏览器类型
Browser string `json:"browser"`
// 操作系统
OS string `json:"os"`
// 登录状态（0失败 1成功）
Status string `json:"status"`
// 提示消息
Msg string `json:"msg"`
// 访问时间
LoginTime int64 `json:"loginTime"`
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 登录ID
UserName string `json:"userName" gorm:"column:user_name"` // 用户账号
LoginIp string `json:"loginIp" gorm:"column:login_ip"` // 登录IP地址
LoginLocation string `json:"loginLocation" gorm:"column:login_location"` // 登录地点
Browser string `json:"browser" gorm:"column:browser"` // 浏览器类型
OS string `json:"os" gorm:"column:os"` // 操作系统
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 登录状态（0失败 1成功）
Msg string `json:"msg" gorm:"column:msg"` // 提示消息
LoginTime int64 `json:"loginTime" gorm:"column:login_time"` // 登录时间
}
// TableName 表名称
func (*SysLogLogin) TableName() string {
return "sys_log_login"
}

53
src/modules/system/model/sys_log_operate.go
View File

@@ -1,37 +1,24 @@
package model
// SysLogOperate 系统操作日志表 sys_log_operate
// SysLogOperate 系统操作日志表
type SysLogOperate struct {
// 日志主键
OperID string `json:"operId"`
// 模块标题
Title string `json:"title"`
// 业务类型（0其它 1新增 2修改 3删除 4授权 5导出 6导入 7强退 8清空数据）
BusinessType string `json:"businessType"`
// 方法名称
Method string `json:"method"`
// 请求方式
RequestMethod string `json:"requestMethod"`
// 操作人员类别（0其它 1后台用户 2手机端用户）
OperatorType string `json:"operatorType"`
// 操作人员
OperName string `json:"operName"`
// 部门名称
DeptName string `json:"deptName"`
// 请求URL
OperURL string `json:"operUrl"`
// 主机地址
OperIP string `json:"operIp"`
// 操作地点
OperLocation string `json:"operLocation"`
// 请求参数
OperParam string `json:"operParam"`
// 操作消息
OperMsg string `json:"operMsg"`
// 操作状态（0异常 1正常）
Status string `json:"status"`
// 操作时间
OperTime int64 `json:"operTime"`
// 消耗时间（毫秒）
CostTime int64 `json:"costTime"`
ID int64 `json:"id" gorm:"column:id;primaryKey;autoIncrement"` // 操作ID
Title string `json:"title" gorm:"column:title"` // 模块标题
BusinessType string `json:"businessType" gorm:"column:business_type"` // 业务类型（0其它 1新增 2修改 3删除 4授权 5导出 6导入 7强退 8清空数据）
OperaUrl string `json:"operaUrl" gorm:"column:opera_url"` // 请求URL
OperaUrlMethod string `json:"operaUrlMethod" gorm:"column:opera_url_method"` // 请求方式
OperaIp string `json:"operaIp" gorm:"column:opera_ip"` // 主机地址
OperaLocation string `json:"operaLocation" gorm:"column:opera_location"` // 操作地点
OperaParam string `json:"operaParam" gorm:"column:opera_param"` // 请求参数
OperaMsg string `json:"operaMsg" gorm:"column:opera_msg"` // 操作消息
OperaMethod string `json:"operaMethod" gorm:"column:opera_method"` // 方法名称
OperaBy string `json:"operaBy" gorm:"column:opera_by"` // 操作人员
OperaTime int64 `json:"operaTime" gorm:"column:opera_time"` // 操作时间
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 操作状态（0异常 1正常）
CostTime int64 `json:"costTime" gorm:"column:cost_time"` // 消耗时间（毫秒）
}
// TableName 表名称
func (*SysLogOperate) TableName() string {
return "sys_log_operate"
}

65
src/modules/system/model/sys_menu.go
View File

@@ -1,46 +1,33 @@
package model
// SysMenu 菜单权限对象 sys_menu
// SysMenu 菜单权限表
type SysMenu struct {
// 菜单ID
MenuID string `json:"menuId"`
// 菜单名称
MenuName string `json:"menuName" binding:"required"`
// 父菜单ID 默认0
ParentID string `json:"parentId" binding:"required"`
// 显示顺序
MenuSort int `json:"menuSort"`
// 路由地址
Path string `json:"path"`
// 组件路径
Component string `json:"component"`
// 是否内部跳转（0否 1是）
IsFrame string `json:"isFrame"`
// 是否缓存（0不缓存 1缓存）
IsCache string `json:"isCache"`
// 菜单类型（D目录 M菜单 B按钮）
MenuType string `json:"menuType" binding:"required"`
// 是否显示（0隐藏 1显示）
Visible string `json:"visible"`
// 菜单状态（0停用 1正常）
Status string `json:"status"`
// 权限标识
Perms string `json:"perms"`
// 菜单图标（#无图标）
Icon string `json:"icon"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
MenuId int64 `json:"menuId" gorm:"column:menu_id;primaryKey;autoIncrement"` // 菜单ID
MenuName string `json:"menuName" gorm:"column:menu_name" binding:"required"` // 菜单名称
ParentId int64 `json:"parentId" gorm:"column:parent_id"` // 父菜单ID 默认0
MenuSort int64 `json:"menuSort" gorm:"column:menu_sort"` // 显示顺序
MenuPath string `json:"menuPath" gorm:"column:menu_path"` // 路由地址
Component string `json:"component" gorm:"column:component"` // 组件路径
FrameFlag string `json:"frameFlag" gorm:"column:frame_flag"` // 内部跳转标记（0否 1是）
CacheFlag string `json:"cacheFlag" gorm:"column:cache_flag"` // 缓存标记（0不缓存 1缓存）
MenuType string `json:"menuType" gorm:"column:menu_type" binding:"required"` // 菜单类型（D目录 M菜单 A访问权限）
VisibleFlag string `json:"visibleFlag" gorm:"column:visible_flag"` // 是否显示（0隐藏 1显示）
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 菜单状态（0停用 1正常）
Perms string `json:"perms" gorm:"column:perms"` // 权限标识
Icon string `json:"icon" gorm:"column:icon"` // 菜单图标（#无图标）
DelFlag string `json:"-" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Remark string `json:"remark" gorm:"column:remark"` // 备注
// ====== 非数据库字段属性 ======
// 子菜单
Children []SysMenu `json:"children,omitempty"`
Children []SysMenu `json:"children,omitempty" gorm:"-"` // 子菜单
}
// TableName 表名称
func (*SysMenu) TableName() string {
return "sys_menu"
}

27
src/modules/system/model/sys_notice.go
View File

@@ -1,27 +0,0 @@
package model
// SysNotice 通知公告对象 sys_notice
type SysNotice struct {
// 公告ID
NoticeID string `json:"noticeId"`
// 公告标题
NoticeTitle string `json:"noticeTitle" binding:"required"`
// 公告类型（1通知 2公告）
NoticeType string `json:"noticeType" binding:"required"`
// 公告内容
NoticeContent string `json:"noticeContent" binding:"required"`
// 公告状态（0关闭 1正常）
Status string `json:"status"`
// 删除标志（0代表存在 1代表删除）
DelFlag string `json:"delFlag"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
}

38
src/modules/system/model/sys_post.go
View File

@@ -1,25 +1,21 @@
package model
// SysPost 岗位对象 sys_post
// SysPost 岗位信息表
type SysPost struct {
// 岗位ID
PostID string `json:"postId"`
// 岗位编码
PostCode string `json:"postCode" binding:"required"`
// 岗位名称
PostName string `json:"postName" binding:"required"`
// 显示顺序
PostSort int `json:"postSort"`
// 状态（0停用 1正常）
Status string `json:"status"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
PostId int64 `json:"postId" gorm:"column:post_id;primaryKey;autoIncrement"` // 岗位ID
PostCode string `json:"postCode" gorm:"column:post_code" binding:"required"` // 岗位编码
PostName string `json:"postName" gorm:"column:post_name" binding:"required"` // 岗位名称
PostSort int64 `json:"postSort" gorm:"column:post_sort"` // 显示顺序
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 状态（0停用 1正常）
DelFlag string `json:"-" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Remark string `json:"remark" gorm:"column:remark"` // 备注
}
// TableName 表名称
func (*SysPost) TableName() string {
return "sys_post"
}

55
src/modules/system/model/sys_role.go
View File

@@ -1,40 +1,29 @@
package model
// SysRole 角色对象 sys_role
// SysRole 角色信息表
type SysRole struct {
// 角色ID
RoleID string `json:"roleId"`
// 角色名称
RoleName string `json:"roleName" binding:"required"`
// 角色键值
RoleKey string `json:"roleKey" binding:"required"`
// 显示顺序
RoleSort int `json:"roleSort"`
// 数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限 5：仅本人数据权限）
DataScope string `json:"dataScope"`
// 菜单树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示）
MenuCheckStrictly string `json:"menuCheckStrictly"`
// 部门树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示）
DeptCheckStrictly string `json:"deptCheckStrictly"`
// 角色状态（0停用 1正常）
Status string `json:"status"`
// 删除标志（0代表存在 1代表删除）
DelFlag string `json:"delFlag"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
RoleId int64 `json:"roleId" gorm:"column:role_id;primaryKey;autoIncrement"` // 角色ID
RoleName string `json:"roleName" gorm:"column:role_name" binding:"required"` // 角色名称
RoleKey string `json:"roleKey" gorm:"column:role_key" binding:"required"` // 角色键值
RoleSort int64 `json:"roleSort" gorm:"column:role_sort"` // 显示顺序
DataScope string `json:"dataScope" gorm:"column:data_scope"` // 数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限 5：仅本人数据权限）
MenuCheckStrictly string `json:"menuCheckStrictly" gorm:"column:menu_check_strictly"` // 菜单树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示）
DeptCheckStrictly string `json:"deptCheckStrictly" gorm:"column:dept_check_strictly"` // 部门树选择项是否关联显示（0：父子不互相关联显示 1：父子互相关联显示 ）
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 角色状态（0停用 1正常）
DelFlag string `json:"-" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Remark string `json:"remark" gorm:"column:remark"` // 备注
// ====== 非数据库字段属性 ======
// 菜单组
MenuIds []string `json:"menuIds,omitempty"`
// 部门组（数据权限）
DeptIds []string `json:"deptIds,omitempty"`
MenuIds []int64 `json:"menuIds,omitempty" gorm:"-"` // 菜单组
DeptIds []int64 `json:"deptIds,omitempty" gorm:"-"` // 部门组（数据权限）
}
// TableName 表名称
func (*SysRole) TableName() string {
return "sys_role"
}

15
src/modules/system/model/sys_role_dept.go
View File

@@ -1,15 +1,12 @@
package model
// SysRoleDept 角色和部门关联对象 sys_role_dept
// SysRoleDept 角色和部门关联表
type SysRoleDept struct {
RoleID string `json:"roleId"` // 角色ID
DeptID string `json:"deptId"` // 部门ID
RoleId int64 `json:"roleId" gorm:"column:role_id"` // 角色ID
DeptId int64 `json:"deptId" gorm:"column:dept_id"` // 部门ID
}
// NewSysRoleDept 创建角色和部门关联对象的构造函数
func NewSysRoleDept(roleID string, deptID string) SysRoleDept {
return SysRoleDept{
RoleID: roleID,
DeptID: deptID,
}
// TableName 表名称
func (*SysRoleDept) TableName() string {
return "sys_role_dept"
}

15
src/modules/system/model/sys_role_menu.go
View File

@@ -1,15 +1,12 @@
package model
// SysRoleMenu 角色和菜单关联对象 sys_role_menu
// SysRoleMenu 角色和菜单关联表
type SysRoleMenu struct {
RoleID string `json:"roleId"` // 角色ID
MenuID string `json:"menuId"` // 菜单ID
RoleId int64 `json:"roleId" gorm:"column:role_id"` // 角色ID
MenuId int64 `json:"menuId" gorm:"column:menu_id"` // 菜单ID
}
// NewSysRoleMenu 创建角色和菜单关联对象的构造函数
func NewSysRoleMenu(roleID string, menuID string) SysRoleMenu {
return SysRoleMenu{
RoleID: roleID,
MenuID: menuID,
}
// TableName 表名称
func (*SysRoleMenu) TableName() string {
return "sys_role_menu"
}

77
src/modules/system/model/sys_user.go
View File

@@ -1,56 +1,35 @@
package model
// SysUser 用户对象 sys_user
// SysUser 用户信息表
type SysUser struct {
// 用户ID
UserID string `json:"userId"`
// 部门ID
DeptID string `json:"deptId"`
// 用户账号
UserName string `json:"userName" binding:"required"`
// 用户昵称
NickName string `json:"nickName" binding:"required"`
// 用户类型（sys系统用户）
UserType string `json:"userType"`
// 用户邮箱
Email string `json:"email"`
// 手机号码
PhoneNumber string `json:"phonenumber"`
// 用户性别（0未知 1男 2女）
Sex string `json:"sex"`
// 头像地址
Avatar string `json:"avatar"`
// 密码
Password string `json:"-"`
// 帐号状态（0停用 1正常）
Status string `json:"status"`
// 删除标志（0代表存在 1代表删除）
DelFlag string `json:"delFlag"`
// 最后登录IP
LoginIP string `json:"loginIp"`
// 最后登录时间
LoginDate int64 `json:"loginDate"`
// 创建者
CreateBy string `json:"createBy"`
// 创建时间
CreateTime int64 `json:"createTime"`
// 更新者
UpdateBy string `json:"updateBy"`
// 更新时间
UpdateTime int64 `json:"updateTime"`
// 备注
Remark string `json:"remark"`
UserId int64 `json:"userId" gorm:"column:user_id;primaryKey;autoIncrement"` // 用户ID
DeptId int64 `json:"deptId" gorm:"column:dept_id"` // 部门ID
UserName string `json:"userName" gorm:"column:user_name"` // 用户账号
Email string `json:"email" gorm:"column:email"` // 用户邮箱
Phone string `json:"phone" gorm:"column:phone"` // 手机号码
NickName string `json:"nickName" gorm:"column:nick_name"` // 用户昵称
Sex string `json:"sex" gorm:"column:sex"` // 用户性别（0未选择 1男 2女）
Avatar string `json:"avatar" gorm:"column:avatar"` // 头像地址
Password string `json:"-" gorm:"column:password"` // 密码
StatusFlag string `json:"statusFlag" gorm:"column:status_flag"` // 账号状态（0停用 1正常）
DelFlag string `json:"-" gorm:"column:del_flag"` // 删除标记（0存在 1删除）
LoginIp string `json:"loginIp" gorm:"column:login_ip"` // 最后登录IP
LoginTime int64 `json:"loginTime" gorm:"column:login_time"` // 最后登录时间
CreateBy string `json:"createBy" gorm:"column:create_by"` // 创建者
CreateTime int64 `json:"createTime" gorm:"column:create_time"` // 创建时间
UpdateBy string `json:"updateBy" gorm:"column:update_by"` // 更新者
UpdateTime int64 `json:"updateTime" gorm:"column:update_time"` // 更新时间
Remark string `json:"remark" gorm:"column:remark"` // 备注
// ====== 非数据库字段属性 ======
// 部门对象
Dept SysDept `json:"dept,omitempty" binding:"structonly"`
// 角色对象组
Roles []SysRole `json:"roles"`
// 角色ID
RoleID string `json:"roleId,omitempty"`
// 角色组
RoleIDs []string `json:"roleIds,omitempty"`
// 岗位组
PostIDs []string `json:"postIds,omitempty"`
Dept *SysDept `json:"dept" gorm:"-"` // 部门对象
Roles []*SysRole `json:"roles" gorm:"-"` // 角色对象组
RoleIds []int64 `json:"roleIds,omitempty" gorm:"-"` // 角色组
PostIds []int64 `json:"postIds,omitempty" gorm:"-"` // 岗位组
}
// TableName 表名称
func (*SysUser) TableName() string {
return "sys_user"
}

15
src/modules/system/model/sys_user_post.go
View File

@@ -1,15 +1,12 @@
package model
// SysUserPost 用户和岗位关联对象 sys_user_post
// SysUserPost 用户与岗位关联表
type SysUserPost struct {
UserID string `json:"userId"` // 用户ID
PostID string `json:"postId"` // 岗位ID
UserId int64 `json:"userId" gorm:"column:user_id"` // 用户ID
PostId int64 `json:"postId" gorm:"column:post_id"` // 岗位ID
}
// NewSysUserPost 创建用户和岗位关联对象的构造函数
func NewSysUserPost(userID string, postID string) SysUserPost {
return SysUserPost{
UserID: userID,
PostID: postID,
}
// TableName 表名称
func (*SysUserPost) TableName() string {
return "sys_user_post"
}

15
src/modules/system/model/sys_user_role.go
View File

@@ -1,15 +1,12 @@
package model
// SysUserRole 用户和角色关联对象 sys_user_role
// SysUserRole 用户和角色关联表
type SysUserRole struct {
UserID string `json:"userId"` // 用户ID
RoleID string `json:"roleId"` // 角色ID
UserId int64 `json:"userId" gorm:"column:user_id"` // 用户ID
RoleId int64 `json:"roleId" gorm:"column:role_id"` // 角色ID
}
// NewSysUserRole 创建用户和角色关联对象的构造函数
func NewSysUserRole(userID string, roleID string) SysUserRole {
return SysUserRole{
UserID: userID,
RoleID: roleID,
}
// TableName 表名称
func (*SysUserRole) TableName() string {
return "sys_user_role"
}

21
src/modules/system/model/vo/router.go Normal file
View File

@@ -0,0 +1,21 @@
package vo
// Router 路由信息对象
type Router struct {
Name string `json:"name"` // 路由名字 英文首字母大写
Path string `json:"path"` // 路由地址
Meta RouterMeta `json:"meta"` // 其他元素
Component string `json:"component"` // 组件地址
Redirect string `json:"redirect"` // 重定向地址
Children []Router `json:"children,omitempty"` // 子路由
}
// RouterMeta 路由元信息对象
type RouterMeta struct {
Title string `json:"title"` // 设置该菜单在侧边栏和面包屑中展示的名字
Icon string `json:"icon"` // 设置该菜单的图标
Cache bool `json:"cache"` // 设置为true，则不会被 <keep-alive>缓存
Target string `json:"target"` // 内链地址（http(s)://开头）, 打开目标位置 '_blank' | '_self' | ''
HideChildInMenu bool `json:"hideChildInMenu"` // 在菜单中隐藏子节点
HideInMenu bool `json:"hideInMenu"` // 在菜单中隐藏自己和子节点
}

46
src/modules/system/model/vo/tree_select.go Normal file
View File

@@ -0,0 +1,46 @@
package vo
import "be.ems/src/modules/system/model"
// TreeSelect 树结构实体类
type TreeSelect struct {
ID int64 `json:"id"` // 节点ID
Label string `json:"label"` // 节点名称
Children []TreeSelect `json:"children"` // 子节点
}
// SysMenuTreeSelect 使用给定的 SysMenu 对象解析为 TreeSelect 对象
func SysMenuTreeSelect(sysMenu model.SysMenu) TreeSelect {
t := TreeSelect{}
t.ID = sysMenu.MenuId
t.Label = sysMenu.MenuName
if len(sysMenu.Children) > 0 {
for _, menu := range sysMenu.Children {
child := SysMenuTreeSelect(menu)
t.Children = append(t.Children, child)
}
} else {
t.Children = []TreeSelect{}
}
return t
}
// SysDeptTreeSelect 使用给定的 SysDept 对象解析为 TreeSelect 对象
func SysDeptTreeSelect(sysDept model.SysDept) TreeSelect {
t := TreeSelect{}
t.ID = sysDept.DeptId
t.Label = sysDept.DeptName
if len(sysDept.Children) > 0 {
for _, dept := range sysDept.Children {
child := SysDeptTreeSelect(dept)
t.Children = append(t.Children, child)
}
} else {
t.Children = []TreeSelect{}
}
return t
}

210
src/modules/system/repository/sys_config.go
View File

@@ -1,30 +1,200 @@
package repository
import "be.ems/src/modules/system/model"
import (
"fmt"
"time"
// ISysConfig 参数配置表 数据层接口
type ISysConfig interface {
// SelectDictDataPage 分页查询参数配置列表数据
SelectConfigPage(query map[string]any) map[string]any
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectConfigList 查询参数配置列表
SelectConfigList(sysConfig model.SysConfig) []model.SysConfig
// NewSysConfig 实例化数据层
var NewSysConfig = &SysConfig{}
// SelectConfigValueByKey 通过参数键名查询参数键值
SelectConfigValueByKey(configKey string) string
// SysConfig 参数配置表 数据层处理
type SysConfig struct{}
// SelectConfigByIds 通过配置ID查询参数配置信息
SelectConfigByIds(configIds []string) []model.SysConfig
// SelectByPage 分页查询集合
func (r SysConfig) SelectByPage(query map[string]string) ([]model.SysConfig, int64) {
tx := db.DB("").Model(&model.SysConfig{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if v, ok := query["configName"]; ok && v != "" {
tx = tx.Where("config_name like concat(?, '%')", v)
}
if v, ok := query["configType"]; ok && v != "" {
tx = tx.Where("config_type = ?", v)
}
if v, ok := query["configKey"]; ok && v != "" {
tx = tx.Where("config_key like concat(?, '%')", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s000", v)
tx = tx.Where("create_time >= ?", v)
} else if len(v) == 13 {
tx = tx.Where("create_time >= ?", v)
}
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s999", v)
tx = tx.Where("create_time <= ?", v)
} else if len(v) == 13 {
tx = tx.Where("create_time <= ?", v)
}
}
// CheckUniqueConfig 校验配置参数是否唯一
CheckUniqueConfig(sysConfig model.SysConfig) string
// 查询结果
var total int64 = 0
rows := []model.SysConfig{}
// InsertConfig 新增参数配置
InsertConfig(sysConfig model.SysConfig) string
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// UpdateConfig 修改参数配置
UpdateConfig(sysConfig model.SysConfig) int64
// DeleteConfigByIds 批量删除参数配置信息
DeleteConfigByIds(configIds []string) int64
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Select 查询集合
func (r SysConfig) Select(sysConfig model.SysConfig) []model.SysConfig {
tx := db.DB("").Model(&model.SysConfig{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysConfig.ConfigName != "" {
tx = tx.Where("config_name like concat(?, '%')", sysConfig.ConfigName)
}
if sysConfig.ConfigType != "" {
tx = tx.Where("config_type = ?", sysConfig.ConfigType)
}
if sysConfig.ConfigKey != "" {
tx = tx.Where("config_key like concat(?, '%')", sysConfig.ConfigKey)
}
if sysConfig.CreateTime > 0 {
tx = tx.Where("create_time >= ?", sysConfig.CreateTime)
}
// 查询数据
rows := []model.SysConfig{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysConfig) SelectByIds(configIds []int64) []model.SysConfig {
rows := []model.SysConfig{}
if len(configIds) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysConfig{})
// 构建查询条件
tx = tx.Where("config_id in ? and del_flag = '0'", configIds)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r SysConfig) Insert(sysConfig model.SysConfig) int64 {
sysConfig.DelFlag = "0"
if sysConfig.CreateBy != "" {
ms := time.Now().UnixMilli()
sysConfig.UpdateBy = sysConfig.CreateBy
sysConfig.UpdateTime = ms
sysConfig.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&sysConfig).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysConfig.ConfigId
}
// Update 修改信息 返回受影响行数
func (r SysConfig) Update(sysConfig model.SysConfig) int64 {
if sysConfig.ConfigId <= 0 {
return 0
}
if sysConfig.UpdateBy != "" {
sysConfig.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.SysConfig{})
// 构建查询条件
tx = tx.Where("config_id = ?", sysConfig.ConfigId)
tx = tx.Omit("config_id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysConfig).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息 返回受影响行数
func (r SysConfig) DeleteByIds(configIds []int64) int64 {
if len(configIds) <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysConfig{})
// 构建查询条件
tx = tx.Where("config_id in ?", configIds)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一 返回数据ID
func (r SysConfig) CheckUnique(sysConfig model.SysConfig) int64 {
tx := db.DB("").Model(&model.SysConfig{})
tx = tx.Where("del_flag = 0")
// 查询条件拼接
if sysConfig.ConfigType != "" {
tx = tx.Where("config_type = ?", sysConfig.ConfigType)
}
if sysConfig.ConfigKey != "" {
tx = tx.Where("config_key = ?", sysConfig.ConfigKey)
}
// 查询数据
var id int64 = 0
if err := tx.Select("config_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// SelectValueByKey 通过Key查询Value
func (r SysConfig) SelectValueByKey(configKey string) string {
if configKey == "" {
return ""
}
tx := db.DB("").Model(&model.SysConfig{})
tx.Where("config_key = ? and del_flag = '0'", configKey)
// 查询数据
var configValue string = ""
if err := tx.Select("config_value").Limit(1).Find(&configValue).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return configValue
}
return configValue
}

334
src/modules/system/repository/sys_config.impl.go
View File

@@ -1,334 +0,0 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysConfigImpl 结构体
var NewSysConfigImpl = &SysConfigImpl{
selectSql: `select
config_id, config_name, config_key, config_value, config_type, create_by, create_time, update_by, update_time, remark
from sys_config`,
resultMap: map[string]string{
"config_id": "ConfigID",
"config_name": "ConfigName",
"config_key": "ConfigKey",
"config_value": "ConfigValue",
"config_type": "ConfigType",
"remark": "Remark",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
},
}
// SysConfigImpl 参数配置表 数据层处理
type SysConfigImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysConfigImpl) convertResultRows(rows []map[string]any) []model.SysConfig {
arr := make([]model.SysConfig, 0)
for _, row := range rows {
sysConfig := model.SysConfig{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysConfig, keyMapper, value)
}
}
arr = append(arr, sysConfig)
}
return arr
}
// SelectDictDataPage 分页查询参数配置列表数据
func (r *SysConfigImpl) SelectConfigPage(query map[string]any) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["configName"]; ok && v != "" {
conditions = append(conditions, "config_name like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["configType"]; ok && v != "" {
conditions = append(conditions, "config_type = ?")
params = append(params, v)
}
if v, ok := query["configKey"]; ok && v != "" {
conditions = append(conditions, "config_key like concat(?, '%')")
params = append(params, v)
}
beginTime, ok := query["beginTime"]
if !ok {
beginTime, ok = query["params[beginTime]"]
}
if ok && beginTime != "" {
conditions = append(conditions, "create_time >= ?")
params = append(params, parse.Number(beginTime.(string)))
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "create_time <= ?")
params = append(params, parse.Number(endTime.(string)))
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysConfig{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_config"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectConfigList 查询参数配置列表
func (r *SysConfigImpl) SelectConfigList(sysConfig model.SysConfig) []model.SysConfig {
// 查询条件拼接
var conditions []string
var params []any
if sysConfig.ConfigName != "" {
conditions = append(conditions, "config_name like concat(?, '%')")
params = append(params, sysConfig.ConfigName)
}
if sysConfig.ConfigType != "" {
conditions = append(conditions, "config_type = ?")
params = append(params, sysConfig.ConfigType)
}
if sysConfig.ConfigKey != "" {
conditions = append(conditions, "config_key like concat(?, '%')")
params = append(params, sysConfig.ConfigKey)
}
if sysConfig.CreateTime > 0 {
conditions = append(conditions, "create_time >= ?")
params = append(params, sysConfig.CreateTime)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysConfig{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectConfigValueByKey 通过参数键名查询参数键值
func (r *SysConfigImpl) SelectConfigValueByKey(configKey string) string {
querySql := "select config_value as 'str' from sys_config where config_key = ?"
results, err := datasource.RawDB("", querySql, []any{configKey})
if err != nil {
logger.Errorf("query err => %v", err)
return ""
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}
// SelectConfigByIds 通过配置ID查询参数配置信息
func (r *SysConfigImpl) SelectConfigByIds(configIds []string) []model.SysConfig {
placeholder := repo.KeyPlaceholderByQuery(len(configIds))
querySql := r.selectSql + " where config_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(configIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysConfig{}
}
// 转换实体
return r.convertResultRows(results)
}
// CheckUniqueConfig 校验配置参数是否唯一
func (r *SysConfigImpl) CheckUniqueConfig(sysConfig model.SysConfig) string {
// 查询条件拼接
var conditions []string
var params []any
if sysConfig.ConfigKey != "" {
conditions = append(conditions, "config_key = ?")
params = append(params, sysConfig.ConfigKey)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
} else {
return ""
}
// 查询数据
querySql := "select config_id as 'str' from sys_config " + whereSql + " limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
return ""
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}
// InsertConfig 新增参数配置
func (r *SysConfigImpl) InsertConfig(sysConfig model.SysConfig) string {
// 参数拼接
params := make(map[string]any)
if sysConfig.ConfigName != "" {
params["config_name"] = sysConfig.ConfigName
}
if sysConfig.ConfigKey != "" {
params["config_key"] = sysConfig.ConfigKey
}
if sysConfig.ConfigValue != "" {
params["config_value"] = sysConfig.ConfigValue
}
if sysConfig.ConfigType != "" {
params["config_type"] = sysConfig.ConfigType
}
if sysConfig.Remark != "" {
params["remark"] = sysConfig.Remark
}
if sysConfig.CreateBy != "" {
params["create_by"] = sysConfig.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_config (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// UpdateConfig 修改参数配置
func (r *SysConfigImpl) UpdateConfig(sysConfig model.SysConfig) int64 {
// 参数拼接
params := make(map[string]any)
if sysConfig.ConfigName != "" {
params["config_name"] = sysConfig.ConfigName
}
if sysConfig.ConfigKey != "" {
params["config_key"] = sysConfig.ConfigKey
}
if sysConfig.ConfigValue != "" {
params["config_value"] = sysConfig.ConfigValue
}
if sysConfig.ConfigType != "" {
params["config_type"] = sysConfig.ConfigType
}
params["remark"] = sysConfig.Remark
if sysConfig.UpdateBy != "" {
params["update_by"] = sysConfig.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_config set " + strings.Join(keys, ",") + " where config_id = ?"
// 执行更新
values = append(values, sysConfig.ConfigID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// DeleteConfigByIds 批量删除参数配置信息
func (r *SysConfigImpl) DeleteConfigByIds(configIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(configIds))
sql := "delete from sys_config where config_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(configIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

280
src/modules/system/repository/sys_dept.go
View File

@@ -1,42 +1,254 @@
package repository
import "be.ems/src/modules/system/model"
import (
"fmt"
"strings"
"time"
// ISysDept 部门表 数据层接口
type ISysDept interface {
// SelectDeptList 查询部门管理数据
SelectDeptList(sysDept model.SysDept, dataScopeSQL string) []model.SysDept
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectDeptListByRoleId 根据角色ID查询部门树信息
SelectDeptListByRoleId(roleId string, deptCheckStrictly bool) []string
// NewSysDept 实例化数据层
var NewSysDept = &SysDept{}
// SelectDeptById 根据部门ID查询信息
SelectDeptById(deptId string) model.SysDept
// SysDept 部门表 数据层处理
type SysDept struct{}
// SelectChildrenDeptById 根据ID查询所有子部门
SelectChildrenDeptById(deptId string) []model.SysDept
// Select 查询集合
func (r SysDept) Select(sysDept model.SysDept, dataScopeSQL string) []model.SysDept {
tx := db.DB("").Model(&model.SysDept{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysDept.DeptId > 0 {
tx = tx.Where("dept_id = ?", sysDept.DeptId)
}
if sysDept.ParentId > 0 {
tx = tx.Where("parent_id = ?", sysDept.ParentId)
}
if sysDept.DeptName != "" {
tx = tx.Where("dept_name like concat(?, '%')", sysDept.DeptName)
}
if sysDept.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysDept.StatusFlag)
}
if dataScopeSQL != "" {
tx = tx.Where(dataScopeSQL)
}
// HasChildByDeptId 是否存在子节点
HasChildByDeptId(deptId string) int64
// CheckDeptExistUser 查询部门是否存在用户
CheckDeptExistUser(deptId string) int64
// CheckUniqueDept 校验部门是否唯一
CheckUniqueDept(sysDept model.SysDept) string
// InsertDept 新增部门信息
InsertDept(sysDept model.SysDept) string
// UpdateDept 修改部门信息
UpdateDept(sysDept model.SysDept) int64
// UpdateDeptStatusNormal 修改所在部门正常状态
UpdateDeptStatusNormal(deptIds []string) int64
// UpdateDeptChildren 修改子元素关系
UpdateDeptChildren(sysDepts []model.SysDept) int64
// DeleteDeptById 删除部门管理信息
DeleteDeptById(deptId string) int64
// 查询数据
rows := []model.SysDept{}
if err := tx.Order("parent_id, dept_sort asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectById 通过ID查询信息
func (r SysDept) SelectById(deptId int64) model.SysDept {
if deptId <= 0 {
return model.SysDept{}
}
tx := db.DB("").Model(&model.SysDept{})
// 构建查询条件
tx = tx.Where("dept_id = ? and del_flag = '0'", deptId)
// 查询数据
item := model.SysDept{}
if err := tx.Limit(1).Find(&item).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return item
}
return item
}
// Insert 新增信息 返回新增数据ID
func (r SysDept) Insert(sysDept model.SysDept) int64 {
sysDept.DelFlag = "0"
if sysDept.CreateBy != "" {
ms := time.Now().UnixMilli()
sysDept.UpdateBy = sysDept.CreateBy
sysDept.UpdateTime = ms
sysDept.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&sysDept).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysDept.DeptId
}
// Update 修改信息 返回受影响行数
func (r SysDept) Update(sysDept model.SysDept) int64 {
if sysDept.DeptId <= 0 {
return 0
}
if sysDept.UpdateBy != "" {
sysDept.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.SysDept{})
// 构建查询条件
tx = tx.Where("dept_id = ?", sysDept.DeptId)
tx = tx.Omit("dept_id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysDept).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteById 删除信息 返回受影响行数
func (r SysDept) DeleteById(deptId int64) int64 {
if deptId <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysDept{})
// 构建查询条件
tx = tx.Where("dept_id = ?", deptId)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一 返回数据ID
func (r SysDept) CheckUnique(sysDept model.SysDept) int64 {
tx := db.DB("").Model(&model.SysDept{})
tx = tx.Where("del_flag = 0")
// 查询条件拼接
if sysDept.DeptName != "" {
tx = tx.Where("dept_name = ?", sysDept.DeptName)
}
if sysDept.ParentId > 0 {
tx = tx.Where("parent_id = ?", sysDept.ParentId)
}
// 查询数据
var id int64 = 0
if err := tx.Select("dept_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// ExistChildrenByDeptId 存在子节点数量
func (r SysDept) ExistChildrenByDeptId(deptId int64) int64 {
if deptId <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysDept{})
tx = tx.Where("del_flag = '0' and status_flag = '1' and parent_id = ?", deptId)
// 查询数据
var count int64 = 0
if err := tx.Count(&count).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return count
}
return count
}
// ExistUserByDeptId 存在用户使用数量
func (r SysDept) ExistUserByDeptId(deptId int64) int64 {
if deptId <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysUser{})
tx = tx.Where("del_flag = '0' and dept_id = ?", deptId)
// 查询数据
var count int64 = 0
if err := tx.Count(&count).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return count
}
return count
}
// SelectDeptIdsByRoleId 通过角色ID查询包含的部门ID
func (r SysDept) SelectDeptIdsByRoleId(roleId int64, deptCheckStrictly bool) []int64 {
if roleId <= 0 {
return []int64{}
}
tx := db.DB("").Model(&model.SysDept{})
tx = tx.Where("del_flag = '0'")
tx = tx.Where("dept_id in (SELECT DISTINCT dept_id FROM sys_role_dept WHERE role_id = ?)", roleId)
// 父子互相关联显示，取所有子节点
if deptCheckStrictly {
tx = tx.Where(`dept_id not in (
SELECT d.parent_id FROM sys_dept d
INNER JOIN sys_role_dept rd ON rd.dept_id = d.dept_id
AND rd.role_id = ?
)`, roleId)
}
// 查询数据
rows := []int64{}
if err := tx.Distinct("dept_id").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectChildrenDeptById 根据ID查询所有子部门
func (r SysDept) SelectChildrenDeptById(deptId int64) []model.SysDept {
tx := db.DB("").Model(&model.SysDept{})
tx = tx.Where("del_flag = 0")
tx = tx.Where("find_in_set(?, ancestors)", deptId)
// 查询数据
rows := []model.SysDept{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// UpdateDeptStatusNormal 修改所在部门正常状态
func (r SysDept) UpdateDeptStatusNormal(deptIds []int64) int64 {
if len(deptIds) <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysDept{})
// 构建查询条件
tx = tx.Where("dept_id in ?", deptIds)
// 执行更新状态标记
if err := tx.Update("status_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// UpdateDeptChildren 修改子元素关系
func (r SysDept) UpdateDeptChildren(arr []model.SysDept) int64 {
if len(arr) == 0 {
return 0
}
// 构建查询条件
var conditions []string
var deptIds []any
for _, dept := range arr {
caseSql := fmt.Sprintf("WHEN dept_id = %d THEN '%s'", dept.DeptId, dept.Ancestors)
conditions = append(conditions, caseSql)
deptIds = append(deptIds, dept.DeptId)
}
cases := strings.Join(conditions, " ")
casesVal := fmt.Sprintf("CASE %s END", cases)
// 执行更新操作
tx := db.DB("").Model(&model.SysDept{})
tx = tx.Update("ancestors", casesVal)
if err := tx.Where("dept_id in ?", deptIds).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

393
src/modules/system/repository/sys_dept.impl.go
View File

@@ -1,393 +0,0 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysDeptImpl 结构体
var NewSysDeptImpl = &SysDeptImpl{
selectSql: `select
d.dept_id, d.parent_id, d.ancestors, d.dept_name, d.order_num, d.leader, d.phone, d.email, d.status, d.del_flag, d.create_by, d.create_time
from sys_dept d`,
resultMap: map[string]string{
"dept_id": "DeptID",
"parent_id": "ParentID",
"ancestors": "Ancestors",
"dept_name": "DeptName",
"order_num": "OrderNum",
"leader": "Leader",
"phone": "Phone",
"email": "Email",
"status": "Status",
"del_flag": "DelFlag",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
"parent_name": "ParentName",
},
}
// SysDeptImpl 部门表 数据层处理
type SysDeptImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysDeptImpl) convertResultRows(rows []map[string]any) []model.SysDept {
arr := make([]model.SysDept, 0)
for _, row := range rows {
sysDept := model.SysDept{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysDept, keyMapper, value)
}
}
arr = append(arr, sysDept)
}
return arr
}
// SelectDeptList 查询部门管理数据
func (r *SysDeptImpl) SelectDeptList(sysDept model.SysDept, dataScopeSQL string) []model.SysDept {
// 查询条件拼接
var conditions []string
var params []any
if sysDept.DeptID != "" {
conditions = append(conditions, "dept_id = ?")
params = append(params, sysDept.DeptID)
}
if sysDept.ParentID != "" {
conditions = append(conditions, "parent_id = ?")
params = append(params, sysDept.ParentID)
}
if sysDept.DeptName != "" {
conditions = append(conditions, "dept_name like concat(?, '%')")
params = append(params, sysDept.DeptName)
}
if sysDept.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, sysDept.Status)
}
// 构建查询条件语句
whereSql := " where d.del_flag = '0' "
if len(conditions) > 0 {
whereSql += " and " + strings.Join(conditions, " and ")
}
// 查询数据
orderSql := " order by d.parent_id, d.order_num asc "
querySql := r.selectSql + whereSql + dataScopeSQL + orderSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysDept{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectDeptListByRoleId 根据角色ID查询部门树信息
func (r *SysDeptImpl) SelectDeptListByRoleId(roleId string, deptCheckStrictly bool) []string {
querySql := `select d.dept_id as 'str' from sys_dept d
left join sys_role_dept rd on d.dept_id = rd.dept_id
where rd.role_id = ? `
var params []any
params = append(params, roleId)
// 展开
if deptCheckStrictly {
querySql += ` and d.dept_id not in
(select d.parent_id from sys_dept d
inner join sys_role_dept rd on d.dept_id = rd.dept_id
and rd.role_id = ?) `
params = append(params, roleId)
}
querySql += "order by d.parent_id, d.order_num"
// 查询结果
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []string{}
}
if len(results) > 0 {
ids := make([]string, 0)
for _, v := range results {
ids = append(ids, fmt.Sprintf("%v", v["str"]))
}
return ids
}
return []string{}
}
// SelectDeptById 根据部门ID查询信息
func (r *SysDeptImpl) SelectDeptById(deptId string) model.SysDept {
querySql := `select d.dept_id, d.parent_id, d.ancestors,
d.dept_name, d.order_num, d.leader, d.phone, d.email, d.status,
(select dept_name from sys_dept where dept_id = d.parent_id) parent_name
from sys_dept d where d.dept_id = ?`
results, err := datasource.RawDB("", querySql, []any{deptId})
if err != nil {
logger.Errorf("query err => %v", err)
return model.SysDept{}
}
// 转换实体
rows := r.convertResultRows(results)
if len(rows) > 0 {
return rows[0]
}
return model.SysDept{}
}
// SelectChildrenDeptById 根据ID查询所有子部门
func (r *SysDeptImpl) SelectChildrenDeptById(deptId string) []model.SysDept {
querySql := r.selectSql + " where find_in_set(?, d.ancestors)"
results, err := datasource.RawDB("", querySql, []any{deptId})
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysDept{}
}
// 转换实体
return r.convertResultRows(results)
}
// HasChildByDeptId 是否存在子节点
func (r *SysDeptImpl) HasChildByDeptId(deptId string) int64 {
querySql := "select count(1) as 'total' from sys_dept where status = '1' and parent_id = ? limit 1"
results, err := datasource.RawDB("", querySql, []any{deptId})
if err != nil {
logger.Errorf("query err => %v", err)
return 0
}
if len(results) > 0 {
return parse.Number(results[0]["total"])
}
return 0
}
// CheckDeptExistUser 查询部门是否存在用户
func (r *SysDeptImpl) CheckDeptExistUser(deptId string) int64 {
querySql := "select count(1) as 'total' from sys_user where dept_id = ? and del_flag = '0'"
results, err := datasource.RawDB("", querySql, []any{deptId})
if err != nil {
logger.Errorf("query err => %v", err)
return 0
}
if len(results) > 0 {
return parse.Number(results[0]["total"])
}
return 0
}
// CheckUniqueDept 校验部门是否唯一
func (r *SysDeptImpl) CheckUniqueDept(sysDept model.SysDept) string {
// 查询条件拼接
var conditions []string
var params []any
if sysDept.DeptName != "" {
conditions = append(conditions, "dept_name = ?")
params = append(params, sysDept.DeptName)
}
if sysDept.ParentID != "" {
conditions = append(conditions, "parent_id = ?")
params = append(params, sysDept.ParentID)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
if whereSql == "" {
return ""
}
// 查询数据
querySql := "select dept_id as 'str' from sys_dept " + whereSql + " and del_flag = '0' limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
return ""
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}
// InsertDept 新增部门信息
func (r *SysDeptImpl) InsertDept(sysDept model.SysDept) string {
// 参数拼接
params := make(map[string]any)
if sysDept.DeptID != "" {
params["dept_id"] = sysDept.DeptID
}
if sysDept.ParentID != "" {
params["parent_id"] = sysDept.ParentID
}
if sysDept.DeptName != "" {
params["dept_name"] = sysDept.DeptName
}
if sysDept.Ancestors != "" {
params["ancestors"] = sysDept.Ancestors
}
if sysDept.OrderNum > 0 {
params["order_num"] = sysDept.OrderNum
}
if sysDept.Leader != "" {
params["leader"] = sysDept.Leader
}
if sysDept.Phone != "" {
params["phone"] = sysDept.Phone
}
if sysDept.Email != "" {
params["email"] = sysDept.Email
}
if sysDept.Status != "" {
params["status"] = sysDept.Status
}
if sysDept.CreateBy != "" {
params["create_by"] = sysDept.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_dept (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// UpdateDept 修改部门信息
func (r *SysDeptImpl) UpdateDept(sysDept model.SysDept) int64 {
// 参数拼接
params := make(map[string]any)
if sysDept.ParentID != "" {
params["parent_id"] = sysDept.ParentID
}
if sysDept.DeptName != "" {
params["dept_name"] = sysDept.DeptName
}
if sysDept.Ancestors != "" {
params["ancestors"] = sysDept.Ancestors
}
if sysDept.OrderNum > 0 {
params["order_num"] = sysDept.OrderNum
}
if sysDept.Leader != "" {
params["leader"] = sysDept.Leader
}
if sysDept.Phone != "" {
params["phone"] = sysDept.Phone
}
if sysDept.Email != "" {
params["email"] = sysDept.Email
}
if sysDept.Status != "" {
params["status"] = sysDept.Status
}
if sysDept.UpdateBy != "" {
params["update_by"] = sysDept.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_dept set " + strings.Join(keys, ",") + " where dept_id = ?"
// 执行更新
values = append(values, sysDept.DeptID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// UpdateDeptStatusNormal 修改所在部门正常状态
func (r *SysDeptImpl) UpdateDeptStatusNormal(deptIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(deptIds))
sql := "update sys_dept set status = '1' where dept_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(deptIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("update err => %v", err)
return 0
}
return results
}
// UpdateDeptChildren 修改子元素关系
func (r *SysDeptImpl) UpdateDeptChildren(sysDepts []model.SysDept) int64 {
// 无参数
if len(sysDepts) == 0 {
return 0
}
// 更新条件拼接
var conditions []string
var params []any
for _, dept := range sysDepts {
caseSql := fmt.Sprintf("WHEN dept_id = '%s' THEN '%s'", dept.DeptID, dept.Ancestors)
conditions = append(conditions, caseSql)
params = append(params, dept.DeptID)
}
cases := strings.Join(conditions, " ")
placeholders := repo.KeyPlaceholderByQuery(len(params))
sql := "update sys_dept set ancestors = CASE " + cases + " END where dept_id in (" + placeholders + ")"
results, err := datasource.ExecDB("", sql, params)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// DeleteDeptById 删除部门管理信息
func (r *SysDeptImpl) DeleteDeptById(deptId string) int64 {
sql := "update sys_dept set status = '0', del_flag = '1' where dept_id = ?"
results, err := datasource.ExecDB("", sql, []any{deptId})
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

212
src/modules/system/repository/sys_dict_data.go
View File

@@ -1,33 +1,199 @@
package repository
import "be.ems/src/modules/system/model"
import (
"time"
// ISysDictData 字典类型数据表 数据层接口
type ISysDictData interface {
// SelectDictDataPage 根据条件分页查询字典数据
SelectDictDataPage(query map[string]any) map[string]any
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectDictDataList 根据条件查询字典数据
SelectDictDataList(sysDictData model.SysDictData) []model.SysDictData
// NewSysDictData 实例化数据层
var NewSysDictData = &SysDictData{}
// SelectDictDataByCodes 根据字典数据编码查询信息
SelectDictDataByCodes(dictCodes []string) []model.SysDictData
// SysDictData 字典类型数据表 数据层处理
type SysDictData struct{}
// CountDictDataByType 查询字典数据
CountDictDataByType(dictType string) int64
// SelectByPage 分页查询集合
func (r SysDictData) SelectByPage(query map[string]string) ([]model.SysDictData, int64) {
tx := db.DB("").Model(&model.SysDictData{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if v, ok := query["dictType"]; ok && v != "" {
tx = tx.Where("dict_type = ?", v)
}
if v, ok := query["dataLabel"]; ok && v != "" {
tx = tx.Where("data_label like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
// CheckUniqueDictData 校验字典数据是否唯一
CheckUniqueDictData(sysDictData model.SysDictData) string
// 查询结果
var total int64 = 0
rows := []model.SysDictData{}
// DeleteDictDataByCodes 批量删除字典数据信息
DeleteDictDataByCodes(dictCodes []string) int64
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// InsertDictData 新增字典数据信息
InsertDictData(sysDictData model.SysDictData) string
// UpdateDictData 修改字典数据信息
UpdateDictData(sysDictData model.SysDictData) int64
// UpdateDictDataType 同步修改字典类型
UpdateDictDataType(oldDictType string, newDictType string) int64
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Order("data_sort asc").Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Select 查询集合
func (r SysDictData) Select(sysDictData model.SysDictData) []model.SysDictData {
tx := db.DB("").Model(&model.SysDictData{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysDictData.DataLabel != "" {
tx = tx.Where("data_label like concat(?, '%')", sysDictData.DataLabel)
}
if sysDictData.DictType != "" {
tx = tx.Where("dict_type = ?", sysDictData.DictType)
}
if sysDictData.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysDictData.StatusFlag)
}
// 查询数据
rows := []model.SysDictData{}
if err := tx.Order("data_sort asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysDictData) SelectByIds(dataIds []int64) []model.SysDictData {
rows := []model.SysDictData{}
if len(dataIds) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysDictData{})
// 构建查询条件
tx = tx.Where("data_id in ? and del_flag = '0'", dataIds)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r SysDictData) Insert(sysDictData model.SysDictData) int64 {
sysDictData.DelFlag = "0"
if sysDictData.CreateBy != "" {
ms := time.Now().UnixMilli()
sysDictData.UpdateBy = sysDictData.CreateBy
sysDictData.UpdateTime = ms
sysDictData.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&sysDictData).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysDictData.DataId
}
// Update 修改信息 返回受影响行数
func (r SysDictData) Update(sysDictData model.SysDictData) int64 {
if sysDictData.DataId <= 0 {
return 0
}
if sysDictData.UpdateBy != "" {
sysDictData.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.SysDictData{})
// 构建查询条件
tx = tx.Where("data_id = ?", sysDictData.DataId)
tx = tx.Omit("data_id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysDictData).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息 返回受影响行数
func (r SysDictData) DeleteByIds(dataIds []int64) int64 {
if len(dataIds) <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysDictData{})
// 构建查询条件
tx = tx.Where("data_id in ?", dataIds)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一 返回数据ID
func (r SysDictData) CheckUnique(sysDictData model.SysDictData) int64 {
tx := db.DB("").Model(&model.SysDictData{})
tx = tx.Where("del_flag = 0")
// 查询条件拼接
if sysDictData.DictType != "" {
tx = tx.Where("dict_type = ?", sysDictData.DictType)
}
if sysDictData.DataLabel != "" {
tx = tx.Where("data_label = ?", sysDictData.DataLabel)
}
if sysDictData.DataValue != "" {
tx = tx.Where("data_value = ?", sysDictData.DataValue)
}
// 查询数据
var id int64 = 0
if err := tx.Select("data_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// ExistDataByDictType 存在数据数量
func (r SysDictData) ExistDataByDictType(dictType string) int64 {
if dictType == "" {
return 0
}
tx := db.DB("").Model(&model.SysDictData{})
tx = tx.Where("del_flag = '0' and dict_type = ?", dictType)
// 查询数据
var count int64 = 0
if err := tx.Count(&count).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return count
}
return count
}
// UpdateDataByDictType 更新一组字典类型 返回受影响行数
func (r SysDictData) UpdateDataByDictType(oldDictType string, newDictType string) int64 {
if oldDictType == "" || newDictType == "" {
return 0
}
tx := db.DB("").Model(&model.SysDictData{})
// 构建查询条件
tx = tx.Where("dict_type = ?", oldDictType)
// 执行更新删除标记
if err := tx.Update("dict_type", newDictType).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

362
src/modules/system/repository/sys_dict_data.impl.go
View File

@@ -1,362 +0,0 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysDictDataImpl 结构体
var NewSysDictData = &SysDictDataImpl{
selectSql: `select
dict_code, dict_sort, dict_label, dict_value, dict_type, tag_class, tag_type, status, create_by, create_time, remark
from sys_dict_data`,
resultMap: map[string]string{
"dict_code": "DictCode",
"dict_sort": "DictSort",
"dict_label": "DictLabel",
"dict_value": "DictValue",
"dict_type": "DictType",
"tag_class": "TagClass",
"tag_type": "TagType",
"status": "Status",
"remark": "Remark",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
},
}
// SysDictDataImpl 字典类型数据表 数据层处理
type SysDictDataImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysDictDataImpl) convertResultRows(rows []map[string]any) []model.SysDictData {
arr := make([]model.SysDictData, 0)
for _, row := range rows {
sysDictData := model.SysDictData{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysDictData, keyMapper, value)
}
}
arr = append(arr, sysDictData)
}
return arr
}
// SelectDictDataPage 根据条件分页查询字典数据
func (r *SysDictDataImpl) SelectDictDataPage(query map[string]any) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["dictType"]; ok && v != "" {
conditions = append(conditions, "dict_type = ?")
params = append(params, v)
}
if v, ok := query["dictLabel"]; ok && v != "" {
conditions = append(conditions, "dict_label like concat(?, '%')")
params = append(params, strings.TrimSpace(v.(string)))
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "status = ?")
params = append(params, v)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysDictData{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_dict_data"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " order by dict_sort asc limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectDictDataList 根据条件查询字典数据
func (r *SysDictDataImpl) SelectDictDataList(sysDictData model.SysDictData) []model.SysDictData {
// 查询条件拼接
var conditions []string
var params []any
if sysDictData.DictLabel != "" {
conditions = append(conditions, "dict_label like concat(?, '%')")
params = append(params, sysDictData.DictLabel)
}
if sysDictData.DictType != "" {
conditions = append(conditions, "dict_type = ?")
params = append(params, sysDictData.DictType)
}
if sysDictData.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, sysDictData.Status)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
orderSql := " order by dict_sort asc "
querySql := r.selectSql + whereSql + orderSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysDictData{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectDictDataByCodes 根据字典数据编码查询信息
func (r *SysDictDataImpl) SelectDictDataByCodes(dictCodes []string) []model.SysDictData {
placeholder := repo.KeyPlaceholderByQuery(len(dictCodes))
querySql := r.selectSql + " where dict_code in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(dictCodes)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysDictData{}
}
// 转换实体
return r.convertResultRows(results)
}
// CountDictDataByType 查询字典数据
func (r *SysDictDataImpl) CountDictDataByType(dictType string) int64 {
querySql := "select count(1) as 'total' from sys_dict_data where dict_type = ?"
results, err := datasource.RawDB("", querySql, []any{dictType})
if err != nil {
logger.Errorf("query err => %v", err)
return 0
}
if len(results) > 0 {
return parse.Number(results[0]["total"])
}
return 0
}
// CheckUniqueDictData 校验字典数据是否唯一
func (r *SysDictDataImpl) CheckUniqueDictData(sysDictData model.SysDictData) string {
// 查询条件拼接
var conditions []string
var params []any
if sysDictData.DictType != "" {
conditions = append(conditions, "dict_type = ?")
params = append(params, sysDictData.DictType)
}
if sysDictData.DictLabel != "" {
conditions = append(conditions, "dict_label = ?")
params = append(params, sysDictData.DictLabel)
}
if sysDictData.DictValue != "" {
conditions = append(conditions, "dict_value = ?")
params = append(params, sysDictData.DictValue)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
} else {
return ""
}
// 查询数据
querySql := "select dict_code as 'str' from sys_dict_data " + whereSql + " limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
return ""
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}
// DeleteDictDataByCodes 批量删除字典数据信息
func (r *SysDictDataImpl) DeleteDictDataByCodes(dictCodes []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(dictCodes))
sql := "delete from sys_dict_data where dict_code in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(dictCodes)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// InsertDictData 新增字典数据信息
func (r *SysDictDataImpl) InsertDictData(sysDictData model.SysDictData) string {
// 参数拼接
params := make(map[string]any)
if sysDictData.DictSort > 0 {
params["dict_sort"] = sysDictData.DictSort
}
if sysDictData.DictLabel != "" {
params["dict_label"] = sysDictData.DictLabel
}
if sysDictData.DictValue != "" {
params["dict_value"] = sysDictData.DictValue
}
if sysDictData.DictType != "" {
params["dict_type"] = sysDictData.DictType
}
if sysDictData.TagClass != "" {
params["tag_class"] = sysDictData.TagClass
}
if sysDictData.TagType != "" {
params["tag_type"] = sysDictData.TagType
}
if sysDictData.Status != "" {
params["status"] = sysDictData.Status
}
if sysDictData.Remark != "" {
params["remark"] = sysDictData.Remark
}
if sysDictData.CreateBy != "" {
params["create_by"] = sysDictData.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_dict_data (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// UpdateDictData 修改字典数据信息
func (r *SysDictDataImpl) UpdateDictData(sysDictData model.SysDictData) int64 {
// 参数拼接
params := make(map[string]any)
if sysDictData.DictSort > 0 {
params["dict_sort"] = sysDictData.DictSort
}
if sysDictData.DictLabel != "" {
params["dict_label"] = sysDictData.DictLabel
}
if sysDictData.DictValue != "" {
params["dict_value"] = sysDictData.DictValue
}
if sysDictData.DictType != "" {
params["dict_type"] = sysDictData.DictType
}
if sysDictData.Status != "" {
params["status"] = sysDictData.Status
}
params["tag_class"] = sysDictData.TagClass
params["tag_type"] = sysDictData.TagType
params["remark"] = sysDictData.Remark
if sysDictData.UpdateBy != "" {
params["update_by"] = sysDictData.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_dict_data set " + strings.Join(keys, ",") + " where dict_code = ?"
// 执行更新
values = append(values, sysDictData.DictCode)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// UpdateDictDataType 同步修改字典类型
func (r *SysDictDataImpl) UpdateDictDataType(oldDictType string, newDictType string) int64 {
// 参数拼接
params := make([]any, 0)
if oldDictType == "" || newDictType == "" {
return 0
}
params = append(params, newDictType)
params = append(params, oldDictType)
// 构建执行语句
sql := "update sys_dict_data set dict_type = ? where dict_type = ?"
// 执行更新
rows, err := datasource.ExecDB("", sql, params)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}

207
src/modules/system/repository/sys_dict_type.go
View File

@@ -1,30 +1,197 @@
package repository
import "be.ems/src/modules/system/model"
import (
"fmt"
"time"
// ISysDictType 字典类型表 数据层接口
type ISysDictType interface {
// SelectDictTypePage 根据条件分页查询字典类型
SelectDictTypePage(query map[string]any) map[string]any
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectDictTypeList 根据条件查询字典类型
SelectDictTypeList(sysDictType model.SysDictType) []model.SysDictType
// NewSysDictType 实例化数据层
var NewSysDictType = &SysDictType{}
// SelectDictTypeByIDs 根据字典类型ID查询信息
SelectDictTypeByIDs(dictIDs []string) []model.SysDictType
// SysDictType 字典类型表 数据层处理
type SysDictType struct{}
// SelectDictTypeByType 根据字典类型查询信息
SelectDictTypeByType(dictType string) model.SysDictType
// SelectByPage 分页查询集合
func (r SysDictType) SelectByPage(query map[string]string) ([]model.SysDictType, int64) {
tx := db.DB("").Model(&model.SysDictType{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if v, ok := query["dictName"]; ok && v != "" {
tx = tx.Where("dict_name like concat(?, '%')", v)
}
if v, ok := query["dictType"]; ok && v != "" {
tx = tx.Where("dict_type like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s000", v)
tx = tx.Where("create_time >= ?", v)
} else if len(v) == 13 {
tx = tx.Where("create_time >= ?", v)
}
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s999", v)
tx = tx.Where("create_time <= ?", v)
} else if len(v) == 13 {
tx = tx.Where("create_time <= ?", v)
}
}
// CheckUniqueDictType 校验字典类型是否唯一
CheckUniqueDictType(sysDictType model.SysDictType) string
// 查询结果
var total int64 = 0
rows := []model.SysDictType{}
// InsertDictType 新增字典类型信息
InsertDictType(sysDictType model.SysDictType) string
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// UpdateDictType 修改字典类型信息
UpdateDictType(sysDictType model.SysDictType) int64
// DeleteDictTypeByIDs 批量删除字典类型信息
DeleteDictTypeByIDs(dictIDs []string) int64
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Select 查询集合
func (r SysDictType) Select(sysDictType model.SysDictType) []model.SysDictType {
tx := db.DB("").Model(&model.SysDictType{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysDictType.DictName != "" {
tx = tx.Where("dict_name like concat(?, '%')", sysDictType.DictName)
}
if sysDictType.DictType != "" {
tx = tx.Where("dict_type like concat(?, '%')", sysDictType.DictType)
}
if sysDictType.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysDictType.StatusFlag)
}
// 查询数据
rows := []model.SysDictType{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysDictType) SelectByIds(dictIds []int64) []model.SysDictType {
rows := []model.SysDictType{}
if len(dictIds) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysDictType{})
// 构建查询条件
tx = tx.Where("dict_id in ? and del_flag = '0'", dictIds)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r SysDictType) Insert(sysDictType model.SysDictType) int64 {
sysDictType.DelFlag = "0"
if sysDictType.CreateBy != "" {
ms := time.Now().UnixMilli()
sysDictType.UpdateBy = sysDictType.CreateBy
sysDictType.UpdateTime = ms
sysDictType.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&sysDictType).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysDictType.DictId
}
// Update 修改信息 返回受影响的行数
func (r SysDictType) Update(sysDictType model.SysDictType) int64 {
if sysDictType.DictId <= 0 {
return 0
}
if sysDictType.UpdateBy != "" {
sysDictType.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.SysDictType{})
// 构建查询条件
tx = tx.Where("dict_id = ?", sysDictType.DictId)
tx = tx.Omit("dict_id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysDictType).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息 返回受影响的行数
func (r SysDictType) DeleteByIds(dictIds []int64) int64 {
if len(dictIds) <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysDictType{})
// 构建查询条件
tx = tx.Where("dict_id in ?", dictIds)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一 返回数据ID
func (r SysDictType) CheckUnique(sysDictType model.SysDictType) int64 {
tx := db.DB("").Model(&model.SysDictType{})
tx = tx.Where("del_flag = 0")
// 查询条件拼接
if sysDictType.DictName != "" {
tx = tx.Where("dict_name = ?", sysDictType.DictName)
}
if sysDictType.DictType != "" {
tx = tx.Where("dict_type = ?", sysDictType.DictType)
}
// 查询数据
var id int64 = 0
if err := tx.Select("dict_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// SelectByType 通过字典类型查询信息
func (r SysDictType) SelectByType(dictType string) model.SysDictType {
item := model.SysDictType{}
if dictType == "" {
return item
}
tx := db.DB("").Model(&model.SysDictType{})
tx.Where("dict_type = ? and del_flag = '0'", dictType)
// 查询数据
if err := tx.Limit(1).Find(&item).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return item
}
return item
}

329
src/modules/system/repository/sys_dict_type.impl.go
View File

@@ -1,329 +0,0 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysDictTypeImpl 结构体
var NewSysDictType = &SysDictTypeImpl{
selectSql: `select
dict_id, dict_name, dict_type, status, create_by, create_time, remark
from sys_dict_type`,
resultMap: map[string]string{
"dict_id": "DictID",
"dict_name": "DictName",
"dict_type": "DictType",
"remark": "Remark",
"status": "Status",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
},
}
// SysDictTypeImpl 字典类型表 数据层处理
type SysDictTypeImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysDictTypeImpl) convertResultRows(rows []map[string]any) []model.SysDictType {
arr := make([]model.SysDictType, 0)
for _, row := range rows {
sysDictType := model.SysDictType{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysDictType, keyMapper, value)
}
}
arr = append(arr, sysDictType)
}
return arr
}
// SelectDictTypePage 根据条件分页查询字典类型
func (r *SysDictTypeImpl) SelectDictTypePage(query map[string]any) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["dictName"]; ok && v != "" {
conditions = append(conditions, "dict_name like concat(?, '%')")
params = append(params, strings.TrimSpace(v.(string)))
}
if v, ok := query["dictType"]; ok && v != "" {
conditions = append(conditions, "dict_type like concat(?, '%')")
params = append(params, strings.TrimSpace(v.(string)))
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "status = ?")
params = append(params, v)
}
beginTime, ok := query["beginTime"]
if !ok {
beginTime, ok = query["params[beginTime]"]
}
if ok && beginTime != "" {
conditions = append(conditions, "create_time >= ?")
params = append(params, parse.Number(beginTime.(string)))
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "create_time <= ?")
params = append(params, parse.Number(endTime.(string)))
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysDictType{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_dict_type"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectDictTypeList 根据条件查询字典类型
func (r *SysDictTypeImpl) SelectDictTypeList(sysDictType model.SysDictType) []model.SysDictType {
// 查询条件拼接
var conditions []string
var params []any
if sysDictType.DictName != "" {
conditions = append(conditions, "dict_name like concat(?, '%')")
params = append(params, sysDictType.DictName)
}
if sysDictType.DictType != "" {
conditions = append(conditions, "dict_type like concat(?, '%')")
params = append(params, sysDictType.DictType)
}
if sysDictType.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, sysDictType.Status)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysDictType{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectDictTypeByIDs 根据字典类型ID查询信息
func (r *SysDictTypeImpl) SelectDictTypeByIDs(dictIDs []string) []model.SysDictType {
placeholder := repo.KeyPlaceholderByQuery(len(dictIDs))
querySql := r.selectSql + " where dict_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(dictIDs)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysDictType{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectDictTypeByType 根据字典类型查询信息
func (r *SysDictTypeImpl) SelectDictTypeByType(dictType string) model.SysDictType {
querySql := r.selectSql + " where dict_type = ?"
results, err := datasource.RawDB("", querySql, []any{dictType})
if err != nil {
logger.Errorf("query err => %v", err)
return model.SysDictType{}
}
// 转换实体
rows := r.convertResultRows(results)
if len(rows) > 0 {
return rows[0]
}
return model.SysDictType{}
}
// CheckUniqueDictType 校验字典是否唯一
func (r *SysDictTypeImpl) CheckUniqueDictType(sysDictType model.SysDictType) string {
// 查询条件拼接
var conditions []string
var params []any
if sysDictType.DictName != "" {
conditions = append(conditions, "dict_name = ?")
params = append(params, sysDictType.DictName)
}
if sysDictType.DictType != "" {
conditions = append(conditions, "dict_type = ?")
params = append(params, sysDictType.DictType)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
} else {
return ""
}
// 查询数据
querySql := "select dict_id as 'str' from sys_dict_type " + whereSql + " limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
return ""
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}
// InsertDictType 新增字典类型信息
func (r *SysDictTypeImpl) InsertDictType(sysDictType model.SysDictType) string {
// 参数拼接
params := make(map[string]any)
if sysDictType.DictName != "" {
params["dict_name"] = sysDictType.DictName
}
if sysDictType.DictType != "" {
params["dict_type"] = sysDictType.DictType
}
if sysDictType.Status != "" {
params["status"] = sysDictType.Status
}
if sysDictType.Remark != "" {
params["remark"] = sysDictType.Remark
}
if sysDictType.CreateBy != "" {
params["create_by"] = sysDictType.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_dict_type (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// UpdateDictType 修改字典类型信息
func (r *SysDictTypeImpl) UpdateDictType(sysDictType model.SysDictType) int64 {
// 参数拼接
params := make(map[string]any)
if sysDictType.DictName != "" {
params["dict_name"] = sysDictType.DictName
}
if sysDictType.DictType != "" {
params["dict_type"] = sysDictType.DictType
}
if sysDictType.Status != "" {
params["status"] = sysDictType.Status
}
params["remark"] = sysDictType.Remark
if sysDictType.UpdateBy != "" {
params["update_by"] = sysDictType.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_dict_type set " + strings.Join(keys, ",") + " where dict_id = ?"
// 执行更新
values = append(values, sysDictType.DictID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// DeleteDictTypeByIDs 批量删除字典类型信息
func (r *SysDictTypeImpl) DeleteDictTypeByIDs(dictIDs []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(dictIDs))
sql := "delete from sys_dict_type where dict_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(dictIDs)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

122
src/modules/system/repository/sys_i18n.go Normal file
View File

@@ -0,0 +1,122 @@
package repository
import (
"time"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// NewSysI18n 实例化数据层
var NewSysI18n = &SysI18n{}
// SysI18nRepository 多语言 数据层处理
type SysI18n struct{}
// Select 查询集合
func (r SysI18n) Select(param model.SysI18n) []model.SysI18n {
tx := db.DB("").Model(&model.SysI18n{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if param.Key != "" {
tx = tx.Where("key = ?", param.Key)
}
if param.ValueZh != "" {
tx = tx.Where("value_zh = ?", param.ValueZh)
}
if param.ValueEn != "" {
tx = tx.Where("value_en = ?", param.ValueEn)
}
// 查询数据
rows := []model.SysI18n{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysI18n) SelectByIds(ids []int64) []model.SysI18n {
rows := []model.SysI18n{}
if len(ids) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysI18n{})
// 构建查询条件
tx = tx.Where("id in ? and del_flag = '0'", ids)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r SysI18n) Insert(param model.SysI18n) int64 {
param.DelFlag = "0"
if param.CreateBy != "" {
ms := time.Now().UnixMilli()
param.UpdateBy = param.CreateBy
param.UpdateTime = ms
param.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&param).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return param.ID
}
// Update 修改信息 返回受影响行数
func (r SysI18n) Update(param model.SysI18n) int64 {
if param.ID <= 0 {
return 0
}
if param.UpdateBy != "" {
param.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.SysI18n{})
// 构建查询条件
tx = tx.Where("id = ?", param.ID)
tx = tx.Omit("id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(param).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息 返回受影响行数
func (r SysI18n) DeleteByIds(ids []int64) int64 {
if len(ids) <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysI18n{})
// 构建查询条件
tx = tx.Where("id in ?", ids)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一 返回ID
func (r SysI18n) CheckUnique(key string) int64 {
tx := db.DB("").Model(&model.SysI18n{})
tx = tx.Where("del_flag = 0 and key= ?", key)
// 查询数据
var id int64 = 0
if err := tx.Select("id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}

96
src/modules/system/repository/sys_log_login.go
View File

@@ -1,21 +1,91 @@
package repository
import "be.ems/src/modules/system/model"
import (
"fmt"
"time"
// ISysLogLogin 系统登录日志表 数据层接口
type ISysLogLogin interface {
// SelectSysLogLoginPage 分页查询系统登录日志集合
SelectSysLogLoginPage(query map[string]any, dataScopeSQL string) map[string]any
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectSysLogLoginList 查询系统登录日志集合
SelectSysLogLoginList(sysLogLogin model.SysLogLogin) []model.SysLogLogin
// NewSysLogLogin 实例化数据层
var NewSysLogLogin = &SysLogLogin{}
// InsertSysLogLogin 新增系统登录日志
InsertSysLogLogin(sysLogLogin model.SysLogLogin) string
// SysLogLoginRepository 系统登录访问表 数据层处理
type SysLogLogin struct{}
// DeleteSysLogLoginByIds 批量删除系统登录日志
DeleteSysLogLoginByIds(loginIds []string) int64
// SelectByPage 分页查询集合
func (r SysLogLogin) SelectByPage(query map[string]string, dataScopeSQL string) ([]model.SysLogLogin, int64) {
tx := db.DB("").Model(&model.SysLogLogin{})
// 查询条件拼接
if v, ok := query["loginIp"]; ok && v != "" {
tx = tx.Where("login_ip like concat(?, '%')", v)
}
if v, ok := query["userName"]; ok && v != "" {
tx = tx.Where("user_name like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s000", v)
tx = tx.Where("login_time >= ?", v)
} else if len(v) == 13 {
tx = tx.Where("login_time >= ?", v)
}
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s999", v)
tx = tx.Where("login_time <= ?", v)
} else if len(v) == 13 {
tx = tx.Where("login_time <= ?", v)
}
}
if dataScopeSQL != "" {
dataScopeSQL = fmt.Sprintf("select distinct user_name from sys_user where %s", dataScopeSQL)
tx = tx.Where(fmt.Sprintf("user_name in ( %s )", dataScopeSQL))
}
// CleanSysLogLogin 清空系统登录日志
CleanSysLogLogin() error
// 查询结果
var total int64 = 0
rows := []model.SysLogLogin{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Order("id desc").Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Insert 新增信息 返回新增的数据ID
func (r SysLogLogin) Insert(sysLogLogin model.SysLogLogin) int64 {
sysLogLogin.LoginTime = time.Now().UnixMilli()
// 执行插入
if err := db.DB("").Create(&sysLogLogin).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysLogLogin.ID
}
// Clean 清空信息
func (r SysLogLogin) Clean() int64 {
tx := db.DB("").Delete(&model.SysLogLogin{})
if err := tx.Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

255
src/modules/system/repository/sys_log_login.impl.go
View File

@@ -1,255 +0,0 @@
package repository
import (
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysLogLoginImpl 结构体
var NewSysLogLoginImpl = &SysLogLoginImpl{
selectSql: `select login_id, user_name, ipaddr, login_location,
browser, os, status, msg, login_time from sys_log_login`,
resultMap: map[string]string{
"login_id": "LoginID",
"user_name": "UserName",
"status": "Status",
"ipaddr": "IPAddr",
"login_location": "LoginLocation",
"browser": "Browser",
"os": "OS",
"msg": "Msg",
"login_time": "LoginTime",
},
}
// SysLogLoginImpl 系统登录访问表 数据层处理
type SysLogLoginImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysLogLoginImpl) convertResultRows(rows []map[string]any) []model.SysLogLogin {
arr := make([]model.SysLogLogin, 0)
for _, row := range rows {
SysLogLogin := model.SysLogLogin{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&SysLogLogin, keyMapper, value)
}
}
arr = append(arr, SysLogLogin)
}
return arr
}
// SelectSysLogLoginPage 分页查询系统登录日志集合
func (r *SysLogLoginImpl) SelectSysLogLoginPage(query map[string]any, dataScopeSQL string) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["ipaddr"]; ok && v != "" {
conditions = append(conditions, "ipaddr like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["userName"]; ok && v != "" {
conditions = append(conditions, "user_name like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "status = ?")
params = append(params, v)
}
beginTime, ok := query["beginTime"]
if !ok {
beginTime, ok = query["params[beginTime]"]
}
if ok && beginTime != "" {
conditions = append(conditions, "login_time >= ?")
params = append(params, parse.Number(beginTime.(string)))
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "login_time <= ?")
params = append(params, parse.Number(endTime.(string)))
}
// 构建查询条件语句
selectSql := r.selectSql
totalSql := "select count(login_id) as 'total' from sys_log_login"
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
whereSql += dataScopeSQL
} else if dataScopeSQL != "" {
totalSql = `select count(o.login_id) as 'total'
from sys_log_login o
left join sys_user u on u.user_name = o.user_name
left join sys_dept d on u.dept_id = d.dept_id`
selectSql = `select o.login_id, o.user_name, o.ipaddr, o.login_location,
o.browser, o.os, o.status, o.msg, o.login_time
from sys_log_login o
left join sys_user u on u.user_name = o.user_name
left join sys_dept d on u.dept_id = d.dept_id`
whereSql += " where 1=1" + dataScopeSQL
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysLogLogin{},
}
// 查询数量 长度为0直接返回
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " order by login_id desc limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := selectSql + whereSql + dataScopeSQL + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectSysLogLoginList 查询系统登录日志集合
func (r *SysLogLoginImpl) SelectSysLogLoginList(SysLogLogin model.SysLogLogin) []model.SysLogLogin {
// 查询条件拼接
var conditions []string
var params []any
if SysLogLogin.IPAddr != "" {
conditions = append(conditions, "title like concat(?, '%')")
params = append(params, SysLogLogin.IPAddr)
}
if SysLogLogin.UserName != "" {
conditions = append(conditions, "user_name like concat(?, '%')")
params = append(params, SysLogLogin.UserName)
}
if SysLogLogin.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, SysLogLogin.Status)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysLogLogin{}
}
// 转换实体
return r.convertResultRows(results)
}
// InsertSysLogLogin 新增系统登录日志
func (r *SysLogLoginImpl) InsertSysLogLogin(SysLogLogin model.SysLogLogin) string {
// 参数拼接
params := make(map[string]any)
params["login_time"] = time.Now().UnixMilli()
if SysLogLogin.UserName != "" {
params["user_name"] = SysLogLogin.UserName
}
if SysLogLogin.Status != "" {
params["status"] = SysLogLogin.Status
}
if SysLogLogin.IPAddr != "" {
params["ipaddr"] = SysLogLogin.IPAddr
}
if SysLogLogin.LoginLocation != "" {
params["login_location"] = SysLogLogin.LoginLocation
}
if SysLogLogin.Browser != "" {
params["browser"] = SysLogLogin.Browser
}
if SysLogLogin.OS != "" {
params["os"] = SysLogLogin.OS
}
if SysLogLogin.Msg != "" {
params["msg"] = SysLogLogin.Msg
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_log_login (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// DeleteSysLogLoginByIds 批量删除系统登录日志
func (r *SysLogLoginImpl) DeleteSysLogLoginByIds(loginIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(loginIds))
sql := "delete from sys_log_login where login_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(loginIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// CleanSysLogLogin 清空系统登录日志
func (r *SysLogLoginImpl) CleanSysLogLogin() error {
sql := "truncate table sys_log_login"
_, err := datasource.ExecDB("", sql, []any{})
return err
}

105
src/modules/system/repository/sys_log_operate.go
View File

@@ -1,24 +1,99 @@
package repository
import "be.ems/src/modules/system/model"
import (
"fmt"
"time"
// ISysLogOperate 操作日志表 数据层接口
type ISysLogOperate interface {
// SelectSysLogOperatePage 分页查询系统操作日志集合
SelectSysLogOperatePage(query map[string]any, dataScopeSQL string) map[string]any
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectSysLogOperateList 查询系统操作日志集合
SelectSysLogOperateList(sysLogOperate model.SysLogOperate) []model.SysLogOperate
// NewSysLogOperate 实例化数据层
var NewSysLogOperate = &SysLogOperate{}
// SelectSysLogOperateById 查询操作日志详细
SelectSysLogOperateById(operId string) model.SysLogOperate
// SysLogOperateRepository 操作日志表 数据层处理
type SysLogOperate struct{}
// InsertSysLogOperate 新增操作日志
InsertSysLogOperate(sysLogOperate model.SysLogOperate) string
// SelectByPage 分页查询集合
func (r SysLogOperate) SelectByPage(query map[string]string, dataScopeSQL string) ([]model.SysLogOperate, int64) {
tx := db.DB("").Model(&model.SysLogOperate{})
// 查询条件拼接
if v, ok := query["title"]; ok && v != "" {
tx = tx.Where("title like concat(?, '%')", v)
}
if v, ok := query["businessType"]; ok && v != "" {
tx = tx.Where("business_type = ?", v)
}
if v, ok := query["operaBy"]; ok && v != "" {
tx = tx.Where("opera_by like concat(?, '%')", v)
}
if v, ok := query["operaIp"]; ok && v != "" {
tx = tx.Where("opera_ip like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s000", v)
tx = tx.Where("opera_time >= ?", v)
} else if len(v) == 13 {
tx = tx.Where("opera_time >= ?", v)
}
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s999", v)
tx = tx.Where("opera_time <= ?", v)
} else if len(v) == 13 {
tx = tx.Where("opera_time <= ?", v)
}
}
if dataScopeSQL != "" {
dataScopeSQL = fmt.Sprintf("select distinct user_name from sys_user where %s", dataScopeSQL)
tx = tx.Where(fmt.Sprintf("opera_by in ( %s )", dataScopeSQL))
}
// DeleteSysLogOperateByIds 批量删除系统操作日志
DeleteSysLogOperateByIds(operIds []string) int64
// 查询结果
var total int64 = 0
rows := []model.SysLogOperate{}
// CleanSysLogOperate 清空操作日志
CleanSysLogOperate() error
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Order("id desc").Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Insert 新增信息
func (r SysLogOperate) Insert(sysLogOperate model.SysLogOperate) int64 {
if sysLogOperate.OperaBy != "" {
sysLogOperate.OperaTime = time.Now().UnixMilli()
}
// 执行插入
if err := db.DB("").Create(&sysLogOperate).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysLogOperate.ID
}
// Clean 清空信息
func (r SysLogOperate) Clean() int64 {
tx := db.DB("").Delete(&model.SysLogOperate{})
if err := tx.Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

310
src/modules/system/repository/sys_log_operate.impl.go
View File

@@ -1,310 +0,0 @@
package repository
import (
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysLogOperateImpl 结构体
var NewSysLogOperateImpl = &SysLogOperateImpl{
selectSql: `select
oper_id, title, business_type, method, request_method, operator_type, oper_name, dept_name,
oper_url, oper_ip, oper_location, oper_param, oper_msg, status, oper_time, cost_time
from sys_log_operate`,
resultMap: map[string]string{
"oper_id": "OperID",
"title": "Title",
"business_type": "BusinessType",
"method": "Method",
"request_method": "RequestMethod",
"operator_type": "OperatorType",
"oper_name": "OperName",
"dept_name": "DeptName",
"oper_url": "OperURL",
"oper_ip": "OperIP",
"oper_location": "OperLocation",
"oper_param": "OperParam",
"oper_msg": "OperMsg",
"status": "Status",
"oper_time": "OperTime",
"cost_time": "CostTime",
},
}
// SysLogOperateImpl 操作日志表 数据层处理
type SysLogOperateImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysLogOperateImpl) convertResultRows(rows []map[string]any) []model.SysLogOperate {
arr := make([]model.SysLogOperate, 0)
for _, row := range rows {
SysLogOperate := model.SysLogOperate{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&SysLogOperate, keyMapper, value)
}
}
arr = append(arr, SysLogOperate)
}
return arr
}
// SelectSysLogOperatePage 分页查询系统操作日志集合
func (r *SysLogOperateImpl) SelectSysLogOperatePage(query map[string]any, dataScopeSQL string) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["title"]; ok && v != "" {
conditions = append(conditions, "title like concat(?, '%')")
params = append(params, strings.TrimSpace(v.(string)))
}
if v, ok := query["businessType"]; ok && v != "" {
conditions = append(conditions, "business_type = ?")
params = append(params, v)
}
if v, ok := query["operName"]; ok && v != "" {
conditions = append(conditions, "oper_name like concat(?, '%')")
params = append(params, strings.TrimSpace(v.(string)))
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "status = ?")
params = append(params, v)
}
beginTime, ok := query["beginTime"]
if !ok {
beginTime, ok = query["params[beginTime]"]
}
if ok && beginTime != "" {
conditions = append(conditions, "oper_time >= ?")
params = append(params, parse.Number(beginTime.(string)))
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "oper_time <= ?")
params = append(params, parse.Number(endTime.(string)))
}
// 构建查询条件语句
selectSql := r.selectSql
totalSql := "select count(oper_id) as 'total' from sys_log_operate"
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
whereSql += dataScopeSQL
} else if dataScopeSQL != "" {
totalSql = `select count(o.oper_id) as 'total'
from sys_log_operate o
left join sys_user u on u.user_name = o.oper_name
left join sys_dept d on u.dept_id = d.dept_id`
selectSql = `select
o.oper_id, o.title, o.business_type, o.method, o.request_method, o.operator_type, o.oper_name, o.dept_name,
o.oper_url, o.oper_ip, o.oper_location, o.oper_param, o.oper_msg, o.status, o.oper_time, o.cost_time
from sys_log_operate o
left join sys_user u on u.user_name = o.oper_name
left join sys_dept d on u.dept_id = d.dept_id`
whereSql += " where 1=1" + dataScopeSQL
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysLogOperate{},
}
// 查询数量 长度为0直接返回
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " order by oper_id desc limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectSysLogOperateList 查询系统操作日志集合
func (r *SysLogOperateImpl) SelectSysLogOperateList(SysLogOperate model.SysLogOperate) []model.SysLogOperate {
// 查询条件拼接
var conditions []string
var params []any
if SysLogOperate.Title != "" {
conditions = append(conditions, "title like concat(?, '%')")
params = append(params, SysLogOperate.Title)
}
if SysLogOperate.BusinessType != "" {
conditions = append(conditions, "business_type = ?")
params = append(params, SysLogOperate.BusinessType)
}
if SysLogOperate.OperName != "" {
conditions = append(conditions, "oper_name like concat(?, '%')")
params = append(params, SysLogOperate.OperName)
}
if SysLogOperate.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, SysLogOperate.Status)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := r.selectSql + whereSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysLogOperate{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectSysLogOperateById 查询操作日志详细
func (r *SysLogOperateImpl) SelectSysLogOperateById(operId string) model.SysLogOperate {
querySql := r.selectSql + " where oper_id = ?"
results, err := datasource.RawDB("", querySql, []any{operId})
if err != nil {
logger.Errorf("query err => %v", err)
return model.SysLogOperate{}
}
// 转换实体
rows := r.convertResultRows(results)
if len(rows) > 0 {
return rows[0]
}
return model.SysLogOperate{}
}
// InsertSysLogOperate 新增操作日志
func (r *SysLogOperateImpl) InsertSysLogOperate(SysLogOperate model.SysLogOperate) string {
// 参数拼接
params := make(map[string]any)
params["oper_time"] = time.Now().UnixMilli()
if SysLogOperate.Title != "" {
params["title"] = SysLogOperate.Title
}
if SysLogOperate.BusinessType != "" {
params["business_type"] = SysLogOperate.BusinessType
}
if SysLogOperate.Method != "" {
params["method"] = SysLogOperate.Method
}
if SysLogOperate.RequestMethod != "" {
params["request_method"] = SysLogOperate.RequestMethod
}
if SysLogOperate.OperatorType != "" {
params["operator_type"] = SysLogOperate.OperatorType
}
if SysLogOperate.DeptName != "" {
params["dept_name"] = SysLogOperate.DeptName
}
if SysLogOperate.OperName != "" {
params["oper_name"] = SysLogOperate.OperName
}
if SysLogOperate.OperURL != "" {
params["oper_url"] = SysLogOperate.OperURL
}
if SysLogOperate.OperIP != "" {
params["oper_ip"] = SysLogOperate.OperIP
}
if SysLogOperate.OperLocation != "" {
params["oper_location"] = SysLogOperate.OperLocation
}
if SysLogOperate.OperParam != "" {
params["oper_param"] = SysLogOperate.OperParam
}
if SysLogOperate.OperMsg != "" {
params["oper_msg"] = SysLogOperate.OperMsg
}
if SysLogOperate.Status != "" {
params["status"] = SysLogOperate.Status
}
if SysLogOperate.CostTime > 0 {
params["cost_time"] = SysLogOperate.CostTime
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_log_operate (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// DeleteSysLogOperateByIds 批量删除系统操作日志
func (r *SysLogOperateImpl) DeleteSysLogOperateByIds(operIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(operIds))
sql := "delete from sys_log_operate where oper_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(operIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// CleanSysLogOperate 清空操作日志
func (r *SysLogOperateImpl) CleanSysLogOperate() error {
sql := "truncate table sys_log_operate"
_, err := datasource.ExecDB("", sql, []any{})
return err
}

304
src/modules/system/repository/sys_menu.go
View File

@@ -1,36 +1,286 @@
package repository
import "be.ems/src/modules/system/model"
import (
"time"
// ISysMenu 菜单表 数据层接口
type ISysMenu interface {
// SelectMenuList 查询系统菜单列表
SelectMenuList(sysMenu model.SysMenu, userId string) []model.SysMenu
"be.ems/src/framework/constants"
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectMenuPermsByUserId 根据用户ID查询权限
SelectMenuPermsByUserId(userId string) []string
// NewSysMenu 实例化数据层
var NewSysMenu = &SysMenu{}
// SelectMenuTreeByUserId 根据用户ID查询菜单
SelectMenuTreeByUserId(userId string) []model.SysMenu
// SysMenu 菜单表 数据层处理
type SysMenu struct{}
// SelectMenuListByRoleId 根据角色ID查询菜单树信息
SelectMenuListByRoleId(roleId string, menuCheckStrictly bool) []string
// Select 查询集合 userId为0是系统管理员
func (r SysMenu) Select(sysMenu model.SysMenu, userId int64) []model.SysMenu {
tx := db.DB("").Model(&model.SysMenu{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysMenu.MenuName != "" {
tx = tx.Where("menu_name like concat(?, '%')", sysMenu.MenuName)
}
if sysMenu.VisibleFlag != "" {
tx = tx.Where("visible_flag = ?", sysMenu.VisibleFlag)
}
if sysMenu.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysMenu.StatusFlag)
}
// SelectMenuByIds 根据菜单ID查询信息
SelectMenuByIds(menuIds []string) []model.SysMenu
// 个人菜单
if userId > 0 {
tx = tx.Where(`menu_id in (
select menu_id from sys_role_menu where role_id in (
select role_id from sys_user_role where user_id = ?
))`, userId)
}
// HasChildByMenuIdAndStatus 存在菜单子节点数量与状态
HasChildByMenuIdAndStatus(menuId, status string) int64
// InsertMenu 新增菜单信息
InsertMenu(sysMenu model.SysMenu) string
// UpdateMenu 修改菜单信息
UpdateMenu(sysMenu model.SysMenu) int64
// DeleteMenuById 删除菜单管理信息
DeleteMenuById(menuId string) int64
// CheckUniqueMenu 校验菜单是否唯一
CheckUniqueMenu(sysMenu model.SysMenu) string
// 查询数据
rows := []model.SysMenu{}
tx.Order("parent_id, menu_sort")
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysMenu) SelectByIds(menuIds []int64) []model.SysMenu {
rows := []model.SysMenu{}
if len(menuIds) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysMenu{})
// 构建查询条件
tx = tx.Where("menu_id in ? and del_flag = '0'", menuIds)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息
func (r SysMenu) Insert(sysMenu model.SysMenu) int64 {
sysMenu.DelFlag = "0"
if sysMenu.MenuId <= 0 {
return 0
}
if sysMenu.Icon == "" {
sysMenu.Icon = "#"
}
if sysMenu.CreateBy != "" {
ms := time.Now().UnixMilli()
sysMenu.UpdateBy = sysMenu.CreateBy
sysMenu.UpdateTime = ms
sysMenu.CreateTime = ms
}
// 根据菜单类型重置参数
if sysMenu.MenuType == constants.MENU_TYPE_BUTTON {
sysMenu.Component = ""
sysMenu.FrameFlag = "1"
sysMenu.CacheFlag = "1"
sysMenu.VisibleFlag = "1"
sysMenu.MenuPath = ""
sysMenu.Icon = "#"
} else if sysMenu.MenuType == constants.MENU_TYPE_DIR {
sysMenu.Component = ""
sysMenu.FrameFlag = "1"
sysMenu.CacheFlag = "1"
sysMenu.Perms = ""
}
// 执行插入
if err := db.DB("").Create(&sysMenu).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysMenu.MenuId
}
// Update 修改信息
func (r SysMenu) Update(sysMenu model.SysMenu) int64 {
if sysMenu.MenuId <= 0 {
return 0
}
if sysMenu.Icon == "" {
sysMenu.Icon = "#"
}
if sysMenu.UpdateBy != "" {
sysMenu.UpdateTime = time.Now().UnixMilli()
}
// 根据菜单类型重置参数
if sysMenu.MenuType == constants.MENU_TYPE_BUTTON {
sysMenu.Component = ""
sysMenu.FrameFlag = "1"
sysMenu.CacheFlag = "1"
sysMenu.VisibleFlag = "1"
sysMenu.MenuPath = ""
sysMenu.Icon = "#"
} else if sysMenu.MenuType == constants.MENU_TYPE_DIR {
sysMenu.Component = ""
sysMenu.FrameFlag = "1"
sysMenu.CacheFlag = "1"
sysMenu.Perms = ""
}
tx := db.DB("").Model(&model.SysMenu{})
// 构建查询条件
tx = tx.Where("menu_id = ?", sysMenu.MenuId)
tx = tx.Omit("menu_id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysMenu).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteById 删除信息 返回受影响行数
func (r SysMenu) DeleteById(menuId int64) int64 {
if menuId <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysMenu{})
// 构建查询条件
tx = tx.Where("menu_id = ?", menuId)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一
func (r SysMenu) CheckUnique(sysMenu model.SysMenu) int64 {
tx := db.DB("").Model(&model.SysMenu{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysMenu.ParentId <= 0 {
tx = tx.Where("parent_id = ?", sysMenu.ParentId)
}
if sysMenu.MenuName != "" {
tx = tx.Where("menu_name = ?", sysMenu.MenuName)
}
if sysMenu.MenuPath != "" {
tx = tx.Where("menu_path = ?", sysMenu.MenuPath)
}
// 查询数据
var id int64 = 0
if err := tx.Select("menu_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// ExistChildrenByMenuIdAndStatus 菜单下同状态存在子节点数量
func (r SysMenu) ExistChildrenByMenuIdAndStatus(menuId int64, statusFlag string) int64 {
if menuId <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysMenu{})
// 构建查询条件
tx = tx.Where("parent_id = ? and del_flag = '0'", menuId)
if statusFlag != "" {
tx = tx.Where("status_flag = ?", statusFlag)
tx = tx.Where("menu_type in ?", []string{constants.MENU_TYPE_DIR, constants.MENU_TYPE_MENU})
}
// 查询数据
var count int64 = 0
if err := tx.Count(&count).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return count
}
return count
}
// SelectPermsByUserId 根据用户ID查询权限标识
func (r SysMenu) SelectPermsByUserId(userId int64) []string {
rows := []string{}
if userId <= 0 {
return rows
}
tx := db.DB("").Table("sys_menu m")
// 构建查询条件
tx = tx.Distinct("m.perms").
Joins("left join sys_role_menu rm on m.menu_id = rm.menu_id").
Joins("left join sys_user_role ur on rm.role_id = ur.role_id").
Joins("left join sys_role r on r.role_id = ur.role_id").
Where("m.status_flag = '1' and m.perms != '' and r.status_flag = '1' and r.del_flag = '0'").
Where("ur.user_id = ?", userId)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByRoleId 根据角色ID查询菜单树信息
func (r SysMenu) SelectByRoleId(roleId int64, menuCheckStrictly bool) []int64 {
if roleId <= 0 {
return []int64{}
}
tx := db.DB("").Model(&model.SysMenu{})
tx = tx.Where("del_flag = '0'")
tx = tx.Where("menu_id in (select menu_id from sys_role_menu where role_id = ?)", roleId)
// 父子互相关联显示，取所有子节点
if menuCheckStrictly {
tx = tx.Where(`menu_id not in (
select m.parent_id from sys_menu m
inner join sys_role_menu rm on m.menu_id = rm.menu_id
and rm.role_id = ?
)`, roleId)
}
// 查询数据
rows := []int64{}
if err := tx.Distinct("menu_id").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectTreeByUserId 根据用户ID查询菜单 0为管理员查询全部菜单，其他为用户ID查询权限
func (r SysMenu) SelectTreeByUserId(userId int64) []model.SysMenu {
if userId < 0 {
return []model.SysMenu{}
}
tx := db.DB("").Model(&model.SysMenu{})
tx = tx.Where("del_flag = '0'")
// 管理员全部菜单
if userId == 0 {
tx = tx.Where("menu_type in ? and status_flag = '1'", []string{constants.MENU_TYPE_DIR, constants.MENU_TYPE_MENU})
tx.Order("parent_id, menu_sort")
} else {
// 用户ID权限
tx = tx.Where(`menu_type in ? and status_flag = '1'
and menu_id in (
select menu_id from sys_role_menu where role_id in (
select role_id from sys_user_role where user_id = ?
))`, []string{constants.MENU_TYPE_DIR, constants.MENU_TYPE_MENU}, userId)
tx.Order("parent_id, menu_sort")
}
// 查询数据
rows := []model.SysMenu{}
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}

474
src/modules/system/repository/sys_menu.impl.go
View File

@@ -1,474 +0,0 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/constants/menu"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysMenuImpl 结构体
var NewSysMenuImpl = &SysMenuImpl{
selectSql: `select
m.menu_id, m.menu_name, m.parent_id, m.menu_sort, m.path, m.component, m.is_frame, m.is_cache, m.menu_type, m.visible, m.status, ifnull(m.perms,'') as perms, m.icon, m.create_time, m.remark
from sys_menu m`,
selectSqlByUser: `select distinct
m.menu_id, m.menu_name, m.parent_id, m.menu_sort, m.path, m.component, m.is_frame, m.is_cache, m.menu_type, m.visible, m.status, ifnull(m.perms,'') as perms, m.icon, m.create_time, m.remark
from sys_menu m
left join sys_role_menu rm on m.menu_id = rm.menu_id
left join sys_user_role ur on rm.role_id = ur.role_id
left join sys_role ro on ur.role_id = ro.role_id`,
resultMap: map[string]string{
"menu_id": "MenuID",
"menu_name": "MenuName",
"parent_name": "ParentName",
"parent_id": "ParentID",
"path": "Path",
"menu_sort": "MenuSort",
"component": "Component",
"is_frame": "IsFrame",
"is_cache": "IsCache",
"menu_type": "MenuType",
"visible": "Visible",
"status": "Status",
"perms": "Perms",
"icon": "Icon",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
"remark": "Remark",
},
}
// SysMenuImpl 菜单表 数据层处理
type SysMenuImpl struct {
// 查询视图对象SQL
selectSql string
// 查询视图用户对象SQL
selectSqlByUser string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysMenuImpl) convertResultRows(rows []map[string]any) []model.SysMenu {
arr := make([]model.SysMenu, 0)
for _, row := range rows {
sysMenu := model.SysMenu{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysMenu, keyMapper, value)
}
}
arr = append(arr, sysMenu)
}
return arr
}
// SelectMenuList 查询系统菜单列表
func (r *SysMenuImpl) SelectMenuList(sysMenu model.SysMenu, userId string) []model.SysMenu {
// 查询条件拼接
var conditions []string
var params []any
if sysMenu.MenuName != "" {
conditions = append(conditions, "m.menu_name like concat(?, '%')")
params = append(params, sysMenu.MenuName)
}
if sysMenu.Visible != "" {
conditions = append(conditions, "m.visible = ?")
params = append(params, sysMenu.Visible)
}
if sysMenu.Status != "" {
conditions = append(conditions, "m.status = ?")
params = append(params, sysMenu.Status)
}
fromSql := r.selectSql
// 个人菜单
if userId != "*" {
fromSql = r.selectSqlByUser
conditions = append(conditions, "ur.user_id = ?")
params = append(params, userId)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
orderSql := " order by m.parent_id, m.menu_sort"
querySql := fromSql + whereSql + orderSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysMenu{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectMenuPermsByUserId 根据用户ID查询权限
func (r *SysMenuImpl) SelectMenuPermsByUserId(userId string) []string {
querySql := `select distinct m.perms as 'str' from sys_menu m
left join sys_role_menu rm on m.menu_id = rm.menu_id
left join sys_user_role ur on rm.role_id = ur.role_id
left join sys_role r on r.role_id = ur.role_id
where m.status = '1' and m.perms != '' and r.status = '1' and ur.user_id = ? `
// 查询结果
results, err := datasource.RawDB("", querySql, []any{userId})
if err != nil {
logger.Errorf("query err => %v", err)
return []string{}
}
// 读取结果
rows := make([]string, 0)
for _, m := range results {
rows = append(rows, fmt.Sprintf("%v", m["str"]))
}
return rows
}
// SelectMenuTreeByUserId 根据用户ID查询菜单
func (r *SysMenuImpl) SelectMenuTreeByUserId(userId string) []model.SysMenu {
var params []any
var querySql string
if userId == "*" {
// 管理员全部菜单
querySql = r.selectSql + ` where
m.menu_type in (?,?) and m.status = '1'
order by m.parent_id, m.menu_sort`
params = append(params, menu.TYPE_DIR)
params = append(params, menu.TYPE_MENU)
} else {
// 用户ID权限
querySql = r.selectSqlByUser + ` where
m.menu_type in (?, ?) and m.status = '1'
and ur.user_id = ? and ro.status = '1'
order by m.parent_id, m.menu_sort`
params = append(params, menu.TYPE_DIR)
params = append(params, menu.TYPE_MENU)
params = append(params, userId)
}
// 查询结果
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysMenu{}
}
return r.convertResultRows(results)
}
// SelectMenuListByRoleId 根据角色ID查询菜单树信息
func (r *SysMenuImpl) SelectMenuListByRoleId(roleId string, menuCheckStrictly bool) []string {
querySql := `select m.menu_id as 'str' from sys_menu m
left join sys_role_menu rm on m.menu_id = rm.menu_id
where rm.role_id = ? `
var params []any
params = append(params, roleId)
// 展开
if menuCheckStrictly {
querySql += ` and m.menu_id not in
(select m.parent_id from sys_menu m
inner join sys_role_menu rm on m.menu_id = rm.menu_id
and rm.role_id = ?) `
params = append(params, roleId)
}
// 查询结果
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []string{}
}
if len(results) > 0 {
ids := make([]string, 0)
for _, v := range results {
ids = append(ids, fmt.Sprintf("%v", v["str"]))
}
return ids
}
return []string{}
}
// SelectMenuByIds 根据菜单ID查询信息
func (r *SysMenuImpl) SelectMenuByIds(menuIds []string) []model.SysMenu {
placeholder := repo.KeyPlaceholderByQuery(len(menuIds))
querySql := r.selectSql + " where m.menu_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(menuIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysMenu{}
}
// 转换实体
return r.convertResultRows(results)
}
// HasChildByMenuIdAndStatus 存在菜单子节点数量与状态
func (r *SysMenuImpl) HasChildByMenuIdAndStatus(menuId, status string) int64 {
querySql := "select count(1) as 'total' from sys_menu where parent_id = ?"
params := []any{menuId}
// 菜单状态
if status != "" {
querySql += " and status = ? and menu_type in (?, ?) "
params = append(params, status)
params = append(params, menu.TYPE_DIR)
params = append(params, menu.TYPE_MENU)
}
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return 0
}
if len(results) > 0 {
return parse.Number(results[0]["total"])
}
return 0
}
// InsertMenu 新增菜单信息
func (r *SysMenuImpl) InsertMenu(sysMenu model.SysMenu) string {
// 参数拼接
params := make(map[string]any)
if sysMenu.MenuID != "" {
params["menu_id"] = sysMenu.MenuID
}
if sysMenu.ParentID != "" {
params["parent_id"] = sysMenu.ParentID
}
if sysMenu.MenuName != "" {
params["menu_name"] = sysMenu.MenuName
}
if sysMenu.MenuSort > 0 {
params["menu_sort"] = sysMenu.MenuSort
}
if sysMenu.Path != "" {
params["path"] = sysMenu.Path
}
if sysMenu.Component != "" {
params["component"] = sysMenu.Component
}
if sysMenu.IsFrame != "" {
params["is_frame"] = sysMenu.IsFrame
}
if sysMenu.IsCache != "" {
params["is_cache"] = sysMenu.IsCache
}
if sysMenu.MenuType != "" {
params["menu_type"] = sysMenu.MenuType
}
if sysMenu.Visible != "" {
params["visible"] = sysMenu.Visible
}
if sysMenu.Status != "" {
params["status"] = sysMenu.Status
}
if sysMenu.Perms != "" {
params["perms"] = sysMenu.Perms
}
if sysMenu.Icon != "" {
params["icon"] = sysMenu.Icon
} else {
params["icon"] = "#"
}
if sysMenu.Remark != "" {
params["remark"] = sysMenu.Remark
}
if sysMenu.CreateBy != "" {
params["create_by"] = sysMenu.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 根据菜单类型重置参数
if sysMenu.MenuType == menu.TYPE_BUTTON {
params["component"] = ""
params["path"] = ""
params["icon"] = "#"
params["is_cache"] = "1"
params["is_frame"] = "1"
params["visible"] = "1"
params["status"] = "1"
}
if sysMenu.MenuType == menu.TYPE_DIR {
params["component"] = ""
params["perms"] = ""
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_menu (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// UpdateMenu 修改菜单信息
func (r *SysMenuImpl) UpdateMenu(sysMenu model.SysMenu) int64 {
// 参数拼接
params := make(map[string]any)
if sysMenu.MenuID != "" {
params["menu_id"] = sysMenu.MenuID
}
if sysMenu.ParentID != "" {
params["parent_id"] = sysMenu.ParentID
}
if sysMenu.MenuName != "" {
params["menu_name"] = sysMenu.MenuName
}
if sysMenu.MenuSort > 0 {
params["menu_sort"] = sysMenu.MenuSort
}
if sysMenu.Path != "" {
params["path"] = sysMenu.Path
}
if sysMenu.Component != "" {
params["component"] = sysMenu.Component
}
if sysMenu.IsFrame != "" {
params["is_frame"] = sysMenu.IsFrame
}
if sysMenu.IsCache != "" {
params["is_cache"] = sysMenu.IsCache
}
if sysMenu.MenuType != "" {
params["menu_type"] = sysMenu.MenuType
}
if sysMenu.Visible != "" {
params["visible"] = sysMenu.Visible
}
if sysMenu.Status != "" {
params["status"] = sysMenu.Status
}
if sysMenu.Perms != "" {
params["perms"] = sysMenu.Perms
}
if sysMenu.Icon != "" {
params["icon"] = sysMenu.Icon
} else {
params["icon"] = "#"
}
params["remark"] = sysMenu.Remark
if sysMenu.UpdateBy != "" {
params["update_by"] = sysMenu.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 根据菜单类型重置参数
if sysMenu.MenuType == menu.TYPE_BUTTON {
params["component"] = ""
params["path"] = ""
params["icon"] = "#"
params["is_cache"] = "1"
params["is_frame"] = "1"
params["visible"] = "1"
params["status"] = "1"
}
if sysMenu.MenuType == menu.TYPE_DIR {
params["component"] = ""
params["perms"] = ""
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_menu set " + strings.Join(keys, ",") + " where menu_id = ?"
// 执行更新
values = append(values, sysMenu.MenuID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// DeleteMenuById 删除菜单管理信息
func (r *SysMenuImpl) DeleteMenuById(menuId string) int64 {
sql := "delete from sys_menu where menu_id = ?"
results, err := datasource.ExecDB("", sql, []any{menuId})
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// CheckUniqueMenu 校验菜单是否唯一
func (r *SysMenuImpl) CheckUniqueMenu(sysMenu model.SysMenu) string {
// 查询条件拼接
var conditions []string
var params []any
if sysMenu.MenuName != "" {
conditions = append(conditions, "menu_name = ?")
params = append(params, sysMenu.MenuName)
}
if sysMenu.ParentID != "" {
conditions = append(conditions, "parent_id = ?")
params = append(params, sysMenu.ParentID)
}
if sysMenu.Path != "" {
conditions = append(conditions, "path = ?")
params = append(params, sysMenu.Path)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
if whereSql == "" {
return ""
}
// 查询数据
querySql := "select menu_id as 'str' from sys_menu " + whereSql + " limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
return ""
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}

192
src/modules/system/repository/sys_post.go
View File

@@ -1,30 +1,182 @@
package repository
import "be.ems/src/modules/system/model"
import (
"time"
// ISysPost 岗位表 数据层接口
type ISysPost interface {
// SelectPostPage 查询岗位分页数据集合
SelectPostPage(query map[string]any) map[string]any
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectPostList 查询岗位数据集合
SelectPostList(sysPost model.SysPost) []model.SysPost
// NewSysPost 实例化数据层
var NewSysPost = &SysPost{}
// SelectPostByIds 通过岗位ID查询岗位信息
SelectPostByIds(postIds []string) []model.SysPost
// SysPost 岗位表 数据层处理
type SysPost struct{}
// SelectPostListByUserId 根据用户ID获取岗位选择框列表
SelectPostListByUserId(userId string) []model.SysPost
// SelectByPage 分页查询集合
func (r SysPost) SelectByPage(query map[string]string) ([]model.SysPost, int64) {
tx := db.DB("").Model(&model.SysPost{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if v, ok := query["postCode"]; ok && v != "" {
tx = tx.Where("post_code like concat(?, '%')", v)
}
if v, ok := query["postName"]; ok && v != "" {
tx = tx.Where("post_name like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
// DeletePostByIds 批量删除岗位信息
DeletePostByIds(postIds []string) int64
// 查询结果
var total int64 = 0
rows := []model.SysPost{}
// UpdatePost 修改岗位信息
UpdatePost(sysPost model.SysPost) int64
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// InsertPost 新增岗位信息
InsertPost(sysPost model.SysPost) string
// CheckUniquePost 校验岗位唯一
CheckUniquePost(sysPost model.SysPost) string
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Order("post_sort asc").Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Select 查询集合
func (r SysPost) Select(sysPost model.SysPost) []model.SysPost {
tx := db.DB("").Model(&model.SysPost{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysPost.PostCode != "" {
tx = tx.Where("post_code like concat(?, '%')", sysPost.PostCode)
}
if sysPost.PostName != "" {
tx = tx.Where("post_name like concat(?, '%')", sysPost.PostName)
}
if sysPost.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysPost.StatusFlag)
}
// 查询数据
rows := []model.SysPost{}
if err := tx.Order("post_sort asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysPost) SelectByIds(postIds []int64) []model.SysPost {
rows := []model.SysPost{}
if len(postIds) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysPost{})
// 构建查询条件
tx = tx.Where("post_id in ? and del_flag = '0'", postIds)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r SysPost) Insert(sysPost model.SysPost) int64 {
sysPost.DelFlag = "0"
if sysPost.CreateBy != "" {
ms := time.Now().UnixMilli()
sysPost.UpdateBy = sysPost.CreateBy
sysPost.UpdateTime = ms
sysPost.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&sysPost).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysPost.PostId
}
// Update 修改信息 返回受影响行数
func (r SysPost) Update(sysPost model.SysPost) int64 {
if sysPost.PostId <= 0 {
return 0
}
if sysPost.UpdateBy != "" {
sysPost.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.SysPost{})
// 构建查询条件
tx = tx.Where("post_id = ?", sysPost.PostId)
tx = tx.Omit("post_id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysPost).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息 返回受影响行数
func (r SysPost) DeleteByIds(postIds []int64) int64 {
if len(postIds) <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysPost{})
// 构建查询条件
tx = tx.Where("post_id in ?", postIds)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一 返回ID
func (r SysPost) CheckUnique(sysPost model.SysPost) int64 {
tx := db.DB("").Model(&model.SysPost{})
tx = tx.Where("del_flag = 0")
// 查询条件拼接
if sysPost.PostName != "" {
tx = tx.Where("post_name= ?", sysPost.PostName)
}
if sysPost.PostCode != "" {
tx = tx.Where("post_code = ?", sysPost.PostCode)
}
// 查询数据
var id int64 = 0
if err := tx.Select("post_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// SelectByUserId 根据用户ID获取岗位选择框列表
func (r SysPost) SelectByUserId(userId int64) []model.SysPost {
rows := []model.SysPost{}
if userId <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysPost{})
// 构建查询条件
tx = tx.Where("post_id in (select post_id from sys_user_post where user_id = ?)", userId)
// 查询数据
if err := tx.Order("post_id").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}

321
src/modules/system/repository/sys_post.impl.go
View File

@@ -1,321 +0,0 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysPostImpl 结构体
var NewSysPostImpl = &SysPostImpl{
selectSql: `select
post_id, post_code, post_name, post_sort, status, create_by, create_time, remark
from sys_post`,
resultMap: map[string]string{
"post_id": "PostID",
"post_code": "PostCode",
"post_name": "PostName",
"post_sort": "PostSort",
"status": "Status",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
"remark": "Remark",
},
}
// SysPostImpl 岗位表 数据层处理
type SysPostImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysPostImpl) convertResultRows(rows []map[string]any) []model.SysPost {
arr := make([]model.SysPost, 0)
for _, row := range rows {
sysPost := model.SysPost{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysPost, keyMapper, value)
}
}
arr = append(arr, sysPost)
}
return arr
}
// SelectPostPage 查询岗位分页数据集合
func (r *SysPostImpl) SelectPostPage(query map[string]any) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["postCode"]; ok && v != "" {
conditions = append(conditions, "post_code like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["postName"]; ok && v != "" {
conditions = append(conditions, "post_name like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "status = ?")
params = append(params, v)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysPost{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_post"
totalRows, err := datasource.RawDB("", totalSql+whereSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " order by post_sort limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := r.selectSql + whereSql + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectPostList 查询岗位数据集合
func (r *SysPostImpl) SelectPostList(sysPost model.SysPost) []model.SysPost {
// 查询条件拼接
var conditions []string
var params []any
if sysPost.PostCode != "" {
conditions = append(conditions, "post_code like concat(?, '%')")
params = append(params, sysPost.PostCode)
}
if sysPost.PostName != "" {
conditions = append(conditions, "post_name like concat(?, '%')")
params = append(params, sysPost.PostName)
}
if sysPost.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, sysPost.Status)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询数据
orderSql := " order by post_sort"
querySql := r.selectSql + whereSql + orderSql
rows, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysPost{}
}
return r.convertResultRows(rows)
}
// SelectPostByIds 通过岗位ID查询岗位信息
func (r *SysPostImpl) SelectPostByIds(postIds []string) []model.SysPost {
placeholder := repo.KeyPlaceholderByQuery(len(postIds))
querySql := r.selectSql + " where post_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(postIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysPost{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectPostListByUserId 根据用户ID获取岗位选择框列表
func (r *SysPostImpl) SelectPostListByUserId(userId string) []model.SysPost {
// 查询数据
querySql := `select distinct
p.post_id, p.post_name, p.post_code
from sys_post p
left join sys_user_post up on up.post_id = p.post_id
left join sys_user u on u.user_id = up.user_id
where u.user_id = ? order by p.post_id`
rows, err := datasource.RawDB("", querySql, []any{userId})
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysPost{}
}
return r.convertResultRows(rows)
}
// DeletePostByIds 批量删除岗位信息
func (r *SysPostImpl) DeletePostByIds(postIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(postIds))
sql := "delete from sys_post where post_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(postIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// UpdatePost 修改岗位信息
func (r *SysPostImpl) UpdatePost(sysPost model.SysPost) int64 {
// 参数拼接
params := make(map[string]any)
if sysPost.PostCode != "" {
params["post_code"] = sysPost.PostCode
}
if sysPost.PostName != "" {
params["post_name"] = sysPost.PostName
}
if sysPost.PostSort > 0 {
params["post_sort"] = sysPost.PostSort
}
if sysPost.Status != "" {
params["status"] = sysPost.Status
}
params["remark"] = sysPost.Remark
if sysPost.UpdateBy != "" {
params["update_by"] = sysPost.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_post set " + strings.Join(keys, ",") + " where post_id = ?"
// 执行更新
values = append(values, sysPost.PostID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// InsertPost 新增岗位信息
func (r *SysPostImpl) InsertPost(sysPost model.SysPost) string {
// 参数拼接
params := make(map[string]any)
if sysPost.PostID != "" {
params["post_id"] = sysPost.PostID
}
if sysPost.PostCode != "" {
params["post_code"] = sysPost.PostCode
}
if sysPost.PostName != "" {
params["post_name"] = sysPost.PostName
}
if sysPost.PostSort > 0 {
params["post_sort"] = sysPost.PostSort
}
if sysPost.Status != "" {
params["status"] = sysPost.Status
}
if sysPost.Remark != "" {
params["remark"] = sysPost.Remark
}
if sysPost.CreateBy != "" {
params["create_by"] = sysPost.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_post (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// CheckUniquePost 校验岗位唯一
func (r *SysPostImpl) CheckUniquePost(sysPost model.SysPost) string {
// 查询条件拼接
var conditions []string
var params []any
if sysPost.PostName != "" {
conditions = append(conditions, "post_name= ?")
params = append(params, sysPost.PostName)
}
if sysPost.PostCode != "" {
conditions = append(conditions, "post_code = ?")
params = append(params, sysPost.PostCode)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
} else {
return ""
}
// 查询数据
querySql := "select post_id as 'str' from sys_post " + whereSql + " limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}

219
src/modules/system/repository/sys_role.go
View File

@@ -1,30 +1,209 @@
package repository
import "be.ems/src/modules/system/model"
import (
"fmt"
"time"
// ISysRole 角色表 数据层接口
type ISysRole interface {
// SelectRolePage 根据条件分页查询角色数据
SelectRolePage(query map[string]any, dataScopeSQL string) map[string]any
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// SelectRoleList 根据条件查询角色数据
SelectRoleList(sysRole model.SysRole, dataScopeSQL string) []model.SysRole
// NewSysRole 实例化数据层
var NewSysRole = &SysRole{}
// SelectRoleListByUserId 根据用户ID获取角色选择框列表
SelectRoleListByUserId(userId string) []model.SysRole
// SysRole 角色表 数据层处理
type SysRole struct{}
// SelectRoleByIds 通过角色ID查询角色
SelectRoleByIds(roleIds []string) []model.SysRole
// SelectByPage 分页查询集合
func (r SysRole) SelectByPage(query map[string]string) ([]model.SysRole, int64) {
tx := db.DB("").Model(&model.SysRole{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if v, ok := query["roleName"]; ok && v != "" {
tx = tx.Where("role_name like concat(?, '%')", v)
}
if v, ok := query["roleKey"]; ok && v != "" {
tx = tx.Where("role_key like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s000", v)
tx = tx.Where("create_time >= ?", v)
} else if len(v) == 13 {
tx = tx.Where("create_time >= ?", v)
}
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s999", v)
tx = tx.Where("create_time <= ?", v)
} else if len(v) == 13 {
tx = tx.Where("create_time <= ?", v)
}
}
if v, ok := query["deptId"]; ok && v != "" {
tx = tx.Where(`role_id in (
select distinct role_id from sys_role_dept where sys_role_dept.dept_id IN (
SELECT dept_id FROM sys_dept WHERE dept_id = ? or find_in_set(? , ancestors )
))`, v, v)
}
// UpdateRole 修改角色信息
UpdateRole(sysRole model.SysRole) int64
// 查询结果
var total int64 = 0
rows := []model.SysRole{}
// InsertRole 新增角色信息
InsertRole(sysRole model.SysRole) string
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// DeleteRoleByIds 批量删除角色信息
DeleteRoleByIds(roleIds []string) int64
// CheckUniqueRole 校验角色是否唯一
CheckUniqueRole(sysRole model.SysRole) string
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Order("role_sort asc").Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Select 查询集合
func (r SysRole) Select(sysRole model.SysRole) []model.SysRole {
tx := db.DB("").Model(&model.SysRole{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysRole.RoleKey != "" {
tx = tx.Where("role_key like concat(?, '%')", sysRole.RoleKey)
}
if sysRole.RoleName != "" {
tx = tx.Where("role_name like concat(?, '%')", sysRole.RoleName)
}
if sysRole.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysRole.StatusFlag)
}
// 查询数据
rows := []model.SysRole{}
if err := tx.Order("role_sort asc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysRole) SelectByIds(roleIds []int64) []model.SysRole {
rows := []model.SysRole{}
if len(roleIds) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysRole{})
// 构建查询条件
tx = tx.Where("role_id in ? and del_flag = '0'", roleIds)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息 返回新增数据ID
func (r SysRole) Insert(sysRole model.SysRole) int64 {
sysRole.DelFlag = "0"
if sysRole.CreateBy != "" {
ms := time.Now().UnixMilli()
sysRole.UpdateBy = sysRole.CreateBy
sysRole.UpdateTime = ms
sysRole.CreateTime = ms
}
// 执行插入
if err := db.DB("").Create(&sysRole).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysRole.RoleId
}
// Update 修改信息 返回受影响行数
func (r SysRole) Update(sysRole model.SysRole) int64 {
if sysRole.RoleId <= 0 {
return 0
}
if sysRole.UpdateBy != "" {
sysRole.UpdateTime = time.Now().UnixMilli()
}
tx := db.DB("").Model(&model.SysRole{})
// 构建查询条件
tx = tx.Where("role_id = ?", sysRole.RoleId)
tx = tx.Omit("role_id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysRole).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息 返回受影响行数
func (r SysRole) DeleteByIds(roleIds []int64) int64 {
if len(roleIds) <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysRole{})
// 构建查询条件
tx = tx.Where("role_id in ?", roleIds)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一
func (r SysRole) CheckUnique(sysRole model.SysRole) int64 {
tx := db.DB("").Model(&model.SysRole{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysRole.RoleName != "" {
tx = tx.Where("role_name = ?", sysRole.RoleName)
}
if sysRole.RoleKey != "" {
tx = tx.Where("role_key = ?", sysRole.RoleKey)
}
// 查询数据
var id int64 = 0
if err := tx.Select("role_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// SelectByUserId 根据用户ID获取角色信息
func (r SysRole) SelectByUserId(userId int64) []model.SysRole {
rows := []model.SysRole{}
if userId <= 0 {
return rows
}
tx := db.DB("").Table("sys_user_role ur")
// 构建查询条件
tx = tx.Distinct("r.role_id, r.role_name, r.role_key, r.role_sort, r.data_scope, r.menu_check_strictly, r.dept_check_strictly, r.status_flag, r.del_flag, r.create_time, r.remark").
Joins("left join sys_user u on u.user_id = ur.user_id").
Joins("left join sys_role r on r.role_id = ur.role_id").
Where("u.del_flag = '0' AND ur.user_id = ?", userId)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}

375
src/modules/system/repository/sys_role.impl.go
View File

@@ -1,375 +0,0 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysRoleImpl 结构体
var NewSysRoleImpl = &SysRoleImpl{
selectSql: `select distinct
r.role_id, r.role_name, r.role_key, r.role_sort, r.data_scope, r.menu_check_strictly,
r.dept_check_strictly, r.status, r.del_flag, r.create_time, r.remark
from sys_role r
left join sys_user_role ur on ur.role_id = r.role_id
left join sys_user u on u.user_id = ur.user_id
left join sys_dept d on u.dept_id = d.dept_id`,
resultMap: map[string]string{
"role_id": "RoleID",
"role_name": "RoleName",
"role_key": "RoleKey",
"role_sort": "RoleSort",
"data_scope": "DataScope",
"menu_check_strictly": "MenuCheckStrictly",
"dept_check_strictly": "DeptCheckStrictly",
"status": "Status",
"del_flag": "DelFlag",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
"remark": "Remark",
},
}
// SysRoleImpl 角色表 数据层处理
type SysRoleImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysRoleImpl) convertResultRows(rows []map[string]any) []model.SysRole {
arr := make([]model.SysRole, 0)
for _, row := range rows {
sysRole := model.SysRole{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysRole, keyMapper, value)
}
}
arr = append(arr, sysRole)
}
return arr
}
// SelectRolePage 根据条件分页查询角色数据
func (r *SysRoleImpl) SelectRolePage(query map[string]any, dataScopeSQL string) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["roleId"]; ok && v != "" {
conditions = append(conditions, "r.role_id = ?")
params = append(params, v)
}
if v, ok := query["roleName"]; ok && v != "" {
conditions = append(conditions, "r.role_name like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["roleKey"]; ok && v != "" {
conditions = append(conditions, "r.role_key like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "r.status = ?")
params = append(params, v)
}
beginTime, ok := query["beginTime"]
if !ok {
beginTime, ok = query["params[beginTime]"]
}
if ok && beginTime != "" {
conditions = append(conditions, "r.create_time >= ?")
params = append(params, parse.Number(beginTime.(string)))
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "r.create_time <= ?")
params = append(params, parse.Number(endTime.(string)))
}
if v, ok := query["deptId"]; ok && v != "" {
conditions = append(conditions, `(u.dept_id = ? or u.dept_id in (
select t.dept_id from sys_dept t where find_in_set(?, ancestors)
))`)
params = append(params, v)
params = append(params, v)
}
// 构建查询条件语句
whereSql := " where r.del_flag = '0' and r.role_id != '1' "
if len(conditions) > 0 {
whereSql += " and " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysRole{},
}
// 查询数量 长度为0直接返回
totalSql := `select count(distinct r.role_id) as 'total' from sys_role r
left join sys_user_role ur on ur.role_id = r.role_id
left join sys_user u on u.user_id = ur.user_id
left join sys_dept d on u.dept_id = d.dept_id`
totalRows, err := datasource.RawDB("", totalSql+whereSql+dataScopeSQL, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " order by r.role_sort asc limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := r.selectSql + whereSql + dataScopeSQL + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectRoleList 根据条件查询角色数据
func (r *SysRoleImpl) SelectRoleList(sysRole model.SysRole, dataScopeSQL string) []model.SysRole {
// 查询条件拼接
var conditions []string
var params []any
if sysRole.RoleID != "" {
conditions = append(conditions, "r.role_id = ?")
params = append(params, sysRole.RoleID)
}
if sysRole.RoleKey != "" {
conditions = append(conditions, "r.role_key like concat(?, '%')")
params = append(params, sysRole.RoleKey)
}
if sysRole.RoleName != "" {
conditions = append(conditions, "r.role_name like concat(?, '%')")
params = append(params, sysRole.RoleName)
}
if sysRole.Status != "" {
conditions = append(conditions, "r.status = ?")
params = append(params, sysRole.Status)
}
// 构建查询条件语句
whereSql := " where r.del_flag = '0' "
if len(conditions) > 0 {
whereSql += " and " + strings.Join(conditions, " and ")
}
// 查询数据
orderSql := " order by r.role_sort"
querySql := r.selectSql + whereSql + dataScopeSQL + orderSql
rows, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysRole{}
}
return r.convertResultRows(rows)
}
// SelectRoleListByUserId 根据用户ID获取角色选择框列表
func (r *SysRoleImpl) SelectRoleListByUserId(userId string) []model.SysRole {
querySql := r.selectSql + " where r.del_flag = '0' and ur.user_id = ?"
results, err := datasource.RawDB("", querySql, []any{userId})
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysRole{}
}
return r.convertResultRows(results)
}
// SelectRoleByIds 通过角色ID查询角色
func (r *SysRoleImpl) SelectRoleByIds(roleIds []string) []model.SysRole {
placeholder := repo.KeyPlaceholderByQuery(len(roleIds))
querySql := r.selectSql + " where r.role_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(roleIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysRole{}
}
// 转换实体
return r.convertResultRows(results)
}
// UpdateRole 修改角色信息
func (r *SysRoleImpl) UpdateRole(sysRole model.SysRole) int64 {
// 参数拼接
params := make(map[string]any)
if sysRole.RoleName != "" {
params["role_name"] = sysRole.RoleName
}
if sysRole.RoleKey != "" {
params["role_key"] = sysRole.RoleKey
}
if sysRole.RoleSort > 0 {
params["role_sort"] = sysRole.RoleSort
}
if sysRole.DataScope != "" {
params["data_scope"] = sysRole.DataScope
}
if sysRole.MenuCheckStrictly != "" {
params["menu_check_strictly"] = sysRole.MenuCheckStrictly
}
if sysRole.DeptCheckStrictly != "" {
params["dept_check_strictly"] = sysRole.DeptCheckStrictly
}
if sysRole.Status != "" {
params["status"] = sysRole.Status
}
params["remark"] = sysRole.Remark
if sysRole.UpdateBy != "" {
params["update_by"] = sysRole.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_role set " + strings.Join(keys, ",") + " where role_id = ?"
// 执行更新
values = append(values, sysRole.RoleID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// InsertRole 新增角色信息
func (r *SysRoleImpl) InsertRole(sysRole model.SysRole) string {
// 参数拼接
params := make(map[string]any)
if sysRole.RoleID != "" {
params["role_id"] = sysRole.RoleID
}
if sysRole.RoleName != "" {
params["role_name"] = sysRole.RoleName
}
if sysRole.RoleKey != "" {
params["role_key"] = sysRole.RoleKey
}
if sysRole.RoleSort > 0 {
params["role_sort"] = sysRole.RoleSort
}
if sysRole.DataScope != "" {
params["data_scope"] = sysRole.DataScope
}
if sysRole.MenuCheckStrictly != "" {
params["menu_check_strictly"] = sysRole.MenuCheckStrictly
}
if sysRole.DeptCheckStrictly != "" {
params["dept_check_strictly"] = sysRole.DeptCheckStrictly
}
if sysRole.Status != "" {
params["status"] = sysRole.Status
}
params["remark"] = sysRole.Remark
if sysRole.CreateBy != "" {
params["create_by"] = sysRole.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_role (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// DeleteRoleByIds 批量删除角色信息
func (r *SysRoleImpl) DeleteRoleByIds(roleIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(roleIds))
sql := "update sys_role set del_flag = '1' where role_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(roleIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// CheckUniqueRole 校验角色是否唯一
func (r *SysRoleImpl) CheckUniqueRole(sysRole model.SysRole) string {
// 查询条件拼接
var conditions []string
var params []any
if sysRole.RoleName != "" {
conditions = append(conditions, "r.role_name = ?")
params = append(params, sysRole.RoleName)
}
if sysRole.RoleKey != "" {
conditions = append(conditions, "r.role_key = ?")
params = append(params, sysRole.RoleKey)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
} else {
return ""
}
// 查询数据
querySql := "select role_id as 'str' from sys_role r " + whereSql + " and r.del_flag = '0' limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
return ""
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}

58
src/modules/system/repository/sys_role_dept.go
View File

@@ -1,15 +1,55 @@
package repository
import "be.ems/src/modules/system/model"
import (
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// ISysRoleDept 角色与部门关联表 数据层接口
type ISysRoleDept interface {
// DeleteRoleDept 批量删除角色部门关联信息
DeleteRoleDept(roleIds []string) int64
// NewSysRoleDept 实例化数据层
var NewSysRoleDept = &SysRoleDept{}
// DeleteDeptRole 批量删除部门角色关联信息
DeleteDeptRole(deptIds []string) int64
// SysRoleDept 角色与部门关联表 数据层处理
type SysRoleDept struct{}
// BatchRoleDept 批量新增角色部门信息
BatchRoleDept(sysRoleDepts []model.SysRoleDept) int64
// DeleteByRoleIds 批量删除信息By角色
func (r SysRoleDept) DeleteByRoleIds(roleIds []int64) int64 {
if len(roleIds) <= 0 {
return 0
}
tx := db.DB("").Where("role_id in ?", roleIds)
// 执行删除
if err := tx.Delete(&model.SysRoleDept{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByDeptIds 批量删除信息By部门
func (r SysRoleDept) DeleteByDeptIds(deptIds []int64) int64 {
if len(deptIds) <= 0 {
return 0
}
tx := db.DB("").Where("dept_id in ?", deptIds)
// 执行删除
if err := tx.Delete(&model.SysRoleDept{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// BatchInsert 批量新增信息
func (r SysRoleDept) BatchInsert(sysRoleDepts []model.SysRoleDept) int64 {
if len(sysRoleDepts) <= 0 {
return 0
}
// 执行批量删除
tx := db.DB("").CreateInBatches(sysRoleDepts, 500)
if err := tx.Error; err != nil {
logger.Errorf("delete batch err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

58
src/modules/system/repository/sys_role_dept.impl.go
View File

@@ -1,58 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysRoleDeptImpl 结构体
var NewSysRoleDeptImpl = &SysRoleDeptImpl{}
// SysRoleDeptImpl 角色与部门关联表 数据层处理
type SysRoleDeptImpl struct{}
// DeleteRoleDept 批量删除角色部门关联信息
func (r *SysRoleDeptImpl) DeleteRoleDept(roleIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(roleIds))
sql := "delete from sys_role_dept where role_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(roleIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// DeleteDeptRole 批量删除部门角色关联信息
func (r *SysRoleDeptImpl) DeleteDeptRole(deptIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(deptIds))
sql := "delete from sys_role_dept where dept_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(deptIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// BatchRoleDept 批量新增角色部门信息
func (r *SysRoleDeptImpl) BatchRoleDept(sysRoleDepts []model.SysRoleDept) int64 {
keyValues := make([]string, 0)
for _, item := range sysRoleDepts {
keyValues = append(keyValues, fmt.Sprintf("(%s,%s)", item.RoleID, item.DeptID))
}
sql := "insert into sys_role_dept(role_id, dept_id) values " + strings.Join(keyValues, ",")
results, err := datasource.ExecDB("", sql, nil)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

77
src/modules/system/repository/sys_role_menu.go
View File

@@ -1,18 +1,71 @@
package repository
import "be.ems/src/modules/system/model"
import (
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// ISysRoleMenu 角色与菜单关联表 数据层接口
type ISysRoleMenu interface {
// CheckMenuExistRole 查询菜单分配给角色使用数量
CheckMenuExistRole(menuId string) int64
// NewSysRoleMenu 实例化数据层
var NewSysRoleMenu = &SysRoleMenu{}
// DeleteRoleMenu 批量删除角色和菜单关联
DeleteRoleMenu(roleIds []string) int64
// SysRoleMenu 角色与菜单关联表 数据层处理
type SysRoleMenu struct{}
// DeleteMenuRole 批量删除菜单和角色关联
DeleteMenuRole(menuIds []string) int64
// BatchRoleMenu 批量新增角色菜单信息
BatchRoleMenu(sysRoleMenus []model.SysRoleMenu) int64
// ExistRoleByMenuId 存在角色使用数量By菜单
func (r SysRoleMenu) ExistRoleByMenuId(menuId int64) int64 {
if menuId <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysRoleMenu{})
tx = tx.Where("menu_id = ?", menuId)
// 查询数据
var count int64 = 0
if err := tx.Count(&count).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return count
}
return count
}
// DeleteByRoleIds 批量删除关联By角色
func (r SysRoleMenu) DeleteByRoleIds(roleIds []int64) int64 {
if len(roleIds) <= 0 {
return 0
}
tx := db.DB("").Where("role_id in ?", roleIds)
// 执行删除
if err := tx.Delete(&model.SysRoleMenu{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByMenuIds 批量删除关联By菜单
func (r SysRoleMenu) DeleteByMenuIds(menuIds []int64) int64 {
if len(menuIds) <= 0 {
return 0
}
tx := db.DB("").Where("menu_id in ?", menuIds)
// 执行删除
if err := tx.Delete(&model.SysRoleMenu{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// BatchInsert 批量新增信息
func (r SysRoleMenu) BatchInsert(sysRoleMenus []model.SysRoleMenu) int64 {
if len(sysRoleMenus) <= 0 {
return 0
}
// 执行批量删除
tx := db.DB("").CreateInBatches(sysRoleMenus, 500)
if err := tx.Error; err != nil {
logger.Errorf("delete batch err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

73
src/modules/system/repository/sys_role_menu.impl.go
View File

@@ -1,73 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysRoleMenuImpl 结构体
var NewSysRoleMenuImpl = &SysRoleMenuImpl{}
// SysRoleMenuImpl 角色与菜单关联表 数据层处理
type SysRoleMenuImpl struct{}
// CheckMenuExistRole 查询菜单分配给角色使用数量
func (r *SysRoleMenuImpl) CheckMenuExistRole(menuId string) int64 {
querySql := "select count(1) as 'total' from sys_role_menu where menu_id = ?"
results, err := datasource.RawDB("", querySql, []any{menuId})
if err != nil {
logger.Errorf("query err => %v", err)
return 0
}
if len(results) > 0 {
return parse.Number(results[0]["total"])
}
return 0
}
// DeleteRoleMenu 批量删除角色和菜单关联
func (r *SysRoleMenuImpl) DeleteRoleMenu(roleIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(roleIds))
sql := "delete from sys_role_menu where role_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(roleIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// DeleteMenuRole 批量删除菜单和角色关联
func (r *SysRoleMenuImpl) DeleteMenuRole(menuIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(menuIds))
sql := "delete from sys_role_menu where menu_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(menuIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// BatchRoleMenu 批量新增角色菜单信息
func (r *SysRoleMenuImpl) BatchRoleMenu(sysRoleMenus []model.SysRoleMenu) int64 {
keyValues := make([]string, 0)
for _, item := range sysRoleMenus {
keyValues = append(keyValues, fmt.Sprintf("(%s,%s)", item.RoleID, item.MenuID))
}
sql := "insert into sys_role_menu(role_id, menu_id) values " + strings.Join(keyValues, ",")
results, err := datasource.ExecDB("", sql, nil)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

293
src/modules/system/repository/sys_user.go
View File

@@ -1,33 +1,280 @@
package repository
import "be.ems/src/modules/system/model"
import (
"fmt"
"time"
// ISysUser 用户表 数据层接口
type ISysUser interface {
// SelectUserPage 根据条件分页查询用户列表
SelectUserPage(query map[string]any, dataScopeSQL string) map[string]any
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/crypto"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/system/model"
)
// SelectAllocatedPage 根据条件分页查询分配用户角色列表
SelectAllocatedPage(query map[string]any, dataScopeSQL string) map[string]any
// NewSysUser 实例化数据层
var NewSysUser = &SysUser{}
// SelectUserList 根据条件查询用户列表
SelectUserList(sysUser model.SysUser, dataScopeSQL string) []model.SysUser
// SysUser 用户表 数据层处理
type SysUser struct{}
// SelectUserByIds 通过用户ID查询用户
SelectUserByIds(userIds []string) []model.SysUser
// SelectByPage 分页查询集合
func (r SysUser) SelectByPage(query map[string]string, dataScopeSQL string) ([]model.SysUser, int64) {
tx := db.DB("").Model(&model.SysUser{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if v, ok := query["userId"]; ok && v != "" {
tx = tx.Where("user_id = ?", v)
}
if v, ok := query["userName"]; ok && v != "" {
tx = tx.Where("user_name like concat(?, '%')", v)
}
if v, ok := query["phone"]; ok && v != "" {
tx = tx.Where("phone like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
if v, ok := query["beginTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s000", v)
tx = tx.Where("login_time >= ?", v)
} else if len(v) == 13 {
tx = tx.Where("login_time >= ?", v)
}
}
if v, ok := query["endTime"]; ok && v != "" {
if len(v) == 10 {
v = fmt.Sprintf("%s999", v)
tx = tx.Where("login_time <= ?", v)
} else if len(v) == 13 {
tx = tx.Where("login_time <= ?", v)
}
}
if v, ok := query["deptId"]; ok && v != "" {
tx = tx.Where(`(dept_id = ? or dept_id in (
select t.dept_id from sys_dept t where find_in_set(?, ancestors)
))`, v, v)
}
if dataScopeSQL != "" {
tx = tx.Where(dataScopeSQL)
}
// SelectUserByUserName 通过用户登录账号查询用户
SelectUserByUserName(userName string) model.SysUser
// 查询结果
var total int64 = 0
rows := []model.SysUser{}
// InsertUser 新增用户信息
InsertUser(sysUser model.SysUser) string
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// UpdateUser 修改用户信息
UpdateUser(sysUser model.SysUser) int64
// DeleteUserByIds 批量删除用户信息
DeleteUserByIds(userIds []string) int64
// CheckUniqueUser 校验用户信息是否唯一
CheckUniqueUser(sysUser model.SysUser) string
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Order("user_id desc").Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}
// Select 查询集合
func (r SysUser) Select(sysUser model.SysUser) []model.SysUser {
tx := db.DB("").Model(&model.SysUser{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if sysUser.UserName != "" {
tx = tx.Where("user_name like concat(?, '%')", sysUser.UserName)
}
if sysUser.Phone != "" {
tx = tx.Where("phone like concat(?, '%')", sysUser.Phone)
}
if sysUser.StatusFlag != "" {
tx = tx.Where("status_flag = ?", sysUser.StatusFlag)
}
if sysUser.UserId > 0 {
tx = tx.Where("user_id = ?", sysUser.UserId)
}
// 查询数据
rows := []model.SysUser{}
if err := tx.Order("login_time desc").Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// SelectByIds 通过ID查询信息
func (r SysUser) SelectByIds(userIds []int64) []model.SysUser {
rows := []model.SysUser{}
if len(userIds) <= 0 {
return rows
}
tx := db.DB("").Model(&model.SysUser{})
// 构建查询条件
tx = tx.Where("user_id in ? and del_flag = '0'", userIds)
// 查询数据
if err := tx.Find(&rows).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows
}
return rows
}
// Insert 新增信息
func (r SysUser) Insert(sysUser model.SysUser) int64 {
sysUser.DelFlag = "0"
if sysUser.CreateBy != "" {
ms := time.Now().UnixMilli()
sysUser.UpdateBy = sysUser.CreateBy
sysUser.UpdateTime = ms
sysUser.CreateTime = ms
}
if sysUser.Password != "" {
sysUser.Password = crypto.BcryptHash(sysUser.Password)
}
// 执行插入
if err := db.DB("").Create(&sysUser).Error; err != nil {
logger.Errorf("insert err => %v", err.Error())
return 0
}
return sysUser.UserId
}
// Update 修改信息
func (r SysUser) Update(sysUser model.SysUser) int64 {
if sysUser.UserId <= 0 {
return 0
}
if sysUser.UpdateBy != "" {
sysUser.UpdateTime = time.Now().UnixMilli()
}
if sysUser.Password != "" {
sysUser.Password = crypto.BcryptHash(sysUser.Password)
}
tx := db.DB("").Model(&model.SysUser{})
// 构建查询条件
tx = tx.Where("user_id = ?", sysUser.UserId)
tx = tx.Omit("user_id", "del_flag", "create_by", "create_time")
// 执行更新
if err := tx.Updates(sysUser).Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByIds 批量删除信息
func (r SysUser) DeleteByIds(userIds []int64) int64 {
if len(userIds) <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysUser{})
// 构建查询条件
tx = tx.Where("user_id in ?", userIds)
// 执行更新删除标记
if err := tx.Update("del_flag", "1").Error; err != nil {
logger.Errorf("update err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// CheckUnique 检查信息是否唯一
func (r SysUser) CheckUnique(sysUser model.SysUser) int64 {
tx := db.DB("").Model(&model.SysUser{})
tx = tx.Where("del_flag = 0")
// 查询条件拼接
if sysUser.UserName != "" {
tx = tx.Where("user_name = ?", sysUser.UserName)
}
if sysUser.Phone != "" {
tx = tx.Where("phone = ?", sysUser.Phone)
}
if sysUser.Email != "" {
tx = tx.Where("email = ?", sysUser.Email)
}
// 查询数据
var id int64 = 0
if err := tx.Select("user_id").Limit(1).Find(&id).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return id
}
return id
}
// SelectByUserName 通过登录账号查询信息
func (r SysUser) SelectByUserName(userName string) model.SysUser {
item := model.SysUser{}
if userName == "" {
return item
}
tx := db.DB("").Model(&model.SysUser{})
// 构建查询条件
tx = tx.Where("user_name = ? and del_flag = '0'", userName)
// 查询数据
if err := tx.Limit(1).Find(&item).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return item
}
return item
}
// SelectAuthUsersByPage 分页查询集合By分配用户角色
func (r SysUser) SelectAuthUsersByPage(query map[string]string, dataScopeSQL string) ([]model.SysUser, int64) {
tx := db.DB("").Model(&model.SysUser{})
tx = tx.Where("del_flag = '0'")
// 查询条件拼接
if v, ok := query["userName"]; ok && v != "" {
tx = tx.Where("user_name like concat(?, '%')", v)
}
if v, ok := query["phone"]; ok && v != "" {
tx = tx.Where("phone like concat(?, '%')", v)
}
if v, ok := query["statusFlag"]; ok && v != "" {
tx = tx.Where("status_flag = ?", v)
}
// 分配角色的用户
if roleId, ok := query["roleId"]; ok && roleId != "" {
auth, ok := query["auth"]
if ok && parse.Boolean(auth) {
tx = tx.Where(`user_id in (
select distinct u.user_id from sys_user u
inner join sys_user_role ur on u.user_id = ur.user_id
and ur.role_id = ?
)`, roleId)
} else {
tx = tx.Where(`user_id not in (
select distinct u.user_id from sys_user u
inner join sys_user_role ur on u.user_id = ur.user_id
and ur.role_id = ?
)`, roleId)
}
}
if dataScopeSQL != "" {
tx = tx.Where(dataScopeSQL)
}
// 查询结果
var total int64 = 0
rows := []model.SysUser{}
// 查询数量为0直接返回
if err := tx.Count(&total).Error; err != nil || total <= 0 {
return rows, total
}
// 查询数据分页
pageNum, pageSize := db.PageNumSize(query["pageNum"], query["pageSize"])
tx = tx.Limit(pageSize).Offset(pageSize * pageNum)
err := tx.Order("user_id desc").Find(&rows).Error
if err != nil {
logger.Errorf("query find err => %v", err.Error())
return rows, total
}
return rows, total
}

564
src/modules/system/repository/sys_user.impl.go
View File

@@ -1,564 +0,0 @@
package repository
import (
"fmt"
"strings"
"time"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/crypto"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysUserImpl 结构体
var NewSysUserImpl = &SysUserImpl{
selectSql: `select
u.user_id, u.dept_id, u.user_name, u.nick_name, u.user_type, u.email, u.avatar, u.phonenumber, u.password, u.sex, u.status, u.del_flag, u.login_ip, u.login_date, u.create_by, u.create_time, u.remark,
d.dept_id, d.parent_id, d.ancestors, d.dept_name, d.order_num, d.leader, d.status as dept_status,
r.role_id, r.role_name, r.role_key, r.role_sort, r.data_scope, r.status as role_status
from sys_user u
left join sys_dept d on u.dept_id = d.dept_id
left join sys_user_role ur on u.user_id = ur.user_id
left join sys_role r on r.role_id = ur.role_id`,
sysUserMap: map[string]string{
"user_id": "UserID",
"dept_id": "DeptID",
"user_name": "UserName",
"nick_name": "NickName",
"user_type": "UserType",
"email": "Email",
"phonenumber": "PhoneNumber",
"sex": "Sex",
"avatar": "Avatar",
"password": "Password",
"status": "Status",
"del_flag": "DelFlag",
"login_ip": "LoginIP",
"login_date": "LoginDate",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
"remark": "Remark",
},
sysDeptMap: map[string]string{
"dept_id": "DeptID",
"parent_id": "ParentID",
"dept_name": "DeptName",
"ancestors": "Ancestors",
"order_num": "OrderNum",
"leader": "Leader",
"dept_status": "Status",
},
sysRoleMap: map[string]string{
"role_id": "RoleID",
"role_name": "RoleName",
"role_key": "RoleKey",
"role_sort": "RoleSort",
"data_scope": "DataScope",
"role_status": "Status",
},
}
// SysUserImpl 用户表 数据层处理
type SysUserImpl struct {
// 查询视图对象SQL
selectSql string
// 用户信息实体映射
sysUserMap map[string]string
// 用户部门实体映射 一对一
sysDeptMap map[string]string
// 用户角色实体映射 一对多
sysRoleMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysUserImpl) convertResultRows(rows []map[string]any) []model.SysUser {
arr := make([]model.SysUser, 0)
for _, row := range rows {
sysUser := model.SysUser{}
sysDept := model.SysDept{}
sysRole := model.SysRole{}
sysUser.Roles = []model.SysRole{}
for key, value := range row {
if keyMapper, ok := r.sysUserMap[key]; ok {
repo.SetFieldValue(&sysUser, keyMapper, value)
}
if keyMapper, ok := r.sysDeptMap[key]; ok {
repo.SetFieldValue(&sysDept, keyMapper, value)
}
if keyMapper, ok := r.sysRoleMap[key]; ok {
repo.SetFieldValue(&sysRole, keyMapper, value)
}
}
sysUser.Dept = sysDept
if sysRole.RoleKey != "" {
sysUser.Roles = append(sysUser.Roles, sysRole)
}
one := true
for i, a := range arr {
if a.UserID == sysUser.UserID {
arrUser := &arr[i]
arrUser.Roles = append(arrUser.Roles, sysUser.Roles...)
one = false
break
}
}
if one {
arr = append(arr, sysUser)
}
}
return arr
}
// SelectUserPage 根据条件分页查询用户列表
func (r *SysUserImpl) SelectUserPage(query map[string]any, dataScopeSQL string) map[string]any {
selectUserTotalSql := `select count(distinct u.user_id) as 'total'
from sys_user u
left join sys_dept d on u.dept_id = d.dept_id
left join sys_user_role ur on u.user_id = ur.user_id
left join sys_role r on r.role_id = ur.role_id`
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["userId"]; ok && v != "" {
conditions = append(conditions, "u.user_id = ?")
params = append(params, v)
}
if v, ok := query["userName"]; ok && v != "" {
conditions = append(conditions, "u.user_name like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "u.status = ?")
params = append(params, v)
}
if v, ok := query["phonenumber"]; ok && v != "" {
conditions = append(conditions, "u.phonenumber like concat(?, '%')")
params = append(params, v)
}
beginTime, ok := query["beginTime"]
if !ok {
beginTime, ok = query["params[beginTime]"]
}
if ok && beginTime != "" {
conditions = append(conditions, "u.login_date >= ?")
params = append(params, parse.Number(beginTime.(string)))
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "u.login_date <= ?")
params = append(params, parse.Number(endTime.(string)))
}
if v, ok := query["deptId"]; ok && v != "" {
conditions = append(conditions, "(u.dept_id = ? or u.dept_id in ( select t.dept_id from sys_dept t where find_in_set(?, ancestors) ))")
params = append(params, v)
params = append(params, v)
}
// 构建查询条件语句
whereSql := " where u.del_flag = '0' and u.user_id != '1' "
if len(conditions) > 0 {
whereSql += " and " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysUser{},
}
// 查询数量 长度为0直接返回
totalSql := selectUserTotalSql + whereSql + dataScopeSQL
totalRows, err := datasource.RawDB("", totalSql, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := r.selectSql + whereSql + dataScopeSQL + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return result
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectAllocatedPage 根据条件分页查询分配用户角色列表
func (r *SysUserImpl) SelectAllocatedPage(query map[string]any, dataScopeSQL string) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["userName"]; ok && v != "" {
conditions = append(conditions, "u.user_name like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["phonenumber"]; ok && v != "" {
conditions = append(conditions, "u.phonenumber like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["status"]; ok && v != "" {
conditions = append(conditions, "u.status = ?")
params = append(params, v)
}
// 分配角色用户
if allocated, ok := query["allocated"]; ok && allocated != "" {
if roleId, ok := query["roleId"]; ok && roleId != "" {
if parse.Boolean(allocated) {
conditions = append(conditions, "r.role_id = ?")
params = append(params, roleId)
} else {
conditions = append(conditions, `(r.role_id != ? or r.role_id IS NULL)
and u.user_id not in (
select u.user_id from sys_user u
inner join sys_user_role ur on u.user_id = ur.user_id
and ur.role_id = ?
)`)
params = append(params, roleId)
params = append(params, roleId)
}
}
}
// 构建查询条件语句
whereSql := " where u.del_flag = '0' and u.user_id != '1' "
if len(conditions) > 0 {
whereSql += " and " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysUser{},
}
// 查询数量 长度为0直接返回
totalSql := `select count(distinct u.user_id) as 'total' from sys_user u
left join sys_dept d on u.dept_id = d.dept_id
left join sys_user_role ur on u.user_id = ur.user_id
left join sys_role r on r.role_id = ur.role_id`
totalRows, err := datasource.RawDB("", totalSql+whereSql+dataScopeSQL, params)
if err != nil {
logger.Errorf("total err => %v", err)
return result
}
total := parse.Number(totalRows[0]["total"])
if total == 0 {
return result
} else {
result["total"] = total
}
// 分页
pageNum, pageSize := repo.PageNumSize(query["pageNum"], query["pageSize"])
pageSql := " limit ?,? "
params = append(params, pageNum*pageSize)
params = append(params, pageSize)
// 查询数据
querySql := `select distinct
u.user_id, u.dept_id, u.user_name, u.nick_name, u.email,
u.phonenumber, u.status, u.create_time, d.dept_name
from sys_user u
left join sys_dept d on u.dept_id = d.dept_id
left join sys_user_role ur on u.user_id = ur.user_id
left join sys_role r on r.role_id = ur.role_id`
querySql = querySql + whereSql + dataScopeSQL + pageSql
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectUserList 根据条件查询用户列表
func (r *SysUserImpl) SelectUserList(sysUser model.SysUser, dataScopeSQL string) []model.SysUser {
selectUserSql := `select
u.user_id, u.dept_id, u.nick_name, u.user_name, u.email, u.avatar, u.phonenumber, u.sex, u.status, u.del_flag, u.login_ip, u.login_date, u.create_by, u.create_time, u.remark, d.dept_name, d.leader
from sys_user u
left join sys_dept d on u.dept_id = d.dept_id`
// 查询条件拼接
var conditions []string
var params []any
if sysUser.UserID != "" {
conditions = append(conditions, "u.user_id = ?")
params = append(params, sysUser.UserID)
}
if sysUser.UserName != "" {
conditions = append(conditions, "u.user_name like concat(?, '%')")
params = append(params, sysUser.UserName)
}
if sysUser.Status != "" {
conditions = append(conditions, "u.status = ?")
params = append(params, sysUser.Status)
}
if sysUser.PhoneNumber != "" {
conditions = append(conditions, "u.phonenumber like concat(?, '%')")
params = append(params, sysUser.PhoneNumber)
}
// 构建查询条件语句
whereSql := " where u.del_flag = '0' "
if len(conditions) > 0 {
whereSql += " and " + strings.Join(conditions, " and ")
}
// 查询数据
querySql := selectUserSql + whereSql + dataScopeSQL
rows, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysUser{}
}
return r.convertResultRows(rows)
}
// SelectUserByIds 通过用户ID查询用户
func (r *SysUserImpl) SelectUserByIds(userIds []string) []model.SysUser {
placeholder := repo.KeyPlaceholderByQuery(len(userIds))
querySql := r.selectSql + " where u.del_flag = '0' and u.user_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(userIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysUser{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectUserByUserName 通过用户登录账号查询用户
func (r *SysUserImpl) SelectUserByUserName(userName string) model.SysUser {
querySql := r.selectSql + " where u.del_flag = '0' and u.user_name = ?"
results, err := datasource.RawDB("", querySql, []any{userName})
if err != nil {
logger.Errorf("query err => %v", err)
return model.SysUser{}
}
// 转换实体
rows := r.convertResultRows(results)
if len(rows) > 0 {
return rows[0]
}
return model.SysUser{}
}
// InsertUser 新增用户信息
func (r *SysUserImpl) InsertUser(sysUser model.SysUser) string {
// 参数拼接
params := make(map[string]any)
if sysUser.UserID != "" {
params["user_id"] = sysUser.UserID
}
if sysUser.DeptID != "" {
params["dept_id"] = sysUser.DeptID
}
if sysUser.UserName != "" {
params["user_name"] = sysUser.UserName
}
if sysUser.NickName != "" {
params["nick_name"] = sysUser.NickName
}
if sysUser.UserType != "" {
params["user_type"] = sysUser.UserType
}
if sysUser.Avatar != "" {
params["avatar"] = sysUser.Avatar
}
if sysUser.Email != "" {
params["email"] = sysUser.Email
}
if sysUser.PhoneNumber != "" {
params["phonenumber"] = sysUser.PhoneNumber
}
if sysUser.Sex != "" {
params["sex"] = sysUser.Sex
}
if sysUser.Password != "" {
password := crypto.BcryptHash(sysUser.Password)
params["password"] = password
}
if sysUser.Status != "" {
params["status"] = sysUser.Status
}
if sysUser.Remark != "" {
params["remark"] = sysUser.Remark
}
if sysUser.CreateBy != "" {
params["create_by"] = sysUser.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_user (" + strings.Join(keys, ",") + ")values(" + placeholder + ")"
db := datasource.DefaultDB()
// 开启事务
tx := db.Begin()
// 执行插入
err := tx.Exec(sql, values...).Error
if err != nil {
logger.Errorf("insert row : %v", err.Error())
tx.Rollback()
return ""
}
// 获取生成的自增 ID
var insertedID string
err = tx.Raw("select last_insert_id()").Row().Scan(&insertedID)
if err != nil {
logger.Errorf("insert last id : %v", err.Error())
tx.Rollback()
return ""
}
// 提交事务
tx.Commit()
return insertedID
}
// UpdateUser 修改用户信息
func (r *SysUserImpl) UpdateUser(sysUser model.SysUser) int64 {
// 参数拼接
params := make(map[string]any)
if sysUser.DeptID != "" {
params["dept_id"] = sysUser.DeptID
}
if sysUser.UserName != "" {
params["user_name"] = sysUser.UserName
}
if sysUser.NickName != "" {
params["nick_name"] = sysUser.NickName
}
if sysUser.UserType != "" {
params["user_type"] = sysUser.UserType
}
if sysUser.Avatar != "" {
params["avatar"] = sysUser.Avatar
}
params["email"] = sysUser.Email
params["phonenumber"] = sysUser.PhoneNumber
params["sex"] = sysUser.Sex
if sysUser.Password != "" {
password := crypto.BcryptHash(sysUser.Password)
params["password"] = password
}
if sysUser.Status != "" {
params["status"] = sysUser.Status
}
params["remark"] = sysUser.Remark
if sysUser.UpdateBy != "" {
params["update_by"] = sysUser.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
if sysUser.LoginIP != "" {
params["login_ip"] = sysUser.LoginIP
}
if sysUser.LoginDate > 0 {
params["login_date"] = sysUser.LoginDate
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_user set " + strings.Join(keys, ",") + " where user_id = ?"
// 执行更新
values = append(values, sysUser.UserID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// DeleteUserByIds 批量删除用户信息
func (r *SysUserImpl) DeleteUserByIds(userIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(userIds))
username := "CASE WHEN user_name = '' THEN user_name WHEN LENGTH(user_name) >= 36 THEN CONCAT('del_', SUBSTRING(user_name, 5, 36)) ELSE CONCAT('del_', user_name) END"
email := "CASE WHEN email = '' THEN email WHEN LENGTH(email) >= 64 THEN CONCAT('del_', SUBSTRING(email, 5, 64)) ELSE CONCAT('del_', email) END"
phonenumber := "CASE WHEN phonenumber = '' THEN phonenumber WHEN LENGTH(phonenumber) >= 16 THEN CONCAT('del_', SUBSTRING(phonenumber, 5, 16)) ELSE CONCAT('del_', phonenumber) END"
sql := fmt.Sprintf("update sys_user set del_flag = '1', user_name = %s, email = %s, phonenumber = %s where user_id in (%s)", username, email, phonenumber, placeholder)
parameters := repo.ConvertIdsSlice(userIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("update err => %v", err)
return 0
}
return results
}
// CheckUniqueUser 校验用户信息是否唯一
func (r *SysUserImpl) CheckUniqueUser(sysUser model.SysUser) string {
// 查询条件拼接
var conditions []string
var params []any
if sysUser.UserName != "" {
conditions = append(conditions, "user_name = ?")
params = append(params, sysUser.UserName)
}
if sysUser.PhoneNumber != "" {
conditions = append(conditions, "phonenumber = ?")
params = append(params, sysUser.PhoneNumber)
}
if sysUser.Email != "" {
conditions = append(conditions, "email = ?")
params = append(params, sysUser.Email)
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
} else {
return ""
}
// 查询数据
querySql := "select user_id as 'str' from sys_user " + whereSql + " limit 1"
results, err := datasource.RawDB("", querySql, params)
if err != nil {
logger.Errorf("query err %v", err)
}
if len(results) > 0 {
return fmt.Sprint(results[0]["str"])
}
return ""
}

60
src/modules/system/repository/sys_user_post.go
View File

@@ -1,15 +1,57 @@
package repository
import "be.ems/src/modules/system/model"
import (
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// ISysUserPost 用户与岗位关联表 数据层接口
type ISysUserPost interface {
// CountUserPostByPostId 通过岗位ID查询岗位使用数量
CountUserPostByPostId(postId string) int64
// NewSysUserPost 实例化数据层
var NewSysUserPost = &SysUserPost{}
// BatchUserPost 批量新增用户岗位信息
BatchUserPost(sysUserPosts []model.SysUserPost) int64
// SysUserPost 用户与岗位关联表 数据层处理
type SysUserPost struct{}
// DeleteUserPost 批量删除用户和岗位关联
DeleteUserPost(userIds []string) int64
// ExistUserByPostId 存在用户使用数量
func (r SysUserPost) ExistUserByPostId(postId int64) int64 {
if postId <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysUserPost{})
tx = tx.Where("post_id = ?", postId)
// 查询数据
var count int64 = 0
if err := tx.Count(&count).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return count
}
return count
}
// DeleteByUserIds 批量删除关联By用户
func (r SysUserPost) DeleteByUserIds(userIds []int64) int64 {
if len(userIds) <= 0 {
return 0
}
tx := db.DB("").Where("user_id in ?", userIds)
// 执行删除
if err := tx.Delete(&model.SysUserPost{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// BatchInsert 批量新增信息
func (r SysUserPost) BatchInsert(sysUserPosts []model.SysUserPost) int64 {
if len(sysUserPosts) <= 0 {
return 0
}
// 执行批量删除
tx := db.DB("").CreateInBatches(sysUserPosts, 500)
if err := tx.Error; err != nil {
logger.Errorf("delete batch err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

60
src/modules/system/repository/sys_user_post.impl.go
View File

@@ -1,60 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysUserPostImpl 结构体
var NewSysUserPostImpl = &SysUserPostImpl{}
// SysUserPostImpl 用户与岗位关联表 数据层处理
type SysUserPostImpl struct{}
// CountUserPostByPostId 通过岗位ID查询岗位使用数量
func (r *SysUserPostImpl) CountUserPostByPostId(postId string) int64 {
querySql := "select count(1) as total from sys_user_role where role_id = ?"
results, err := datasource.RawDB("", querySql, []any{postId})
if err != nil {
logger.Errorf("query err => %v", err)
return 0
}
if len(results) > 0 {
return parse.Number(results[0]["total"])
}
return 0
}
// DeleteUserPost 批量删除用户和岗位关联
func (r *SysUserPostImpl) DeleteUserPost(userIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(userIds))
sql := "delete from sys_user_post where user_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(userIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// BatchUserPost 批量新增用户岗位信息
func (r *SysUserPostImpl) BatchUserPost(sysUserPosts []model.SysUserPost) int64 {
keyValues := make([]string, 0)
for _, item := range sysUserPosts {
keyValues = append(keyValues, fmt.Sprintf("(%s,%s)", item.UserID, item.PostID))
}
sql := "insert into sys_user_post(user_id, post_id) values " + strings.Join(keyValues, ",")
results, err := datasource.ExecDB("", sql, nil)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

77
src/modules/system/repository/sys_user_role.go
View File

@@ -1,18 +1,71 @@
package repository
import "be.ems/src/modules/system/model"
import (
"be.ems/src/framework/database/db"
"be.ems/src/framework/logger"
"be.ems/src/modules/system/model"
)
// ISysUserRole 用户与角色关联表 数据层接口
type ISysUserRole interface {
// CountUserRoleByRoleId 通过角色ID查询角色使用数量
CountUserRoleByRoleId(roleId string) int64
// NewSysUserRole 实例化数据层
var NewSysUserRole = &SysUserRole{}
// BatchUserRole 批量新增用户角色信息
BatchUserRole(sysUserRoles []model.SysUserRole) int64
// SysUserRole 用户与角色关联表 数据层处理
type SysUserRole struct{}
// DeleteUserRole 批量删除用户和角色关联
DeleteUserRole(userIds []string) int64
// DeleteUserRoleByRoleId 批量取消授权用户角色
DeleteUserRoleByRoleId(roleId string, userIds []string) int64
// ExistUserByRoleId 存在用户使用数量
func (r SysUserRole) ExistUserByRoleId(roleId int64) int64 {
if roleId <= 0 {
return 0
}
tx := db.DB("").Model(&model.SysUserRole{})
tx = tx.Where("role_id = ?", roleId)
// 查询数据
var count int64 = 0
if err := tx.Count(&count).Error; err != nil {
logger.Errorf("query find err => %v", err.Error())
return count
}
return count
}
// DeleteByUserIds 批量删除关联By用户
func (r SysUserRole) DeleteByUserIds(userIds []int64) int64 {
if len(userIds) <= 0 {
return 0
}
tx := db.DB("").Where("user_id in ?", userIds)
// 执行删除
if err := tx.Delete(&model.SysUserRole{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// DeleteByRoleId 批量删除关联By角色
func (r SysUserRole) DeleteByRoleId(roleId int64, userIds []int64) int64 {
if roleId <= 0 || len(userIds) <= 0 {
return 0
}
tx := db.DB("").Where("role_id = ?", roleId).Where("user_id in ?", userIds)
// 执行删除
if err := tx.Delete(&model.SysUserRole{}).Error; err != nil {
logger.Errorf("delete err => %v", err.Error())
return 0
}
return tx.RowsAffected
}
// BatchInsert 批量新增信息
func (r SysUserRole) BatchInsert(sysUserRoles []model.SysUserRole) int64 {
if len(sysUserRoles) <= 0 {
return 0
}
// 执行批量删除
tx := db.DB("").CreateInBatches(sysUserRoles, 500)
if err := tx.Error; err != nil {
logger.Errorf("delete batch err => %v", err.Error())
return 0
}
return tx.RowsAffected
}

74
src/modules/system/repository/sys_user_role.impl.go
View File

@@ -1,74 +0,0 @@
package repository
import (
"fmt"
"strings"
"be.ems/src/framework/datasource"
"be.ems/src/framework/logger"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/repo"
"be.ems/src/modules/system/model"
)
// 实例化数据层 SysUserRoleImpl 结构体
var NewSysUserRoleImpl = &SysUserRoleImpl{}
// SysUserRoleImpl 用户与角色关联表 数据层处理
type SysUserRoleImpl struct{}
// CountUserRoleByRoleId 通过角色ID查询角色使用数量
func (r *SysUserRoleImpl) CountUserRoleByRoleId(roleId string) int64 {
querySql := "select count(1) as total from sys_user_role where role_id = ?"
results, err := datasource.RawDB("", querySql, []any{roleId})
if err != nil {
logger.Errorf("query err => %v", err)
return 0
}
if len(results) > 0 {
return parse.Number(results[0]["total"])
}
return 0
}
// BatchUserRole 批量新增用户角色信息
func (r *SysUserRoleImpl) BatchUserRole(sysUserRoles []model.SysUserRole) int64 {
keyValues := make([]string, 0)
for _, item := range sysUserRoles {
keyValues = append(keyValues, fmt.Sprintf("(%s,%s)", item.UserID, item.RoleID))
}
sql := "insert into sys_user_role(user_id, role_id) values " + strings.Join(keyValues, ",")
results, err := datasource.ExecDB("", sql, nil)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// DeleteUserRole 批量删除用户和角色关联
func (r *SysUserRoleImpl) DeleteUserRole(userIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(userIds))
sql := "delete from sys_user_role where user_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(userIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}
// DeleteUserRoleByRoleId 批量取消授权用户角色
func (r *SysUserRoleImpl) DeleteUserRoleByRoleId(roleId string, userIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(userIds))
sql := "delete from sys_user_role where role_id= ? and user_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(userIds)
parameters = append([]any{roleId}, parameters...)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("delete err => %v", err)
return 0
}
return results
}

200
src/modules/system/service/sys_config.go
View File

@@ -1,33 +1,177 @@
package service
import "be.ems/src/modules/system/model"
import (
"fmt"
"strconv"
// ISysConfig 参数配置 服务层接口
type ISysConfig interface {
// SelectDictDataPage 分页查询参数配置列表数据
SelectConfigPage(query map[string]any) map[string]any
"be.ems/src/framework/constants"
"be.ems/src/framework/database/redis"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// SelectConfigValueByKey 通过参数键名查询参数键值
SelectConfigValueByKey(configKey string) string
// SelectConfigById 通过配置ID查询参数配置信息
SelectConfigById(configId string) model.SysConfig
// CheckUniqueConfigKey 校验参数键名是否唯一
CheckUniqueConfigKey(configKey, configId string) bool
// InsertConfig 新增参数配置
InsertConfig(sysConfig model.SysConfig) string
// UpdateConfig 修改参数配置
UpdateConfig(sysConfig model.SysConfig) int64
// DeleteConfigByIds 批量删除参数配置信息
DeleteConfigByIds(configIds []string) (int64, error)
// ResetConfigCache 重置参数缓存数据
ResetConfigCache()
// SelectConfigByKey 查询配置信息BY键
SelectConfigByKey(configKey string) model.SysConfig
// NewSysConfig 实例化服务层
var NewSysConfig = &SysConfig{
sysConfigRepository: repository.NewSysConfig,
}
// SysConfig 参数配置 服务层处理
type SysConfig struct {
sysConfigRepository *repository.SysConfig // 参数配置表
}
// FindByPage 分页查询列表数据
func (s SysConfig) FindByPage(query map[string]string) ([]model.SysConfig, int64) {
return s.sysConfigRepository.SelectByPage(query)
}
// FindById 通过ID查询信息
func (s SysConfig) FindById(configId int64) model.SysConfig {
if configId <= 0 {
return model.SysConfig{}
}
configs := s.sysConfigRepository.SelectByIds([]int64{configId})
if len(configs) > 0 {
return configs[0]
}
return model.SysConfig{}
}
// Insert 新增信息
func (s SysConfig) Insert(sysConfig model.SysConfig) int64 {
configId := s.sysConfigRepository.Insert(sysConfig)
if configId > 0 {
s.CacheLoad(sysConfig.ConfigKey)
}
return configId
}
// Update 修改信息
func (s SysConfig) Update(sysConfig model.SysConfig) int64 {
rows := s.sysConfigRepository.Update(sysConfig)
if rows > 0 {
s.CacheLoad(sysConfig.ConfigKey)
}
return rows
}
// DeleteByIds 批量删除信息
func (s SysConfig) DeleteByIds(configIds []int64) (int64, error) {
// 检查是否存在
configs := s.sysConfigRepository.SelectByIds(configIds)
if len(configs) <= 0 {
return 0, fmt.Errorf("没有权限访问参数配置数据！")
}
for _, config := range configs {
// 检查是否为内置参数
if config.ConfigType == "Y" {
return 0, fmt.Errorf("该配置参数属于内置参数，禁止删除！")
}
// 清除缓存
s.CacheClean(config.ConfigKey)
}
if len(configs) == len(configIds) {
return s.sysConfigRepository.DeleteByIds(configIds), nil
}
return 0, fmt.Errorf("删除参数配置信息失败！")
}
// CheckUniqueByKey 检查参数键名是否唯一
func (s SysConfig) CheckUniqueByKey(configKey string, configId int64) bool {
uniqueId := s.sysConfigRepository.CheckUnique(model.SysConfig{
ConfigKey: configKey,
})
if uniqueId == configId {
return true
}
return uniqueId == 0
}
// FindValueByKey 通过参数键名查询参数值
func (s SysConfig) FindValueByKey(configKey string) string {
cacheKey := constants.CACHE_SYS_CONFIG + ":" + configKey
// 从缓存中读取
if cacheValue, err := redis.Get("", cacheKey); cacheValue != "" || err != nil {
return cacheValue
}
// 无缓存时读取数据放入缓存中
if configValue := s.sysConfigRepository.SelectValueByKey(configKey); configValue != "" {
_ = redis.Set("", cacheKey, configValue)
return configValue
}
return ""
}
// CacheLoad 加载参数缓存数据 传入*查询全部
func (s SysConfig) CacheLoad(configKey string) {
// 查询全部参数
if configKey == "*" || configKey == "" {
sysConfigs := s.sysConfigRepository.Select(model.SysConfig{})
for _, v := range sysConfigs {
key := constants.CACHE_SYS_CONFIG + ":" + v.ConfigKey
_ = redis.Del("", key)
_ = redis.Set("", key, v.ConfigValue)
}
return
}
// 指定参数
cacheValue := s.sysConfigRepository.SelectValueByKey(configKey)
if cacheValue != "" {
key := constants.CACHE_SYS_CONFIG + ":" + configKey
_ = redis.Del("", key)
_ = redis.Set("", key, cacheValue)
}
}
// CacheClean 清空参数缓存数据 传入*清除全部
func (s SysConfig) CacheClean(configKey string) bool {
key := constants.CACHE_SYS_CONFIG + ":" + configKey
keys, err := redis.GetKeys("", key)
if err != nil {
return false
}
return redis.DelKeys("", keys) == nil
}
// FindByKey 查询配置信息BY键
func (s SysConfig) FindByKey(configKey string) model.SysConfig {
sysConf := s.sysConfigRepository.Select(model.SysConfig{
ConfigKey: configKey,
})
if len(sysConf) > 0 {
return sysConf[0]
}
return model.SysConfig{}
}
// ExportData 导出数据表格
func (s SysConfig) ExportData(rows []model.SysConfig, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "参数编号",
"B1": "参数名称",
"C1": "参数键名",
"D1": "参数键值",
"E1": "系统内置",
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
typeValue := "否"
if row.ConfigType == "Y" {
typeValue = "是"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ConfigId,
"B" + idx: row.ConfigName,
"C" + idx: row.ConfigKey,
"D" + idx: row.ConfigValue,
"E" + idx: typeValue,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

170
src/modules/system/service/sys_config.impl.go
View File

@@ -1,170 +0,0 @@
package service
import (
"fmt"
"be.ems/src/framework/constants/cachekey"
"be.ems/src/framework/redis"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysConfigImpl 结构体
var NewSysConfigImpl = &SysConfigImpl{
sysConfigRepository: repository.NewSysConfigImpl,
}
// SysConfigImpl 参数配置 服务层处理
type SysConfigImpl struct {
// 参数配置表
sysConfigRepository repository.ISysConfig
}
// SelectDictDataPage 分页查询参数配置列表数据
func (r *SysConfigImpl) SelectConfigPage(query map[string]any) map[string]any {
return r.sysConfigRepository.SelectConfigPage(query)
}
// SelectConfigList 查询参数配置列表
func (r *SysConfigImpl) SelectConfigList(sysConfig model.SysConfig) []model.SysConfig {
return r.sysConfigRepository.SelectConfigList(sysConfig)
}
// SelectConfigValueByKey 通过参数键名查询参数键值
func (r *SysConfigImpl) SelectConfigValueByKey(configKey string) string {
cacheKey := r.getCacheKey(configKey)
// 从缓存中读取
cacheValue, _ := redis.Get("", cacheKey)
if cacheValue != "" {
return cacheValue
}
// 无缓存时读取数据放入缓存中
configValue := r.sysConfigRepository.SelectConfigValueByKey(configKey)
if configValue != "" {
redis.Set("", cacheKey, configValue)
return configValue
}
return ""
}
// SelectConfigById 通过配置ID查询参数配置信息
func (r *SysConfigImpl) SelectConfigById(configId string) model.SysConfig {
if configId == "" {
return model.SysConfig{}
}
configs := r.sysConfigRepository.SelectConfigByIds([]string{configId})
if len(configs) > 0 {
return configs[0]
}
return model.SysConfig{}
}
// CheckUniqueConfigKey 校验参数键名是否唯一
func (r *SysConfigImpl) CheckUniqueConfigKey(configKey, configId string) bool {
uniqueId := r.sysConfigRepository.CheckUniqueConfig(model.SysConfig{
ConfigKey: configKey,
})
if uniqueId == configId {
return true
}
return uniqueId == ""
}
// InsertConfig 新增参数配置
func (r *SysConfigImpl) InsertConfig(sysConfig model.SysConfig) string {
configId := r.sysConfigRepository.InsertConfig(sysConfig)
if configId != "" {
r.loadingConfigCache(sysConfig.ConfigKey)
}
return configId
}
// UpdateConfig 修改参数配置
func (r *SysConfigImpl) UpdateConfig(sysConfig model.SysConfig) int64 {
rows := r.sysConfigRepository.UpdateConfig(sysConfig)
if rows > 0 {
r.loadingConfigCache(sysConfig.ConfigKey)
}
return rows
}
// DeleteConfigByIds 批量删除参数配置信息
func (r *SysConfigImpl) DeleteConfigByIds(configIds []string) (int64, error) {
// 检查是否存在
configs := r.sysConfigRepository.SelectConfigByIds(configIds)
if len(configs) <= 0 {
return 0, fmt.Errorf("config.noData")
}
for _, config := range configs {
// 检查是否为内置参数
if config.ConfigType == "Y" {
// 操作含有内置参数，禁止删除！
return 0, fmt.Errorf("config.errType")
}
// 清除缓存
r.clearConfigCache(config.ConfigKey)
}
if len(configs) == len(configIds) {
rows := r.sysConfigRepository.DeleteConfigByIds(configIds)
return rows, nil
}
// 删除参数配置信息失败！
return 0, fmt.Errorf("config.errDelete")
}
// ResetConfigCache 重置参数缓存数据
func (r *SysConfigImpl) ResetConfigCache() {
r.clearConfigCache("*")
r.loadingConfigCache("*")
}
// getCacheKey 组装缓存key
func (r *SysConfigImpl) getCacheKey(configKey string) string {
return cachekey.SYS_CONFIG_KEY + configKey
}
// loadingConfigCache 加载参数缓存数据
func (r *SysConfigImpl) loadingConfigCache(configKey string) {
// 查询全部参数
if configKey == "*" {
sysConfigs := r.SelectConfigList(model.SysConfig{})
for _, v := range sysConfigs {
key := r.getCacheKey(v.ConfigKey)
redis.Del("", key)
redis.Set("", key, v.ConfigValue)
}
return
}
// 指定参数
if configKey != "" {
cacheValue := r.sysConfigRepository.SelectConfigValueByKey(configKey)
if cacheValue != "" {
key := r.getCacheKey(configKey)
redis.Del("", key)
redis.Set("", key, cacheValue)
}
return
}
}
// clearConfigCache 清空参数缓存数据
func (r *SysConfigImpl) clearConfigCache(configKey string) bool {
key := r.getCacheKey(configKey)
keys, err := redis.GetKeys("", key)
if err != nil {
return false
}
delOk, _ := redis.DelKeys("", keys)
return delOk
}
// SelectConfigByKey 查询配置信息BY键
func (r *SysConfigImpl) SelectConfigByKey(configKey string) model.SysConfig {
sysConf := r.sysConfigRepository.SelectConfigList(model.SysConfig{
ConfigKey: configKey,
})
if len(sysConf) > 0 {
return sysConf[0]
}
return model.SysConfig{}
}

226
src/modules/system/service/sys_dept.go
View File

@@ -1,39 +1,201 @@
package service
import (
"be.ems/src/framework/vo"
"fmt"
"strings"
"be.ems/src/framework/constants"
"be.ems/src/framework/utils/parse"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/model/vo"
"be.ems/src/modules/system/repository"
)
// ISysDept 部门管理 服务层接口
type ISysDept interface {
// SelectDeptList 查询部门管理数据
SelectDeptList(sysDept model.SysDept, dataScopeSQL string) []model.SysDept
// SelectDeptListByRoleId 根据角色ID查询部门树信息
SelectDeptListByRoleId(roleId string) []string
// SelectDeptById 根据部门ID查询信息
SelectDeptById(deptId string) model.SysDept
// HasChildByDeptId 是否存在子节点
HasChildByDeptId(deptId string) int64
// CheckDeptExistUser 查询部门是否存在用户
CheckDeptExistUser(deptId string) int64
// CheckUniqueDeptName 校验同级部门名称是否唯一
CheckUniqueDeptName(deptName, parentId, deptId string) bool
// InsertDept 新增部门信息
InsertDept(sysDept model.SysDept) string
// UpdateDept 修改部门信息
UpdateDept(sysDept model.SysDept) int64
// DeleteDeptById 删除部门管理信息
DeleteDeptById(deptId string) int64
// SelectDeptTreeSelect 查询部门树结构信息
SelectDeptTreeSelect(sysDept model.SysDept, dataScopeSQL string) []vo.TreeSelect
// NewSysDept 实例化服务层
var NewSysDept = &SysDept{
sysDeptRepository: repository.NewSysDept,
sysRoleRepository: repository.NewSysRole,
sysRoleDeptRepository: repository.NewSysRoleDept,
}
// SysDept 部门管理 服务层处理
type SysDept struct {
sysDeptRepository *repository.SysDept // 部门服务
sysRoleRepository *repository.SysRole // 角色服务
sysRoleDeptRepository *repository.SysRoleDept // 角色与部门关联服务
}
// Find 查询数据
func (s SysDept) Find(sysDept model.SysDept, dataScopeSQL string) []model.SysDept {
return s.sysDeptRepository.Select(sysDept, dataScopeSQL)
}
// FindById 根据ID查询信息
func (s SysDept) FindById(deptId int64) model.SysDept {
return s.sysDeptRepository.SelectById(deptId)
}
// Insert 新增信息
func (s SysDept) Insert(sysDept model.SysDept) int64 {
return s.sysDeptRepository.Insert(sysDept)
}
// Update 修改信息
func (s SysDept) Update(sysDept model.SysDept) int64 {
dept := s.sysDeptRepository.SelectById(sysDept.DeptId)
parentDept := s.sysDeptRepository.SelectById(sysDept.ParentId)
// 上级与当前部门祖级列表更新
if parentDept.DeptId == sysDept.ParentId && dept.DeptId == sysDept.DeptId {
newAncestors := fmt.Sprintf("%s,%d", parentDept.Ancestors, parentDept.DeptId)
oldAncestors := dept.Ancestors
// 祖级列表不一致时更新
if newAncestors != oldAncestors {
dept.Ancestors = newAncestors
s.updateDeptChildren(dept.DeptId, newAncestors, oldAncestors)
}
}
// 如果该部门是启用状态，则启用该部门的所有上级部门
if sysDept.StatusFlag == constants.STATUS_YES && parentDept.StatusFlag == constants.STATUS_NO {
s.updateDeptStatusNormal(sysDept.Ancestors)
}
return s.sysDeptRepository.Update(sysDept)
}
// updateDeptStatusNormal 修改所在部门正常状态
func (s SysDept) updateDeptStatusNormal(ancestors string) int64 {
if ancestors == "" || ancestors == "0" {
return 0
}
deptIds := make([]int64, 0)
for _, v := range strings.Split(ancestors, ",") {
deptIds = append(deptIds, parse.Number(v))
}
return s.sysDeptRepository.UpdateDeptStatusNormal(deptIds)
}
// updateDeptChildren 修改子元素关系
func (s SysDept) updateDeptChildren(deptId int64, newAncestors, oldAncestors string) int64 {
arr := s.sysDeptRepository.SelectChildrenDeptById(deptId)
if len(arr) == 0 {
return 0
}
// 替换父ID
for i := range arr {
item := &arr[i]
ancestors := strings.Replace(item.Ancestors, oldAncestors, newAncestors, 1)
item.Ancestors = ancestors
}
return s.sysDeptRepository.UpdateDeptChildren(arr)
}
// DeleteById 删除信息
func (s SysDept) DeleteById(deptId int64) int64 {
s.sysRoleDeptRepository.DeleteByDeptIds([]int64{deptId}) // 删除角色与部门关联
return s.sysDeptRepository.DeleteById(deptId)
}
// FindDeptIdsByRoleId 根据角色ID查询包含的部门ID
func (s SysDept) FindDeptIdsByRoleId(roleId int64) []int64 {
roles := s.sysRoleRepository.SelectByIds([]int64{roleId})
if len(roles) > 0 {
role := roles[0]
if role.RoleId == roleId {
return s.sysDeptRepository.SelectDeptIdsByRoleId(
role.RoleId,
role.DeptCheckStrictly == "1",
)
}
}
return []int64{}
}
// ExistChildrenByDeptId 部门下存在子节点数量
func (s SysDept) ExistChildrenByDeptId(deptId int64) int64 {
return s.sysDeptRepository.ExistChildrenByDeptId(deptId)
}
// ExistUserByDeptId 部门下存在用户数量
func (s SysDept) ExistUserByDeptId(deptId int64) int64 {
return s.sysDeptRepository.ExistUserByDeptId(deptId)
}
// CheckUniqueParentIdByDeptName 检查同级下部门名称唯一
func (s SysDept) CheckUniqueParentIdByDeptName(parentId int64, deptName string, deptId int64) bool {
uniqueId := s.sysDeptRepository.CheckUnique(model.SysDept{
DeptName: deptName,
ParentId: parentId,
})
if uniqueId == deptId {
return true
}
return uniqueId == 0
}
// BuildTreeSelect 查询部门树状结构
func (s SysDept) BuildTreeSelect(sysDept model.SysDept, dataScopeSQL string) []vo.TreeSelect {
arr := s.sysDeptRepository.Select(sysDept, dataScopeSQL)
treeArr := s.parseDataToTree(arr)
tree := make([]vo.TreeSelect, 0)
for _, item := range treeArr {
tree = append(tree, vo.SysDeptTreeSelect(item))
}
return tree
}
// parseDataToTree 将数据解析为树结构，构建前端所需要下拉树结构
func (s SysDept) parseDataToTree(arr []model.SysDept) []model.SysDept {
// 节点分组
nodesMap := make(map[int64][]model.SysDept)
// 节点id
treeIds := make([]int64, 0)
// 树节点
tree := make([]model.SysDept, 0)
for _, item := range arr {
parentID := item.ParentId
// 分组
mapItem, ok := nodesMap[parentID]
if !ok {
mapItem = []model.SysDept{}
}
mapItem = append(mapItem, item)
nodesMap[parentID] = mapItem
// 记录节点ID
treeIds = append(treeIds, item.DeptId)
}
for key, value := range nodesMap {
// 选择不是节点ID的作为树节点
found := false
for _, id := range treeIds {
if id == key {
found = true
break
}
}
if !found {
tree = append(tree, value...)
}
}
for i, node := range tree {
iN := s.parseDataToTreeComponent(node, &nodesMap)
tree[i] = iN
}
return tree
}
// parseDataToTreeComponent 递归函数处理子节点
func (s SysDept) parseDataToTreeComponent(node model.SysDept, nodesMap *map[int64][]model.SysDept) model.SysDept {
if children, ok := (*nodesMap)[node.DeptId]; ok {
node.Children = children
}
if len(node.Children) > 0 {
for i, child := range node.Children {
icN := s.parseDataToTreeComponent(child, nodesMap)
node.Children[i] = icN
}
}
return node
}

202
src/modules/system/service/sys_dept.impl.go
View File

@@ -1,202 +0,0 @@
package service
import (
"strings"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/vo"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysDeptImpl 结构体
var NewSysDeptImpl = &SysDeptImpl{
sysDeptRepository: repository.NewSysDeptImpl,
sysRoleRepository: repository.NewSysRoleImpl,
sysRoleDeptRepository: repository.NewSysRoleDeptImpl,
}
// SysDeptImpl 部门表 服务层处理
type SysDeptImpl struct {
// 部门服务
sysDeptRepository repository.ISysDept
// 角色服务
sysRoleRepository repository.ISysRole
// 角色与部门关联服务
sysRoleDeptRepository repository.ISysRoleDept
}
// SelectDeptList 查询部门管理数据
func (r *SysDeptImpl) SelectDeptList(sysDept model.SysDept, dataScopeSQL string) []model.SysDept {
return r.sysDeptRepository.SelectDeptList(sysDept, dataScopeSQL)
}
// SelectDeptListByRoleId 根据角色ID查询部门树信息 TODO
func (r *SysDeptImpl) SelectDeptListByRoleId(roleId string) []string {
roles := r.sysRoleRepository.SelectRoleByIds([]string{roleId})
if len(roles) > 0 {
role := roles[0]
if role.RoleID == roleId {
return r.sysDeptRepository.SelectDeptListByRoleId(
role.RoleID,
role.DeptCheckStrictly == "1",
)
}
}
return []string{}
}
// SelectDeptById 根据部门ID查询信息
func (r *SysDeptImpl) SelectDeptById(deptId string) model.SysDept {
return r.sysDeptRepository.SelectDeptById(deptId)
}
// HasChildByDeptId 是否存在子节点
func (r *SysDeptImpl) HasChildByDeptId(deptId string) int64 {
return r.sysDeptRepository.HasChildByDeptId(deptId)
}
// CheckDeptExistUser 查询部门是否存在用户
func (r *SysDeptImpl) CheckDeptExistUser(deptId string) int64 {
return r.sysDeptRepository.CheckDeptExistUser(deptId)
}
// CheckUniqueDeptName 校验同级部门名称是否唯一
func (r *SysDeptImpl) CheckUniqueDeptName(deptName, parentId, deptId string) bool {
uniqueId := r.sysDeptRepository.CheckUniqueDept(model.SysDept{
DeptName: deptName,
ParentID: parentId,
})
if uniqueId == deptId {
return true
}
return uniqueId == ""
}
// InsertDept 新增部门信息
func (r *SysDeptImpl) InsertDept(sysDept model.SysDept) string {
return r.sysDeptRepository.InsertDept(sysDept)
}
// UpdateDept 修改部门信息
func (r *SysDeptImpl) UpdateDept(sysDept model.SysDept) int64 {
parentDept := r.sysDeptRepository.SelectDeptById(sysDept.ParentID)
dept := r.sysDeptRepository.SelectDeptById(sysDept.DeptID)
// 上级与当前部门祖级列表更新
if parentDept.DeptID == sysDept.ParentID && dept.DeptID == sysDept.DeptID {
newAncestors := parentDept.Ancestors + "," + parentDept.DeptID
oldAncestors := dept.Ancestors
// 祖级列表不一致时更新
if newAncestors != oldAncestors {
sysDept.Ancestors = newAncestors
r.updateDeptChildren(sysDept.DeptID, newAncestors, oldAncestors)
}
}
// 如果该部门是启用状态，则启用该部门的所有上级部门
if sysDept.Status == common.STATUS_YES && parentDept.Status == common.STATUS_NO {
r.updateDeptStatusNormal(sysDept.Ancestors)
}
return r.sysDeptRepository.UpdateDept(sysDept)
}
// updateDeptStatusNormal 修改所在部门正常状态
func (r *SysDeptImpl) updateDeptStatusNormal(ancestors string) int64 {
if ancestors == "" || ancestors == "0" {
return 0
}
deptIds := strings.Split(ancestors, ",")
return r.sysDeptRepository.UpdateDeptStatusNormal(deptIds)
}
// updateDeptChildren 修改子元素关系
func (r *SysDeptImpl) updateDeptChildren(deptId, newAncestors, oldAncestors string) int64 {
childrens := r.sysDeptRepository.SelectChildrenDeptById(deptId)
if len(childrens) == 0 {
return 0
}
// 替换父ID
for i := range childrens {
child := &childrens[i]
ancestors := strings.Replace(child.Ancestors, oldAncestors, newAncestors, -1)
child.Ancestors = ancestors
}
return r.sysDeptRepository.UpdateDeptChildren(childrens)
}
// DeleteDeptById 删除部门管理信息
func (r *SysDeptImpl) DeleteDeptById(deptId string) int64 {
// 删除角色与部门关联
r.sysRoleDeptRepository.DeleteDeptRole([]string{deptId})
return r.sysDeptRepository.DeleteDeptById(deptId)
}
// SelectDeptTreeSelect 查询部门树结构信息
func (r *SysDeptImpl) SelectDeptTreeSelect(sysDept model.SysDept, dataScopeSQL string) []vo.TreeSelect {
sysDepts := r.sysDeptRepository.SelectDeptList(sysDept, dataScopeSQL)
depts := r.parseDataToTree(sysDepts)
tree := make([]vo.TreeSelect, 0)
for _, dept := range depts {
tree = append(tree, vo.SysDeptTreeSelect(dept))
}
return tree
}
// parseDataToTree 将数据解析为树结构，构建前端所需要下拉树结构
func (r *SysDeptImpl) parseDataToTree(sysDepts []model.SysDept) []model.SysDept {
// 节点分组
nodesMap := make(map[string][]model.SysDept)
// 节点id
treeIds := []string{}
// 树节点
tree := []model.SysDept{}
for _, item := range sysDepts {
parentID := item.ParentID
// 分组
mapItem, ok := nodesMap[parentID]
if !ok {
mapItem = []model.SysDept{}
}
mapItem = append(mapItem, item)
nodesMap[parentID] = mapItem
// 记录节点ID
treeIds = append(treeIds, item.DeptID)
}
for key, value := range nodesMap {
// 选择不是节点ID的作为树节点
found := false
for _, id := range treeIds {
if id == key {
found = true
break
}
}
if !found {
tree = append(tree, value...)
}
}
for i, node := range tree {
iN := r.parseDataToTreeComponet(node, &nodesMap)
tree[i] = iN
}
return tree
}
// parseDataToTreeComponet 递归函数处理子节点
func (r *SysDeptImpl) parseDataToTreeComponet(node model.SysDept, nodesMap *map[string][]model.SysDept) model.SysDept {
id := node.DeptID
children, ok := (*nodesMap)[id]
if ok {
node.Children = children
}
if len(node.Children) > 0 {
for i, child := range node.Children {
icN := r.parseDataToTreeComponet(child, nodesMap)
node.Children[i] = icN
}
}
return node
}

180
src/modules/system/service/sys_dict_data.go
View File

@@ -2,12 +2,15 @@ package service
import (
"fmt"
"strconv"
"be.ems/src/framework/constants"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysDictData 结构体
// NewSysDictData 实例化服务层
var NewSysDictData = &SysDictData{
sysDictDataRepository: repository.NewSysDictData,
sysDictTypeService: NewSysDictType,
@@ -15,100 +18,127 @@ var NewSysDictData = &SysDictData{
// SysDictData 字典类型数据 服务层处理
type SysDictData struct {
sysDictDataRepository repository.ISysDictData // 字典数据服务
sysDictDataRepository *repository.SysDictData // 字典数据服务
sysDictTypeService *SysDictType // 字典类型服务
}
// SelectDictDataPage 根据条件分页查询字典数据
func (r *SysDictData) SelectDictDataPage(query map[string]any) map[string]any {
return r.sysDictDataRepository.SelectDictDataPage(query)
// FindByPage 分页查询列表数据
func (s SysDictData) FindByPage(query map[string]string) ([]model.SysDictData, int64) {
return s.sysDictDataRepository.SelectByPage(query)
}
// SelectDictDataList 根据条件查询字典数据
func (r *SysDictData) SelectDictDataList(sysDictData model.SysDictData) []model.SysDictData {
return r.sysDictDataRepository.SelectDictDataList(sysDictData)
// Find 查询数据
func (s SysDictData) Find(sysDictData model.SysDictData) []model.SysDictData {
return s.sysDictDataRepository.Select(sysDictData)
}
// SelectDictDataByCode 根据字典数据编码查询信息
func (r *SysDictData) SelectDictDataByCode(dictCode string) model.SysDictData {
if dictCode == "" {
// FindById 通过ID查询信息
func (s SysDictData) FindById(dictId int64) model.SysDictData {
if dictId <= 0 {
return model.SysDictData{}
}
dictCodes := r.sysDictDataRepository.SelectDictDataByCodes([]string{dictCode})
if len(dictCodes) > 0 {
return dictCodes[0]
dicts := s.sysDictDataRepository.SelectByIds([]int64{dictId})
if len(dicts) > 0 {
return dicts[0]
}
return model.SysDictData{}
}
// SelectDictDataByType 根据字典类型查询信息
func (r *SysDictData) SelectDictDataByType(dictType string) []model.SysDictData {
return r.sysDictTypeService.DictDataCache(dictType)
// FindByType 根据字典类型查询信息
func (s SysDictData) FindByType(dictType string) []model.SysDictData {
return s.sysDictTypeService.FindDataByType(dictType)
}
// CheckUniqueDictLabel 校验字典标签是否唯一
func (r *SysDictData) CheckUniqueDictLabel(dictType, dictLabel, dictCode string) bool {
uniqueId := r.sysDictDataRepository.CheckUniqueDictData(model.SysDictData{
DictType: dictType,
DictLabel: dictLabel,
})
if uniqueId == dictCode {
return true
}
return uniqueId == ""
}
// CheckUniqueDictValue 校验字典键值是否唯一
func (r *SysDictData) CheckUniqueDictValue(dictType, dictValue, dictCode string) bool {
uniqueId := r.sysDictDataRepository.CheckUniqueDictData(model.SysDictData{
DictType: dictType,
DictValue: dictValue,
})
if uniqueId == dictCode {
return true
}
return uniqueId == ""
}
// DeleteDictDataByCodes 批量删除字典数据信息
func (r *SysDictData) DeleteDictDataByCodes(dictCodes []string) (int64, error) {
// 检查是否存在
dictDatas := r.sysDictDataRepository.SelectDictDataByCodes(dictCodes)
if len(dictDatas) <= 0 {
// 没有可访问字典编码数据！
return 0, fmt.Errorf("there is no accessible dictionary-encoded data")
}
if len(dictDatas) == len(dictCodes) {
for _, v := range dictDatas {
// 刷新缓存
r.sysDictTypeService.ClearDictCache(v.DictType)
r.sysDictTypeService.LoadingDictCache(v.DictType)
}
rows := r.sysDictDataRepository.DeleteDictDataByCodes(dictCodes)
return rows, nil
}
// 删除字典数据信息失败！
return 0, fmt.Errorf("failed to delete dictionary data information")
}
// InsertDictData 新增字典数据信息
func (r *SysDictData) InsertDictData(sysDictData model.SysDictData) string {
insertId := r.sysDictDataRepository.InsertDictData(sysDictData)
if insertId != "" {
// 刷新缓存
r.sysDictTypeService.ClearDictCache(sysDictData.DictType)
r.sysDictTypeService.LoadingDictCache(sysDictData.DictType)
// Insert 新增信息
func (s SysDictData) Insert(sysDictData model.SysDictData) int64 {
insertId := s.sysDictDataRepository.Insert(sysDictData)
if insertId > 0 {
s.sysDictTypeService.CacheLoad(sysDictData.DictType)
}
return insertId
}
// UpdateDictData 修改字典数据信息
func (r *SysDictData) UpdateDictData(sysDictData model.SysDictData) int64 {
rows := r.sysDictDataRepository.UpdateDictData(sysDictData)
// Update 修改信息
func (s SysDictData) Update(sysDictData model.SysDictData) int64 {
rows := s.sysDictDataRepository.Update(sysDictData)
if rows > 0 {
// 刷新缓存
r.sysDictTypeService.ClearDictCache(sysDictData.DictType)
r.sysDictTypeService.LoadingDictCache(sysDictData.DictType)
s.sysDictTypeService.CacheLoad(sysDictData.DictType)
}
return rows
}
// DeleteByIds 批量删除信息
func (s SysDictData) DeleteByIds(dictIds []int64) (int64, error) {
// 检查是否存在
dicts := s.sysDictDataRepository.SelectByIds(dictIds)
if len(dicts) <= 0 {
return 0, fmt.Errorf("没有权限访问字典编码数据！")
}
if len(dicts) == len(dictIds) {
for _, v := range dicts {
// 刷新缓存
s.sysDictTypeService.CacheClean(v.DictType)
s.sysDictTypeService.CacheLoad(v.DictType)
}
rows := s.sysDictDataRepository.DeleteByIds(dictIds)
return rows, nil
}
return 0, fmt.Errorf("删除字典数据信息失败！")
}
// CheckUniqueTypeByLabel 检查同字典类型下字典标签是否唯一
func (s SysDictData) CheckUniqueTypeByLabel(dictType, dataLabel string, dataId int64) bool {
uniqueId := s.sysDictDataRepository.CheckUnique(model.SysDictData{
DictType: dictType,
DataLabel: dataLabel,
})
if uniqueId == dataId {
return true
}
return uniqueId == 0
}
// CheckUniqueTypeByValue 检查同字典类型下字典键值是否唯一
func (s SysDictData) CheckUniqueTypeByValue(dictType, dataValue string, dataId int64) bool {
uniqueId := s.sysDictDataRepository.CheckUnique(model.SysDictData{
DictType: dictType,
DataValue: dataValue,
})
if uniqueId == dataId {
return true
}
return uniqueId == 0
}
// ExportData 导出数据表格
func (s SysDictData) ExportData(rows []model.SysDictData, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "字典类型",
"B1": "数据排序",
"C1": "数据编号",
"D1": "数据标签",
"E1": "数据键值",
"F1": "数据状态",
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
statusValue := "停用"
if row.StatusFlag == constants.STATUS_YES {
statusValue = "正常"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.DictType,
"B" + idx: row.DataSort,
"C" + idx: row.DataId,
"D" + idx: row.DataLabel,
"E" + idx: row.DataValue,
"F" + idx: statusValue,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

252
src/modules/system/service/sys_dict_type.go
View File

@@ -3,15 +3,16 @@ package service
import (
"encoding/json"
"fmt"
"strconv"
"be.ems/src/framework/constants/cachekey"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/redis"
"be.ems/src/framework/constants"
"be.ems/src/framework/database/redis"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysDictType 结构体
// NewSysDictType 实例化服务层
var NewSysDictType = &SysDictType{
sysDictTypeRepository: repository.NewSysDictType,
sysDictDataRepository: repository.NewSysDictData,
@@ -19,147 +20,149 @@ var NewSysDictType = &SysDictType{
// SysDictType 字典类型 服务层处理
type SysDictType struct {
// 字典类型服务
sysDictTypeRepository repository.ISysDictType
// 字典数据服务
sysDictDataRepository repository.ISysDictData
sysDictTypeRepository *repository.SysDictType // 字典类型服务
sysDictDataRepository *repository.SysDictData // 字典数据服务
}
// SelectDictTypePage 根据条件分页查询字典类型
func (r *SysDictType) SelectDictTypePage(query map[string]any) map[string]any {
return r.sysDictTypeRepository.SelectDictTypePage(query)
// FindByPage 分页查询列表数据
func (s SysDictType) FindByPage(query map[string]string) ([]model.SysDictType, int64) {
return s.sysDictTypeRepository.SelectByPage(query)
}
// SelectDictTypeList 根据条件查询字典类型
func (r *SysDictType) SelectDictTypeList(sysDictType model.SysDictType) []model.SysDictType {
return r.sysDictTypeRepository.SelectDictTypeList(sysDictType)
// Find 查询数据
func (s SysDictType) Find(sysDictType model.SysDictType) []model.SysDictType {
return s.sysDictTypeRepository.Select(sysDictType)
}
// SelectDictTypeByID 根据字典类型ID查询信息
func (r *SysDictType) SelectDictTypeByID(dictID string) model.SysDictType {
if dictID == "" {
// FindById 通过ID查询信息
func (s SysDictType) FindById(dictId int64) model.SysDictType {
if dictId <= 0 {
return model.SysDictType{}
}
dictTypes := r.sysDictTypeRepository.SelectDictTypeByIDs([]string{dictID})
dictTypes := s.sysDictTypeRepository.SelectByIds([]int64{dictId})
if len(dictTypes) > 0 {
return dictTypes[0]
}
return model.SysDictType{}
}
// SelectDictTypeByType 根据字典类型查询信息
func (r *SysDictType) SelectDictTypeByType(dictType string) model.SysDictType {
return r.sysDictTypeRepository.SelectDictTypeByType(dictType)
// FindByType 根据字典类型查询信息
func (s SysDictType) FindByType(dictType string) model.SysDictType {
return s.sysDictTypeRepository.SelectByType(dictType)
}
// CheckUniqueDictName 校验字典名称是否唯一
func (r *SysDictType) CheckUniqueDictName(dictName, dictID string) bool {
uniqueId := r.sysDictTypeRepository.CheckUniqueDictType(model.SysDictType{
DictName: dictName,
})
if uniqueId == dictID {
return true
}
return uniqueId == ""
}
// CheckUniqueDictType 校验字典类型是否唯一
func (r *SysDictType) CheckUniqueDictType(dictType, dictID string) bool {
uniqueId := r.sysDictTypeRepository.CheckUniqueDictType(model.SysDictType{
DictType: dictType,
})
if uniqueId == dictID {
return true
}
return uniqueId == ""
}
// InsertDictType 新增字典类型信息
func (r *SysDictType) InsertDictType(sysDictType model.SysDictType) string {
insertId := r.sysDictTypeRepository.InsertDictType(sysDictType)
if insertId != "" {
r.LoadingDictCache(sysDictType.DictType)
// Insert 新增信息
func (s SysDictType) Insert(sysDictType model.SysDictType) int64 {
insertId := s.sysDictTypeRepository.Insert(sysDictType)
if insertId > 0 {
s.CacheLoad(sysDictType.DictType)
}
return insertId
}
// UpdateDictType 修改字典类型信息
func (r *SysDictType) UpdateDictType(sysDictType model.SysDictType) int64 {
data := r.sysDictTypeRepository.SelectDictTypeByIDs([]string{sysDictType.DictID})
if len(data) == 0 {
// Update 修改信息
func (s SysDictType) Update(sysDictType model.SysDictType) int64 {
arr := s.sysDictTypeRepository.SelectByIds([]int64{sysDictType.DictId})
if len(arr) == 0 {
return 0
}
// 修改字典类型key时同步更新其字典数据的类型key
oldDictType := data[0].DictType
rows := r.sysDictTypeRepository.UpdateDictType(sysDictType)
// 同字典类型被修改时，同步更新修改
oldDictType := arr[0].DictType
rows := s.sysDictTypeRepository.Update(sysDictType)
if rows > 0 && oldDictType != "" && oldDictType != sysDictType.DictType {
r.sysDictDataRepository.UpdateDictDataType(oldDictType, sysDictType.DictType)
s.sysDictDataRepository.UpdateDataByDictType(oldDictType, sysDictType.DictType)
}
// 刷新缓存
r.ClearDictCache(oldDictType)
r.LoadingDictCache(sysDictType.DictType)
s.CacheLoad(sysDictType.DictType)
return rows
}
// DeleteDictTypeByIDs 批量删除字典类型信息
func (r *SysDictType) DeleteDictTypeByIDs(dictIDs []string) (int64, error) {
// DeleteByIds 批量删除信息
func (s SysDictType) DeleteByIds(dictIds []int64) (int64, error) {
// 检查是否存在
dictTypes := r.sysDictTypeRepository.SelectDictTypeByIDs(dictIDs)
if len(dictTypes) <= 0 {
// 没有可访问字典类型数据！
return 0, fmt.Errorf("there is no accessible dictionary type data")
arr := s.sysDictTypeRepository.SelectByIds(dictIds)
if len(arr) <= 0 {
return 0, fmt.Errorf("没有权限访问字典类型数据！")
}
for _, v := range dictTypes {
for _, v := range arr {
// 字典类型下级含有数据
useCount := r.sysDictDataRepository.CountDictDataByType(v.DictType)
if useCount > 0 {
// 【%s】存在字典数据,不能删除
return 0, fmt.Errorf("[%s] dictionary data exists and cannot be deleted", v.DictName)
if useCount := s.sysDictDataRepository.ExistDataByDictType(v.DictType); useCount > 0 {
return 0, fmt.Errorf("【%s】存在字典数据,不能删除", v.DictName)
}
// 清除缓存
r.ClearDictCache(v.DictType)
s.CacheClean(v.DictType)
}
if len(dictTypes) == len(dictIDs) {
rows := r.sysDictTypeRepository.DeleteDictTypeByIDs(dictIDs)
return rows, nil
if len(arr) == len(dictIds) {
return s.sysDictTypeRepository.DeleteByIds(dictIds), nil
}
// 删除字典数据信息失败！
return 0, fmt.Errorf("failed to delete dictionary data information")
return 0, fmt.Errorf("删除字典数据信息失败！")
}
// ResetDictCache 重置字典缓存数据
func (r *SysDictType) ResetDictCache() {
r.ClearDictCache("*")
r.LoadingDictCache("")
// CheckUniqueByName 检查字典名称是否唯一
func (s SysDictType) CheckUniqueByName(dictName string, dictId int64) bool {
uniqueId := s.sysDictTypeRepository.CheckUnique(model.SysDictType{
DictName: dictName,
})
if uniqueId == dictId {
return true
}
return uniqueId == 0
}
// getCacheKey 组装缓存key
func (r *SysDictType) getDictCache(dictType string) string {
return cachekey.SYS_DICT_KEY + dictType
// CheckUniqueByType 检查字典类型是否唯一
func (s SysDictType) CheckUniqueByType(dictType string, dictId int64) bool {
uniqueId := s.sysDictTypeRepository.CheckUnique(model.SysDictType{
DictType: dictType,
})
if uniqueId == dictId {
return true
}
return uniqueId == 0
}
// LoadingDictCache 加载字典缓存数据
func (r *SysDictType) LoadingDictCache(dictType string) {
// FindDataByType 获取字典数据缓存数据
func (s SysDictType) FindDataByType(dictType string) []model.SysDictData {
var data []model.SysDictData
key := constants.CACHE_SYS_DICT + ":" + dictType
jsonStr, _ := redis.Get("", key)
if len(jsonStr) > 7 {
if err := json.Unmarshal([]byte(jsonStr), &data); err != nil {
data = []model.SysDictData{}
}
} else {
data = s.sysDictDataRepository.Select(model.SysDictData{
StatusFlag: constants.STATUS_YES,
DictType: dictType,
})
if len(data) > 0 {
_ = redis.Del("", key)
values, _ := json.Marshal(data)
_ = redis.Set("", key, string(values))
}
}
return data
}
// CacheLoad 加载字典缓存数据 传入*查询全部
func (s SysDictType) CacheLoad(dictType string) {
sysDictData := model.SysDictData{
Status: common.STATUS_YES,
DictType: dictType,
StatusFlag: constants.STATUS_YES,
}
// 指定字典类型
if dictType != "" {
sysDictData.DictType = dictType
// 删除缓存
key := r.getDictCache(dictType)
redis.Del("", key)
if dictType == "*" || dictType == "" {
sysDictData.DictType = ""
}
sysDictDataList := r.sysDictDataRepository.SelectDictDataList(sysDictData)
if len(sysDictDataList) == 0 {
arr := s.sysDictDataRepository.Select(sysDictData)
if len(arr) == 0 {
return
}
// 将字典数据按类型分组
m := make(map[string][]model.SysDictData, 0)
for _, v := range sysDictDataList {
m := make(map[string][]model.SysDictData)
for _, v := range arr {
key := v.DictType
if item, ok := m[key]; ok {
m[key] = append(item, v)
@@ -170,43 +173,48 @@ func (r *SysDictType) LoadingDictCache(dictType string) {
// 放入缓存
for k, v := range m {
key := r.getDictCache(k)
key := constants.CACHE_SYS_DICT + ":" + k
_ = redis.Del("", key)
values, _ := json.Marshal(v)
redis.Set("", key, string(values))
_ = redis.Set("", key, string(values))
}
}
// ClearDictCache 清空字典缓存数据
func (r *SysDictType) ClearDictCache(dictType string) bool {
key := r.getDictCache(dictType)
// CacheClean 清空字典缓存数据 传入*清除全部
func (s SysDictType) CacheClean(dictType string) bool {
key := constants.CACHE_SYS_DICT + ":" + dictType
keys, err := redis.GetKeys("", key)
if err != nil {
return false
}
delOk, _ := redis.DelKeys("", keys)
return delOk
return redis.DelKeys("", keys) == nil
}
// DictDataCache 获取字典数据缓存数据
func (r *SysDictType) DictDataCache(dictType string) []model.SysDictData {
data := []model.SysDictData{}
key := r.getDictCache(dictType)
jsonStr, _ := redis.Get("", key)
if len(jsonStr) > 7 {
err := json.Unmarshal([]byte(jsonStr), &data)
if err != nil {
data = []model.SysDictData{}
}
} else {
data = r.sysDictDataRepository.SelectDictDataList(model.SysDictData{
Status: common.STATUS_YES,
DictType: dictType,
})
if len(data) > 0 {
redis.Del("", key)
values, _ := json.Marshal(data)
redis.Set("", key, string(values))
}
// ExportData 导出数据表格
func (s SysDictType) ExportData(rows []model.SysDictType, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "字典编号",
"B1": "字典名称",
"C1": "字典类型",
"D1": "字典状态",
}
return data
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
statusValue := "停用"
if row.StatusFlag == constants.STATUS_YES {
statusValue = "正常"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.DictId,
"B" + idx: row.DictName,
"C" + idx: row.DictType,
"D" + idx: statusValue,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

133
src/modules/system/service/sys_i18n.go Normal file
View File

@@ -0,0 +1,133 @@
package service
import (
"fmt"
"be.ems/src/framework/constants"
"be.ems/src/framework/database/redis"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// NewSysI18n 实例化服务层
var NewSysI18n = &SysI18n{
sysI18nRepository: repository.NewSysI18n,
}
// SysI18nService 多语言表 服务层处理
type SysI18n struct {
sysI18nRepository *repository.SysI18n // 多语言服务
}
// Find 查询列表数据
func (s SysI18n) Find(SysI18n model.SysI18n) []model.SysI18n {
return s.sysI18nRepository.Select(SysI18n)
}
// FindById 通过ID查询信息
func (s SysI18n) FindById(id int64) model.SysI18n {
if id <= 0 {
return model.SysI18n{}
}
rows := s.sysI18nRepository.SelectByIds([]int64{id})
if len(rows) > 0 {
return rows[0]
}
return model.SysI18n{}
}
// Insert 新增信息
func (s SysI18n) Insert(param model.SysI18n) int64 {
return s.sysI18nRepository.Insert(param)
}
// Update 修改信息
func (s SysI18n) Update(param model.SysI18n) int64 {
return s.sysI18nRepository.Update(param)
}
// DeleteByIds 批量删除信息
func (s SysI18n) DeleteByIds(ids []int64) (int64, error) {
// 检查是否存在
rows := s.sysI18nRepository.SelectByIds(ids)
if len(rows) <= 0 {
return 0, fmt.Errorf("not data")
}
if len(rows) == len(ids) {
return s.sysI18nRepository.DeleteByIds(ids), nil
}
return 0, fmt.Errorf("delete fail")
}
// CheckUniqueByKey 检查属性名是否唯一
func (s SysI18n) CheckUniqueByKey(key string, id int64) bool {
uniqueId := s.sysI18nRepository.CheckUnique(key)
if uniqueId == id {
return true
}
return uniqueId == 0
}
// UpdateKeyValue 更新键对应的值
func (s SysI18n) UpdateKeyValue(language, key, value string) bool {
rows := s.sysI18nRepository.Select(model.SysI18n{
Key: key,
})
if len(rows) != 1 {
return false
}
item := rows[0]
// 检查是否存在
if !s.CheckUniqueByKey(key, item.ID) {
return false
}
// 更新数据
if language == "zh" {
item.ValueZh = value
}
if language == "en" {
item.ValueEn = value
}
return s.sysI18nRepository.Update(item) > 0
}
// CacheLoad 加载多语言数据 传入*查询全部
func (s SysI18n) CacheLoad(langKey string) {
param := model.SysI18n{
DelFlag: constants.STATUS_NO,
Key: langKey,
}
// 指定属性名
if langKey == "*" || langKey == "" {
param.Key = ""
}
arr := s.sysI18nRepository.Select(param)
if len(arr) == 0 {
return
}
// 放入缓存
for _, v := range arr {
key := constants.CACHE_I18N + ":" + v.Key
_ = redis.Del("", key)
value := map[string]any{
"zh": v.ValueZh,
"en": v.ValueEn,
}
_ = redis.SetHash("", key, value)
}
}
// CacheClean 清空多语言数据 传入*清除全部
func (s SysI18n) CacheClean(langKey string) bool {
key := constants.CACHE_I18N + ":" + langKey
keys, err := redis.GetKeys("", key)
if err != nil {
return false
}
return redis.DelKeys("", keys) == nil
}

99
src/modules/system/service/sys_log_login.go
View File

@@ -1,24 +1,85 @@
package service
import "be.ems/src/modules/system/model"
import (
"strconv"
// ISysLogLogin 系统登录日志 服务层接口
type ISysLogLogin interface {
// SelectSysLogLoginPage 分页查询系统登录日志集合
SelectSysLogLoginPage(query map[string]any, dataScopeSQL string) map[string]any
"be.ems/src/framework/constants"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// SelectSysLogLoginList 查询系统登录日志集合
SelectSysLogLoginList(sysLogLogin model.SysLogLogin) []model.SysLogLogin
// InsertSysLogLogin 新增系统登录日志
InsertSysLogLogin(sysLogLogin model.SysLogLogin) string
// DeleteSysLogLoginByIds 批量删除系统登录日志
DeleteSysLogLoginByIds(loginIds []string) int64
// CleanSysLogLogin 清空系统登录日志
CleanSysLogLogin() error
// CreateSysLogLogin 创建系统登录日志
CreateSysLogLogin(userName, status, msg string, ilobArgs ...string) string
// NewSysLogLogin 实例化服务层
var NewSysLogLogin = &SysLogLogin{
sysLogLoginRepository: repository.NewSysLogLogin,
}
// SysLogLogin 系统登录日志 服务层处理
type SysLogLogin struct {
sysLogLoginRepository *repository.SysLogLogin // 系统登录日志信息
}
// FindByPage 分页查询列表数据
func (s SysLogLogin) FindByPage(query map[string]string, dataScopeSQL string) ([]model.SysLogLogin, int64) {
return s.sysLogLoginRepository.SelectByPage(query, dataScopeSQL)
}
// Insert 新增信息
func (s SysLogLogin) Insert(userName, status, msg string, ilobArr [4]string) int64 {
sysSysLogLogin := model.SysLogLogin{
LoginIp: ilobArr[0],
LoginLocation: ilobArr[1],
OS: ilobArr[2],
Browser: ilobArr[3],
UserName: userName,
StatusFlag: status,
Msg: msg,
}
return s.sysLogLoginRepository.Insert(sysSysLogLogin)
}
// Clean 清空系统登录日志
func (s SysLogLogin) Clean() int64 {
return s.sysLogLoginRepository.Clean()
}
// ExportData 导出数据表格
func (s SysLogLogin) ExportData(rows []model.SysLogLogin, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "序号",
"B1": "用户账号",
"C1": "登录状态",
"D1": "登录地址",
"E1": "登录地点",
"F1": "浏览器",
"G1": "操作系统",
"H1": "提示消息",
"I1": "访问时间",
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 状态
statusValue := "失败"
if row.StatusFlag == constants.STATUS_YES {
statusValue = "成功"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: row.UserName,
"C" + idx: statusValue,
"D" + idx: row.LoginIp,
"E" + idx: row.LoginLocation,
"F" + idx: row.Browser,
"G" + idx: row.OS,
"H" + idx: row.Msg,
"I" + idx: date.ParseDateToStr(row.LoginTime, date.YYYY_MM_DD_HH_MM_SS),
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

56
src/modules/system/service/sys_log_login.impl.go
View File

@@ -1,56 +0,0 @@
package service
import (
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysLogLoginImpl 结构体
var NewSysLogLoginImpl = &SysLogLoginImpl{
sysLogLoginService: repository.NewSysLogLoginImpl,
}
// SysLogLoginImpl 系统登录访问 服务层处理
type SysLogLoginImpl struct {
// 系统登录访问信息
sysLogLoginService repository.ISysLogLogin
}
// SelectSysLogLoginPage 分页查询系统登录日志集合
func (s *SysLogLoginImpl) SelectSysLogLoginPage(query map[string]any, dataScopeSQL string) map[string]any {
return s.sysLogLoginService.SelectSysLogLoginPage(query, dataScopeSQL)
}
// SelectSysLogLoginList 查询系统登录日志集合
func (s *SysLogLoginImpl) SelectSysLogLoginList(sysSysLogLogin model.SysLogLogin) []model.SysLogLogin {
return s.sysLogLoginService.SelectSysLogLoginList(sysSysLogLogin)
}
// InsertSysLogLogin 新增系统登录日志
func (s *SysLogLoginImpl) InsertSysLogLogin(sysSysLogLogin model.SysLogLogin) string {
return s.sysLogLoginService.InsertSysLogLogin(sysSysLogLogin)
}
// DeleteSysLogLoginByIds 批量删除系统登录日志
func (s *SysLogLoginImpl) DeleteSysLogLoginByIds(loginIds []string) int64 {
return s.sysLogLoginService.DeleteSysLogLoginByIds(loginIds)
}
// CleanSysLogLogin 清空系统登录日志
func (s *SysLogLoginImpl) CleanSysLogLogin() error {
return s.sysLogLoginService.CleanSysLogLogin()
}
// CreateSysLogLogin 创建系统登录日志
func (s *SysLogLoginImpl) CreateSysLogLogin(userName, status, msg string, ilobArgs ...string) string {
sysSysLogLogin := model.SysLogLogin{
IPAddr: ilobArgs[0],
LoginLocation: ilobArgs[1],
OS: ilobArgs[2],
Browser: ilobArgs[3],
UserName: userName,
Status: status,
Msg: msg,
}
return s.InsertSysLogLogin(sysSysLogLogin)
}

102
src/modules/system/service/sys_log_operate.go
View File

@@ -1,24 +1,88 @@
package service
import "be.ems/src/modules/system/model"
import (
"strconv"
// ISysLogOperate 操作日志表 服务层接口
type ISysLogOperate interface {
// SelectSysLogOperatePage 分页查询系统操作日志集合
SelectSysLogOperatePage(query map[string]any, dataScopeSQL string) map[string]any
"be.ems/src/framework/constants"
"be.ems/src/framework/utils/date"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// SelectSysLogOperateList 查询系统操作日志集合
SelectSysLogOperateList(sysLogOperate model.SysLogOperate) []model.SysLogOperate
// SelectSysLogOperateById 查询操作日志详细
SelectSysLogOperateById(operId string) model.SysLogOperate
// InsertSysLogOperate 新增操作日志
InsertSysLogOperate(sysLogOperate model.SysLogOperate) string
// DeleteSysLogOperateByIds 批量删除系统操作日志
DeleteSysLogOperateByIds(operIds []string) int64
// CleanSysLogOperate 清空操作日志
CleanSysLogOperate() error
// NewSysLogOperate 实例化服务层
var NewSysLogOperate = &SysLogOperate{
sysLogOperateRepository: repository.NewSysLogOperate,
}
// SysLogOperate 操作日志表 服务层处理
type SysLogOperate struct {
sysLogOperateRepository *repository.SysLogOperate // 操作日志信息
}
// FindByPage 分页查询列表数据
func (s SysLogOperate) FindByPage(query map[string]string, dataScopeSQL string) ([]model.SysLogOperate, int64) {
return s.sysLogOperateRepository.SelectByPage(query, dataScopeSQL)
}
// Insert 新增信息
func (s SysLogOperate) Insert(sysLogOperate model.SysLogOperate) int64 {
return s.sysLogOperateRepository.Insert(sysLogOperate)
}
// Clean 清空操作日志
func (s SysLogOperate) Clean() int64 {
return s.sysLogOperateRepository.Clean()
}
// ExportData 导出数据表格
func (s SysLogOperate) ExportData(rows []model.SysLogOperate, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "操作序号",
"B1": "模块标题",
"C1": "业务类型",
"D1": "请求URL",
"E1": "请求方式",
"F1": "主机地址",
"G1": "操作地点",
"H1": "请求参数",
"I1": "操作消息",
"J1": "方法名称",
"K1": "操作人员",
"L1": "操作时间",
"M1": "操作状态",
"N1": "消耗时间",
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 业务类型
businessType := ""
// 状态
statusValue := "失败"
if row.StatusFlag == constants.STATUS_YES {
statusValue = "成功"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.ID,
"B" + idx: row.Title,
"C" + idx: businessType,
"D" + idx: row.OperaUrl,
"E" + idx: row.OperaUrlMethod,
"F" + idx: row.OperaIp,
"G" + idx: row.OperaLocation,
"H" + idx: row.OperaParam,
"I" + idx: row.OperaMsg,
"J" + idx: row.OperaMethod,
"K" + idx: row.OperaBy,
"L" + idx: date.ParseDateToStr(row.OperaTime, date.YYYY_MM_DD_HH_MM_SS),
"M" + idx: statusValue,
"N" + idx: row.CostTime,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

47
src/modules/system/service/sys_log_operate.impl.go
View File

@@ -1,47 +0,0 @@
package service
import (
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysLogOperateImpl 结构体
var NewSysLogOperateImpl = &SysLogOperateImpl{
SysLogOperateService: repository.NewSysLogOperateImpl,
}
// SysLogOperateImpl 操作日志表 服务层处理
type SysLogOperateImpl struct {
// 操作日志信息
SysLogOperateService repository.ISysLogOperate
}
// SelectSysLogOperatePage 分页查询系统操作日志集合
func (r *SysLogOperateImpl) SelectSysLogOperatePage(query map[string]any, dataScopeSQL string) map[string]any {
return r.SysLogOperateService.SelectSysLogOperatePage(query, dataScopeSQL)
}
// SelectSysLogOperateList 查询系统操作日志集合
func (r *SysLogOperateImpl) SelectSysLogOperateList(SysLogOperate model.SysLogOperate) []model.SysLogOperate {
return r.SysLogOperateService.SelectSysLogOperateList(SysLogOperate)
}
// SelectSysLogOperateById 查询操作日志详细
func (r *SysLogOperateImpl) SelectSysLogOperateById(operId string) model.SysLogOperate {
return r.SysLogOperateService.SelectSysLogOperateById(operId)
}
// InsertSysLogOperate 新增操作日志
func (r *SysLogOperateImpl) InsertSysLogOperate(SysLogOperate model.SysLogOperate) string {
return r.SysLogOperateService.InsertSysLogOperate(SysLogOperate)
}
// DeleteSysLogOperateByIds 批量删除系统操作日志
func (r *SysLogOperateImpl) DeleteSysLogOperateByIds(operIds []string) int64 {
return r.SysLogOperateService.DeleteSysLogOperateByIds(operIds)
}
// CleanSysLogOperate 清空操作日志
func (r *SysLogOperateImpl) CleanSysLogOperate() error {
return r.SysLogOperateService.CleanSysLogOperate()
}

414
src/modules/system/service/sys_menu.go
View File

@@ -1,51 +1,377 @@
package service
import (
"be.ems/src/framework/vo"
"encoding/base64"
"fmt"
"strings"
"be.ems/src/framework/constants"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/regular"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/model/vo"
"be.ems/src/modules/system/repository"
)
// ISysMenu 菜单 服务层接口
type ISysMenu interface {
// SelectMenuList 查询系统菜单列表
SelectMenuList(sysMenu model.SysMenu, userId string) []model.SysMenu
// SelectMenuPermsByUserId 根据用户ID查询权限
SelectMenuPermsByUserId(userId string) []string
// SelectMenuTreeByUserId 根据用户ID查询权限
SelectMenuTreeByUserId(userId string) []model.SysMenu
// SelectMenuTreeSelectByUserId 查询菜单树结构信息
SelectMenuTreeSelectByUserId(sysMenu model.SysMenu, userId string) []vo.TreeSelect
// SelectMenuListByRoleId 根据角色ID查询菜单树信息
SelectMenuListByRoleId(roleId string) []string
// SelectMenuById 根据菜单ID查询信息
SelectMenuById(menuId string) model.SysMenu
// HasChildByMenuIdAndStatus 存在菜单子节点数量与状态
HasChildByMenuIdAndStatus(menuId, status string) int64
// CheckMenuExistRole 查询菜单分配角色数量
CheckMenuExistRole(menuId string) int64
// InsertMenu 新增菜单信息
InsertMenu(sysMenu model.SysMenu) string
// UpdateMenu 修改菜单信息
UpdateMenu(sysMenu model.SysMenu) int64
// DeleteMenuById 删除菜单管理信息
DeleteMenuById(menuId string) int64
// CheckUniqueMenuName 校验菜单名称是否唯一
CheckUniqueMenuName(menuName, parentId, menuId string) bool
// CheckUniqueMenuPath 校验路由地址是否唯一（针对目录和菜单）
CheckUniqueMenuPath(path, parentId, menuId string) bool
// BuildRouteMenus 构建前端路由所需要的菜单
BuildRouteMenus(sysMenus []model.SysMenu, prefix string) []vo.Router
// NewSysMenu 实例化服务层
var NewSysMenu = &SysMenu{
sysMenuRepository: repository.NewSysMenu,
sysRoleMenuRepository: repository.NewSysRoleMenu,
sysRoleRepository: repository.NewSysRole,
}
// SysMenu 菜单 服务层处理
type SysMenu struct {
sysMenuRepository *repository.SysMenu // 菜单服务
sysRoleMenuRepository *repository.SysRoleMenu // 角色与菜单关联服务
sysRoleRepository *repository.SysRole // 角色服务
}
// Find 查询数据
func (s SysMenu) Find(sysMenu model.SysMenu, userId int64) []model.SysMenu {
return s.sysMenuRepository.Select(sysMenu, userId)
}
// FindById 通过ID查询信息
func (s SysMenu) FindById(menuId int64) model.SysMenu {
if menuId <= 0 {
return model.SysMenu{}
}
menus := s.sysMenuRepository.SelectByIds([]int64{menuId})
if len(menus) > 0 {
return menus[0]
}
return model.SysMenu{}
}
// Insert 新增信息
func (s SysMenu) Insert(sysMenu model.SysMenu) int64 {
return s.sysMenuRepository.Insert(sysMenu)
}
// Update 修改信息
func (s SysMenu) Update(sysMenu model.SysMenu) int64 {
return s.sysMenuRepository.Update(sysMenu)
}
// DeleteById 删除信息
func (s SysMenu) DeleteById(menuId int64) int64 {
s.sysRoleMenuRepository.DeleteByMenuIds([]int64{menuId}) // 删除菜单与角色关联
return s.sysMenuRepository.DeleteById(menuId)
}
// ExistChildrenByMenuIdAndStatus 菜单下同状态存在子节点数量
func (s SysMenu) ExistChildrenByMenuIdAndStatus(menuId int64, status string) int64 {
return s.sysMenuRepository.ExistChildrenByMenuIdAndStatus(menuId, status)
}
// ExistRoleByMenuId 菜单分配给的角色数量
func (s SysMenu) ExistRoleByMenuId(menuId int64) int64 {
return s.sysRoleMenuRepository.ExistRoleByMenuId(menuId)
}
// CheckUniqueParentIdByMenuName 检查同级下菜单名称是否唯一
func (s SysMenu) CheckUniqueParentIdByMenuName(parentId int64, menuName string, menuId int64) bool {
uniqueId := s.sysMenuRepository.CheckUnique(model.SysMenu{
MenuName: menuName,
ParentId: parentId,
})
if uniqueId == menuId {
return true
}
return uniqueId == 0
}
// CheckUniqueParentIdByMenuPath 检查同级下路由地址是否唯一（针对目录和菜单）
func (s SysMenu) CheckUniqueParentIdByMenuPath(parentId int64, menuPath string, menuId int64) bool {
uniqueId := s.sysMenuRepository.CheckUnique(model.SysMenu{
MenuPath: menuPath,
ParentId: parentId,
})
if uniqueId == menuId {
return true
}
return uniqueId == 0
}
// FindPermsByUserId 根据用户ID查询权限标识
func (s SysMenu) FindPermsByUserId(userId int64) []string {
return s.sysMenuRepository.SelectPermsByUserId(userId)
}
// FindByRoleId 根据角色ID查询菜单树信息
func (s SysMenu) FindByRoleId(roleId int64) []int64 {
roles := s.sysRoleRepository.SelectByIds([]int64{roleId})
if len(roles) > 0 {
role := roles[0]
if role.RoleId == roleId {
return s.sysMenuRepository.SelectByRoleId(
role.RoleId,
role.MenuCheckStrictly == "1",
)
}
}
return []int64{}
}
// BuildTreeMenusByUserId 根据用户ID查询菜单树状嵌套
func (s SysMenu) BuildTreeMenusByUserId(userId int64) []model.SysMenu {
arr := s.sysMenuRepository.SelectTreeByUserId(userId)
return s.parseDataToTree(arr)
}
// BuildTreeSelectByUserId 根据用户ID查询菜单树状结构
func (s SysMenu) BuildTreeSelectByUserId(sysMenu model.SysMenu, userId int64) []vo.TreeSelect {
arr := s.sysMenuRepository.Select(sysMenu, userId)
menus := s.parseDataToTree(arr)
tree := make([]vo.TreeSelect, 0)
for _, v := range menus {
tree = append(tree, vo.SysMenuTreeSelect(v))
}
return tree
}
// parseDataToTree 将数据解析为树结构，构建前端所需要下拉树结构
func (s SysMenu) parseDataToTree(sysMenus []model.SysMenu) []model.SysMenu {
// 节点分组
nodesMap := make(map[int64][]model.SysMenu)
// 节点id
var treeIds []int64
// 树节点
var tree []model.SysMenu
for _, item := range sysMenus {
ParentId := item.ParentId
// 分组
mapItem, ok := nodesMap[ParentId]
if !ok {
mapItem = []model.SysMenu{}
}
mapItem = append(mapItem, item)
nodesMap[ParentId] = mapItem
// 记录节点ID
treeIds = append(treeIds, item.MenuId)
}
for key, value := range nodesMap {
// 选择不是节点ID的作为树节点
found := false
for _, id := range treeIds {
if id == key {
found = true
break
}
}
if !found {
tree = append(tree, value...)
}
}
for i, node := range tree {
iN := s.parseDataToTreeComponent(node, &nodesMap)
tree[i] = iN
}
return tree
}
// parseDataToTreeComponent 递归函数处理子节点
func (s SysMenu) parseDataToTreeComponent(node model.SysMenu, nodesMap *map[int64][]model.SysMenu) model.SysMenu {
if children, ok := (*nodesMap)[node.MenuId]; ok {
node.Children = children
}
if len(node.Children) > 0 {
for i, child := range node.Children {
icN := s.parseDataToTreeComponent(child, nodesMap)
node.Children[i] = icN
}
}
return node
}
// BuildRouteMenus 构建前端路由所需要的菜单
func (s SysMenu) BuildRouteMenus(sysMenus []model.SysMenu, prefix string) []vo.Router {
routers := make([]vo.Router, 0)
for _, item := range sysMenus {
router := vo.Router{
Name: s.getRouteName(item),
Path: s.getRouterPath(item),
Component: s.getComponent(item),
Meta: s.getRouteMeta(item),
Children: []vo.Router{},
}
// 子项菜单 目录类型 非路径链接
cMenus := item.Children
if len(cMenus) > 0 && item.MenuType == constants.MENU_TYPE_DIR && !regular.ValidHttp(item.MenuPath) {
// 获取重定向地址
redirectPrefix, redirectPath := s.getRouteRedirect(
cMenus,
router.Path,
prefix,
)
router.Redirect = redirectPath
// 子菜单进入递归
router.Children = s.BuildRouteMenus(cMenus, redirectPrefix)
} else if item.ParentId == 0 && item.FrameFlag == constants.STATUS_YES && item.MenuType == constants.MENU_TYPE_MENU {
// 父菜单 内部跳转 菜单类型
menuPath := fmt.Sprintf("/%d", item.MenuId)
childPath := menuPath + s.getRouterPath(item)
children := vo.Router{
Name: s.getRouteName(item),
Path: childPath,
Component: item.Component,
Meta: s.getRouteMeta(item),
}
router.Meta.HideChildInMenu = true
router.Children = append(router.Children, children)
router.Name = fmt.Sprint(item.MenuId)
router.Path = menuPath
router.Redirect = childPath
router.Component = constants.MENU_COMPONENT_LAYOUT_BASIC
} else if item.ParentId == 0 && item.FrameFlag == constants.STATUS_YES && regular.ValidHttp(item.MenuPath) {
// 父菜单 内部跳转 路径链接
menuPath := fmt.Sprintf("/%d", item.MenuId)
childPath := menuPath + s.getRouterPath(item)
children := vo.Router{
Name: s.getRouteName(item),
Path: childPath,
Component: constants.MENU_COMPONENT_LAYOUT_LINK,
Meta: s.getRouteMeta(item),
}
router.Meta.HideChildInMenu = true
router.Children = append(router.Children, children)
router.Name = fmt.Sprint(item.MenuId)
router.Path = menuPath
router.Redirect = childPath
router.Component = constants.MENU_COMPONENT_LAYOUT_BASIC
}
routers = append(routers, router)
}
return routers
}
// getRouteName 获取路由名称 路径英文首字母大写
func (s SysMenu) getRouteName(sysMenu model.SysMenu) string {
routerName := parse.ConvertToCamelCase(sysMenu.MenuPath)
// 路径链接
if regular.ValidHttp(sysMenu.MenuPath) {
routerName = routerName[:5] + "Link"
}
// 拼上菜单ID防止name重名
return fmt.Sprintf("%s_%d", routerName, sysMenu.MenuId)
}
// getRouterPath 获取路由地址
func (s SysMenu) getRouterPath(sysMenu model.SysMenu) string {
routerPath := sysMenu.MenuPath
// 显式路径
if routerPath == "" || strings.HasPrefix(routerPath, "/") {
return routerPath
}
// 路径链接 内部跳转
if regular.ValidHttp(routerPath) && sysMenu.FrameFlag == constants.STATUS_YES {
routerPath = regular.Replace(`/^http(s)?:\/\/+/`, routerPath, "")
routerPath = base64.StdEncoding.EncodeToString([]byte(routerPath))
}
// 父菜单 内部跳转
if sysMenu.ParentId == 0 && sysMenu.FrameFlag == constants.STATUS_YES {
routerPath = "/" + routerPath
}
return routerPath
}
// getComponent 获取组件信息
func (s SysMenu) getComponent(sysMenu model.SysMenu) string {
// 内部跳转 路径链接
if sysMenu.FrameFlag == constants.STATUS_YES && regular.ValidHttp(sysMenu.MenuPath) {
return constants.MENU_COMPONENT_LAYOUT_LINK
}
// 非父菜单 目录类型
if sysMenu.ParentId > 0 && sysMenu.MenuType == constants.MENU_TYPE_DIR {
return constants.MENU_COMPONENT_LAYOUT_BLANK
}
// 组件路径 内部跳转 菜单类型
if sysMenu.Component != "" && sysMenu.FrameFlag == constants.STATUS_YES && sysMenu.MenuType == constants.MENU_TYPE_MENU {
// 父菜单套外层布局
if sysMenu.ParentId == 0 {
return constants.MENU_COMPONENT_LAYOUT_BASIC
}
return sysMenu.Component
}
return constants.MENU_COMPONENT_LAYOUT_BASIC
}
// getRouteMeta 获取路由元信息
func (s SysMenu) getRouteMeta(sysMenu model.SysMenu) vo.RouterMeta {
meta := vo.RouterMeta{}
if sysMenu.Icon == "#" {
meta.Icon = ""
} else {
meta.Icon = sysMenu.Icon
}
meta.Title = sysMenu.MenuName
meta.HideChildInMenu = false
meta.HideInMenu = sysMenu.VisibleFlag == constants.STATUS_NO
meta.Cache = sysMenu.CacheFlag == constants.STATUS_YES
meta.Target = ""
// 路径链接 非内部跳转
if regular.ValidHttp(sysMenu.MenuPath) && sysMenu.FrameFlag == constants.STATUS_NO {
meta.Target = "_blank"
}
return meta
}
// getRouteRedirect 获取路由重定向地址（针对目录）
//
// cMenus 子菜单数组
// routerPath 当前菜单路径
// prefix 菜单重定向路径前缀
func (s SysMenu) getRouteRedirect(cMenus []model.SysMenu, routerPath string, prefix string) (string, string) {
redirectPath := ""
// 重定向为首个显示并启用的子菜单
var firstChild *model.SysMenu
for _, item := range cMenus {
if item.FrameFlag == constants.STATUS_YES && item.VisibleFlag == constants.STATUS_YES {
firstChild = &item
break
}
}
// 检查内嵌隐藏菜单是否可做重定向
if firstChild == nil {
for _, item := range cMenus {
if item.FrameFlag == constants.STATUS_YES && item.VisibleFlag == constants.STATUS_NO && strings.Contains(item.MenuPath, constants.MENU_PATH_INLINE) {
firstChild = &item
break
}
}
}
if firstChild != nil {
firstChildPath := s.getRouterPath(*firstChild)
if strings.HasPrefix(firstChildPath, "/") {
redirectPath = firstChildPath
} else {
// 拼接追加路径
if !strings.HasPrefix(routerPath, "/") {
prefix += "/"
}
prefix = prefix + routerPath
redirectPath = prefix + "/" + firstChildPath
}
}
return prefix, redirectPath
}

391
src/modules/system/service/sys_menu.impl.go
View File

@@ -1,391 +0,0 @@
package service
import (
"encoding/base64"
"strings"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/constants/menu"
"be.ems/src/framework/utils/parse"
"be.ems/src/framework/utils/regular"
"be.ems/src/framework/vo"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysMenuImpl 结构体
var NewSysMenuImpl = &SysMenuImpl{
sysMenuRepository: repository.NewSysMenuImpl,
sysRoleMenuRepository: repository.NewSysRoleMenuImpl,
sysRoleRepository: repository.NewSysRoleImpl,
}
// SysMenuImpl 菜单 服务层处理
type SysMenuImpl struct {
// 菜单服务
sysMenuRepository repository.ISysMenu
// 角色与菜单关联服务
sysRoleMenuRepository repository.ISysRoleMenu
// 角色服务
sysRoleRepository repository.ISysRole
}
// SelectMenuList 查询系统菜单列表
func (r *SysMenuImpl) SelectMenuList(sysMenu model.SysMenu, userId string) []model.SysMenu {
return r.sysMenuRepository.SelectMenuList(sysMenu, userId)
}
// SelectMenuPermsByUserId 根据用户ID查询权限
func (r *SysMenuImpl) SelectMenuPermsByUserId(userId string) []string {
return r.sysMenuRepository.SelectMenuPermsByUserId(userId)
}
// SelectMenuTreeByUserId 根据用户ID查询菜单
func (r *SysMenuImpl) SelectMenuTreeByUserId(userId string) []model.SysMenu {
sysMenus := r.sysMenuRepository.SelectMenuTreeByUserId(userId)
return r.parseDataToTree(sysMenus)
}
// SelectMenuTreeSelectByUserId 根据用户ID查询菜单树结构信息
func (r *SysMenuImpl) SelectMenuTreeSelectByUserId(sysMenu model.SysMenu, userId string) []vo.TreeSelect {
sysMenus := r.sysMenuRepository.SelectMenuList(sysMenu, userId)
// 过滤旧前端菜单
sysMenusF := []model.SysMenu{}
for _, v := range sysMenus {
if v.Perms == "page" {
continue
}
sysMenusF = append(sysMenusF, v)
}
menus := r.parseDataToTree(sysMenusF)
tree := make([]vo.TreeSelect, 0)
for _, menu := range menus {
tree = append(tree, vo.SysMenuTreeSelect(menu))
}
return tree
}
// SelectMenuListByRoleId 根据角色ID查询菜单树信息 TODO
func (r *SysMenuImpl) SelectMenuListByRoleId(roleId string) []string {
roles := r.sysRoleRepository.SelectRoleByIds([]string{roleId})
if len(roles) > 0 {
role := roles[0]
if role.RoleID == roleId {
return r.sysMenuRepository.SelectMenuListByRoleId(
role.RoleID,
role.MenuCheckStrictly == "1",
)
}
}
return []string{}
}
// SelectMenuById 根据菜单ID查询信息
func (r *SysMenuImpl) SelectMenuById(menuId string) model.SysMenu {
if menuId == "" {
return model.SysMenu{}
}
menus := r.sysMenuRepository.SelectMenuByIds([]string{menuId})
if len(menus) > 0 {
return menus[0]
}
return model.SysMenu{}
}
// HasChildByMenuIdAndStatus 存在菜单子节点数量与状态
func (r *SysMenuImpl) HasChildByMenuIdAndStatus(menuId, status string) int64 {
return r.sysMenuRepository.HasChildByMenuIdAndStatus(menuId, status)
}
// CheckMenuExistRole 查询菜单是否存在角色
func (r *SysMenuImpl) CheckMenuExistRole(menuId string) int64 {
return r.sysRoleMenuRepository.CheckMenuExistRole(menuId)
}
// InsertMenu 新增菜单信息
func (r *SysMenuImpl) InsertMenu(sysMenu model.SysMenu) string {
return r.sysMenuRepository.InsertMenu(sysMenu)
}
// UpdateMenu 修改菜单信息
func (r *SysMenuImpl) UpdateMenu(sysMenu model.SysMenu) int64 {
return r.sysMenuRepository.UpdateMenu(sysMenu)
}
// DeleteMenuById 删除菜单管理信息
func (r *SysMenuImpl) DeleteMenuById(menuId string) int64 {
// 删除菜单与角色关联
r.sysRoleMenuRepository.DeleteMenuRole([]string{menuId})
return r.sysMenuRepository.DeleteMenuById(menuId)
}
// CheckUniqueMenuName 校验菜单名称是否唯一
func (r *SysMenuImpl) CheckUniqueMenuName(menuName, parentId, menuId string) bool {
uniqueId := r.sysMenuRepository.CheckUniqueMenu(model.SysMenu{
MenuName: menuName,
ParentID: parentId,
})
if uniqueId == menuId {
return true
}
return uniqueId == ""
}
// CheckUniqueMenuPath 校验路由地址是否唯一（针对目录和菜单）
func (r *SysMenuImpl) CheckUniqueMenuPath(path, parentId, menuId string) bool {
uniqueId := r.sysMenuRepository.CheckUniqueMenu(model.SysMenu{
Path: path,
ParentID: parentId,
})
if uniqueId == menuId {
return true
}
return uniqueId == ""
}
// BuildRouteMenus 构建前端路由所需要的菜单
func (r *SysMenuImpl) BuildRouteMenus(sysMenus []model.SysMenu, prefix string) []vo.Router {
routers := []vo.Router{}
for _, item := range sysMenus {
router := vo.Router{}
router.Name = r.getRouteName(item)
router.Path = r.getRouterPath(item)
router.Component = r.getComponent(item)
router.Meta = r.getRouteMeta(item)
// 子项菜单 目录类型 非路径链接
cMenus := item.Children
if len(cMenus) > 0 && item.MenuType == menu.TYPE_DIR && !regular.ValidHttp(item.Path) {
// 获取重定向地址
redirectPrefix, redirectPath := r.getRouteRedirect(
cMenus,
router.Path,
prefix,
)
router.Redirect = redirectPath
// 子菜单进入递归
router.Children = r.BuildRouteMenus(cMenus, redirectPrefix)
} else if item.ParentID == "0" && item.IsFrame == common.STATUS_YES && item.MenuType == menu.TYPE_MENU {
// 父菜单 内部跳转 菜单类型
menuPath := "/" + item.MenuID
childPath := menuPath + r.getRouterPath(item)
children := vo.Router{
Name: r.getRouteName(item),
Path: childPath,
Component: item.Component,
Meta: r.getRouteMeta(item),
}
router.Meta.HideChildInMenu = true
router.Children = append(router.Children, children)
router.Name = item.MenuID
router.Path = menuPath
router.Redirect = childPath
router.Component = menu.COMPONENT_LAYOUT_BASIC
} else if item.ParentID == "0" && item.IsFrame == common.STATUS_YES && regular.ValidHttp(item.Path) {
// 父菜单 内部跳转 路径链接
menuPath := "/" + item.MenuID
childPath := menuPath + r.getRouterPath(item)
children := vo.Router{
Name: r.getRouteName(item),
Path: childPath,
Component: menu.COMPONENT_LAYOUT_LINK,
Meta: r.getRouteMeta(item),
}
router.Meta.HideChildInMenu = true
router.Children = append(router.Children, children)
router.Name = item.MenuID
router.Path = menuPath
router.Redirect = childPath
router.Component = menu.COMPONENT_LAYOUT_BASIC
}
routers = append(routers, router)
}
return routers
}
// getRouteName 获取路由名称 路径英文首字母大写
func (r *SysMenuImpl) getRouteName(sysMenu model.SysMenu) string {
routerName := parse.ConvertToCamelCase(sysMenu.Path)
// 路径链接
if regular.ValidHttp(sysMenu.Path) {
routerName = routerName[:5] + "Link"
}
// 拼上菜单ID防止name重名
return routerName + "_" + sysMenu.MenuID
}
// getRouterPath 获取路由地址
func (r *SysMenuImpl) getRouterPath(sysMenu model.SysMenu) string {
routerPath := sysMenu.Path
// 显式路径
if routerPath == "" || strings.HasPrefix(routerPath, "/") {
return routerPath
}
// 路径链接 内部跳转
if regular.ValidHttp(routerPath) && sysMenu.IsFrame == common.STATUS_YES {
routerPath = regular.Replace(routerPath, `/^http(s)?:\/\/+/`, "")
routerPath = base64.StdEncoding.EncodeToString([]byte(routerPath))
}
// 父菜单 内部跳转
if sysMenu.ParentID == "0" && sysMenu.IsFrame == common.STATUS_YES {
routerPath = "/" + routerPath
}
return routerPath
}
// getComponent 获取组件信息
func (r *SysMenuImpl) getComponent(sysMenu model.SysMenu) string {
// 内部跳转 路径链接
if sysMenu.IsFrame == common.STATUS_YES && regular.ValidHttp(sysMenu.Path) {
return menu.COMPONENT_LAYOUT_LINK
}
// 非父菜单 目录类型
if sysMenu.ParentID != "0" && sysMenu.MenuType == menu.TYPE_DIR {
return menu.COMPONENT_LAYOUT_BLANK
}
// 组件路径 内部跳转 菜单类型
if sysMenu.Component != "" && sysMenu.IsFrame == common.STATUS_YES && sysMenu.MenuType == menu.TYPE_MENU {
// 父菜单套外层布局
if sysMenu.ParentID == "0" {
return menu.COMPONENT_LAYOUT_BASIC
}
return sysMenu.Component
}
return menu.COMPONENT_LAYOUT_BASIC
}
// getRouteMeta 获取路由元信息
func (r *SysMenuImpl) getRouteMeta(sysMenu model.SysMenu) vo.RouterMeta {
meta := vo.RouterMeta{}
if sysMenu.Icon == "#" {
meta.Icon = ""
} else {
meta.Icon = sysMenu.Icon
}
meta.Title = sysMenu.MenuName
meta.HideChildInMenu = false
meta.HideInMenu = sysMenu.Visible == common.STATUS_NO
meta.Cache = sysMenu.IsCache == common.STATUS_YES
meta.Target = ""
// 路径链接 非内部跳转
if regular.ValidHttp(sysMenu.Path) && sysMenu.IsFrame == common.STATUS_NO {
meta.Target = "_blank"
}
return meta
}
// getRouteRedirect 获取路由重定向地址（针对目录）
//
// cMenus 子菜单数组
// routerPath 当前菜单路径
// prefix 菜单重定向路径前缀
func (r *SysMenuImpl) getRouteRedirect(cMenus []model.SysMenu, routerPath string, prefix string) (string, string) {
redirectPath := ""
// 重定向为首个显示并启用的子菜单
var firstChild *model.SysMenu
for _, item := range cMenus {
if item.IsFrame == common.STATUS_YES && item.Visible == common.STATUS_YES {
firstChild = &item
break
}
}
// 检查内嵌隐藏菜单是否可做重定向
if firstChild == nil {
for _, item := range cMenus {
if item.IsFrame == common.STATUS_YES && item.Visible == common.STATUS_NO && strings.Contains(item.Path, menu.PATH_INLINE) {
firstChild = &item
break
}
}
}
if firstChild != nil {
firstChildPath := r.getRouterPath(*firstChild)
if strings.HasPrefix(firstChildPath, "/") {
redirectPath = firstChildPath
} else {
// 拼接追加路径
if !strings.HasPrefix(routerPath, "/") {
prefix += "/"
}
prefix = prefix + routerPath
redirectPath = prefix + "/" + firstChildPath
}
}
return prefix, redirectPath
}
// parseDataToTree 将数据解析为树结构，构建前端所需要下拉树结构
func (r *SysMenuImpl) parseDataToTree(sysMenus []model.SysMenu) []model.SysMenu {
// 节点分组
nodesMap := make(map[string][]model.SysMenu)
// 节点id
treeIds := []string{}
// 树节点
tree := []model.SysMenu{}
for _, item := range sysMenus {
parentID := item.ParentID
// 分组
mapItem, ok := nodesMap[parentID]
if !ok {
mapItem = []model.SysMenu{}
}
mapItem = append(mapItem, item)
nodesMap[parentID] = mapItem
// 记录节点ID
treeIds = append(treeIds, item.MenuID)
}
for key, value := range nodesMap {
// 选择不是节点ID的作为树节点
found := false
for _, id := range treeIds {
if id == key {
found = true
break
}
}
if !found {
tree = append(tree, value...)
}
}
for i, node := range tree {
iN := r.parseDataToTreeComponet(node, &nodesMap)
tree[i] = iN
}
return tree
}
// parseDataToTreeComponet 递归函数处理子节点
func (r *SysMenuImpl) parseDataToTreeComponet(node model.SysMenu, nodesMap *map[string][]model.SysMenu) model.SysMenu {
id := node.MenuID
children, ok := (*nodesMap)[id]
if ok {
node.Children = children
}
if len(node.Children) > 0 {
for i, child := range node.Children {
icN := r.parseDataToTreeComponet(child, nodesMap)
node.Children[i] = icN
}
}
return node
}

157
src/modules/system/service/sys_post.go
View File

@@ -1,33 +1,134 @@
package service
import "be.ems/src/modules/system/model"
import (
"fmt"
"strconv"
// ISysPost 岗位信息 服务层接口
type ISysPost interface {
// SelectPostPage 查询岗位分页数据集合
SelectPostPage(query map[string]any) map[string]any
"be.ems/src/framework/constants"
"be.ems/src/framework/utils/file"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// SelectPostList 查询岗位数据集合
SelectPostList(sysPost model.SysPost) []model.SysPost
// SelectPostById 通过岗位ID查询岗位信息
SelectPostById(postId string) model.SysPost
// SelectPostListByUserId 根据用户ID获取岗位选择框列表
SelectPostListByUserId(userId string) []model.SysPost
// DeletePostByIds 批量删除岗位信息
DeletePostByIds(postIds []string) (int64, error)
// UpdatePost 修改岗位信息
UpdatePost(sysPost model.SysPost) int64
// InsertPost 新增岗位信息
InsertPost(sysPost model.SysPost) string
// CheckUniquePostName 校验岗位名称
CheckUniquePostName(postName, postId string) bool
// CheckUniquePostCode 校验岗位编码
CheckUniquePostCode(postCode, postId string) bool
// NewSysPost 实例化服务层
var NewSysPost = &SysPost{
sysPostRepository: repository.NewSysPost,
sysUserPostRepository: repository.NewSysUserPost,
}
// SysPostService 岗位表 服务层处理
type SysPost struct {
sysPostRepository *repository.SysPost // 岗位服务
sysUserPostRepository *repository.SysUserPost // 用户与岗位关联服务
}
// FindByPage 分页查询列表数据
func (s SysPost) FindByPage(query map[string]string) ([]model.SysPost, int64) {
return s.sysPostRepository.SelectByPage(query)
}
// Find 查询列表数据
func (s SysPost) Find(sysPost model.SysPost) []model.SysPost {
return s.sysPostRepository.Select(sysPost)
}
// FindById 通过ID查询信息
func (s SysPost) FindById(postId int64) model.SysPost {
if postId <= 0 {
return model.SysPost{}
}
posts := s.sysPostRepository.SelectByIds([]int64{postId})
if len(posts) > 0 {
return posts[0]
}
return model.SysPost{}
}
// Insert 新增信息
func (s SysPost) Insert(sysPost model.SysPost) int64 {
return s.sysPostRepository.Insert(sysPost)
}
// Update 修改信息
func (s SysPost) Update(sysPost model.SysPost) int64 {
return s.sysPostRepository.Update(sysPost)
}
// DeleteByIds 批量删除信息
func (s SysPost) DeleteByIds(postIds []int64) (int64, error) {
// 检查是否存在
posts := s.sysPostRepository.SelectByIds(postIds)
if len(posts) <= 0 {
// return 0, fmt.Errorf("没有权限访问岗位数据！")
return 0, fmt.Errorf("there is no accessible post data")
}
for _, post := range posts {
if useCount := s.sysUserPostRepository.ExistUserByPostId(post.PostId); useCount > 0 {
// return 0, fmt.Errorf("【%s】已分配给用户,不能删除", post.PostName)
return 0, fmt.Errorf("[%s] has been assigned to a user and cannot be deleted", post.PostName)
}
}
if len(posts) == len(postIds) {
return s.sysPostRepository.DeleteByIds(postIds), nil
}
// return 0, fmt.Errorf("删除岗位信息失败！")
return 0, fmt.Errorf("failed to delete post information")
}
// CheckUniqueByName 检查岗位名称是否唯一
func (s SysPost) CheckUniqueByName(postName string, postId int64) bool {
uniqueId := s.sysPostRepository.CheckUnique(model.SysPost{
PostName: postName,
})
if uniqueId == postId {
return true
}
return uniqueId == 0
}
// CheckUniqueByCode 检查岗位编码是否唯一
func (s SysPost) CheckUniqueByCode(postCode string, postId int64) bool {
uniqueId := s.sysPostRepository.CheckUnique(model.SysPost{
PostCode: postCode,
})
if uniqueId == postId {
return true
}
return uniqueId == 0
}
// FindByUserId 根据用户ID获取岗位选择框列表
func (s SysPost) FindByUserId(userId int64) []model.SysPost {
return s.sysPostRepository.SelectByUserId(userId)
}
// ExportData 导出数据表格
func (s SysPost) ExportData(rows []model.SysPost, fileName string) (string, error) {
// 第一行表头标题
headerCells := map[string]string{
"A1": "岗位编号",
"B1": "岗位编码",
"C1": "岗位名称",
"D1": "岗位排序",
"E1": "岗位状态",
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
statusValue := "停用"
if row.StatusFlag == constants.STATUS_YES {
statusValue = "正常"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.PostId,
"B" + idx: row.PostCode,
"C" + idx: row.PostName,
"D" + idx: row.PostSort,
"E" + idx: statusValue,
})
}
// 导出数据表格
return file.WriteSheet(headerCells, dataCells, fileName, "")
}

104
src/modules/system/service/sys_post.impl.go
View File

@@ -1,104 +0,0 @@
package service
import (
"fmt"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysPostImpl 结构体
var NewSysPostImpl = &SysPostImpl{
sysPostRepository: repository.NewSysPostImpl,
sysUserPostRepository: repository.NewSysUserPostImpl,
}
// SysPostImpl 岗位表 服务层处理
type SysPostImpl struct {
// 岗位服务
sysPostRepository repository.ISysPost
// 用户与岗位关联服务
sysUserPostRepository repository.ISysUserPost
}
// SelectPostPage 查询岗位分页数据集合
func (r *SysPostImpl) SelectPostPage(query map[string]any) map[string]any {
return r.sysPostRepository.SelectPostPage(query)
}
// SelectPostList 查询岗位数据集合
func (r *SysPostImpl) SelectPostList(sysPost model.SysPost) []model.SysPost {
return r.sysPostRepository.SelectPostList(sysPost)
}
// SelectPostById 通过岗位ID查询岗位信息
func (r *SysPostImpl) SelectPostById(postId string) model.SysPost {
if postId == "" {
return model.SysPost{}
}
posts := r.sysPostRepository.SelectPostByIds([]string{postId})
if len(posts) > 0 {
return posts[0]
}
return model.SysPost{}
}
// SelectPostListByUserId 根据用户ID获取岗位选择框列表
func (r *SysPostImpl) SelectPostListByUserId(userId string) []model.SysPost {
return r.sysPostRepository.SelectPostListByUserId(userId)
}
// DeletePostByIds 批量删除岗位信息
func (r *SysPostImpl) DeletePostByIds(postIds []string) (int64, error) {
// 检查是否存在
posts := r.sysPostRepository.SelectPostByIds(postIds)
if len(posts) <= 0 {
// 没有可访问岗位数据！
return 0, fmt.Errorf("there is no accessible post data")
}
for _, post := range posts {
useCount := r.sysUserPostRepository.CountUserPostByPostId(post.PostID)
if useCount > 0 {
// 【%s】已分配给用户,不能删除
return 0, fmt.Errorf("[%s] has been assigned to a user and cannot be deleted", post.PostName)
}
}
if len(posts) == len(postIds) {
rows := r.sysPostRepository.DeletePostByIds(postIds)
return rows, nil
}
// 删除岗位信息失败！
return 0, fmt.Errorf("failed to delete post information")
}
// UpdatePost 修改岗位信息
func (r *SysPostImpl) UpdatePost(sysPost model.SysPost) int64 {
return r.sysPostRepository.UpdatePost(sysPost)
}
// InsertPost 新增岗位信息
func (r *SysPostImpl) InsertPost(sysPost model.SysPost) string {
return r.sysPostRepository.InsertPost(sysPost)
}
// CheckUniquePostName 校验岗位名称
func (r *SysPostImpl) CheckUniquePostName(postName, postId string) bool {
uniqueId := r.sysPostRepository.CheckUniquePost(model.SysPost{
PostName: postName,
})
if uniqueId == postId {
return true
}
return uniqueId == ""
}
// CheckUniquePostCode 校验岗位编码
func (r *SysPostImpl) CheckUniquePostCode(postCode, postId string) bool {
uniqueId := r.sysPostRepository.CheckUniquePost(model.SysPost{
PostCode: postCode,
})
if uniqueId == postId {
return true
}
return uniqueId == ""
}

222
src/modules/system/service/sys_role.go
View File

@@ -1,42 +1,190 @@
package service
import "be.ems/src/modules/system/model"
import (
"fmt"
// ISysRole 角色 服务层接口
type ISysRole interface {
// SelectRolePage 根据条件分页查询角色数据
SelectRolePage(query map[string]any, dataScopeSQL string) map[string]any
"be.ems/src/framework/constants"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// SelectRoleList 根据条件查询角色数据
SelectRoleList(sysRole model.SysRole, dataScopeSQL string) []model.SysRole
// SelectRoleListByUserId 根据用户ID获取角色选择框列表
SelectRoleListByUserId(userId string) []model.SysRole
// SelectRoleById 通过角色ID查询角色
SelectRoleById(roleId string) model.SysRole
// UpdateRole 修改角色信息
UpdateRole(sysRole model.SysRole) int64
// InsertRole 新增角色信息
InsertRole(sysRole model.SysRole) string
// DeleteRoleByIds 批量删除角色信息
DeleteRoleByIds(roleIds []string) (int64, error)
// CheckUniqueRoleName 校验角色名称是否唯一
CheckUniqueRoleName(roleName, roleId string) bool
// CheckUniqueRoleKey 校验角色权限是否唯一
CheckUniqueRoleKey(roleKey, roleId string) bool
// AuthDataScope 修改数据权限信息
AuthDataScope(sysRole model.SysRole) int64
// DeleteAuthUsers 批量取消授权用户角色
DeleteAuthUsers(roleId string, userIds []string) int64
// InsertAuthUsers 批量新增授权用户角色
InsertAuthUsers(roleId string, userIds []string) int64
// NewSysRole 实例化服务层
var NewSysRole = &SysRole{
sysRoleRepository: repository.NewSysRole,
sysUserRoleRepository: repository.NewSysUserRole,
sysRoleDeptRepository: repository.NewSysRoleDept,
sysRoleMenuRepository: repository.NewSysRoleMenu,
}
// SysRole 角色 服务层处理
type SysRole struct {
sysRoleRepository *repository.SysRole // 角色服务
sysUserRoleRepository *repository.SysUserRole // 用户与角色关联服务
sysRoleDeptRepository *repository.SysRoleDept // 角色与部门关联服务
sysRoleMenuRepository *repository.SysRoleMenu // 角色与菜单关联服务
}
// FindByPage 分页查询列表数据
func (r SysRole) FindByPage(query map[string]string) ([]model.SysRole, int64) {
return r.sysRoleRepository.SelectByPage(query)
}
// Find 查询列表数据
func (r SysRole) Find(sysRole model.SysRole) []model.SysRole {
rows := r.sysRoleRepository.Select(sysRole)
arr := make([]model.SysRole, 0)
for _, v := range rows {
if v.RoleId == constants.SYS_ROLE_SYSTEM_ID {
continue
}
arr = append(arr, v)
}
return arr
}
// FindById 通过ID查询信息
func (r SysRole) FindById(roleId int64) model.SysRole {
if roleId <= 0 {
return model.SysRole{}
}
posts := r.sysRoleRepository.SelectByIds([]int64{roleId})
if len(posts) > 0 {
return posts[0]
}
return model.SysRole{}
}
// Insert 新增信息
func (r SysRole) Insert(sysRole model.SysRole) int64 {
insertId := r.sysRoleRepository.Insert(sysRole)
if insertId > 0 && len(sysRole.MenuIds) > 0 {
r.insertRoleMenu(insertId, sysRole.MenuIds)
}
return insertId
}
// insertRoleMenu 新增角色菜单信息
func (r SysRole) insertRoleMenu(roleId int64, menuIds []int64) int64 {
if roleId <= 0 || len(menuIds) <= 0 {
return 0
}
sysRoleMenus := make([]model.SysRoleMenu, 0)
for _, menuId := range menuIds {
if menuId <= 0 {
continue
}
sysRoleMenus = append(sysRoleMenus, model.SysRoleMenu{
RoleId: roleId, MenuId: menuId,
})
}
return r.sysRoleMenuRepository.BatchInsert(sysRoleMenus)
}
// Update 修改信息
func (r SysRole) Update(sysRole model.SysRole) int64 {
rows := r.sysRoleRepository.Update(sysRole)
if rows > 0 && len(sysRole.MenuIds) > 0 {
// 删除角色与菜单关联
r.sysRoleMenuRepository.DeleteByRoleIds([]int64{sysRole.RoleId})
r.insertRoleMenu(sysRole.RoleId, sysRole.MenuIds)
}
return rows
}
// DeleteByIds 批量删除信息
func (r SysRole) DeleteByIds(roleIds []int64) (int64, error) {
// 检查是否存在
roles := r.sysRoleRepository.SelectByIds(roleIds)
if len(roles) <= 0 {
return 0, fmt.Errorf("没有权限访问角色数据！")
}
for _, role := range roles {
// 检查是否为已删除
if role.DelFlag == "1" {
return 0, fmt.Errorf("ID:%d 角色信息已经删除！", role.RoleId)
}
// 检查分配用户
if useCount := r.sysUserRoleRepository.ExistUserByRoleId(role.RoleId); useCount > 0 {
return 0, fmt.Errorf("【%s】已分配给用户,不能删除", role.RoleName)
}
}
if len(roles) == len(roleIds) {
r.sysRoleMenuRepository.DeleteByRoleIds(roleIds) // 删除角色与菜单关联
r.sysRoleDeptRepository.DeleteByRoleIds(roleIds) // 删除角色与部门关联
return r.sysRoleRepository.DeleteByIds(roleIds), nil
}
return 0, fmt.Errorf("删除角色信息失败！")
}
// FindByUserId 根据用户ID获取角色选择框列表
func (r SysRole) FindByUserId(userId int64) []model.SysRole {
return r.sysRoleRepository.SelectByUserId(userId)
}
// CheckUniqueByName 检查角色名称是否唯一
func (r SysRole) CheckUniqueByName(roleName string, roleId int64) bool {
uniqueId := r.sysRoleRepository.CheckUnique(model.SysRole{
RoleName: roleName,
})
if uniqueId == roleId {
return true
}
return uniqueId == 0
}
// CheckUniqueByKey 检查角色权限是否唯一
func (r SysRole) CheckUniqueByKey(roleKey string, roleId int64) bool {
uniqueId := r.sysRoleRepository.CheckUnique(model.SysRole{
RoleKey: roleKey,
})
if uniqueId == roleId {
return true
}
return uniqueId == 0
}
// UpdateAndDataScope 修改信息同时更新数据权限信息
func (r SysRole) UpdateAndDataScope(sysRole model.SysRole) int64 {
// 修改角色信息
rows := r.sysRoleRepository.Update(sysRole)
if rows > 0 {
// 删除角色与部门关联
r.sysRoleDeptRepository.DeleteByRoleIds([]int64{sysRole.RoleId})
// 新增角色和部门信息
if sysRole.DataScope == constants.ROLE_SCOPE_CUSTOM && len(sysRole.DeptIds) > 0 {
arr := make([]model.SysRoleDept, 0)
for _, deptId := range sysRole.DeptIds {
if deptId <= 0 {
continue
}
arr = append(arr, model.SysRoleDept{
RoleId: sysRole.RoleId, DeptId: deptId,
})
}
r.sysRoleDeptRepository.BatchInsert(arr)
}
}
return rows
}
// InsertAuthUsers 批量新增授权用户角色
func (r SysRole) InsertAuthUsers(roleId int64, userIds []int64) int64 {
if roleId <= 0 || len(userIds) <= 0 {
return 0
}
sysUserRoles := make([]model.SysUserRole, 0)
for _, userId := range userIds {
if userId <= 0 {
continue
}
sysUserRoles = append(sysUserRoles, model.SysUserRole{
UserId: userId, RoleId: roleId,
})
}
return r.sysUserRoleRepository.BatchInsert(sysUserRoles)
}
// DeleteAuthUsers 批量取消授权用户角色
func (r SysRole) DeleteAuthUsers(roleId int64, userIds []int64) int64 {
return r.sysUserRoleRepository.DeleteByRoleId(roleId, userIds)
}

189
src/modules/system/service/sys_role.impl.go
View File

@@ -1,189 +0,0 @@
package service
import (
"fmt"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysRoleImpl 结构体
var NewSysRoleImpl = &SysRoleImpl{
sysRoleRepository: repository.NewSysRoleImpl,
sysUserRoleRepository: repository.NewSysUserRoleImpl,
sysRoleDeptRepository: repository.NewSysRoleDeptImpl,
sysRoleMenuRepository: repository.NewSysRoleMenuImpl,
}
// SysRoleImpl 角色 服务层处理
type SysRoleImpl struct {
// 角色服务
sysRoleRepository repository.ISysRole
// 用户与角色关联服务
sysUserRoleRepository repository.ISysUserRole
// 角色与部门关联服务
sysRoleDeptRepository repository.ISysRoleDept
// 角色与菜单关联服务
sysRoleMenuRepository repository.ISysRoleMenu
}
// SelectRolePage 根据条件分页查询角色数据
func (r *SysRoleImpl) SelectRolePage(query map[string]any, dataScopeSQL string) map[string]any {
return r.sysRoleRepository.SelectRolePage(query, dataScopeSQL)
}
// SelectRoleList 根据条件查询角色数据
func (r *SysRoleImpl) SelectRoleList(sysRole model.SysRole, dataScopeSQL string) []model.SysRole {
return r.sysRoleRepository.SelectRoleList(sysRole, dataScopeSQL)
}
// SelectRoleListByUserId 根据用户ID获取角色选择框列表
func (r *SysRoleImpl) SelectRoleListByUserId(userId string) []model.SysRole {
return r.sysRoleRepository.SelectRoleListByUserId(userId)
}
// SelectRoleById 通过角色ID查询角色
func (r *SysRoleImpl) SelectRoleById(roleId string) model.SysRole {
if roleId == "" {
return model.SysRole{}
}
posts := r.sysRoleRepository.SelectRoleByIds([]string{roleId})
if len(posts) > 0 {
return posts[0]
}
return model.SysRole{}
}
// UpdateRole 修改角色信息
func (r *SysRoleImpl) UpdateRole(sysRole model.SysRole) int64 {
rows := r.sysRoleRepository.UpdateRole(sysRole)
if rows > 0 && len(sysRole.MenuIds) > 0 {
// 删除角色与菜单关联
r.sysRoleMenuRepository.DeleteRoleMenu([]string{sysRole.RoleID})
r.insertRoleMenu(sysRole.RoleID, sysRole.MenuIds)
}
return rows
}
// InsertRole 新增角色信息
func (r *SysRoleImpl) InsertRole(sysRole model.SysRole) string {
insertId := r.sysRoleRepository.InsertRole(sysRole)
if insertId != "" && len(sysRole.MenuIds) > 0 {
r.insertRoleMenu(insertId, sysRole.MenuIds)
}
return insertId
}
// insertRoleMenu 新增角色菜单信息
func (r *SysRoleImpl) insertRoleMenu(roleId string, menuIds []string) int64 {
if roleId == "" || len(menuIds) <= 0 {
return 0
}
sysRoleMenus := []model.SysRoleMenu{}
for _, menuId := range menuIds {
if menuId == "" {
continue
}
sysRoleMenus = append(sysRoleMenus, model.NewSysRoleMenu(roleId, menuId))
}
return r.sysRoleMenuRepository.BatchRoleMenu(sysRoleMenus)
}
// DeleteRoleByIds 批量删除角色信息
func (r *SysRoleImpl) DeleteRoleByIds(roleIds []string) (int64, error) {
// 检查是否存在
roles := r.sysRoleRepository.SelectRoleByIds(roleIds)
if len(roles) <= 0 {
// 没有可访问角色数据！
return 0, fmt.Errorf("there is no accessible role data")
}
for _, role := range roles {
// 检查是否为已删除
if role.DelFlag == "1" {
// 【%s】角色信息已经删除！
return 0, fmt.Errorf("[%s] Role information has been deleted", role.RoleID)
}
// 检查分配用户
userCount := r.sysUserRoleRepository.CountUserRoleByRoleId(role.RoleID)
if userCount > 0 {
// 【%s】已分配给用户,不能删除
return 0, fmt.Errorf("[%s] has been assigned to a user and cannot be deleted", role.RoleName)
}
}
if len(roles) == len(roleIds) {
// 删除角色与菜单关联
r.sysRoleMenuRepository.DeleteRoleMenu(roleIds)
// 删除角色与部门关联
r.sysRoleDeptRepository.DeleteRoleDept(roleIds)
rows := r.sysRoleRepository.DeleteRoleByIds(roleIds)
return rows, nil
}
// 删除角色信息失败！
return 0, fmt.Errorf("failed to delete role information")
}
// CheckUniqueRoleName 校验角色名称是否唯一
func (r *SysRoleImpl) CheckUniqueRoleName(roleName, roleId string) bool {
uniqueId := r.sysRoleRepository.CheckUniqueRole(model.SysRole{
RoleName: roleName,
})
if uniqueId == roleId {
return true
}
return uniqueId == ""
}
// CheckUniqueRoleKey 校验角色权限是否唯一
func (r *SysRoleImpl) CheckUniqueRoleKey(roleKey, roleId string) bool {
uniqueId := r.sysRoleRepository.CheckUniqueRole(model.SysRole{
RoleKey: roleKey,
})
if uniqueId == roleId {
return true
}
return uniqueId == ""
}
// AuthDataScope 修改数据权限信息
func (r *SysRoleImpl) AuthDataScope(sysRole model.SysRole) int64 {
// 修改角色信息
rows := r.sysRoleRepository.UpdateRole(sysRole)
// 删除角色与部门关联
r.sysRoleDeptRepository.DeleteRoleDept([]string{sysRole.RoleID})
// 新增角色和部门信息
if sysRole.DataScope == "2" && len(sysRole.DeptIds) > 0 {
sysRoleDepts := []model.SysRoleDept{}
for _, deptId := range sysRole.DeptIds {
if deptId == "" {
continue
}
sysRoleDepts = append(sysRoleDepts, model.NewSysRoleDept(sysRole.RoleID, deptId))
}
rows += r.sysRoleDeptRepository.BatchRoleDept(sysRoleDepts)
}
return rows
}
// DeleteAuthUsers 批量取消授权用户角色
func (r *SysRoleImpl) DeleteAuthUsers(roleId string, userIds []string) int64 {
return r.sysUserRoleRepository.DeleteUserRoleByRoleId(roleId, userIds)
}
// InsertAuthUsers 批量新增授权用户角色
func (r *SysRoleImpl) InsertAuthUsers(roleId string, userIds []string) int64 {
if roleId == "" || len(userIds) <= 0 {
return 0
}
sysUserRoles := []model.SysUserRole{}
for _, userId := range userIds {
if userId == "" {
continue
}
sysUserRoles = append(sysUserRoles, model.NewSysUserRole(userId, roleId))
}
return r.sysUserRoleRepository.BatchUserRole(sysUserRoles)
}

276
src/modules/system/service/sys_user.go
View File

@@ -1,42 +1,244 @@
package service
import "be.ems/src/modules/system/model"
import (
"fmt"
// ISysUser 用户 服务层接口
type ISysUser interface {
// SelectUserPage 根据条件分页查询用户列表
SelectUserPage(query map[string]any, dataScopeSQL string) map[string]any
"be.ems/src/framework/constants"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// SelectUserList 根据条件查询用户列表
SelectUserList(sysUser model.SysUser, dataScopeSQL string) []model.SysUser
// SelectAllocatedPage 根据条件分页查询分配用户角色列表
SelectAllocatedPage(query map[string]any, dataScopeSQL string) map[string]any
// SelectUserByUserName 通过用户名查询用户
SelectUserByUserName(userName string) model.SysUser
// SelectUserById 通过用户ID查询用户
SelectUserById(userId string) model.SysUser
// InsertUser 新增用户信息
InsertUser(sysUser model.SysUser) string
// UpdateUser 修改用户信息
UpdateUser(sysUser model.SysUser) int64
// UpdateUserAndRolePost 修改用户信息同时更新角色和岗位
UpdateUserAndRolePost(sysUser model.SysUser) int64
// DeleteUserByIds 批量删除用户信息
DeleteUserByIds(userIds []string) (int64, error)
// CheckUniqueUserName 校验用户名称是否唯一
CheckUniqueUserName(userName, userId string) bool
// CheckUniquePhone 校验手机号码是否唯一
CheckUniquePhone(phonenumber, userId string) bool
// CheckUniqueEmail 校验email是否唯一
CheckUniqueEmail(email, userId string) bool
// NewSysUser 实例化服务层
var NewSysUser = &SysUser{
sysUserRepository: repository.NewSysUser,
sysRoleRepository: repository.NewSysRole,
sysDeptRepository: repository.NewSysDept,
sysUserRoleRepository: repository.NewSysUserRole,
sysUserPostRepository: repository.NewSysUserPost,
sysDictTypeService: NewSysDictType,
sysDictDataService: NewSysDictData,
sysConfigService: NewSysConfig,
}
// SysUser 用户 服务层处理
type SysUser struct {
sysUserRepository *repository.SysUser // 用户服务
sysRoleRepository *repository.SysRole // 角色服务
sysDeptRepository *repository.SysDept // 部门服务
sysUserRoleRepository *repository.SysUserRole // 用户与角色服务
sysUserPostRepository *repository.SysUserPost // 用户与岗位服务
sysDictTypeService *SysDictType // 字典类型服务
sysDictDataService *SysDictData // 字典数据服务
sysConfigService *SysConfig // 参数配置服务
}
// FindByPage 分页查询列表数据
func (s SysUser) FindByPage(query map[string]string, dataScopeSQL string) ([]model.SysUser, int64) {
rows, total := s.sysUserRepository.SelectByPage(query, dataScopeSQL)
for i, v := range rows {
// 部门
deptInfo := s.sysDeptRepository.SelectById(v.DeptId)
rows[i].Dept = &deptInfo
// 角色
roleArr := s.sysRoleRepository.SelectByUserId(v.UserId)
roleIds := make([]int64, 0)
roles := make([]*model.SysRole, 0)
for _, role := range roleArr {
roles = append(roles, &role)
roleIds = append(roleIds, role.RoleId)
}
rows[i].Roles = roles
rows[i].RoleIds = roleIds
}
return rows, total
}
// Find 查询数据
func (s SysUser) Find(sysUser model.SysUser) []model.SysUser {
return s.sysUserRepository.Select(sysUser)
}
// FindById 通过ID查询信息
func (s SysUser) FindById(userId int64) model.SysUser {
userInfo := model.SysUser{}
if userId <= 0 {
return userInfo
}
users := s.sysUserRepository.SelectByIds([]int64{userId})
if len(users) > 0 {
userInfo = users[0]
// 部门
deptInfo := s.sysDeptRepository.SelectById(userInfo.DeptId)
userInfo.Dept = &deptInfo
// 角色
roleArr := s.sysRoleRepository.SelectByUserId(userInfo.UserId)
roleIds := make([]int64, 0)
roles := make([]*model.SysRole, 0)
for _, role := range roleArr {
roles = append(roles, &role)
roleIds = append(roleIds, role.RoleId)
}
userInfo.Roles = roles
userInfo.RoleIds = roleIds
}
return userInfo
}
// Insert 新增信息
func (s SysUser) Insert(sysUser model.SysUser) int64 {
// 新增用户信息
insertId := s.sysUserRepository.Insert(sysUser)
if insertId > 0 {
s.insertUserRole(insertId, sysUser.RoleIds) // 新增用户角色信息
s.insertUserPost(insertId, sysUser.PostIds) // 新增用户岗位信息
}
return insertId
}
// insertUserRole 新增用户角色信息
func (s SysUser) insertUserRole(userId int64, roleIds []int64) int64 {
if userId <= 0 || len(roleIds) <= 0 {
return 0
}
var arr []model.SysUserRole
for _, roleId := range roleIds {
// 系统管理员角色禁止操作，只能通过配置指定用户ID分配
if roleId <= 0 || roleId == constants.SYS_ROLE_SYSTEM_ID {
continue
}
arr = append(arr, model.SysUserRole{
UserId: userId, RoleId: roleId,
})
}
return s.sysUserRoleRepository.BatchInsert(arr)
}
// insertUserPost 新增用户岗位信息
func (s SysUser) insertUserPost(userId int64, postIds []int64) int64 {
if userId <= 0 || len(postIds) <= 0 {
return 0
}
var arr []model.SysUserPost
for _, postId := range postIds {
if postId <= 0 {
continue
}
arr = append(arr, model.SysUserPost{
UserId: userId, PostId: postId,
})
}
return s.sysUserPostRepository.BatchInsert(arr)
}
// Update 修改信息
func (s SysUser) Update(sysUser model.SysUser) int64 {
return s.sysUserRepository.Update(sysUser)
}
// UpdateUserAndRolePost 修改用户信息同时更新角色和岗位
func (s SysUser) UpdateUserAndRolePost(sysUser model.SysUser) int64 {
// 删除用户与角色关联
s.sysUserRoleRepository.DeleteByUserIds([]int64{sysUser.UserId})
// 新增用户角色信息
s.insertUserRole(sysUser.UserId, sysUser.RoleIds)
// 删除用户与岗位关联
s.sysUserPostRepository.DeleteByUserIds([]int64{sysUser.UserId})
// 新增用户岗位信息
s.insertUserPost(sysUser.UserId, sysUser.PostIds)
return s.sysUserRepository.Update(sysUser)
}
// DeleteByIds 批量删除信息
func (s SysUser) DeleteByIds(userIds []int64) (int64, error) {
// 检查是否存在
users := s.sysUserRepository.SelectByIds(userIds)
if len(users) <= 0 {
return 0, fmt.Errorf("没有权限访问用户数据！")
}
if len(users) == len(userIds) {
s.sysUserRoleRepository.DeleteByUserIds(userIds) // 删除用户与角色关联
s.sysUserPostRepository.DeleteByUserIds(userIds) // 删除用户与岗位关联
return s.sysUserRepository.DeleteByIds(userIds), nil
}
return 0, fmt.Errorf("删除用户信息失败！")
}
// CheckUniqueByUserName 检查用户名称是否唯一
func (s SysUser) CheckUniqueByUserName(userName string, userId int64) bool {
uniqueId := s.sysUserRepository.CheckUnique(model.SysUser{
UserName: userName,
})
if uniqueId == userId {
return true
}
return uniqueId == 0
}
// CheckUniqueByPhone 检查手机号码是否唯一
func (s SysUser) CheckUniqueByPhone(phone string, userId int64) bool {
uniqueId := s.sysUserRepository.CheckUnique(model.SysUser{
Phone: phone,
})
if uniqueId == userId {
return true
}
return uniqueId == 0
}
// CheckUniqueByEmail 检查Email是否唯一
func (s SysUser) CheckUniqueByEmail(email string, userId int64) bool {
uniqueId := s.sysUserRepository.CheckUnique(model.SysUser{
Email: email,
})
if uniqueId == userId {
return true
}
return uniqueId == 0
}
// FindByUserName 通过用户名查询用户信息
func (s SysUser) FindByUserName(userName string) model.SysUser {
userinfo := s.sysUserRepository.SelectByUserName(userName)
if userinfo.UserName != userName {
return userinfo
}
// 部门
deptInfo := s.sysDeptRepository.SelectById(userinfo.DeptId)
userinfo.Dept = &deptInfo
// 角色
roleArr := s.sysRoleRepository.SelectByUserId(userinfo.UserId)
roles := make([]*model.SysRole, 0)
roleIds := make([]int64, 0)
for _, role := range roleArr {
roles = append(roles, &role)
roleIds = append(roleIds, role.RoleId)
}
userinfo.Roles = roles
userinfo.RoleIds = roleIds
return userinfo
}
// FindAuthUsersPage 根据条件分页查询分配用户角色列表
func (s SysUser) FindAuthUsersPage(query map[string]string, dataScopeSQL string) ([]model.SysUser, int64) {
rows, total := s.sysUserRepository.SelectAuthUsersByPage(query, dataScopeSQL)
for i, v := range rows {
// 部门
deptInfo := s.sysDeptRepository.SelectById(v.DeptId)
rows[i].Dept = &deptInfo
// 角色
roleArr := s.sysRoleRepository.SelectByUserId(v.UserId)
roleIds := make([]int64, 0)
roles := make([]*model.SysRole, 0)
for _, role := range roleArr {
roles = append(roles, &role)
roleIds = append(roleIds, role.RoleId)
}
rows[i].Roles = roles
rows[i].RoleIds = roleIds
}
return rows, total
}

178
src/modules/system/service/sys_user.impl.go
View File

@@ -1,178 +0,0 @@
package service
import (
"fmt"
"be.ems/src/framework/constants/admin"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 实例化服务层 SysUserImpl 结构体
var NewSysUserImpl = &SysUserImpl{
sysUserRepository: repository.NewSysUserImpl,
sysUserRoleRepository: repository.NewSysUserRoleImpl,
sysUserPostRepository: repository.NewSysUserPostImpl,
}
// SysUserImpl 用户 服务层处理
type SysUserImpl struct {
// 用户服务
sysUserRepository repository.ISysUser
// 用户与角色服务
sysUserRoleRepository repository.ISysUserRole
// 用户与岗位服务
sysUserPostRepository repository.ISysUserPost
}
// SelectUserPage 根据条件分页查询用户列表
func (r *SysUserImpl) SelectUserPage(query map[string]any, dataScopeSQL string) map[string]any {
return r.sysUserRepository.SelectUserPage(query, dataScopeSQL)
}
// SelectUserList 根据条件查询用户列表
func (r *SysUserImpl) SelectUserList(sysUser model.SysUser, dataScopeSQL string) []model.SysUser {
return r.sysUserRepository.SelectUserList(sysUser, dataScopeSQL)
}
// SelectAllocatedPage 根据条件分页查询分配用户角色列表
func (r *SysUserImpl) SelectAllocatedPage(query map[string]any, dataScopeSQL string) map[string]any {
return r.sysUserRepository.SelectAllocatedPage(query, dataScopeSQL)
}
// SelectUserByUserName 通过用户名查询用户
func (r *SysUserImpl) SelectUserByUserName(userName string) model.SysUser {
return r.sysUserRepository.SelectUserByUserName(userName)
}
// SelectUserById 通过用户ID查询用户
func (r *SysUserImpl) SelectUserById(userId string) model.SysUser {
if userId == "" {
return model.SysUser{}
}
users := r.sysUserRepository.SelectUserByIds([]string{userId})
if len(users) > 0 {
return users[0]
}
return model.SysUser{}
}
// InsertUser 新增用户信息
func (r *SysUserImpl) InsertUser(sysUser model.SysUser) string {
// 新增用户信息
insertId := r.sysUserRepository.InsertUser(sysUser)
if insertId != "" {
// 新增用户角色信息
r.insertUserRole(insertId, sysUser.RoleIDs)
// 新增用户岗位信息
r.insertUserPost(insertId, sysUser.PostIDs)
}
return insertId
}
// insertUserRole 新增用户角色信息
func (r *SysUserImpl) insertUserRole(userId string, roleIds []string) int64 {
if userId == "" || len(roleIds) <= 0 {
return 0
}
sysUserRoles := []model.SysUserRole{}
for _, roleId := range roleIds {
// 管理员角色禁止操作，只能通过配置指定用户ID分配
if roleId == "" || roleId == admin.ROLE_ID {
continue
}
sysUserRoles = append(sysUserRoles, model.NewSysUserRole(userId, roleId))
}
return r.sysUserRoleRepository.BatchUserRole(sysUserRoles)
}
// insertUserPost 新增用户岗位信息
func (r *SysUserImpl) insertUserPost(userId string, postIds []string) int64 {
if userId == "" || len(postIds) <= 0 {
return 0
}
sysUserPosts := []model.SysUserPost{}
for _, postId := range postIds {
if postId == "" {
continue
}
sysUserPosts = append(sysUserPosts, model.NewSysUserPost(userId, postId))
}
return r.sysUserPostRepository.BatchUserPost(sysUserPosts)
}
// UpdateUser 修改用户信息
func (r *SysUserImpl) UpdateUser(sysUser model.SysUser) int64 {
return r.sysUserRepository.UpdateUser(sysUser)
}
// UpdateUserAndRolePost 修改用户信息同时更新角色和岗位
func (r *SysUserImpl) UpdateUserAndRolePost(sysUser model.SysUser) int64 {
// 删除用户与角色关联
r.sysUserRoleRepository.DeleteUserRole([]string{sysUser.UserID})
// 新增用户角色信息
r.insertUserRole(sysUser.UserID, sysUser.RoleIDs)
// 删除用户与岗位关联
r.sysUserPostRepository.DeleteUserPost([]string{sysUser.UserID})
// 新增用户岗位信息
r.insertUserPost(sysUser.UserID, sysUser.PostIDs)
return r.sysUserRepository.UpdateUser(sysUser)
}
// DeleteUserByIds 批量删除用户信息
func (r *SysUserImpl) DeleteUserByIds(userIds []string) (int64, error) {
// 检查是否存在
users := r.sysUserRepository.SelectUserByIds(userIds)
if len(users) <= 0 {
// 没有可访问用户数据！
return 0, fmt.Errorf("there is no accessible user data")
}
if len(users) == len(userIds) {
// 删除用户与角色关联
r.sysUserRoleRepository.DeleteUserRole(userIds)
// 删除用户与岗位关联
r.sysUserPostRepository.DeleteUserPost(userIds)
// ... 注意其他userId进行关联的表
// 删除用户
rows := r.sysUserRepository.DeleteUserByIds(userIds)
return rows, nil
}
return 0, fmt.Errorf("failed to delete user information")
}
// CheckUniqueUserName 校验用户名称是否唯一
func (r *SysUserImpl) CheckUniqueUserName(userName, userId string) bool {
uniqueId := r.sysUserRepository.CheckUniqueUser(model.SysUser{
UserName: userName,
})
if uniqueId == userId {
return true
}
return uniqueId == ""
}
// CheckUniquePhone 校验手机号码是否唯一
func (r *SysUserImpl) CheckUniquePhone(phonenumber, userId string) bool {
uniqueId := r.sysUserRepository.CheckUniqueUser(model.SysUser{
PhoneNumber: phonenumber,
})
if uniqueId == userId {
return true
}
return uniqueId == ""
}
// CheckUniqueEmail 校验email是否唯一
func (r *SysUserImpl) CheckUniqueEmail(email, userId string) bool {
uniqueId := r.sysUserRepository.CheckUniqueUser(model.SysUser{
Email: email,
})
if uniqueId == userId {
return true
}
return uniqueId == ""
}

301
src/modules/system/system.go
View File

@@ -1,14 +1,12 @@
package system
import (
"github.com/gin-gonic/gin"
"be.ems/src/framework/logger"
"be.ems/src/framework/middleware"
"be.ems/src/framework/middleware/collectlogs"
"be.ems/src/framework/middleware/repeat"
"be.ems/src/modules/system/controller"
"be.ems/src/modules/system/service"
"github.com/gin-gonic/gin"
)
// Setup 模块路由注册
@@ -31,34 +29,41 @@ func Setup(router *gin.Engine) {
)
sysConfigGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysConfig", collectlogs.BUSINESS_TYPE_INSERT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysConfig.Add,
)
sysConfigGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysConfig", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysConfig.Edit,
)
sysConfigGroup.DELETE("/:configIds",
sysConfigGroup.DELETE("/:configId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysConfig", collectlogs.BUSINESS_TYPE_DELETE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysConfig.Remove,
)
sysConfigGroup.PUT("/refreshCache",
repeat.RepeatSubmit(5),
sysConfigGroup.PUT("/refresh",
middleware.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysConfig", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysConfig.RefreshCache,
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_OTHER)),
controller.NewSysConfig.Refresh,
)
sysConfigGroup.GET("/configKey/:configKey", controller.NewSysConfig.ConfigKey)
sysConfigGroup.POST("/export",
sysConfigGroup.GET("/config-key/:configKey",
middleware.RateLimit(middleware.LimitOption{
Time: 120,
Count: 15,
Type: middleware.LIMIT_IP,
}),
controller.NewSysConfig.ConfigKey,
)
sysConfigGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysConfig", collectlogs.BUSINESS_TYPE_EXPORT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysConfig.Export,
)
sysConfigGroup.PUT("/changeValue",
sysConfigGroup.PUT("/change-value",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysConfig", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysConfig", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysConfig.ConfigValue,
)
}
@@ -76,30 +81,30 @@ func Setup(router *gin.Engine) {
)
sysDeptGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDept", collectlogs.BUSINESS_TYPE_INSERT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDept", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysDept.Add,
)
sysDeptGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDept", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDept", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysDept.Edit,
)
sysDeptGroup.DELETE("/:deptId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDept", collectlogs.BUSINESS_TYPE_DELETE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDept", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysDept.Remove,
)
sysDeptGroup.GET("/list/exclude/:deptId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:list"}}),
controller.NewSysDept.ExcludeChild,
)
sysDeptGroup.GET("/treeSelect",
sysDeptGroup.GET("/tree",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:list", "system:user:list"}}),
controller.NewSysDept.TreeSelect,
controller.NewSysDept.Tree,
)
sysDeptGroup.GET("/roleDeptTreeSelect/:roleId",
sysDeptGroup.GET("/tree/role/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:query", "system:user:edit"}}),
controller.NewSysDept.RoleDeptTreeSelect,
controller.NewSysDept.TreeRole,
)
}
@@ -110,32 +115,32 @@ func Setup(router *gin.Engine) {
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:list"}}),
controller.NewSysDictData.List,
)
sysDictDataGroup.GET("/:dictCode",
sysDictDataGroup.GET("/:dataId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:query"}}),
controller.NewSysDictData.Info,
)
sysDictDataGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictData", collectlogs.BUSINESS_TYPE_INSERT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictData", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysDictData.Add,
)
sysDictDataGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictData", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictData", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysDictData.Edit,
)
sysDictDataGroup.DELETE("/:dictCodes",
sysDictDataGroup.DELETE("/:dataId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictData", collectlogs.BUSINESS_TYPE_DELETE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictData", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysDictData.Remove,
)
sysDictDataGroup.GET("/type/:dictType",
middleware.PreAuthorize(nil),
controller.NewSysDictData.DictType,
)
sysDictDataGroup.POST("/export",
sysDictDataGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictData", collectlogs.BUSINESS_TYPE_EXPORT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictData", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysDictData.Export,
)
}
@@ -153,35 +158,78 @@ func Setup(router *gin.Engine) {
)
sysDictTypeGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictType", collectlogs.BUSINESS_TYPE_INSERT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysDictType.Add,
)
sysDictTypeGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictType", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysDictType.Edit,
)
sysDictTypeGroup.DELETE("/:dictIds",
sysDictTypeGroup.DELETE("/:dictId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictType", collectlogs.BUSINESS_TYPE_DELETE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysDictType.Remove,
)
sysDictTypeGroup.PUT("/refreshCache",
sysDictTypeGroup.PUT("/refresh",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictType", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysDictType.RefreshCache,
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_OTHER)),
controller.NewSysDictType.Refresh,
)
sysDictTypeGroup.GET("/getDictOptionselect",
sysDictTypeGroup.GET("/options",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:query"}}),
controller.NewSysDictType.DictOptionselect,
controller.NewSysDictType.Options,
)
sysDictTypeGroup.POST("/export",
sysDictTypeGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysDictType", collectlogs.BUSINESS_TYPE_EXPORT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysDictType", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysDictType.Export,
)
}
// 系统登录日志信息
sysLogLoginGroup := router.Group("/system/log/login")
{
sysLogLoginGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:list"}}),
controller.NewSysLogLogin.List,
)
sysLogLoginGroup.DELETE("/clean",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogLogin", middleware.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogLogin.Clean,
)
sysLogLoginGroup.PUT("/unlock/:userName",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:unlock"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogLogin", middleware.BUSINESS_TYPE_OTHER)),
controller.NewSysLogLogin.Unlock,
)
sysLogLoginGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogLogin", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysLogLogin.Export,
)
}
// 操作日志记录信息
sysLogOperateGroup := router.Group("/system/log/operate")
{
sysLogOperateGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:list"}}),
controller.NewSysLogOperate.List,
)
sysLogOperateGroup.DELETE("/clean",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:remove"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogOper", middleware.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogOperate.Clean,
)
sysLogOperateGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysLogOper", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysLogOperate.Export,
)
}
// 菜单信息
sysMenuGroup := router.Group("/system/menu")
{
@@ -195,26 +243,26 @@ func Setup(router *gin.Engine) {
)
sysMenuGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysMenu", collectlogs.BUSINESS_TYPE_INSERT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysMenu", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysMenu.Add,
)
sysMenuGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysMenu", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysMenu", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysMenu.Edit,
)
sysMenuGroup.DELETE("/:menuId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysMenu", collectlogs.BUSINESS_TYPE_DELETE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysMenu", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysMenu.Remove,
)
sysMenuGroup.GET("/treeSelect",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list", "system:dept:list"}}),
controller.NewSysMenu.TreeSelect,
)
sysMenuGroup.GET("/roleMenuTreeSelect/:roleId",
sysMenuGroup.GET("/tree",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list", "system:role:query"}}),
controller.NewSysMenu.RoleMenuTreeSelect,
controller.NewSysMenu.Tree,
)
sysMenuGroup.GET("/tree/role/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list", "system:role:query"}}),
controller.NewSysMenu.TreeRole,
)
}
@@ -231,21 +279,22 @@ func Setup(router *gin.Engine) {
)
sysPostGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysPost", collectlogs.BUSINESS_TYPE_INSERT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysPost", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysPost.Add,
)
sysPostGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysPost", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysPost", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysPost.Edit,
)
sysPostGroup.DELETE("/:postIds",
sysPostGroup.DELETE("/:postId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysPost", collectlogs.BUSINESS_TYPE_DELETE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysPost", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysPost.Remove,
)
sysPostGroup.POST("/export",
sysPostGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:export"}}),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysPost", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysPost.Export,
)
}
@@ -259,17 +308,13 @@ func Setup(router *gin.Engine) {
)
sysProfileGroup.PUT("",
middleware.PreAuthorize(nil),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysProfile", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.UpdateProfile,
)
sysProfileGroup.PUT("/updatePwd",
sysProfileGroup.PUT("/password",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysProfile", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.UpdatePwd,
)
sysProfileGroup.POST("/avatar",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysProfileAvatar", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.Avatar,
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysProfile", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.UpdatePassword,
)
}
@@ -286,43 +331,43 @@ func Setup(router *gin.Engine) {
)
sysRoleGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysRole", collectlogs.BUSINESS_TYPE_INSERT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysRole.Add,
)
sysRoleGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysRole", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.Edit,
)
sysRoleGroup.DELETE("/:roleIds",
sysRoleGroup.DELETE("/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysRole", collectlogs.BUSINESS_TYPE_DELETE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysRole.Remove,
)
sysRoleGroup.PUT("/changeStatus",
repeat.RepeatSubmit(5),
sysRoleGroup.PUT("/status",
middleware.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysRole", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.Status,
)
sysRoleGroup.PUT("/dataScope",
repeat.RepeatSubmit(5),
sysRoleGroup.PUT("/data-scope",
middleware.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysRole", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.DataScope,
)
sysRoleGroup.GET("/authUser/allocatedList",
sysRoleGroup.GET("/user/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:list"}}),
controller.NewSysRole.AuthUserAllocatedList,
controller.NewSysRole.UserAuthList,
)
sysRoleGroup.PUT("/authUser/checked",
sysRoleGroup.PUT("/user/auth",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysRole", collectlogs.BUSINESS_TYPE_GRANT)),
controller.NewSysRole.AuthUserChecked,
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_GRANT)),
controller.NewSysRole.UserAuthChecked,
)
sysRoleGroup.POST("/export",
sysRoleGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysRole", collectlogs.BUSINESS_TYPE_EXPORT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysRole", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysRole.Export,
)
}
@@ -340,96 +385,43 @@ func Setup(router *gin.Engine) {
)
sysUserGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysUser", collectlogs.BUSINESS_TYPE_INSERT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_INSERT)),
controller.NewSysUser.Add,
)
sysUserGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysUser", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.Edit,
)
sysUserGroup.DELETE("/:userIds",
sysUserGroup.DELETE("/:userId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysUser", collectlogs.BUSINESS_TYPE_DELETE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_DELETE)),
controller.NewSysUser.Remove,
)
sysUserGroup.PUT("/resetPwd",
sysUserGroup.PUT("/password",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:resetPwd"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysUser", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.ResetPwd,
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.Password,
)
sysUserGroup.PUT("/changeStatus",
repeat.RepeatSubmit(5),
sysUserGroup.PUT("/status",
middleware.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysUser", collectlogs.BUSINESS_TYPE_UPDATE)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.Status,
)
sysUserGroup.POST("/export",
sysUserGroup.GET("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysUser", collectlogs.BUSINESS_TYPE_EXPORT)),
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_EXPORT)),
controller.NewSysUser.Export,
)
sysUserGroup.GET("/importTemplate",
sysUserGroup.GET("/import/template",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:import"}}),
controller.NewSysUser.Template,
)
sysUserGroup.POST("/importData",
sysUserGroup.POST("/import",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:import"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysUser", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysUser.ImportData,
)
}
// 操作日志记录信息
sysLogOperGroup := router.Group("/system/log/operate")
{
sysLogOperGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:list"}}),
controller.NewSysLogOperate.List,
)
sysLogOperGroup.DELETE("/:operIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysLogOper", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysLogOperate.Remove,
)
sysLogOperGroup.DELETE("/clean",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysLogOper", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogOperate.Clean,
)
sysLogOperGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysLogOper", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysLogOperate.Export,
)
}
// 系统登录日志信息
sysLogLoginGroup := router.Group("/system/log/login")
{
sysLogLoginGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:list"}}),
controller.NewSysLogLogin.List,
)
sysLogLoginGroup.DELETE("/:loginIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysLogLogin", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysLogLogin.Remove,
)
sysLogLoginGroup.DELETE("/clean",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysLogLogin", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogLogin.Clean,
)
sysLogLoginGroup.PUT("/unlock/:userName",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:unlock"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysLogLogin", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogLogin.Unlock,
)
sysLogLoginGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("log.operate.title.sysLogLogin", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysLogLogin.Export,
middleware.OperateLog(middleware.OptionNew("log.operate.title.sysUser", middleware.BUSINESS_TYPE_IMPORT)),
controller.NewSysUser.Import,
)
}
}
@@ -437,7 +429,12 @@ func Setup(router *gin.Engine) {
// InitLoad 初始参数
func InitLoad() {
// 启动时，刷新缓存-参数配置
service.NewSysConfigImpl.ResetConfigCache()
service.NewSysConfig.CacheClean("*")
service.NewSysConfig.CacheLoad("*")
// 启动时，刷新缓存-字典类型数据
service.NewSysDictType.ResetDictCache()
service.NewSysDictType.CacheClean("*")
service.NewSysDictType.CacheLoad("*")
// 启动时，刷新缓存-多语言数据
service.NewSysI18n.CacheClean("*")
service.NewSysI18n.CacheLoad("*")
}