feature:基础模块开发

1.菜单管理
2.用户管理
3.字典管理

opms_admin/app/dao/internal/sys_menu.go

@@ -35,12 +35,13 @@ type sysMenuColumns struct {
 	IsFrame     string // 是否为外链（10是20否）
 	IsCache     string // 是否缓存（10缓存20不缓存）
 	MenuType    string // 菜单类型（M目录C菜单 F按钮）
-	Visible     string // 菜单状态（10显示20隐藏）
+	Visible     string // 显示状态（10显示20隐藏）
 	Status      string // 菜单状态（10正常20停用）
 	Perms       string // 权限标识
 	Icon        string // 菜单图标
 	PlatformId  string // 所属平台
 	Sort        string // 显示顺序
+	ActiveMenu  string // 高亮路由
 	Remark      string // 备注
 	CreatedBy   string // 创建者
 	CreatedName string // 创建人
@@ -73,6 +74,7 @@ var (
 			Icon:        "icon",
 			PlatformId:  "platform_id",
 			Sort:        "sort",
+			ActiveMenu:  "active_menu",
 			Remark:      "remark",
 			CreatedBy:   "created_by",
 			CreatedName: "created_name",
@@ -107,6 +109,7 @@ func NewSysMenuDao(tenant string) SysMenuDao {
 			Icon:        "icon",
 			PlatformId:  "platform_id",
 			Sort:        "sort",
+			ActiveMenu:  "active_menu",
 			Remark:      "remark",
 			CreatedBy:   "created_by",
 			CreatedName: "created_name",

opms_admin/app/handler/dict.go

@@ -0,0 +1,227 @@
+package handler
+
+import (
+	"context"
+	"dashoo.cn/common_definition/comm_def"
+	"dashoo.cn/micro/app/model"
+	"dashoo.cn/micro/app/service"
+	"dashoo.cn/opms_libary/myerrors"
+	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/glog"
+	"github.com/gogf/gf/util/gvalid"
+)
+
+type Dict struct{}
+
+// GetDictTypeList 分页查询字典分类列表信息
+func (c *Dict) GetDictTypeList(ctx context.Context, req *model.ListSysDictTypeReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	// 设置默认的页数
+	if req.PageSize == 0 {
+		req.PageSize = DefaultPageNum
+	}
+	dictService, err := service.NewDictTypeService(ctx)
+	if flag, err, _, _ := myerrors.CheckError(err); flag {
+		return err
+	}
+
+	total, list, err := dictService.GetList(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		g.Log().Error(err)
+		return err
+	}
+	rsp.Data = g.Map{"list": list, "total": total}
+	return nil
+}
+
+// GetDictTypeEntity 根据id获取字典分类详情信息
+func (c *Dict) GetDictTypeEntity(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if req.Id == 0 {
+		return NoParamsErr
+	}
+	dictService, err := service.NewDictTypeService(ctx)
+	if flag, err, _, _ := myerrors.CheckError(err); flag {
+		return err
+	}
+
+	data, err := dictService.GetDictById(req.Id)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		g.Log().Error(err)
+		return err
+	}
+	rsp.Data = data
+	return nil
+}
+
+// CreateDictType 添加字典分类
+func (c *Dict) CreateDictType(ctx context.Context, req *model.SysDictTypeAddReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
+		return err
+	}
+	dictService, err := service.NewDictTypeService(ctx)
+	if flag, err, _, _ := myerrors.CheckError(err); flag {
+		return err
+	}
+
+	err = dictService.Create(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	return err
+}
+
+// UpdateDictType 更新字典分类信息
+func (c *Dict) UpdateDictType(ctx context.Context, req *model.SysDictTypeEditReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
+		return err
+	}
+	dictService, err := service.NewDictTypeService(ctx)
+	if flag, err, _, _ := myerrors.CheckError(err); flag {
+		return err
+	}
+
+	err = dictService.UpdateById(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	return err
+}
+
+// DeleteDictTypeByIds 删除字典分类 支持批量删除
+func (c *Dict) DeleteDictTypeByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if len(req.Ids) == 0 {
+		return NoParamsErr
+	}
+	dictService, err := service.NewDictTypeService(ctx)
+	if err != nil {
+		return err
+	}
+
+	err = dictService.Delete(req.Ids)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	return err
+}
+
+// 字典明细数据相关
+
+// GetDictDataList 分页查询字典明细列表信息
+func (c *Dict) GetDictDataList(ctx context.Context, req *model.SelectDictPageReq, rsp *comm_def.CommonMsg) error {
+	dictService, err := service.NewDictDataService(ctx)
+	if err != nil {
+		return err
+	}
+	if req.PageSize == 0 {
+		req.PageSize = DefaultPageNum
+	}
+	total, list, err := dictService.GetDictDataList(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		glog.Error(err)
+		return err
+	}
+	rsp.Data = g.Map{"list": list, "total": total}
+	return nil
+}
+
+// GetDictDataEntity 根据id获取字典明细详情信息
+func (c *Dict) GetDictDataEntity(ctx context.Context, req *comm_def.IdReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if req.Id == 0 {
+		return NoParamsErr
+	}
+	dictService, err := service.NewDictDataService(ctx)
+	if err != nil {
+		return err
+	}
+
+	data, err := dictService.GetDictDataById(req.Id)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		glog.Error(err)
+		return err
+	}
+	rsp.Data = data
+	return nil
+}
+
+// GetDictDataByType 根据字典类型获取字典项明细
+func (c *Dict) GetDictDataByType(ctx context.Context, req *model.GetDictReq, rsp *comm_def.CommonMsg) error {
+	dictService, err := service.NewDictDataService(ctx)
+	if err != nil {
+		return err
+	}
+
+	list, err := dictService.GetDictWithDataByType(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		glog.Error(err)
+		return err
+	}
+	rsp.Data = list
+	return nil
+}
+
+// CreateDictData 添加字典明细
+func (c *Dict) CreateDictData(ctx context.Context, req *model.DictDataAddReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
+		return err
+	}
+
+	dictService, err := service.NewDictDataService(ctx)
+	if err != nil {
+		return err
+	}
+
+	_, err = dictService.Create(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		glog.Error(err)
+		return err
+
+	}
+	return nil
+}
+
+// UpdateDictData 更新字典明细信息
+func (c *Dict) UpdateDictData(ctx context.Context, req *model.EditDictDataReq, rsp *comm_def.CommonMsg) error {
+	// 参数校验
+	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
+		return err
+	}
+
+	dictService, err := service.NewDictDataService(ctx)
+	if err != nil {
+		return err
+	}
+
+	err = dictService.UpdateByDict(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		glog.Error(err)
+		return err
+	}
+	return nil
+}
+
+// DeleteDictDataByIds 删除字典明细 支持批量删除
+func (c *Dict) DeleteDictDataByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
+	// 参数验证
+	if len(req.Ids) == 0 {
+		return NoParamsErr
+	}
+	dictService, err := service.NewDictDataService(ctx)
+	if err != nil {
+		return err
+	}
+
+	err = dictService.DeleteDictDataByIds(req.Ids)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		glog.Error(err)
+		return err
+	}
+	return nil
+}

