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

feat: 合并Gin_Vue

Browse Source
This commit is contained in:
TsMask
2023-10-16 17:10:38 +08:00
parent 5289818fd4
commit 40a32cb67f
203 changed files with 19719 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
src/modules/system/controller/sys_config.go Normal file
View File

@@ -0,0 +1,220 @@
package controller
import (
"fmt"
"strconv"
"strings"
"time"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysConfigController 结构体
var NewSysConfig = &SysConfigController{
sysConfigService: service.NewSysConfigImpl,
}
// 参数配置信息
//
// PATH /system/config
type SysConfigController struct {
// 参数配置服务
sysConfigService service.ISysConfig
}
// 参数配置列表
//
// GET /list
func (s *SysConfigController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
data := s.sysConfigService.SelectConfigPage(querys)
c.JSON(200, result.Ok(data))
}
// 参数配置信息
//
// GET /:configId
func (s *SysConfigController) Info(c *gin.Context) {
configId := c.Param("configId")
if configId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysConfigService.SelectConfigById(configId)
if data.ConfigID == configId {
c.JSON(200, result.OkData(data))
return
}
c.JSON(200, result.Err(nil))
}
// 参数配置新增
//
// POST /
func (s *SysConfigController) Add(c *gin.Context) {
var body model.SysConfig
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.ConfigID != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查属性值唯一
uniqueConfigKey := s.sysConfigService.CheckUniqueConfigKey(body.ConfigKey, "")
if !uniqueConfigKey {
msg := fmt.Sprintf("参数配置新增【%s】失败，参数键名已存在", body.ConfigKey)
c.JSON(200, result.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysConfigService.InsertConfig(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 参数配置修改
//
// PUT /
func (s *SysConfigController) Edit(c *gin.Context) {
var body model.SysConfig
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.ConfigID == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查属性值唯一
uniqueConfigKey := s.sysConfigService.CheckUniqueConfigKey(body.ConfigKey, body.ConfigID)
if !uniqueConfigKey {
msg := fmt.Sprintf("参数配置修改【%s】失败，参数键名已存在", body.ConfigKey)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查是否存在
config := s.sysConfigService.SelectConfigById(body.ConfigID)
if config.ConfigID != body.ConfigID {
c.JSON(200, result.ErrMsg("没有权限访问参数配置数据！"))
return
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysConfigService.UpdateConfig(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 参数配置删除
//
// DELETE /:configIds
func (s *SysConfigController) Remove(c *gin.Context) {
configIds := c.Param("configIds")
if configIds == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(configIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows, err := s.sysConfigService.DeleteConfigByIds(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
}
// 参数配置刷新缓存
//
// PUT /refreshCache
func (s *SysConfigController) RefreshCache(c *gin.Context) {
s.sysConfigService.ResetConfigCache()
c.JSON(200, result.Ok(nil))
}
// 参数配置根据参数键名
//
// GET /configKey/:configKey
func (s *SysConfigController) ConfigKey(c *gin.Context) {
configKey := c.Param("configKey")
if configKey == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
key := s.sysConfigService.SelectConfigValueByKey(configKey)
if key != "" {
c.JSON(200, result.OkData(key))
return
}
c.JSON(200, result.Err(nil))
}
// 导出参数配置信息
//
// POST /export
func (s *SysConfigController) Export(c *gin.Context) {
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
data := s.sysConfigService.SelectConfigPage(querys)
if data["total"].(int64) == 0 {
c.JSON(200, result.ErrMsg("导出数据记录为空"))
return
}
rows := data["rows"].([]model.SysConfig)
// 导出文件名称
fileName := fmt.Sprintf("config_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
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,
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

309
src/modules/system/controller/sys_dept.go Normal file
View File

@@ -0,0 +1,309 @@
package controller
import (
"fmt"
"strings"
"ems.agt/src/framework/constants/common"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysDeptController 结构体
var NewSysDept = &SysDeptController{
sysDeptService: service.NewSysDeptImpl,
}
// 部门信息
//
// PATH /system/dept
type SysDeptController struct {
// 部门服务
sysDeptService service.ISysDept
}
// 部门列表
//
// GET /list
func (s *SysDeptController) List(c *gin.Context) {
var querys struct {
// 部门ID
DeptID string `json:"deptId"`
// 父部门ID
ParentID string `json:"parentId" `
// 部门名称
DeptName string `json:"deptName" `
// 部门状态（0正常 1停用）
Status string `json:"status"`
}
err := c.ShouldBindQuery(&querys)
if err != nil {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
SysDeptController := model.SysDept{
DeptID: querys.DeptID,
ParentID: querys.ParentID,
DeptName: querys.DeptName,
Status: querys.Status,
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysDeptService.SelectDeptList(SysDeptController, dataScopeSQL)
c.JSON(200, result.OkData(data))
}
// 部门信息
//
// GET /:deptId
func (s *SysDeptController) Info(c *gin.Context) {
deptId := c.Param("deptId")
if deptId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysDeptService.SelectDeptById(deptId)
if data.DeptID == deptId {
c.JSON(200, result.OkData(data))
return
}
c.JSON(200, result.Err(nil))
}
// 部门新增
//
// POST /
func (s *SysDeptController) Add(c *gin.Context) {
var body model.SysDept
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DeptID != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 父级ID不为0是要检查
if body.ParentID != "0" {
deptParent := s.sysDeptService.SelectDeptById(body.ParentID)
if deptParent.DeptID != body.ParentID {
c.JSON(200, result.ErrMsg("没有权限访问部门数据！"))
return
}
if deptParent.Status == common.STATUS_NO {
msg := fmt.Sprintf("上级部门【%s】停用，不允许新增", deptParent.DeptName)
c.JSON(200, result.ErrMsg(msg))
return
}
if deptParent.DelFlag == common.STATUS_YES {
msg := fmt.Sprintf("上级部门【%s】已删除，不允许新增", deptParent.DeptName)
c.JSON(200, result.ErrMsg(msg))
return
}
body.Ancestors = deptParent.Ancestors + "," + body.ParentID
} else {
body.Ancestors = "0"
}
// 检查同级下名称唯一
uniqueDeptName := s.sysDeptService.CheckUniqueDeptName(body.DeptName, body.ParentID, "")
if !uniqueDeptName {
msg := fmt.Sprintf("部门新增【%s】失败，部门名称已存在", body.DeptName)
c.JSON(200, result.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysDeptService.InsertDept(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 部门修改
//
// PUT /
func (s *SysDeptController) Edit(c *gin.Context) {
var body model.SysDept
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DeptID == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 上级部门不能选自己
if body.DeptID == body.ParentID {
msg := fmt.Sprintf("部门修改【%s】失败，上级部门不能是自己", body.DeptName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查数据是否存在
deptInfo := s.sysDeptService.SelectDeptById(body.DeptID)
if deptInfo.DeptID != body.DeptID {
c.JSON(200, result.ErrMsg("没有权限访问部门数据！"))
return
}
// 父级ID不为0是要检查
if body.ParentID != "0" {
deptParent := s.sysDeptService.SelectDeptById(body.ParentID)
if deptParent.DeptID != body.ParentID {
c.JSON(200, result.ErrMsg("没有权限访问部门数据！"))
return
}
}
// 检查同级下名称唯一
uniqueDeptName := s.sysDeptService.CheckUniqueDeptName(body.DeptName, body.ParentID, body.DeptID)
if !uniqueDeptName {
msg := fmt.Sprintf("部门修改【%s】失败，部门名称已存在", body.DeptName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 上级停用需要检查下级是否有在使用
if body.Status == common.STATUS_NO {
hasChild := s.sysDeptService.HasChildByDeptId(body.DeptID)
if hasChild > 0 {
msg := fmt.Sprintf("该部门包含未停用的子部门数量：%d", hasChild)
c.JSON(200, result.ErrMsg(msg))
return
}
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysDeptService.UpdateDept(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 部门删除
//
// DELETE /:deptId
func (s *SysDeptController) Remove(c *gin.Context) {
deptId := c.Param("deptId")
if deptId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查数据是否存在
dept := s.sysDeptService.SelectDeptById(deptId)
if dept.DeptID != deptId {
c.JSON(200, result.ErrMsg("没有权限访问部门数据！"))
return
}
// 检查是否存在子部门
hasChild := s.sysDeptService.HasChildByDeptId(deptId)
if hasChild > 0 {
msg := fmt.Sprintf("不允许删除，存在子部门数：%d", hasChild)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查是否分配给用户
existUser := s.sysDeptService.CheckDeptExistUser(deptId)
if existUser > 0 {
msg := fmt.Sprintf("不允许删除，部门已分配给用户数：%d", existUser)
c.JSON(200, result.ErrMsg(msg))
return
}
rows := s.sysDeptService.DeleteDeptById(deptId)
if rows > 0 {
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
}
// 部门列表（排除节点）
//
// GET /list/exclude/:deptId
func (s *SysDeptController) ExcludeChild(c *gin.Context) {
deptId := c.Param("deptId")
if deptId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysDeptService.SelectDeptList(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 || hasAncestor) {
filtered = append(filtered, dept)
}
}
c.JSON(200, result.OkData(filtered))
}
// 部门树结构列表
//
// GET /treeSelect
func (s *SysDeptController) TreeSelect(c *gin.Context) {
var querys struct {
// 部门ID
DeptID string `json:"deptId"`
// 父部门ID
ParentID string `json:"parentId" `
// 部门名称
DeptName string `json:"deptName" `
// 部门状态（0正常 1停用）
Status string `json:"status"`
}
err := c.ShouldBindQuery(&querys)
if err != nil {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
SysDeptController := model.SysDept{
DeptID: querys.DeptID,
ParentID: querys.ParentID,
DeptName: querys.DeptName,
Status: querys.Status,
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysDeptService.SelectDeptTreeSelect(SysDeptController, dataScopeSQL)
c.JSON(200, result.OkData(data))
}
// 部门树结构列表（指定角色）
//
// GET /roleDeptTreeSelect/:roleId
func (s *SysDeptController) RoleDeptTreeSelect(c *gin.Context) {
roleId := c.Param("roleId")
if roleId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
deptTreeSelect := s.sysDeptService.SelectDeptTreeSelect(model.SysDept{}, dataScopeSQL)
checkedKeys := s.sysDeptService.SelectDeptListByRoleId(roleId)
c.JSON(200, result.OkData(map[string]any{
"depts": deptTreeSelect,
"checkedKeys": checkedKeys,
}))
}

244
src/modules/system/controller/sys_dict_data.go Normal file
View File

@@ -0,0 +1,244 @@
package controller
import (
"fmt"
"strconv"
"strings"
"time"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysDictDataController 结构体
var NewSysDictData = &SysDictDataController{
sysDictDataService: service.NewSysDictDataImpl,
sysDictTypeService: service.NewSysDictTypeImpl,
}
// 字典类型对应的字典数据信息
//
// PATH /system/dict/data
type SysDictDataController struct {
// 字典数据服务
sysDictDataService service.ISysDictData
// 字典类型服务
sysDictTypeService service.ISysDictType
}
// 字典数据列表
//
// GET /list
func (s *SysDictDataController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
data := s.sysDictDataService.SelectDictDataPage(querys)
c.JSON(200, result.Ok(data))
}
// 字典数据详情
//
// GET /:dictCode
func (s *SysDictDataController) Info(c *gin.Context) {
dictCode := c.Param("dictCode")
if dictCode == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysDictDataService.SelectDictDataByCode(dictCode)
if data.DictCode == dictCode {
c.JSON(200, result.OkData(data))
return
}
c.JSON(200, result.Err(nil))
}
// 字典数据新增
//
// POST /
func (s *SysDictDataController) Add(c *gin.Context) {
var body model.SysDictData
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DictCode != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查字典类型是否存在
sysDictType := s.sysDictTypeService.SelectDictTypeByType(body.DictType)
if sysDictType.DictType != body.DictType {
c.JSON(200, result.ErrMsg("没有权限访问字典类型数据！"))
return
}
// 检查字典标签唯一
uniqueDictLabel := s.sysDictDataService.CheckUniqueDictLabel(body.DictType, body.DictLabel, "")
if !uniqueDictLabel {
msg := fmt.Sprintf("数据新增【%s】失败，该字典类型下标签名已存在", body.DictLabel)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查字典键值唯一
uniqueDictValue := s.sysDictDataService.CheckUniqueDictValue(body.DictType, body.DictValue, "")
if !uniqueDictValue {
msg := fmt.Sprintf("数据新增【%s】失败，该字典类型下标签值已存在", body.DictValue)
c.JSON(200, result.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysDictDataService.InsertDictData(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 字典类型修改
//
// PUT /
func (s *SysDictDataController) Edit(c *gin.Context) {
var body model.SysDictData
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DictCode == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查字典类型是否存在
sysDictType := s.sysDictTypeService.SelectDictTypeByType(body.DictType)
if sysDictType.DictType != body.DictType {
c.JSON(200, result.ErrMsg("没有权限访问字典类型数据！"))
return
}
// 检查字典编码是否存在
SysDictDataController := s.sysDictDataService.SelectDictDataByCode(body.DictCode)
if SysDictDataController.DictCode != body.DictCode {
c.JSON(200, result.ErrMsg("没有权限访问字典编码数据！"))
return
}
// 检查字典标签唯一
uniqueDictLabel := s.sysDictDataService.CheckUniqueDictLabel(body.DictType, body.DictLabel, body.DictCode)
if !uniqueDictLabel {
msg := fmt.Sprintf("数据修改【%s】失败，该字典类型下标签名已存在", body.DictLabel)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查字典键值唯一
uniqueDictValue := s.sysDictDataService.CheckUniqueDictValue(body.DictType, body.DictValue, body.DictCode)
if !uniqueDictValue {
msg := fmt.Sprintf("数据修改【%s】失败，该字典类型下标签值已存在", body.DictValue)
c.JSON(200, result.ErrMsg(msg))
return
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysDictDataService.UpdateDictData(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 字典数据删除
//
// DELETE /:dictCodes
func (s *SysDictDataController) Remove(c *gin.Context) {
dictCodes := c.Param("dictCodes")
if dictCodes == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(dictCodes, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows, err := s.sysDictDataService.DeleteDictDataByCodes(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
}
// 字典数据列表（指定字典类型）
//
// GET /type/:dictType
func (s *SysDictDataController) DictType(c *gin.Context) {
dictType := c.Param("dictType")
if dictType == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysDictDataService.SelectDictDataByType(dictType)
c.JSON(200, result.OkData(data))
}
// 字典数据列表导出
//
// POST /export
func (s *SysDictDataController) Export(c *gin.Context) {
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
data := s.sysDictDataService.SelectDictDataPage(querys)
if data["total"].(int64) == 0 {
c.JSON(200, result.ErrMsg("导出数据记录为空"))
return
}
rows := data["rows"].([]model.SysDictData)
// 导出文件名称
fileName := fmt.Sprintf("dict_data_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
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.Status == "1" {
statusValue = "正常"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.DictCode,
"B" + idx: row.DictSort,
"C" + idx: row.DictLabel,
"D" + idx: row.DictValue,
"E" + idx: row.DictType,
"F" + idx: statusValue,
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

242
src/modules/system/controller/sys_dict_type.go Normal file
View File

@@ -0,0 +1,242 @@
package controller
import (
"fmt"
"strconv"
"strings"
"time"
"ems.agt/src/framework/constants/common"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysDictTypeController 结构体
var NewSysDictType = &SysDictTypeController{
sysDictTypeService: service.NewSysDictTypeImpl,
}
// 字典类型信息
//
// PATH /system/dict/type
type SysDictTypeController struct {
// 字典类型服务
sysDictTypeService service.ISysDictType
}
// 字典类型列表
//
// GET /list
func (s *SysDictTypeController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
data := s.sysDictTypeService.SelectDictTypePage(querys)
c.JSON(200, result.Ok(data))
}
// 字典类型信息
//
// GET /:dictId
func (s *SysDictTypeController) Info(c *gin.Context) {
dictId := c.Param("dictId")
if dictId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysDictTypeService.SelectDictTypeByID(dictId)
if data.DictID == dictId {
c.JSON(200, result.OkData(data))
return
}
c.JSON(200, result.Err(nil))
}
// 字典类型新增
//
// POST /
func (s *SysDictTypeController) Add(c *gin.Context) {
var body model.SysDictType
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DictID != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查字典名称唯一
uniqueDictName := s.sysDictTypeService.CheckUniqueDictName(body.DictName, "")
if !uniqueDictName {
msg := fmt.Sprintf("字典新增【%s】失败，字典名称已存在", body.DictName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查字典类型唯一
uniqueDictType := s.sysDictTypeService.CheckUniqueDictType(body.DictType, "")
if !uniqueDictType {
msg := fmt.Sprintf("字典新增【%s】失败，字典类型已存在", body.DictType)
c.JSON(200, result.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysDictTypeService.InsertDictType(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 字典类型修改
//
// PUT /
func (s *SysDictTypeController) Edit(c *gin.Context) {
var body model.SysDictType
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.DictID == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查数据是否存在
dictInfo := s.sysDictTypeService.SelectDictTypeByID(body.DictID)
if dictInfo.DictID != body.DictID {
c.JSON(200, result.ErrMsg("没有权限访问字典类型数据！"))
return
}
// 检查字典名称唯一
uniqueDictName := s.sysDictTypeService.CheckUniqueDictName(body.DictName, body.DictID)
if !uniqueDictName {
msg := fmt.Sprintf("字典修改【%s】失败，字典名称已存在", body.DictName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查字典类型唯一
uniqueDictType := s.sysDictTypeService.CheckUniqueDictType(body.DictType, body.DictID)
if !uniqueDictType {
msg := fmt.Sprintf("字典修改【%s】失败，字典类型已存在", body.DictType)
c.JSON(200, result.ErrMsg(msg))
return
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysDictTypeService.UpdateDictType(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 字典类型删除
//
// DELETE /:dictIds
func (s *SysDictTypeController) Remove(c *gin.Context) {
dictIds := c.Param("dictIds")
if dictIds == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(dictIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows, err := s.sysDictTypeService.DeleteDictTypeByIDs(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
}
// 字典类型刷新缓存
//
// PUT /refreshCache
func (s *SysDictTypeController) RefreshCache(c *gin.Context) {
s.sysDictTypeService.ResetDictCache()
c.JSON(200, result.Ok(nil))
}
// 字典类型选择框列表
//
// GET /getDictOptionselect
func (s *SysDictTypeController) DictOptionselect(c *gin.Context) {
data := s.sysDictTypeService.SelectDictTypeList(model.SysDictType{
Status: common.STATUS_YES,
})
type labelValue struct {
Label string `json:"label"`
Value string `json:"value"`
}
// 数据组
arr := []labelValue{}
for _, v := range data {
arr = append(arr, labelValue{
Label: v.DictName,
Value: v.DictType,
})
}
c.JSON(200, result.OkData(arr))
}
// 字典类型列表导出
//
// POST /export
func (s *SysDictTypeController) Export(c *gin.Context) {
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
data := s.sysDictTypeService.SelectDictTypePage(querys)
if data["total"].(int64) == 0 {
c.JSON(200, result.ErrMsg("导出数据记录为空"))
return
}
rows := data["rows"].([]model.SysDictType)
// 导出文件名称
fileName := fmt.Sprintf("dict_type_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
headerCells := map[string]string{
"A1": "字典主键",
"B1": "字典名称",
"C1": "字典类型",
"D1": "状态",
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
statusValue := "停用"
if row.Status == "1" {
statusValue = "正常"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.DictID,
"B" + idx: row.DictName,
"C" + idx: row.DictType,
"D" + idx: statusValue,
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

158
src/modules/system/controller/sys_log_login.go Normal file
View File

@@ -0,0 +1,158 @@
package controller
import (
"fmt"
"strconv"
"strings"
"time"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/vo/result"
commonService "ems.agt/src/modules/common/service"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 SysLogLoginController 结构体
var NewSysLogLogin = &SysLogLoginController{
sysLogLoginService: service.NewSysLogLoginImpl,
accountService: commonService.NewAccountImpl,
}
// 系统登录日志信息
//
// PATH /system/log/login
type SysLogLoginController struct {
// 系统登录日志服务
sysLogLoginService service.ISysLogLogin
// 账号身份操作服务
accountService commonService.IAccount
}
// 系统登录日志列表
//
// GET /list
func (s *SysLogLoginController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
data := s.sysLogLoginService.SelectSysLogLoginPage(querys)
c.JSON(200, result.Ok(data))
}
// 系统登录日志删除
//
// DELETE /:infoIds
func (s *SysLogLoginController) Remove(c *gin.Context) {
infoIds := c.Param("infoIds")
if infoIds == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(infoIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows := s.sysLogLoginService.DeleteSysLogLoginByIds(uniqueIDs)
if rows > 0 {
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
}
// 系统登录日志清空
//
// 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))
}
// 系统登录日志账户解锁
//
// PUT /unlock/:userName
func (s *SysLogLoginController) Unlock(c *gin.Context) {
userName := c.Param("userName")
if userName == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
ok := s.accountService.ClearLoginRecordCache(userName)
if ok {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 导出系统登录日志信息
//
// POST /export
func (s *SysLogLoginController) Export(c *gin.Context) {
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
data := s.sysLogLoginService.SelectSysLogLoginPage(querys)
if data["total"].(int64) == 0 {
c.JSON(200, result.ErrMsg("导出数据记录为空"))
return
}
rows := data["rows"].([]model.SysLogLogin)
// 导出文件名称
fileName := fmt.Sprintf("sys_log_login_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
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.Status == "1" {
statusValue = "成功"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.LoginID,
"B" + idx: row.UserName,
"C" + idx: statusValue,
"D" + idx: row.IPAddr,
"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),
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

155
src/modules/system/controller/sys_log_operate.go Normal file
View File

@@ -0,0 +1,155 @@
package controller
import (
"fmt"
"strconv"
"strings"
"time"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
)
// 实例化控制层 SysLogOperateController 结构体
var NewSysLogOperate = &SysLogOperateController{
SysLogOperateService: service.NewSysLogOperateImpl,
}
// 操作日志记录信息
//
// PATH /system/log/operate
type SysLogOperateController struct {
// 操作日志服务
SysLogOperateService service.ISysLogOperate
}
// 操作日志列表
//
// GET /list
func (s *SysLogOperateController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
data := s.SysLogOperateService.SelectSysLogOperatePage(querys)
c.JSON(200, result.Ok(data))
}
// 操作日志删除
//
// DELETE /:operIds
func (s *SysLogOperateController) Remove(c *gin.Context) {
operIds := c.Param("operIds")
if operIds == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
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 := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
}
// 操作日志清空
//
// 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))
}
// 导出操作日志
//
// POST /export
func (s *SysLogOperateController) Export(c *gin.Context) {
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
data := s.SysLogOperateService.SelectSysLogOperatePage(querys)
if data["total"].(int64) == 0 {
c.JSON(200, result.ErrMsg("导出数据记录为空"))
return
}
rows := data["rows"].([]model.SysLogOperate)
// 导出文件名称
fileName := fmt.Sprintf("sys_log_operate_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
headerCells := map[string]string{
"A1": "操作序号",
"B1": "操作模块",
"C1": "业务类型",
"D1": "请求方法",
"E1": "请求方式",
"F1": "操作类别",
"G1": "操作人员",
"H1": "部门名称",
"I1": "请求地址",
"J1": "操作地址",
"K1": "操作地点",
"L1": "请求参数",
"M1": "操作消息",
"N1": "状态",
"O1": "消耗时间（毫秒）",
"P1": "操作时间",
}
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 业务类型
businessType := ""
// 操作类别
OperatorType := ""
// 状态
statusValue := "失败"
if row.Status == "1" {
statusValue = "成功"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.OperID,
"B" + idx: row.Title,
"C" + idx: businessType,
"D" + idx: row.Method,
"E" + idx: row.RequestMethod,
"F" + idx: OperatorType,
"G" + idx: row.OperName,
"H" + idx: row.DeptName,
"I" + idx: row.OperURL,
"J" + idx: row.OperIP,
"K" + idx: row.OperLocation,
"L" + idx: row.OperParam,
"M" + idx: row.OperMsg,
"N" + idx: statusValue,
"O" + idx: row.CostTime,
"P" + idx: date.ParseDateToStr(row.OperTime, date.YYYY_MM_DD_HH_MM_SS),
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

287
src/modules/system/controller/sys_menu.go Normal file
View File

@@ -0,0 +1,287 @@
package controller
import (
"fmt"
"ems.agt/src/framework/config"
"ems.agt/src/framework/constants/common"
"ems.agt/src/framework/constants/menu"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/regular"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysMenuController 结构体
var NewSysMenu = &SysMenuController{
sysMenuService: service.NewSysMenuImpl,
}
// 菜单信息
//
// PATH /system/menu
type SysMenuController struct {
// 菜单服务
sysMenuService service.ISysMenu
}
// 菜单列表
//
// GET /list
func (s *SysMenuController) List(c *gin.Context) {
query := model.SysMenu{}
if v, ok := c.GetQuery("menuName"); ok {
query.MenuName = v
}
if v, ok := c.GetQuery("status"); ok {
query.Status = v
}
userId := ctx.LoginUserToUserID(c)
if config.IsAdmin(userId) {
userId = "*"
}
data := s.sysMenuService.SelectMenuList(query, userId)
c.JSON(200, result.OkData(data))
}
// 菜单信息
//
// GET /:menuId
func (s *SysMenuController) Info(c *gin.Context) {
menuId := c.Param("menuId")
if menuId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysMenuService.SelectMenuById(menuId)
if data.MenuID == menuId {
c.JSON(200, result.OkData(data))
return
}
c.JSON(200, result.Err(nil))
}
// 菜单新增
//
// POST /
func (s *SysMenuController) Add(c *gin.Context) {
var body model.SysMenu
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.MenuID != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 目录和菜单检查地址唯一
if menu.TYPE_DIR == body.MenuType || menu.TYPE_MENU == body.MenuType {
uniqueNenuPath := s.sysMenuService.CheckUniqueMenuPath(body.Path, "")
if !uniqueNenuPath {
msg := fmt.Sprintf("菜单新增【%s】失败，菜单路由地址已存在", body.MenuName)
c.JSON(200, result.ErrMsg(msg))
return
}
}
// 检查名称唯一
uniqueNenuName := s.sysMenuService.CheckUniqueMenuName(body.MenuName, body.ParentID, "")
if !uniqueNenuName {
msg := fmt.Sprintf("菜单新增【%s】失败，菜单名称已存在", body.MenuName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 外链菜单需要符合网站http(s)开头
if body.IsFrame == common.STATUS_NO && !regular.ValidHttp(body.Path) {
msg := fmt.Sprintf("菜单新增【%s】失败，非内部地址必须以http(s)://开头", body.MenuName)
c.JSON(200, result.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysMenuService.InsertMenu(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 菜单修改
//
// PUT /
func (s *SysMenuController) Edit(c *gin.Context) {
var body model.SysMenu
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.MenuID == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 上级菜单不能选自己
if body.MenuID == body.ParentID {
msg := fmt.Sprintf("菜单修改【%s】失败，上级菜单不能选择自己", body.MenuName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查数据是否存在
menuInfo := s.sysMenuService.SelectMenuById(body.MenuID)
if menuInfo.MenuID != body.MenuID {
c.JSON(200, result.ErrMsg("没有权限访问菜单数据"))
return
}
// 父级ID不为0是要检查
if body.ParentID != "0" {
menuParent := s.sysMenuService.SelectMenuById(body.ParentID)
if menuParent.MenuID != body.ParentID {
c.JSON(200, result.ErrMsg("没有权限访问菜单数据"))
return
}
// 禁用菜单时检查父菜单是否使用
if body.Status == common.STATUS_YES && menuParent.Status == common.STATUS_NO {
c.JSON(200, result.ErrMsg("上级菜单未启用！"))
return
}
}
// 目录和菜单检查地址唯一
if menu.TYPE_DIR == body.MenuType || menu.TYPE_MENU == body.MenuType {
uniqueNenuPath := s.sysMenuService.CheckUniqueMenuPath(body.Path, body.MenuID)
if !uniqueNenuPath {
msg := fmt.Sprintf("菜单修改【%s】失败，菜单路由地址已存在", body.MenuName)
c.JSON(200, result.ErrMsg(msg))
return
}
}
// 检查名称唯一
uniqueNenuName := s.sysMenuService.CheckUniqueMenuName(body.MenuName, body.ParentID, body.MenuID)
if !uniqueNenuName {
msg := fmt.Sprintf("菜单修改【%s】失败，菜单名称已存在", body.MenuName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 外链菜单需要符合网站http(s)开头
if body.IsFrame == common.STATUS_NO && !regular.ValidHttp(body.Path) {
msg := fmt.Sprintf("菜单修改【%s】失败，非内部地址必须以http(s)://开头", body.MenuName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 禁用菜单时检查子菜单是否使用
if body.Status == common.STATUS_NO {
hasStatus := s.sysMenuService.HasChildByMenuIdAndStatus(body.MenuID, common.STATUS_YES)
if hasStatus > 0 {
msg := fmt.Sprintf("不允许禁用，存在使用子菜单数：%d", hasStatus)
c.JSON(200, result.ErrMsg(msg))
return
}
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysMenuService.UpdateMenu(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 菜单删除
//
// DELETE /:menuId
func (s *SysMenuController) Remove(c *gin.Context) {
menuId := c.Param("menuId")
if menuId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查数据是否存在
menu := s.sysMenuService.SelectMenuById(menuId)
if menu.MenuID != menuId {
c.JSON(200, result.ErrMsg("没有权限访问菜单数据！"))
return
}
// 检查是否存在子菜单
hasChild := s.sysMenuService.HasChildByMenuIdAndStatus(menuId, "")
if hasChild > 0 {
msg := fmt.Sprintf("不允许删除，存在子菜单数：%d", hasChild)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查是否分配给角色
existRole := s.sysMenuService.CheckMenuExistRole(menuId)
if existRole > 0 {
msg := fmt.Sprintf("不允许删除，菜单已分配给角色数：%d", existRole)
c.JSON(200, result.ErrMsg(msg))
return
}
rows := s.sysMenuService.DeleteMenuById(menuId)
if rows > 0 {
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
return
}
c.JSON(200, result.Err(nil))
}
// 菜单树结构列表
//
// GET /treeSelect
func (s *SysMenuController) TreeSelect(c *gin.Context) {
query := model.SysMenu{}
if v, ok := c.GetQuery("menuName"); ok {
query.MenuName = v
}
if v, ok := c.GetQuery("status"); ok {
query.Status = v
}
userId := ctx.LoginUserToUserID(c)
if config.IsAdmin(userId) {
userId = "*"
}
data := s.sysMenuService.SelectMenuTreeSelectByUserId(query, userId)
c.JSON(200, result.OkData(data))
}
// 菜单树结构列表（指定角色）
//
// GET /roleMenuTreeSelect/:roleId
func (s *SysMenuController) RoleMenuTreeSelect(c *gin.Context) {
roleId := c.Param("roleId")
if roleId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
query := model.SysMenu{}
if v, ok := c.GetQuery("menuName"); ok {
query.MenuName = v
}
if v, ok := c.GetQuery("status"); ok {
query.Status = v
}
userId := ctx.LoginUserToUserID(c)
if config.IsAdmin(userId) {
userId = "*"
}
menuTreeSelect := s.sysMenuService.SelectMenuTreeSelectByUserId(query, userId)
checkedKeys := s.sysMenuService.SelectMenuListByRoleId(roleId)
c.JSON(200, result.OkData(map[string]any{
"menus": menuTreeSelect,
"checkedKeys": checkedKeys,
}))
}

126
src/modules/system/controller/sys_notice.go Normal file
View File

@@ -0,0 +1,126 @@
package controller
import (
"fmt"
"strings"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysNoticeController 结构体
var NewSysNotice = &SysNoticeController{
sysNoticeService: service.NewSysNoticeImpl,
}
// 通知公告信息
//
// PATH /system/notice
type SysNoticeController struct {
// 公告服务
sysNoticeService service.ISysNotice
}
// 通知公告列表
//
// GET /list
func (s *SysNoticeController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
data := s.sysNoticeService.SelectNoticePage(querys)
c.JSON(200, result.Ok(data))
}
// 通知公告信息
//
// GET /:noticeId
func (s *SysNoticeController) Info(c *gin.Context) {
noticeId := c.Param("noticeId")
if noticeId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysNoticeService.SelectNoticeById(noticeId)
if data.NoticeID == noticeId {
c.JSON(200, result.OkData(data))
return
}
c.JSON(200, result.Err(nil))
}
// 通知公告新增
//
// POST /
func (s *SysNoticeController) Add(c *gin.Context) {
var body model.SysNotice
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.NoticeID != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysNoticeService.InsertNotice(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 通知公告修改
//
// PUT /
func (s *SysNoticeController) Edit(c *gin.Context) {
var body model.SysNotice
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.NoticeID == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否存在
notice := s.sysNoticeService.SelectNoticeById(body.NoticeID)
if notice.NoticeID != body.NoticeID {
c.JSON(200, result.ErrMsg("没有权限访问公告信息数据！"))
return
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysNoticeService.UpdateNotice(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 通知公告删除
//
// DELETE /:noticeIds
func (s *SysNoticeController) Remove(c *gin.Context) {
noticeIds := c.Param("noticeIds")
if noticeIds == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(noticeIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows, err := s.sysNoticeService.DeleteNoticeByIds(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
}

211
src/modules/system/controller/sys_post.go Normal file
View File

@@ -0,0 +1,211 @@
package controller
import (
"fmt"
"strconv"
"strings"
"time"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysPostController 结构体
var NewSysPost = &SysPostController{
sysPostService: service.NewSysPostImpl,
}
// 岗位信息
//
// PATH /system/post
type SysPostController struct {
// 岗位服务
sysPostService service.ISysPost
}
// 岗位列表
//
// GET /list
func (s *SysPostController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
data := s.sysPostService.SelectPostPage(querys)
c.JSON(200, result.Ok(data))
}
// 岗位信息
//
// GET /:postId
func (s *SysPostController) Info(c *gin.Context) {
postId := c.Param("postId")
if postId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysPostService.SelectPostById(postId)
if data.PostID == postId {
c.JSON(200, result.OkData(data))
return
}
c.JSON(200, result.Err(nil))
}
// 岗位新增
//
// POST /
func (s *SysPostController) Add(c *gin.Context) {
var body model.SysPost
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.PostID != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查名称唯一
uniqueuPostName := s.sysPostService.CheckUniquePostName(body.PostName, "")
if !uniqueuPostName {
msg := fmt.Sprintf("岗位新增【%s】失败，岗位名称已存在", body.PostName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查编码属性值唯一
uniquePostCode := s.sysPostService.CheckUniquePostCode(body.PostCode, "")
if !uniquePostCode {
msg := fmt.Sprintf("岗位新增【%s】失败，岗位编码已存在", body.PostCode)
c.JSON(200, result.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysPostService.InsertPost(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 岗位修改
//
// PUT /
func (s *SysPostController) Edit(c *gin.Context) {
var body model.SysPost
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.PostID == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否存在
post := s.sysPostService.SelectPostById(body.PostID)
if post.PostID != body.PostID {
c.JSON(200, result.ErrMsg("没有权限访问岗位数据！"))
return
}
// 检查名称唯一
uniqueuPostName := s.sysPostService.CheckUniquePostName(body.PostName, body.PostID)
if !uniqueuPostName {
msg := fmt.Sprintf("岗位修改【%s】失败，岗位名称已存在", body.PostName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查编码属性值唯一
uniquePostCode := s.sysPostService.CheckUniquePostCode(body.PostCode, body.PostID)
if !uniquePostCode {
msg := fmt.Sprintf("岗位修改【%s】失败，岗位编码已存在", body.PostCode)
c.JSON(200, result.ErrMsg(msg))
return
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysPostService.UpdatePost(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 岗位删除
//
// DELETE /:postIds
func (s *SysPostController) Remove(c *gin.Context) {
postIds := c.Param("postIds")
if postIds == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(postIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows, err := s.sysPostService.DeletePostByIds(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
}
// 导出岗位信息
//
// POST /export
func (s *SysPostController) Export(c *gin.Context) {
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
data := s.sysPostService.SelectPostPage(querys)
if data["total"].(int64) == 0 {
c.JSON(200, result.ErrMsg("导出数据记录为空"))
return
}
rows := data["rows"].([]model.SysPost)
// 导出文件名称
fileName := fmt.Sprintf("post_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
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.Status == "1" {
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,
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

282
src/modules/system/controller/sys_profile.go Normal file
View File

@@ -0,0 +1,282 @@
package controller
import (
"fmt"
"ems.agt/src/framework/config"
"ems.agt/src/framework/constants/admin"
"ems.agt/src/framework/constants/uploadsubpath"
"ems.agt/src/framework/utils/crypto"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/regular"
"ems.agt/src/framework/utils/token"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/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,
}
// 个人信息
//
// PATH /system/user/profile
type SysProfileController struct {
// 用户服务
sysUserService service.ISysUser
// 角色服务
sysRoleService service.ISysRole
// 岗位服务
sysPostService service.ISysPost
// 菜单服务
sysMenuService service.ISysMenu
}
// 个人信息
//
// GET /
func (s *SysProfileController) Info(c *gin.Context) {
loginUser, err := ctx.LoginUser(c)
if err != nil {
c.JSON(401, result.CodeMsg(401, err.Error()))
return
}
// 查询用户所属角色组
roleGroup := []string{}
roles := s.sysRoleService.SelectRoleListByUserId(loginUser.UserID)
for _, role := range roles {
roleGroup = append(roleGroup, role.RoleName)
}
isAdmin := config.IsAdmin(loginUser.UserID)
if isAdmin {
roleGroup = append(roleGroup, "管理员")
}
// 查询用户所属岗位组
postGroup := []string{}
posts := s.sysPostService.SelectPostListByUserId(loginUser.UserID)
for _, post := range posts {
postGroup = append(postGroup, post.PostName)
}
c.JSON(200, result.OkData(map[string]any{
"user": loginUser.User,
"roleGroup": parse.RemoveDuplicates(roleGroup),
"postGroup": parse.RemoveDuplicates(postGroup),
}))
}
// 个人信息修改
//
// PUT /
func (s *SysProfileController) UpdateProfile(c *gin.Context) {
var body struct {
// 昵称
NickName string `json:"nickName" binding:"required"`
// 性别
Sex string `json:"sex" binding:"required"`
// 手机号
PhoneNumber string `json:"phonenumber"`
// 邮箱
Email string `json:"email"`
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.Sex == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 登录用户信息
loginUser, err := ctx.LoginUser(c)
if err != nil {
c.JSON(401, result.CodeMsg(401, err.Error()))
return
}
userId := loginUser.UserID
userName := loginUser.User.UserName
// 检查手机号码格式并判断是否唯一
if body.PhoneNumber != "" {
if regular.ValidMobile(body.PhoneNumber) {
uniquePhone := s.sysUserService.CheckUniquePhone(body.PhoneNumber, userId)
if !uniquePhone {
msg := fmt.Sprintf("修改用户【%s】失败，手机号码已存在", userName)
c.JSON(200, result.ErrMsg(msg))
return
}
} else {
msg := fmt.Sprintf("修改用户【%s】失败，手机号码格式错误", userName)
c.JSON(200, result.ErrMsg(msg))
return
}
} else {
body.PhoneNumber = "nil"
}
// 检查邮箱格式并判断是否唯一
if body.Email != "" {
if regular.ValidEmail(body.Email) {
uniqueEmail := s.sysUserService.CheckUniqueEmail(body.Email, userId)
if !uniqueEmail {
msg := fmt.Sprintf("修改用户【%s】失败，邮箱已存在", userName)
c.JSON(200, result.ErrMsg(msg))
return
}
} else {
msg := fmt.Sprintf("修改用户【%s】失败，邮箱格式错误", userName)
c.JSON(200, result.ErrMsg(msg))
return
}
} else {
body.Email = "nil"
}
// 用户基本资料
sysUser := model.SysUser{
UserID: userId,
UpdateBy: userName,
NickName: body.NickName,
PhoneNumber: body.PhoneNumber,
Email: body.Email,
Sex: body.Sex,
}
rows := s.sysUserService.UpdateUser(sysUser)
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)
}
// 刷新令牌信息
token.Cache(&loginUser)
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.ErrMsg("上传图片异常"))
}
// 个人重置密码
//
// PUT /updatePwd
func (s *SysProfileController) UpdatePwd(c *gin.Context) {
var body struct {
// 旧密码
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, "参数错误"))
return
}
// 登录用户信息
loginUser, err := ctx.LoginUser(c)
if err != nil {
c.JSON(401, result.CodeMsg(401, err.Error()))
return
}
userId := loginUser.UserID
userName := loginUser.User.UserName
// 查询当前登录用户信息得到密码值
user := s.sysUserService.SelectUserById(userId)
if user.UserID != userId {
c.JSON(200, result.ErrMsg("没有权限访问用户数据！"))
return
}
// 检查匹配用户密码
oldCompare := crypto.BcryptCompare(body.OldPassword, user.Password)
if !oldCompare {
c.JSON(200, result.ErrMsg("修改密码失败，旧密码错误"))
return
}
newCompare := crypto.BcryptCompare(body.NewPassword, user.Password)
if newCompare {
c.JSON(200, result.ErrMsg("新密码不能与旧密码相同"))
return
}
// 修改新密码
sysUser := model.SysUser{
UserID: userId,
UpdateBy: userName,
Password: body.NewPassword,
}
rows := s.sysUserService.UpdateUser(sysUser)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 个人头像上传
//
// POST /avatar
func (s *SysProfileController) Avatar(c *gin.Context) {
formFile, err := c.FormFile("file")
if err != nil {
c.JSON(400, result.CodeMsg(400, "参数错误"))
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, err.Error()))
return
}
// 更新头像地址
sysUser := model.SysUser{
UserID: loginUser.UserID,
UpdateBy: loginUser.User.UserName,
Avatar: filePath,
}
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))
}

408
src/modules/system/controller/sys_role.go Normal file
View File

@@ -0,0 +1,408 @@
package controller
import (
"fmt"
"strconv"
"strings"
"time"
"ems.agt/src/framework/constants/admin"
"ems.agt/src/framework/constants/roledatascope"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/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,
}
// 角色信息
//
// PATH /system/role
type SysRoleController struct {
// 角色服务
sysRoleService service.ISysRole
// 用户服务
sysUserService service.ISysUser
}
// 角色列表
//
// GET /list
func (s *SysRoleController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysRoleService.SelectRolePage(querys, dataScopeSQL)
c.JSON(200, result.Ok(data))
}
// 角色信息详情
//
// GET /:roleId
func (s *SysRoleController) Info(c *gin.Context) {
roleId := c.Param("roleId")
if roleId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
data := s.sysRoleService.SelectRoleById(roleId)
if data.RoleID == roleId {
c.JSON(200, result.OkData(data))
return
}
c.JSON(200, result.Err(nil))
}
// 角色信息新增
//
// POST /
func (s *SysRoleController) Add(c *gin.Context) {
var body model.SysRole
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.RoleID != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 判断角色名称是否唯一
uniqueRoleName := s.sysRoleService.CheckUniqueRoleName(body.RoleName, "")
if !uniqueRoleName {
msg := fmt.Sprintf("角色新增【%s】失败，角色名称已存在", body.RoleName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 判断角色键值是否唯一
uniqueRoleKey := s.sysRoleService.CheckUniqueRoleKey(body.RoleKey, "")
if !uniqueRoleKey {
msg := fmt.Sprintf("角色新增【%s】失败，角色键值已存在", body.RoleName)
c.JSON(200, result.ErrMsg(msg))
return
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysRoleService.InsertRole(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 角色信息修改
//
// PUT /
func (s *SysRoleController) Edit(c *gin.Context) {
var body model.SysRole
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.RoleID == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否管理员角色
if body.RoleID == admin.ROLE_ID {
c.JSON(200, result.ErrMsg("不允许操作管理员角色"))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(body.RoleID)
if role.RoleID != body.RoleID {
c.JSON(200, result.ErrMsg("没有权限访问角色数据！"))
return
}
// 判断角色名称是否唯一
uniqueRoleName := s.sysRoleService.CheckUniqueRoleName(body.RoleName, body.RoleID)
if !uniqueRoleName {
msg := fmt.Sprintf("角色修改【%s】失败，角色名称已存在", body.RoleName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 判断角色键值是否唯一
uniqueRoleKey := s.sysRoleService.CheckUniqueRoleKey(body.RoleKey, body.RoleID)
if !uniqueRoleKey {
msg := fmt.Sprintf("角色修改【%s】失败，角色键值已存在", body.RoleName)
c.JSON(200, result.ErrMsg(msg))
return
}
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysRoleService.UpdateRole(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 角色信息删除
//
// DELETE /:roleIds
func (s *SysRoleController) Remove(c *gin.Context) {
roleIds := c.Param("roleIds")
if roleIds == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(roleIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
// 检查是否管理员角色
for _, id := range uniqueIDs {
if id == admin.ROLE_ID {
c.JSON(200, result.ErrMsg("不允许操作管理员角色"))
return
}
}
rows, err := s.sysRoleService.DeleteRoleByIds(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
}
// 角色状态变更
//
// PUT /changeStatus
func (s *SysRoleController) Status(c *gin.Context) {
var body struct {
// 角色ID
RoleID string `json:"roleId" binding:"required"`
// 状态
Status string `json:"status" binding:"required"`
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否管理员角色
if body.RoleID == admin.ROLE_ID {
c.JSON(200, result.ErrMsg("不允许操作管理员角色"))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(body.RoleID)
if role.RoleID != body.RoleID {
c.JSON(200, result.ErrMsg("没有权限访问角色数据！"))
return
}
// 与旧值相等不变更
if role.Status == body.Status {
c.JSON(200, result.ErrMsg("变更状态与旧值相等！"))
return
}
// 更新状态不刷新缓存
userName := ctx.LoginUserToUserName(c)
SysRoleController := model.SysRole{
RoleID: body.RoleID,
Status: body.Status,
UpdateBy: userName,
}
rows := s.sysRoleService.UpdateRole(SysRoleController)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 角色数据权限修改
//
// PUT /dataScope
func (s *SysRoleController) DataScope(c *gin.Context) {
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"`
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否管理员角色
if body.RoleID == admin.ROLE_ID {
c.JSON(200, result.ErrMsg("不允许操作管理员角色"))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(body.RoleID)
if role.RoleID != body.RoleID {
c.JSON(200, result.ErrMsg("没有权限访问角色数据！"))
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)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 角色分配用户列表
//
// GET /authUser/allocatedList
func (s *SysRoleController) AuthUserAllocatedList(c *gin.Context) {
querys := ctx.QueryMap(c)
roleId, ok := querys["roleId"]
if !ok || roleId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(roleId.(string))
if role.RoleID != roleId {
c.JSON(200, result.ErrMsg("没有权限访问角色数据！"))
return
}
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "u")
data := s.sysUserService.SelectAllocatedPage(querys, dataScopeSQL)
c.JSON(200, result.Ok(data))
}
// 角色分配选择授权
//
// PUT /authUser/checked
func (s *SysRoleController) AuthUserChecked(c *gin.Context) {
var body struct {
// 角色ID
RoleID string `json:"roleId" binding:"required"`
// 用户ID组
UserIDs string `json:"userIds" binding:"required"`
// 选择操作 添加true 取消false
Checked bool `json:"checked"`
}
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(body.UserIDs, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
// 检查是否存在
role := s.sysRoleService.SelectRoleById(body.RoleID)
if role.RoleID != body.RoleID {
c.JSON(200, result.ErrMsg("没有权限访问角色数据！"))
return
}
var rows int64
if body.Checked {
rows = s.sysRoleService.InsertAuthUsers(body.RoleID, uniqueIDs)
} else {
rows = s.sysRoleService.DeleteAuthUsers(body.RoleID, uniqueIDs)
}
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 导出角色信息
//
// POST /export
func (s *SysRoleController) Export(c *gin.Context) {
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
data := s.sysRoleService.SelectRolePage(querys, dataScopeSQL)
if data["total"].(int64) == 0 {
c.JSON(200, result.ErrMsg("导出数据记录为空"))
return
}
rows := data["rows"].([]model.SysRole)
// 导出文件名称
fileName := fmt.Sprintf("role_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
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)
// 数据范围
dataScope := "空"
if v, ok := roledatascope.RoleDataScope[row.DataScope]; ok {
dataScope = v
}
// 角色状态
statusValue := "停用"
if row.Status == "1" {
statusValue = "正常"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.RoleID,
"B" + idx: row.RoleName,
"C" + idx: row.RoleKey,
"D" + idx: row.RoleSort,
"E" + idx: dataScope,
"F" + idx: statusValue,
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}

481
src/modules/system/controller/sys_user.go Normal file
View File

@@ -0,0 +1,481 @@
package controller
import (
"fmt"
"strconv"
"strings"
"time"
"ems.agt/src/framework/config"
"ems.agt/src/framework/constants/admin"
"ems.agt/src/framework/utils/ctx"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/file"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/regular"
"ems.agt/src/framework/vo/result"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
"github.com/gin-gonic/gin/binding"
)
// 实例化控制层 SysUserController 结构体
var NewSysUser = &SysUserController{
sysUserService: service.NewSysUserImpl,
sysRoleService: service.NewSysRoleImpl,
sysPostService: service.NewSysPostImpl,
sysDictDataService: service.NewSysDictDataImpl,
}
// 用户信息
//
// PATH /system/user
type SysUserController struct {
// 用户服务
sysUserService service.ISysUser
// 角色服务
sysRoleService service.ISysRole
// 岗位服务
sysPostService service.ISysPost
// 字典数据服务
sysDictDataService service.ISysDictData
}
// 用户信息列表
//
// GET /list
func (s *SysUserController) List(c *gin.Context) {
querys := ctx.QueryMap(c)
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "u")
data := s.sysUserService.SelectUserPage(querys, dataScopeSQL)
c.JSON(200, result.Ok(data))
}
// 用户信息详情
//
// GET /:userId
func (s *SysUserController) Info(c *gin.Context) {
userId := c.Param("userId")
if userId == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 查询系统角色列表
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "")
roles := s.sysRoleService.SelectRoleList(model.SysRole{}, dataScopeSQL)
// 不是系统指定管理员需要排除其角色
if !config.IsAdmin(userId) {
rolesFilter := make([]model.SysRole, 0)
for _, r := range roles {
if r.RoleID != admin.ROLE_ID {
rolesFilter = append(rolesFilter, r)
}
}
roles = rolesFilter
}
// 查询系统岗位列表
posts := s.sysPostService.SelectPostList(model.SysPost{})
// 新增用户时，用户ID为0
if userId == "0" {
c.JSON(200, result.OkData(map[string]any{
"user": map[string]any{},
"roleIds": []string{},
"postIds": []string{},
"roles": roles,
"posts": posts,
}))
return
}
// 检查用户是否存在
user := s.sysUserService.SelectUserById(userId)
if user.UserID != userId {
c.JSON(200, result.ErrMsg("没有权限访问用户数据！"))
return
}
// 角色ID组
roleIds := make([]string, 0)
for _, r := range user.Roles {
roleIds = append(roleIds, r.RoleID)
}
// 岗位ID组
postIds := make([]string, 0)
userPosts := s.sysPostService.SelectPostListByUserId(userId)
for _, p := range userPosts {
postIds = append(postIds, p.PostID)
}
c.JSON(200, result.OkData(map[string]any{
"user": user,
"roleIds": roleIds,
"postIds": postIds,
"roles": roles,
"posts": posts,
}))
}
// 用户信息新增
//
// POST /
func (s *SysUserController) Add(c *gin.Context) {
var body model.SysUser
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.UserID != "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查用户登录账号是否唯一
uniqueUserName := s.sysUserService.CheckUniqueUserName(body.UserName, "")
if !uniqueUserName {
msg := fmt.Sprintf("新增用户【%s】失败，登录账号已存在", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查手机号码格式并判断是否唯一
if body.PhoneNumber != "" {
if regular.ValidMobile(body.PhoneNumber) {
uniquePhone := s.sysUserService.CheckUniquePhone(body.PhoneNumber, "")
if !uniquePhone {
msg := fmt.Sprintf("新增用户【%s】失败，手机号码已存在", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
} else {
msg := fmt.Sprintf("新增用户【%s】失败，手机号码格式错误", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
}
// 检查邮箱格式并判断是否唯一
if body.Email != "" {
if regular.ValidEmail(body.Email) {
uniqueEmail := s.sysUserService.CheckUniqueEmail(body.Email, "")
if !uniqueEmail {
msg := fmt.Sprintf("新增用户【%s】失败，邮箱已存在", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
} else {
msg := fmt.Sprintf("新增用户【%s】失败，邮箱格式错误", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
}
body.CreateBy = ctx.LoginUserToUserName(c)
insertId := s.sysUserService.InsertUser(body)
if insertId != "" {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 用户信息修改
//
// POST /
func (s *SysUserController) Edit(c *gin.Context) {
var body model.SysUser
err := c.ShouldBindBodyWith(&body, binding.JSON)
if err != nil || body.UserID == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否管理员用户
if config.IsAdmin(body.UserID) {
c.JSON(200, result.ErrMsg("不允许操作管理员用户"))
return
}
user := s.sysUserService.SelectUserById(body.UserID)
if user.UserID != body.UserID {
c.JSON(200, result.ErrMsg("没有权限访问用户数据！"))
return
}
// 检查用户登录账号是否唯一
uniqueUserName := s.sysUserService.CheckUniqueUserName(body.UserName, body.UserID)
if !uniqueUserName {
msg := fmt.Sprintf("修改用户【%s】失败，登录账号已存在", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
// 检查手机号码格式并判断是否唯一
if body.PhoneNumber != "" {
if regular.ValidMobile(body.PhoneNumber) {
uniquePhone := s.sysUserService.CheckUniquePhone(body.PhoneNumber, body.UserID)
if !uniquePhone {
msg := fmt.Sprintf("修改用户【%s】失败，手机号码已存在", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
} else {
msg := fmt.Sprintf("修改用户【%s】失败，手机号码格式错误", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
}
// 检查邮箱格式并判断是否唯一
if body.Email != "" {
if regular.ValidEmail(body.Email) {
uniqueEmail := s.sysUserService.CheckUniqueEmail(body.Email, body.UserID)
if !uniqueEmail {
msg := fmt.Sprintf("修改用户【%s】失败，邮箱已存在", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
} else {
msg := fmt.Sprintf("修改用户【%s】失败，邮箱格式错误", body.UserName)
c.JSON(200, result.ErrMsg(msg))
return
}
}
body.UserName = "" // 忽略修改登录用户名称
body.Password = "" // 忽略修改密码
body.UpdateBy = ctx.LoginUserToUserName(c)
rows := s.sysUserService.UpdateUserAndRolePost(body)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 用户信息删除
//
// DELETE /:userIds
func (s *SysUserController) Remove(c *gin.Context) {
userIds := c.Param("userIds")
if userIds == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 处理字符转id数组后去重
ids := strings.Split(userIds, ",")
uniqueIDs := parse.RemoveDuplicates(ids)
if len(uniqueIDs) <= 0 {
c.JSON(200, result.Err(nil))
return
}
rows, err := s.sysUserService.DeleteUserByIds(uniqueIDs)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
msg := fmt.Sprintf("删除成功：%d", rows)
c.JSON(200, result.OkMsg(msg))
}
// 用户重置密码
//
// PUT /resetPwd
func (s *SysUserController) ResetPwd(c *gin.Context) {
var body struct {
UserID string `json:"userId" binding:"required"`
Password string `json:"password" binding:"required"`
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否管理员用户
if config.IsAdmin(body.UserID) {
c.JSON(200, result.ErrMsg("不允许操作管理员用户"))
return
}
user := s.sysUserService.SelectUserById(body.UserID)
if user.UserID != body.UserID {
c.JSON(200, result.ErrMsg("没有权限访问用户数据！"))
return
}
if !regular.ValidPassword(body.Password) {
c.JSON(200, result.ErrMsg("登录密码至少包含大小写字母、数字、特殊符号，且不少于6位"))
return
}
userName := ctx.LoginUserToUserName(c)
SysUserController := model.SysUser{
UserID: body.UserID,
Password: body.Password,
UpdateBy: userName,
}
rows := s.sysUserService.UpdateUser(SysUserController)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 用户状态修改
//
// PUT /changeStatus
func (s *SysUserController) Status(c *gin.Context) {
var body struct {
UserID string `json:"userId" binding:"required"`
Status string `json:"status" binding:"required"`
}
if err := c.ShouldBindBodyWith(&body, binding.JSON); err != nil {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 检查是否存在
user := s.sysUserService.SelectUserById(body.UserID)
if user.UserID != body.UserID {
c.JSON(200, result.ErrMsg("没有权限访问用户数据！"))
return
}
// 与旧值相等不变更
if user.Status == body.Status {
c.JSON(200, result.ErrMsg("变更状态与旧值相等！"))
return
}
userName := ctx.LoginUserToUserName(c)
SysUserController := model.SysUser{
UserID: body.UserID,
Status: body.Status,
UpdateBy: userName,
}
rows := s.sysUserService.UpdateUser(SysUserController)
if rows > 0 {
c.JSON(200, result.Ok(nil))
return
}
c.JSON(200, result.Err(nil))
}
// 用户信息列表导出
//
// POST /export
func (s *SysUserController) Export(c *gin.Context) {
// 查询结果，根据查询条件结果，单页最大值限制
querys := ctx.BodyJSONMap(c)
dataScopeSQL := ctx.LoginUserToDataScopeSQL(c, "d", "u")
data := s.sysUserService.SelectUserPage(querys, dataScopeSQL)
if data["total"].(int64) == 0 {
c.JSON(200, result.ErrMsg("导出数据记录为空"))
return
}
rows := data["rows"].([]model.SysUser)
// 导出文件名称
fileName := fmt.Sprintf("user_export_%d_%d.xlsx", len(rows), time.Now().UnixMilli())
// 第一行表头标题
headerCells := map[string]string{
"A1": "用户序号",
"B1": "登录名称",
"C1": "用户名称",
"D1": "用户邮箱",
"E1": "手机号码",
"F1": "用户性别",
"G1": "帐号状态",
"H1": "最后登录IP",
"I1": "最后登录时间",
"J1": "部门名称",
"K1": "部门负责人",
}
// 读取用户性别字典数据
dictSysUserSex := s.sysDictDataService.SelectDictDataByType("sys_user_sex")
// 从第二行开始的数据
dataCells := make([]map[string]any, 0)
for i, row := range rows {
idx := strconv.Itoa(i + 2)
// 用户性别
sysUserSex := "未知"
for _, v := range dictSysUserSex {
if row.Sex == v.DictValue {
sysUserSex = v.DictLabel
break
}
}
// 帐号状态
statusValue := "停用"
if row.Status == "1" {
statusValue = "正常"
}
dataCells = append(dataCells, map[string]any{
"A" + idx: row.UserID,
"B" + idx: row.UserName,
"C" + idx: row.NickName,
"D" + idx: row.Email,
"E" + idx: row.PhoneNumber,
"F" + idx: sysUserSex,
"G" + idx: statusValue,
"H" + idx: row.LoginIP,
"I" + idx: date.ParseDateToStr(row.LoginDate, date.YYYY_MM_DD_HH_MM_SS),
"J" + idx: row.Dept.DeptName,
"K" + idx: row.Dept.Leader,
})
}
// 导出数据表格
saveFilePath, err := file.WriteSheet(headerCells, dataCells, fileName, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
c.FileAttachment(saveFilePath, fileName)
}
// 用户信息列表导入模板下载
//
// GET /importTemplate
func (s *SysUserController) Template(c *gin.Context) {
fileName := fmt.Sprintf("user_import_template_%d.xlsx", time.Now().UnixMilli())
asserPath := "assets/template/excel/user_import_template.xlsx"
c.FileAttachment(asserPath, fileName)
}
// 用户信息列表导入
//
// POST /importData
func (s *SysUserController) ImportData(c *gin.Context) {
// 允许进行更新
updateSupport := c.PostForm("updateSupport")
// 上传的文件
formFile, err := c.FormFile("file")
if err != nil || updateSupport == "" {
c.JSON(400, result.CodeMsg(400, "参数错误"))
return
}
// 保存表格文件
filePath, err := file.TransferExeclUploadFile(formFile)
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
// 读取表格数据
rows, err := file.ReadSheet(filePath, "")
if err != nil {
c.JSON(200, result.ErrMsg(err.Error()))
return
}
// 获取操作人名称
operName := ctx.LoginUserToUserName(c)
isUpdateSupport := parse.Boolean(updateSupport)
message := s.sysUserService.ImportUser(rows, isUpdateSupport, operName)
c.JSON(200, result.OkMsg(message))
}

25
src/modules/system/model/sys_config.go Normal file
View File

@@ -0,0 +1,25 @@
package model
// 参数配置对象 sys_config
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"`
}

41
src/modules/system/model/sys_dept.go Normal file
View File

@@ -0,0 +1,41 @@
package model
// SysDept 部门对象 sys_dept
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"`
// ====== 非数据库字段属性 ======
// 子部门列表
Children []SysDept `json:"children,omitempty"`
// 父部门名称
ParentName string `json:"parentName,omitempty"`
}

31
src/modules/system/model/sys_dict_data.go Normal file
View File

@@ -0,0 +1,31 @@
package model
// SysDictData 字典数据对象 sys_dict_data
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"`
}

23
src/modules/system/model/sys_dict_type.go Normal file
View File

@@ -0,0 +1,23 @@
package model
// SysDictType 字典类型对象 sys_dict_type
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"`
}

23
src/modules/system/model/sys_log_login.go Normal file
View File

@@ -0,0 +1,23 @@
package model
// SysLogLogin 系统登录日志表 sys_log_login
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"`
}

37
src/modules/system/model/sys_log_operate.go Normal file
View File

@@ -0,0 +1,37 @@
package model
// SysLogOperate 系统操作日志表 sys_log_operate
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"`
}

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

@@ -0,0 +1,46 @@
package model
// SysMenu 菜单权限对象 sys_menu
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"`
// ====== 非数据库字段属性 ======
// 子菜单
Children []SysMenu `json:"children,omitempty"`
}

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

@@ -0,0 +1,27 @@
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"`
}

25
src/modules/system/model/sys_post.go Normal file
View File

@@ -0,0 +1,25 @@
package model
// SysPost 岗位对象 sys_post
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"`
}

40
src/modules/system/model/sys_role.go Normal file
View File

@@ -0,0 +1,40 @@
package model
// SysRole 角色对象 sys_role
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"`
// ====== 非数据库字段属性 ======
// 菜单组
MenuIds []string `json:"menuIds,omitempty"`
// 部门组（数据权限）
DeptIds []string `json:"deptIds,omitempty"`
}

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

@@ -0,0 +1,15 @@
package model
// SysRoleDept 角色和部门关联对象 sys_role_dept
type SysRoleDept struct {
RoleID string `json:"roleId"` // 角色ID
DeptID string `json:"deptId"` // 部门ID
}
// NewSysRoleDept 创建角色和部门关联对象的构造函数
func NewSysRoleDept(roleID string, deptID string) SysRoleDept {
return SysRoleDept{
RoleID: roleID,
DeptID: deptID,
}
}

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

@@ -0,0 +1,15 @@
package model
// SysRoleMenu 角色和菜单关联对象 sys_role_menu
type SysRoleMenu struct {
RoleID string `json:"roleId"` // 角色ID
MenuID string `json:"menuId"` // 菜单ID
}
// NewSysRoleMenu 创建角色和菜单关联对象的构造函数
func NewSysRoleMenu(roleID string, menuID string) SysRoleMenu {
return SysRoleMenu{
RoleID: roleID,
MenuID: menuID,
}
}

56
src/modules/system/model/sys_user.go Normal file
View File

@@ -0,0 +1,56 @@
package model
// SysUser 用户对象 sys_user
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"`
// ====== 非数据库字段属性 ======
// 部门对象
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"`
}

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

@@ -0,0 +1,15 @@
package model
// SysUserPost 用户和岗位关联对象 sys_user_post
type SysUserPost struct {
UserID string `json:"userId"` // 用户ID
PostID string `json:"postId"` // 岗位ID
}
// NewSysUserPost 创建用户和岗位关联对象的构造函数
func NewSysUserPost(userID string, postID string) SysUserPost {
return SysUserPost{
UserID: userID,
PostID: postID,
}
}

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

@@ -0,0 +1,15 @@
package model
// SysUserRole 用户和角色关联对象 sys_user_role
type SysUserRole struct {
UserID string `json:"userId"` // 用户ID
RoleID string `json:"roleId"` // 角色ID
}
// NewSysUserRole 创建用户和角色关联对象的构造函数
func NewSysUserRole(userID string, roleID string) SysUserRole {
return SysUserRole{
UserID: userID,
RoleID: roleID,
}
}

30
src/modules/system/repository/sys_config.go Normal file
View File

@@ -0,0 +1,30 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysConfig 参数配置表 数据层接口
type ISysConfig interface {
// SelectDictDataPage 分页查询参数配置列表数据
SelectConfigPage(query map[string]any) map[string]any
// SelectConfigList 查询参数配置列表
SelectConfigList(sysConfig model.SysConfig) []model.SysConfig
// SelectConfigValueByKey 通过参数键名查询参数键值
SelectConfigValueByKey(configKey string) string
// SelectConfigByIds 通过配置ID查询参数配置信息
SelectConfigByIds(configIds []string) []model.SysConfig
// CheckUniqueConfig 校验配置参数是否唯一
CheckUniqueConfig(sysConfig model.SysConfig) string
// InsertConfig 新增参数配置
InsertConfig(sysConfig model.SysConfig) string
// UpdateConfig 修改参数配置
UpdateConfig(sysConfig model.SysConfig) int64
// DeleteConfigByIds 批量删除参数配置信息
DeleteConfigByIds(configIds []string) int64
}

339
src/modules/system/repository/sys_config.impl.go Normal file
View File

@@ -0,0 +1,339 @@
package repository
import (
"fmt"
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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 >= ?")
beginDate := date.ParseStrToDate(beginTime.(string), date.YYYY_MM_DD)
params = append(params, beginDate.UnixMilli())
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "create_time <= ?")
endDate := date.ParseStrToDate(endTime.(string), date.YYYY_MM_DD)
params = append(params, endDate.UnixMilli())
}
// 构建查询条件语句
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.Sprintf("%v", 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.Sprintf("%v", 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
}
if sysConfig.Remark != "" {
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
}

42
src/modules/system/repository/sys_dept.go Normal file
View File

@@ -0,0 +1,42 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysDept 部门表 数据层接口
type ISysDept interface {
// SelectDeptList 查询部门管理数据
SelectDeptList(sysDept model.SysDept, dataScopeSQL string) []model.SysDept
// SelectDeptListByRoleId 根据角色ID查询部门树信息
SelectDeptListByRoleId(roleId string, deptCheckStrictly bool) []string
// SelectDeptById 根据部门ID查询信息
SelectDeptById(deptId string) model.SysDept
// SelectChildrenDeptById 根据ID查询所有子部门
SelectChildrenDeptById(deptId string) []model.SysDept
// 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
}

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

@@ -0,0 +1,393 @@
package repository
import (
"fmt"
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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.Sprintf("%v", 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
}

33
src/modules/system/repository/sys_dict_data.go Normal file
View File

@@ -0,0 +1,33 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysDictData 字典类型数据表 数据层接口
type ISysDictData interface {
// SelectDictDataPage 根据条件分页查询字典数据
SelectDictDataPage(query map[string]any) map[string]any
// SelectDictDataList 根据条件查询字典数据
SelectDictDataList(sysDictData model.SysDictData) []model.SysDictData
// SelectDictDataByCodes 根据字典数据编码查询信息
SelectDictDataByCodes(dictCodes []string) []model.SysDictData
// CountDictDataByType 查询字典数据
CountDictDataByType(dictType string) int64
// CheckUniqueDictData 校验字典数据是否唯一
CheckUniqueDictData(sysDictData model.SysDictData) string
// DeleteDictDataByCodes 批量删除字典数据信息
DeleteDictDataByCodes(dictCodes []string) int64
// InsertDictData 新增字典数据信息
InsertDictData(sysDictData model.SysDictData) string
// UpdateDictData 修改字典数据信息
UpdateDictData(sysDictData model.SysDictData) int64
// UpdateDictDataType 同步修改字典类型
UpdateDictDataType(oldDictType string, newDictType string) int64
}

368
src/modules/system/repository/sys_dict_data.impl.go Normal file
View File

@@ -0,0 +1,368 @@
package repository
import (
"fmt"
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/src/modules/system/model"
)
// 实例化数据层 SysDictDataImpl 结构体
var NewSysDictDataImpl = &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, 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.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.Sprintf("%v", 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.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.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
}

30
src/modules/system/repository/sys_dict_type.go Normal file
View File

@@ -0,0 +1,30 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysDictType 字典类型表 数据层接口
type ISysDictType interface {
// SelectDictTypePage 根据条件分页查询字典类型
SelectDictTypePage(query map[string]any) map[string]any
// SelectDictTypeList 根据条件查询字典类型
SelectDictTypeList(sysDictType model.SysDictType) []model.SysDictType
// SelectDictTypeByIDs 根据字典类型ID查询信息
SelectDictTypeByIDs(dictIDs []string) []model.SysDictType
// SelectDictTypeByType 根据字典类型查询信息
SelectDictTypeByType(dictType string) model.SysDictType
// CheckUniqueDictType 校验字典类型是否唯一
CheckUniqueDictType(sysDictType model.SysDictType) string
// InsertDictType 新增字典类型信息
InsertDictType(sysDictType model.SysDictType) string
// UpdateDictType 修改字典类型信息
UpdateDictType(sysDictType model.SysDictType) int64
// DeleteDictTypeByIDs 批量删除字典类型信息
DeleteDictTypeByIDs(dictIDs []string) int64
}

334
src/modules/system/repository/sys_dict_type.impl.go Normal file
View File

@@ -0,0 +1,334 @@
package repository
import (
"fmt"
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/src/modules/system/model"
)
// 实例化数据层 SysDictTypeImpl 结构体
var NewSysDictTypeImpl = &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, v)
}
if v, ok := query["dictType"]; ok && v != "" {
conditions = append(conditions, "dict_type 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, "create_time >= ?")
beginDate := date.ParseStrToDate(beginTime.(string), date.YYYY_MM_DD)
params = append(params, beginDate.UnixMilli())
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "create_time <= ?")
endDate := date.ParseStrToDate(endTime.(string), date.YYYY_MM_DD)
params = append(params, endDate.UnixMilli())
}
// 构建查询条件语句
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.Sprintf("%v", 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
}
if sysDictType.Remark != "" {
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
}

21
src/modules/system/repository/sys_log_login.go Normal file
View File

@@ -0,0 +1,21 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysLogLogin 系统登录日志表 数据层接口
type ISysLogLogin interface {
// SelectSysLogLoginPage 分页查询系统登录日志集合
SelectSysLogLoginPage(query map[string]any) map[string]any
// SelectSysLogLoginList 查询系统登录日志集合
SelectSysLogLoginList(sysLogLogin model.SysLogLogin) []model.SysLogLogin
// InsertSysLogLogin 新增系统登录日志
InsertSysLogLogin(sysLogLogin model.SysLogLogin) string
// DeleteSysLogLoginByIds 批量删除系统登录日志
DeleteSysLogLoginByIds(loginIds []string) int64
// CleanSysLogLogin 清空系统登录日志
CleanSysLogLogin() error
}

245
src/modules/system/repository/sys_log_login.impl.go Normal file
View File

@@ -0,0 +1,245 @@
package repository
import (
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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) 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 >= ?")
beginDate := date.ParseStrToDate(beginTime.(string), date.YYYY_MM_DD)
params = append(params, beginDate.UnixMilli())
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "login_time <= ?")
endDate := date.ParseStrToDate(endTime.(string), date.YYYY_MM_DD)
params = append(params, endDate.UnixMilli())
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysLogLogin{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_log_login"
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 := 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
}
// 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
}

24
src/modules/system/repository/sys_log_operate.go Normal file
View File

@@ -0,0 +1,24 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysLogOperate 操作日志表 数据层接口
type ISysLogOperate interface {
// SelectSysLogOperatePage 分页查询系统操作日志集合
SelectSysLogOperatePage(query map[string]any) map[string]any
// 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
}

299
src/modules/system/repository/sys_log_operate.impl.go Normal file
View File

@@ -0,0 +1,299 @@
package repository
import (
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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) 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, v)
}
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, 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, "oper_time >= ?")
beginDate := date.ParseStrToDate(beginTime.(string), date.YYYY_MM_DD)
params = append(params, beginDate.UnixMilli())
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "oper_time <= ?")
endDate := date.ParseStrToDate(endTime.(string), date.YYYY_MM_DD)
params = append(params, endDate.UnixMilli())
}
// 构建查询条件语句
whereSql := ""
if len(conditions) > 0 {
whereSql += " where " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysLogOperate{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_log_operate"
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 := 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
}
// 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
}

36
src/modules/system/repository/sys_menu.go Normal file
View File

@@ -0,0 +1,36 @@
package repository
import "ems.agt/src/modules/system/model"
// 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
// SelectMenuListByRoleId 根据角色ID查询菜单树信息
SelectMenuListByRoleId(roleId string, menuCheckStrictly bool) []string
// SelectMenuByIds 根据菜单ID查询信息
SelectMenuByIds(menuIds []string) []model.SysMenu
// 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
}

476
src/modules/system/repository/sys_menu.impl.go Normal file
View File

@@ -0,0 +1,476 @@
package repository
import (
"fmt"
"strings"
"time"
"ems.agt/src/framework/constants/menu"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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"] = "#"
}
if sysMenu.Remark != "" {
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.Sprintf("%v", results[0]["str"])
}
return ""
}

24
src/modules/system/repository/sys_notice.go Normal file
View File

@@ -0,0 +1,24 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysNotice 通知公告表 数据层接口
type ISysNotice interface {
// SelectNoticePage 分页查询公告列表
SelectNoticePage(query map[string]any) map[string]any
// SelectNoticeList 查询公告列表
SelectNoticeList(sysNotice model.SysNotice) []model.SysNotice
// SelectNoticeById 查询公告信息
SelectNoticeByIds(noticeIds []string) []model.SysNotice
// InsertNotice 新增公告
InsertNotice(sysNotice model.SysNotice) string
// UpdateNotice 修改公告
UpdateNotice(sysNotice model.SysNotice) int64
// DeleteNoticeByIds 批量删除公告信息
DeleteNoticeByIds(noticeIds []string) int64
}

297
src/modules/system/repository/sys_notice.impl.go Normal file
View File

@@ -0,0 +1,297 @@
package repository
import (
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/src/modules/system/model"
)
// 实例化数据层 SysNoticeImpl 结构体
var NewSysNoticeImpl = &SysNoticeImpl{
selectSql: `select
notice_id, notice_title, notice_type, notice_content, status, del_flag,
create_by, create_time, update_by, update_time, remark from sys_notice`,
resultMap: map[string]string{
"notice_id": "NoticeID",
"notice_title": "NoticeTitle",
"notice_type": "NoticeType",
"notice_content": "NoticeContent",
"status": "Status",
"del_flag": "DelFlag",
"create_by": "CreateBy",
"create_time": "CreateTime",
"update_by": "UpdateBy",
"update_time": "UpdateTime",
"remark": "Remark",
},
}
// SysNoticeImpl 通知公告表 数据层处理
type SysNoticeImpl struct {
// 查询视图对象SQL
selectSql string
// 结果字段与实体映射
resultMap map[string]string
}
// convertResultRows 将结果记录转实体结果组
func (r *SysNoticeImpl) convertResultRows(rows []map[string]any) []model.SysNotice {
arr := make([]model.SysNotice, 0)
for _, row := range rows {
sysNotice := model.SysNotice{}
for key, value := range row {
if keyMapper, ok := r.resultMap[key]; ok {
repo.SetFieldValue(&sysNotice, keyMapper, value)
}
}
arr = append(arr, sysNotice)
}
return arr
}
// SelectNoticePage 分页查询公告列表
func (r *SysNoticeImpl) SelectNoticePage(query map[string]any) map[string]any {
// 查询条件拼接
var conditions []string
var params []any
if v, ok := query["noticeTitle"]; ok && v != "" {
conditions = append(conditions, "notice_title like concat(?, '%')")
params = append(params, v)
}
if v, ok := query["noticeType"]; ok && v != "" {
conditions = append(conditions, "notice_type = ?")
params = append(params, v)
}
if v, ok := query["createBy"]; ok && v != "" {
conditions = append(conditions, "create_by 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, "create_time >= ?")
beginDate := date.ParseStrToDate(beginTime.(string), date.YYYY_MM_DD)
params = append(params, beginDate.UnixMilli())
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "create_time <= ?")
endDate := date.ParseStrToDate(endTime.(string), date.YYYY_MM_DD)
params = append(params, endDate.UnixMilli())
}
// 构建查询条件语句
whereSql := " where del_flag = '0' "
if len(conditions) > 0 {
whereSql += " and " + strings.Join(conditions, " and ")
}
// 查询结果
result := map[string]any{
"total": 0,
"rows": []model.SysNotice{},
}
// 查询数量 长度为0直接返回
totalSql := "select count(1) as 'total' from sys_notice"
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)
}
// 转换实体
result["rows"] = r.convertResultRows(results)
return result
}
// SelectNoticeList 查询公告列表
func (r *SysNoticeImpl) SelectNoticeList(sysNotice model.SysNotice) []model.SysNotice {
// 查询条件拼接
var conditions []string
var params []any
if sysNotice.NoticeTitle != "" {
conditions = append(conditions, "notice_title like concat(?, '%')")
params = append(params, sysNotice.NoticeTitle)
}
if sysNotice.NoticeType != "" {
conditions = append(conditions, "notice_type = ?")
params = append(params, sysNotice.NoticeType)
}
if sysNotice.CreateBy != "" {
conditions = append(conditions, "create_by like concat(?, '%')")
params = append(params, sysNotice.CreateBy)
}
if sysNotice.Status != "" {
conditions = append(conditions, "status = ?")
params = append(params, sysNotice.Status)
}
// 构建查询条件语句
whereSql := " where del_flag = '0' "
if len(conditions) > 0 {
whereSql += " and " + 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.SysNotice{}
}
// 转换实体
return r.convertResultRows(results)
}
// SelectNoticeByIds 查询公告信息
func (r *SysNoticeImpl) SelectNoticeByIds(noticeIds []string) []model.SysNotice {
placeholder := repo.KeyPlaceholderByQuery(len(noticeIds))
querySql := r.selectSql + " where notice_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(noticeIds)
results, err := datasource.RawDB("", querySql, parameters)
if err != nil {
logger.Errorf("query err => %v", err)
return []model.SysNotice{}
}
// 转换实体
return r.convertResultRows(results)
}
// InsertNotice 新增公告
func (r *SysNoticeImpl) InsertNotice(sysNotice model.SysNotice) string {
// 参数拼接
params := make(map[string]any)
if sysNotice.NoticeTitle != "" {
params["notice_title"] = sysNotice.NoticeTitle
}
if sysNotice.NoticeType != "" {
params["notice_type"] = sysNotice.NoticeType
}
if sysNotice.NoticeContent != "" {
params["notice_content"] = sysNotice.NoticeContent
}
if sysNotice.Status != "" {
params["status"] = sysNotice.Status
}
if sysNotice.Remark != "" {
params["remark"] = sysNotice.Remark
}
if sysNotice.CreateBy != "" {
params["create_by"] = sysNotice.CreateBy
params["create_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, placeholder, values := repo.KeyPlaceholderValueByInsert(params)
sql := "insert into sys_notice (" + 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
}
// UpdateNotice 修改公告
func (r *SysNoticeImpl) UpdateNotice(sysNotice model.SysNotice) int64 {
// 参数拼接
params := make(map[string]any)
if sysNotice.NoticeTitle != "" {
params["notice_title"] = sysNotice.NoticeTitle
}
if sysNotice.NoticeType != "" {
params["notice_type"] = sysNotice.NoticeType
}
if sysNotice.NoticeContent != "" {
params["notice_content"] = sysNotice.NoticeContent
}
if sysNotice.Status != "" {
params["status"] = sysNotice.Status
}
if sysNotice.Remark != "" {
params["remark"] = sysNotice.Remark
}
if sysNotice.UpdateBy != "" {
params["update_by"] = sysNotice.UpdateBy
params["update_time"] = time.Now().UnixMilli()
}
// 构建执行语句
keys, values := repo.KeyValueByUpdate(params)
sql := "update sys_notice set " + strings.Join(keys, ",") + " where notice_id = ?"
// 执行更新
values = append(values, sysNotice.NoticeID)
rows, err := datasource.ExecDB("", sql, values)
if err != nil {
logger.Errorf("update row : %v", err.Error())
return 0
}
return rows
}
// DeleteNoticeByIds 批量删除公告信息
func (r *SysNoticeImpl) DeleteNoticeByIds(noticeIds []string) int64 {
placeholder := repo.KeyPlaceholderByQuery(len(noticeIds))
sql := "update sys_notice set del_flag = '1' where notice_id in (" + placeholder + ")"
parameters := repo.ConvertIdsSlice(noticeIds)
results, err := datasource.ExecDB("", sql, parameters)
if err != nil {
logger.Errorf("update err => %v", err)
return 0
}
return results
}

30
src/modules/system/repository/sys_post.go Normal file
View File

@@ -0,0 +1,30 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysPost 岗位表 数据层接口
type ISysPost interface {
// SelectPostPage 查询岗位分页数据集合
SelectPostPage(query map[string]any) map[string]any
// SelectPostList 查询岗位数据集合
SelectPostList(sysPost model.SysPost) []model.SysPost
// SelectPostByIds 通过岗位ID查询岗位信息
SelectPostByIds(postIds []string) []model.SysPost
// SelectPostListByUserId 根据用户ID获取岗位选择框列表
SelectPostListByUserId(userId string) []model.SysPost
// DeletePostByIds 批量删除岗位信息
DeletePostByIds(postIds []string) int64
// UpdatePost 修改岗位信息
UpdatePost(sysPost model.SysPost) int64
// InsertPost 新增岗位信息
InsertPost(sysPost model.SysPost) string
// CheckUniquePost 校验岗位唯一
CheckUniquePost(sysPost model.SysPost) string
}

323
src/modules/system/repository/sys_post.impl.go Normal file
View File

@@ -0,0 +1,323 @@
package repository
import (
"fmt"
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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
}
if sysPost.Remark != "" {
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.Sprintf("%v", results[0]["str"])
}
return ""
}

30
src/modules/system/repository/sys_role.go Normal file
View File

@@ -0,0 +1,30 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysRole 角色表 数据层接口
type ISysRole interface {
// SelectRolePage 根据条件分页查询角色数据
SelectRolePage(query map[string]any, dataScopeSQL string) map[string]any
// SelectRoleList 根据条件查询角色数据
SelectRoleList(sysRole model.SysRole, dataScopeSQL string) []model.SysRole
// SelectRoleListByUserId 根据用户ID获取角色选择框列表
SelectRoleListByUserId(userId string) []model.SysRole
// SelectRoleByIds 通过角色ID查询角色
SelectRoleByIds(roleIds []string) []model.SysRole
// UpdateRole 修改角色信息
UpdateRole(sysRole model.SysRole) int64
// InsertRole 新增角色信息
InsertRole(sysRole model.SysRole) string
// DeleteRoleByIds 批量删除角色信息
DeleteRoleByIds(roleIds []string) int64
// CheckUniqueRole 校验角色是否唯一
CheckUniqueRole(sysRole model.SysRole) string
}

382
src/modules/system/repository/sys_role.impl.go Normal file
View File

@@ -0,0 +1,382 @@
package repository
import (
"fmt"
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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 >= ?")
beginDate := date.ParseStrToDate(beginTime.(string), date.YYYY_MM_DD)
params = append(params, beginDate.UnixMilli())
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "r.create_time <= ?")
endDate := date.ParseStrToDate(endTime.(string), date.YYYY_MM_DD)
params = append(params, endDate.UnixMilli())
}
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' "
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
}
if sysRole.Remark != "" {
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
}
if sysRole.Remark != "" {
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.Sprintf("%v", results[0]["str"])
}
return ""
}

15
src/modules/system/repository/sys_role_dept.go Normal file
View File

@@ -0,0 +1,15 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysRoleDept 角色与部门关联表 数据层接口
type ISysRoleDept interface {
// DeleteRoleDept 批量删除角色部门关联信息
DeleteRoleDept(roleIds []string) int64
// DeleteDeptRole 批量删除部门角色关联信息
DeleteDeptRole(deptIds []string) int64
// BatchRoleDept 批量新增角色部门信息
BatchRoleDept(sysRoleDepts []model.SysRoleDept) int64
}

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

@@ -0,0 +1,58 @@
package repository
import (
"fmt"
"strings"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/repo"
"ems.agt/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
}

18
src/modules/system/repository/sys_role_menu.go Normal file
View File

@@ -0,0 +1,18 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysRoleMenu 角色与菜单关联表 数据层接口
type ISysRoleMenu interface {
// CheckMenuExistRole 查询菜单分配给角色使用数量
CheckMenuExistRole(menuId string) int64
// DeleteRoleMenu 批量删除角色和菜单关联
DeleteRoleMenu(roleIds []string) int64
// DeleteMenuRole 批量删除菜单和角色关联
DeleteMenuRole(menuIds []string) int64
// BatchRoleMenu 批量新增角色菜单信息
BatchRoleMenu(sysRoleMenus []model.SysRoleMenu) int64
}

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

@@ -0,0 +1,73 @@
package repository
import (
"fmt"
"strings"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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
}

33
src/modules/system/repository/sys_user.go Normal file
View File

@@ -0,0 +1,33 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysUser 用户表 数据层接口
type ISysUser interface {
// SelectUserPage 根据条件分页查询用户列表
SelectUserPage(query map[string]any, dataScopeSQL string) map[string]any
// SelectAllocatedPage 根据条件分页查询分配用户角色列表
SelectAllocatedPage(query map[string]any, dataScopeSQL string) map[string]any
// SelectUserList 根据条件查询用户列表
SelectUserList(sysUser model.SysUser, dataScopeSQL string) []model.SysUser
// SelectUserByIds 通过用户ID查询用户
SelectUserByIds(userIds []string) []model.SysUser
// SelectUserByUserName 通过用户登录账号查询用户
SelectUserByUserName(userName string) model.SysUser
// InsertUser 新增用户信息
InsertUser(sysUser model.SysUser) string
// UpdateUser 修改用户信息
UpdateUser(sysUser model.SysUser) int64
// DeleteUserByIds 批量删除用户信息
DeleteUserByIds(userIds []string) int64
// CheckUniqueUser 校验用户信息是否唯一
CheckUniqueUser(sysUser model.SysUser) string
}

580
src/modules/system/repository/sys_user.impl.go Normal file
View File

@@ -0,0 +1,580 @@
package repository
import (
"fmt"
"strings"
"time"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/crypto"
"ems.agt/src/framework/utils/date"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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 {
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`
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`
// 查询条件拼接
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 >= ?")
beginDate := date.ParseStrToDate(beginTime.(string), date.YYYY_MM_DD)
params = append(params, beginDate.UnixMilli())
}
endTime, ok := query["endTime"]
if !ok {
endTime, ok = query["params[endTime]"]
}
if ok && endTime != "" {
conditions = append(conditions, "u.login_date <= ?")
endDate := date.ParseStrToDate(endTime.(string), date.YYYY_MM_DD)
params = append(params, endDate.UnixMilli())
}
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' "
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 := selectUserSql + 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' "
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
}
if sysUser.Email != "" {
if sysUser.Email == "nil" {
params["email"] = ""
} else {
params["email"] = sysUser.Email
}
}
if sysUser.PhoneNumber != "" {
if sysUser.PhoneNumber == "nil" {
params["phonenumber"] = ""
} else {
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.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))
sql := "update sys_user set del_flag = '1' where user_id in (" + 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.Sprintf("%v", results[0]["str"])
}
return ""
}

15
src/modules/system/repository/sys_user_post.go Normal file
View File

@@ -0,0 +1,15 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysUserPost 用户与岗位关联表 数据层接口
type ISysUserPost interface {
// CountUserPostByPostId 通过岗位ID查询岗位使用数量
CountUserPostByPostId(postId string) int64
// BatchUserPost 批量新增用户岗位信息
BatchUserPost(sysUserPosts []model.SysUserPost) int64
// DeleteUserPost 批量删除用户和岗位关联
DeleteUserPost(userIds []string) int64
}

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

@@ -0,0 +1,60 @@
package repository
import (
"fmt"
"strings"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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
}

18
src/modules/system/repository/sys_user_role.go Normal file
View File

@@ -0,0 +1,18 @@
package repository
import "ems.agt/src/modules/system/model"
// ISysUserRole 用户与角色关联表 数据层接口
type ISysUserRole interface {
// CountUserRoleByRoleId 通过角色ID查询角色使用数量
CountUserRoleByRoleId(roleId string) int64
// BatchUserRole 批量新增用户角色信息
BatchUserRole(sysUserRoles []model.SysUserRole) int64
// DeleteUserRole 批量删除用户和角色关联
DeleteUserRole(userIds []string) int64
// DeleteUserRoleByRoleId 批量取消授权用户角色
DeleteUserRoleByRoleId(roleId string, userIds []string) int64
}

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

@@ -0,0 +1,74 @@
package repository
import (
"fmt"
"strings"
"ems.agt/src/framework/datasource"
"ems.agt/src/framework/logger"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/repo"
"ems.agt/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
}

30
src/modules/system/service/sys_config.go Normal file
View File

@@ -0,0 +1,30 @@
package service
import "ems.agt/src/modules/system/model"
// ISysConfig 参数配置 服务层接口
type ISysConfig interface {
// SelectDictDataPage 分页查询参数配置列表数据
SelectConfigPage(query map[string]any) map[string]any
// 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()
}

157
src/modules/system/service/sys_config.impl.go Normal file
View File

@@ -0,0 +1,157 @@
package service
import (
"errors"
"ems.agt/src/framework/constants/cachekey"
"ems.agt/src/framework/redis"
"ems.agt/src/modules/system/model"
"ems.agt/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, err := redis.Get("", cacheKey)
if cacheValue != "" || err != nil {
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, errors.New("没有权限访问参数配置数据！")
}
for _, config := range configs {
// 检查是否为内置参数
if config.ConfigType == "Y" {
return 0, errors.New(config.ConfigID + " 配置参数属于内置参数，禁止删除！")
}
// 清除缓存
r.clearConfigCache(config.ConfigKey)
}
if len(configs) == len(configIds) {
rows := r.sysConfigRepository.DeleteConfigByIds(configIds)
return rows, nil
}
return 0, errors.New("删除参数配置信息失败！")
}
// 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
}

39
src/modules/system/service/sys_dept.go Normal file
View File

@@ -0,0 +1,39 @@
package service
import (
"ems.agt/src/framework/vo"
"ems.agt/src/modules/system/model"
)
// 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
}

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

@@ -0,0 +1,202 @@
package service
import (
"strings"
"ems.agt/src/framework/constants/common"
"ems.agt/src/framework/vo"
"ems.agt/src/modules/system/model"
"ems.agt/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
}

33
src/modules/system/service/sys_dict_data.go Normal file
View File

@@ -0,0 +1,33 @@
package service
import "ems.agt/src/modules/system/model"
// ISysDictData 字典类型数据 服务层接口
type ISysDictData interface {
// SelectDictDataPage 根据条件分页查询字典数据
SelectDictDataPage(query map[string]any) map[string]any
// SelectDictDataList 根据条件查询字典数据
SelectDictDataList(sysDictData model.SysDictData) []model.SysDictData
// SelectDictDataByCode 根据字典数据编码查询信息
SelectDictDataByCode(dictCode string) model.SysDictData
// SelectDictDataByType 根据字典类型查询信息
SelectDictDataByType(dictType string) []model.SysDictData
// CheckUniqueDictLabel 校验字典标签是否唯一
CheckUniqueDictLabel(dictType, dictLabel, dictCode string) bool
// CheckUniqueDictValue 校验字典键值是否唯一
CheckUniqueDictValue(dictType, dictValue, dictCode string) bool
// DeleteDictDataByCodes 批量删除字典数据信息
DeleteDictDataByCodes(dictCodes []string) (int64, error)
// InsertDictData 新增字典数据信息
InsertDictData(sysDictData model.SysDictData) string
// UpdateDictData 修改字典数据信息
UpdateDictData(sysDictData model.SysDictData) int64
}

110
src/modules/system/service/sys_dict_data.impl.go Normal file
View File

@@ -0,0 +1,110 @@
package service
import (
"errors"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/repository"
)
// 实例化服务层 SysDictDataImpl 结构体
var NewSysDictDataImpl = &SysDictDataImpl{
sysDictDataRepository: repository.NewSysDictDataImpl,
sysDictTypeService: NewSysDictTypeImpl,
}
// SysDictDataImpl 字典类型数据 服务层处理
type SysDictDataImpl struct {
// 字典数据服务
sysDictDataRepository repository.ISysDictData
// 字典类型服务
sysDictTypeService ISysDictType
}
// SelectDictDataPage 根据条件分页查询字典数据
func (r *SysDictDataImpl) SelectDictDataPage(query map[string]any) map[string]any {
return r.sysDictDataRepository.SelectDictDataPage(query)
}
// SelectDictDataList 根据条件查询字典数据
func (r *SysDictDataImpl) SelectDictDataList(sysDictData model.SysDictData) []model.SysDictData {
return r.sysDictDataRepository.SelectDictDataList(sysDictData)
}
// SelectDictDataByCode 根据字典数据编码查询信息
func (r *SysDictDataImpl) SelectDictDataByCode(dictCode string) model.SysDictData {
if dictCode == "" {
return model.SysDictData{}
}
dictCodes := r.sysDictDataRepository.SelectDictDataByCodes([]string{dictCode})
if len(dictCodes) > 0 {
return dictCodes[0]
}
return model.SysDictData{}
}
// SelectDictDataByType 根据字典类型查询信息
func (r *SysDictDataImpl) SelectDictDataByType(dictType string) []model.SysDictData {
return r.sysDictTypeService.DictDataCache(dictType)
}
// CheckUniqueDictLabel 校验字典标签是否唯一
func (r *SysDictDataImpl) 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 *SysDictDataImpl) 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 *SysDictDataImpl) DeleteDictDataByCodes(dictCodes []string) (int64, error) {
// 检查是否存在
dictDatas := r.sysDictDataRepository.SelectDictDataByCodes(dictCodes)
if len(dictDatas) <= 0 {
return 0, errors.New("没有权限访问字典编码数据！")
}
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, errors.New("删除字典数据信息失败！")
}
// InsertDictData 新增字典数据信息
func (r *SysDictDataImpl) InsertDictData(sysDictData model.SysDictData) string {
insertId := r.sysDictDataRepository.InsertDictData(sysDictData)
if insertId != "" {
r.sysDictTypeService.LoadingDictCache(sysDictData.DictType)
}
return insertId
}
// UpdateDictData 修改字典数据信息
func (r *SysDictDataImpl) UpdateDictData(sysDictData model.SysDictData) int64 {
rows := r.sysDictDataRepository.UpdateDictData(sysDictData)
if rows > 0 {
r.sysDictTypeService.LoadingDictCache(sysDictData.DictType)
}
return rows
}

45
src/modules/system/service/sys_dict_type.go Normal file
View File

@@ -0,0 +1,45 @@
package service
import "ems.agt/src/modules/system/model"
// ISysDictType 字典类型 服务层接口
type ISysDictType interface {
// SelectDictTypePage 根据条件分页查询字典类型
SelectDictTypePage(query map[string]any) map[string]any
// SelectDictTypeList 根据条件查询字典类型
SelectDictTypeList(sysDictType model.SysDictType) []model.SysDictType
// SelectDictTypeByID 根据字典类型ID查询信息
SelectDictTypeByID(dictID string) model.SysDictType
// SelectDictTypeByType 根据字典类型查询信息
SelectDictTypeByType(dictType string) model.SysDictType
// CheckUniqueDictName 校验字典名称是否唯一
CheckUniqueDictName(dictName, dictID string) bool
// CheckUniqueDictType 校验字典类型是否唯一
CheckUniqueDictType(dictType, dictID string) bool
// InsertDictType 新增字典类型信息
InsertDictType(sysDictType model.SysDictType) string
// UpdateDictType 修改字典类型信息
UpdateDictType(sysDictType model.SysDictType) int64
// DeleteDictTypeByIDs 批量删除字典类型信息
DeleteDictTypeByIDs(dictIDs []string) (int64, error)
// ResetDictCache 重置字典缓存数据
ResetDictCache()
// 加载字典缓存数据
LoadingDictCache(dictType string)
// 清空字典缓存数据
ClearDictCache(dictType string) bool
// DictDataCache 获取字典数据缓存数据
DictDataCache(dictType string) []model.SysDictData
}

211
src/modules/system/service/sys_dict_type.impl.go Normal file
View File

@@ -0,0 +1,211 @@
package service
import (
"encoding/json"
"errors"
"fmt"
"ems.agt/src/framework/constants/cachekey"
"ems.agt/src/framework/constants/common"
"ems.agt/src/framework/redis"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/repository"
)
// 实例化服务层 SysDictTypeImpl 结构体
var NewSysDictTypeImpl = &SysDictTypeImpl{
sysDictTypeRepository: repository.NewSysDictTypeImpl,
sysDictDataRepository: repository.NewSysDictDataImpl,
}
// SysDictTypeImpl 字典类型 服务层处理
type SysDictTypeImpl struct {
// 字典类型服务
sysDictTypeRepository repository.ISysDictType
// 字典数据服务
sysDictDataRepository repository.ISysDictData
}
// SelectDictTypePage 根据条件分页查询字典类型
func (r *SysDictTypeImpl) SelectDictTypePage(query map[string]any) map[string]any {
return r.sysDictTypeRepository.SelectDictTypePage(query)
}
// SelectDictTypeList 根据条件查询字典类型
func (r *SysDictTypeImpl) SelectDictTypeList(sysDictType model.SysDictType) []model.SysDictType {
return r.sysDictTypeRepository.SelectDictTypeList(sysDictType)
}
// SelectDictTypeByID 根据字典类型ID查询信息
func (r *SysDictTypeImpl) SelectDictTypeByID(dictID string) model.SysDictType {
if dictID == "" {
return model.SysDictType{}
}
dictTypes := r.sysDictTypeRepository.SelectDictTypeByIDs([]string{dictID})
if len(dictTypes) > 0 {
return dictTypes[0]
}
return model.SysDictType{}
}
// SelectDictTypeByType 根据字典类型查询信息
func (r *SysDictTypeImpl) SelectDictTypeByType(dictType string) model.SysDictType {
return r.sysDictTypeRepository.SelectDictTypeByType(dictType)
}
// CheckUniqueDictName 校验字典名称是否唯一
func (r *SysDictTypeImpl) CheckUniqueDictName(dictName, dictID string) bool {
uniqueId := r.sysDictTypeRepository.CheckUniqueDictType(model.SysDictType{
DictName: dictName,
})
if uniqueId == dictID {
return true
}
return uniqueId == ""
}
// CheckUniqueDictType 校验字典类型是否唯一
func (r *SysDictTypeImpl) CheckUniqueDictType(dictType, dictID string) bool {
uniqueId := r.sysDictTypeRepository.CheckUniqueDictType(model.SysDictType{
DictType: dictType,
})
if uniqueId == dictID {
return true
}
return uniqueId == ""
}
// InsertDictType 新增字典类型信息
func (r *SysDictTypeImpl) InsertDictType(sysDictType model.SysDictType) string {
insertId := r.sysDictTypeRepository.InsertDictType(sysDictType)
if insertId != "" {
r.LoadingDictCache(sysDictType.DictType)
}
return insertId
}
// UpdateDictType 修改字典类型信息
func (r *SysDictTypeImpl) UpdateDictType(sysDictType model.SysDictType) int64 {
data := r.sysDictTypeRepository.SelectDictTypeByIDs([]string{sysDictType.DictID})
if len(data) == 0 {
return 0
}
// 修改字典类型key时同步更新其字典数据的类型key
oldDictType := data[0].DictType
rows := r.sysDictTypeRepository.UpdateDictType(sysDictType)
if rows > 0 && oldDictType != "" && oldDictType != sysDictType.DictType {
r.sysDictDataRepository.UpdateDictDataType(oldDictType, sysDictType.DictType)
}
// 刷新缓存
r.ClearDictCache(oldDictType)
r.LoadingDictCache(sysDictType.DictType)
return rows
}
// DeleteDictTypeByIDs 批量删除字典类型信息
func (r *SysDictTypeImpl) DeleteDictTypeByIDs(dictIDs []string) (int64, error) {
// 检查是否存在
dictTypes := r.sysDictTypeRepository.SelectDictTypeByIDs(dictIDs)
if len(dictTypes) <= 0 {
return 0, errors.New("没有权限访问字典类型数据！")
}
for _, v := range dictTypes {
// 字典类型下级含有数据
useCount := r.sysDictDataRepository.CountDictDataByType(v.DictType)
if useCount > 0 {
msg := fmt.Sprintf("【%s】存在字典数据,不能删除", v.DictName)
return 0, errors.New(msg)
}
// 清除缓存
r.ClearDictCache(v.DictType)
}
if len(dictTypes) == len(dictIDs) {
rows := r.sysDictTypeRepository.DeleteDictTypeByIDs(dictIDs)
return rows, nil
}
return 0, errors.New("删除字典数据信息失败！")
}
// ResetDictCache 重置字典缓存数据
func (r *SysDictTypeImpl) ResetDictCache() {
r.ClearDictCache("*")
r.LoadingDictCache("")
}
// getCacheKey 组装缓存key
func (r *SysDictTypeImpl) getDictCache(dictType string) string {
return cachekey.SYS_DICT_KEY + dictType
}
// LoadingDictCache 加载字典缓存数据
func (r *SysDictTypeImpl) LoadingDictCache(dictType string) {
sysDictData := model.SysDictData{
Status: common.STATUS_YES,
}
// 指定字典类型
if dictType != "" {
sysDictData.DictType = dictType
// 删除缓存
key := r.getDictCache(dictType)
redis.Del("", key)
}
sysDictDataList := r.sysDictDataRepository.SelectDictDataList(sysDictData)
if len(sysDictDataList) == 0 {
return
}
// 将字典数据按类型分组
m := make(map[string][]model.SysDictData, 0)
for _, v := range sysDictDataList {
key := v.DictType
if item, ok := m[key]; ok {
m[key] = append(item, v)
} else {
m[key] = []model.SysDictData{v}
}
}
// 放入缓存
for k, v := range m {
key := r.getDictCache(k)
values, _ := json.Marshal(v)
redis.Set("", key, string(values))
}
}
// ClearDictCache 清空字典缓存数据
func (r *SysDictTypeImpl) ClearDictCache(dictType string) bool {
key := r.getDictCache(dictType)
keys, err := redis.GetKeys("", key)
if err != nil {
return false
}
delOk, _ := redis.DelKeys("", keys)
return delOk
}
// DictDataCache 获取字典数据缓存数据
func (r *SysDictTypeImpl) 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))
}
}
return data
}

24
src/modules/system/service/sys_log_login.go Normal file
View File

@@ -0,0 +1,24 @@
package service
import "ems.agt/src/modules/system/model"
// ISysLogLogin 系统登录日志 服务层接口
type ISysLogLogin interface {
// SelectSysLogLoginPage 分页查询系统登录日志集合
SelectSysLogLoginPage(query map[string]any) map[string]any
// SelectSysLogLoginList 查询系统登录日志集合
SelectSysLogLoginList(sysLogLogin model.SysLogLogin) []model.SysLogLogin
// InsertSysLogLogin 新增系统登录日志
InsertSysLogLogin(sysLogLogin model.SysLogLogin) string
// DeleteSysLogLoginByIds 批量删除系统登录日志
DeleteSysLogLoginByIds(loginIds []string) int64
// CleanSysLogLogin 清空系统登录日志
CleanSysLogLogin() error
// NewSysLogLogin 生成系统登录日志
NewSysLogLogin(userName, status, msg string, ilobArgs ...string) string
}

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

@@ -0,0 +1,56 @@
package service
import (
"ems.agt/src/modules/system/model"
"ems.agt/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) map[string]any {
return s.sysLogLoginService.SelectSysLogLoginPage(query)
}
// 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()
}
// NewSysLogLogin 生成系统登录日志
func (s *SysLogLoginImpl) NewSysLogLogin(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)
}

24
src/modules/system/service/sys_log_operate.go Normal file
View File

@@ -0,0 +1,24 @@
package service
import "ems.agt/src/modules/system/model"
// ISysLogOperate 操作日志表 服务层接口
type ISysLogOperate interface {
// SelectSysLogOperatePage 分页查询系统操作日志集合
SelectSysLogOperatePage(query map[string]any) map[string]any
// 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
}

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

@@ -0,0 +1,47 @@
package service
import (
"ems.agt/src/modules/system/model"
"ems.agt/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) map[string]any {
return r.SysLogOperateService.SelectSysLogOperatePage(query)
}
// 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()
}

51
src/modules/system/service/sys_menu.go Normal file
View File

@@ -0,0 +1,51 @@
package service
import (
"ems.agt/src/framework/vo"
"ems.agt/src/modules/system/model"
)
// ISysMenu 菜单 服务层接口
type ISysMenu interface {
// SelectMenuList 查询系统菜单列表
SelectMenuList(sysMenu model.SysMenu, userId string) []model.SysMenu
// SelectMenuPermsByUserId 根据用户ID查询权限
SelectMenuPermsByUserId(userId string) []string
// SelectMenuPermsByUserId 根据用户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, menuId string) bool
// BuildRouteMenus 构建前端路由所需要的菜单
BuildRouteMenus(sysMenus []model.SysMenu, prefix string) []vo.Router
}

380
src/modules/system/service/sys_menu.impl.go Normal file
View File

@@ -0,0 +1,380 @@
package service
import (
"encoding/base64"
"strings"
"ems.agt/src/framework/constants/common"
"ems.agt/src/framework/constants/menu"
"ems.agt/src/framework/utils/parse"
"ems.agt/src/framework/utils/regular"
"ems.agt/src/framework/vo"
"ems.agt/src/modules/system/model"
"ems.agt/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)
menus := r.parseDataToTree(sysMenus)
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, menuId string) bool {
uniqueId := r.sysMenuRepository.CheckUniqueMenu(model.SysMenu{
Path: path,
})
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
}

24
src/modules/system/service/sys_notice.go Normal file
View File

@@ -0,0 +1,24 @@
package service
import "ems.agt/src/modules/system/model"
// ISysNotice 公告 服务层接口
type ISysNotice interface {
// SelectNoticePage 分页查询公告列表
SelectNoticePage(query map[string]any) map[string]any
// SelectNoticeList 查询公告列表
SelectNoticeList(sysNotice model.SysNotice) []model.SysNotice
// SelectNoticeById 查询公告信息
SelectNoticeById(noticeId string) model.SysNotice
// InsertNotice 新增公告
InsertNotice(sysNotice model.SysNotice) string
// UpdateNotice 修改公告
UpdateNotice(sysNotice model.SysNotice) int64
// DeleteNoticeByIds 批量删除公告信息
DeleteNoticeByIds(noticeIds []string) (int64, error)
}

71
src/modules/system/service/sys_notice.impl.go Normal file
View File

@@ -0,0 +1,71 @@
package service
import (
"errors"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/repository"
)
// 实例化服务层 SysNoticeImpl 结构体
var NewSysNoticeImpl = &SysNoticeImpl{
sysNoticeRepository: repository.NewSysNoticeImpl,
}
// SysNoticeImpl 公告 服务层处理
type SysNoticeImpl struct {
// 公告服务
sysNoticeRepository repository.ISysNotice
}
// SelectNoticePage 分页查询公告列表
func (r *SysNoticeImpl) SelectNoticePage(query map[string]any) map[string]any {
return r.sysNoticeRepository.SelectNoticePage(query)
}
// SelectNoticeList 查询公告列表
func (r *SysNoticeImpl) SelectNoticeList(sysNotice model.SysNotice) []model.SysNotice {
return r.sysNoticeRepository.SelectNoticeList(sysNotice)
}
// SelectNoticeById 查询公告信息
func (r *SysNoticeImpl) SelectNoticeById(noticeId string) model.SysNotice {
if noticeId == "" {
return model.SysNotice{}
}
configs := r.sysNoticeRepository.SelectNoticeByIds([]string{noticeId})
if len(configs) > 0 {
return configs[0]
}
return model.SysNotice{}
}
// InsertNotice 新增公告
func (r *SysNoticeImpl) InsertNotice(sysNotice model.SysNotice) string {
return r.sysNoticeRepository.InsertNotice(sysNotice)
}
// UpdateNotice 修改公告
func (r *SysNoticeImpl) UpdateNotice(sysNotice model.SysNotice) int64 {
return r.sysNoticeRepository.UpdateNotice(sysNotice)
}
// DeleteNoticeByIds 批量删除公告信息
func (r *SysNoticeImpl) DeleteNoticeByIds(noticeIds []string) (int64, error) {
// 检查是否存在
notices := r.sysNoticeRepository.SelectNoticeByIds(noticeIds)
if len(notices) <= 0 {
return 0, errors.New("没有权限访问公告信息数据！")
}
for _, notice := range notices {
// 检查是否为已删除
if notice.DelFlag == "1" {
return 0, errors.New(notice.NoticeID + " 公告信息已经删除！")
}
}
if len(notices) == len(noticeIds) {
rows := r.sysNoticeRepository.DeleteNoticeByIds(noticeIds)
return rows, nil
}
return 0, errors.New("删除公告信息失败！")
}

33
src/modules/system/service/sys_post.go Normal file
View File

@@ -0,0 +1,33 @@
package service
import "ems.agt/src/modules/system/model"
// ISysPost 岗位信息 服务层接口
type ISysPost interface {
// SelectPostPage 查询岗位分页数据集合
SelectPostPage(query map[string]any) map[string]any
// 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
}

103
src/modules/system/service/sys_post.impl.go Normal file
View File

@@ -0,0 +1,103 @@
package service
import (
"errors"
"fmt"
"ems.agt/src/modules/system/model"
"ems.agt/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, errors.New("没有权限访问岗位数据！")
}
for _, post := range posts {
useCount := r.sysUserPostRepository.CountUserPostByPostId(post.PostID)
if useCount > 0 {
msg := fmt.Sprintf("【%s】已分配给用户,不能删除", post.PostName)
return 0, errors.New(msg)
}
}
if len(posts) == len(postIds) {
rows := r.sysPostRepository.DeletePostByIds(postIds)
return rows, nil
}
return 0, errors.New("删除岗位信息失败！")
}
// 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 == ""
}

42
src/modules/system/service/sys_role.go Normal file
View File

@@ -0,0 +1,42 @@
package service
import "ems.agt/src/modules/system/model"
// ISysRole 角色 服务层接口
type ISysRole interface {
// SelectRolePage 根据条件分页查询角色数据
SelectRolePage(query map[string]any, dataScopeSQL string) map[string]any
// 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
}

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

@@ -0,0 +1,189 @@
package service
import (
"errors"
"fmt"
"ems.agt/src/modules/system/model"
"ems.agt/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 {
// 删除角色与菜单关联
r.sysRoleMenuRepository.DeleteRoleMenu([]string{sysRole.RoleID})
if len(sysRole.MenuIds) > 0 {
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, errors.New("没有权限访问角色数据！")
}
for _, role := range roles {
// 检查是否为已删除
if role.DelFlag == "1" {
return 0, errors.New(role.RoleID + " 角色信息已经删除！")
}
// 检查分配用户
userCount := r.sysUserRoleRepository.CountUserRoleByRoleId(role.RoleID)
if userCount > 0 {
msg := fmt.Sprintf("【%s】已分配给用户,不能删除", role.RoleName)
return 0, errors.New(msg)
}
}
if len(roles) == len(roleIds) {
// 删除角色与菜单关联
r.sysRoleMenuRepository.DeleteRoleMenu(roleIds)
// 删除角色与部门关联
r.sysRoleDeptRepository.DeleteRoleDept(roleIds)
rows := r.sysRoleRepository.DeleteRoleByIds(roleIds)
return rows, nil
}
return 0, errors.New("删除角色信息失败！")
}
// 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)
}

45
src/modules/system/service/sys_user.go Normal file
View File

@@ -0,0 +1,45 @@
package service
import "ems.agt/src/modules/system/model"
// ISysUser 用户 服务层接口
type ISysUser interface {
// SelectUserPage 根据条件分页查询用户列表
SelectUserPage(query map[string]any, dataScopeSQL string) map[string]any
// 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
// ImportUser 导入用户数据
ImportUser(rows []map[string]string, isUpdateSupport bool, operName string) string
}

322
src/modules/system/service/sys_user.impl.go Normal file
View File

@@ -0,0 +1,322 @@
package service
import (
"errors"
"fmt"
"strings"
"ems.agt/src/framework/constants/admin"
"ems.agt/src/framework/constants/common"
"ems.agt/src/framework/utils/regular"
"ems.agt/src/modules/system/model"
"ems.agt/src/modules/system/repository"
)
// 实例化服务层 SysUserImpl 结构体
var NewSysUserImpl = &SysUserImpl{
sysUserRepository: repository.NewSysUserImpl,
sysUserRoleRepository: repository.NewSysUserRoleImpl,
sysUserPostRepository: repository.NewSysUserPostImpl,
sysDictDataService: NewSysDictDataImpl,
sysConfigService: NewSysConfigImpl,
}
// SysUserImpl 用户 服务层处理
type SysUserImpl struct {
// 用户服务
sysUserRepository repository.ISysUser
// 用户与角色服务
sysUserRoleRepository repository.ISysUserRole
// 用户与岗位服务
sysUserPostRepository repository.ISysUserPost
// 字典数据服务
sysDictDataService ISysDictData
// 参数配置服务
sysConfigService ISysConfig
}
// 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 []model.SysUser{}
}
// 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, errors.New("没有权限访问用户数据！")
}
if len(users) == len(userIds) {
// 删除用户与角色关联
r.sysUserRoleRepository.DeleteUserRole(userIds)
// 删除用户与岗位关联
r.sysUserPostRepository.DeleteUserPost(userIds)
// ... 注意其他userId进行关联的表
// 删除用户
rows := r.sysUserRepository.DeleteUserByIds(userIds)
return rows, nil
}
return 0, errors.New("删除用户信息失败！")
}
// 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 == ""
}
// ImportUser 导入用户数据
func (r *SysUserImpl) ImportUser(rows []map[string]string, isUpdateSupport bool, operName string) string {
// 读取默认初始密码
initPassword := r.sysConfigService.SelectConfigValueByKey("sys.user.initPassword")
// 读取用户性别字典数据
dictSysUserSex := r.sysDictDataService.SelectDictDataByType("sys_user_sex")
// 导入记录
successNum := 0
failureNum := 0
successMsgArr := []string{}
failureMsgArr := []string{}
mustItemArr := []string{"C", "D"}
for _, row := range rows {
// 检查必填列
ownItem := true
for _, item := range mustItemArr {
if v, ok := row[item]; !ok || v == "" {
ownItem = false
break
}
}
if !ownItem {
mustItemArrStr := strings.Join(mustItemArr, "、")
failureNum++
failureMsgArr = append(failureMsgArr, fmt.Sprintf("表格中必填列表项，%s}", mustItemArrStr))
continue
}
// 用户性别转值
sysUserSex := "0"
for _, v := range dictSysUserSex {
if row["G"] == v.DictLabel {
sysUserSex = v.DictValue
break
}
}
sysUserStatus := common.STATUS_NO
if row["H"] == "正常" {
sysUserStatus = common.STATUS_YES
}
// 构建用户实体信息
newSysUser := model.SysUser{
UserType: "sys",
Password: initPassword,
DeptID: row["B"],
UserName: row["C"],
NickName: row["D"],
PhoneNumber: row["F"],
Email: row["E"],
Status: sysUserStatus,
Sex: sysUserSex,
}
// 检查手机号码格式并判断是否唯一
if newSysUser.PhoneNumber != "" {
if regular.ValidMobile(newSysUser.PhoneNumber) {
uniquePhone := r.CheckUniquePhone(newSysUser.PhoneNumber, "")
if !uniquePhone {
msg := fmt.Sprintf("序号：%s 手机号码 %s 已存在", row["A"], row["F"])
failureNum++
failureMsgArr = append(failureMsgArr, msg)
continue
}
} else {
msg := fmt.Sprintf("序号：%s 手机号码 %s 格式错误", row["A"], row["F"])
failureNum++
failureMsgArr = append(failureMsgArr, msg)
continue
}
}
// 检查邮箱格式并判断是否唯一
if newSysUser.Email != "" {
if regular.ValidEmail(newSysUser.Email) {
uniqueEmail := r.CheckUniqueEmail(newSysUser.Email, "")
if !uniqueEmail {
msg := fmt.Sprintf("序号：%s 用户邮箱 %s 已存在", row["A"], row["E"])
failureNum++
failureMsgArr = append(failureMsgArr, msg)
continue
}
} else {
msg := fmt.Sprintf("序号：%s 用户邮箱 %s 格式错误", row["A"], row["E"])
failureNum++
failureMsgArr = append(failureMsgArr, msg)
continue
}
}
// 验证是否存在这个用户
userInfo := r.sysUserRepository.SelectUserByUserName(newSysUser.UserName)
if userInfo.UserName != newSysUser.UserName {
newSysUser.CreateBy = operName
insertId := r.InsertUser(newSysUser)
if insertId != "" {
msg := fmt.Sprintf("序号：%s 登录名称 %s 导入成功", row["A"], row["C"])
successNum++
successMsgArr = append(successMsgArr, msg)
} else {
msg := fmt.Sprintf("序号：%s 登录名称 %s 导入失败", row["A"], row["E"])
failureNum++
failureMsgArr = append(failureMsgArr, msg)
}
continue
}
// 如果用户已存在 同时 是否更新支持
if userInfo.UserName == newSysUser.UserName && isUpdateSupport {
newSysUser.UserID = userInfo.UserID
newSysUser.UpdateBy = operName
rows := r.UpdateUser(newSysUser)
if rows > 0 {
msg := fmt.Sprintf("序号：%s 登录名称 %s 更新成功", row["A"], row["C"])
successNum++
successMsgArr = append(successMsgArr, msg)
} else {
msg := fmt.Sprintf("序号：%s 登录名称 %s 更新失败", row["A"], row["E"])
failureNum++
failureMsgArr = append(failureMsgArr, msg)
}
continue
}
}
if failureNum > 0 {
failureMsgArr = append([]string{fmt.Sprintf("很抱歉，导入失败！共 %d 条数据格式不正确，错误如下：", failureNum)}, failureMsgArr...)
return strings.Join(failureMsgArr, "<br/>")
}
successMsgArr = append([]string{fmt.Sprintf("恭喜您，数据已全部导入成功！共 %d 条，数据如下：", successNum)}, successMsgArr...)
return strings.Join(successMsgArr, "<br/>")
}

466
src/modules/system/system.go Normal file
View File

@@ -0,0 +1,466 @@
package system
import (
"ems.agt/src/framework/logger"
"ems.agt/src/framework/middleware"
"ems.agt/src/framework/middleware/collectlogs"
"ems.agt/src/framework/middleware/repeat"
"ems.agt/src/modules/system/controller"
"ems.agt/src/modules/system/service"
"github.com/gin-gonic/gin"
)
// Setup 模块路由注册
func Setup(router *gin.Engine) {
logger.Infof("开始加载 ====> system 模块路由")
// 启动时需要的初始参数
InitLoad()
// 参数配置信息
sysConfigGroup := router.Group("/system/config")
{
sysConfigGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:list"}}),
controller.NewSysConfig.List,
)
sysConfigGroup.GET("/:configId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:query"}}),
controller.NewSysConfig.Info,
)
sysConfigGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("参数配置信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysConfig.Add,
)
sysConfigGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("参数配置信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysConfig.Edit,
)
sysConfigGroup.DELETE("/:configIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("参数配置信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysConfig.Remove,
)
sysConfigGroup.PUT("/refreshCache",
repeat.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("参数配置信息", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysConfig.RefreshCache,
)
sysConfigGroup.GET("/configKey/:configKey", controller.NewSysConfig.ConfigKey)
sysConfigGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:config:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("参数配置信息", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysConfig.Export,
)
}
// 部门信息
sysDeptGroup := router.Group("/system/dept")
{
sysDeptGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:list"}}),
controller.NewSysDept.List,
)
sysDeptGroup.GET("/:deptId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:query"}}),
controller.NewSysDept.Info,
)
sysDeptGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("部门信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysDept.Add,
)
sysDeptGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("部门信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysDept.Edit,
)
sysDeptGroup.DELETE("/:deptId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("部门信息", collectlogs.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",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:list", "system:user:list"}}),
controller.NewSysDept.TreeSelect,
)
sysDeptGroup.GET("/roleDeptTreeSelect/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dept:query"}}),
controller.NewSysDept.RoleDeptTreeSelect,
)
}
// 字典数据信息
sysDictDataGroup := router.Group("/system/dict/data")
{
sysDictDataGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:list"}}),
controller.NewSysDictData.List,
)
sysDictDataGroup.GET("/:dictCode",
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("字典数据信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysDictData.Add,
)
sysDictDataGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("字典数据信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysDictData.Edit,
)
sysDictDataGroup.DELETE("/:dictCodes",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("字典数据信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysDictData.Remove,
)
sysDictDataGroup.GET("/type/:dictType",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:query"}}),
controller.NewSysDictData.DictType,
)
sysDictDataGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("字典类型信息", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysDictData.Export,
)
}
// 字典类型信息
sysDictTypeGroup := router.Group("/system/dict/type")
{
sysDictTypeGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:list"}}),
controller.NewSysDictType.List,
)
sysDictTypeGroup.GET("/:dictId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:query"}}),
controller.NewSysDictType.Info,
)
sysDictTypeGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("字典类型信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysDictType.Add,
)
sysDictTypeGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("字典类型信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysDictType.Edit,
)
sysDictTypeGroup.DELETE("/:dictIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("字典类型信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysDictType.Remove,
)
sysDictTypeGroup.PUT("/refreshCache",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("字典类型信息", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysDictType.RefreshCache,
)
sysDictTypeGroup.GET("/getDictOptionselect",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:query"}}),
controller.NewSysDictType.DictOptionselect,
)
sysDictTypeGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:dict:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("字典类型信息", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysDictType.Export,
)
}
// 菜单信息
sysMenuGroup := router.Group("/system/menu")
{
sysMenuGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list"}}),
controller.NewSysMenu.List,
)
sysMenuGroup.GET("/:menuId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:query"}}),
controller.NewSysMenu.Info,
)
sysMenuGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("菜单信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysMenu.Add,
)
sysMenuGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("菜单信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysMenu.Edit,
)
sysMenuGroup.DELETE("/:menuId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("菜单信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysMenu.Remove,
)
sysMenuGroup.GET("/treeSelect",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list"}}),
controller.NewSysMenu.TreeSelect,
)
sysMenuGroup.GET("/roleMenuTreeSelect/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:menu:list"}}),
controller.NewSysMenu.RoleMenuTreeSelect,
)
}
// 通知公告信息
sysNoticeGroup := router.Group("/system/notice")
{
sysNoticeGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:notice:list"}}),
controller.NewSysNotice.List,
)
sysNoticeGroup.GET("/:noticeId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:notice:query"}}),
controller.NewSysNotice.Info,
)
sysNoticeGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:notice:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("参数配置信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysNotice.Add,
)
sysNoticeGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:notice:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("参数配置信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysNotice.Edit,
)
sysNoticeGroup.DELETE("/:noticeIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:notice:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("参数配置信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysNotice.Remove,
)
}
// 岗位信息
sysPostGroup := router.Group("/system/post")
{
sysPostGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:list"}}),
controller.NewSysPost.List,
)
sysPostGroup.GET("/:postId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:query"}}),
controller.NewSysPost.Info,
)
sysPostGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("岗位信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysPost.Add,
)
sysPostGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("岗位信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysPost.Edit,
)
sysPostGroup.DELETE("/:postIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("岗位信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysPost.Remove,
)
sysPostGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:post:export"}}),
controller.NewSysPost.Export,
)
}
// 个人信息
sysProfileGroup := router.Group("/system/user/profile")
{
sysProfileGroup.GET("",
middleware.PreAuthorize(nil),
controller.NewSysProfile.Info,
)
sysProfileGroup.PUT("",
middleware.PreAuthorize(nil),
controller.NewSysProfile.UpdateProfile,
)
sysProfileGroup.PUT("/updatePwd",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("个人信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.UpdatePwd,
)
sysProfileGroup.POST("/avatar",
middleware.PreAuthorize(nil),
collectlogs.OperateLog(collectlogs.OptionNew("用户头像", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysProfile.Avatar,
)
}
// 角色信息
sysRoleGroup := router.Group("/system/role")
{
sysRoleGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:list"}}),
controller.NewSysRole.List,
)
sysRoleGroup.GET("/:roleId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:query"}}),
controller.NewSysRole.Info,
)
sysRoleGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("角色信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysRole.Add,
)
sysRoleGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("角色信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.Edit,
)
sysRoleGroup.DELETE("/:roleIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("角色信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysRole.Remove,
)
sysRoleGroup.PUT("/changeStatus",
repeat.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:role:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("角色信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.Status,
)
sysRoleGroup.PUT("/dataScope",
repeat.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("角色信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysRole.DataScope,
)
sysRoleGroup.GET("/authUser/allocatedList",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:list"}}),
controller.NewSysRole.AuthUserAllocatedList,
)
sysRoleGroup.PUT("/authUser/checked",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("角色信息", collectlogs.BUSINESS_TYPE_GRANT)),
controller.NewSysRole.AuthUserChecked,
)
sysRoleGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("角色信息", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysRole.Export,
)
}
// 用户信息
sysUserGroup := router.Group("/system/user")
{
sysUserGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:list"}}),
controller.NewSysUser.List,
)
sysUserGroup.GET("/:userId",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:query"}}),
controller.NewSysUser.Info,
)
sysUserGroup.POST("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:add"}}),
collectlogs.OperateLog(collectlogs.OptionNew("用户信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysUser.Add,
)
sysUserGroup.PUT("",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("用户信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.Edit,
)
sysUserGroup.DELETE("/:userIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("用户信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysUser.Remove,
)
sysUserGroup.PUT("/resetPwd",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:resetPwd"}}),
collectlogs.OperateLog(collectlogs.OptionNew("用户信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.ResetPwd,
)
sysUserGroup.PUT("/changeStatus",
repeat.RepeatSubmit(5),
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:edit"}}),
collectlogs.OperateLog(collectlogs.OptionNew("用户信息", collectlogs.BUSINESS_TYPE_UPDATE)),
controller.NewSysUser.Status,
)
sysUserGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("用户信息", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysUser.Export,
)
sysUserGroup.GET("/importTemplate",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:import"}}),
controller.NewSysUser.Template,
)
sysUserGroup.POST("/importData",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:user:import"}}),
collectlogs.OperateLog(collectlogs.OptionNew("用户信息", collectlogs.BUSINESS_TYPE_INSERT)),
controller.NewSysUser.ImportData,
)
}
// 操作日志记录信息
sysOperLogGroup := router.Group("/system/log/operate")
{
sysOperLogGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:list"}}),
controller.NewSysLogOperate.List,
)
sysOperLogGroup.DELETE("/:operIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("操作日志", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysLogOperate.Remove,
)
sysOperLogGroup.DELETE("/clean",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("操作日志", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogOperate.Clean,
)
sysOperLogGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:operate:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("操作日志", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysLogOperate.Export,
)
}
// 系统登录日志信息
sysLogininforGroup := router.Group("/system/log/login")
{
sysLogininforGroup.GET("/list",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:list"}}),
controller.NewSysLogLogin.List,
)
sysLogininforGroup.DELETE("/:loginIds",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("系统登录信息", collectlogs.BUSINESS_TYPE_DELETE)),
controller.NewSysLogLogin.Remove,
)
sysLogininforGroup.DELETE("/clean",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:remove"}}),
collectlogs.OperateLog(collectlogs.OptionNew("系统登录信息", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogLogin.Clean,
)
sysLogininforGroup.PUT("/unlock/:userName",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:unlock"}}),
collectlogs.OperateLog(collectlogs.OptionNew("系统登录信息", collectlogs.BUSINESS_TYPE_CLEAN)),
controller.NewSysLogLogin.Unlock,
)
sysLogininforGroup.POST("/export",
middleware.PreAuthorize(map[string][]string{"hasPerms": {"system:log:login:export"}}),
collectlogs.OperateLog(collectlogs.OptionNew("系统登录信息", collectlogs.BUSINESS_TYPE_EXPORT)),
controller.NewSysLogLogin.Export,
)
}
}
// InitLoad 初始参数
func InitLoad() {
// 启动时，刷新缓存-参数配置
service.NewSysConfigImpl.ResetConfigCache()
// 启动时，刷新缓存-字典类型数据
service.NewSysDictTypeImpl.ResetDictCache()
}