odboy/cutego
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init...

Browse Source
This commit is contained in:
odboy
2022-03-01 13:50:13 +08:00
parent 8eab9943e9
commit d2cabd7d58
113 changed files with 7925 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/service/config_service.go
+64
View File
@@ -0,0 +1,64 @@
package service
import (
"cutego/core/api/v1/request"
cache2 "cutego/core/cache"
"cutego/core/dao"
"cutego/core/entity"
)
type ConfigService struct {
configDao dao.ConfigDao
}
// GetConfigKey 根据键名查询参数配置信息
func (s ConfigService) GetConfigKey(param string) *entity.SysConfig {
// 从缓存中取出数据判断是否存在, 存在直接使用, 不存在就从数据库查询
val := cache2.GetRedisConfig(param)
if val != nil {
return val
}
configKey := s.configDao.SelectByConfigKey(param)
cache2.SetRedisConfig(*configKey)
return configKey
}
// FindPage 分页查询数据
func (s ConfigService) FindPage(query request.ConfigQuery) (*[]entity.SysConfig, int64) {
return s.configDao.SelectPage(query)
}
// CheckConfigKeyUnique 校验是否存在
func (s ConfigService) CheckConfigKeyUnique(config entity.SysConfig) bool {
return s.configDao.CheckConfigKeyUnique(config) > 0
}
// Save 添加数据
func (s ConfigService) Save(config entity.SysConfig) int64 {
return s.configDao.Insert(config)
}
// GetInfo 查询数据
func (s ConfigService) GetInfo(id int64) *entity.SysConfig {
return s.configDao.SelectById(id)
}
// Edit 修改数据
func (s ConfigService) Edit(config entity.SysConfig) int64 {
return s.configDao.Update(config)
}
// Remove 批量删除
func (s ConfigService) Remove(list []int64) bool {
return s.configDao.Delete(list)
}
// CheckConfigByIds 根据id集合查询
func (s ConfigService) CheckConfigByIds(list []int64) *[]entity.SysConfig {
return s.configDao.CheckConfigByIds(list)
}
// FindAll 查询所有数据
func (s ConfigService) FindAll() *[]entity.SysConfig {
return s.configDao.SelectAll()
}
core/service/cron_job_service.go
+41
View File
@@ -0,0 +1,41 @@
package service
import (
"cutego/core/api/v1/request"
"cutego/core/dao"
"cutego/core/entity"
)
type CronJobService struct {
cronJobService dao.CronJobDao
}
// FindPage 分页查询数据
func (s CronJobService) FindPage(query request.CronJobQuery) ([]entity.SysCronJob, int64) {
return s.cronJobService.SelectPage(query)
}
// Save 添加数据
func (s CronJobService) Save(config entity.SysCronJob) int64 {
return s.cronJobService.Insert(config)
}
// GetInfo 查询数据
func (s CronJobService) GetInfo(id int64) *entity.SysCronJob {
return s.cronJobService.SelectById(id)
}
// GetInfo 查询数据
func (s CronJobService) GetInfoByAlias(funcAlias string) *entity.SysCronJob {
return s.cronJobService.SelectByFuncAlias(funcAlias)
}
// Edit 修改数据
func (s CronJobService) Edit(config entity.SysCronJob) int64 {
return s.cronJobService.Update(config)
}
// Remove 批量删除
func (s CronJobService) Remove(list []int64) bool {
return s.cronJobService.Delete(list)
}
core/service/dept_service.go
+67
View File
@@ -0,0 +1,67 @@
package service
import (
"cutego/core/api/v1/request"
dao2 "cutego/core/dao"
"cutego/core/entity"
)
type DeptService struct {
deptDao dao2.DeptDao
roleDao dao2.RoleDao
}
// TreeSelect 根据条件查询部门树
func (s DeptService) FindTreeSelect(query request.DeptQuery) *[]entity.SysDept {
treeSelect := s.deptDao.SelectTree(query)
return treeSelect
}
// FindDeptListByRoleId 根据角色ID查询部门树信息
func (s DeptService) FindDeptListByRoleId(id int64) *[]int64 {
role := s.roleDao.SelectRoleByRoleId(id)
return s.deptDao.SelectDeptListByRoleId(id, role.DeptCheckStrictly)
}
// FindDeptList 查询部门列表
func (s DeptService) FindDeptList(query request.DeptQuery) *[]entity.SysDept {
return s.deptDao.GetList(query)
}
// GetDeptById 根据部门编号获取详细信息
func (s DeptService) GetDeptById(id int) *entity.SysDept {
return s.deptDao.SelectDeptById(id)
}
// Save 添加部门数据
func (s DeptService) Save(dept entity.SysDept) int64 {
return s.deptDao.Insert(dept)
}
// CheckDeptNameUnique 校验部门名称是否唯一
func (s DeptService) CheckDeptNameUnique(dept entity.SysDept) bool {
if s.deptDao.CheckDeptNameUnique(dept) > 0 {
return true
}
return false
}
// Remove 删除部门
func (s DeptService) Remove(id int) int64 {
return s.deptDao.Delete(id)
}
// HasChildByDeptId 是否存在部门子节点
func (s DeptService) HasChildByDeptId(id int) int64 {
return s.deptDao.HasChildByDeptId(id)
}
// CheckDeptExistUser 查询部门是否存在用户
func (s DeptService) CheckDeptExistUser(id int) int64 {
return s.deptDao.CheckDeptExistUser(id)
}
// 修改部门
func (s DeptService) Edit(dept entity.SysDept) bool {
return s.deptDao.Update(dept) > 0
}
core/service/dict_data_service.go
+76
View File
@@ -0,0 +1,76 @@
package service
import (
"cutego/core/api/v1/request"
cache2 "cutego/core/cache"
"cutego/core/dao"
"cutego/core/entity"
"cutego/pkg/constant"
)
type DictDataService struct {
dictDataDao dao.DictDataDao
}
// FindByDictType 根据字典类型查询字典数据
func (s DictDataService) FindByDictType(dictType string) []entity.SysDictData {
// 先从缓存中拉数据
key := cache2.GetRedisDict(dictType)
if key != nil {
return key.([]entity.SysDictData)
} else {
// 缓存中为空, 从数据库中取数据
return s.dictDataDao.SelectByDictType(dictType)
}
}
// FindPage 查询字段数据集合
func (s DictDataService) FindPage(query request.DiceDataQuery) (*[]entity.SysDictData, int64) {
return s.dictDataDao.SelectPage(query)
}
// GetByCode 根据code查询字典数据
// @Param code int64
// @Return *entity.SysDictData
func (s DictDataService) GetByCode(code int64) *entity.SysDictData {
return s.dictDataDao.SelectByDictCode(code)
}
// Save 新增字典数据
// @Param data entity.SysDictData
// @Return bool
func (s DictDataService) Save(data entity.SysDictData) bool {
insert := s.dictDataDao.Insert(data)
if insert > 0 {
// 刷新缓存数据
byType := s.GetNoCacheByType(data.DictType)
cache2.SetRedisDict(data.DictType, byType)
}
return insert > 0
}
// Remove 删除数据
// @Param codes 字典code集合
// @Return bool
func (s DictDataService) Remove(codes []int64) bool {
dictType := s.GetByCode(codes[0]).DictType
remove := s.dictDataDao.Delete(codes)
if remove {
// 刷新缓存
code := s.GetNoCacheByType(dictType)
cache2.SetRedisDict(dictType, code)
}
return remove
}
// GetNoCacheByType 根据字典类型查询字典数据
// @Param dictType 字典类型
// @Return []entity.SysDictData
func (s DictDataService) GetNoCacheByType(dictType string) []entity.SysDictData {
return s.dictDataDao.SelectByDictType(constant.RedisConst{}.GetRedisDictKey() + dictType)
}
// 修改字典数据
func (s DictDataService) Edit(data entity.SysDictData) bool {
return s.dictDataDao.Update(data)
}
core/service/dict_type_service.go
+98
View File
@@ -0,0 +1,98 @@
package service
import (
"cutego/core/api/v1/request"
cache2 "cutego/core/cache"
dao2 "cutego/core/dao"
models2 "cutego/core/entity"
)
type DictTypeService struct {
dictTypeDao dao2.DictTypeDao
dictDataDao dao2.DictDataDao
}
// FindPage 分页查询字典类型数据
func (s DictTypeService) FindPage(query request.DictTypeQuery) (*[]models2.SysDictType, int64) {
return s.dictTypeDao.SelectPage(query)
}
// GetById 根据id查询字典类型数据
func (s DictTypeService) GetById(id int64) *models2.SysDictType {
return s.dictTypeDao.SelectById(id)
}
// CheckDictTypeUnique 检验字典类型是否存在
func (s DictTypeService) CheckDictTypeUnique(dictType models2.SysDictType) bool {
return s.dictTypeDao.CheckDictTypeUnique(dictType) > 0
}
// Edit 修改字典数据
func (s DictTypeService) Edit(dictType models2.SysDictType) bool {
return s.dictTypeDao.Update(dictType)
}
// Save 新增字典类型
func (s DictTypeService) Save(dictType models2.SysDictType) bool {
insert := s.dictTypeDao.Insert(dictType)
if insert > 0 {
cache2.SetRedisDict(dictType.DictType, nil)
}
return insert > 0
}
// Remove 批量删除
func (s DictTypeService) Remove(ids []int64) bool {
return s.dictTypeDao.Delete(ids)
}
// FindAll 查询所有字典类型数据
func (s DictTypeService) FindAll() []*models2.SysDictType {
return s.dictTypeDao.SelectAll()
}
// RemoveAllCache 删除所有字典缓存
func (s DictTypeService) RemoveAllCache() []string {
typeList := make([]string, 0)
allType := s.FindAll()
for _, dictType := range allType {
typeList = append(typeList, dictType.DictType)
}
// 删除缓存
cache2.RemoveRedisDictList(typeList)
return typeList
}
// LoadDictCache 将字典数据存入缓存
func (s DictTypeService) LoadDictCache() {
typeList := make([]string, 0)
allType := s.FindAll()
for _, dictType := range allType {
typeList = append(typeList, dictType.DictType)
}
allData := s.dictDataDao.GetDiceDataAll()
for _, key := range typeList {
list := make([]models2.SysDictData, 0)
for _, data := range *allData {
if key == data.DictType {
list = append(list, data)
}
}
cache2.SetRedisDict(key, list)
}
}
// RefreshCache 刷新缓存数据
func (s DictTypeService) RefreshCache() {
typeList := s.RemoveAllCache()
allData := s.dictDataDao.GetDiceDataAll()
for _, key := range typeList {
list := make([]models2.SysDictData, 0)
for _, data := range *allData {
if key == data.DictType {
list = append(list, data)
}
}
cache2.SetRedisDict(key, list)
}
}
core/service/login_info_service.go
+57
View File
@@ -0,0 +1,57 @@
package service
import (
"cutego/core/api/v1/request"
"cutego/core/dao"
"cutego/core/entity"
"cutego/pkg/config"
"github.com/gin-gonic/gin"
"github.com/yinheli/qqwry"
"net"
"os"
)
type LoginInfoService struct {
loginInfoDao dao.LoginInfoDao
}
// FindPage 分页查询数据
func (s LoginInfoService) FindPage(query request.LoginInfoQuery) (*[]entity.SysLoginInfo, int64) {
return s.loginInfoDao.SelectPage(query)
}
// Save 添加登录记录业务逻辑
func (s LoginInfoService) Save(body entity.SysLoginInfo) bool {
// 添加登录记录数据库操作
user := s.loginInfoDao.Insert(body)
if user != nil {
return true
}
return false
}
// GetRequestClientIp 获取请求客户端的ip
func (s LoginInfoService) GetRequestClientIp(c *gin.Context) string {
reqIP := c.ClientIP()
if reqIP == "::1" {
reqIP = "127.0.0.1"
}
return reqIP
}
// 纯真数据库获取ip地址
// @return {"Ip": "180.89.94.90","Country": "北京市","City": "鹏博士宽带"}
func (s LoginInfoService) GetLocationByIp(ipAddr string) *qqwry.QQwry {
address := net.ParseIP(ipAddr)
if ipAddr == "" || address == nil {
panic("参数ipAddr是空的")
} else {
dir, err := os.Getwd()
if err != nil {
panic("无法获取当前路径, " + err.Error())
}
q := qqwry.NewQQwry(dir + "/" + config.BaseConfigDirPath + "/scanip/qqwry.dat")
q.Find(ipAddr)
return q
}
}
core/service/login_service.go
+46
View File
@@ -0,0 +1,46 @@
package service
import (
"cutego/core/api/v1/response"
"cutego/pkg/common"
"cutego/pkg/jwt"
"github.com/druidcaesa/gotool"
"github.com/gin-gonic/gin"
"strings"
)
type LoginService struct {
userService UserService
}
// Login 用户登录业务处理
func (s LoginService) Login(name string, password string) (bool, string) {
user := s.userService.GetUserByUserName(name)
if user == nil {
return false, "用户不存在"
}
if !gotool.BcryptUtils.CompareHash(user.Password, password) {
return false, "密码错误"
}
// 生成token
token, err := jwt.CreateUserToken(s.userService.GetUserById(user.UserId))
if err != nil {
common.ErrorLog(err)
return false, ""
}
// 数据存储到redis中
return true, token
}
// GetCurrentUser 获取当前登录用户
func (s LoginService) GetCurrentUser(c *gin.Context) *response.UserResponse {
token := c.Request.Header.Get("Authorization")
str := strings.Split(token, " ")
// parseToken 解析token包含的信息
claims, err := jwt.ParseToken(str[1])
if err != nil {
common.ErrorLog(err)
}
info := claims.UserInfo
return &info
}
core/service/menu_service.go
+62
View File
@@ -0,0 +1,62 @@
package service
import (
"cutego/core/api/v1/request"
"cutego/core/api/v1/response"
dao2 "cutego/core/dao"
models2 "cutego/core/entity"
)
type MenuService struct {
menuDao dao2.MenuDao
roleDao dao2.RoleDao
}
// GetMenuTreeByUserId 根据用户ID查询菜单
func (s MenuService) GetMenuTreeByUserId(user *response.UserResponse) *[]models2.SysMenu {
var menuList *[]models2.SysMenu
// 判断是否是管理员
flag := models2.SysUser{}.IsAdmin(user.UserId)
if flag {
menuList = s.menuDao.GetMenuAll()
} else {
menuList = s.menuDao.GetMenuByUserId(user.UserId)
}
return menuList
}
// FindMenuListByRoleId 根据角色ID查询菜单树信息
func (s MenuService) FindMenuListByRoleId(id int64) *[]int64 {
role := s.roleDao.SelectRoleByRoleId(id)
return s.menuDao.SelectMenuByRoleId(id, role.MenuCheckStrictly)
}
// GetMenuList 获取菜单列表
func (s MenuService) FindMenuList(query request.MenuQuery, info *response.UserResponse) *[]models2.SysMenu {
if info.IsAdmin() {
return s.menuDao.SelectMenuList(query)
} else {
query.UserId = info.UserId
return s.menuDao.SelectMenuListByUserId(query)
}
}
// GetMenuByMenuId 根据菜单ID查询信息
func (s MenuService) GetMenuByMenuId(id int) *models2.SysMenu {
return s.menuDao.SelectMenuByMenuId(id)
}
// Save 添加菜单数据
func (s MenuService) Save(menu models2.SysMenu) int64 {
return s.menuDao.Insert(menu)
}
// Edit 修改菜单数据
func (s MenuService) Edit(menu models2.SysMenu) int64 {
return s.menuDao.Update(menu)
}
// Remove 删除菜单操作
func (s MenuService) Remove(id int) int64 {
return s.menuDao.Delete(id)
}
core/service/notice_service.go
+36
View File
@@ -0,0 +1,36 @@
package service
import (
"cutego/core/api/v1/request"
"cutego/core/dao"
"cutego/core/entity"
)
type NoticeService struct {
noticeDao dao.NoticeDao
}
// FindPage 查询集合数据
func (s NoticeService) FindPage(query request.NoticeQuery) (*[]entity.SysNotice, int64) {
return s.noticeDao.SelectPage(query)
}
// Save 添加公告
func (s NoticeService) Save(notice entity.SysNotice) bool {
return s.noticeDao.Insert(notice) > 0
}
// Remove 批量删除
func (s NoticeService) Remove(list []int64) bool {
return s.noticeDao.Delete(list) > 0
}
// GetById 查询
func (s NoticeService) GetById(id int64) *entity.SysNotice {
return s.noticeDao.SelectById(id)
}
// Edit 修改
func (s NoticeService) Edit(notice entity.SysNotice) bool {
return s.noticeDao.Update(notice) > 0
}
core/service/permission_service.go
+43
View File
@@ -0,0 +1,43 @@
package service
import (
"cutego/core/api/v1/response"
dao2 "cutego/core/dao"
"cutego/core/entity"
"github.com/druidcaesa/gotool"
)
type PermissionService struct {
roleDao dao2.RoleDao
menuDao dao2.MenuDao
}
// GetRolePermissionByUserId 查询用户角色集合
func (s PermissionService) GetRolePermissionByUserId(user *response.UserResponse) *[]string {
admin := entity.SysUser{}.IsAdmin(user.UserId)
roleKeys := s.roleDao.SelectRolePermissionByUserId(user.UserId)
if admin && roleKeys != nil {
*roleKeys = append(*roleKeys, "admin")
}
duplication := gotool.StrArrayUtils.ArrayDuplication(*roleKeys)
return &duplication
}
// GetMenuPermission 获取菜单数据权限
func (s PermissionService) GetMenuPermission(user *response.UserResponse) *[]string {
flag := entity.SysUser{}.IsAdmin(user.UserId)
// 查询菜单数据权限
permission := s.menuDao.GetMenuPermission(user.UserId)
if flag && permission != nil {
*permission = append(*permission, "*:*:*")
}
var ret []string
duplication := gotool.StrArrayUtils.ArrayDuplication(*permission)
for i := 0; i < len(duplication); i++ {
if (i > 0 && duplication[i-1] == duplication[i]) || len(duplication[i]) == 0 {
continue
}
ret = append(ret, duplication[i])
}
return &ret
}
core/service/post_service.go
+77
View File
@@ -0,0 +1,77 @@
package service
import (
"bytes"
"cutego/core/api/v1/request"
"cutego/core/dao"
"cutego/core/entity"
"github.com/druidcaesa/gotool"
)
type PostService struct {
postDao dao.PostDao
}
// FindAll 查询所有岗位业务方法
func (s PostService) FindAll() []*entity.SysPost {
return s.postDao.SelectAll()
}
// FindPostListByUserId 根据用户id查询岗位id集合
func (s PostService) FindPostListByUserId(userId int64) *[]int64 {
return s.postDao.SelectPostListByUserId(userId)
}
// FindList 查询岗位分页列表
func (s PostService) FindPage(query request.PostQuery) (*[]entity.SysPost, int64) {
return s.postDao.SelectPage(query)
}
// CheckPostNameUnique 校验岗位名称是否存在
func (s PostService) CheckPostNameUnique(post entity.SysPost) bool {
return s.postDao.CheckPostNameUnique(post) > 0
}
// CheckPostCodeUnique 校验岗位编码是否存在
func (s PostService) CheckPostCodeUnique(post entity.SysPost) bool {
return s.postDao.CheckPostCodeUnique(post) > 0
}
// Save 添加岗位数据
func (s PostService) Save(post entity.SysPost) bool {
return s.postDao.Insert(post) > 0
}
// GetPostById 根据id查询岗位数据
func (s PostService) GetPostById(id int64) *entity.SysPost {
post := entity.SysPost{
PostId: id,
}
return s.postDao.GetPostById(post)
}
// Remove 批量删除岗位信息
func (s PostService) Remove(ids []int64) bool {
return s.postDao.Delete(ids) > 0
}
// Edit 修改岗位数据
func (s PostService) Edit(post entity.SysPost) bool {
return s.postDao.Update(post)
}
// FindPostByUserName 获取岗位数据
func (s PostService) FindPostByUserName(name string) string {
list := s.postDao.SelectPostByUserName(name)
var buffer bytes.Buffer
var postName string
for _, post := range *list {
buffer.WriteString(post.PostName)
buffer.WriteString(",")
}
s2 := buffer.String()
if gotool.StrUtils.HasNotEmpty(s2) {
postName = s2[0:(len(s2) - 1)]
}
return postName
}
core/service/role_service.go
+133
View File
@@ -0,0 +1,133 @@
package service
import (
"bytes"
req2 "cutego/core/api/v1/request"
dao2 "cutego/core/dao"
models2 "cutego/core/entity"
"github.com/druidcaesa/gotool"
)
type RoleService struct {
roleDao dao2.RoleDao
roleMenuDao dao2.RoleMenuDao
userRoleDao dao2.UserRoleDao
}
// FindAll 查询所有角色
func (s RoleService) FindAll(query *req2.RoleQuery) ([]*models2.SysRole, int64) {
if query == nil {
all := s.roleDao.SelectAll()
return all, 0
}
return s.roleDao.SelectPage(query)
}
// FindRoleListByUserId 根据用户id查询角色id集合
func (s RoleService) FindRoleListByUserId(parseInt int64) *[]int64 {
return s.roleDao.SelectRoleListByUserId(parseInt)
}
// GetRoleListByUserId 根据用户ID查询角色
func (s RoleService) GetRoleListByUserId(id int64) *[]models2.SysRole {
return s.roleDao.GetRoleListByUserId(id)
}
// FindPage 分页查询角色数据
func (s RoleService) FindPage(query req2.RoleQuery) ([]*models2.SysRole, int64) {
return s.roleDao.SelectPage(&query)
}
// GetRoleByRoleId 根据角色id查询角色数据
func (s RoleService) GetRoleByRoleId(id int64) *models2.SysRole {
return s.roleDao.SelectRoleByRoleId(id)
}
// CheckRoleNameUnique 判断角色名城是否存在
func (s RoleService) CheckRoleNameUnique(role models2.SysRole) int64 {
return s.roleDao.CheckRoleNameUnique(role)
}
// CheckRoleKeyUnique 校验角色权限是否唯一
func (s RoleService) CheckRoleKeyUnique(role models2.SysRole) int64 {
return s.roleDao.CheckRoleKeyUnique(role)
}
// Save 添加角色数据
func (s RoleService) Save(role models2.SysRole) int64 {
role = s.roleDao.Insert(role)
return s.BindRoleMenu(role)
}
// 添加角色菜单关系
func (s RoleService) BindRoleMenu(role models2.SysRole) int64 {
list := make([]models2.SysRoleMenu, 0)
for _, id := range role.MenuIds {
menu := models2.SysRoleMenu{
RoleId: role.RoleId,
MenuId: id,
}
list = append(list, menu)
}
return s.roleMenuDao.Insert(list)
}
// Edit 修改角色数据
func (s RoleService) Edit(role models2.SysRole) int64 {
// 删除菜单关联关系
s.roleMenuDao.Delete(role)
s.BindRoleMenu(role)
// 修改数据
return s.roleDao.Update(role)
}
// Remove 删除角色
func (s RoleService) Remove(id int64) int64 {
role := models2.SysRole{
RoleId: id,
}
// 删除菜单角色关系
s.roleMenuDao.Delete(role)
// 删除角色
return s.roleDao.Delete(role)
}
// CheckRoleAllowed 校验是否可以操作
func (s RoleService) CheckRoleAllowed(id int64) (bool, string) {
if id == 1 {
return false, "超级管理员不允许操作"
}
return true, ""
}
// EditRoleStatus 角色状态修改
func (s RoleService) EditRoleStatus(role *models2.SysRole) int64 {
return s.roleDao.UpdateRoleStatus(role)
}
// DeleteAuthUser 取消授权用户
func (s RoleService) DeleteAuthUser(userRole models2.SysUserRole) int64 {
return s.userRoleDao.DeleteAuthUser(userRole)
}
// InsertAuthUsers 批量选择用户授权
func (s RoleService) InsertAuthUsers(body req2.UserRoleBody) int64 {
return s.userRoleDao.InsertAuthUsers(body)
}
// GetRolesByUserName 查询所属角色组
func (s RoleService) GetRolesByUserName(name string) string {
list := s.roleDao.SelectRolesByUserName(name)
var buffer bytes.Buffer
var roleName string
for _, role := range *list {
buffer.WriteString(role.RoleName)
buffer.WriteString(",")
}
s2 := buffer.String()
if gotool.StrUtils.HasNotEmpty(s2) {
roleName = s2[0:(len(s2) - 1)]
}
return roleName
}
core/service/user_post_service.go
+19
View File
@@ -0,0 +1,19 @@
package service
import (
"cutego/core/dao"
)
type UserPostService struct {
userPostDao dao.UserPostDao
}
// CountUserPostById 统计岗位数据数量
func (s UserPostService) CountUserPostById(ids []int64) int64 {
for _, id := range ids {
if s.userPostDao.CountById(id) > 0 {
return id
}
}
return 0
}
core/service/user_service.go
+151
View File
@@ -0,0 +1,151 @@
package service
import (
"cutego/core/api/v1/request"
"cutego/core/api/v1/response"
dao2 "cutego/core/dao"
models2 "cutego/core/entity"
)
// UserService 用户操作业务逻辑
type UserService struct {
userDao dao2.UserDao
userPostDao dao2.UserPostDao
userRoleDao dao2.UserRoleDao
}
// FindList 查询用户集合业务方法
func (s UserService) FindList(query request.UserQuery) ([]*response.UserResponse, int64) {
return s.userDao.SelectPage(query)
}
// GetUserById 根据id查询用户数据
func (s UserService) GetUserById(parseInt int64) *response.UserResponse {
return s.userDao.GetUserById(parseInt)
}
// GetUserByUserName 根据用户名查询用户
func (s UserService) GetUserByUserName(name string) *models2.SysUser {
user := models2.SysUser{}
user.UserName = name
return s.userDao.GetUserByUserName(user)
}
// CheckEmailUnique 校验邮箱是否存在
func (s UserService) CheckEmailUnique(user request.UserBody) *models2.SysUser {
return s.userDao.CheckEmailUnique(user)
}
// CheckPhoneNumUnique 校验手机号是否存在
func (s UserService) CheckPhoneNumUnique(body request.UserBody) *models2.SysUser {
return s.userDao.CheckPhoneNumUnique(body)
}
// Insert 添加用户业务逻辑
func (s UserService) Save(body request.UserBody) bool {
// 添加用户数据库操作
user := s.userDao.Insert(body)
if user != nil {
s.BindUserPost(user)
s.BindUserRole(user)
return true
}
return false
}
// 新增用户岗位信息
func (s UserService) BindUserPost(user *request.UserBody) {
postIds := user.PostIds
if len(postIds) > 0 {
sysUserPosts := make([]models2.SysUserPost, 0)
for i := 0; i < len(postIds); i++ {
m := models2.SysUserPost{
UserId: user.UserId,
PostId: postIds[i],
}
sysUserPosts = append(sysUserPosts, m)
}
s.userPostDao.BatchInsert(sysUserPosts)
}
}
// 新增用户角色信息
func (s UserService) BindUserRole(user *request.UserBody) {
roleIds := user.RoleIds
if len(roleIds) > 0 {
roles := make([]models2.SysUserRole, 0)
for i := 0; i < len(roleIds); i++ {
role := models2.SysUserRole{
RoleId: roleIds[i],
UserId: user.UserId,
}
roles = append(roles, role)
}
s.userRoleDao.BatchInsert(roles)
}
}
// Edit 修改用户数据
func (s UserService) Edit(body request.UserBody) int64 {
// 删除原有用户和角色关系
s.userRoleDao.Delete(body.UserId)
// 重新添加用具角色关系
s.BindUserRole(&body)
// 删除原有用户岗位关系
s.userPostDao.Delete(body.UserId)
// 添加新的用户岗位关系
s.BindUserPost(&body)
// 修改用户数据
return s.userDao.Update(body)
}
// Remove 根据用户id删除用户相关数据
func (s UserService) Remove(id int64) int64 {
// 删除原有用户和角色关系
s.userRoleDao.Delete(id)
// 删除原有用户岗位关系
s.userPostDao.Delete(id)
// 删除用户数据
return s.userDao.Delete(id)
}
// CheckUserAllowed 校验是否可以修改用户密码
func (s UserService) CheckUserAllowed(body request.UserBody) bool {
user := models2.SysUser{}
return user.IsAdmin(body.UserId)
}
// ResetPwd 修改用户密码
func (s UserService) ResetPwd(body request.UserBody) int64 {
return s.userDao.ResetPwd(body)
}
// GetAllocatedList 查询未分配用户角色列表
func (s UserService) GetAllocatedList(query request.UserQuery) ([]*response.UserResponse, int64) {
return s.userDao.GetAllocatedList(query)
}
// GetUnallocatedList 查询未分配用户角色列表
func (s UserService) GetUnallocatedList(query request.UserQuery) ([]*response.UserResponse, int64) {
return s.userDao.GetUnallocatedList(query)
}
// EditProfile 修改数据
func (s UserService) EditProfile(user request.UserBody) int64 {
return s.userDao.Update(user)
}
// EditPwd 修改密码
func (s UserService) EditPwd(id int64, hash string) bool {
return s.userDao.UpdatePwd(id, hash) > 0
}
// EditAvatar 修改头像
func (s UserService) EditAvatar(info *response.UserResponse) bool {
return s.userDao.UpdateAvatar(info) > 0
}
// EditStatus 修改可用状态
func (s UserService) EditStatus(info request.UserBody) bool {
return s.userDao.UpdateStatus(info) > 0
}