opms_admin/app/handler/menu.go

@@ -50,8 +50,8 @@ func (o *Menu) GetEntityById(ctx context.Context, req *comm_def.IdReq, rsp *comm
 	return nil
 }
 
-// Add 添加
-func (o *Menu) Add(ctx context.Context, req *model.SysMenuReq, rsp *comm_def.CommonMsg) error {
+// Create 添加
+func (o *Menu) 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)
@@ -62,7 +62,7 @@ func (o *Menu) Add(ctx context.Context, req *model.SysMenuReq, rsp *comm_def.Com
 		g.Log().Error(err)
 		return gerror.New("系统异常，请重新尝试")
 	}
-	id, err := menuService.Add(ctx, req)
+	id, err := menuService.Create(req)
 	_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	rsp.Data = gconv.String(id)
 	return nil
@@ -86,7 +86,7 @@ func (o *Menu) UpdateById(ctx context.Context, req *model.SysMenuReq, rsp *comm_
 		return gerror.New("系统异常，请重新尝试")
 	}
 
-	err = menuService.UpdateById(ctx, req)
+	err = menuService.UpdateById(req)
 	_, _, rsp.Code, rsp.Msg = myerrors.CheckError(err)
 	return nil
 }

opms_admin/app/handler/user.go

@@ -2,11 +2,9 @@ package handler
 
 import (
 	"context"
-	"dashoo.cn/common_definition/admin/user_def"
 	"dashoo.cn/micro/app/model"
 	"dashoo.cn/micro/app/service"
 	"dashoo.cn/opms_libary/myerrors"
-	"dashoo.cn/opms_libary/utils"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/util/gvalid"
 
@@ -39,8 +37,8 @@ func (e *User) GetList(ctx context.Context, req *model.SysUserSearchReq, rsp *co
 	return nil
 }
 
-// Add 添加用户
-func (e *User) Add(ctx context.Context, req *model.AddUserReq, rsp *comm_def.CommonMsg) error {
+// Create 添加用户
+func (e *User) Create(ctx context.Context, req *model.AddUserReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
 		return err
@@ -65,8 +63,8 @@ func (e *User) Add(ctx context.Context, req *model.AddUserReq, rsp *comm_def.Com
 	return nil
 }
 
-// Update 更新用户
-func (e *User) Update(ctx context.Context, req *user_def.UpdateReq, rsp *comm_def.CommonMsg) error {
+// UpdateById 更新用户
+func (e *User) UpdateById(ctx context.Context, req *model.EditUserReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if req.Id == 0 {
 		return NoParamsErr
@@ -74,24 +72,24 @@ func (e *User) Update(ctx context.Context, req *user_def.UpdateReq, rsp *comm_de
 	if err := gvalid.CheckStruct(ctx, req, nil); err != nil {
 		return err
 	}
-	req.RoleIds = utils.IntArrayToIdsString(req.RoleArray)
-	req.PostIds = utils.IntArrayToIdsString(req.PostArray)
-	//userService, err := service.NewUserService(ctx)
-	//if err != nil {
-	//	g.Log().Error(err)
-	//	return err
-	//}
-	//// 获取用户信息
+	//req.RoleIds = utils.IntArrayToIdsString(req.RoleArray)
+	//req.PostIds = utils.IntArrayToIdsString(req.PostArray)
+	userService, err := service.NewUserService(ctx)
+	if err != nil {
+		g.Log().Error(err)
+		return err
+	}
+	// 获取用户信息
 	//userInfo, err := micro_srv.GetUserInfo(ctx)
 	//if err != nil {
 	//	return err
 	//}
-	//err = userService.EditUser(userInfo, req)
-	//_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
-	//if err != nil {
-	//	g.Log().Error(err)
-	//	return err
-	//}
+	err = userService.EditUser(req)
+	_, err, rsp.Code, rsp.Msg = myerrors.CheckError(err)
+	if err != nil {
+		g.Log().Error(err)
+		return err
+	}
 	return nil
 }
 
@@ -171,8 +169,8 @@ func (e *User) Update(ctx context.Context, req *user_def.UpdateReq, rsp *comm_de
 //	return nil
 //}
 
-// DeleteUserByIds 删除 支持批量删除
-func (e *User) DeleteUserByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
+// DeleteByIds 删除 支持批量删除
+func (e *User) DeleteByIds(ctx context.Context, req *comm_def.IdsReq, rsp *comm_def.CommonMsg) error {
 	// 参数校验
 	if len(req.Ids) == 0 {
 		return NoParamsErr

opms_admin/app/model/internal/sys_menu.go

@@ -25,6 +25,7 @@ type SysMenu struct {
 	Icon        string      `orm:"icon"         json:"icon"`        // 菜单图标
 	PlatformId  int         `orm:"platform_id"  json:"platformId"`  // 所属平台
 	Sort        int         `orm:"sort"         json:"sort"`        // 显示顺序
+	ActiveMenu  string      `orm:"active_menu"  json:"activeMenu"`  // 高亮路由
 	Remark      string      `orm:"remark"       json:"remark"`      // 备注
 	CreatedBy   int         `orm:"created_by"   json:"createdBy"`   // 创建者
 	CreatedName string      `orm:"created_name" json:"createdName"` // 创建人

opms_admin/app/model/sys_dict_data.go

@@ -57,10 +57,10 @@ type DictDataAddReq struct {
 	DictSort  int    `p:"dictSort"  v:"integer#排序只能为整数"`
 	CssClass  string `p:"cssClass"`
 	ListClass string `p:"listClass"`
-	IsDefault int    `p:"isDefault" v:"required|in:0,1#系统默认不能为空|默认值只能为0或1"`
-	Status    int    `p:"status"    v:"required|in:0,1#状态不能为空|状态只能为0或1"`
-	Remark    string `p:"remark"`
-	CreateBy  uint64
+	//IsDefault string `p:"isDefault" v:"required|in:10,20#系统默认不能为空|默认值只能为10或20"`
+	Status   string `p:"status"    v:"required|in:10,20#状态不能为空|状态只能为10或20"`
+	Remark   string `p:"remark"`
+	CreateBy uint64
 }
 
 // EditDictDataReq 修改字典数据操作请求参数

opms_admin/app/model/sys_dict_type.go

@@ -7,7 +7,6 @@ package model
 import (
 	comModel "dashoo.cn/micro/app/common/model"
 	"dashoo.cn/micro/app/model/internal"
-	"github.com/gogf/gf/os/gtime"
 )
 
 // SysDictType is the golang structure for table sys_dict_type.
@@ -16,32 +15,23 @@ type SysDictType internal.SysDictType
 // Fill with you ideas below.
 
 type ListSysDictTypeReq struct {
-	DictName string `p:"dictName"` //字典名称
-	DictType string `p:"dictType"` //字典类型
-	Status   string `p:"status"`   //字典状态
+	DictName string `json:"dictName"` //字典名称
+	DictType string `json:"dictType"` //字典类型
+	Status   string `json:"status"`   //字典状态
 	comModel.PageReq
 }
 
 // SysDictTypeAddReq 新增操作请求参数
 type SysDictTypeAddReq struct {
-	DictName string `p:"dictName"  v:"required#字典名称不能为空"`
-	DictType string `p:"dictType"  v:"required#字典类型不能为空"`
-	Status   uint   `p:"status"  v:"required|in:0,1#状态不能为空|状态只能为0或1"`
-	Remark   string `p:"remark"`
+	DictName string `json:"dictName"  v:"required#字典名称不能为空"`
+	DictType string `json:"dictType"  v:"required#字典类型不能为空"`
+	Status   string `json:"status"  v:"required|in:10,20#状态不能为空|状态只能为10或20"`
+	Remark   string `json:"remark"`
 	CreateBy uint64
 }
 
 type SysDictTypeEditReq struct {
 	SysDictTypeAddReq
-	DictId   int64 `p:dictId v:required|min:1#主键ID不能为空|主键ID必须为大于0的值`
+	Id       int64 `json:"id v:required|min:1#主键ID不能为空|主键ID必须为大于0的值"`
 	UpdateBy uint64
 }
-
-type SysDictTypeInfoRes struct {
-	DictId    uint64      `orm:"dict_id,primary"  json:"dictId"`    // 字典主键
-	DictName  string      `orm:"dict_name"        json:"dictName"`  // 字典名称
-	DictType  string      `orm:"dict_type,unique" json:"dictType"`  // 字典类型
-	Status    uint        `orm:"status"           json:"status"`    // 状态（0正常 1停用）
-	Remark    string      `orm:"remark"           json:"remark"`    // 备注
-	CreatedAt *gtime.Time `orm:"created_at"       json:"createdAt"` // 创建日期
-}

opms_admin/app/model/sys_menu.go

@@ -6,6 +6,8 @@ package model
 
 import (
 	"dashoo.cn/micro/app/model/internal"
+	"dashoo.cn/opms_libary/utils"
+	"strings"
 )
 
 // SysMenu is the golang structure for table sys_menu.
@@ -16,8 +18,8 @@ type SysMenu internal.SysMenu
 // SysMenuReq 新增页面请求参数
 type SysMenuReq struct {
 	Id         int    `json:"id"`                             // ID
-	MenuName   string `json:"menuName" v:"required#菜单名称不能为空"` // 菜单名称
 	ParentId   int    `json:"parentId"`                       // 父菜单ID
+	MenuName   string `json:"menuName" v:"required#菜单名称不能为空"` // 菜单名称
 	Path       string `json:"path"`                           // 路由地址
 	Component  string `json:"component"`                      // 组件路径
 	Query      string `json:"query"`                          // 路由参数
@@ -30,6 +32,7 @@ type SysMenuReq struct {
 	Icon       string `json:"icon"`                           // 菜单图标
 	PlatformId int    `json:"platformId"`                     // 所属平台
 	Sort       int    `json:"sort"`                           // 显示顺序
+	ActiveMenu string `json:"activeMenu"`                     // 高亮路由
 	Remark     string `json:"remark"`                         // 备注
 }
 
@@ -37,10 +40,8 @@ type MenuTree struct {
 	Id        int        `json:"id"`
 	ParentId  int        `json:"parent_id"`
 	Name      string     `json:"name"`
-	Component string     `json:"component"`
 	Path      string     `json:"path"`
-	Redirect  string     `json:"redirect"`
-	Hidden    bool       `json:"hidden"`
+	Component string     `json:"component"`
 	Meta      Meta       `json:"meta"`
 	Children  []MenuTree `json:"children,omitempty"`
 }
@@ -48,28 +49,46 @@ type MenuTree struct {
 type Meta struct {
 	Title            string `json:"title"`
 	Icon             string `json:"icon"`
-	Link             string `json:"link"`
-	BreadcrumbHidden bool   `json:"breadcrumbHidden"`
-	NoCache          bool   `json:"noCache"`
+	BreadcrumbHidden bool   `json:"breadcrumbHidden,omitempty"`
+	NoKeepAlive      bool   `json:"noKeepAlive,omitempty"`
+	Hidden           bool   `json:"hidden,omitempty"`
+	ActiveMenu       string `json:"activeMenu,omitempty"`
+	Target           string `json:"target,omitempty"`
+}
+
+func (m SysMenu) ConvName() string {
+	name := m.Path
+	if strings.Contains(m.Path, "/") {
+		nameList := strings.Split(m.Path, "/")
+		for _, v := range nameList {
+			if v != "" {
+				name = v
+				break
+			}
+		}
+	}
+	return utils.FirstUpper(name)
 }
 
 func (m SysMenu) ConvMenuTree() MenuTree {
 	menuTree := MenuTree{
 		Id:        m.Id,
 		ParentId:  m.ParentId,
-		Name:      m.MenuName,
-		Component: m.Component,
+		Name:      m.ConvName(),
 		Path:      m.Path,
-		//Redirect:  m.Redirect,
-		//Hidden:    m.Hidden,
+		Component: m.Component,
 		Meta: Meta{
 			Title: m.MenuName,
 			Icon:  m.Icon,
-			//Link:             m.Link,
 			//BreadcrumbHidden: m.BreadcrumbHidden,
-			NoCache: m.IsCache == 1,
+			ActiveMenu:  m.ActiveMenu,
+			NoKeepAlive: m.IsCache == 1,
+			Hidden:      m.Visible != "10",
 		},
 		Children: nil,
 	}
+	if m.IsFrame == 1 {
+		menuTree.Meta.Target = "_blank"
+	}
 	return menuTree
 }

opms_admin/app/model/sys_user.go

@@ -68,7 +68,7 @@ type AddUserReq struct {
 
 type EditUserReq struct {
 	SetUserReq
-	UserId int `p:"userId" v:"required#用户id不能为空"`
+	Id int `p:"id" v:"required#用户id不能为空"`
 }
 
 type SysUserRoleDeptRes struct {

opms_admin/app/service/sys_dict_data.go

@@ -1,23 +1,39 @@
 package service
 
 import (
+	"context"
 	"dashoo.cn/micro/app/common/global"
 	comModel "dashoo.cn/micro/app/common/model"
 	comService "dashoo.cn/micro/app/common/service"
 	"dashoo.cn/micro/app/dao"
 	"dashoo.cn/micro/app/model"
+	"dashoo.cn/opms_libary/micro_srv"
 	"database/sql"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/glog"
 	"github.com/gogf/gf/text/gstr"
 	"github.com/gogf/gf/util/gconv"
 )
 
-type sysDictData struct{}
+type dictDataService struct {
+	Dao *dao.SysDictTypeDao
+}
 
-var SysDictData = new(sysDictData)
+func NewDictDataService(ctx context.Context) (*dictDataService, error) {
+	dict := new(dictDataService)
+	// 获取租户码
+	tenant, err := micro_srv.GetTenant(ctx)
+	if err != nil {
+		return nil, err
+	}
+	reqMethod, _ := micro_srv.GetReqMethod(ctx)
+	glog.Info("Received " + reqMethod + " request @ " + tenant)
+	dict.Dao = dao.NewSysDictTypeDao(tenant)
+	return dict, err
+}
 
-func (s sysDictData) DictDataList(req *model.SelectDictPageReq) (total, page int, list []*model.SysDictData, err error) {
+func (s *dictDataService) GetDictDataList(req *model.SelectDictPageReq) (total int, list []*model.SysDictData, err error) {
 	d := dao.SysDictData.Ctx(req.Ctx)
 	if req != nil {
 		if req.DictLabel != "" {
@@ -39,11 +55,10 @@ func (s sysDictData) DictDataList(req *model.SelectDictPageReq) (total, page int
 			req.PageNum = 1
 		}
 	}
-	page = req.PageNum
 	if req.PageSize == 0 {
 		req.PageSize = comModel.PageSize
 	}
-	list, err = d.Page(page, req.PageSize).Order(dao.SysDictData.Columns.DictSort + " asc," +
+	list, err = d.Page(req.PageNum, req.PageSize).Order(dao.SysDictData.Columns.DictSort + " asc," +
 		dao.SysDictData.Columns.DictCode + " asc").All()
 	if err != nil {
 		g.Log().Error(err)
@@ -53,8 +68,22 @@ func (s sysDictData) DictDataList(req *model.SelectDictPageReq) (total, page int
 	return
 }
 
+// GetDictDataById 通过字典数据id获取字典数据
+func (s *dictDataService) GetDictDataById(id int64) (data *model.SysDictData, err error) {
+	data, err = dao.SysDictData.FindOne(dao.SysDictData.Columns.DictCode, id)
+	if err != nil {
+		g.Log().Error(err)
+		err = gerror.New("获取字典数据失败")
+		return
+	}
+	if data == nil {
+		err = gerror.New("获取字典数据失败")
+	}
+	return
+}
+
 // GetDictWithDataByType 通过字典键类型获取选项
-func (s sysDictData) GetDictWithDataByType(req *model.GetDictReq) (dict *model.DictRes, err error) {
+func (s *dictDataService) GetDictWithDataByType(req *model.GetDictReq) (dict *model.DictRes, err error) {
 	cache := comService.Cache.New()
 	cacheKey := global.SysDict + "_" + req.DictType
 	//从缓存获取
@@ -102,7 +131,7 @@ func (s sysDictData) GetDictWithDataByType(req *model.GetDictReq) (dict *model.D
 }
 
 // CheckDictTypeUniqueAll 检查字典类型是否唯一
-func (s *sysDictData) CheckDictTypeUniqueAll(dictType string) bool {
+func (s *dictDataService) CheckDictTypeUniqueAll(dictType string) bool {
 	dict, err := dao.SysDictData.FindOne(dao.SysDictData.Columns.DictType+"=?", dictType)
 	if err != nil {
 		g.Log().Error(err)
@@ -114,10 +143,15 @@ func (s *sysDictData) CheckDictTypeUniqueAll(dictType string) bool {
 	return true
 }
 
-// AddSave 添加保存字典数据
-func (s *sysDictData) AddSave(req *model.DictDataAddReq) (id int64, err error) {
+// Create 添加保存字典数据
+func (s *dictDataService) Create(req *model.DictDataAddReq) (id int64, err error) {
 	var res sql.Result
-	res, err = dao.SysDictData.Data(req).Insert()
+	data := new(model.SysDictData)
+	if err := gconv.Struct(req, data); err != nil {
+		return -1, err
+	}
+	SetCreatedInfo(data, 1, "")
+	res, err = dao.SysDictData.Data(data).Insert()
 	if err != nil {
 		g.Log().Error(err)
 		err = gerror.New("添加字典数据失败")
@@ -127,29 +161,15 @@ func (s *sysDictData) AddSave(req *model.DictDataAddReq) (id int64, err error) {
 	return
 }
 
-// GetDictDataById 通过字典数据id获取字典数据
-func (s sysDictData) GetDictDataById(id int) (data *model.SysDictData, err error) {
-	data, err = dao.SysDictData.FindOne(dao.SysDictData.Columns.DictCode, id)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("获取字典数据失败")
-		return
-	}
-	if data == nil {
-		err = gerror.New("获取字典数据失败")
-	}
-	return
-}
-
-// EditSaveData 修改字典数据
-func (s sysDictData) EditSaveData(req *model.EditDictDataReq) (err error) {
+// UpdateByDict 修改字典数据
+func (s *dictDataService) UpdateByDict(req *model.EditDictDataReq) (err error) {
 	_, err = dao.SysDictData.FieldsEx(dao.SysDictData.Columns.DictCode, dao.SysDictData.Columns.CreatedBy).
 		WherePri(req.DictCode).Update(req)
 	return
 }
 
 // DeleteDictDataByIds 删除字典数据
-func (s sysDictData) DeleteDictDataByIds(ids []int) error {
+func (s *dictDataService) DeleteDictDataByIds(ids []int64) error {
 	_, err := dao.SysDictData.Where(dao.SysDictData.Columns.DictCode+" in(?)", ids).Delete()
 	if err != nil {
 		g.Log().Error(err)

opms_admin/app/service/sys_dict_type.go

@@ -7,6 +7,8 @@ import (
 	comService "dashoo.cn/micro/app/common/service"
 	"dashoo.cn/micro/app/dao"
 	"dashoo.cn/micro/app/model"
+	"dashoo.cn/opms_libary/micro_srv"
+	"github.com/gogf/gf/os/glog"
 
 	"github.com/gogf/gf/container/garray"
 	"github.com/gogf/gf/database/gdb"
@@ -15,24 +17,35 @@ import (
 	"github.com/gogf/gf/util/gconv"
 )
 
-type sysDictType struct {
+type dictTypeService struct {
+	Dao *dao.SysDictTypeDao
 }
 
-var SysDictType = new(sysDictType)
+func NewDictTypeService(ctx context.Context) (*dictTypeService, error) {
+	dict := new(dictTypeService)
+	// 获取租户码
+	tenant, err := micro_srv.GetTenant(ctx)
+	if err != nil {
+		return nil, err
+	}
+	reqMethod, _ := micro_srv.GetReqMethod(ctx)
+	glog.Info("Received " + reqMethod + " request @ " + tenant)
+	dict.Dao = dao.NewSysDictTypeDao(tenant)
+	return dict, err
+}
 
-func (s *sysDictType) SelectList(req *model.ListSysDictTypeReq) (total, page int,
-	list []*model.SysDictTypeInfoRes, err error) {
-	d := dao.SysDictType.Ctx(req.Ctx)
+func (s *dictTypeService) GetList(req *model.ListSysDictTypeReq) (total int, list []*model.SysDictType, err error) {
+	db := s.Dao.M
 	if req.DictName != "" {
-		d = d.Where(dao.SysDictType.Columns.DictName+" like ?", "%"+req.DictName+"%")
+		db = db.Where(dao.SysDictType.Columns.DictName+" like ?", "%"+req.DictName+"%")
 	}
 	if req.DictType != "" {
-		d = d.Where(dao.SysDictType.Columns.DictType+" like ?", "%"+req.DictType+"%")
+		db = db.Where(dao.SysDictType.Columns.DictType+" like ?", "%"+req.DictType+"%")
 	}
 	if req.Status != "" {
-		d = d.Where(dao.SysDictType.Columns.Status+" = ", gconv.Int(req.Status))
+		db = db.Where(dao.SysDictType.Columns.Status+" = ", gconv.Int(req.Status))
 	}
-	total, err = d.Count()
+	total, err = db.Count()
 	if err != nil {
 		g.Log().Error(err)
 		err = gerror.New("获取总行数失败")
@@ -41,12 +54,10 @@ func (s *sysDictType) SelectList(req *model.ListSysDictTypeReq) (total, page int
 	if req.PageNum == 0 {
 		req.PageNum = 1
 	}
-	page = req.PageNum
 	if req.PageSize == 0 {
 		req.PageSize = comModel.PageSize
 	}
-	err = d.Fields(model.SysDictTypeInfoRes{}).Page(page, req.PageSize).
-		Order(dao.SysDictType.Columns.Id + " asc").Scan(&list)
+	err = db.Page(req.PageNum, req.PageSize).Order(dao.SysDictType.Columns.Id + " asc").Scan(&list)
 	if err != nil {
 		g.Log().Error(err)
 		err = gerror.New("获取数据失败")
@@ -54,8 +65,42 @@ func (s *sysDictType) SelectList(req *model.ListSysDictTypeReq) (total, page int
 	return
 }
 
+// GetDictById 获取字典类型
+func (s *dictTypeService) GetDictById(id int64) (dict *model.SysDictType, err error) {
+	dict, err = dao.SysDictType.FindOne(dao.SysDictType.Columns.Id, id)
+	if err != nil {
+		g.Log().Error(err)
+		err = gerror.New("获取字典类型失败")
+		return
+	}
+	if dict == nil {
+		err = gerror.New("不存在的字典类型")
+	}
+	return
+}
+
+// GetAllDictType 获取所有正常状态下的字典类型
+func (s *dictTypeService) GetAllDictType() (list []*model.SysDictType, err error) {
+	cache := comService.Cache.New()
+	//从缓存获取
+	data := cache.Get(global.SysDict + "_dict_type_all")
+	if data != nil {
+		err = gconv.Structs(data, &list)
+		return
+	}
+	err = dao.SysDictType.Where("status", 1).Order("dict_id ASC").Scan(&list)
+	if err != nil {
+		g.Log().Error(err)
+		err = gerror.New("获取字典类型数据出错")
+		return
+	}
+	//缓存
+	cache.Set(global.SysDict+"_dict_type_all", list, 0, global.SysDictTag)
+	return
+}
+
 // ExistsDictType 检查类型是否已经存在
-func (s *sysDictType) ExistsDictType(dictType string, dictId ...int64) bool {
+func (s *dictTypeService) ExistsDictType(dictType string, dictId ...int64) bool {
 	d := dao.SysDictType.Fields(dao.SysDictType.Columns.Id).
 		Where(dao.SysDictType.Columns.DictType, dictType)
 	if len(dictId) > 0 {
@@ -72,8 +117,13 @@ func (s *sysDictType) ExistsDictType(dictType string, dictId ...int64) bool {
 	return false
 }
 
-func (s *sysDictType) Add(req *model.SysDictTypeAddReq) error {
-	_, err := dao.SysDictType.Insert(req)
+func (s *dictTypeService) Create(req *model.SysDictTypeAddReq) error {
+	data := new(model.SysDictType)
+	if err := gconv.Struct(req, data); err != nil {
+		return err
+	}
+	SetCreatedInfo(data, 1, "")
+	_, err := dao.SysDictType.Insert(data)
 	if err != nil {
 		g.Log().Debug(err)
 		err = gerror.New("保存到数据库失败")
@@ -81,15 +131,15 @@ func (s *sysDictType) Add(req *model.SysDictTypeAddReq) error {
 	return err
 }
 
-func (s *sysDictType) Edit(ctx context.Context, req *model.SysDictTypeEditReq) error {
-	err := g.DB().Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
-		dt, err := dao.SysDictType.Fields(dao.SysDictType.Columns.DictType).FindOne(req.DictId)
+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 := dao.SysDictType.Fields(dao.SysDictType.Columns.DictType).FindOne(req.Id)
 		if err != nil {
 			return err
 		}
 		//修改字典类型
 		_, err = dao.SysDictType.TX(tx).FieldsEx(dao.SysDictType.Columns.CreatedBy,
-			dao.SysDictType.Columns.Id).WherePri(req.DictId).Update(req)
+			dao.SysDictType.Columns.Id).WherePri(req.Id).Update(req)
 		if err != nil {
 			return err
 		}
@@ -105,7 +155,7 @@ func (s *sysDictType) Edit(ctx context.Context, req *model.SysDictTypeEditReq) e
 	return err
 }
 
-func (s *sysDictType) Delete(ctx context.Context, dictIds []int) (err error) {
+func (s *dictTypeService) Delete(dictIds []int64) (err error) {
 	discs := ([]*model.SysDictType)(nil)
 	discs, err = dao.SysDictType.Fields(dao.SysDictType.Columns.DictType).
 		Where(dao.SysDictType.Columns.Id+" in (?) ", dictIds).All()
@@ -119,7 +169,7 @@ func (s *sysDictType) Delete(ctx context.Context, dictIds []int) (err error) {
 		types.Append(dt.DictType)
 	}
 	if types.Len() > 0 {
-		err = g.DB().Transaction(ctx, func(ctx context.Context, tx *gdb.TX) error {
+		err = g.DB().Transaction(s.Dao.GetCtx(), func(ctx context.Context, tx *gdb.TX) error {
 			_, err = dao.SysDictType.TX(tx).Delete(dao.SysDictType.Columns.Id+" in (?) ", dictIds)
 			if err != nil {
 				g.Log().Error(err)
@@ -137,37 +187,3 @@ func (s *sysDictType) Delete(ctx context.Context, dictIds []int) (err error) {
 	}
 	return
 }
-
-// GetDictById 获取字典类型
-func (s *sysDictType) GetDictById(id int) (dict *model.SysDictType, err error) {
-	dict, err = dao.SysDictType.FindOne(dao.SysDictType.Columns.Id, id)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("获取字典类型失败")
-		return
-	}
-	if dict == nil {
-		err = gerror.New("不存在的字典类型")
-	}
-	return
-}
-
-// GetAllDictType 获取所有正常状态下的字典类型
-func (s *sysDictType) GetAllDictType() (list []*model.SysDictType, err error) {
-	cache := comService.Cache.New()
-	//从缓存获取
-	data := cache.Get(global.SysDict + "_dict_type_all")
-	if data != nil {
-		err = gconv.Structs(data, &list)
-		return
-	}
-	err = dao.SysDictType.Where("status", 1).Order("dict_id ASC").Scan(&list)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("获取字典类型数据出错")
-		return
-	}
-	//缓存
-	cache.Set(global.SysDict+"_dict_type_all", list, 0, global.SysDictTag)
-	return
-}

opms_admin/app/service/sys_menu.go

@@ -13,6 +13,7 @@ import (
 	"errors"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/glog"
 	"github.com/gogf/gf/util/gconv"
 )
 
@@ -27,13 +28,14 @@ func NewMenuService(ctx context.Context) (*MenuService, error) {
 	if err != nil {
 		return nil, err
 	}
-	g.Log().Info("Received Menu.Login request @ " + tenant)
+	reqMethod, _ := micro_srv.GetReqMethod(ctx)
+	glog.Info("Received " + reqMethod + " request @ " + tenant)
 	menu.Dao = dao.NewSysMenuDao(tenant)
 	return menu, err
 }
 
-// Add 添加菜单项
-func (s MenuService) Add(ctx context.Context, param *model.SysMenuReq) (id int64, err error) {
+// Create 添加菜单项
+func (s MenuService) Create(param *model.SysMenuReq) (id int64, err error) {
 	// 菜单类型 D目录 M菜单 F按钮或功能 I接口
 	if param.MenuType == "F" && param.Perms == "" {
 		return -1, errors.New("权限标识不能为空！")
@@ -77,7 +79,7 @@ func (s MenuService) Add(ctx context.Context, param *model.SysMenuReq) (id int64
 }
 
 // UpdateById 根据ID更新菜单项
-func (s MenuService) UpdateById(ctx context.Context, param *model.SysMenuReq) error {
+func (s MenuService) UpdateById(param *model.SysMenuReq) error {
 	// 菜单类型 D目录 M菜单 F按钮或功能 I接口
 	if param.MenuType == "F" && param.Perms == "" {
 		return gerror.New("权限标识不能为空！")
@@ -199,7 +201,7 @@ func (s MenuService) GetList(param *menu_def.SelectReq) ([]model.SysMenu, error)
 func (s MenuService) GetMenuTree() ([]model.MenuTree, error) {
 	db := s.Dao.M
 	menuList := make([]model.SysMenu, 0)
-	err := db.Where("visible = 10").Where("menu_type IN (?)", g.Slice{"M", "C"}).Order("sort").Scan(&menuList)
+	err := db.Where("status = 10").Where("menu_type IN (?)", g.Slice{"M", "C"}).Order("sort").Scan(&menuList)
 
 	treeMap := make(map[int][]model.MenuTree, 0)
 	for _, v := range menuList {

opms_admin/app/service/sys_user.go

@@ -14,6 +14,7 @@ import (
 	"github.com/gogf/gf/database/gdb"
 	"github.com/gogf/gf/errors/gerror"
 	"github.com/gogf/gf/frame/g"
+	"github.com/gogf/gf/os/glog"
 	"github.com/gogf/gf/util/gconv"
 	"github.com/gogf/gf/util/grand"
 )
@@ -29,7 +30,8 @@ func NewUserService(ctx context.Context) (*UserService, error) {
 	if err != nil {
 		return nil, err
 	}
-	g.Log().Info("Received User.Login request @ " + tenant)
+	reqMethod, _ := micro_srv.GetReqMethod(ctx)
+	glog.Info("Received " + reqMethod + " request @ " + tenant)
 	user.Dao = dao.NewSysUserDao(tenant)
 	return user, err
 }
@@ -410,11 +412,12 @@ func (s *UserService) AddUser(req *model.AddUserReq) (err error) {
 	//userData.UserSalt = req.UserSalt
 	//userData.Password = req.Password
 	//userData.Remark = req.Remark
-	err = gconv.Struct(req, userData)
-	if err != nil {
+
+	if err = gconv.Struct(req, userData); err != nil {
 		tx.Rollback()
 		return
 	}
+	SetCreatedInfo(userData, int(1), "userInfo.UserName")
 	res, err := Model.Insert(userData)
 	if err != nil {
 		tx.Rollback()
@@ -459,7 +462,7 @@ func (s *UserService) AddUserRole(roleIds interface{}, userId int64) (err error)
 
 // EditUser 修改用户
 func (s *UserService) EditUser(req *model.EditUserReq) (err error) {
-	if i, _ := dao.SysUser.Where("id!=? and mobile=?", req.UserId, req.Phone).Count(); i != 0 {
+	if i, _ := dao.SysUser.Where("id!=? and phone=?", req.Id, req.Phone).Count(); i != 0 {
 		err = gerror.New("手机号已经存在")
 		return
 	}
@@ -467,19 +470,24 @@ func (s *UserService) EditUser(req *model.EditUserReq) (err error) {
 	tx, err = g.DB().Begin()
 	//保存管理员信息
 	var userData *model.SysUser
-	err = dao.SysUser.Where("id", req.UserId).Scan(&userData)
+	err = dao.SysUser.Where("id", req.Id).Scan(&userData)
 	if err != nil || userData == nil {
 		g.Log().Error(err)
 		err = gerror.New("获取用户信息失败")
 		return
 	}
-	userData.DeptId = req.DeptId
-	userData.Status = req.Status
-	userData.Phone = req.Phone
-	userData.Sex = req.Sex
-	userData.Email = req.Email
-	userData.NickName = req.NickName
-	userData.Remark = req.Remark
+	//userData.DeptId = req.DeptId
+	//userData.Status = req.Status
+	//userData.Phone = req.Phone
+	//userData.Sex = req.Sex
+	//userData.Email = req.Email
+	//userData.NickName = req.NickName
+	//userData.Remark = req.Remark
+	if err = gconv.Struct(req, userData); err != nil {
+		tx.Rollback()
+		return
+	}
+	SetUpdatedInfo(userData, int(1), "userInfo.UserName")
 	_, err = dao.SysUser.TX(tx).FieldsEx(dao.SysUser.Columns.Id, dao.SysUser.Columns.CreatedTime,
 		dao.SysUser.Columns.DeletedTime, dao.SysUser.Columns.LoginDate).
 		WherePri(userData.Id).Update(userData)
@@ -490,21 +498,21 @@ func (s *UserService) EditUser(req *model.EditUserReq) (err error) {
 		return
 	}
 	//设置用户所属角色信息
-	err = s.EditUserRole(req.RoleIds, req.UserId)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("设置用户权限失败")
-		tx.Rollback()
-		return
-	}
+	//err = s.EditUserRole(req.RoleIds, req.Id)
+	//if err != nil {
+	//	g.Log().Error(err)
+	//	err = gerror.New("设置用户权限失败")
+	//	tx.Rollback()
+	//	return
+	//}
 	//设置用户岗位数据
-	err = s.AddUserPost(req.PostIds, int64(req.UserId), tx)
-	if err != nil {
-		g.Log().Error(err)
-		err = gerror.New("设置用户岗位信息失败")
-		tx.Rollback()
-		return
-	}
+	//err = s.AddUserPost(req.PostIds, int64(req.Id), tx)
+	//if err != nil {
+	//	g.Log().Error(err)
+	//	err = gerror.New("设置用户岗位信息失败")
+	//	tx.Rollback()
+	//	return
+	//}
 	tx.Commit()
 	return
 }

opms_admin/main.go

@@ -21,6 +21,7 @@ func main() {
 	s.RegisterName("User", new(handler.User), "")
 	s.RegisterName("Menu", new(handler.Menu), "")
 	s.RegisterName("Role", new(handler.RoleHandler), "")
+	s.RegisterName("Dict", new(handler.Dict), "")
 
 	// 注册文件处理Service对象
 	dynamic.BeanFactory.BeanRegister(service.NewRoleService())

opms_libary/micro_srv/micro_srv.go

@@ -299,6 +299,16 @@ func GetTenant(ctx context.Context) (string, error) {
 	return tenant, nil
 }
 
+// GetReqMethod 从context中获取请求方式
+func GetReqMethod(ctx context.Context) (string, error) {
+	reqMeta := ctx.Value(share.ReqMetaDataKey).(map[string]string)
+	reqMethod, ok := reqMeta["reqMethod"]
+	if !ok {
+		return "", errors.New("获取请求方式异常")
+	}
+	return reqMethod, nil
+}
+
 // GetToken 从context中获取Token
 func GetToken(ctx context.Context) (string, error) {
 	reqMeta := ctx.Value(share.ReqMetaDataKey).(map[string]string)

opms_libary/utils/utils.go

@@ -18,6 +18,7 @@ import (
 	"github.com/gogf/gf/text/gstr"
 	"github.com/mojocn/base64Captcha"
 	"io"
+	"strings"
 	"time"
 )
 
@@ -196,3 +197,19 @@ func TimeStampToDateStr(timeStamp int64) string {
 	tm := gtime.NewFromTimeStamp(timeStamp)
 	return tm.Format("Y-m-d")
 }
+
+// FirstUpper 字符串首字母大写
+func FirstUpper(s string) string {
+	if s == "" {
+		return ""
+	}
+	return strings.ToUpper(s[:1]) + s[1:]
+}
+
+// FirstLower 字符串首字母小写
+func FirstLower(s string) string {
+	if s == "" {
+		return ""
+	}
+	return strings.ToLower(s[:1]) + s[1:]
+}