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

Merge branch 'main' into multi-tenant

Browse Source
This commit is contained in:
simonzhangsz
2024-10-31 17:50:10 +08:00
parent d26300e1e2 e335c75b53
commit ff6caf2ca5
229 changed files with 11395 additions and 11870 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -214,7 +214,7 @@ func (s *SysConfigController) ConfigKey(c *gin.Context) {
}
key := s.sysConfigService.SelectConfigValueByKey(configKey)
if key != "" {
c.JSON(200, result.OkData(key))
c.JSON(200, result.OkData(i18n.TKey(language, key)))
return
}
c.JSON(200, result.Err(nil))

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

@@ -20,18 +20,16 @@ import (
// 实例化控制层 SysDictDataController 结构体
var NewSysDictData = &SysDictDataController{
sysDictDataService: service.NewSysDictDataImpl,
sysDictTypeService: service.NewSysDictTypeImpl,
sysDictDataService: service.NewSysDictData,
sysDictTypeService: service.NewSysDictType,
}
// 字典类型对应的字典数据信息
//
// PATH /system/dict/data
type SysDictDataController struct {
// 字典数据服务
sysDictDataService service.ISysDictData
// 字典类型服务
sysDictTypeService service.ISysDictType
sysDictDataService *service.SysDictData // 字典数据服务
sysDictTypeService *service.SysDictType // 字典类型服务
}
// 字典数据列表

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

@@ -21,15 +21,14 @@ import (
// 实例化控制层 SysDictTypeController 结构体
var NewSysDictType = &SysDictTypeController{
sysDictTypeService: service.NewSysDictTypeImpl,
sysDictTypeService: service.NewSysDictType,
}
// 字典类型信息
//
// PATH /system/dict/type
type SysDictTypeController struct {
// 字典类型服务
sysDictTypeService service.ISysDictType
sysDictTypeService *service.SysDictType // 字典类型服务
}
// 字典类型列表

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

@@ -22,7 +22,7 @@ import (
// 实例化控制层 SysLogLoginController 结构体
var NewSysLogLogin = &SysLogLoginController{
sysLogLoginService: service.NewSysLogLoginImpl,
accountService: commonService.NewAccountImpl,
accountService: commonService.NewAccount,
}
// 系统登录日志信息
@@ -31,8 +31,7 @@ var NewSysLogLogin = &SysLogLoginController{
type SysLogLoginController struct {
// 系统登录日志服务
sysLogLoginService service.ISysLogLogin
// 账号身份操作服务
accountService commonService.IAccount
accountService *commonService.Account // 账号身份操作服务
}
// 系统登录日志列表

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

@@ -157,6 +157,7 @@ func (s *SysProfileController) UpdateProfile(c *gin.Context) {
PhoneNumber: body.PhoneNumber,
Email: body.Email,
Sex: body.Sex,
Remark: loginUser.User.Remark,
}
rows := s.sysUserService.UpdateUser(sysUser)
if rows > 0 {
@@ -229,9 +230,13 @@ func (s *SysProfileController) UpdatePwd(c *gin.Context) {
// 修改新密码
sysUser := model.SysUser{
UserID: userId,
UpdateBy: userName,
Password: body.NewPassword,
UserID: userId,
UpdateBy: userName,
Password: body.NewPassword,
Sex: user.Sex,
PhoneNumber: user.PhoneNumber,
Email: user.Email,
Remark: user.Remark,
}
rows := s.sysUserService.UpdateUser(sysUser)
if rows > 0 {
@@ -268,9 +273,13 @@ func (s *SysProfileController) Avatar(c *gin.Context) {
// 更新头像地址
sysUser := model.SysUser{
UserID: loginUser.UserID,
UpdateBy: loginUser.User.UserName,
Avatar: filePath,
UserID: loginUser.UserID,
UpdateBy: loginUser.User.UserName,
Avatar: filePath,
Sex: loginUser.User.Sex,
PhoneNumber: loginUser.User.PhoneNumber,
Email: loginUser.User.Email,
Remark: loginUser.User.Remark,
}
rows := s.sysUserService.UpdateUser(sysUser)
if rows > 0 {

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

@@ -24,7 +24,7 @@ import (
var NewSysRole = &SysRoleController{
sysRoleService: service.NewSysRoleImpl,
sysUserService: service.NewSysUserImpl,
sysDictDataService: service.NewSysDictDataImpl,
sysDictDataService: service.NewSysDictData,
}
// 角色信息
@@ -34,9 +34,8 @@ type SysRoleController struct {
// 角色服务
sysRoleService service.ISysRole
// 用户服务
sysUserService service.ISysUser
// 字典数据服务
sysDictDataService service.ISysDictData
sysUserService service.ISysUser
sysDictDataService *service.SysDictData // 字典数据服务
}
// 角色列表

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

@@ -28,7 +28,7 @@ var NewSysUser = &SysUserController{
sysUserService: service.NewSysUserImpl,
sysRoleService: service.NewSysRoleImpl,
sysPostService: service.NewSysPostImpl,
sysDictDataService: service.NewSysDictDataImpl,
sysDictDataService: service.NewSysDictData,
sysConfigService: service.NewSysConfigImpl,
}
@@ -41,9 +41,8 @@ type SysUserController struct {
// 角色服务
sysRoleService service.ISysRole
// 岗位服务
sysPostService service.ISysPost
// 字典数据服务
sysDictDataService service.ISysDictData
sysPostService service.ISysPost
sysDictDataService *service.SysDictData // 字典数据服务
// 参数配置服务
sysConfigService service.ISysConfig
}

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

@@ -13,7 +13,7 @@ import (
)
// 实例化数据层 SysDictDataImpl 结构体
var NewSysDictDataImpl = &SysDictDataImpl{
var NewSysDictData = &SysDictDataImpl{
selectSql: `select
dict_code, dict_sort, dict_label, dict_value, dict_type, tag_class, tag_type, status, create_by, create_time, remark
from sys_dict_data`,

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

@@ -13,7 +13,7 @@ import (
)
// 实例化数据层 SysDictTypeImpl 结构体
var NewSysDictTypeImpl = &SysDictTypeImpl{
var NewSysDictType = &SysDictTypeImpl{
selectSql: `select
dict_id, dict_name, dict_type, status, create_by, create_time, remark
from sys_dict_type`,

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

@@ -1,33 +1,114 @@
package service
import "be.ems/src/modules/system/model"
import (
"fmt"
// ISysDictData 字典类型数据 服务层接口
type ISysDictData interface {
// SelectDictDataPage 根据条件分页查询字典数据
SelectDictDataPage(query map[string]any) map[string]any
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 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
// 实例化服务层 SysDictData 结构体
var NewSysDictData = &SysDictData{
sysDictDataRepository: repository.NewSysDictData,
sysDictTypeService: NewSysDictType,
}
// SysDictData 字典类型数据 服务层处理
type SysDictData struct {
sysDictDataRepository repository.ISysDictData // 字典数据服务
sysDictTypeService *SysDictType // 字典类型服务
}
// SelectDictDataPage 根据条件分页查询字典数据
func (r *SysDictData) SelectDictDataPage(query map[string]any) map[string]any {
return r.sysDictDataRepository.SelectDictDataPage(query)
}
// SelectDictDataList 根据条件查询字典数据
func (r *SysDictData) SelectDictDataList(sysDictData model.SysDictData) []model.SysDictData {
return r.sysDictDataRepository.SelectDictDataList(sysDictData)
}
// SelectDictDataByCode 根据字典数据编码查询信息
func (r *SysDictData) 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 *SysDictData) SelectDictDataByType(dictType string) []model.SysDictData {
return r.sysDictTypeService.DictDataCache(dictType)
}
// CheckUniqueDictLabel 校验字典标签是否唯一
func (r *SysDictData) CheckUniqueDictLabel(dictType, dictLabel, dictCode string) bool {
uniqueId := r.sysDictDataRepository.CheckUniqueDictData(model.SysDictData{
DictType: dictType,
DictLabel: dictLabel,
})
if uniqueId == dictCode {
return true
}
return uniqueId == ""
}
// CheckUniqueDictValue 校验字典键值是否唯一
func (r *SysDictData) CheckUniqueDictValue(dictType, dictValue, dictCode string) bool {
uniqueId := r.sysDictDataRepository.CheckUniqueDictData(model.SysDictData{
DictType: dictType,
DictValue: dictValue,
})
if uniqueId == dictCode {
return true
}
return uniqueId == ""
}
// DeleteDictDataByCodes 批量删除字典数据信息
func (r *SysDictData) DeleteDictDataByCodes(dictCodes []string) (int64, error) {
// 检查是否存在
dictDatas := r.sysDictDataRepository.SelectDictDataByCodes(dictCodes)
if len(dictDatas) <= 0 {
// 没有可访问字典编码数据！
return 0, fmt.Errorf("there is no accessible dictionary-encoded data")
}
if len(dictDatas) == len(dictCodes) {
for _, v := range dictDatas {
// 刷新缓存
r.sysDictTypeService.ClearDictCache(v.DictType)
r.sysDictTypeService.LoadingDictCache(v.DictType)
}
rows := r.sysDictDataRepository.DeleteDictDataByCodes(dictCodes)
return rows, nil
}
// 删除字典数据信息失败！
return 0, fmt.Errorf("failed to delete dictionary data information")
}
// InsertDictData 新增字典数据信息
func (r *SysDictData) InsertDictData(sysDictData model.SysDictData) string {
insertId := r.sysDictDataRepository.InsertDictData(sysDictData)
if insertId != "" {
// 刷新缓存
r.sysDictTypeService.ClearDictCache(sysDictData.DictType)
r.sysDictTypeService.LoadingDictCache(sysDictData.DictType)
}
return insertId
}
// UpdateDictData 修改字典数据信息
func (r *SysDictData) UpdateDictData(sysDictData model.SysDictData) int64 {
rows := r.sysDictDataRepository.UpdateDictData(sysDictData)
if rows > 0 {
// 刷新缓存
r.sysDictTypeService.ClearDictCache(sysDictData.DictType)
r.sysDictTypeService.LoadingDictCache(sysDictData.DictType)
}
return rows
}

116
src/modules/system/service/sys_dict_data.impl.go
View File

@@ -1,116 +0,0 @@
package service
import (
"fmt"
"be.ems/src/modules/system/model"
"be.ems/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, fmt.Errorf("there is no accessible dictionary-encoded data")
}
if len(dictDatas) == len(dictCodes) {
for _, v := range dictDatas {
// 刷新缓存
r.sysDictTypeService.ClearDictCache(v.DictType)
r.sysDictTypeService.LoadingDictCache(v.DictType)
}
rows := r.sysDictDataRepository.DeleteDictDataByCodes(dictCodes)
return rows, nil
}
// 删除字典数据信息失败！
return 0, fmt.Errorf("failed to delete dictionary data information")
}
// InsertDictData 新增字典数据信息
func (r *SysDictDataImpl) InsertDictData(sysDictData model.SysDictData) string {
insertId := r.sysDictDataRepository.InsertDictData(sysDictData)
if insertId != "" {
// 刷新缓存
r.sysDictTypeService.ClearDictCache(sysDictData.DictType)
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.ClearDictCache(sysDictData.DictType)
r.sysDictTypeService.LoadingDictCache(sysDictData.DictType)
}
return rows
}

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

@@ -1,45 +1,212 @@
package service
import "be.ems/src/modules/system/model"
import (
"encoding/json"
"fmt"
// ISysDictType 字典类型 服务层接口
type ISysDictType interface {
// SelectDictTypePage 根据条件分页查询字典类型
SelectDictTypePage(query map[string]any) map[string]any
"be.ems/src/framework/constants/cachekey"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/redis"
"be.ems/src/modules/system/model"
"be.ems/src/modules/system/repository"
)
// 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
// 实例化服务层 SysDictType 结构体
var NewSysDictType = &SysDictType{
sysDictTypeRepository: repository.NewSysDictType,
sysDictDataRepository: repository.NewSysDictData,
}
// SysDictType 字典类型 服务层处理
type SysDictType struct {
// 字典类型服务
sysDictTypeRepository repository.ISysDictType
// 字典数据服务
sysDictDataRepository repository.ISysDictData
}
// SelectDictTypePage 根据条件分页查询字典类型
func (r *SysDictType) SelectDictTypePage(query map[string]any) map[string]any {
return r.sysDictTypeRepository.SelectDictTypePage(query)
}
// SelectDictTypeList 根据条件查询字典类型
func (r *SysDictType) SelectDictTypeList(sysDictType model.SysDictType) []model.SysDictType {
return r.sysDictTypeRepository.SelectDictTypeList(sysDictType)
}
// SelectDictTypeByID 根据字典类型ID查询信息
func (r *SysDictType) 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 *SysDictType) SelectDictTypeByType(dictType string) model.SysDictType {
return r.sysDictTypeRepository.SelectDictTypeByType(dictType)
}
// CheckUniqueDictName 校验字典名称是否唯一
func (r *SysDictType) CheckUniqueDictName(dictName, dictID string) bool {
uniqueId := r.sysDictTypeRepository.CheckUniqueDictType(model.SysDictType{
DictName: dictName,
})
if uniqueId == dictID {
return true
}
return uniqueId == ""
}
// CheckUniqueDictType 校验字典类型是否唯一
func (r *SysDictType) CheckUniqueDictType(dictType, dictID string) bool {
uniqueId := r.sysDictTypeRepository.CheckUniqueDictType(model.SysDictType{
DictType: dictType,
})
if uniqueId == dictID {
return true
}
return uniqueId == ""
}
// InsertDictType 新增字典类型信息
func (r *SysDictType) InsertDictType(sysDictType model.SysDictType) string {
insertId := r.sysDictTypeRepository.InsertDictType(sysDictType)
if insertId != "" {
r.LoadingDictCache(sysDictType.DictType)
}
return insertId
}
// UpdateDictType 修改字典类型信息
func (r *SysDictType) 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 *SysDictType) DeleteDictTypeByIDs(dictIDs []string) (int64, error) {
// 检查是否存在
dictTypes := r.sysDictTypeRepository.SelectDictTypeByIDs(dictIDs)
if len(dictTypes) <= 0 {
// 没有可访问字典类型数据！
return 0, fmt.Errorf("there is no accessible dictionary type data")
}
for _, v := range dictTypes {
// 字典类型下级含有数据
useCount := r.sysDictDataRepository.CountDictDataByType(v.DictType)
if useCount > 0 {
// 【%s】存在字典数据,不能删除
return 0, fmt.Errorf("[%s] dictionary data exists and cannot be deleted", v.DictName)
}
// 清除缓存
r.ClearDictCache(v.DictType)
}
if len(dictTypes) == len(dictIDs) {
rows := r.sysDictTypeRepository.DeleteDictTypeByIDs(dictIDs)
return rows, nil
}
// 删除字典数据信息失败！
return 0, fmt.Errorf("failed to delete dictionary data information")
}
// ResetDictCache 重置字典缓存数据
func (r *SysDictType) ResetDictCache() {
r.ClearDictCache("*")
r.LoadingDictCache("")
}
// getCacheKey 组装缓存key
func (r *SysDictType) getDictCache(dictType string) string {
return cachekey.SYS_DICT_KEY + dictType
}
// LoadingDictCache 加载字典缓存数据
func (r *SysDictType) 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 *SysDictType) 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 *SysDictType) DictDataCache(dictType string) []model.SysDictData {
data := []model.SysDictData{}
key := r.getDictCache(dictType)
jsonStr, _ := redis.Get("", key)
if len(jsonStr) > 7 {
err := json.Unmarshal([]byte(jsonStr), &data)
if err != nil {
data = []model.SysDictData{}
}
} else {
data = r.sysDictDataRepository.SelectDictDataList(model.SysDictData{
Status: common.STATUS_YES,
DictType: dictType,
})
if len(data) > 0 {
redis.Del("", key)
values, _ := json.Marshal(data)
redis.Set("", key, string(values))
}
}
return data
}

212
src/modules/system/service/sys_dict_type.impl.go
View File

@@ -1,212 +0,0 @@
package service
import (
"encoding/json"
"fmt"
"be.ems/src/framework/constants/cachekey"
"be.ems/src/framework/constants/common"
"be.ems/src/framework/redis"
"be.ems/src/modules/system/model"
"be.ems/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, fmt.Errorf("there is no accessible dictionary type data")
}
for _, v := range dictTypes {
// 字典类型下级含有数据
useCount := r.sysDictDataRepository.CountDictDataByType(v.DictType)
if useCount > 0 {
// 【%s】存在字典数据,不能删除
return 0, fmt.Errorf("[%s] dictionary data exists and cannot be deleted", v.DictName)
}
// 清除缓存
r.ClearDictCache(v.DictType)
}
if len(dictTypes) == len(dictIDs) {
rows := r.sysDictTypeRepository.DeleteDictTypeByIDs(dictIDs)
return rows, nil
}
// 删除字典数据信息失败！
return 0, fmt.Errorf("failed to delete dictionary data information")
}
// 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
}

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

@@ -479,5 +479,5 @@ func InitLoad() {
// 启动时，刷新缓存-参数配置
service.NewSysConfigImpl.ResetConfigCache()
// 启动时，刷新缓存-字典类型数据
service.NewSysDictTypeImpl.ResetDictCache()
service.NewSysDictType.ResetDictCache()
}