feature(系统管理):

1.错误处理
2.岗位角色功能
3.用户列表修改

opms_admin/app/dao/sys_user.go

@@ -5,11 +5,7 @@
 package dao
 
 import (
-	"context"
 	"dashoo.cn/micro/app/dao/internal"
-	"dashoo.cn/micro/app/model"
-	"github.com/gogf/gf/errors/gerror"
-	"github.com/gogf/gf/frame/g"
 )
 
 // sysUserDao is the manager for logic model data accessing
@@ -38,14 +34,3 @@ func NewSysUserDao(tenant string) *SysUserDao {
 }
 
 // Fill with you ideas below.
-
-// FindByUsername 通过用户名获取用户信息
-func (d *sysUserDao) FindByUsername(ctx context.Context, username string) (user *model.LoginUserRes, err error) {
-	user = &model.LoginUserRes{}
-	err = d.Ctx(ctx).Fields(user).Where(d.Columns.UserName, username).Scan(user)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("获取用户信息失败")
-	}
-	return
-}

opms_admin/app/handler/auth.go

@@ -2,13 +2,13 @@ package handler
 
 import (
 	"context"
+	"dashoo.cn/opms_libary/myerrors"
 
 	"dashoo.cn/common_definition/admin/user_def"
 	"dashoo.cn/common_definition/comm_def"
 	"dashoo.cn/opms_libary/gtoken"
 	"dashoo.cn/opms_libary/micro_srv"
 	"github.com/gogf/gf/encoding/gjson"
-	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/os/glog"
 	"github.com/gogf/gf/util/gconv"
@@ -35,15 +35,13 @@ func init() {
 func (h *AuthHandler) Login(ctx context.Context, req *user_def.LoginReq, rsp *comm_def.CommonMsg) error {
 	// 参数验证
 	if req.UserName == "" || req.Password == "" {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	userInfo, err := userService.Login(req.UserName, req.Password)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	loginLogService, _ := service.NewLoginLogService(ctx)
 	loginLogService.Invoke(ctx, req.UserName, rsp.Msg)
 	if err != nil {
@@ -63,10 +61,9 @@ func (h *AuthHandler) LogOut(ctx context.Context, req interface{}, rsp *comm_def
 	if err != nil {
 		return err
 	} else if token == "" {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	tokenResp := gtoken.GFToken.RemoveToken(token)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}

opms_admin/app/handler/base.go

@@ -1,7 +0,0 @@
-package handler
-
-import "errors"
-
-var (
-	NoParamsErr = errors.New("参数为空,操作失败")
-)

opms_admin/app/handler/dept.go

@@ -2,10 +2,10 @@ package handler
 
 import (
 	"context"
+	"dashoo.cn/opms_libary/myerrors"
 	"errors"
 
 	"dashoo.cn/common_definition/comm_def"
-	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/util/gvalid"
 
@@ -23,7 +23,9 @@ func (h *DeptHandler) GetList(ctx context.Context, req *model.SysDeptSearchParam
 		return errors.New("系统异常，请重新尝试")
 	}
 	list, err := deptService.GetList(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = list
 	return nil
 }
@@ -32,19 +34,16 @@ func (h *DeptHandler) GetList(ctx context.Context, req *model.SysDeptSearchParam
 func (h *DeptHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	deptService, err := service.NewDeptService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	entity, err := deptService.GetDeptById(req.Id)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	rsp.Data = entity
 	return nil
 }
@@ -53,65 +52,58 @@ func (h *DeptHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rs
 func (h *DeptHandler) Create(ctx context.Context, req *model.SysDeptReq, rsp *comm_def.CommonMsg) error {
 	// 检查请求参数
 	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
 		return v
 	}
 	deptService, err := service.NewDeptService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	err = deptService.Create(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // UpdateById 更新
 func (h *DeptHandler) UpdateById(ctx context.Context, req *model.UpdateSysDeptReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	// 检查请求参数
 	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
 		return v
 	}
 
 	deptService, err := service.NewDeptService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = deptService.UpdateById(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // DeleteById 删除
 func (h *DeptHandler) DeleteById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	deptService, err := service.NewDeptService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = deptService.DeleteById(int(req.Id))
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // GetDeptTree 获取树
 func (h *DeptHandler) GetDeptTree(ctx context.Context, nullParams interface{}, rsp *comm_def.CommonMsg) error {
 	deptService, err := service.NewDeptService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	//获取正常状态部门数据
 	list, err := deptService.GetList(&model.SysDeptSearchParams{Status: "10"})
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	treeList := deptService.GetDeptListTree(0, list)
 	rsp.Data = treeList
 	return nil

opms_admin/app/handler/dict.go

@@ -2,6 +2,7 @@ package handler
 
 import (
 	"context"
+	"dashoo.cn/opms_libary/myerrors"
 
 	"dashoo.cn/common_definition/comm_def"
 	"github.com/gogf/gf/frame/g"
@@ -17,12 +18,11 @@ type DictHandler struct{}
 func (h *DictHandler) GetDictTypeList(ctx context.Context, req *model.ListSysDictTypeReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	dictService, err := service.NewDictTypeService(ctx)
-	//if flag, err, _, _ := myerrors.CheckError(err); flag {
-	//	return err
-	//}
+	if err != nil {
+		return err
+	}
 
 	total, list, err := dictService.GetList(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -34,15 +34,14 @@ func (h *DictHandler) GetDictTypeList(ctx context.Context, req *model.ListSysDic
 func (h *DictHandler) GetDictTypeEntity(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	dictService, err := service.NewDictTypeService(ctx)
-	//if flag, err, _, _ := myerrors.CheckError(err); flag {
-	//	return err
-	//}
+	if err != nil {
+		return err
+	}
 
 	data, err := dictService.GetDictById(req.Id)
-//	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -57,12 +56,11 @@ func (h *DictHandler) CreateDictType(ctx context.Context, req *model.SysDictType
 		return err
 	}
 	dictService, err := service.NewDictTypeService(ctx)
-	//if flag, err, _, _ := myerrors.CheckError(err); flag {
-	//	return err
-	//}
+	if err != nil {
+		return err
+	}
 
 	err = dictService.Create(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	return err
 }
 
@@ -73,12 +71,11 @@ func (h *DictHandler) UpdateDictType(ctx context.Context, req *model.SysDictType
 		return err
 	}
 	dictService, err := service.NewDictTypeService(ctx)
-	//if flag, err, _, _ := myerrors.CheckError(err); flag {
-	//	return err
-	//}
+	if err != nil {
+		return err
+	}
 
 	err = dictService.UpdateById(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	return err
 }
 
@@ -86,7 +83,7 @@ func (h *DictHandler) UpdateDictType(ctx context.Context, req *model.SysDictType
 func (h *DictHandler) DeleteDictTypeByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if len(req.Ids) == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	dictService, err := service.NewDictTypeService(ctx)
 	if err != nil {
@@ -94,7 +91,6 @@ func (h *DictHandler) DeleteDictTypeByIds(ctx context.Context, req *comm_def.Ids
 	}
 
 	err = dictService.Delete(req.Ids)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	return err
 }
 
@@ -107,7 +103,6 @@ func (h *DictHandler) GetDictDataList(ctx context.Context, req *model.SelectDict
 		return err
 	}
 	total, list, err := dictService.GetDictDataList(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -119,7 +114,7 @@ func (h *DictHandler) GetDictDataList(ctx context.Context, req *model.SelectDict
 func (h *DictHandler) GetDictDataEntity(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	dictService, err := service.NewDictDataService(ctx)
 	if err != nil {
@@ -127,7 +122,6 @@ func (h *DictHandler) GetDictDataEntity(ctx context.Context, req *comm_def.IdReq
 	}
 
 	data, err := dictService.GetDictDataById(req.Id)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -143,7 +137,6 @@ func (h *DictHandler) GetDictDataByType(ctx context.Context, req *model.GetDictR
 	}
 
 	list, err := dictService.GetDictWithDataByType(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -163,11 +156,9 @@ func (h *DictHandler) CreateDictData(ctx context.Context, req *model.DictDataAdd
 		return err
 	}
 
-	_, err = dictService.Create(req)
-//	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	rsp.Data, err = dictService.Create(req)
 	if err != nil {
 		return err
-
 	}
 	return nil
 }
@@ -185,7 +176,6 @@ func (h *DictHandler) UpdateDictData(ctx context.Context, req *model.EditDictDat
 	}
 
 	err = dictService.UpdateByDict(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -196,7 +186,7 @@ func (h *DictHandler) UpdateDictData(ctx context.Context, req *model.EditDictDat
 func (h *DictHandler) DeleteDictDataByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
 	// 参数验证
 	if len(req.Ids) == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	dictService, err := service.NewDictDataService(ctx)
 	if err != nil {
@@ -204,7 +194,6 @@ func (h *DictHandler) DeleteDictDataByIds(ctx context.Context, req *comm_def.Ids
 	}
 
 	err = dictService.DeleteDictDataByIds(req.Ids)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}

opms_admin/app/handler/group.go

@@ -2,9 +2,9 @@ package handler
 
 import (
 	"context"
+	"dashoo.cn/opms_libary/myerrors"
 
 	"dashoo.cn/common_definition/comm_def"
-	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/util/gvalid"
 
@@ -18,77 +18,71 @@ type GroupHandler struct{}
 func (h *GroupHandler) GetList(ctx context.Context, req *model.SysGroupSearchParams, rsp *comm_def.CommonMsg) error {
 	groupService, err := service.NewGroupService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	total, list, err := groupService.GetList(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = g.Map{"list": list, "total": total}
 	return nil
 }
 
 // GetEntityById 详情
-//func (o *GroupHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
-//	// 参数校验
-//	if req.Id == 0 {
-//		return NoParamsErr
-//	}
-//	groupService, err := service.NewGroupService(ctx)
-//	if err != nil {
-//		g.Log().Error(err)
-//		return gerror.New("系统异常，请重新尝试")
-//	}
-//	entity, err := groupService.GetEntity(req.Id)
-//	_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-//	rsp.Data = entity
-//	return nil
-//}
+func (o *GroupHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if req.Id == 0 {
+		return myerrors.TipsError("请求参数不存在。")
+	}
+	groupService, err := service.NewGroupService(ctx)
+	if err != nil {
+		return err
+	}
+	entity, err := groupService.GetEntity(req.Id)
+	if err != nil {
+		return err
+	}
+	rsp.Data = entity
+	return nil
+}
 
 // Create 添加
 func (h *GroupHandler) Create(ctx context.Context, req *model.SysGroupReq, rsp *comm_def.CommonMsg) error {
 	// 检查请求参数
 	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
 		return v
 	}
 	groupService, err := service.NewGroupService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	err = groupService.Create(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // UpdateById 编辑
 func (h *GroupHandler) UpdateById(ctx context.Context, req *model.UpdateSysGroupReq, rsp *comm_def.CommonMsg) error {
 	// 检查请求参数
 	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
 		return v
 	}
 
 	groupService, err := service.NewGroupService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = groupService.UpdateById(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // DeleteByIds 删除菜单
 func (h *GroupHandler) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
 	groupService, err := service.NewGroupService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = groupService.DeleteByIds(req.Ids)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }

opms_admin/app/handler/loginLog.go

@@ -4,7 +4,6 @@ import (
 	"context"
 
 	"dashoo.cn/common_definition/comm_def"
-	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 
 	"dashoo.cn/micro/app/model"
@@ -15,26 +14,25 @@ type LoginLogHandler struct{}
 
 // GetList 获取列表
 func (h *LoginLogHandler) GetList(ctx context.Context, req *model.SysLoginLogSearchReq, rsp *comm_def.CommonMsg) error {
-	postService, err := service.NewLoginLogService(ctx)
+	logService, err := service.NewLoginLogService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
+	}
+	total, list, err := logService.GetList(req)
+	if err != nil {
+		return err
 	}
-	total, list, err := postService.GetList(req)
-//	_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	rsp.Data = g.Map{"list": list, "total": total}
 	return nil
 }
 
 // DeleteByIds 删除菜单
 func (h *LoginLogHandler) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
-	postService, err := service.NewLoginLogService(ctx)
+	logService, err := service.NewLoginLogService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
-	err = postService.DeleteByIds(req.Ids)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	err = logService.DeleteByIds(req.Ids)
+	return err
 }

opms_admin/app/handler/menu.go

@@ -2,12 +2,9 @@ package handler
 
 import (
 	"context"
-	"errors"
-
 	"dashoo.cn/common_definition/admin/menu_def"
 	"dashoo.cn/common_definition/comm_def"
-	"github.com/gogf/gf/errors/gerror"
-	"github.com/gogf/gf/frame/g"
+	"dashoo.cn/opms_libary/myerrors"
 	"github.com/gogf/gf/util/gconv"
 	"github.com/gogf/gf/util/gvalid"
 
@@ -21,11 +18,12 @@ type MenuHandler struct{}
 func (h *MenuHandler) GetList(ctx context.Context, req *menu_def.SelectReq, rsp *comm_def.CommonMsg) error {
 	menuService, err := service.NewMenuService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return errors.New("系统异常，请重新尝试")
+		return err
 	}
 	list, err := menuService.GetList(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = list
 	return nil
 }
@@ -34,19 +32,16 @@ func (h *MenuHandler) GetList(ctx context.Context, req *menu_def.SelectReq, rsp
 func (h *MenuHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	menuService, err := service.NewMenuService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	entity, err := menuService.GetEntity(req.Id)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	rsp.Data = entity
 	return nil
 }
@@ -55,16 +50,16 @@ func (h *MenuHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rs
 func (h *MenuHandler) Create(ctx context.Context, req *model.SysMenuReq, rsp *comm_def.CommonMsg) error {
 	// 检查请求参数
 	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
 		return v
 	}
 	menuService, err := service.NewMenuService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	id, err := menuService.Create(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = gconv.String(id)
 	return nil
 }
@@ -73,47 +68,41 @@ func (h *MenuHandler) Create(ctx context.Context, req *model.SysMenuReq, rsp *co
 func (h *MenuHandler) UpdateById(ctx context.Context, req *model.SysMenuReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	// 检查请求参数
 	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
 		return v
 	}
 
 	menuService, err := service.NewMenuService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = menuService.UpdateById(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // DeleteById 删除菜单
 func (h *MenuHandler) DeleteById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	menuService, err := service.NewMenuService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = menuService.Delete(req.Id)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // GetRoleMenuIds 根据角色获取菜单
 //func (o *MenuHandler) GetRoleMenuIds(ctx context.Context, req *menu_def.RoleIdReq, rsp *comm_def.CommonMsg) error {
 //	menuService, err := service.NewMenuService(ctx)
 //	if err != nil {
-//		return gerror.New("系统异常，请重新尝试")
+//		return err
 //	}
 //
 //	entity, err := menuService.GetRoleMenuIds(req.RoleId)
-//	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 //	if err != nil {
 //		return err
 //	}
@@ -121,11 +110,11 @@ func (h *MenuHandler) DeleteById(ctx context.Context, req *comm_def.IdReq, rsp *
 //	return nil
 //}
 
-// GetMenuTree 获取菜单树
+// GetMenuTree 获取菜单树  isAll获取完整菜单树
 func (h *MenuHandler) GetMenuTree(ctx context.Context, req map[string]interface{}, rsp *comm_def.CommonMsg) error {
 	menuService, err := service.NewMenuService(ctx)
 	if err != nil {
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	isAll := false
 	if val, ok := req["isAll"]; ok && val == "all" {
@@ -139,7 +128,9 @@ func (h *MenuHandler) GetMenuTree(ctx context.Context, req map[string]interface{
 		userRoles, _ := userService.GetUserRoleIds(userService.GetCxtUserId())
 		list, err = menuService.GetUserRoleMenuTree(userRoles)
 	}
-//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = list
 	return nil
 }

opms_admin/app/handler/post.go

@@ -2,9 +2,8 @@ package handler
 
 import (
 	"context"
-
 	"dashoo.cn/common_definition/comm_def"
-	"github.com/gogf/gf/errors/gerror"
+	"dashoo.cn/opms_libary/myerrors"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/util/gvalid"
 
@@ -18,81 +17,71 @@ type PostHandler struct{}
 func (h *PostHandler) GetList(ctx context.Context, req *model.SysPostSearchParams, rsp *comm_def.CommonMsg) error {
 	postService, err := service.NewPostService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	total, list, err := postService.GetList(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = g.Map{"list": list, "total": total}
-	return nil
+	return err
 }
 
 // GetEntityById 详情
-//func (o *PostHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
-//	// 参数校验
-//	if req.Id == 0 {
-//		return NoParamsErr
-//	}
-//	postService, err := service.NewPostService(ctx)
-//	if err != nil {
-//		g.Log().Error(err)
-//		return gerror.New("系统异常，请重新尝试")
-//	}
-//	entity, err := postService.GetEntity(req.Id)
-//	if err != nil {
-//		g.Log().Error(err)
-//		return err
-//	}
-//	_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-//	rsp.Data = entity
-//	return nil
-//}
+func (o *PostHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if req.Id == 0 {
+		return myerrors.TipsError("请求参数不存在。")
+	}
+	postService, err := service.NewPostService(ctx)
+	if err != nil {
+		return err
+	}
+	entity, err := postService.GetEntity(req.Id)
+	if err != nil {
+		return err
+	}
+	rsp.Data = entity
+	return nil
+}
 
 // Create 添加
 func (h *PostHandler) Create(ctx context.Context, req *model.SysPostReq, rsp *comm_def.CommonMsg) error {
 	// 检查请求参数
-	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
-		return v
+	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
+		return err
 	}
 	postService, err := service.NewPostService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	err = postService.Create(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // UpdateById 编辑
 func (h *PostHandler) UpdateById(ctx context.Context, req *model.UpdateSysPostReq, rsp *comm_def.CommonMsg) error {
 	// 检查请求参数
-	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
-		return v
+	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
+		return err
 	}
 
 	postService, err := service.NewPostService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = postService.UpdateById(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // DeleteByIds 删除菜单
 func (h *PostHandler) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
 	postService, err := service.NewPostService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = postService.DeleteByIds(req.Ids)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }

opms_admin/app/handler/role.go

@@ -2,9 +2,9 @@ package handler
 
 import (
 	"context"
+	"dashoo.cn/opms_libary/myerrors"
 
 	"dashoo.cn/common_definition/comm_def"
-	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/util/gvalid"
 
@@ -18,11 +18,12 @@ type RoleHandler struct{}
 func (h *RoleHandler) GetList(ctx context.Context, req *model.SelectPageReq, rsp *comm_def.CommonMsg) error {
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	total, list, err := roleService.GetRoleListSearch(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = g.Map{"list": list, "total": total}
 	return nil
 }
@@ -31,15 +32,16 @@ func (h *RoleHandler) GetList(ctx context.Context, req *model.SelectPageReq, rsp
 func (o *RoleHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	entity, err := roleService.GetRoleById(req.Id)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = entity
 	return nil
 }
@@ -48,61 +50,54 @@ func (o *RoleHandler) GetEntityById(ctx context.Context, req *comm_def.IdReq, rs
 func (h *RoleHandler) Create(ctx context.Context, req *model.SysRoleReq, rsp *comm_def.CommonMsg) error {
 	// 检查请求参数
 	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
 		return v
 	}
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	err = roleService.CreateRole(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // UpdateById 编辑
 func (h *RoleHandler) UpdateById(ctx context.Context, req *model.UpdateSysRoleReq, rsp *comm_def.CommonMsg) error {
 	// 检查请求参数
 	if v := gvalid.CheckStruct(ctx, req, nil); v != nil {
-		g.Log().Error(v)
 		return v
 	}
 
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = roleService.UpdateRole(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // DeleteByIds 删除菜单
 func (h *RoleHandler) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = roleService.DeleteByIds(req.Ids)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // GetRoleDeptTreeselect 获取角色下的自定义部门
 func (h *RoleHandler) GetRoleDeptTreeselect(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	deptIds, err := roleService.GetRoleDeptTreeselect(req.Id)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		return err
+	}
 	rsp.Data = deptIds
 	return nil
 }
@@ -111,36 +106,31 @@ func (h *RoleHandler) GetRoleDeptTreeselect(ctx context.Context, req *comm_def.I
 func (h *RoleHandler) UpdateRoleStatus(ctx context.Context, req *model.StatusSetReq, rsp *comm_def.CommonMsg) error {
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = roleService.UpdateRoleStatus(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // UpdateRoleDataScope 角色下的数据权限
 func (h *RoleHandler) UpdateRoleDataScope(ctx context.Context, req *model.DataScopeReq, rsp *comm_def.CommonMsg) error {
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		g.Log().Error(err)
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	err = roleService.UpdateRoleDataScope(req)
-	//_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	return nil
+	return err
 }
 
 // GetDataScope 获取某用户数据集合权限，返回Ids(用户Id列表)，返回-1表示无角色，返回-2表示有全部集合权限
 func (o *RoleHandler) GetDataScope(ctx context.Context, nullParams interface{}, rsp *comm_def.CommonMsg) error {
 	roleService, err := service.NewRoleService(ctx)
 	if err != nil {
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	ids, err := roleService.GetDataScope(roleService.GetCxtUserId())
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}

opms_admin/app/handler/user.go

@@ -2,6 +2,7 @@ package handler
 
 import (
 	"context"
+	"dashoo.cn/opms_libary/myerrors"
 
 	"dashoo.cn/common_definition/admin/user_def"
 	"dashoo.cn/opms_libary/micro_srv"
@@ -22,12 +23,10 @@ type UserHandler struct{}
 func (h *UserHandler) GetList(ctx context.Context, req *model.SysUserSearchReq, rsp *comm_def.CommonMsg) error {
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
-		g.Log().Error(err)
 		return err
 	}
 
 	total, list, err := userService.GetUserList(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -53,7 +52,6 @@ func (h *UserHandler) Create(ctx context.Context, req *model.AddUserReq, rsp *co
 	//	return err
 	//}
 	err = userService.CreateUser(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -64,7 +62,7 @@ func (h *UserHandler) Create(ctx context.Context, req *model.AddUserReq, rsp *co
 func (h *UserHandler) UpdateById(ctx context.Context, req *model.EditUserReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
 		return err
@@ -82,7 +80,6 @@ func (h *UserHandler) UpdateById(ctx context.Context, req *model.EditUserReq, rs
 	//	return err
 	//}
 	err = userService.UpdateUser(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -93,7 +90,7 @@ func (h *UserHandler) UpdateById(ctx context.Context, req *model.EditUserReq, rs
 func (e *UserHandler) GetUserInfo(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	// 从上下文中获取用户
 	userId := userService.GetCxtUserId()
@@ -107,24 +104,20 @@ func (e *UserHandler) GetUserInfo(ctx context.Context, req *comm_def.IdReq, rsp
 	}
 	// 获取用户权限 角色
 	userRoles, err := userService.GetUserRoleIds(userId)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
 	roleService, _ := service.NewRoleService(ctx)
 	permissions, err := roleService.GetRolesMenuPermissions(userRoles)
-//	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
 
 	userPosts, err := userService.GetUserPostIds(userId)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
 	userGroups, err := userService.GetUserGroupIds(userId)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -139,18 +132,17 @@ func (e *UserHandler) GetUserInfo(ctx context.Context, req *comm_def.IdReq, rsp
 	return nil
 }
 
-//// GetEntityByUuId 根据UUID获取用户实体信息
+// GetEntityByUuId 根据UUID获取用户实体信息
 //func (e *UserHandler) GetEntityByUuId(ctx context.Context, req *user_def.UuIdReq, rsp *comm_def.CommonMsg) error {
 //	// 参数校验
 //	if req.Uuid == "" {
-//		return NoParamsErr
+//		return myerrors.TipsError("请求参数不存在。")
 //	}
 //	userService, err := service.NewUserService(ctx)
 //	if err != nil {
 //		return gerror.New("系统异常，请重新尝试")
 //	}
 //	data, err := userService.GetEntityByUuId(req.Uuid)
-//	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 //	if err != nil {
 //		return err
 //	}
@@ -162,7 +154,7 @@ func (e *UserHandler) GetUserInfo(ctx context.Context, req *comm_def.IdReq, rsp
 func (h *UserHandler) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if len(req.Ids) == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
@@ -171,7 +163,6 @@ func (h *UserHandler) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp
 	}
 
 	err = userService.DeleteUserByIds(ctx, req.Ids)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -186,10 +177,9 @@ func (e *UserHandler) ResetPassword(ctx context.Context, req *model.SysUserReset
 	// todo:校验用户是否有修改权限
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	err = userService.ResetUserPwd(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -203,10 +193,9 @@ func (e *UserHandler) SetStatus(ctx context.Context, req *model.SysUserStatusReq
 	}
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	err = userService.ChangeUserStatus(req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -217,15 +206,14 @@ func (e *UserHandler) SetStatus(ctx context.Context, req *model.SysUserStatusReq
 func (e *UserHandler) GetUserByDept(ctx context.Context, req *user_def.DeptIdReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.DeptId == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	list, err := userService.GetUserByDept(req.DeptId)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -237,15 +225,14 @@ func (e *UserHandler) GetUserByDept(ctx context.Context, req *user_def.DeptIdReq
 func (e *UserHandler) GetUserByRole(ctx context.Context, req *model.SysUserRoleReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.RoleId == 0 {
-		return NoParamsErr
+		return myerrors.TipsError("请求参数不存在。")
 	}
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 
 	list, err := userService.GetUserByRole(req.RoleId)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	if err != nil {
 		return err
 	}
@@ -425,13 +412,12 @@ func (e *UserHandler) GetUserByRole(ctx context.Context, req *model.SysUserRoleR
 
 // ChangePassword 用户修改密码
 func (e *UserHandler) ChangePassword(ctx context.Context, req *user_def.PWDReq, rsp *comm_def.CommonMsg) error {
-	gvalidErr := gvalid.CheckStruct(ctx, req, nil)
-	if gvalidErr != nil {
-		return gvalidErr.Current()
+	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
+		return err
 	}
 	userService, err := service.NewUserService(ctx)
 	if err != nil {
-		return gerror.New("系统异常，请重新尝试")
+		return err
 	}
 	userInfo, err := micro_srv.GetUserInfo(ctx)
 	if err != nil {
@@ -442,7 +428,6 @@ func (e *UserHandler) ChangePassword(ctx context.Context, req *user_def.PWDReq,
 		OldPassword: req.OldPassword,
 		NewPassword: req.NewPassword,
 	})
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	return err
 }
 

opms_admin/app/model/sys_post.go

@@ -28,6 +28,7 @@ type SysPostReq struct {
 	PostName string `p:"postName" v:"required#岗位名称不能为空"`
 	Sort     int    `p:"sort" v:"required#岗位排序不能为空"`
 	Status   string `p:"status" v:"required|in:10,20#状态不能为空|状态只能为10或20"`
+	RoleIds  []int  `p:"roleIds"`
 	Remark   string `p:"remark"`
 }
 
@@ -36,3 +37,9 @@ type UpdateSysPostReq struct {
 	Id int64 `p:"id" v:"required#id必须"`
 	SysPostReq
 }
+
+// SysPostRes 岗位详情
+type SysPostRes struct {
+	SysPost
+	RoleIds []int `json:"roleIds"`
+}

opms_admin/app/model/sys_user.go

@@ -30,8 +30,8 @@ type LoginUserRes struct {
 	UserPassword string `orm:"user_password"    json:"userPassword"` // 登录密码;cmf_password加密
 	UserSalt     string `orm:"user_salt"        json:"userSalt"`     // 加密盐
 	UserStatus   string `orm:"user_status"      json:"userStatus"`   // 用户状态;0:禁用,1:正常,2:未验证
-	Avatar       string `orm:"avatar" json:"avatar"`                 //头像
-	DeptId       int    `orm:"dept_id"       json:"deptId"`          //部门id
+	Avatar       string `orm:"avatar"           json:"avatar"`       //头像
+	DeptId       int    `orm:"dept_id"          json:"deptId"`       //部门id
 }
 
 // SysUserSearchReq 用户搜索请求参数
@@ -47,6 +47,11 @@ type SysUserSearchReq struct {
 	request.PageReq
 }
 
+type SysUserRes struct {
+	SysUser
+	DeptName string `json:"deptName"` //部门名称
+}
+
 // SetUserReq 添加修改用户公用请求字段
 type SetUserReq struct {
 	DeptId   int    `p:"deptId" v:"required#用户部门不能为空"` //所属部门
@@ -115,8 +120,8 @@ type ProfileUpdatePwdReq struct {
 	NewPassword string `p:"newPassword" v:"required#新密码不能为空"`
 }
 
-// SysUserRes 用于查询用户信息对象
-type SysUserRes struct {
+// SysUserNickNameRes 用于查询用户信息对象
+type SysUserNickNameRes struct {
 	Id           int    `json:"id" orm:"id"`
-	UserNickname string `json:"userNickname" orm:"user_nickname"`
+	UserNickname string `json:"userNickname" orm:"nick_name"`
 }

opms_admin/app/service/context.go

@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"dashoo.cn/opms_libary/myerrors"
 	"fmt"
 	"reflect"
 
@@ -36,16 +37,19 @@ func (c *contextService) Init(ctx context.Context) (*contextService, error) {
 	// 获取租户码
 	tenant, err := micro_srv.GetTenant(ctx)
 	if err != nil {
-		return nil, err
+		return nil, myerrors.MicroCallError(err.Error())
+	}
+	reqMethod, err := micro_srv.GetReqMethod(ctx)
+	if err != nil {
+		return nil, myerrors.MicroCallError(err.Error())
 	}
-	reqMethod, _ := micro_srv.GetReqMethod(ctx)
 	glog.Info("Received " + reqMethod + " request @ " + tenant)
 	c.Tenant = tenant
 	c.CxtUser = nil
 	if !micro_srv.IsAuthExclude(ctx) {
 		userInfo, err := micro_srv.GetUserInfo(ctx)
 		if err != nil {
-			return nil, err
+			return nil, myerrors.MicroCallError(err.Error())
 		}
 		c.CxtUser = &userInfo
 	}
@@ -81,15 +85,15 @@ func (c *contextService) SetDataScopeWhere(M *gdb.Model) (*gdb.Model, error) {
 
 // GetDataScopeWhere 获取数据权限判断条件
 func (c *contextService) GetDataScopeWhere() (where g.Map, err error) {
-	userSrv := &userService{
+	userSrv := &UserService{
 		contextService: c,
 		Dao:            dao.NewSysUserDao(c.Tenant),
 	}
-	roleSrv := &roleService{
+	roleSrv := &RoleService{
 		contextService: c,
 		Dao:            dao.NewSysRoleDao(c.Tenant),
 	}
-	deptSrv := &deptService{
+	deptSrv := &DeptService{
 		contextService: c,
 		Dao:            dao.NewSysDeptDao(c.Tenant),
 	}

opms_admin/app/service/sys_dept.go

@@ -7,13 +7,13 @@ import (
 	"github.com/gogf/gf/util/gconv"
 )
 
-type deptService struct {
+type DeptService struct {
 	*contextService
 	Dao *dao.SysDeptDao
 }
 
-func NewDeptService(ctx context.Context) (svc *deptService, err error) {
-	svc = new(deptService)
+func NewDeptService(ctx context.Context) (svc *DeptService, err error) {
+	svc = new(DeptService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
@@ -22,7 +22,7 @@ func NewDeptService(ctx context.Context) (svc *deptService, err error) {
 	return svc, nil
 }
 
-func (s *deptService) GetList(searchParams *model.SysDeptSearchParams) ([]*model.SysDept, error) {
+func (s *DeptService) GetList(searchParams *model.SysDeptSearchParams) ([]*model.SysDept, error) {
 	deptModel := s.Dao.M
 	if searchParams.DeptName != "" {
 		deptModel = deptModel.WhereLike("dept_name", "%"+searchParams.DeptName+"%")
@@ -47,7 +47,7 @@ func (s *deptService) GetList(searchParams *model.SysDeptSearchParams) ([]*model
 	}
 }
 
-func (s *deptService) GetRoleDepts(roleId int) ([]int, error) {
+func (s *DeptService) GetRoleDepts(roleId int) ([]int, error) {
 	var entityList []*model.SysRoleDept
 	err := s.Dao.Where("role_id", roleId).Scan(&entityList)
 	if err != nil {
@@ -60,7 +60,7 @@ func (s *deptService) GetRoleDepts(roleId int) ([]int, error) {
 	return result, nil
 }
 
-func (s *deptService) FindSonByParentId(depts []*model.SysDept, deptId int) []*model.SysDept {
+func (s *DeptService) FindSonByParentId(depts []*model.SysDept, deptId int) []*model.SysDept {
 	children := make([]*model.SysDept, 0, len(depts))
 	for _, v := range depts {
 		if v.ParentId == deptId {
@@ -72,7 +72,7 @@ func (s *deptService) FindSonByParentId(depts []*model.SysDept, deptId int) []*m
 	return children
 }
 
-func (s *deptService) GetDeptListTree(pid int, list []*model.SysDept) []*model.SysDeptTreeRes {
+func (s *DeptService) GetDeptListTree(pid int, list []*model.SysDept) []*model.SysDeptTreeRes {
 	tree := make([]*model.SysDeptTreeRes, 0, len(list))
 	for _, v := range list {
 		if v.ParentId == pid {
@@ -89,12 +89,12 @@ func (s *deptService) GetDeptListTree(pid int, list []*model.SysDept) []*model.S
 	return tree
 }
 
-func (s *deptService) GetDeptById(id int64) (dept *model.SysDept, err error) {
+func (s *DeptService) GetDeptById(id int64) (dept *model.SysDept, err error) {
 	err = s.Dao.Where("id", id).Scan(&dept)
 	return
 }
 
-func (s *deptService) Create(req *model.SysDeptReq) (err error) {
+func (s *DeptService) Create(req *model.SysDeptReq) (err error) {
 	data := new(model.SysDept)
 	if err := gconv.Struct(req, data); err != nil {
 		return err
@@ -104,7 +104,7 @@ func (s *deptService) Create(req *model.SysDeptReq) (err error) {
 	return
 }
 
-func (s *deptService) UpdateById(req *model.UpdateSysDeptReq) error {
+func (s *DeptService) UpdateById(req *model.UpdateSysDeptReq) error {
 	data := new(model.SysDept)
 	if err := gconv.Struct(req, data); err != nil {
 		return err
@@ -115,7 +115,7 @@ func (s *deptService) UpdateById(req *model.UpdateSysDeptReq) error {
 	return err
 }
 
-func (s *deptService) DeleteById(id int) error {
+func (s *DeptService) DeleteById(id int) error {
 	var list []*model.SysDept
 	err := s.Dao.Scan(&list)
 	if err != nil {

opms_admin/app/service/sys_dict_data.go

@@ -11,13 +11,13 @@ import (
 	"github.com/gogf/gf/util/gconv"
 )
 
-type dictDataService struct {
+type DictDataService struct {
 	*contextService
 	Dao *dao.SysDictDataDao
 }
 
-func NewDictDataService(ctx context.Context) (svc *dictDataService, err error) {
-	svc = new(dictDataService)
+func NewDictDataService(ctx context.Context) (svc *DictDataService, err error) {
+	svc = new(DictDataService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
@@ -26,7 +26,7 @@ func NewDictDataService(ctx context.Context) (svc *dictDataService, err error) {
 	return svc, nil
 }
 
-func (s *dictDataService) GetDictDataList(req *model.SelectDictPageReq) (total int, list []*model.SysDictData, err error) {
+func (s *DictDataService) GetDictDataList(req *model.SelectDictPageReq) (total int, list []*model.SysDictData, err error) {
 	db := s.Dao.Ctx(req.Ctx)
 	if req != nil {
 		if req.DictLabel != "" {
@@ -55,7 +55,7 @@ func (s *dictDataService) GetDictDataList(req *model.SelectDictPageReq) (total i
 }
 
 // GetDictDataById 通过字典数据id获取字典数据
-func (s *dictDataService) GetDictDataById(id int64) (data *model.SysDictData, err error) {
+func (s *DictDataService) GetDictDataById(id int64) (data *model.SysDictData, err error) {
 	data, err = s.Dao.FindOne(s.Dao.Columns.DictCode, id)
 	if err != nil {
 		g.Log().Error(err)
@@ -69,7 +69,7 @@ func (s *dictDataService) GetDictDataById(id int64) (data *model.SysDictData, er
 }
 
 // GetDictWithDataByType 通过字典键类型获取选项
-func (s *dictDataService) GetDictWithDataByType(req *model.GetDictReq) (dict *model.DictRes, err error) {
+func (s *DictDataService) GetDictWithDataByType(req *model.GetDictReq) (dict *model.DictRes, err error) {
 	//从数据库获取
 	dict = &model.DictRes{}
 	//获取类型数据
@@ -101,7 +101,7 @@ func (s *dictDataService) GetDictWithDataByType(req *model.GetDictReq) (dict *mo
 }
 
 // CheckDictTypeUniqueAll 检查字典类型是否唯一
-func (s *dictDataService) CheckDictTypeUniqueAll(dictType string) bool {
+func (s *DictDataService) CheckDictTypeUniqueAll(dictType string) bool {
 	dict, err := s.Dao.FindOne(s.Dao.Columns.DictType+"=?", dictType)
 	if err != nil {
 		g.Log().Error(err)
@@ -114,7 +114,7 @@ func (s *dictDataService) CheckDictTypeUniqueAll(dictType string) bool {
 }
 
 // Create 添加保存字典数据
-func (s *dictDataService) Create(req *model.DictDataAddReq) (id int64, err error) {
+func (s *DictDataService) Create(req *model.DictDataAddReq) (id int64, err error) {
 	var res sql.Result
 	data := new(model.SysDictData)
 	if err := gconv.Struct(req, data); err != nil {
@@ -132,7 +132,7 @@ func (s *dictDataService) Create(req *model.DictDataAddReq) (id int64, err error
 }
 
 // UpdateByDict 修改字典数据
-func (s *dictDataService) UpdateByDict(req *model.EditDictDataReq) (err error) {
+func (s *DictDataService) UpdateByDict(req *model.EditDictDataReq) (err error) {
 	data := new(model.SysDictData)
 	if err := gconv.Struct(req, data); err != nil {
 		return err
@@ -144,7 +144,7 @@ func (s *dictDataService) UpdateByDict(req *model.EditDictDataReq) (err error) {
 }
 
 // DeleteDictDataByIds 删除字典数据
-func (s *dictDataService) DeleteDictDataByIds(ids []int64) error {
+func (s *DictDataService) DeleteDictDataByIds(ids []int64) error {
 	_, err := s.Dao.Where(s.Dao.Columns.DictCode+" in(?)", ids).Delete()
 	if err != nil {
 		g.Log().Error(err)

opms_admin/app/service/sys_dict_type.go

@@ -12,13 +12,13 @@ import (
 	"github.com/gogf/gf/util/gconv"
 )
 
-type dictTypeService struct {
+type DictTypeService struct {
 	*contextService
 	Dao *dao.SysDictTypeDao
 }
 
-func NewDictTypeService(ctx context.Context) (svc *dictTypeService, err error) {
-	svc = new(dictTypeService)
+func NewDictTypeService(ctx context.Context) (svc *DictTypeService, err error) {
+	svc = new(DictTypeService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
@@ -27,7 +27,7 @@ func NewDictTypeService(ctx context.Context) (svc *dictTypeService, err error) {
 	return svc, nil
 }
 
-func (s *dictTypeService) GetList(req *model.ListSysDictTypeReq) (total int, list []*model.SysDictType, err error) {
+func (s *DictTypeService) GetList(req *model.ListSysDictTypeReq) (total int, list []*model.SysDictType, err error) {
 	db := s.Dao
 	if req.DictName != "" {
 		db.Where(s.Dao.Columns.DictName+" like ?", "%"+req.DictName+"%")
@@ -53,7 +53,7 @@ func (s *dictTypeService) GetList(req *model.ListSysDictTypeReq) (total int, lis
 }
 
 // GetDictById 获取字典类型
-func (s *dictTypeService) GetDictById(id int64) (dict *model.SysDictType, err error) {
+func (s *DictTypeService) GetDictById(id int64) (dict *model.SysDictType, err error) {
 	dict, err = s.Dao.FindOne(s.Dao.Columns.Id, id)
 	if err != nil {
 		g.Log().Error(err)
@@ -67,7 +67,7 @@ func (s *dictTypeService) GetDictById(id int64) (dict *model.SysDictType, err er
 }
 
 // GetAllDictType 获取所有正常状态下的字典类型
-func (s *dictTypeService) GetAllDictType() (list []*model.SysDictType, err error) {
+func (s *DictTypeService) GetAllDictType() (list []*model.SysDictType, err error) {
 	err = s.Dao.Where("status", 1).Order("dict_id ASC").Scan(&list)
 	if err != nil {
 		g.Log().Error(err)
@@ -78,7 +78,7 @@ func (s *dictTypeService) GetAllDictType() (list []*model.SysDictType, err error
 }
 
 // ExistsDictType 检查类型是否已经存在
-func (s *dictTypeService) ExistsDictType(dictType string, dictId ...int64) bool {
+func (s *DictTypeService) ExistsDictType(dictType string, dictId ...int64) bool {
 	d := s.Dao.Fields(s.Dao.Columns.Id).Where(s.Dao.Columns.DictType, dictType)
 	if len(dictId) > 0 {
 		d = d.And(s.Dao.Columns.Id+" !=? ", dictId)
@@ -94,7 +94,7 @@ func (s *dictTypeService) ExistsDictType(dictType string, dictId ...int64) bool
 	return false
 }
 
-func (s *dictTypeService) Create(req *model.SysDictTypeAddReq) error {
+func (s *DictTypeService) Create(req *model.SysDictTypeAddReq) error {
 	data := new(model.SysDictType)
 	if err := gconv.Struct(req, data); err != nil {
 		return err
@@ -108,14 +108,14 @@ func (s *dictTypeService) Create(req *model.SysDictTypeAddReq) error {
 	return err
 }
 
-func (s *dictTypeService) UpdateById(req *model.SysDictTypeEditReq) error {
+func (s *DictTypeService) UpdateById(req *model.SysDictTypeEditReq) error {
 	err := s.Dao.Transaction(s.Dao.GetCtx(), func(ctx context.Context, tx *gdb.TX) error {
 		dt, err := s.Dao.Fields(dao.SysDictType.Columns.DictType).FindOne(req.Id)
 		if err != nil {
 			return err
 		}
 		if dt == nil {
-			return myerrors.TipsError( "字典不存在")
+			return myerrors.TipsError("字典不存在")
 		}
 		//修改字典类型
 		data := new(model.SysDictType)
@@ -140,7 +140,7 @@ func (s *dictTypeService) UpdateById(req *model.SysDictTypeEditReq) error {
 	return err
 }
 
-func (s *dictTypeService) Delete(dictIds []int64) (err error) {
+func (s *DictTypeService) Delete(dictIds []int64) (err error) {
 	discs := ([]*model.SysDictType)(nil)
 	discs, err = s.Dao.Fields(s.Dao.Columns.DictType).Where(s.Dao.Columns.Id+" in (?) ", dictIds).All()
 	if err != nil {

opms_admin/app/service/sys_group.go

@@ -9,13 +9,13 @@ import (
 	"github.com/gogf/gf/util/gconv"
 )
 
-type groupService struct {
+type GroupService struct {
 	*contextService
 	Dao *dao.SysGroupDao
 }
 
-func NewGroupService(ctx context.Context) (svc *groupService, err error) {
-	svc = new(groupService)
+func NewGroupService(ctx context.Context) (svc *GroupService, err error) {
+	svc = new(GroupService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
@@ -24,7 +24,7 @@ func NewGroupService(ctx context.Context) (svc *groupService, err error) {
 	return svc, nil
 }
 
-func (s *groupService) GetList(req *model.SysGroupSearchParams) (total int, list []*model.SysGroup, err error) {
+func (s *GroupService) GetList(req *model.SysGroupSearchParams) (total int, list []*model.SysGroup, err error) {
 	db := s.Dao.M
 	if req != nil {
 		if req.GroupCode != "" {
@@ -53,12 +53,12 @@ func (s *groupService) GetList(req *model.SysGroupSearchParams) (total int, list
 	return
 }
 
-func (s *groupService) GetEntity(id int64) (group *model.SysGroup, err error) {
+func (s *GroupService) GetEntity(id int64) (group *model.SysGroup, err error) {
 	err = s.Dao.WherePri(id).Scan(&group)
 	return
 }
 
-func (s *groupService) Create(params *model.SysGroupReq) error {
+func (s *GroupService) Create(params *model.SysGroupReq) error {
 	data := new(model.SysGroup)
 	if err := gconv.Struct(params, data); err != nil {
 		return err
@@ -68,7 +68,7 @@ func (s *groupService) Create(params *model.SysGroupReq) error {
 	return err
 }
 
-func (s *groupService) UpdateById(params *model.UpdateSysGroupReq) (err error) {
+func (s *GroupService) UpdateById(params *model.UpdateSysGroupReq) (err error) {
 	data := new(model.SysGroup)
 	if err := gconv.Struct(params, data); err != nil {
 		return err
@@ -78,7 +78,7 @@ func (s *groupService) UpdateById(params *model.UpdateSysGroupReq) (err error) {
 	return err
 }
 
-func (s *groupService) DeleteByIds(ids []int64) error {
+func (s *GroupService) DeleteByIds(ids []int64) error {
 	_, err := s.Dao.WhereIn(s.Dao.Columns.Id, ids).Delete()
 	return err
 }

opms_admin/app/service/sys_login_log.go

@@ -14,14 +14,14 @@ import (
 	"github.com/mssola/user_agent"
 )
 
-type loginLogService struct {
+type LoginLogService struct {
 	*contextService
 	Dao  *dao.SysLoginDao
 	Pool *grpool.Pool
 }
 
-func NewLoginLogService(ctx context.Context) (svc *loginLogService, err error) {
-	svc = new(loginLogService)
+func NewLoginLogService(ctx context.Context) (svc *LoginLogService, err error) {
+	svc = new(LoginLogService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
@@ -31,14 +31,14 @@ func NewLoginLogService(ctx context.Context) (svc *loginLogService, err error) {
 	return svc, nil
 }
 
-func (s *loginLogService) Invoke(ctx context.Context, userName, msg string) {
+func (s *LoginLogService) Invoke(ctx context.Context, userName, msg string) {
 	s.Pool.Add(func() {
 		//写入日志数据
 		s.Create(ctx, userName, msg)
 	})
 }
 
-func (s *loginLogService) GetList(req *model.SysLoginLogSearchReq) (total int, list []*model.SysLogin, err error) {
+func (s *LoginLogService) GetList(req *model.SysLoginLogSearchReq) (total int, list []*model.SysLogin, err error) {
 	db := s.Dao.M
 	order := "info_id DESC"
 	if req.LoginName != "" {
@@ -82,7 +82,7 @@ func (s *loginLogService) GetList(req *model.SysLoginLogSearchReq) (total int, l
 }
 
 // Create 记录登录日志
-func (s *loginLogService) Create(ctx context.Context, userName, msg string) {
+func (s *LoginLogService) Create(ctx context.Context, userName, msg string) {
 	clientIP, userAgent, err := micro_srv.GetBrowserInfo(ctx)
 	if err != nil {
 		// 非必要信息，只输出错误日志
@@ -113,7 +113,7 @@ func (s *loginLogService) Create(ctx context.Context, userName, msg string) {
 	}
 }
 
-func (s *loginLogService) DeleteByIds(ids []int64) (err error) {
+func (s *LoginLogService) DeleteByIds(ids []int64) (err error) {
 	if len(ids) == 0 {
 		err = gerror.New("参数错误")
 		return
@@ -126,7 +126,7 @@ func (s *loginLogService) DeleteByIds(ids []int64) (err error) {
 	return
 }
 
-func (s *loginLogService) ClearLoginLog() (err error) {
+func (s *LoginLogService) ClearLoginLog() (err error) {
 	_, err = s.Dao.DB.Exec("truncate " + s.Table)
 	if err != nil {
 		g.Log().Error(err)

opms_admin/app/service/sys_menu.go

@@ -15,13 +15,13 @@ import (
 	"github.com/gogf/gf/util/gconv"
 )
 
-type menuService struct {
+type MenuService struct {
 	*contextService
 	Dao *dao.SysMenuDao
 }
 
-func NewMenuService(ctx context.Context) (svc *menuService, err error) {
-	svc = new(menuService)
+func NewMenuService(ctx context.Context) (svc *MenuService, err error) {
+	svc = new(MenuService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
@@ -31,7 +31,7 @@ func NewMenuService(ctx context.Context) (svc *menuService, err error) {
 }
 
 // Create 添加菜单项
-func (s menuService) Create(param *model.SysMenuReq) (id int64, err error) {
+func (s MenuService) Create(param *model.SysMenuReq) (id int64, err error) {
 	// 菜单类型 M目录C菜单 F按钮
 	if param.MenuType == "F" && param.Perms == "" {
 		return -1, errors.New("权限标识不能为空！")
@@ -66,7 +66,7 @@ func (s menuService) Create(param *model.SysMenuReq) (id int64, err error) {
 }
 
 // UpdateById 根据ID更新菜单项
-func (s menuService) UpdateById(param *model.SysMenuReq) error {
+func (s MenuService) UpdateById(param *model.SysMenuReq) error {
 	// 菜单类型 M目录C菜单 F按钮
 	if param.MenuType == "F" && param.Perms == "" {
 		return gerror.New("权限标识不能为空！")
@@ -106,7 +106,7 @@ func (s menuService) UpdateById(param *model.SysMenuReq) error {
 	return err
 }
 
-func (s menuService) Delete(id int64) (err error) {
+func (s MenuService) Delete(id int64) (err error) {
 	db := s.Dao
 	record, err := db.FindOne("Id", id)
 	if err != nil {
@@ -120,7 +120,7 @@ func (s menuService) Delete(id int64) (err error) {
 }
 
 // GetEntity 获取菜单项实体
-func (s menuService) GetEntity(id int64) (*model.SysMenu, error) {
+func (s MenuService) GetEntity(id int64) (*model.SysMenu, error) {
 	one, err := s.Dao.M.FindOne(id)
 	if err != nil {
 		return nil, err
@@ -136,7 +136,7 @@ func (s menuService) GetEntity(id int64) (*model.SysMenu, error) {
 }
 
 // GetList 获取菜单列表
-func (s menuService) GetList(param *menu_def.SelectReq) ([]model.SysMenu, error) {
+func (s MenuService) GetList(param *menu_def.SelectReq) ([]model.SysMenu, error) {
 	db := s.Dao.M
 	if param != nil {
 		if param.Title != "" {
@@ -164,7 +164,7 @@ func (s menuService) GetList(param *menu_def.SelectReq) ([]model.SysMenu, error)
 }
 
 // GetMenuTree 获取菜单树
-func (s menuService) GetMenuTree(isAll bool) ([]model.MenuTree, error) {
+func (s MenuService) GetMenuTree(isAll bool) ([]model.MenuTree, error) {
 	menuType := g.Slice{"M", "C"}
 	if isAll {
 		menuType = g.Slice{"M", "C", "F"}
@@ -184,7 +184,7 @@ func (s menuService) GetMenuTree(isAll bool) ([]model.MenuTree, error) {
 }
 
 // GetUserRoleMenuTree 用户获取角色菜单树
-func (s menuService) GetUserRoleMenuTree(roles []int) ([]model.MenuTree, error) {
+func (s MenuService) GetUserRoleMenuTree(roles []int) ([]model.MenuTree, error) {
 	menuList := make([]model.SysMenu, 0)
 	err := s.Dao.Where(s.Dao.Columns.Status, "10").WhereIn(s.Dao.Columns.MenuType, g.Slice{"M", "C"}).
 		WhereIn(s.Dao.Columns.Id, dao.NewSysRoleMenuDao(s.Tenant).WhereIn(dao.SysRoleMenu.Columns.RoleId, roles).Fields(dao.SysRoleMenu.Columns.MenuId)).
@@ -205,7 +205,7 @@ func (s menuService) GetUserRoleMenuTree(roles []int) ([]model.MenuTree, error)
 }
 
 // getChildrenList 获取菜单的子菜单
-func (s menuService) getChildrenList(menu *model.MenuTree, treeMap map[int][]model.MenuTree) {
+func (s MenuService) getChildrenList(menu *model.MenuTree, treeMap map[int][]model.MenuTree) {
 	if value, ok := treeMap[menu.Id]; ok {
 		menu.Children = value
 		for i := 0; i < len(menu.Children); i++ {

opms_admin/app/service/sys_post.go

@@ -4,27 +4,30 @@ import (
 	"context"
 	"dashoo.cn/micro/app/dao"
 	"dashoo.cn/micro/app/model"
+	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
 	"github.com/gogf/gf/util/gconv"
 )
 
-type postService struct {
+type PostService struct {
 	*contextService
-	Dao *dao.SysPostDao
+	Dao         *dao.SysPostDao
+	postRoleDao *dao.SysPostRoleDao
 }
 
-func NewPostService(ctx context.Context) (svc *postService, err error) {
-	svc = new(postService)
+func NewPostService(ctx context.Context) (svc *PostService, err error) {
+	svc = new(PostService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
 	svc.Dao = dao.NewSysPostDao(svc.Tenant)
+	svc.postRoleDao = dao.NewSysPostRoleDao(svc.Tenant)
 	svc.Table = svc.Dao.Table
 	return svc, nil
 }
 
-func (s *postService) GetList(req *model.SysPostSearchParams) (total int, list []*model.SysPost, err error) {
+func (s *PostService) GetList(req *model.SysPostSearchParams) (total int, list []*model.SysPost, err error) {
 	db := s.Dao.M
 	if req != nil {
 		if req.PostCode != "" {
@@ -53,32 +56,80 @@ func (s *postService) GetList(req *model.SysPostSearchParams) (total int, list [
 	return
 }
 
-func (s *postService) GetEntity(id int64) (post *model.SysPost, err error) {
-	err = s.Dao.WherePri(id).Scan(&post)
+func (s *PostService) GetEntity(id int64) (post *model.SysPostRes, err error) {
+	post = new(model.SysPostRes)
+	err = s.Dao.WherePri(id).Scan(&post.SysPost)
+	if err != nil {
+		return nil, err
+	}
+	result, err := s.postRoleDao.Fields(dao.SysPostRole.Columns.RoleId).WherePri(dao.SysPostRole.Columns.PostId, id).Array()
+	if err != nil {
+		return nil, err
+	}
+	post.RoleIds = gconv.Ints(result)
 	return
 }
 
-func (s *postService) Create(params *model.SysPostReq) error {
+func (s *PostService) Create(params *model.SysPostReq) error {
 	data := new(model.SysPost)
 	if err := gconv.Struct(params, data); err != nil {
 		return err
 	}
 	SetCreatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
-	_, err := s.Dao.Insert(data)
+	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
+		lastId, err := s.Dao.TX(tx).InsertAndGetId(data)
+		if err != nil {
+			return err
+		}
+		err = s.AddPostRole(lastId, params.RoleIds, tx)
+		return err
+	})
 	return err
 }
 
-func (s *postService) UpdateById(params *model.UpdateSysPostReq) (err error) {
+// AddPostRole 添加岗位角色
+func (s *PostService) AddPostRole(postId int64, roleIds []int, tx *gdb.TX) (err error) {
+	//删除旧岗位角色信息
+	_, err = s.postRoleDao.TX(tx).Where(dao.SysPostRole.Columns.PostId, postId).Delete()
+	if err != nil {
+		return
+	}
+	if len(roleIds) == 0 {
+		return
+	}
+	//添加岗位角色
+	data := g.List{}
+	for _, v := range roleIds {
+		data = append(data, g.Map{
+			dao.SysPostRole.Columns.PostId: postId,
+			dao.SysPostRole.Columns.RoleId: v,
+		})
+	}
+	_, err = s.postRoleDao.TX(tx).Data(data).Insert()
+	if err != nil {
+		return
+	}
+	return
+}
+
+func (s *PostService) UpdateById(params *model.UpdateSysPostReq) (err error) {
 	data := new(model.SysPost)
 	if err := gconv.Struct(params, data); err != nil {
 		return err
 	}
 	SetUpdatedInfo(data, s.GetCxtUserId(), s.GetCxtUserName())
-	_, err = s.Dao.FieldsEx(UpdateFieldEx...).WherePri(params.Id).Update(data)
+	err = s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
+		_, err := s.Dao.FieldsEx(UpdateFieldEx...).WherePri(params.Id).Update(data)
+		if err != nil {
+			return err
+		}
+		err = s.AddPostRole(params.Id, params.RoleIds, tx)
+		return err
+	})
 	return err
 }
 
-func (s *postService) DeleteByIds(ids []int64) error {
+func (s *PostService) DeleteByIds(ids []int64) error {
 	_, err := s.Dao.WhereIn(s.Dao.Columns.Id, ids).Delete()
 	return err
 }

opms_admin/app/service/sys_role.go

@@ -12,15 +12,15 @@ import (
 	"github.com/gogf/gf/util/gconv"
 )
 
-type roleService struct {
+type RoleService struct {
 	*contextService
 	Dao         *dao.SysRoleDao
 	roleMenuDao *dao.SysRoleMenuDao
 	roleDeptDao *dao.SysRoleDeptDao
 }
 
-func NewRoleService(ctx context.Context) (svc *roleService, err error) {
-	svc = new(roleService)
+func NewRoleService(ctx context.Context) (svc *RoleService, err error) {
+	svc = new(RoleService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
@@ -32,7 +32,7 @@ func NewRoleService(ctx context.Context) (svc *roleService, err error) {
 }
 
 // GetRoleList 获取角色列表
-func (s *roleService) GetRoleList() (list []*model.SysRole, err error) {
+func (s *RoleService) GetRoleList() (list []*model.SysRole, err error) {
 	//从数据库获取
 	list, err = s.Dao.Order(s.Dao.Columns.Sort + " asc," + s.Dao.Columns.Id + " asc").All()
 	if err != nil {
@@ -42,7 +42,7 @@ func (s *roleService) GetRoleList() (list []*model.SysRole, err error) {
 	return
 }
 
-func (s *roleService) GetRoleListSearch(req *model.SelectPageReq) (total int, list []*model.SysRole, err error) {
+func (s *RoleService) GetRoleListSearch(req *model.SelectPageReq) (total int, list []*model.SysRole, err error) {
 	db := dao.SysRole.M
 	if req.RoleName != "" {
 		db = db.Where("role_name like ?", "%"+req.RoleName+"%")
@@ -71,7 +71,7 @@ func (s *roleService) GetRoleListSearch(req *model.SelectPageReq) (total int, li
 	return
 }
 
-func (s *roleService) GetRoleById(id int64) (roleInfo *model.UpdateSysRoleReq, err error) {
+func (s *RoleService) GetRoleById(id int64) (roleInfo *model.UpdateSysRoleReq, err error) {
 	roleInfo = new(model.UpdateSysRoleReq)
 	role := new(model.SysRole)
 	err = s.Dao.WherePri(id).Scan(&role)
@@ -90,7 +90,7 @@ func (s *roleService) GetRoleById(id int64) (roleInfo *model.UpdateSysRoleReq, e
 	return
 }
 
-func (s *roleService) GetRoleDeptTreeselect(id int64) (deptIds []int, err error) {
+func (s *RoleService) GetRoleDeptTreeselect(id int64) (deptIds []int, err error) {
 	count, err := s.Dao.WherePri(id).Count()
 	if err != nil || count == 0 {
 		return nil, gerror.New("角色不存在")
@@ -107,7 +107,7 @@ func (s *roleService) GetRoleDeptTreeselect(id int64) (deptIds []int, err error)
 }
 
 // GetRolesMenuPermissions 获取角色菜单权限
-func (s *roleService) GetRolesMenuPermissions(ids []int) (perms []string, err error) {
+func (s *RoleService) GetRolesMenuPermissions(ids []int) (perms []string, err error) {
 	result, err := dao.NewSysMenuDao(s.Tenant).Fields(dao.SysMenu.Columns.Perms).WhereIn(dao.SysMenu.Columns.MenuType, g.Slice{"C", "F"}).
 		WhereIn(dao.SysMenu.Columns.Id, s.roleMenuDao.WhereIn(s.roleMenuDao.Columns.RoleId, ids).Fields(s.roleMenuDao.Columns.MenuId)).
 		WhereNot(dao.SysMenu.Columns.Perms, "").Array()
@@ -115,7 +115,7 @@ func (s *roleService) GetRolesMenuPermissions(ids []int) (perms []string, err er
 	return perms, err
 }
 
-func (s *roleService) CreateRole(req *model.SysRoleReq) error {
+func (s *RoleService) CreateRole(req *model.SysRoleReq) error {
 	data := new(model.SysRole)
 	if err := gconv.Struct(req, data); err != nil {
 		return err
@@ -131,7 +131,7 @@ func (s *roleService) CreateRole(req *model.SysRoleReq) error {
 	return err
 }
 
-func (s *roleService) UpdateRole(req *model.UpdateSysRoleReq) error {
+func (s *RoleService) UpdateRole(req *model.UpdateSysRoleReq) error {
 	//保存角色信息
 	roleMap := gdb.Map{
 		"id":        req.Id,
@@ -157,7 +157,7 @@ func (s *roleService) UpdateRole(req *model.UpdateSysRoleReq) error {
 }
 
 // 角色关联菜单
-func (s *roleService) createRoleMenu(tx *gdb.TX, roleId int64, menuIds []int) error {
+func (s *RoleService) createRoleMenu(tx *gdb.TX, roleId int64, menuIds []int) error {
 	list := g.Slice{}
 	for _, v := range menuIds {
 		list = append(list, g.Map{
@@ -172,7 +172,7 @@ func (s *roleService) createRoleMenu(tx *gdb.TX, roleId int64, menuIds []int) er
 	return nil
 }
 
-func (s *roleService) DeleteByIds(ids []int64) (err error) {
+func (s *RoleService) DeleteByIds(ids []int64) (err error) {
 	err = s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
 		_, err = s.Dao.TX(tx).Where("id in(?)", ids).Delete()
 		if err != nil {
@@ -191,13 +191,13 @@ func (s *roleService) DeleteByIds(ids []int64) (err error) {
 	return err
 }
 
-func (s *roleService) UpdateRoleStatus(req *model.StatusSetReq) error {
+func (s *RoleService) UpdateRoleStatus(req *model.StatusSetReq) error {
 	_, err := s.Dao.Where(s.Dao.Columns.Id, req.RoleId).Data(s.Dao.Columns.Status, req.Status).Update()
 	return err
 }
 
 // 设置角色数据权限
-func (s *roleService) UpdateRoleDataScope(req *model.DataScopeReq) error {
+func (s *RoleService) UpdateRoleDataScope(req *model.DataScopeReq) error {
 	err := s.Dao.Transaction(context.TODO(), func(ctx context.Context, tx *gdb.TX) error {
 		_, err := s.Dao.TX(tx).Where("id", req.RoleId).Data(g.Map{"data_scope": req.DataScope}).Update()
 		if err != nil {
@@ -223,7 +223,7 @@ func (s *roleService) UpdateRoleDataScope(req *model.DataScopeReq) error {
 }
 
 // GetMaxRoleDataScopeByUser 获取用户所拥有的角色最高数据权限
-func (s *roleService) GetMaxRoleDataScopeByUser(userId int) (string, []int, error) {
+func (s *RoleService) GetMaxRoleDataScopeByUser(userId int) (string, []int, error) {
 	roleIds, err := dao.NewSysUserRoleDao(s.Tenant).Fields(dao.SysUserRole.Columns.RoleId).Where(dao.SysUserRole.Columns.UserId, userId).Array()
 	if err != nil {
 		return "", nil, err
@@ -254,7 +254,7 @@ func (s *roleService) GetMaxRoleDataScopeByUser(userId int) (string, []int, erro
 }
 
 // GetDataScope 获取某用户数据集合权限，返回Ids(用户Id列表)，返回-1表示无角色，返回-2表示有全部集合权限
-func (s *roleService) GetDataScope(userId int) (ids string, err error) {
+func (s *RoleService) GetDataScope(userId int) (ids string, err error) {
 	userDao := dao.NewSysUserDao(s.Tenant)
 	_, err = userDao.WherePri(userId).FindOne()
 	if err != nil {
@@ -297,7 +297,7 @@ func (s *roleService) GetDataScope(userId int) (ids string, err error) {
 			return "", err
 		}
 
-		deptSrv := &deptService{
+		deptSrv := &DeptService{
 			contextService: s.contextService,
 			Dao:            dao.NewSysDeptDao(s.Tenant),
 		}

opms_admin/app/service/sys_user.go

@@ -4,8 +4,10 @@ import (
 	"context"
 	"dashoo.cn/micro/app/dao"
 	"dashoo.cn/micro/app/model"
+	"dashoo.cn/opms_libary/myerrors"
 	"dashoo.cn/opms_libary/request"
 	"dashoo.cn/opms_libary/utils"
+	"database/sql"
 	"errors"
 	"github.com/gogf/gf/container/gset"
 	"github.com/gogf/gf/database/gdb"
@@ -15,7 +17,7 @@ import (
 	"github.com/gogf/gf/util/grand"
 )
 
-type userService struct {
+type UserService struct {
 	*contextService
 	Dao          *dao.SysUserDao
 	userRoleDao  *dao.SysUserRoleDao
@@ -23,8 +25,8 @@ type userService struct {
 	userGroupDao *dao.SysUserGroupDao
 }
 
-func NewUserService(ctx context.Context) (svc *userService, err error) {
-	svc = new(userService)
+func NewUserService(ctx context.Context) (svc *UserService, err error) {
+	svc = new(UserService)
 	if svc.contextService, err = svc.Init(ctx); err != nil {
 		return nil, err
 	}
@@ -37,7 +39,7 @@ func NewUserService(ctx context.Context) (svc *userService, err error) {
 }
 
 // Login 用户登录，成功返回用户UUID，否则返回空字符串;
-func (s *userService) Login(username, password string) (*request.UserInfo, error) {
+func (s *UserService) Login(username, password string) (*request.UserInfo, error) {
 	record, err := s.Dao.Where("user_name", username).Where("status='10'").FindOne()
 	if err != nil {
 		return nil, gerror.New("系统异常")
@@ -65,8 +67,8 @@ func (s *userService) Login(username, password string) (*request.UserInfo, error
 	return userInfo, nil
 }
 
-func (s *userService) GetUserList(req *model.SysUserSearchReq) (total int, userList []*model.SysUser, err error) {
-	userModel := s.Dao.M
+func (s *UserService) GetUserList(req *model.SysUserSearchReq) (total int, userList []*model.SysUserRes, err error) {
+	userModel := s.Dao.M.LeftJoin(dao.SysDept.Table, "dept", "sys_user.dept_id=dept.id").Fields(dao.SysDept.Columns.DeptName)
 	if req.KeyWords != "" {
 		keyWords := "%" + req.KeyWords + "%"
 		userModel = userModel.Where("sys_user.user_name like ? or  sys_user.nick_name like ?", keyWords, keyWords)
@@ -90,16 +92,16 @@ func (s *userService) GetUserList(req *model.SysUserSearchReq) (total int, userL
 		userModel = userModel.WhereLTE("sys_user.created_time", req.EndTime)
 	}
 	if len(req.Roles) > 0 {
-		sql := dao.NewSysRoleDao(s.Tenant).Fields(dao.SysRole.Columns.Id).WhereIn(dao.SysRole.Columns.RoleKey, req.Roles)
-		userModel = userModel.LeftJoin(dao.SysUserRole.Table, "ur", "sys_user.id=ur.user_id").WhereIn("ur.role_id", sql)
+		insql := dao.NewSysRoleDao(s.Tenant).Fields(dao.SysRole.Columns.Id).WhereIn(dao.SysRole.Columns.RoleKey, req.Roles)
+		userModel = userModel.LeftJoin(dao.SysUserRole.Table, "ur", "sys_user.id=ur.user_id").WhereIn("ur.role_id", insql)
 	}
 	if len(req.Posts) > 0 {
-		sql := dao.NewSysPostDao(s.Tenant).Fields(dao.SysPost.Columns.Id).WhereIn(dao.SysPost.Columns.PostCode, req.Posts)
-		userModel = userModel.LeftJoin(dao.SysUserPost.Table, "up", "sys_user.id=up.user_id").WhereIn("up.post_id", sql)
+		insql := dao.NewSysPostDao(s.Tenant).Fields(dao.SysPost.Columns.Id).WhereIn(dao.SysPost.Columns.PostCode, req.Posts)
+		userModel = userModel.LeftJoin(dao.SysUserPost.Table, "up", "sys_user.id=up.user_id").WhereIn("up.post_id", insql)
 	}
 	if len(req.Groups) > 0 {
-		sql := dao.NewSysGroupDao(s.Tenant).Fields(dao.SysGroup.Columns.Id).WhereIn(dao.SysGroup.Columns.GroupCode, req.Groups)
-		userModel = userModel.LeftJoin(dao.SysUserGroup.Table, "ug", "sys_user.id=ug.user_id").WhereIn("ug.group_id", sql)
+		insql := dao.NewSysGroupDao(s.Tenant).Fields(dao.SysGroup.Columns.Id).WhereIn(dao.SysGroup.Columns.GroupCode, req.Groups)
+		userModel = userModel.LeftJoin(dao.SysUserGroup.Table, "ug", "sys_user.id=ug.user_id").WhereIn("ug.group_id", insql)
 	}
 	if userModel, err = s.SetDataScopeWhere(userModel); err != nil {
 		return 0, nil, err
@@ -107,16 +109,15 @@ func (s *userService) GetUserList(req *model.SysUserSearchReq) (total int, userL
 
 	total, err = userModel.Count()
 	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("获取总行数失败")
 		return
 	}
-	err = userModel.Fields("sys_user.*").Group("sys_user.id").Page(req.PageNum, req.PageSize).Order("id asc").Scan(&userList)
+	err = userModel.Fields("sys_user.*").FieldsEx(s.Dao.Columns.Password, s.Dao.Columns.UserSalt).
+		Group("sys_user.id").Page(req.PageNum, req.PageSize).Order("sys_user.id asc").Scan(&userList)
 	return
 }
 
 // GetUserByDept 获取部门下用户
-func (s *userService) GetUserByDept(deptId int) (userList []*model.SysUser, err error) {
+func (s *UserService) GetUserByDept(deptId int) (userList []*model.SysUser, err error) {
 	count, err := dao.NewSysDeptDao(s.Tenant).Where(dao.SysDept.Columns.Id, deptId).Where(dao.SysDept.Columns.Status, "10").Count()
 	if err != nil {
 		return nil, err
@@ -124,12 +125,12 @@ func (s *userService) GetUserByDept(deptId int) (userList []*model.SysUser, err
 	if count == 0 {
 		return nil, gerror.New("部门不存在或已停用")
 	}
-	err = s.Dao.Where(s.Dao.Columns.DeptId, deptId).FieldsEx(dao.SysUser.Columns.Password, dao.SysUser.Columns.UserSalt).Scan(&userList)
+	err = s.Dao.Where(s.Dao.Columns.DeptId, deptId).FieldsEx(s.Dao.Columns.Password, s.Dao.Columns.UserSalt).Scan(&userList)
 	return userList, err
 }
 
 // GetUserByRole 获取角色关联的用户
-func (s *userService) GetUserByRole(roleId int) (userList []*model.SysUser, err error) {
+func (s *UserService) GetUserByRole(roleId int) (userList []*model.SysUser, err error) {
 	count, err := dao.NewSysRoleDao(s.Tenant).Where(dao.SysRole.Columns.Id, roleId).Where(dao.SysRole.Columns.Status, "10").Count()
 	if err != nil {
 		return nil, err
@@ -138,14 +139,14 @@ func (s *userService) GetUserByRole(roleId int) (userList []*model.SysUser, err
 		return nil, gerror.New("角色不存在或已停用")
 	}
 	userList = make([]*model.SysUser, 0)
-	err = s.Dao.FieldsEx(dao.SysUser.Columns.Password, dao.SysUser.Columns.UserSalt).Where(s.Dao.Columns.Status, "10").
+	err = s.Dao.FieldsEx(s.Dao.Columns.Password, s.Dao.Columns.UserSalt).Where(s.Dao.Columns.Status, "10").
 		WhereIn(s.Dao.Columns.Id, dao.NewSysUserRoleDao(s.Tenant).Fields(dao.SysUserRole.Columns.UserId).WhereIn(dao.SysUserRole.Columns.RoleId, roleId)).
 		Scan(&userList)
 	return userList, err
 }
 
 // GetAdminUserByUsernamePassword 后台登陆验证
-func (s *userService) GetAdminUserByUsernamePassword(ctx context.Context, req *model.LoginParamsReq) (user *model.LoginUserRes, err error) {
+func (s *UserService) GetAdminUserByUsernamePassword(ctx context.Context, req *model.LoginParamsReq) (user *model.LoginUserRes, err error) {
 	user, err = s.GetUserByUsernamePassword(ctx, req)
 	if err != nil {
 		return
@@ -158,7 +159,7 @@ func (s *userService) GetAdminUserByUsernamePassword(ctx context.Context, req *m
 }
 
 // GetUserByUsernamePassword 登陆验证
-func (s *userService) GetUserByUsernamePassword(ctx context.Context, req *model.LoginParamsReq) (user *model.LoginUserRes, err error) {
+func (s *UserService) GetUserByUsernamePassword(ctx context.Context, req *model.LoginParamsReq) (user *model.LoginUserRes, err error) {
 	user, err = s.GetUserByUsername(ctx, req.Username)
 	if err != nil {
 		return
@@ -178,19 +179,26 @@ func (s *userService) GetUserByUsernamePassword(ctx context.Context, req *model.
 }
 
 // GetUserByUsername 通过用户名获取用户信息
-func (s *userService) GetUserByUsername(ctx context.Context, userName string) (user *model.LoginUserRes, err error) {
-	return dao.SysUser.FindByUsername(ctx, userName)
+func (s *UserService) GetUserByUsername(ctx context.Context, userName string) (user *model.LoginUserRes, err error) {
+	user = &model.LoginUserRes{}
+	err = s.Dao.Ctx(ctx).Fields(user).Where(s.Dao.Columns.UserName, userName).Scan(user)
+	if err != nil {
+		return nil, err
+	}
+	if err == sql.ErrNoRows {
+		return nil, myerrors.TipsError("用户信息不存在")
+	}
+	return user, nil
 }
 
 // GetUserInfoById 通过Id获取用户信息
-func (s *userService) GetUserInfoById(id int, withPwd ...bool) (user *model.SysUser, err error) {
+func (s *UserService) GetUserInfoById(id int, withPwd ...bool) (user *model.SysUser, err error) {
 	if len(withPwd) > 0 && withPwd[0] {
 		//用户用户信息
-		err = dao.SysUser.Where(dao.SysUser.Columns.Id, id).Scan(&user)
+		err = s.Dao.Where(s.Dao.Columns.Id, id).Scan(&user)
 	} else {
 		//用户用户信息
-		err = dao.SysUser.Where(dao.SysUser.Columns.Id, id).
-			FieldsEx(dao.SysUser.Columns.Password, dao.SysUser.Columns.UserSalt).Scan(&user)
+		err = s.Dao.Where(s.Dao.Columns.Id, id).FieldsEx(s.Dao.Columns.Password, s.Dao.Columns.UserSalt).Scan(&user)
 	}
 	if err != nil {
 		g.Log().Error(err)
@@ -200,7 +208,7 @@ func (s *userService) GetUserInfoById(id int, withPwd ...bool) (user *model.SysU
 }
 
 // GetUserPermission 获取用户权限字符（角色、岗位、用户组）
-func (s *userService) GetUserPermission(userId int) ([]string, []string, []string, error) {
+func (s *UserService) GetUserPermission(userId int) ([]string, []string, []string, error) {
 	s.userRoleDao = dao.NewSysUserRoleDao(s.Tenant)
 	s.userPostDao = dao.NewSysUserPostDao(s.Tenant)
 	s.userGroupDao = dao.NewSysUserGroupDao(s.Tenant)
@@ -227,7 +235,7 @@ func (s *userService) GetUserPermission(userId int) ([]string, []string, []strin
 }
 
 // GetUserRoleIds 获取用户角色
-func (s *userService) GetUserRoleIds(userId int) (roleIds []int, err error) {
+func (s *UserService) GetUserRoleIds(userId int) (roleIds []int, err error) {
 	s.userRoleDao = dao.NewSysUserRoleDao(s.Tenant)
 	list, err := s.userRoleDao.Where(dao.SysUserRole.Columns.UserId, userId).All()
 	if err != nil {
@@ -242,7 +250,7 @@ func (s *userService) GetUserRoleIds(userId int) (roleIds []int, err error) {
 }
 
 // GetUserPostIds 获取用户岗位
-func (s *userService) GetUserPostIds(userId int) (postIds []int, err error) {
+func (s *UserService) GetUserPostIds(userId int) (postIds []int, err error) {
 	s.userPostDao = dao.NewSysUserPostDao(s.Tenant)
 	list, err := s.userPostDao.Where(dao.SysUserPost.Columns.UserId, userId).All()
 	if err != nil {
@@ -257,7 +265,7 @@ func (s *userService) GetUserPostIds(userId int) (postIds []int, err error) {
 }
 
 // GetUserGroupIds 获取用户的用户组
-func (s *userService) GetUserGroupIds(userId int) (postIds []int, err error) {
+func (s *UserService) GetUserGroupIds(userId int) (postIds []int, err error) {
 	s.userGroupDao = dao.NewSysUserGroupDao(s.Tenant)
 	list, err := s.userGroupDao.Where(dao.SysUserGroup.Columns.UserId, userId).All()
 	if err != nil {
@@ -272,7 +280,7 @@ func (s *userService) GetUserGroupIds(userId int) (postIds []int, err error) {
 }
 
 // GetRolesByUserId 根据用户id获取岗位信息详情
-func (s *userService) GetRolesByUserId(userId int) ([]*model.SysRole, error) {
+func (s *UserService) GetRolesByUserId(userId int) ([]*model.SysRole, error) {
 	roleIds, err := s.GetUserRoleIds(userId)
 	if err != nil {
 		return nil, err
@@ -282,7 +290,7 @@ func (s *userService) GetRolesByUserId(userId int) ([]*model.SysRole, error) {
 }
 
 // GetPostsByUserId 根据用户id获取岗位信息详情
-func (s *userService) GetPostsByUserId(userId int) ([]*model.SysPost, error) {
+func (s *UserService) GetPostsByUserId(userId int) ([]*model.SysPost, error) {
 	postIds, err := s.GetUserPostIds(userId)
 	if err != nil {
 		return nil, err
@@ -291,14 +299,14 @@ func (s *userService) GetPostsByUserId(userId int) ([]*model.SysPost, error) {
 	return posts, err
 }
 
-func (s *userService) CreateUser(req *model.AddUserReq) (err error) {
+func (s *UserService) CreateUser(req *model.AddUserReq) (err error) {
 	var tx *gdb.TX
 	tx, err = g.DB().Begin()
 	if err != nil {
 		err = gerror.New("事务开启失败")
 		return
 	}
-	Model := dao.SysUser.TX(tx)
+	Model := s.Dao.TX(tx)
 	if i, _ := Model.Where("user_name=?", req.UserName).Count(); i != 0 {
 		err = gerror.New("用户名已经存在")
 		tx.Rollback()
@@ -332,7 +340,7 @@ func (s *userService) CreateUser(req *model.AddUserReq) (err error) {
 }
 
 // AddUserOtherInfo 重新设置用户相关其他表信息
-func (s *userService) AddUserOtherInfo(req model.SetUserReq, insertId int64, tx *gdb.TX) (err error) {
+func (s *UserService) AddUserOtherInfo(req model.SetUserReq, insertId int64, tx *gdb.TX) (err error) {
 	// 设置用户角色信息
 	err = s.AddUserRole(req.RoleIds, insertId, tx)
 	if err != nil {
@@ -361,9 +369,10 @@ func (s *userService) AddUserOtherInfo(req model.SetUserReq, insertId int64, tx
 }
 
 // AddUserRole 添加用户角色信息
-func (s *userService) AddUserRole(roleIds []int, userId int64, tx *gdb.TX) (err error) {
+func (s *UserService) AddUserRole(roleIds []int, userId int64, tx *gdb.TX) (err error) {
+	s.userRoleDao = dao.NewSysUserRoleDao(s.Tenant)
 	//删除旧用户角色信息
-	_, err = dao.SysUserRole.TX(tx).Where(dao.SysUserPost.Columns.UserId, userId).Delete()
+	_, err = s.userRoleDao.TX(tx).Where(dao.SysUserPost.Columns.UserId, userId).Delete()
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -379,7 +388,7 @@ func (s *userService) AddUserRole(roleIds []int, userId int64, tx *gdb.TX) (err
 			dao.SysUserRole.Columns.RoleId: v,
 		})
 	}
-	_, err = dao.SysUserRole.TX(tx).Data(data).Insert()
+	_, err = s.userRoleDao.TX(tx).Data(data).Insert()
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -388,9 +397,10 @@ func (s *userService) AddUserRole(roleIds []int, userId int64, tx *gdb.TX) (err
 }
 
 // AddUserPost 添加用户岗位信息
-func (s *userService) AddUserPost(postIds []int, userId int64, tx *gdb.TX) (err error) {
+func (s *UserService) AddUserPost(postIds []int, userId int64, tx *gdb.TX) (err error) {
+	s.userPostDao = dao.NewSysUserPostDao(s.Tenant)
 	//删除旧岗位信息
-	_, err = dao.SysUserPost.TX(tx).Where(dao.SysUserPost.Columns.UserId, userId).Delete()
+	_, err = s.userPostDao.TX(tx).Where(dao.SysUserPost.Columns.UserId, userId).Delete()
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -406,7 +416,7 @@ func (s *userService) AddUserPost(postIds []int, userId int64, tx *gdb.TX) (err
 			dao.SysUserPost.Columns.PostId: v,
 		})
 	}
-	_, err = dao.SysUserPost.TX(tx).Data(data).Insert()
+	_, err = s.userPostDao.TX(tx).Data(data).Insert()
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -415,9 +425,10 @@ func (s *userService) AddUserPost(postIds []int, userId int64, tx *gdb.TX) (err
 }
 
 // AddUserGroup 添加用户的用户组信息
-func (s *userService) AddUserGroup(groupIds []int, userId int64, tx *gdb.TX) (err error) {
+func (s *UserService) AddUserGroup(groupIds []int, userId int64, tx *gdb.TX) (err error) {
+	s.userGroupDao = dao.NewSysUserGroupDao(s.Tenant)
 	//删除旧用户组信息
-	_, err = dao.SysUserGroup.TX(tx).Where(dao.SysUserGroup.Columns.UserId, userId).Delete()
+	_, err = s.userGroupDao.TX(tx).Where(dao.SysUserGroup.Columns.UserId, userId).Delete()
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -435,7 +446,7 @@ func (s *userService) AddUserGroup(groupIds []int, userId int64, tx *gdb.TX) (er
 			dao.SysUserGroup.Columns.CreatedName: v,
 		})
 	}
-	_, err = dao.SysUserGroup.TX(tx).Data(data).Insert()
+	_, err = s.userGroupDao.TX(tx).Data(data).Insert()
 	if err != nil {
 		g.Log().Error(err)
 		return
@@ -444,8 +455,8 @@ func (s *userService) AddUserGroup(groupIds []int, userId int64, tx *gdb.TX) (er
 }
 
 // UpdateUser 修改用户
-func (s *userService) UpdateUser(req *model.EditUserReq) (err error) {
-	if i, _ := dao.SysUser.Where("id!=? and phone=?", req.Id, req.Phone).Count(); i != 0 {
+func (s *UserService) UpdateUser(req *model.EditUserReq) (err error) {
+	if i, _ := s.Dao.Where("id!=? and phone=?", req.Id, req.Phone).Count(); i != 0 {
 		err = gerror.New("手机号已经存在")
 		return
 	}
@@ -453,7 +464,7 @@ func (s *userService) UpdateUser(req *model.EditUserReq) (err error) {
 	tx, err = g.DB().Begin()
 	//保存管理员信息
 	var userData *model.SysUser
-	err = dao.SysUser.Where("id", req.Id).Scan(&userData)
+	err = s.Dao.Where("id", req.Id).Scan(&userData)
 	if err != nil || userData == nil {
 		g.Log().Error(err)
 		err = gerror.New("获取用户信息失败")
@@ -464,8 +475,8 @@ func (s *userService) UpdateUser(req *model.EditUserReq) (err error) {
 		return
 	}
 	SetUpdatedInfo(userData, s.GetCxtUserId(), s.GetCxtUserName())
-	_, err = dao.SysUser.TX(tx).FieldsEx(dao.SysUser.Columns.Id, dao.SysUser.Columns.CreatedTime,
-		dao.SysUser.Columns.DeletedTime, dao.SysUser.Columns.LoginDate).
+	_, err = s.Dao.TX(tx).FieldsEx(s.Dao.Columns.Id, s.Dao.Columns.CreatedTime,
+		s.Dao.Columns.DeletedTime, s.Dao.Columns.LoginDate).
 		WherePri(userData.Id).Update(userData)
 	if err != nil {
 		g.Log().Error(err)
@@ -481,31 +492,31 @@ func (s *userService) UpdateUser(req *model.EditUserReq) (err error) {
 }
 
 // ResetUserPwd 重置用户密码
-func (s *userService) ResetUserPwd(req *model.SysUserResetPwdReq) error {
+func (s *UserService) ResetUserPwd(req *model.SysUserResetPwdReq) error {
 	salt := grand.S(10)
 	password := utils.EncryptPassword(req.Password, salt)
 	data := g.Map{
-		dao.SysUser.Columns.UserSalt: salt,
-		dao.SysUser.Columns.Password: password,
+		s.Dao.Columns.UserSalt: salt,
+		s.Dao.Columns.Password: password,
 	}
 	SetCurrentUpdatedInfo(data, s.CxtUser)
-	_, err := dao.SysUser.WherePri(req.Id).Update()
+	_, err := s.Dao.WherePri(req.Id).Update()
 	return err
 }
 
-func (s *userService) ChangeUserStatus(req *model.SysUserStatusReq) error {
+func (s *UserService) ChangeUserStatus(req *model.SysUserStatusReq) error {
 	data := g.Map{
-		dao.SysUser.Columns.Status: req.UserStatus,
+		s.Dao.Columns.Status: req.UserStatus,
 	}
 	SetCurrentUpdatedInfo(data, s.CxtUser)
-	_, err := dao.SysUser.WherePri(req.Id).Update()
+	_, err := s.Dao.WherePri(req.Id).Update()
 	return err
 }
 
 // DeleteUserByIds 删除用户信息
-func (s *userService) DeleteUserByIds(ctx context.Context, ids []int64) error {
+func (s *UserService) DeleteUserByIds(ctx context.Context, ids []int64) error {
 	return g.DB().Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
-		_, err := s.Dao.Ctx(ctx).TX(tx).Where(dao.SysUser.Columns.Id+" in(?)", ids).Delete()
+		_, err := s.Dao.Ctx(ctx).TX(tx).Where(s.Dao.Columns.Id+" in(?)", ids).Delete()
 		//删除用户对应的岗位
 		_, err = dao.SysUserPost.Ctx(ctx).TX(tx).Delete(dao.SysUserPost.Columns.UserId+" in (?)", ids)
 		return err
@@ -513,21 +524,21 @@ func (s *userService) DeleteUserByIds(ctx context.Context, ids []int64) error {
 }
 
 // SetAvatar 修改用户头像
-func (s *userService) SetAvatar(userId int, avatarUrl string) error {
-	_, err := dao.SysUser.WherePri(userId).Unscoped().Update(g.Map{
-		dao.SysUser.Columns.Avatar: avatarUrl,
+func (s *UserService) SetAvatar(userId int, avatarUrl string) error {
+	_, err := s.Dao.WherePri(userId).Unscoped().Update(g.Map{
+		s.Dao.Columns.Avatar: avatarUrl,
 	})
 	return err
 }
 
 // ProfileEdit 修改个人资料
-func (s *userService) ProfileEdit(req *model.ProfileUpReq) error {
-	_, err := dao.SysUser.WherePri(req.UserId).Unscoped().Update(req)
+func (s *UserService) ProfileEdit(req *model.ProfileUpReq) error {
+	_, err := s.Dao.WherePri(req.UserId).Unscoped().Update(req)
 	return err
 }
 
 // ProfileUpdatePwd 修改个人密码
-func (s *userService) ProfileUpdatePwd(req *model.ProfileUpdatePwdReq) error {
+func (s *UserService) ProfileUpdatePwd(req *model.ProfileUpdatePwdReq) error {
 	userInfo, err := s.GetUserInfoById(req.UserId, true)
 	if err != nil {
 		return err
@@ -539,21 +550,21 @@ func (s *userService) ProfileUpdatePwd(req *model.ProfileUpdatePwdReq) error {
 	salt := grand.S(10)
 	newPassword := utils.EncryptPassword(req.NewPassword, salt)
 	data := g.Map{
-		dao.SysUser.Columns.UserSalt: salt,
-		dao.SysUser.Columns.Password: newPassword,
+		s.Dao.Columns.UserSalt: salt,
+		s.Dao.Columns.Password: newPassword,
 	}
 	SetCurrentUpdatedInfo(data, s.CxtUser)
-	_, err = dao.SysUser.WherePri(req.UserId).Unscoped().Update(data)
+	_, err = s.Dao.WherePri(req.UserId).Unscoped().Update(data)
 	return err
 }
 
-// GetUsers 通过用户ids查询多个用户信息
-func (s *userService) GetUsers(ids []int) (users []*model.SysUserRes, err error) {
+// GetUsersNickName 通过用户ids查询多个用户信息
+func (s *UserService) GetUsersNickName(ids []int) (users []*model.SysUserNickNameRes, err error) {
 	if len(ids) == 0 {
 		return
 	}
 	idsSet := gset.NewIntSetFrom(ids).Slice()
-	err = dao.SysUser.Where(dao.SysUser.Columns.Id+" in(?)", idsSet).Fields(model.SysUserRes{}).
-		Order(dao.SysUser.Columns.Id + " ASC").Scan(&users)
+	err = s.Dao.Where(s.Dao.Columns.Id+" in(?)", idsSet).Fields(model.SysUserNickNameRes{}).
+		Order(s.Dao.Columns.Id + " ASC").Scan(&users)
 	return
 }

opms_admin/config/config.toml

@@ -20,6 +20,12 @@
         updatedAt = "updated_time"
         deletedAt = "deleted_time"
         link = "mysql:root:Dashoo#190801@ali@tcp(192.168.0.252:3306)/dashoo_crm"
+    [[database.cp5vbwxy]]
+        Debug = true
+        createdAt = "created_time"
+        updatedAt = "updated_time"
+        deletedAt = "deleted_time"
+        link = "mysql:root:Bgt5^yhn@tcp(sh-cynosdbmysql-grp-caipe5bm.sql.tencentcdb.com:20185)/opms"
 
 # token认证设置
 [gtoken]

opms_admin/main.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"dashoo.cn/micro/app/handler"
 	"dashoo.cn/opms_libary/micro_srv"
+	"dashoo.cn/opms_libary/myerrors"
 	"github.com/gogf/gf/frame/g"
 	"github.com/smallnest/rpcx/protocol"
 )
@@ -28,6 +29,9 @@ func main() {
 	//dynamic.BeanFactory.BeanRegister(service.NewRoleService())
 	// 注册auth处理
 	s.AuthFunc = handleAuth
+	// 错误拦截
+	s.Plugins.Add(&myerrors.HandleErrorPlugin{})
+
 	// 运行服务
 	if err := s.Serve("tcp", srvAddr); err != nil {
 		g.Log().Fatal(err)