init...

core/api/v1/config_api.go

@@ -0,0 +1,152 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	cache2 "cutego/core/cache"
+	"cutego/core/entity"
+	"cutego/core/service"
+	"cutego/pkg/cache"
+	"cutego/pkg/excels"
+	"cutego/pkg/file"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"cutego/pkg/util"
+	"github.com/druidcaesa/gotool"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+type ConfigApi struct {
+	configService service.ConfigService
+}
+
+// GetConfigValue 根据参数键名查询参数值
+func (a ConfigApi) GetConfigValue(c *gin.Context) {
+	param := c.Query("key")
+	if !gotool.StrUtils.HasEmpty(param) {
+		key := a.configService.GetConfigKey(param)
+		c.JSON(http.StatusOK, resp.Success(key.ConfigValue, ""))
+	} else {
+		c.JSON(http.StatusInternalServerError, resp.ErrorResp("参数不合法"))
+	}
+}
+
+// List 查询设置列表
+func (a ConfigApi) List(c *gin.Context) {
+	query := request.ConfigQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	find, i := a.configService.FindPage(query)
+	resp.OK(c, page.Page{
+		List:  find,
+		Total: i,
+		Size:  query.PageSize,
+	})
+}
+
+// Add 添加数据
+func (a ConfigApi) Add(c *gin.Context) {
+	config := entity.SysConfig{}
+	if c.Bind(&config) != nil {
+		resp.ParamError(c)
+		return
+	}
+	// 检验key是否存在
+	if a.configService.CheckConfigKeyUnique(config) {
+		resp.Error(c, "新增参数'"+config.ConfigName+"'失败, 参数键名已存在")
+	}
+	config.CreateBy = util.GetUserInfo(c).UserName
+	if a.configService.Save(config) > 0 {
+		// 进行缓存数据添加
+		cache2.SetRedisConfig(config)
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Get 查询数据
+func (a ConfigApi) Get(c *gin.Context) {
+	param := c.Param("configId")
+	configId, _ := strconv.ParseInt(param, 10, 64)
+	resp.OK(c, a.configService.GetInfo(configId))
+}
+
+// Edit 修改数据
+func (a ConfigApi) Edit(c *gin.Context) {
+	config := entity.SysConfig{}
+	if c.Bind(&config) != nil {
+		resp.ParamError(c)
+		return
+	}
+	// 检验key是否存在
+	if a.configService.CheckConfigKeyUnique(config) {
+		resp.Error(c, "修改参数'"+config.ConfigName+"'失败, 参数键名已存在")
+	}
+	config.UpdateBy = util.GetUserInfo(c).UserName
+	if a.configService.Edit(config) > 0 {
+		cache2.SetRedisConfig(config)
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Delete 删除数据
+func (a ConfigApi) Delete(c *gin.Context) {
+	ids := strings.Split(c.Param("ids"), ",")
+	list := make([]int64, 0)
+	for _, id := range ids {
+		parseInt, _ := strconv.ParseInt(id, 10, 64)
+		list = append(list, parseInt)
+	}
+	// 进行校验, 查看是否可以删除
+	byIds := a.configService.CheckConfigByIds(list)
+	for _, config := range *byIds {
+		if config.ConfigType == "Y" {
+			resp.Error(c, "内置参数"+config.ConfigName+"不能删除")
+			return
+		}
+	}
+	// 进行删除
+	if a.configService.Remove(list) {
+		// 刷新缓存
+		strs := make([]string, 0)
+		for _, config := range *byIds {
+			strs = append(strs, config.ConfigKey)
+		}
+		cache.RemoveList(strs)
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// RefreshCache 刷新缓存
+func (a ConfigApi) RefreshCache(c *gin.Context) {
+	all := a.configService.FindAll()
+	for _, sysConfig := range *all {
+		cache2.RemoveRedisConfig(sysConfig.ConfigKey)
+		cache2.SetRedisConfig(sysConfig)
+	}
+}
+
+// Export 导出数据
+func (a ConfigApi) Export(c *gin.Context) {
+	query := request.ConfigQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	find, _ := a.configService.FindPage(query)
+	items := make([]interface{}, 0)
+	for _, config := range *find {
+		items = append(items, config)
+	}
+	_, files := excels.ExportExcel(items, "配置表")
+	file.DownloadExcel(c, files)
+}

core/api/v1/cron_job_api.go

@@ -0,0 +1,106 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/core/service"
+	"cutego/pkg/cache"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"github.com/gin-gonic/gin"
+	"strconv"
+	"strings"
+)
+
+type CronJobApi struct {
+	cronJobService service.CronJobService
+}
+
+// List 获取定时任务数据
+func (a CronJobApi) List(c *gin.Context) {
+	query := request.CronJobQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	find, i := a.cronJobService.FindPage(query)
+	resp.OK(c, page.Page{
+		List:  find,
+		Total: i,
+		Size:  query.PageSize,
+	})
+}
+
+// Edit 修改定时任务
+func (a CronJobApi) Edit(c *gin.Context) {
+	dictType := entity.SysDictType{}
+	if c.Bind(&dictType) != nil {
+		resp.ParamError(c)
+		return
+	}
+	//检验定时任务是否存在
+	if a.dictTypeService.CheckDictTypeUnique(dictType) {
+		resp.Error(c, "修改字典'"+dictType.DictName+"'失败, 定时任务已存在")
+		return
+	}
+	//修改数据
+	if a.dictTypeService.Edit(dictType) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Add 新增定时任务
+func (a CronJobApi) Add(c *gin.Context) {
+	dictType := entity.SysDictType{}
+	if c.Bind(&dictType) != nil {
+		resp.ParamError(c)
+		return
+	}
+	//检验定时任务是否存在
+	if a.dictTypeService.CheckDictTypeUnique(dictType) {
+		resp.Error(c, "新增字典'"+dictType.DictName+"'失败, 定时任务已存在")
+		return
+	}
+	//新增定时任务
+	if a.dictTypeService.Save(dictType) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Remove 批量删除定时任务
+func (a CronJobApi) Remove(c *gin.Context) {
+	param := c.Param("dictId")
+	split := strings.Split(param, ",")
+	ids := make([]int64, 0)
+	types := make([]string, 0)
+	for _, s := range split {
+		parseInt, _ := strconv.ParseInt(s, 10, 64)
+		ids = append(ids, parseInt)
+	}
+	//校验定时任务是否使用
+	for _, id := range ids {
+		dictType := a.dictTypeService.GetById(id)
+		if len(a.dictDataService.FindByDictType(dictType.DictType)) > 0 {
+			resp.Error(c, dictType.DictName+"已分配,不能删除")
+			return
+		}
+		types = append(types, dictType.DictType)
+	}
+	//批量删除
+	if a.dictTypeService.Remove(ids) {
+		//从缓存中删除数据
+		cache.RemoveList(types)
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// 改变任务状态
+func (a CronJobApi) ChangeStatus(context *gin.Context) {
+
+}

core/api/v1/dept_api.go

@@ -0,0 +1,149 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/core/service"
+	"cutego/pkg/resp"
+	"cutego/pkg/tree/tree_dept"
+	"cutego/pkg/util"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type DeptApi struct {
+	deptService service.DeptService
+}
+
+// TreeSelect 查询部门菜单树
+func (a DeptApi) DeptTreeSelect(c *gin.Context) {
+	query := request.DeptQuery{}
+	if c.BindQuery(&query) == nil {
+		treeSelect := a.deptService.FindTreeSelect(query)
+		list := tree_dept.DeptList{}
+		c.JSON(http.StatusOK, resp.Success(list.GetTree(treeSelect)))
+	} else {
+		c.JSON(http.StatusInternalServerError, resp.ErrorResp("参数绑定错误"))
+	}
+}
+
+// RoleDeptTreeSelect 加载对应角色部门列表树
+func (a DeptApi) RoleDeptTreeSelect(c *gin.Context) {
+	m := make(map[string]interface{})
+	param := c.Param("roleId")
+	roleId, _ := strconv.ParseInt(param, 10, 64)
+	checkedKeys := a.deptService.FindDeptListByRoleId(roleId)
+	m["checkedKeys"] = checkedKeys
+	treeSelect := a.deptService.FindTreeSelect(request.DeptQuery{})
+	list := tree_dept.DeptList{}
+	tree := list.GetTree(treeSelect)
+	m["depts"] = tree
+	resp.OK(c, m)
+}
+
+// Find 查询部门列表
+func (a DeptApi) Find(c *gin.Context) {
+	query := request.DeptQuery{}
+	if c.BindQuery(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	resp.OK(c, a.deptService.FindDeptList(query))
+}
+
+// ExcludeChild 查询部门列表（排除节点)
+func (a DeptApi) ExcludeChild(c *gin.Context) {
+	param := c.Param("deptId")
+	deptId, err := strconv.Atoi(param)
+	if err != nil {
+		resp.ParamError(c)
+		return
+	}
+	list := a.deptService.FindDeptList(request.DeptQuery{})
+	var depts = *list
+	deptList := make([]entity.SysDept, 0)
+	for _, dept := range depts {
+		if dept.DeptId == deptId || strings.Contains(dept.Ancestors, strconv.Itoa(deptId)) {
+			continue
+		}
+		deptList = append(deptList, dept)
+	}
+	resp.OK(c, deptList)
+}
+
+// GetInfo 根据部门编号获取详细信息
+func (a DeptApi) GetInfo(c *gin.Context) {
+	param := c.Param("deptId")
+	deptId, err := strconv.Atoi(param)
+	if err != nil {
+		resp.ParamError(c)
+		return
+	}
+	resp.OK(c, a.deptService.GetDeptById(deptId))
+}
+
+// Add 添加部门
+func (a DeptApi) Add(c *gin.Context) {
+	dept := entity.SysDept{}
+	if c.Bind(&dept) != nil {
+		resp.ParamError(c)
+		return
+	}
+	// 校验部门名称是否唯一
+	unique := a.deptService.CheckDeptNameUnique(dept)
+	if unique {
+		resp.Error(c, "新增部门'"+dept.DeptName+"'失败, 部门名称已存在")
+		return
+	}
+	info := a.deptService.GetDeptById(dept.ParentId)
+	if info.Status == "1" {
+		resp.Error(c, "部门停用, 不允许新增")
+		return
+	}
+	dept.Ancestors = info.Ancestors + "," + strconv.Itoa(dept.ParentId)
+	dept.CreateBy = util.GetUserInfo(c).UserName
+	if a.deptService.Save(dept) > 0 {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Delete 删除部门
+func (a DeptApi) Delete(c *gin.Context) {
+	param := c.Param("deptId")
+	deptId, _ := strconv.Atoi(param)
+	// 是否存在部门子节点
+	if a.deptService.HasChildByDeptId(deptId) > 0 {
+		resp.Error(c, "存在下级部门,不允许删除")
+		return
+	}
+	if a.deptService.CheckDeptExistUser(deptId) > 0 {
+		resp.Error(c, "部门存在用户,不允许删除")
+		return
+	}
+	if a.deptService.Remove(deptId) > 0 {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Edit 修改部门数据接口
+func (a DeptApi) Edit(c *gin.Context) {
+	dept := entity.SysDept{}
+	if c.Bind(&dept) != nil {
+		resp.ParamError(c)
+		return
+	}
+	dept.UpdateTime = time.Now()
+	dept.UpdateBy = util.GetUserInfo(c).UserName
+	if a.deptService.Edit(dept) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}

core/api/v1/dict_data_api.go

@@ -0,0 +1,128 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/api/v1/response"
+	"cutego/core/entity"
+	"cutego/core/service"
+	"cutego/pkg/excels"
+	"cutego/pkg/file"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"cutego/pkg/util"
+	"github.com/druidcaesa/gotool"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type DictDataApi struct {
+	dictDataService service.DictDataService
+}
+
+// GetByType 根据字典类型查询字典数据d
+func (a DictDataApi) GetByType(c *gin.Context) {
+	param := c.Param("dictType")
+	if !gotool.StrUtils.HasEmpty(param) {
+		list := a.dictDataService.FindByDictType(param)
+		var result []response.DictDataResponse
+		for _, data := range list {
+			result = append(result, response.DictDataResponse{
+				DictCode:  data.DictCode,
+				DictLabel: data.DictLabel,
+				DictSort:  data.DictSort,
+				DictValue: data.DictValue,
+				DictType:  data.DictType,
+				IsDefault: data.IsDefault,
+			})
+		}
+		c.JSON(http.StatusOK, resp.Success(result))
+	}
+}
+
+// List 查询字典数据集合
+func (a DictDataApi) List(c *gin.Context) {
+	query := request.DiceDataQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	list, i := a.dictDataService.FindPage(query)
+	resp.OK(c, page.Page{
+		List:  list,
+		Total: i,
+		Size:  query.PageSize,
+	})
+}
+
+// Get 根据id查询字典数据
+func (a DictDataApi) Get(c *gin.Context) {
+	param := c.Param("dictCode")
+	dictCode, _ := strconv.ParseInt(param, 10, 64)
+	resp.OK(c, a.dictDataService.GetByCode(dictCode))
+}
+
+// Add 添加字典数据
+func (a DictDataApi) Add(c *gin.Context) {
+	data := entity.SysDictData{}
+	if c.Bind(&data) != nil {
+		resp.ParamError(c)
+		return
+	}
+	data.CreateBy = util.GetUserInfo(c).UserName
+	if a.dictDataService.Save(data) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Edit 编辑字典数据
+func (a DictDataApi) Edit(c *gin.Context) {
+	data := entity.SysDictData{}
+	if c.Bind(&data) != nil {
+		resp.ParamError(c)
+		return
+	}
+	data.UpdateBy = util.GetUserInfo(c).UserName
+	data.UpdateTime = time.Now()
+	if a.dictDataService.Edit(data) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Delete 删除数据
+func (a DictDataApi) Delete(c *gin.Context) {
+	param := c.Param("dictCode")
+	split := strings.Split(param, ",")
+	dictCodeList := make([]int64, 0)
+	for _, s := range split {
+		diceCode, _ := strconv.ParseInt(s, 10, 64)
+		dictCodeList = append(dictCodeList, diceCode)
+	}
+	if a.dictDataService.Remove(dictCodeList) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Export 导出excel
+func (a DictDataApi) Export(c *gin.Context) {
+	query := request.DiceDataQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	items := make([]interface{}, 0)
+	list, _ := a.dictDataService.FindPage(query)
+	for _, data := range *list {
+		items = append(items, data)
+	}
+	_, files := excels.ExportExcel(items, "字典数据表")
+	file.DownloadExcel(c, files)
+}

core/api/v1/dict_type_api.go

@@ -0,0 +1,133 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	service2 "cutego/core/service"
+	"cutego/pkg/cache"
+	"cutego/pkg/excels"
+	"cutego/pkg/file"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"github.com/gin-gonic/gin"
+	"strconv"
+	"strings"
+)
+
+type DictTypeApi struct {
+	dictTypeService service2.DictTypeService
+	dictDataService service2.DictDataService
+}
+
+// List 获取字典类型数据
+func (a DictTypeApi) List(c *gin.Context) {
+	query := request.DictTypeQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	find, i := a.dictTypeService.FindPage(query)
+	resp.OK(c, page.Page{
+		List:  find,
+		Total: i,
+		Size:  query.PageSize,
+	})
+}
+
+// Get 根据id查询字典类型数据
+func (a DictTypeApi) Get(c *gin.Context) {
+	param := c.Param("dictTypeId")
+	dictTypeId, _ := strconv.ParseInt(param, 0, 64)
+	resp.OK(c, a.dictTypeService.GetById(dictTypeId))
+}
+
+// Edit 修改字典类型
+func (a DictTypeApi) Edit(c *gin.Context) {
+	dictType := entity.SysDictType{}
+	if c.Bind(&dictType) != nil {
+		resp.ParamError(c)
+		return
+	}
+	//检验字典类型是否存在
+	if a.dictTypeService.CheckDictTypeUnique(dictType) {
+		resp.Error(c, "修改字典'"+dictType.DictName+"'失败, 字典类型已存在")
+		return
+	}
+	//修改数据
+	if a.dictTypeService.Edit(dictType) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Add 新增字典类型
+func (a DictTypeApi) Add(c *gin.Context) {
+	dictType := entity.SysDictType{}
+	if c.Bind(&dictType) != nil {
+		resp.ParamError(c)
+		return
+	}
+	//检验字典类型是否存在
+	if a.dictTypeService.CheckDictTypeUnique(dictType) {
+		resp.Error(c, "新增字典'"+dictType.DictName+"'失败, 字典类型已存在")
+		return
+	}
+	//新增字典类型
+	if a.dictTypeService.Save(dictType) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Remove 批量删除字典类型
+func (a DictTypeApi) Remove(c *gin.Context) {
+	param := c.Param("dictId")
+	split := strings.Split(param, ",")
+	ids := make([]int64, 0)
+	types := make([]string, 0)
+	for _, s := range split {
+		parseInt, _ := strconv.ParseInt(s, 10, 64)
+		ids = append(ids, parseInt)
+	}
+	//校验字典类型是否使用
+	for _, id := range ids {
+		dictType := a.dictTypeService.GetById(id)
+		if len(a.dictDataService.FindByDictType(dictType.DictType)) > 0 {
+			resp.Error(c, dictType.DictName+"已分配,不能删除")
+			return
+		}
+		types = append(types, dictType.DictType)
+	}
+	//批量删除
+	if a.dictTypeService.Remove(ids) {
+		//从缓存中删除数据
+		cache.RemoveList(types)
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// RefreshCache 刷新缓存
+func (a DictTypeApi) RefreshCache(c *gin.Context) {
+	a.dictTypeService.RefreshCache()
+	resp.OK(c)
+}
+
+// Export 导出Excel
+func (a DictTypeApi) Export(c *gin.Context) {
+	query := request.DictTypeQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	find, _ := a.dictTypeService.FindPage(query)
+	list := make([]interface{}, 0)
+	for _, dictType := range *find {
+		list = append(list, dictType)
+	}
+	_, files := excels.ExportExcel(list, "字典类型表")
+	file.DownloadExcel(c, files)
+}

core/api/v1/login_api.go

@@ -0,0 +1,119 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	cache2 "cutego/core/cache"
+	"cutego/core/entity"
+	service2 "cutego/core/service"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"cutego/pkg/tree/tree_menu"
+	"cutego/pkg/util"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type LoginApi struct {
+	loginService      service2.LoginService
+	roleService       service2.RoleService
+	permissionService service2.PermissionService
+	menuService       service2.MenuService
+	loginInfoService  service2.LoginInfoService
+}
+
+// Login 登录
+func (a LoginApi) Login(c *gin.Context) {
+	loginBody := request.LoginBody{}
+	if c.BindJSON(&loginBody) == nil {
+		m := make(map[string]string)
+		loginStatus, token := a.loginService.Login(loginBody.UserName, loginBody.Password)
+		if loginStatus {
+			a.handleLoginInfo(c, loginBody, loginStatus)
+			// 将token存入到redis中
+			cache2.SetRedisToken(loginBody.UserName, token)
+			m["token"] = token
+			c.JSON(http.StatusOK, resp.Success(m))
+		} else {
+			a.handleLoginInfo(c, loginBody, loginStatus)
+			c.JSON(http.StatusOK, resp.ErrorResp(token))
+		}
+	} else {
+		c.JSON(http.StatusOK, resp.ErrorResp(500, "参数绑定错误"))
+	}
+}
+
+func (a LoginApi) handleLoginInfo(c *gin.Context, body request.LoginBody, loginStatus bool) {
+	status := common.If(loginStatus, "1", "0")
+
+	clientIp := a.loginInfoService.GetRequestClientIp(c)
+	var location string
+	if "127.0.0.1" == clientIp {
+		location = "本机"
+	} else {
+		location = a.loginInfoService.GetLocationByIp(clientIp).Country
+	}
+
+	a.loginInfoService.Save(entity.SysLoginInfo{
+		UserName:      body.UserName,
+		IpAddr:        clientIp,
+		LoginLocation: location,
+		Browser:       c.GetHeader("User-Agent"),
+		OS:            strings.ReplaceAll(c.GetHeader("sec-ch-ua-platform"), "\"", ""),
+		Status:        status.(string),
+		LoginTime:     time.Now(),
+	})
+}
+
+// GetUserInfo 获取用户信息
+func (a LoginApi) GetUserInfo(c *gin.Context) {
+	m := make(map[string]interface{})
+	user := a.loginService.GetCurrentUser(c)
+	// 查询用户角色集合
+	roleKeys := a.permissionService.GetRolePermissionByUserId(user)
+	// 权限集合
+	perms := a.permissionService.GetMenuPermission(user)
+	m["roles"] = roleKeys
+	m["permissions"] = perms
+	m["user"] = user
+	c.JSON(http.StatusOK, resp.Success(m))
+}
+
+// GetRouters 根据用户ID查询菜单
+func (a LoginApi) GetRouters(c *gin.Context) {
+	// 获取当前登录用户
+	user := a.loginService.GetCurrentUser(c)
+	menus := a.menuService.GetMenuTreeByUserId(user)
+	systemMenus := tree_menu.SystemMenus{}
+	systemMenus = *menus
+	array := systemMenus.ConvertToINodeArray(menus)
+	generateTree := tree_menu.GenerateTree(array, nil)
+	c.JSON(http.StatusOK, resp.Success(generateTree))
+}
+
+// GetLoginHistory 根据用户名称查询登录记录
+func (a LoginApi) GetLoginHistory(c *gin.Context) {
+	// 获取当前登录用户
+	user := a.loginService.GetCurrentUser(c)
+	// 配置参数
+	query := request.LoginInfoQuery{}
+	query.UserName = user.UserName
+	// 查询
+	list, i := a.loginInfoService.FindPage(query)
+	success := resp.Success(page.Page{
+		Size:  query.PageSize,
+		Total: i,
+		List:  list,
+	}, "查询成功")
+	c.JSON(http.StatusOK, success)
+}
+
+// Logout 退出登录
+func (a LoginApi) Logout(c *gin.Context) {
+	// 删除Redis缓存
+	name := util.GetUserInfo(c).UserName
+	cache2.RemoveRedisToken(name)
+	resp.OK(c)
+}

core/api/v1/menu_api.go

@@ -0,0 +1,112 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/core/service"
+	"cutego/pkg/resp"
+	"cutego/pkg/tree/tree_menu"
+	"cutego/pkg/util"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+type MenuApi struct {
+	menuService service.MenuService
+}
+
+// List 查询菜单数据
+func (a MenuApi) List(c *gin.Context) {
+	// 获取当前登录用户
+	info := util.GetUserInfo(c)
+	// 获取参数
+	query := request.MenuQuery{}
+	if c.Bind(&query) != nil {
+		resp.Error(c)
+		return
+	}
+	resp.OK(c, a.menuService.FindMenuList(query, info))
+}
+
+// GetInfo 根据id查询菜单详情
+func (a MenuApi) GetInfo(c *gin.Context) {
+	param := c.Param("menuId")
+	menuId, err := strconv.Atoi(param)
+	if err != nil {
+		resp.ParamError(c, "参数绑定错误")
+		return
+	}
+	resp.OK(c, a.menuService.GetMenuByMenuId(menuId))
+}
+
+// RoleMenuTreeSelect 加载对应角色菜单列表树
+func (a MenuApi) RoleMenuTreeSelect(c *gin.Context) {
+	m := make(map[string]interface{})
+	param := c.Param("roleId")
+	roleId, _ := strconv.ParseInt(param, 10, 64)
+	// 获取当前登录用户
+	info := util.GetUserInfo(c)
+	menuList := a.menuService.GetMenuTreeByUserId(info)
+	menus := tree_menu.SystemMenus{}
+	tree := menus.GetTree(menuList)
+	ids := a.menuService.FindMenuListByRoleId(roleId)
+	m["checkedKeys"] = ids
+	m["menus"] = tree
+	c.JSON(http.StatusOK, resp.Success(m))
+}
+
+// TreeSelect 获取菜单下拉树列表
+func (a MenuApi) TreeSelect(c *gin.Context) {
+	info := util.GetUserInfo(c)
+	menus := a.menuService.GetMenuTreeByUserId(info)
+	systemMenus := tree_menu.SystemMenus{}
+	tree := systemMenus.GetTree(menus)
+	c.JSON(http.StatusOK, resp.Success(tree))
+}
+
+// Add 添加菜单数据
+func (a MenuApi) Add(c *gin.Context) {
+	menu := entity.SysMenu{}
+	if c.Bind(&menu) != nil {
+		resp.ParamError(c, "参数绑定异常")
+		return
+	}
+	if a.menuService.Save(menu) > 0 {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Edit 修改菜单数据
+func (a MenuApi) Edit(c *gin.Context) {
+	menu := entity.SysMenu{}
+	if c.Bind(&menu) != nil {
+		resp.ParamError(c)
+		return
+	}
+	menu.UpdateBy = util.GetUserInfo(c).UserName
+	menu.UpdateTime = time.Now()
+	if a.menuService.Edit(menu) > 0 {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Delete 删除菜单
+func (a MenuApi) Delete(c *gin.Context) {
+	param := c.Param("menuId")
+	menuId, err := strconv.Atoi(param)
+	if err != nil {
+		resp.ParamError(c)
+		return
+	}
+	if a.menuService.Remove(menuId) > 0 {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}

core/api/v1/notice_api.go

@@ -0,0 +1,86 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/core/service"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"cutego/pkg/util"
+	"github.com/gin-gonic/gin"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type NoticeApi struct {
+	noticeService service.NoticeService
+}
+
+// List 查询集合
+func (a NoticeApi) List(c *gin.Context) {
+	query := request.NoticeQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	find, i := a.noticeService.FindPage(query)
+	resp.OK(c, page.Page{
+		List:  find,
+		Total: i,
+		Size:  query.PageSize,
+	})
+}
+
+// Add 添加公告
+func (a NoticeApi) Add(c *gin.Context) {
+	notice := entity.SysNotice{}
+	if c.Bind(&notice) != nil {
+		resp.ParamError(c)
+		return
+	}
+	notice.CreateBy = util.GetUserInfo(c).UserName
+	if a.noticeService.Save(notice) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Delete 删除
+func (a NoticeApi) Delete(c *gin.Context) {
+	ids := strings.Split(c.Param("ids"), ",")
+	idList := make([]int64, 0)
+	for _, s := range ids {
+		id, _ := strconv.ParseInt(s, 10, 64)
+		idList = append(idList, id)
+	}
+	if a.noticeService.Remove(idList) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Get 查询
+func (a NoticeApi) Get(c *gin.Context) {
+	param := c.Param("id")
+	id, _ := strconv.ParseInt(param, 10, 64)
+	resp.OK(c, a.noticeService.GetById(id))
+}
+
+// Edit 修改
+func (a NoticeApi) Edit(c *gin.Context) {
+	notice := entity.SysNotice{}
+	if c.Bind(&notice) != nil {
+		resp.ParamError(c)
+		return
+	}
+	notice.UpdateTime = time.Now()
+	notice.UpdateBy = util.GetUserInfo(c).UserName
+	if a.noticeService.Edit(notice) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}

core/api/v1/post_api.go

@@ -0,0 +1,137 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	service2 "cutego/core/service"
+	"cutego/pkg/excels"
+	"cutego/pkg/file"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"cutego/pkg/util"
+	"github.com/druidcaesa/gotool"
+	"github.com/gin-gonic/gin"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type PostApi struct {
+	postService     service2.PostService
+	userPostService service2.UserPostService
+}
+
+// List 查询刚问分页数据
+func (a PostApi) List(c *gin.Context) {
+	query := request.PostQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	list, i := a.postService.FindPage(query)
+	resp.OK(c, page.Page{
+		List:  list,
+		Total: i,
+		Size:  query.PageSize,
+	})
+}
+
+// Add 新增岗位
+func (a PostApi) Add(c *gin.Context) {
+	post := entity.SysPost{}
+	if c.Bind(&post) != nil {
+		resp.ParamError(c)
+		return
+	}
+	// 校验岗位名称是否存在
+	if a.postService.CheckPostNameUnique(post) {
+		resp.Error(c, "新增岗位'"+post.PostName+"'失败, 岗位名称已存在")
+		return
+	}
+	// 检验岗位编码是否存在
+	if a.postService.CheckPostCodeUnique(post) {
+		resp.Error(c, "新增岗位'"+post.PostCode+"'失败, 岗位编码已存在")
+		return
+	}
+	post.CreateBy = util.GetUserInfo(c).UserName
+	if a.postService.Save(post) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Get 根据岗位编号获取详细信息
+func (a PostApi) Get(c *gin.Context) {
+	param := c.Param("postId")
+	postId, _ := strconv.ParseInt(param, 10, 64)
+	resp.OK(c, a.postService.GetPostById(postId))
+}
+
+// Delete 删除岗位数据
+func (a PostApi) Delete(c *gin.Context) {
+	// 获取postId
+	param := c.Param("postId")
+	list := make([]int64, 0)
+	if gotool.StrUtils.HasNotEmpty(param) {
+		strs := strings.Split(param, ",")
+		for _, str := range strs {
+			postId, _ := strconv.ParseInt(str, 10, 64)
+			list = append(list, postId)
+		}
+	}
+	// 判断是否可以删除
+	postId := a.userPostService.CountUserPostById(list)
+	if postId > 0 {
+		post := a.postService.GetPostById(postId)
+		resp.Error(c, post.PostName+"岗位已分配, 不允许删除")
+		return
+	}
+	if a.postService.Remove(list) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Edit 修改岗位数据接口
+func (a PostApi) Edit(c *gin.Context) {
+	post := entity.SysPost{}
+	if c.Bind(&post) != nil {
+		resp.ParamError(c)
+		return
+	}
+	// 校验岗位名称是否存在
+	if a.postService.CheckPostNameUnique(post) {
+		resp.Error(c, "修改岗位'"+post.PostName+"'失败, 岗位名称已存在")
+		return
+	}
+	// 检验岗位编码是否存在
+	if a.postService.CheckPostCodeUnique(post) {
+		resp.Error(c, "修改岗位'"+post.PostCode+"'失败, 岗位编码已存在")
+		return
+	}
+	post.UpdateBy = util.GetUserInfo(c).UserName
+	post.UpdateTime = time.Now()
+	if a.postService.Edit(post) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Export 导出excel
+func (a PostApi) Export(c *gin.Context) {
+	query := request.PostQuery{}
+	if c.Bind(&query) != nil {
+		resp.ParamError(c)
+		return
+	}
+	list, _ := a.postService.FindPage(query)
+	excelList := make([]interface{}, 0)
+	for _, post := range *list {
+		excelList = append(excelList, post)
+	}
+	_, files := excels.ExportExcel(excelList, "岗位数据表")
+	file.DownloadExcel(c, files)
+}

core/api/v1/request/config_request.go

@@ -0,0 +1,10 @@
+package request
+
+import "cutego/pkg/base"
+
+type ConfigQuery struct {
+	base.GlobalQuery
+	ConfigName string `form:"configName"`
+	ConfigType string `form:"configType"`
+	ConfigKey  string `form:"configKey"`
+}

core/api/v1/request/cron_job_request.go

@@ -0,0 +1,8 @@
+package request
+
+import "cutego/pkg/base"
+
+type CronJobQuery struct {
+	base.GlobalQuery
+	JobName string `form:"jobName"`
+}

core/api/v1/request/dept_request.go

@@ -0,0 +1,8 @@
+package request
+
+// DeptQuery 部门查询参数结构体 GET请求
+type DeptQuery struct {
+	ParentId int    `form:"parentId"`
+	DeptName string `form:"deptName"`
+	Status   string `form:"status"`
+}

core/api/v1/request/dict_data_reqest.go

@@ -0,0 +1,10 @@
+package request
+
+import "cutego/pkg/base"
+
+type DiceDataQuery struct {
+	base.GlobalQuery
+	DictType  string `form:"dictType"`
+	DictLabel string `form:"dictLabel"`
+	Status    string `form:"status"`
+}

core/api/v1/request/dict_type_request.go

@@ -0,0 +1,10 @@
+package request
+
+import "cutego/pkg/base"
+
+type DictTypeQuery struct {
+	base.GlobalQuery
+	DictName string `form:"dictName"`
+	Status   string `form:"status"`
+	DictType string `form:"dictType"`
+}

core/api/v1/request/login_info_request.go

@@ -0,0 +1,9 @@
+package request
+
+import "cutego/pkg/base"
+
+// LoginInfoQuery 用户get请求数据参数
+type LoginInfoQuery struct {
+	base.GlobalQuery
+	UserName string // 筛选用户名称
+}

core/api/v1/request/login_request.go

@@ -0,0 +1,7 @@
+package request
+
+// LoginBody 登录参数
+type LoginBody struct {
+	UserName string `json:"username"` // 用户名
+	Password string `json:"password"` // 密码
+}

core/api/v1/request/menu_request.go

@@ -0,0 +1,12 @@
+package request
+
+import "cutego/pkg/base"
+
+// MenuQuery 菜单查询条件封装
+type MenuQuery struct {
+	base.GlobalQuery
+	MenuName string `json:"menuName" form:"menuName"`
+	Visible  string `json:"visible" form:"visible"`
+	Status   string `json:"status" form:"status"`
+	UserId   int64  `json:"userId" form:"userId"`
+}

core/api/v1/request/notice_reqest.go

@@ -0,0 +1,10 @@
+package request
+
+import "cutego/pkg/base"
+
+type NoticeQuery struct {
+	base.GlobalQuery
+	NoticeTitle string `form:"noticeTitle"`
+	NoticeType  string `form:"noticeType"`
+	CreateBy    string `form:"createBy"`
+}

core/api/v1/request/post_request.go

@@ -0,0 +1,10 @@
+package request
+
+import "cutego/pkg/base"
+
+type PostQuery struct {
+	base.GlobalQuery
+	PostCode string `form:"postCode"`
+	Status   string `form:"status"`
+	PostName string `form:"postName"`
+}

core/api/v1/request/role_request.go

@@ -0,0 +1,17 @@
+package request
+
+import "cutego/pkg/base"
+
+// RoleQuery 角色Get请求参数
+type RoleQuery struct {
+	base.GlobalQuery
+	RoleName string `form:"roleName"` // 角色名称
+	Status   string `form:"status"`   // 角色状态
+	RoleKey  string `form:"roleKey"`  // 角色Key
+}
+
+// RoleBody 角色Post和Put参数
+type RoleBody struct {
+	RoleId int64  `json:"roleId"`
+	Status string `json:"status"`
+}

core/api/v1/request/user_request.go

@@ -0,0 +1,39 @@
+package request
+
+import (
+	"cutego/pkg/base"
+	"time"
+)
+
+// UserQuery 用户get请求数据参数
+type UserQuery struct {
+	base.GlobalQuery
+	RoleId      int64  `form:"roleId"`      // 角色id
+	UserName    string `form:"userName"`    // 用户名
+	Status      string `form:"status"`      // 状态
+	PhoneNumber string `form:"phoneNumber"` // 手机号
+	DeptId      int64  `form:"deptId"`      // 部门id
+}
+
+// UserBody 用户接收POST 或者 PUT请求参数
+type UserBody struct {
+	UserId      int64     `xorm:"pk autoincr" json:"userId"` // 用户ID
+	DeptId      int64     `json:"deptId"`                    // 部门ID
+	UserName    string    `json:"userName"`                  // 登录用户名
+	NickName    string    `json:"nickName"`                  // 用户昵称
+	Email       string    `json:"email"`                     // 邮箱
+	PhoneNumber string    `json:"phoneNumber"`               // 手机号
+	Sex         string    `json:"sex"`                       // 性别0男1女
+	Avatar      string    `json:"avatar"`                    // 头像路径
+	Password    string    `json:"password"`                  // 密码
+	Status      string    `json:"status"`                    // 状态 0正常1停用
+	DelFlag     string    `json:"delFlag"`                   // 0正常1删除
+	LoginIp     string    `json:"loginIp"`                   // 登录ip
+	LoginDate   time.Time `json:"loginDate"`                 // 登录时间
+	CreateTime  time.Time `xorm:"created" json:"createTime"` // 创建时间
+	CreateBy    string    `json:"createBy"`                  // 创建人
+	UpdateTime  time.Time `json:"updateTime"`                // 更新时间
+	UpdateBy    string    `json:"updateBy"`                  // 更新人
+	RoleIds     []int64   `xorm:"-" json:"roleIds"`          // 角色id组
+	PostIds     []int64   `xorm:"-" json:"postIds"`          // 岗位id组
+}

core/api/v1/request/user_role_request.go

@@ -0,0 +1,7 @@
+package request
+
+// UserRoleBody 用户角色Post和Put参数接收结构体
+type UserRoleBody struct {
+	RoleId  int64   `form:"roleId" json:"roleId"`
+	UserIds []int64 `form:"userIds" json:"userIds"`
+}

core/api/v1/response/dict_data_response.go

@@ -0,0 +1,11 @@
+package response
+
+// DictDataResponse 字典数据实体返回结构体
+type DictDataResponse struct {
+	DictCode  int64  `excel:"name=字典编码" xorm:"pk autoincr" json:"dictCode"`   // 字典ID
+	DictSort  int    `excel:"name=字典排序" xorm:"int" json:"dictSort"`           // 字典排序
+	DictLabel string `excel:"name=字典标签" xorm:"varchar(128)" json:"dictLabel"` // 字典标签
+	DictValue string `excel:"name=字典键值" xorm:"varchar(128)" json:"dictValue"` // 字典键值
+	DictType  string `excel:"name=字典类型" xorm:"varchar(128)" json:"dictType"`  // 字典类型
+	IsDefault string `excel:"name=是否默认,format=Y=是,N=否" json:"isDefault"`      // 是否默认
+}

core/api/v1/response/user_response.go

@@ -0,0 +1,41 @@
+package response
+
+import (
+	models2 "cutego/core/entity"
+	"time"
+)
+
+// UserResponse 用户实体返回结构体
+type UserResponse struct {
+	UserId      int64           `json:"userId"`                                  // 用户ID
+	DeptId      int64           `excel:"name=部门" json:"deptId"`                  // 部门ID
+	UserName    string          `excel:"name=用户登录名" json:"userName"`             // 登录用户名
+	NickName    string          `excel:"name=用户昵称" json:"nickName"`              // 用户昵称
+	Email       string          `excel:"name=用户邮箱" json:"email"`                 // 邮箱
+	PhoneNumber string          `excel:"name=手机号" json:"phoneNumber"`            // 手机号
+	Sex         string          `excel:"name=性别,format=0=男,1=女,2=未知" json:"sex"` // 性别0男1女
+	Avatar      string          `json:"avatar"`                                  // 头像路径
+	Status      string          `json:"status"`                                  // 状态 0正常1停用
+	DelFlag     string          `json:"delFlag"`                                 // 0正常1删除
+	LoginIp     string          `json:"loginIp"`                                 // 登录ip
+	LoginDate   time.Time       `json:"loginDate"`                               // 登录时间
+	CreateTime  time.Time       `xorm:"created" json:"createTime"`               // 创建时间
+	CreateBy    string          `json:"createBy"`                                // 创建人
+	UpdateTime  time.Time       `json:"updateTime"`                              // 更新时间
+	UpdateBy    string          `json:"updateBy"`                                // 更新人
+	SysDept     models2.SysDept `xorm:"extends" json:"dept"`                     // 部门实体
+}
+
+// UserInfo 用户整体数据
+type UserInfo struct {
+	User    *UserResponse      `json:"user,omitempty"`    // 用户数据
+	Roles   []*models2.SysRole `json:"roles,omitempty"`   // 角色集合
+	Posts   []*models2.SysPost `json:"posts,omitempty"`   // 部门集合
+	PostIds *[]int64           `json:"postIds,omitempty"` // 岗位id集合
+	RoleIds *[]int64           `json:"roleIds,omitempty"` // 觉得id集合
+}
+
+// IsAdmin 判断当前用户是否是管理员
+func (r UserResponse) IsAdmin() bool {
+	return r.UserId == 1
+}

core/api/v1/role_api.go

@@ -0,0 +1,202 @@
+package v1
+
+import (
+	req2 "cutego/core/api/v1/request"
+	models2 "cutego/core/entity"
+	service2 "cutego/core/service"
+	"cutego/pkg/excels"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"cutego/pkg/util"
+	"github.com/druidcaesa/gotool"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+type RoleApi struct {
+	roleService service2.RoleService
+	userService service2.UserService
+}
+
+// Find 分页查询角色数据
+func (a RoleApi) Find(c *gin.Context) {
+	query := req2.RoleQuery{}
+	if c.BindQuery(&query) == nil {
+		list, i := a.roleService.FindPage(query)
+		p := page.Page{
+			List:  list,
+			Total: i,
+			Size:  query.PageSize,
+		}
+		c.JSON(http.StatusOK, resp.Success(p))
+	} else {
+		c.JSON(http.StatusInternalServerError, resp.ErrorResp("参数绑定异常"))
+	}
+}
+
+// GetRoleId 根据人roleId查询角色数据
+func (a RoleApi) GetRoleId(c *gin.Context) {
+	param := c.Param("roleId")
+	roleId, err := strconv.ParseInt(param, 10, 64)
+	if err == nil {
+		role := a.roleService.GetRoleByRoleId(roleId)
+		c.JSON(200, resp.Success(role))
+	} else {
+		c.JSON(500, resp.ErrorResp("参数绑定异常"))
+	}
+}
+
+// Add 添加角色业务操作
+func (a RoleApi) Add(c *gin.Context) {
+	role := models2.SysRole{}
+	if c.BindJSON(&role) == nil {
+		if a.roleService.CheckRoleNameUnique(role) > 0 {
+			c.JSON(500, resp.ErrorResp(500, "新增角色'"+role.RoleName+"'失败, 角色名称已存在"))
+		} else if a.roleService.CheckRoleKeyUnique(role) > 0 {
+			c.JSON(500, resp.ErrorResp(500, "新增角色'"+role.RoleName+"'失败, 角色权限已存在"))
+		}
+		role.CreateBy = util.GetUserInfo(c).UserName
+		if a.roleService.Save(role) > 0 {
+			c.JSON(200, resp.Success("保存成功"))
+		} else {
+			c.JSON(500, resp.Success("保存失败"))
+		}
+	} else {
+		c.JSON(500, resp.ErrorResp("参数绑定异常"))
+	}
+}
+
+// Edit 修改角色
+func (a RoleApi) Edit(c *gin.Context) {
+	role := models2.SysRole{}
+	if c.BindJSON(&role) == nil {
+		if a.roleService.CheckRoleNameUnique(role) > 0 {
+			c.JSON(500, resp.ErrorResp(500, "修改角色'"+role.RoleName+"'失败, 角色名称已存在"))
+		} else if a.roleService.CheckRoleKeyUnique(role) > 0 {
+			c.JSON(500, resp.ErrorResp(500, "修改角色'"+role.RoleName+"'失败, 角色权限已存在"))
+		}
+		role.CreateBy = util.GetUserInfo(c).UserName
+		role.CreateTime = time.Now()
+		if a.roleService.Edit(role) > 0 {
+			c.JSON(200, resp.Success("修改成功"))
+		} else {
+			c.JSON(500, resp.Success("修改失败"))
+		}
+	} else {
+		c.JSON(500, resp.ErrorResp("参数绑定异常"))
+	}
+}
+
+// Delete 删除角色
+func (a RoleApi) Delete(c *gin.Context) {
+	param := c.Param("roleId")
+	roleId, err := strconv.ParseInt(param, 10, 64)
+	if err != nil {
+		c.JSON(500, resp.ErrorResp("参数绑定异常"))
+		return
+	}
+	if a.roleService.Remove(roleId) > 0 {
+		c.JSON(200, resp.Success("删除成功"))
+	} else {
+		c.JSON(500, resp.Success("删除失败"))
+	}
+}
+
+// ChangeStatus 状态修改
+func (a RoleApi) ChangeStatus(c *gin.Context) {
+	body := models2.SysRole{}
+	if c.BindJSON(&body) != nil {
+		c.JSON(500, resp.ErrorResp("参数绑定异常"))
+		return
+	}
+	allowed, s := a.roleService.CheckRoleAllowed(body.RoleId)
+	if !allowed {
+		c.JSON(500, resp.ErrorResp(s))
+		return
+	}
+	body.UpdateTime = time.Now()
+	body.UpdateBy = util.GetUserInfo(c).UserName
+	if a.roleService.EditRoleStatus(&body) > 0 {
+		resp.OK(c, "修改成功")
+	} else {
+		resp.Error(c)
+	}
+}
+
+// AllocatedList 查询已分配用户角色列表
+func (a RoleApi) AllocatedList(c *gin.Context) {
+	query := req2.UserQuery{}
+	if c.BindQuery(&query) != nil {
+		resp.Error(c)
+		return
+	}
+	list, i := a.userService.GetAllocatedList(query)
+	resp.OK(c, page.Page{
+		List:  list,
+		Total: i,
+	})
+}
+
+// UnallocatedList 查询未分配用户角色列表
+func (a RoleApi) UnallocatedList(c *gin.Context) {
+	query := req2.UserQuery{}
+	if c.BindQuery(&query) != nil {
+		resp.Error(c)
+		return
+	}
+	list, i := a.userService.GetUnallocatedList(query)
+	resp.OK(c, page.Page{
+		List:  list,
+		Total: i,
+	})
+}
+
+// CancelAuthUser 取消授权用户
+func (a RoleApi) CancelAuthUser(c *gin.Context) {
+	roleUser := models2.SysUserRole{}
+	if c.BindJSON(&roleUser) != nil {
+		resp.Error(c)
+		return
+	}
+	if a.roleService.DeleteAuthUser(roleUser) > 0 {
+		resp.OK(c, "操作成功")
+	} else {
+		resp.Error(c, "操作失败")
+	}
+}
+
+// UpdateAuthUserAll 批量选择用户授权
+func (a RoleApi) UpdateAuthUserAll(c *gin.Context) {
+	body := req2.UserRoleBody{}
+	if c.Bind(&body) != nil {
+		resp.Error(c)
+		return
+	}
+	if a.roleService.InsertAuthUsers(body) > 0 {
+		resp.OK(c, "操作成功")
+	} else {
+		resp.Error(c, "操作失败")
+	}
+}
+
+// Export 导出Excel
+func (a RoleApi) Export(c *gin.Context) {
+	query := req2.RoleQuery{}
+	items := make([]interface{}, 0)
+	if c.BindQuery(&query) == nil {
+		list, _ := a.roleService.FindPage(query)
+		for _, role := range list {
+			items = append(items, *role)
+		}
+		_, file := excels.ExportExcel(items, "角色表")
+		c.Header("Content-Type", "application/octet-stream")
+		c.Header("Content-Disposition", "attachment; filename="+gotool.IdUtils.IdUUIDToRan(false)+".xlsx")
+		c.Header("Content-Transfer-Encoding", "binary")
+		c.Header("FileName", gotool.IdUtils.IdUUIDToRan(false)+".xlsx")
+		file.Write(c.Writer)
+	} else {
+		c.JSON(200, resp.ErrorResp(500, "参数错误"))
+	}
+}

core/api/v1/user_api.go

@@ -0,0 +1,334 @@
+package v1
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/api/v1/response"
+	models2 "cutego/core/entity"
+	service2 "cutego/core/service"
+	"cutego/pkg/common"
+	"cutego/pkg/excels"
+	"cutego/pkg/page"
+	"cutego/pkg/resp"
+	"cutego/pkg/util"
+	"github.com/druidcaesa/gotool"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"strconv"
+)
+
+// UserApi 用户操作api
+type UserApi struct {
+	userService service2.UserService
+	roleService service2.RoleService
+	postService service2.PostService
+}
+
+// Find 查询用户列表
+func (a UserApi) Find(c *gin.Context) {
+	query := request.UserQuery{}
+	if c.BindQuery(&query) == nil {
+		list, i := a.userService.FindList(query)
+		success := resp.Success(page.Page{
+			Size:  query.PageSize,
+			Total: i,
+			List:  list,
+		}, "查询成功")
+		c.JSON(http.StatusOK, success)
+	} else {
+		c.JSON(http.StatusOK, resp.ErrorResp(http.StatusInternalServerError, "参数错误"))
+	}
+}
+
+// GetInfo 查询用户信息
+func (a UserApi) GetInfo(c *gin.Context) {
+	param := c.Param("userId")
+	r := new(response.UserInfo)
+	// 查询角色
+	roleAll, _ := a.roleService.FindAll(nil)
+	// 岗位所有数据
+	postAll := a.postService.FindAll()
+	// 判断id传入的是否为空
+	if !gotool.StrUtils.HasEmpty(param) {
+		parseInt, err := strconv.ParseInt(param, 10, 64)
+		if err == nil {
+			// 判断当前登录用户是否是admin
+			m := new(models2.SysUser)
+			if m.IsAdmin(parseInt) {
+				r.Roles = roleAll
+			} else {
+				roles := make([]*models2.SysRole, 0)
+				for _, role := range roleAll {
+					if role.RoleId != 1 {
+						roles = append(roles, role)
+					}
+				}
+				r.Roles = roles
+			}
+			// 根据id获取用户数据
+			r.User = a.userService.GetUserById(parseInt)
+			// 根据用户ID查询岗位id集合
+			r.PostIds = a.postService.FindPostListByUserId(parseInt)
+			// 根据用户ID查询角色id集合
+			r.RoleIds = a.roleService.FindRoleListByUserId(parseInt)
+		}
+	} else {
+		//id为空不取管理员角色
+		roles := make([]*models2.SysRole, 0)
+		for _, role := range roleAll {
+			if role.RoleId != 1 {
+				roles = append(roles, role)
+			}
+		}
+		r.Roles = roles
+	}
+	r.Posts = postAll
+	c.JSON(http.StatusOK, resp.Success(r, "操作成功"))
+}
+
+// AuthRole 根据用户编号获取授权角色
+func (a UserApi) AuthRole(c *gin.Context) {
+	m := make(map[string]interface{})
+	userId := c.Param("userId")
+	parseInt, err := strconv.ParseInt(userId, 10, 64)
+	if err != nil {
+		common.ErrorLog(err)
+		c.JSON(http.StatusInternalServerError, resp.ErrorResp(err))
+	}
+	user := a.userService.GetUserById(parseInt)
+	// 查询角色
+	roles := a.roleService.GetRoleListByUserId(parseInt)
+	flag := models2.SysUser{}.IsAdmin(parseInt)
+	if flag {
+		m["roles"] = roles
+	} else {
+		roleList := make([]models2.SysRole, 0)
+		for _, role := range *roles {
+			if role.RoleId != 1 {
+				roleList = append(roleList, role)
+			}
+		}
+		m["roles"] = roleList
+	}
+	m["user"] = user
+	c.JSON(http.StatusOK, resp.Success(m))
+}
+
+// Add 新增用户
+func (a UserApi) Add(c *gin.Context) {
+	userBody := request.UserBody{}
+	if c.BindJSON(&userBody) == nil {
+		// 根据用户名查询用户
+		user := a.userService.GetUserByUserName(userBody.UserName)
+		if user != nil {
+			c.JSON(http.StatusOK, resp.ErrorResp(http.StatusInternalServerError, "失败, 登录账号已存在"))
+			return
+		} else if a.userService.CheckPhoneNumUnique(userBody) != nil {
+			c.JSON(http.StatusOK, resp.ErrorResp(http.StatusInternalServerError, "失败, 手机号码已存在"))
+			return
+		} else if a.userService.CheckEmailUnique(userBody) != nil {
+			c.JSON(http.StatusOK, resp.ErrorResp(http.StatusInternalServerError, "失败, 邮箱已存在"))
+			return
+		}
+		// 进行密码加密
+		userBody.Password = gotool.BcryptUtils.Generate(userBody.Password)
+		// 添加用户
+		if a.userService.Save(userBody) {
+			c.JSON(http.StatusOK, resp.Success(nil))
+		} else {
+			c.JSON(http.StatusInternalServerError, resp.ErrorResp("保存失败"))
+		}
+	} else {
+		c.JSON(http.StatusInternalServerError, resp.ErrorResp("参数错误"))
+	}
+}
+
+// Edit 修改用户
+func (a UserApi) Edit(c *gin.Context) {
+	userBody := request.UserBody{}
+	if c.BindJSON(&userBody) == nil {
+		if a.userService.CheckPhoneNumUnique(userBody) != nil {
+			c.JSON(http.StatusOK, resp.ErrorResp(http.StatusInternalServerError, "失败, 手机号码已存在"))
+			return
+		} else if a.userService.CheckEmailUnique(userBody) != nil {
+			c.JSON(http.StatusOK, resp.ErrorResp(http.StatusInternalServerError, "失败, 邮箱已存在"))
+			return
+		}
+		// 进行用户修改操作
+		if a.userService.Edit(userBody) > 0 {
+			resp.OK(c)
+			return
+		} else {
+			resp.Error(c)
+			return
+		}
+	} else {
+		resp.ParamError(c)
+		return
+	}
+}
+
+// Remove 删除用户
+func (a UserApi) Remove(c *gin.Context) {
+	param := c.Param("userId")
+	userId, err := strconv.ParseInt(param, 10, 64)
+	if err != nil {
+		common.ErrorLog(err)
+		c.JSON(http.StatusInternalServerError, resp.ErrorResp("参数错误"))
+		return
+	}
+	if a.userService.Remove(userId) > 0 {
+		c.JSON(http.StatusOK, resp.Success(nil))
+		return
+	} else {
+		c.JSON(http.StatusInternalServerError, resp.ErrorResp("删除失败"))
+		return
+	}
+}
+
+// ResetPwd 修改重置密码
+func (a UserApi) ResetPwd(c *gin.Context) {
+	userBody := request.UserBody{}
+	if c.BindJSON(&userBody) == nil {
+		if a.userService.CheckUserAllowed(userBody) {
+			c.JSON(http.StatusInternalServerError, resp.ErrorResp("不允许操作超级管理员用户"))
+			return
+		}
+		userBody.Password = gotool.BcryptUtils.Generate(userBody.Password)
+		if a.userService.ResetPwd(userBody) > 0 {
+			c.JSON(http.StatusOK, resp.Success(nil))
+		} else {
+			c.JSON(http.StatusInternalServerError, resp.ErrorResp("重置失败"))
+		}
+	} else {
+		c.JSON(http.StatusInternalServerError, resp.ErrorResp("参数错误"))
+	}
+}
+
+// Export 导出excel
+func (a UserApi) Export(c *gin.Context) {
+	query := request.UserQuery{}
+	if c.BindQuery(&query) == nil {
+		items := make([]interface{}, 0)
+		list, _ := a.userService.FindList(query)
+		for _, userResponse := range list {
+			items = append(items, *userResponse)
+		}
+		_, file := excels.ExportExcel(items, "用户表")
+		c.Header("Content-Type", "application/octet-stream")
+		c.Header("Content-Disposition", "attachment; filename="+gotool.IdUtils.IdUUIDToRan(false)+".xlsx")
+		c.Header("Content-Transfer-Encoding", "binary")
+		c.Header("FileName", gotool.IdUtils.IdUUIDToRan(false)+".xlsx")
+		file.Write(c.Writer)
+	} else {
+		c.JSON(http.StatusOK, resp.ErrorResp(http.StatusInternalServerError, "参数错误"))
+	}
+}
+
+// Profile 查询个人信息
+func (a UserApi) Profile(c *gin.Context) {
+	m := make(map[string]interface{})
+	info := util.GetUserInfo(c)
+	u := a.userService.GetUserById(info.UserId)
+	m["user"] = u
+	// 查询所属角色组
+	m["roleGroup"] = a.roleService.GetRolesByUserName(info.UserName)
+	m["postGroup"] = a.postService.FindPostByUserName(info.UserName)
+	resp.OK(c, m)
+}
+
+// UpdateProfile 修改个人数据
+func (a UserApi) UpdateProfile(c *gin.Context) {
+	user := request.UserBody{}
+	if c.Bind(&user) != nil {
+		resp.ParamError(c)
+		return
+	}
+	if a.userService.CheckEmailUnique(user) != nil {
+		resp.Error(c, "修改用户'"+user.UserName+"'失败, 邮箱账号已存在")
+		return
+	}
+	if a.userService.CheckPhoneNumUnique(user) != nil {
+		resp.Error(c, "修改用户'"+user.UserName+"'失败, 手机号已存在")
+		return
+	}
+	if a.userService.EditProfile(user) > 0 {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// UpdatePwd 修改个人密码
+func (a UserApi) UpdatePwd(c *gin.Context) {
+	oldPassword := c.Query("oldPassword")
+	newPassword := c.Query("newPassword")
+	info := util.GetUserInfo(c)
+	name := a.userService.GetUserByUserName(info.UserName)
+	hash := gotool.BcryptUtils.CompareHash(name.Password, oldPassword)
+	if !hash {
+		resp.Error(c, "修改密码失败, 旧密码错误")
+		return
+	}
+	generate := gotool.BcryptUtils.Generate(oldPassword)
+	compareHash := gotool.BcryptUtils.CompareHash(generate, newPassword)
+	if compareHash {
+		resp.Error(c, "新密码不能与旧密码相同")
+		return
+	}
+	pwd := a.userService.EditPwd(info.UserId, gotool.BcryptUtils.Generate(newPassword))
+	if pwd {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// Avatar 修改头像
+func (a UserApi) Avatar(c *gin.Context) {
+	dirPath := common.GetDirPath("avatar")
+	file, _, err := c.Request.FormFile("avatarFile")
+	fileName := gotool.IdUtils.IdUUIDToRan(true) + ".jpg"
+	filePath := dirPath + fileName
+	fileAppend, err := gotool.FileUtils.OpenFileAppend(filePath)
+	defer fileAppend.Close()
+	if err != nil {
+		common.ErrorLog(err)
+		resp.Error(c)
+		return
+	}
+	_, err = io.Copy(fileAppend, file)
+	if err != nil {
+		common.ErrorLog(err)
+		resp.Error(c)
+		return
+	}
+	info := util.GetUserInfo(c)
+	info.Avatar = filePath
+	avatar := a.userService.EditAvatar(info)
+	if avatar {
+		m := make(map[string]interface{})
+		m["imgUrl"] = filePath
+		resp.OK(c, m)
+	} else {
+		resp.Error(c)
+	}
+}
+
+// 修改可用状态
+func (a UserApi) ChangeStatus(c *gin.Context) {
+	user := request.UserBody{}
+	if c.Bind(&user) != nil {
+		resp.ParamError(c)
+		return
+	}
+	if user.UserId == 1 && user.Status == "1" {
+		c.JSON(http.StatusOK, resp.ErrorResp(http.StatusInternalServerError, "不可禁用admin账号"))
+		return
+	}
+	if a.userService.EditStatus(user) {
+		resp.OK(c)
+	} else {
+		resp.Error(c)
+	}
+}

core/cache/config_cache.go

@@ -0,0 +1,30 @@
+package cache
+
+import (
+	models2 "cutego/core/entity"
+	"cutego/pkg/cache"
+	"cutego/pkg/common"
+	"cutego/pkg/constant"
+)
+
+// GetRedisConfig 根据key从缓存中获取配置数据
+// @Param key 键
+// @Return *models2.SysConfig
+func GetRedisConfig(key string) *models2.SysConfig {
+	val := cache.GetCache(constant.RedisConst{}.GetRedisConfigKey() + key)
+	s := new(models2.SysConfig)
+	return common.JsonToStruct(val, s).(*models2.SysConfig)
+}
+
+// SetRedisConfig 将配置存入缓存
+// @Param config models2.SysConfig
+func SetRedisConfig(config models2.SysConfig) {
+	cache.SetCache(config.ConfigKey, common.StructToJson(config))
+}
+
+// RemoveRedisConfig 从缓存中删除配置
+// @Param configKey string 配置键
+// @Return 影响的行数
+func RemoveRedisConfig(configKey string) int {
+	return cache.RemoveCache(constant.RedisConst{}.GetRedisConfigKey() + configKey)
+}

core/cache/dict_cache.go

@@ -0,0 +1,35 @@
+package cache
+
+import (
+	models2 "cutego/core/entity"
+	"cutego/pkg/cache"
+	"cutego/pkg/common"
+	"cutego/pkg/constant"
+)
+
+// GetRedisDict 根据key获取缓存中的字典数据
+// @Param key string 键
+// @Return interface {}
+func GetRedisDict(key string) interface{} {
+	val := cache.GetCache(key)
+	s := make([]interface{}, 0)
+	return common.JsonToStruct(val, s)
+}
+
+// SetRedisDict 保存字典数据
+// @Param dictType string 字典类型
+// @Param list []models2.SysDictData
+func SetRedisDict(dictType string, list []models2.SysDictData) {
+	cache.SetCache(constant.RedisConst{}.GetRedisDictKey()+dictType, list)
+}
+
+// RemoveRedisDictList 批量删除字典数据
+// @Param dictType []string 字典类型集合
+func RemoveRedisDictList(dictType []string) {
+	includeKey := make([]string, 0)
+	header := constant.RedisConst{}.GetRedisDictKey()
+	for _, e := range dictType {
+		includeKey = append(includeKey, header+e)
+	}
+	cache.RemoveList(includeKey)
+}

core/cache/online_cache.go

@@ -0,0 +1,24 @@
+package cache
+
+import (
+	"cutego/pkg/cache"
+	"cutego/pkg/config"
+	"cutego/pkg/constant"
+)
+
+// SetRedisToken 将token存入到redis
+// @Param username string 用户名
+// @Param token string token令牌
+func SetRedisToken(username string, token string) {
+	if config.AppEnvConfig.Login.Single {
+		cache.SetCacheTTL(constant.RedisOnlineUserKey+username, token, 3600)
+	}
+}
+
+// RemoveRedisToken 将token从redis中删除
+// @Param username string 用户名
+// @Return 删除的行数
+func RemoveRedisToken(username string) int {
+	// 不管是不是单点登录, 直接踢
+	return cache.RemoveCache(constant.RedisOnlineUserKey + username)
+}

core/dao/config_dao.go

@@ -0,0 +1,147 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/druidcaesa/gotool"
+	"github.com/go-xorm/xorm"
+)
+
+type ConfigDao struct {
+}
+
+func (d ConfigDao) sql(session *xorm.Session) *xorm.Session {
+	return session.Table("sys_config")
+}
+
+// SelectByConfigKey 根据键名查询参数配置信息
+func (d ConfigDao) SelectByConfigKey(configKey string) *entity.SysConfig {
+	config := entity.SysConfig{}
+	_, err := d.sql(SqlDB.NewSession()).Where("config_key = ?", configKey).Get(&config)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &config
+}
+
+// SelectPage 分页查询数据
+func (d ConfigDao) SelectPage(query request.ConfigQuery) (*[]entity.SysConfig, int64) {
+	configs := make([]entity.SysConfig, 0)
+	session := d.sql(SqlDB.NewSession())
+	if gotool.StrUtils.HasNotEmpty(query.ConfigName) {
+		session.And("config_name like concat('%', ?, '%')", query.ConfigName)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.ConfigType) {
+		session.And("config_type = ?", query.ConfigType)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.ConfigKey) {
+		session.And("config_key like concat('%', ?, '%')", query.ConfigKey)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.BeginTime) {
+		session.And("date_format(create_time,'%y%m%d') >= date_format(?,'%y%m%d')", query.BeginTime)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.EndTime) {
+		session.And("date_format(create_time,'%y%m%d') <= date_format(?,'%y%m%d')", query.EndTime)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&configs)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return &configs, total
+}
+
+// CheckConfigKeyUnique 校验是否存在
+func (d ConfigDao) CheckConfigKeyUnique(config entity.SysConfig) int64 {
+	session := d.sql(SqlDB.NewSession())
+	if config.ConfigId > 0 {
+		session.Where("config_id != ?", config.ConfigId)
+	}
+	count, err := session.And("config_key = ?", config.ConfigKey).Cols("config_id").Count()
+	if err != nil {
+		common.ErrorLog(err)
+		return 0
+	}
+	return count
+}
+
+// Insert 添加数据
+func (d ConfigDao) Insert(config entity.SysConfig) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&config)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return insert
+}
+
+// SelectById 查询数据
+func (d ConfigDao) SelectById(id int64) *entity.SysConfig {
+	config := entity.SysConfig{}
+	session := d.sql(SqlDB.NewSession())
+	_, err := session.Where("config_id = ?", id).Get(&config)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &config
+}
+
+// Update 修改数据
+func (d ConfigDao) Update(config entity.SysConfig) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Where("config_id = ?", config.ConfigId).Update(&config)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return update
+}
+
+// CheckConfigByIds 根据id集合查询
+func (d ConfigDao) CheckConfigByIds(list []int64) *[]entity.SysConfig {
+	configs := make([]entity.SysConfig, 0)
+	err := d.sql(SqlDB.NewSession()).In("config_id", list).Find(&configs)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &configs
+}
+
+// Remove 删除数据
+func (d ConfigDao) Delete(list []int64) bool {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.In("config_id", list).Delete(&entity.SysConfig{})
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return false
+	}
+	session.Commit()
+	return true
+}
+
+// SelectAll 查询所有数据
+func (d ConfigDao) SelectAll() *[]entity.SysConfig {
+	configs := make([]entity.SysConfig, 0)
+	session := SqlDB.NewSession()
+	err := session.Find(&configs)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &configs
+}

core/dao/cron_job_dao.go

@@ -0,0 +1,99 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/druidcaesa/gotool"
+	"github.com/go-xorm/xorm"
+)
+
+type CronJobDao struct {
+}
+
+func (d CronJobDao) sql(session *xorm.Session) *xorm.Session {
+	return session.Table("sys_cron_job")
+}
+
+// SelectPage 分页查询数据
+func (d CronJobDao) SelectPage(query request.CronJobQuery) ([]entity.SysCronJob, int64) {
+	configs := make([]entity.SysCronJob, 0)
+	session := d.sql(SqlDB.NewSession())
+	if gotool.StrUtils.HasNotEmpty(query.JobName) {
+		session.And("job_name like concat('%', ?, '%')", query.JobName)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&configs)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return configs, total
+}
+
+// Insert 添加数据
+func (d CronJobDao) Insert(config entity.SysCronJob) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&config)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return insert
+}
+
+// SelectById 查询数据
+func (d CronJobDao) SelectById(id int64) *entity.SysCronJob {
+	config := entity.SysCronJob{}
+	session := d.sql(SqlDB.NewSession())
+	_, err := session.Where("job_id = ?", id).Get(&config)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &config
+}
+
+// Update 修改数据
+func (d CronJobDao) Update(config entity.SysCronJob) int64 {
+	//session := SqlDB.NewSession()
+	//session.Begin()
+	//update, err := session.Where("job_id = ?", config.JobId).Update(&config)
+	//if err != nil {
+	//	common.ErrorLog(err)
+	//	session.Rollback()
+	//	return 0
+	//}
+	//session.Commit()
+	return CustomUpdateById("job_id", config.JobId, config)
+}
+
+// Remove 删除数据
+func (d CronJobDao) Delete(list []int64) bool {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.In("config_id", list).Delete(&entity.SysCronJob{})
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return false
+	}
+	session.Commit()
+	return true
+}
+
+// 通过方法别名获取任务详情
+func (d CronJobDao) SelectByFuncAlias(funcAlias string) *entity.SysCronJob {
+	config := entity.SysCronJob{}
+	session := d.sql(SqlDB.NewSession())
+	_, err := session.Where("func_alias = ?", funcAlias).Get(&config)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &config
+}

core/dao/dept_dao.go

@@ -0,0 +1,153 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"github.com/druidcaesa/gotool"
+)
+
+type DeptDao struct {
+}
+
+// SelectTree 根据条件查询部门集合
+func (d DeptDao) SelectTree(query request.DeptQuery) *[]entity.SysDept {
+	depts := make([]entity.SysDept, 0)
+	session := SqlDB.NewSession().Where("del_flag = '0'")
+	if query.ParentId > 0 {
+		session.And("parent_id = ?", query.ParentId)
+	}
+	if !gotool.StrUtils.HasEmpty(query.DeptName) {
+		session.And("dept_name like concat('%', ?, '%')", query.DeptName)
+	}
+	if !gotool.StrUtils.HasEmpty(query.Status) {
+		session.And("status = ?", query.Status)
+	}
+	err := session.OrderBy("parent_id").OrderBy("order_num").Find(&depts)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &depts
+}
+
+// SelectDeptListByRoleId 根据角色ID查询部门树信息
+func (d DeptDao) SelectDeptListByRoleId(id int64, strictly bool) *[]int64 {
+	list := make([]int64, 0)
+	session := SqlDB.NewSession().Table([]string{"sys_dept", "d"}).Cols("d.dept_id")
+	session.Join("LEFT", []string{"sys_role_dept", "rd"}, "d.dept_id = rd.dept_id").
+		Where("rd.role_id = ?", id)
+	if strictly {
+		session.And("d.dept_id not in (select d.parent_id from sys_dept d inner join sys_role_dept rd on d.dept_id = rd.dept_id and rd.role_id = ?)", id)
+	}
+	err := session.OrderBy("d.parent_id").OrderBy("d.order_num").Find(&list)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &list
+}
+
+// GetList 查询部门列表
+func (d DeptDao) GetList(query request.DeptQuery) *[]entity.SysDept {
+	list := make([]entity.SysDept, 0)
+	session := SqlDB.NewSession().OrderBy("parent_id").OrderBy("order_num")
+	session.Where("del_flag = '0'")
+	if query.ParentId > 0 {
+		session.And("parent_id = ?", query.ParentId)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.DeptName) {
+		session.And("dept_name like concat('%', ?, '%')", query.DeptName)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.Status) {
+		session.And("status = ?", query.Status)
+	}
+	err := session.Find(&list)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &list
+}
+
+// SelectDeptById 根据部门编号获取详细信息
+func (d DeptDao) SelectDeptById(id int) *entity.SysDept {
+	dept := entity.SysDept{}
+	_, err := SqlDB.NewSession().Where("dept_id = ?", id).Get(&dept)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &dept
+}
+
+// Insert 添加部门数据
+func (d DeptDao) Insert(dept entity.SysDept) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&dept)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return insert
+}
+
+// CheckDeptNameUnique 校验部门名称是否唯一
+func (d DeptDao) CheckDeptNameUnique(dept entity.SysDept) int64 {
+	session := SqlDB.NewSession()
+	count, err := session.Table("sys_dept").Cols("dept_id").Where("dept_name=?", dept.DeptName).And("parent_id = ?", dept.ParentId).Limit(1).Count()
+	if err != nil {
+		common.ErrorLog(err)
+		return 1
+	}
+	return count
+
+}
+
+// HasChildByDeptId 是否存在部门子节点
+func (d DeptDao) HasChildByDeptId(id int) int64 {
+	count, _ := SqlDB.NewSession().Table("sys_dept").Cols("dept_id").Where("parent_id = ?", id).
+		And("del_flag = '0'").Limit(1).Count()
+	return count
+}
+
+// CheckDeptExistUser 查询部门是否存在用户
+func (d DeptDao) CheckDeptExistUser(id int) int64 {
+	count, _ := SqlDB.NewSession().Table("sys_user").Cols("user_id").Where("dept_id = ?", id).
+		And("del_flag = '0'").Count()
+	return count
+}
+
+// Delete 删除部门
+func (d DeptDao) Delete(id int) int64 {
+	dept := entity.SysDept{
+		DeptId: id,
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	i, err := session.Where("dept_id = ?", id).Delete(&dept)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return i
+}
+
+// Update 更新部门
+func (d DeptDao) Update(dept entity.SysDept) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Where("dept_id = ?", dept.DeptId).Update(&dept)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return update
+}

core/dao/dict_data_dao.go

@@ -0,0 +1,129 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/druidcaesa/gotool"
+	"github.com/go-xorm/xorm"
+)
+
+type DictDataDao struct {
+}
+
+func (d *DictDataDao) sql(session *xorm.Session) *xorm.Session {
+	return session.Table("sys_dict_data")
+}
+
+// SelectByDictType 根据字典类型查询字典数据
+// @Param dictType string 字典类型
+// @Return []entity.SysDictData
+func (d *DictDataDao) SelectByDictType(dictType string) []entity.SysDictData {
+	data := make([]entity.SysDictData, 0)
+	session := d.sql(SqlDB.NewSession())
+	err := session.Where("status = '0' ").And("dict_type = ?", dictType).OrderBy("dict_sort").Asc("dict_sort").
+		Find(&data)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return data
+}
+
+// GetDiceDataAll 查询所有字典数据
+// @Return *[]entity.SysDictData
+func (d DictDataDao) GetDiceDataAll() *[]entity.SysDictData {
+	session := d.sql(SqlDB.NewSession())
+	data := make([]entity.SysDictData, 0)
+	err := session.Where("status = '0' ").OrderBy("dict_sort").Asc("dict_sort").
+		Find(&data)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &data
+}
+
+// SelectPage 查询集合数据
+// @Param query request.DiceDataQuery
+// @Return *[]entity.SysDictData
+// @Return 总行数
+func (d *DictDataDao) SelectPage(query request.DiceDataQuery) (*[]entity.SysDictData, int64) {
+	list := make([]entity.SysDictData, 0)
+	session := SqlDB.NewSession().Table("sys_dict_data").OrderBy("dict_sort").Asc("dict_sort")
+	if gotool.StrUtils.HasNotEmpty(query.DictType) {
+		session.And("dict_type = ?", query.DictType)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.DictLabel) {
+		session.And("dict_label like concat('%', ?, '%')", query.DictLabel)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.Status) {
+		session.And("status = ?", query.Status)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&list)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return &list, total
+}
+
+// SelectByDictCode 根据dictCode查询字典数据
+// @Param dictCode int64
+// @Return *entity.SysDictData
+func (d *DictDataDao) SelectByDictCode(dictCode int64) *entity.SysDictData {
+	data := entity.SysDictData{}
+	session := SqlDB.NewSession()
+	_, err := session.Where("dict_code = ?", dictCode).Get(&data)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &data
+}
+
+// Insert 添加字典数据
+// @Param data entity.SysDictData
+// @Return 新增的行数
+func (d *DictDataDao) Insert(data entity.SysDictData) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&data)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return insert
+}
+
+// Delete 删除字典数据
+func (d *DictDataDao) Delete(codes []int64) bool {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.In("dict_code", codes).Delete(&entity.SysDictData{})
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return false
+	}
+	session.Commit()
+	return true
+}
+
+// 修改字典数据
+func (d *DictDataDao) Update(data entity.SysDictData) bool {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Where("dict_code = ?", data.DictCode).Update(&data)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return false
+	}
+	session.Commit()
+	return true
+}

core/dao/dict_type_dao.go

@@ -0,0 +1,123 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/druidcaesa/gotool"
+	"github.com/go-xorm/xorm"
+)
+
+type DictTypeDao struct {
+}
+
+func (d DictTypeDao) sql(session *xorm.Session) *xorm.Session {
+	return session.Table("sys_dict_type")
+}
+
+// SelectAll 查询所有字典类型数据
+func (d DictTypeDao) SelectAll() []*entity.SysDictType {
+	types := make([]*entity.SysDictType, 0)
+	err := d.sql(SqlDB.NewSession()).Where("status = '0'").Find(&types)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return types
+}
+
+// SelectPage 分页查询字典类型数据
+func (d DictTypeDao) SelectPage(query request.DictTypeQuery) (*[]entity.SysDictType, int64) {
+	list := make([]entity.SysDictType, 0)
+	session := SqlDB.NewSession().Table("sys_dict_type")
+	if gotool.StrUtils.HasNotEmpty(query.DictName) {
+		session.And("dict_name like concat('%', ?, '%')", query.DictName)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.Status) {
+		session.And("status = ?", query.Status)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.DictType) {
+		session.And("AND dict_type like concat('%', ?, '%')", query.DictType)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.BeginTime) {
+		session.And("date_format(create_time,'%y%m%d') >= date_format(?,'%y%m%d')", query.BeginTime)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.EndTime) {
+		session.And("date_format(create_time,'%y%m%d') <= date_format(?,'%y%m%d')", query.EndTime)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&list)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return &list, total
+}
+
+// SelectById 根据id查询字典类型数据
+func (d DictTypeDao) SelectById(id int64) *entity.SysDictType {
+	dictType := entity.SysDictType{}
+	_, err := SqlDB.NewSession().Where("dict_id = ?", id).Get(&dictType)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &dictType
+}
+
+// CheckDictTypeUnique 检验字典类型是否存在
+func (d DictTypeDao) CheckDictTypeUnique(dictType entity.SysDictType) int64 {
+	session := SqlDB.NewSession().Table("sys_dict_type")
+	if dictType.DictId > 0 {
+		session.And("dict_id != ?", dictType.DictId)
+	}
+	count, err := session.Where("dict_type = ?", dictType.DictType).Cols("dict_id").Count()
+	if err != nil {
+		common.ErrorLog(err)
+		return 0
+	}
+	return count
+}
+
+// Update 修改字典
+func (d DictTypeDao) Update(dictType entity.SysDictType) bool {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Where("dict_id = ?", dictType.DictId).Update(&dictType)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return false
+	}
+	session.Commit()
+	return true
+}
+
+// Insert 新增字典类型
+func (d DictTypeDao) Insert(dictType entity.SysDictType) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&dictType)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return insert
+}
+
+// Delete 批量删除
+func (d DictTypeDao) Delete(ids []int64) bool {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.In("dict_id", ids).Delete(entity.SysDictType{})
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return false
+	}
+	session.Commit()
+	return true
+}

core/dao/index.go

@@ -0,0 +1,133 @@
+package dao
+
+import (
+	models2 "cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/config"
+	"cutego/pkg/constant"
+	redisTool "cutego/pkg/redispool"
+	"fmt"
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/go-xorm/xorm"
+	"time"
+)
+
+// X 全局DB
+var (
+	SqlDB   *xorm.Engine
+	RedisDB *redisTool.RedisClient
+)
+
+func initDatabase() {
+	var err error
+	// 配置mysql数据库
+	ds := config.AppEnvConfig.DataSource
+	jdbc := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=%s&parseTime=True&loc=Local",
+		ds.Username,
+		ds.Password,
+		ds.Host,
+		ds.Port,
+		ds.Database,
+		ds.Charset,
+	)
+	SqlDB, _ = xorm.NewEngine(ds.DbType, jdbc)
+	if err != nil {
+		common.FatalfLog("db error: %#v\n", err.Error())
+	}
+	err = SqlDB.Ping()
+	if err != nil {
+		common.FatalfLog("db connect error: %#v\n", err.Error())
+	}
+	SqlDB.SetMaxIdleConns(ds.MaxIdleSize)
+	SqlDB.SetMaxOpenConns(ds.MaxOpenSize)
+	timer := time.NewTicker(time.Minute * 30)
+	go func(x *xorm.Engine) {
+		for _ = range timer.C {
+			err = x.Ping()
+			if err != nil {
+				common.FatalfLog("db connect error: %#v\n", err.Error())
+			}
+		}
+	}(SqlDB)
+	SqlDB.ShowSQL(true)
+}
+func initRedis() {
+	// 配置redis数据库
+	RedisDB = redisTool.NewRedis()
+}
+func init() {
+	initDatabase()
+	initRedis()
+	cacheInitDataToRedis()
+}
+
+// 初始化缓存数据
+func cacheInitDataToRedis() {
+	initDict()
+	initConfig()
+}
+
+func initDict() {
+	// 查询字典类型数据
+	dictTypeDao := new(DictTypeDao)
+	typeAll := dictTypeDao.SelectAll()
+	// 所有字典数据
+	d := new(DictDataDao)
+	listData := d.GetDiceDataAll()
+	for _, dictType := range typeAll {
+		dictData := make([]map[string]interface{}, 0)
+		for _, data := range *listData {
+			if dictType.DictType == data.DictType {
+				dictData = append(dictData, map[string]interface{}{
+					"dictCode":  data.DictCode,
+					"dictSort":  data.DictSort,
+					"dictLabel": data.DictLabel,
+					"dictValue": data.DictValue,
+					"isDefault": data.IsDefault,
+					"remark":    data.Remark,
+				})
+			}
+		}
+		RedisDB.SET(constant.RedisConst{}.GetRedisDictKey()+dictType.DictType, common.StructToJson(dictData))
+	}
+}
+
+func initConfig() {
+	// 查询配置数据存入到缓存中
+	configDao := new(ConfigDao)
+	configSession := configDao.sql(SqlDB.NewSession())
+	configs := make([]*models2.SysConfig, 0)
+	err := configSession.Find(&configs)
+	if err != nil {
+		common.ErrorLog(err)
+		return
+	}
+	for _, sysConfig := range configs {
+		RedisDB.SET(constant.RedisConst{}.GetRedisConfigKey()+sysConfig.ConfigKey, common.StructToJson(map[string]interface{}{
+			"configId":    sysConfig.ConfigId,
+			"configName":  sysConfig.ConfigName,
+			"configKey":   sysConfig.ConfigKey,
+			"configValue": sysConfig.ConfigValue,
+			"configType":  sysConfig.ConfigType,
+			"remark":      sysConfig.Remark,
+		}))
+	}
+}
+
+// 通用: 根据ID更新
+// @Param idColumnName 字段名称
+// @Param idColumnValue 字段值
+// @Param bean 更新的bean内容
+// @Return
+func CustomUpdateById(idColumnName string, idColumnValue interface{}, bean interface{}) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Where(idColumnName+" = ?", idColumnValue).Update(&bean)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return update
+}

core/dao/login_info_dao.go

@@ -0,0 +1,44 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/go-xorm/xorm"
+)
+
+type LoginInfoDao struct {
+}
+
+// 查询公共sql
+func (d LoginInfoDao) sql(session *xorm.Session) *xorm.Session {
+	return session.Table("sys_login_info")
+}
+
+// SelectPage 分页查询数据
+func (d LoginInfoDao) SelectPage(query request.LoginInfoQuery) (*[]entity.SysLoginInfo, int64) {
+	loginInfos := make([]entity.SysLoginInfo, 0)
+	session := d.sql(SqlDB.NewSession())
+	session.And("user_name = ?", query.UserName)
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&loginInfos)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return &loginInfos, total
+}
+
+// Insert 添加登录记录
+func (d LoginInfoDao) Insert(body entity.SysLoginInfo) *entity.SysLoginInfo {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Table("sys_login_info").Insert(&body)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+	}
+	session.Commit()
+	return &body
+}

core/dao/menu_dao.go

@@ -0,0 +1,179 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"github.com/druidcaesa/gotool"
+)
+
+type MenuDao struct {
+}
+
+// GetMenuPermission 根据用户ID查询权限
+func (d MenuDao) GetMenuPermission(id int64) *[]string {
+	var perms []string
+	session := SqlDB.Table([]string{"sys_menu", "m"})
+	err := session.Distinct("m.perms").
+		Join("LEFT", []string{"sys_role_menu", "rm"}, "m.menu_id = rm.menu_id").
+		Join("LEFT", []string{"sys_user_role", "ur"}, "rm.role_id = ur.role_id").
+		Join("LEFT", []string{"sys_role", "r"}, "r.role_id = ur.role_id").
+		Where("m.status = '0'").And("r.status = '0'").And("ur.user_id = ?", id).Find(&perms)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &perms
+}
+
+// GetMenuAll 查询所有菜单数据
+func (d MenuDao) GetMenuAll() *[]entity.SysMenu {
+	menus := make([]entity.SysMenu, 0)
+	session := SqlDB.Table([]string{entity.SysMenu{}.TableName(), "m"})
+	err := session.Distinct("m.menu_id").Cols("m.parent_id", "m.menu_name", "m.path", "m.component", "m.visible", "m.status", "m.perms", "m.is_frame", "m.is_cache", "m.menu_type", "m.icon", "m.order_num", "m.create_time").
+		Where("m.menu_type in ('M', 'C')").And("m.status = 0").OrderBy("m.parent_id").OrderBy("m.order_num").Find(&menus)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &menus
+}
+
+// GetMenuByUserId 根据用户ID查询菜单
+func (d MenuDao) GetMenuByUserId(id int64) *[]entity.SysMenu {
+	menus := make([]entity.SysMenu, 0)
+	session := SqlDB.Table([]string{entity.SysMenu{}.TableName(), "m"})
+	err := session.Distinct("m.menu_id").Cols("m.parent_id", "m.menu_name", "m.path", "m.component", "m.visible", "m.status", "m.perms", "m.is_frame", "m.is_cache", "m.menu_type", "m.icon", "m.order_num", "m.create_time").
+		Join("LEFT", []string{"sys_role_menu", "rm"}, "m.menu_id = rm.menu_id").
+		Join("LEFT", []string{"sys_user_role", "ur"}, "rm.role_id = ur.role_id").
+		Join("LEFT", []string{"sys_role", "ro"}, "ur.role_id = ro.role_id").
+		Join("LEFT", []string{"sys_user", "u"}, "ur.user_id = u.user_id").Where("u.user_id = ?", id).
+		And("m.menu_type in ('M', 'C')").And("m.status = 0").OrderBy("m.parent_id").OrderBy("m.order_num").Find(&menus)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &menus
+}
+
+// SelectMenuByRoleId 根据角色ID查询菜单树信息
+func (d MenuDao) SelectMenuByRoleId(id int64, strictly bool) *[]int64 {
+	list := make([]int64, 0)
+	session := SqlDB.NewSession().Table([]string{"sys_menu", "m"})
+	session.Join("LEFT", []string{"sys_role_menu", "rm"}, "m.menu_id = rm.menu_id")
+	session.Where("rm.role_id = ?", id)
+	if strictly {
+		session.And("m.menu_id not in (select m.parent_id from sys_menu m inner join sys_role_menu rm on m.menu_id = rm.menu_id and rm.role_id = ?)", id)
+	}
+	err := session.OrderBy("m.parent_id").OrderBy("m.order_num").Cols("m.menu_id").Find(&list)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &list
+}
+
+// SelectMenuList 查询系统菜单列表
+func (d MenuDao) SelectMenuList(query request.MenuQuery) *[]entity.SysMenu {
+	list := make([]entity.SysMenu, 0)
+	session := SqlDB.NewSession().OrderBy("parent_id").OrderBy("order_num")
+	if gotool.StrUtils.HasNotEmpty(query.MenuName) {
+		session.And("menu_name like concat('%', ?, '%')", query.MenuName)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.Visible) {
+		session.And("visible = ?", query.Visible)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.Status) {
+		session.And("status = ?", query.Status)
+	}
+	err := session.Find(&list)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &list
+}
+
+// SelectMenuListByUserId 根据用户查询系统菜单列表
+func (d MenuDao) SelectMenuListByUserId(query request.MenuQuery) *[]entity.SysMenu {
+	session := SqlDB.NewSession().OrderBy("parent_id").OrderBy("order_num")
+	list := make([]entity.SysMenu, 0)
+	session.Distinct("m.menu_id", "m.parent_id", "m.menu_name", "m.path", "m.component", "m.visible", "m.status", "ifnull(m.perms,'') as perms", "m.is_frame", "m.is_cache", "m.menu_type", "m.icon", "m.order_num", "m.create_time")
+	session.Join("LEFT", []string{"sys_role_menu", "rm"}, "m.menu_id = rm.menu_id").
+		Join("LEFT", []string{"sys_user_role", "ur"}, "rm.role_id = ur.role_id").
+		Join("LEFT", []string{"sys_role", "ro"}, "ur.role_id = ro.role_id").
+		Where("ur.user_id = ?", query.UserId)
+	if gotool.StrUtils.HasNotEmpty(query.MenuName) {
+		session.And("menu_name like concat('%', ?, '%')", query.MenuName)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.Visible) {
+		session.And("visible = ?", query.Visible)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.Status) {
+		session.And("status = ?", query.Status)
+	}
+	err := session.Find(&list)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &list
+}
+
+// SelectMenuByMenuId 根据菜单ID查询信息
+func (d MenuDao) SelectMenuByMenuId(id int) *entity.SysMenu {
+	menu := entity.SysMenu{
+		MenuId: id,
+	}
+	_, err := SqlDB.NewSession().Where("menu_id = ?", menu.MenuId).Get(&menu)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &menu
+}
+
+// Insert 添加菜单数据
+func (d MenuDao) Insert(menu entity.SysMenu) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&menu)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return insert
+}
+
+// Update 修改菜单数据
+func (d MenuDao) Update(menu entity.SysMenu) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Where("menu_id = ?", menu.MenuId).Update(&menu)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return update
+}
+
+// Delete 删除菜单操作
+func (d MenuDao) Delete(id int) int64 {
+	menu := entity.SysMenu{
+		MenuId: id,
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	i, err := session.Delete(&menu)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return i
+}

core/dao/notice_dao.go

@@ -0,0 +1,87 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/druidcaesa/gotool"
+)
+
+type NoticeDao struct {
+}
+
+// SelectPage 查询集合
+func (d NoticeDao) SelectPage(query request.NoticeQuery) (*[]entity.SysNotice, int64) {
+	notices := make([]entity.SysNotice, 0)
+	session := SqlDB.NewSession().Table(entity.SysNotice{}.TableName())
+	if gotool.StrUtils.HasNotEmpty(query.NoticeTitle) {
+		session.And("notice_title like concat('%', ?, '%')", query.NoticeTitle)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.NoticeType) {
+		session.And("notice_type = ?", query.NoticeType)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.CreateBy) {
+		session.And("create_by like concat('%', ?, '%')", query.CreateBy)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&notices)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return &notices, total
+}
+
+// Insert 添加数据
+func (d NoticeDao) Insert(notice entity.SysNotice) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&notice)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return insert
+}
+
+// Delete 批量删除
+func (d NoticeDao) Delete(list []int64) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	i, err := session.In("notice_id", list).Delete(&entity.SysNotice{})
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return i
+}
+
+// SelectById 查询
+func (d NoticeDao) SelectById(id int64) *entity.SysNotice {
+	notice := entity.SysNotice{}
+	_, err := SqlDB.NewSession().Where("notice_id = ?", id).Get(&notice)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &notice
+}
+
+// Update 修改数据
+func (d NoticeDao) Update(notice entity.SysNotice) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Where("notice_id = ?", notice.NoticeId).Update(&notice)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return update
+}

core/dao/post_dao.go

@@ -0,0 +1,153 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/druidcaesa/gotool"
+	"github.com/go-xorm/xorm"
+)
+
+type PostDao struct {
+}
+
+func (d PostDao) sqlSelectJoin(session *xorm.Session) *xorm.Session {
+	return session.Table([]string{"sys_post", "p"}).
+		Join("LEFT", []string{"sys_user_post", "up"}, "up.post_id = p.post_id").
+		Join("LEFT", []string{"sys_user", "u"}, "u.user_id = up.user_id")
+}
+
+// SelectAll 查询所有岗位数据, 数据库操作
+func (d PostDao) SelectAll() []*entity.SysPost {
+	session := SqlDB.NewSession()
+	posts := make([]*entity.SysPost, 0)
+	err := session.Find(&posts)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return posts
+}
+
+// SelectPostListByUserId 根据用户id查询岗位id集合
+func (d PostDao) SelectPostListByUserId(userId int64) *[]int64 {
+	var ids []int64
+	selectSql := d.sqlSelectJoin(SqlDB.NewSession())
+	err := selectSql.Where("u.user_id = ?", userId).Cols("p.post_id").Find(&ids)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &ids
+}
+
+// SelectPage 查询岗位分页数据
+func (d PostDao) SelectPage(query request.PostQuery) (*[]entity.SysPost, int64) {
+	posts := make([]entity.SysPost, 0)
+	session := SqlDB.NewSession().Table(entity.SysPost{}.TableName())
+	if gotool.StrUtils.HasNotEmpty(query.PostCode) {
+		session.And("post_code like concat('%', ?, '%')", query.PostCode)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.Status) {
+		session.And("status = ?", query.Status)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.PostName) {
+		session.And("post_name like concat('%', ?, '%')", query.PostName)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&posts)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return &posts, total
+}
+
+// CheckPostNameUnique 校验岗位名称是否存在
+func (d PostDao) CheckPostNameUnique(post entity.SysPost) int64 {
+	session := SqlDB.NewSession().Table("sys_post").Cols("post_id").
+		Where("post_name = ?", post.PostName)
+	if post.PostId > 0 {
+		session.And("post_id != ?", post.PostId)
+	}
+	count, _ := session.Count()
+	return count
+}
+
+// CheckPostCodeUnique 校验岗位编码是否存在
+func (d PostDao) CheckPostCodeUnique(post entity.SysPost) int64 {
+	session := SqlDB.NewSession().Table("sys_post").Cols("post_id").
+		Where("post_code = ?", post.PostCode)
+	if post.PostId > 0 {
+		session.And("post_id != ?", post.PostId)
+	}
+	count, _ := session.Count()
+	return count
+}
+
+// Insert 添加岗位数据
+func (d PostDao) Insert(post entity.SysPost) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&post)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return insert
+}
+
+// GetPostById 根据id查询岗位数据
+func (d PostDao) GetPostById(post entity.SysPost) *entity.SysPost {
+	_, err := SqlDB.NewSession().Where("post_id = ?", post.PostId).Get(&post)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &post
+}
+
+// Delete 批量删除岗位
+func (d PostDao) Delete(posts []int64) int64 {
+
+	session := SqlDB.NewSession()
+	session.Begin()
+	i, err := session.In("post_id", posts).Delete(&entity.SysPost{})
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return i
+}
+
+// Update 修改岗位数据
+func (d PostDao) Update(post entity.SysPost) bool {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Where("post_id = ?", post.PostId).Update(&post)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return false
+	}
+	session.Commit()
+	return true
+}
+
+func (d PostDao) SelectPostByUserName(name string) *[]entity.SysPost {
+	posts := make([]entity.SysPost, 0)
+	session := SqlDB.NewSession().Table([]string{entity.SysPost{}.TableName(), "p"})
+	err := session.Cols("p.post_id", "p.post_name", "p.post_code").
+		Join("LEFT", []string{"sys_user_post", "up"}, "up.post_id = p.post_id").
+		Join("LEFT", []string{"sys_user", "u"}, "u.user_id = up.user_id").Where("u.user_name = ?", name).Find(&posts)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &posts
+}

core/dao/role_dao.go

@@ -0,0 +1,205 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/druidcaesa/gotool"
+	"github.com/go-xorm/xorm"
+)
+
+type RoleDao struct {
+}
+
+// 角色公用sql
+func (d RoleDao) sqlSelectJoin() *xorm.Session {
+	return SqlDB.Table([]string{entity.SysRole{}.TableName(), "r"}).
+		Join("LEFT", []string{"sys_user_role", "ur"}, "ur.role_id = r.role_id").
+		Join("LEFT", []string{"sys_user", "u"}, "u.user_id = ur.user_id").
+		Join("LEFT", []string{"sys_dept", "d"}, "u.dept_id = d.dept_id")
+}
+
+// 用户角色关系查询sql
+func (d RoleDao) sqlSelectRoleAndUser() *xorm.Session {
+	return SqlDB.Table([]string{entity.SysRole{}.TableName(), "r"}).
+		Join("LEFT", []string{"sys_user_role", "ur"}, "ur.role_id = r.role_id").
+		Join("LEFT", []string{"sys_user", "u"}, "u.user_id = ur.user_id")
+}
+
+// SelectPage 根据条件查询角色数据
+func (d RoleDao) SelectPage(q *request.RoleQuery) ([]*entity.SysRole, int64) {
+	roles := make([]*entity.SysRole, 0)
+	session := d.sqlSelectJoin()
+	if !gotool.StrUtils.HasEmpty(q.RoleName) {
+		session.And("r.role_name like concat('%', ?, '%')", q.RoleName)
+	}
+	if !gotool.StrUtils.HasEmpty(q.Status) {
+		session.And("r.status = ?", q.Status)
+	}
+	if !gotool.StrUtils.HasEmpty(q.RoleKey) {
+		session.And("r.role_key like concat('%', ?, '%')", q.RoleKey)
+	}
+	if !gotool.StrUtils.HasEmpty(q.BeginTime) {
+		session.And("date_format(r.create_time,'%y%m%d') >= date_format(?,'%y%m%d')", q.BeginTime)
+	}
+	if !gotool.StrUtils.HasEmpty(q.EndTime) {
+		session.And("date_format(r.create_time,'%y%m%d') <= date_format(?,'%y%m%d')", q.EndTime)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(q.PageSize, page.StartSize(q.PageNum, q.PageSize)).OrderBy("r.role_sort").Find(&roles)
+	if err != nil {
+		return nil, 0
+	}
+	return roles, total
+}
+
+// SelectAll 查询所有角色
+func (d RoleDao) SelectAll() []*entity.SysRole {
+	sql := d.sqlSelectJoin()
+	roles := make([]*entity.SysRole, 0)
+	err := sql.Find(&roles)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return roles
+}
+
+// SelectRoleListByUserId 根据用户id查询用户角色id集合
+func (d RoleDao) SelectRoleListByUserId(userId int64) *[]int64 {
+	sqlSelectRoleAndUser := d.sqlSelectRoleAndUser()
+	var roleIds []int64
+	err := sqlSelectRoleAndUser.Cols("r.role_id").Where("u.user_id = ?", userId).Find(&roleIds)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &roleIds
+}
+
+// SelectRolePermissionByUserId 查询用户角色集合
+func (d RoleDao) SelectRolePermissionByUserId(id int64) *[]string {
+	var roleKeys []string
+	err := d.sqlSelectJoin().Cols("r.role_key").Where("r.del_flag = '0'").And("ur.user_id = ?", id).Find(&roleKeys)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &roleKeys
+}
+
+// GetRoleListByUserId 根据用户ID查询角色
+func (d RoleDao) GetRoleListByUserId(id int64) *[]entity.SysRole {
+	roles := make([]entity.SysRole, 0)
+	err := d.sqlSelectJoin().Where("r.del_flag = '0'").And("ur.user_id = ?", id).Find(&roles)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &roles
+}
+
+// SelectRoleByRoleId 根据角色id查询角色数据
+func (d RoleDao) SelectRoleByRoleId(id int64) *entity.SysRole {
+	role := entity.SysRole{}
+	_, err := d.sqlSelectJoin().Where("r.role_id = ?", id).Get(&role)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &role
+}
+
+// CheckRoleNameUnique 校验角色名称是否唯一
+func (d RoleDao) CheckRoleNameUnique(role entity.SysRole) int64 {
+	session := SqlDB.Table(role.TableName()).Where("role_name = ?", role.RoleName)
+	if role.RoleId > 0 {
+		session.And("role_id != ?", role.RoleId)
+	}
+	count, err := session.Count(&role)
+	if err != nil {
+		common.ErrorLog(err)
+	}
+	return count
+}
+
+// CheckRoleKeyUnique 校验角色权限是否唯一
+func (d RoleDao) CheckRoleKeyUnique(role entity.SysRole) int64 {
+	session := SqlDB.Table(role.TableName()).Where("role_key = ?", role.RoleKey)
+	if role.RoleId > 0 {
+		session.And("role_id != ?", role.RoleId)
+	}
+	count, err := session.Count(&role)
+	if err != nil {
+		common.ErrorLog(err)
+	}
+	return count
+}
+
+// Add 添加角色进入数据库操作
+func (d RoleDao) Insert(role entity.SysRole) entity.SysRole {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Insert(&role)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+	}
+	session.Commit()
+	return role
+}
+
+// Update 修改数据
+func (d RoleDao) Update(role entity.SysRole) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Where("role_id = ?", role.RoleId).Update(&role)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return update
+}
+
+// Delete 删除角色
+func (d RoleDao) Delete(role entity.SysRole) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	i, err := session.Delete(&role)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return i
+}
+
+// UpdateRoleStatus 修改角色状态
+func (d RoleDao) UpdateRoleStatus(role *entity.SysRole) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Where("role_id = ?", role.RoleId).Cols("status", "update_by", "update_time").Update(role)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return update
+}
+
+// SelectRolesByUserName 查询角色组
+func (d RoleDao) SelectRolesByUserName(name string) *[]entity.SysRole {
+	roles := make([]entity.SysRole, 0)
+	session := d.sqlSelectJoin()
+	err := session.Where("r.del_flag = '0'").And("u.user_name = ?", name).Find(&roles)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	return &roles
+}

core/dao/role_menu_dao.go

@@ -0,0 +1,37 @@
+package dao
+
+import (
+	models2 "cutego/core/entity"
+	"cutego/pkg/common"
+)
+
+type RoleMenuDao struct {
+}
+
+// Insert 添加角色菜单关系
+func (d RoleMenuDao) Insert(list []models2.SysRoleMenu) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&list)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+	}
+	session.Commit()
+	return insert
+}
+
+// Delete 删除角色和菜单关系
+func (d RoleMenuDao) Delete(role models2.SysRole) {
+	menu := models2.SysRoleMenu{
+		RoleId: role.RoleId,
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Delete(&menu)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+	}
+	session.Commit()
+}

core/dao/user_dao.go

@@ -0,0 +1,276 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/api/v1/response"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+	"cutego/pkg/page"
+	"github.com/druidcaesa/gotool"
+	"github.com/go-xorm/xorm"
+	"time"
+)
+
+type UserDao struct {
+}
+
+// 查询公共sql
+func (d UserDao) sqlSelectJoin() *xorm.Session {
+	return SqlDB.NewSession().Table([]string{"sys_user", "u"}).
+		Join("LEFT", []string{"sys_dept", "d"}, "u.dept_id = d.dept_id").
+		Join("LEFT", []string{"sys_user_role", "ur"}, "u.user_id = ur.user_id").
+		Join("LEFT", []string{"sys_role", "r"}, "r.role_id = ur.role_id")
+}
+
+// SelectPage 查询用户集合
+func (d UserDao) SelectPage(query request.UserQuery) ([]*response.UserResponse, int64) {
+	resp := make([]*response.UserResponse, 0)
+	sql := d.sqlSelectJoin()
+	if !gotool.StrUtils.HasEmpty(query.UserName) {
+		sql.And("u.user_name like concat('%',?,'%')", query.UserName)
+	}
+	if !gotool.StrUtils.HasEmpty(query.Status) {
+		sql.And("i.status = ?", query.Status)
+	}
+	if !gotool.StrUtils.HasEmpty(query.PhoneNumber) {
+		sql.And("u.phone_number like concat('%',?,'%')", query.PhoneNumber)
+	}
+	if !gotool.StrUtils.HasEmpty(query.BeginTime) {
+		sql.And("date_format(u.create_time,'%y%m%d') >= date_format(?,'%y%m%d')", query.BeginTime)
+	}
+	if !gotool.StrUtils.HasEmpty(query.EndTime) {
+		sql.And("date_format(u.create_time,'%y%m%d') <= date_format(?,'%y%m%d')", query.EndTime)
+	}
+	if query.DeptId > 0 {
+		sql.And("u.dept_id = ? OR u.dept_id in ( SELECT t.dept_id FROM sys_dept t WHERE find_in_set(?, ancestors))", query.DeptId, query.DeptId)
+	}
+	total, _ := page.GetTotal(sql.Clone())
+	err := sql.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return resp, total
+}
+
+// GetUserById 根据id查询用户数据
+func (d UserDao) GetUserById(userId int64) *response.UserResponse {
+	var resp response.UserResponse
+	get, err := d.sqlSelectJoin().Where("u.user_id = ?", userId).Get(&resp)
+	if err != nil {
+		common.ErrorLog(err)
+	}
+	if !get {
+		return nil
+	}
+	return &resp
+}
+
+// GetUserByUserName 根据用户名查询用户数据
+func (d UserDao) GetUserByUserName(user entity.SysUser) *entity.SysUser {
+	i, err := SqlDB.Get(&user)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil
+	}
+	if i {
+		return &user
+	}
+	return nil
+}
+
+// CheckEmailUnique 校验邮箱是否存在
+func (d UserDao) CheckEmailUnique(user request.UserBody) *entity.SysUser {
+	sysUser := entity.SysUser{}
+	session := SqlDB.NewSession().Table("sys_user")
+	session.Cols("user_id", "email")
+	session.Where("email = ?", user.Email)
+	if user.UserId > 0 {
+		session.And("user_id != ?", user.UserId)
+	}
+	get, _ := session.Limit(1).Get(&sysUser)
+	if !get {
+		return nil
+	}
+	return &sysUser
+}
+
+// CheckPhoneNumUnique 校验手机号是否存在
+func (d UserDao) CheckPhoneNumUnique(body request.UserBody) *entity.SysUser {
+	sysUser := entity.SysUser{}
+	session := SqlDB.NewSession().Table("sys_user")
+	session.Cols("user_id", "phone_num")
+	session.Where("phone_num = ?", body.PhoneNumber)
+	if body.UserId > 0 {
+		session.And("user_id != ?", body.UserId)
+	}
+	get, _ := session.Limit(1).Get(&sysUser)
+	if !get {
+		return nil
+	}
+	return &sysUser
+}
+
+// Insert 添加用户
+func (d UserDao) Insert(body request.UserBody) *request.UserBody {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Table("sys_user").Insert(&body)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+	}
+	session.Commit()
+	return &body
+}
+
+// Update 修改用户数据
+func (d UserDao) Update(body request.UserBody) int64 {
+	session := SqlDB.NewSession().Table("sys_user")
+	session.Begin()
+	_, err := session.Where("user_id = ?", body.UserId).Update(&body)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return 1
+}
+
+// Delete 根据id删除用户数据
+func (d UserDao) Delete(id int64) int64 {
+	user := entity.SysUser{
+		UserId: id,
+	}
+	session := SqlDB.NewSession().Table("sys_user")
+	session.Begin()
+	i, err := session.Delete(&user)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+	}
+	session.Commit()
+	return i
+}
+
+// ResetPwd 修改用户密码数据库操作
+func (d UserDao) ResetPwd(body request.UserBody) int64 {
+	user := entity.SysUser{
+		UserId:   body.UserId,
+		Password: body.Password,
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Where("user_id = ?", user.UserId).Cols("password").Update(&user)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return 1
+}
+
+// GetAllocatedList 查询未分配用户角色列表
+func (d UserDao) GetAllocatedList(query request.UserQuery) ([]*response.UserResponse, int64) {
+	resp := make([]*response.UserResponse, 0)
+	session := SqlDB.NewSession()
+	session.Table([]string{"sys_user", "u"}).Distinct("u.user_id", "u.dept_id", "u.user_name", "u.nick_name", "u.email", "u.phone_number", "u.status", "u.create_time").
+		Join("LEFT", []string{"sys_dept", "d"}, "u.dept_id = d.dept_id").
+		Join("LEFT", []string{"sys_user_role", "ur"}, "u.user_id = ur.user_id").
+		Join("LEFT", []string{"sys_role", "r"}, "r.role_id = ur.role_id").Where("u.del_flag = '0'").And("r.role_id = ?", query.RoleId)
+	if gotool.StrUtils.HasNotEmpty(query.UserName) {
+		session.And("u.user_name like concat('%', ?, '%')", query.UserName)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.PhoneNumber) {
+		session.And("u.phone_number like concat('%', ?, '%')", query.PhoneNumber)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return resp, total
+}
+
+// GetUnallocatedList 查询未分配用户角色列表
+func (d UserDao) GetUnallocatedList(query request.UserQuery) ([]*response.UserResponse, int64) {
+	resp := make([]*response.UserResponse, 0)
+	session := SqlDB.NewSession()
+	session.Table([]string{"sys_user", "u"}).Distinct("u.user_id", "u.dept_id", "u.user_name", "u.nick_name", "u.email", "u.phone_number", "u.status", "u.create_time").
+		Join("LEFT", []string{"sys_dept", "d"}, "u.dept_id = d.dept_id").
+		Join("LEFT", []string{"sys_user_role", "ur"}, "u.user_id = ur.user_id").
+		Join("LEFT", []string{"sys_role", "r"}, "r.role_id = ur.role_id").Where("u.del_flag = '0'").And("r.role_id = ? or r.role_id IS NULL", query.RoleId).
+		And("u.user_id not in (select u.user_id from sys_user u inner join sys_user_role ur on u.user_id = ur.user_id and ur.role_id = ?)", query.RoleId)
+	if gotool.StrUtils.HasNotEmpty(query.UserName) {
+		session.And("u.user_name like concat('%', ?, '%')", query.UserName)
+	}
+	if gotool.StrUtils.HasNotEmpty(query.PhoneNumber) {
+		session.And("u.phone_number like concat('%', ?, '%')", query.PhoneNumber)
+	}
+	total, _ := page.GetTotal(session.Clone())
+	err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp)
+	if err != nil {
+		common.ErrorLog(err)
+		return nil, 0
+	}
+	return resp, total
+}
+
+// UpdatePwd 修改密码
+func (d UserDao) UpdatePwd(id int64, hash string) int64 {
+	user := entity.SysUser{}
+	user.UserId = id
+	user.Password = hash
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Cols("password").Where("user_id = ?", id).Update(&user)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return update
+}
+
+// UpdateAvatar 修改头像
+func (d UserDao) UpdateAvatar(info *response.UserResponse) int64 {
+	user := entity.SysUser{
+		Avatar:     info.Avatar,
+		UserId:     info.UserId,
+		UpdateBy:   info.UserName,
+		UpdateTime: time.Now(),
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Cols("avatar", "update_by", "update_time").Where("user_id = ?", user.UserId).Update(&user)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return update
+}
+
+func (d UserDao) UpdateStatus(info request.UserBody) int64 {
+	user := entity.SysUser{
+		UserId:     info.UserId,
+		Status:     info.Status,
+		UpdateBy:   info.UserName,
+		UpdateTime: time.Now(),
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	update, err := session.Cols("status", "update_by", "update_time").Where("user_id = ?", user.UserId).Update(&user)
+	if err != nil {
+		session.Rollback()
+		common.ErrorLog(err)
+		return 0
+	}
+	session.Commit()
+	return update
+}

core/dao/user_post_dao.go

@@ -0,0 +1,47 @@
+package dao
+
+import (
+	"cutego/core/entity"
+	"cutego/pkg/common"
+)
+
+type UserPostDao struct {
+}
+
+// BatchInsert 批量新增用户岗位信息
+func (d UserPostDao) BatchInsert(posts []entity.SysUserPost) {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Table(entity.SysUserPost{}.TableName()).Insert(&posts)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return
+	}
+	session.Commit()
+}
+
+// Delete 删除用户和岗位关系
+func (d UserPostDao) Delete(id int64) {
+	post := entity.SysUserPost{
+		UserId: id,
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Delete(&post)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+	}
+	session.Commit()
+}
+
+// CountById 通过岗位ID查询岗位使用数量
+func (d UserPostDao) CountById(id int64) int64 {
+	count, err := SqlDB.NewSession().Table("sys_user_post").Cols("post_id").Where("post_id = ?", id).Count()
+	if err != nil {
+		common.ErrorLog(err)
+		return 0
+	}
+	return count
+}

core/dao/user_role_dao.go

@@ -0,0 +1,76 @@
+package dao
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/entity"
+	"cutego/pkg/common"
+)
+
+type UserRoleDao struct {
+}
+
+// BatchInsert 批量新增用户角色信息
+func (d UserRoleDao) BatchInsert(roles []entity.SysUserRole) {
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Table(entity.SysUserRole{}.TableName()).Insert(&roles)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return
+	}
+	session.Commit()
+}
+
+// Delete 删除用户和角色关系
+func (d UserRoleDao) Delete(id int64) {
+	role := entity.SysUserRole{
+		UserId: id,
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	_, err := session.Delete(&role)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return
+	}
+	session.Commit()
+}
+
+// DeleteAuthUser 取消用户授权
+func (d UserRoleDao) DeleteAuthUser(role entity.SysUserRole) int64 {
+	session := SqlDB.NewSession()
+	session.Begin()
+	i, err := session.Delete(&role)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return i
+}
+
+// InsertAuthUsers 批量选择用户授权
+func (d UserRoleDao) InsertAuthUsers(body request.UserRoleBody) int64 {
+	ids := body.UserIds
+	roles := make([]entity.SysUserRole, 0)
+	for i := 0; i < len(ids); i++ {
+		role := entity.SysUserRole{
+			RoleId: body.RoleId,
+			UserId: ids[i],
+		}
+		roles = append(roles, role)
+	}
+	session := SqlDB.NewSession()
+	session.Begin()
+	insert, err := session.Insert(&roles)
+	if err != nil {
+		common.ErrorLog(err)
+		session.Rollback()
+		return 0
+	}
+	session.Commit()
+	return insert
+}

core/entity/sys_config.go

@@ -0,0 +1,22 @@
+package entity
+
+import (
+	"time"
+)
+
+type SysConfig struct {
+	ConfigId    int       `excel:"name=参数主键" xorm:"pk autoincr" json:"configId"`              // 主键id
+	ConfigName  string    `excel:"name=参数名称" xorm:"varchar(100)" json:"configName"`           // 参数名称
+	ConfigKey   string    `excel:"name=参数键名" xorm:"varchar(100)" json:"configKey"`            // 参数建名
+	ConfigValue string    `excel:"name=参数键值" xorm:"varchar(1)" json:"configValue"`            // 参数键值
+	ConfigType  string    `excel:"name=系统内置,format=Y=是,N=否" xorm:"char(1)" json:"configType"` // 系统内置（Y是 N否）
+	CreateBy    string    `xorm:"varchar(64)" json:"createBy"`                                // 创建人
+	CreateTime  time.Time `xorm:"created" json:"createTime"`                                  // 创建时间
+	UpdateBy    string    `xorm:"varchar(64)" json:"updateBy"`                                // 更新人
+	UpdateTime  time.Time `json:"updateTime"`                                                 // 更新时间
+	Remark      string    `xorm:"varchar(500)" json:"remark"`                                 // 备注
+}
+
+func (c SysConfig) TableName() string {
+	return "sys_config"
+}

core/entity/sys_cron_job.go

@@ -0,0 +1,24 @@
+package entity
+
+import (
+	"time"
+)
+
+type SysCronJob struct {
+	JobId      int       `xorm:"pk autoincr" json:"jobId"`      // 任务主键
+	JobName    string    `xorm:"varchar(100)" json:"jobName"`   // 任务名称
+	JobCron    string    `xorm:"varchar(255)" json:"job_cron"`  // cron表达式
+	FuncAlias  string    `xorm:"varchar(100)" json:"funcAlias"` // 方法别名(程序内注册的别名)
+	FuncParam  string    `xorm:"varchar(1)" json:"funcParam"`   // 方法参数
+	Status     string    `xorm:"char(1)" json:"status"`         // 状态(1、Running 0、Stop)
+	Level      int       `xorm:"int(1)" json:"level"`           // 任务级别(0、普通  1、一般 2、重要 3、强保)
+	CreateBy   string    `xorm:"varchar(64)" json:"createBy"`   // 创建人
+	CreateTime time.Time `xorm:"created" json:"createTime"`     // 创建时间
+	UpdateBy   string    `xorm:"varchar(64)" json:"updateBy"`   // 更新人
+	UpdateTime time.Time `json:"updateTime"`                    // 更新时间
+	Remark     string    `xorm:"varchar(500)" json:"remark"`    // 备注
+}
+
+func (c SysCronJob) TableName() string {
+	return "sys_cron_job"
+}

core/entity/sys_dept.go

@@ -0,0 +1,45 @@
+package entity
+
+import "time"
+
+// SysDept 部门结构体
+type SysDept struct {
+	DeptId     int       `xorm:"pk autoincr" json:"deptId"`
+	Ancestors  string    `xorm:"varchar(50)" json:"ancestors"`
+	DeptName   string    `xorm:"varchar(128)" json:"deptName"`
+	OrderNum   int       `json:"orderNum"`
+	Leader     string    `xorm:"varchar(20)" json:"leader"`
+	ParentId   int       `json:"parentId"`
+	Phone      string    `xorm:"varchar(11)" json:"phone"`
+	Status     string    `xorm:"char(1)" json:"status"`
+	Email      string    `json:"email"`
+	DelFlag    string    `xorm:"char(1) default('0')" json:"delFlag"`
+	CreateTime time.Time `xorm:"created" json:"createTime"` // 创建时间
+	CreateBy   string    `json:"createBy"`                  // 创建人
+	UpdateTime time.Time `json:"updateTime"`                // 更新时间
+	UpdateBy   string    `json:"updateBy"`                  // 更新人
+}
+
+func (d SysDept) GetLabel() string {
+	return d.DeptName
+}
+
+func (d SysDept) GetId() int {
+	return d.DeptId
+}
+
+func (d SysDept) GetParentId() int {
+	return d.ParentId
+}
+
+func (d SysDept) GetData() interface{} {
+	return d
+}
+
+func (d SysDept) IsRoot() bool {
+	return d.ParentId == 0 || d.ParentId == d.DeptId
+}
+
+func (SysDept) TableName() string {
+	return "sys_dept"
+}

core/entity/sys_dict_data.go

@@ -0,0 +1,25 @@
+package entity
+
+import (
+	"time"
+)
+
+// SysDictData 字典数据
+type SysDictData struct {
+	DictCode   int64     `excel:"name=字典编码" xorm:"pk autoincr" json:"dictCode"`          // 字典ID
+	DictSort   int       `excel:"name=字典排序" xorm:"int" json:"dictSort"`                  // 字典排序
+	DictLabel  string    `excel:"name=字典标签" xorm:"varchar(128)" json:"dictLabel"`        // 字典标签
+	DictValue  string    `excel:"name=字典键值" xorm:"varchar(128)" json:"dictValue"`        // 字典键值
+	DictType   string    `excel:"name=字典类型" xorm:"varchar(128)" json:"dictType"`         // 字典类型
+	IsDefault  string    `excel:"name=是否默认,format=Y=是,N=否" json:"isDefault"`             // 是否默认
+	Status     string    `excel:"name=状态,format=0=正常,1=停用" xorm:"char(1)" json:"status"` // 状态 0正常1停用
+	Remark     string    `xorm:"varchar(512)" json:"remark"`                             // 备注
+	CreateTime time.Time `xorm:"created" json:"createTime"`                              // 创建时间
+	CreateBy   string    `json:"createBy"`                                               // 创建人
+	UpdateTime time.Time `json:"updateTime"`                                             // 更新时间
+	UpdateBy   string    `json:"updateBy"`                                               // 更新人
+}
+
+func (SysDictData) TableName() string {
+	return "sys_dict_data"
+}

core/entity/sys_dict_type.go

@@ -0,0 +1,22 @@
+package entity
+
+import (
+	"time"
+)
+
+// SysDictType 字典类型表
+type SysDictType struct {
+	DictId     int64     `excel:"name=字典主键" xorm:"pk autoincr" json:"dictId"`              // 字典ID
+	DictName   string    `excel:"name=字典名称" xorm:"varchar(128)" json:"dictName"`           // 字典名称
+	DictType   string    `excel:"name=字典类型" xorm:"varchar(128)" json:"dictType"`           // 字典类型
+	Status     string    `excel:"name=字典状态,format=0=正常,1=停用" xorm:"char(1)" json:"status"` // 状态 0正常1停用
+	Remark     string    `xorm:"varchar(512)" json:"remark"`                               // 备注
+	CreateTime time.Time `xorm:"created" json:"createTime"`                                // 创建时间
+	CreateBy   string    `json:"createBy"`                                                 // 创建人
+	UpdateTime time.Time `json:"updateTime"`                                               // 更新时间
+	UpdateBy   string    `json:"updateBy"`                                                 // 更新人
+}
+
+func (SysDictType) TableName() string {
+	return "sys_dict_type"
+}

core/entity/sys_login_info.go

@@ -0,0 +1,21 @@
+package entity
+
+import (
+	"time"
+)
+
+type SysLoginInfo struct {
+	Id            int       `excel:"name=主键id" xorm:"pk autoincr" json:"id"`                  // 主键id
+	UserName      string    `excel:"name=用户账号" xorm:"varchar(50)" json:"userName"`            // 用户账号
+	IpAddr        string    `excel:"name=登录IP地址" xorm:"varchar(128)" json:"ipAddr"`           // 登录IP地址
+	LoginLocation string    `excel:"name=登录地点" xorm:"varchar(255)" json:"loginLocation"`      // 登录地点
+	Browser       string    `excel:"name=浏览器类型" xorm:"varchar(255)" json:"browser"`           // 浏览器类型
+	OS            string    `excel:"name=操作系统" xorm:"os varchar(50)" json:"os"`               // 操作系统
+	Status        string    `excel:"name=登录状态,format=1=成功,0=失败" xorm:"char(1)" json:"status"` // 登录状态（1成功 0失败）
+	Msg           string    `excel:"name=提示消息" xorm:"varchar(255)" json:"msg"`                // 提示消息
+	LoginTime     time.Time `excel:"name=登录时间" xorm:"login_time" json:"loginTime"`            // 登录时间
+}
+
+func (c SysLoginInfo) TableName() string {
+	return "sys_login_info"
+}

core/entity/sys_menu.go

@@ -0,0 +1,59 @@
+package entity
+
+import (
+	"strings"
+	"time"
+)
+
+// SysMenu 菜单结构体
+type SysMenu struct {
+	MenuId     int       `xorm:"pk autoincr" json:"menuId"`     // 主键Id
+	ParentId   int       `json:"parentId"`                      // 父Id
+	MenuName   string    `xorm:"varchar(128)" json:"menuName"`  // 菜单名称
+	OrderNum   int       `xorm:"int" json:"orderNum"`           // 显示顺序
+	Path       string    `xorm:"varchar(200)" json:"path"`      // 请求路径
+	MenuType   string    `xorm:"char(1)" json:"menuType"`       // 菜单类型 （M目录 C菜单 F按钮）
+	Visible    string    `xorm:"char(1)" json:"visible"`        // 菜单状态 （0显示 1隐藏）
+	IsFrame    int       `json:"isFrame"`                       // 是否为外链（0是 1否）
+	IsCache    int       `json:"isCache"`                       // 是否缓存（0缓存 1不缓存）
+	Perms      string    `xorm:"varchar(100)" json:"perms"`     // 权限标识
+	Icon       string    `xorm:"varchar(100)" json:"icon"`      // 图标
+	Remark     string    `xorm:"varchar(512)" json:"remark"`    // 备注
+	CreateTime time.Time `xorm:"created" json:"createTime"`     // 创建时间
+	CreateBy   string    `json:"createBy"`                      // 创建人
+	UpdateTime time.Time `json:"updateTime"`                    // 更新时间
+	UpdateBy   string    `json:"updateBy"`                      // 更新人
+	Status     string    `xorm:"char(1)" json:"status"`         // 菜单状态（0正常 1停用）
+	Component  string    `xorm:"varchar(255)" json:"component"` // 组件路径
+}
+
+func (SysMenu) TableName() string {
+	return "sys_menu"
+}
+func (s SysMenu) GetPath() string {
+	return s.Path
+}
+func (s SysMenu) GetName() string {
+	return strings.Title(s.Path)
+}
+func (s SysMenu) GetMenuId() int {
+	return s.MenuId
+}
+func (s SysMenu) GetParentId() int {
+	return s.ParentId
+}
+func (s SysMenu) GetData() interface{} {
+	return s
+}
+func (s SysMenu) IsRoot() bool {
+	// 这里通过FatherId等于0 或者 FatherId等于自身Id表示顶层根节点
+	return s.ParentId == 0 || s.ParentId == s.MenuId
+}
+
+func (s SysMenu) GetId() int {
+	return s.MenuId
+}
+
+func (s SysMenu) GetLabel() string {
+	return s.MenuName
+}

core/entity/sys_notice.go

@@ -0,0 +1,20 @@
+package entity
+
+import "time"
+
+type SysNotice struct {
+	NoticeId      int64     `xorm:"pk autoincr" json:"noticeId"`     // 公告id
+	NoticeTitle   string    `xorm:"notice_title" json:"noticeTitle"` // 公告标题
+	NoticeType    string    `xorm:"notice_type" json:"noticeType"`   // 公告类型（1通知 2公告）
+	NoticeContent string    `json:"noticeContent"`                   // 公告内容
+	Status        string    `json:"status"`                          // 公告状态（0正常 1关闭）
+	CreateBy      string    `xorm:"varchar(64)" json:"createBy"`     // 创建人
+	CreateTime    time.Time `xorm:"created" json:"createTime"`       // 创建时间
+	UpdateBy      string    `xorm:"varchar(64)" json:"updateBy"`     // 更新人
+	UpdateTime    time.Time `json:"updateTime"`                      // 更新时间
+	Remark        string    `xorm:"varchar(500)" json:"remark"`      // 备注
+}
+
+func (SysNotice) TableName() string {
+	return "sys_notice"
+}

core/entity/sys_post.go

@@ -0,0 +1,21 @@
+package entity
+
+import "time"
+
+// SysPost 岗位表对应结构体
+type SysPost struct {
+	PostId     int64     `excel:"name=岗位编号" xorm:"pk autoincr" json:"postId"`            // 岗位ID
+	PostCode   string    `excel:"name=岗位编码" xorm:"varchar(64)" json:"postCode"`          // 岗位编码
+	PostName   string    `excel:"name=岗位名称" xorm:"varchar(64)" json:"postName"`          // 岗位名称
+	PostSort   int       `excel:"name=岗位排序" json:"postSort"`                             // 显示顺序
+	Status     string    `excel:"name=状态,format=0=正常,1=停用" xorm:"char(1)" json:"status"` // 状态 0正常 1停用
+	Remark     string    `xorm:"varchar(512)" json:"remark"`                             // 备注
+	CreateTime time.Time `xorm:"created" json:"createTime"`                              // 创建时间
+	CreateBy   string    `json:"createBy"`                                               // 创建人
+	UpdateTime time.Time `json:"updateTime"`                                             // 更新时间
+	UpdateBy   string    `json:"updateBy"`                                               // 更新人
+}
+
+func (SysPost) TableName() string {
+	return "sys_post"
+}

core/entity/sys_role.go

@@ -0,0 +1,26 @@
+package entity
+
+import "time"
+
+type SysRole struct {
+	RoleId            int64     `excel:"name=角色序号" xorm:"pk autoincr" json:"roleId"`              // 角色id
+	RoleName          string    `excel:"name=角色名称" xorm:"varchar(64)" json:"roleName"`            // 角色名称
+	RoleKey           string    `excel:"name=角色权限" xorm:"varchar(64)" json:"roleKey"`             // 角色权限标识
+	RoleSort          int       `excel:"name=角色排序" xorm:"int" json:"roleSort"`                    // 角色顺序
+	DataScope         string    `excel:"-" json:"dataScope"`                                      // 数据范围（1：全部数据权限 2：自定数据权限 3：本部门数据权限 4：本部门及以下数据权限）
+	MenuCheckStrictly bool      `excel:"-" json:"menuCheckStrictly"`                              // 菜单树选择项是否关联显示
+	DeptCheckStrictly bool      `excel:"-" json:"deptCheckStrictly"`                              // 部门树选择项是否关联显示
+	Status            string    `excel:"name=角色状态,format=0=正常,1=停用" xorm:"char(1)" json:"status"` // 角色状态 0正常1停用
+	DelFlag           string    `excel:"" xorm:"char(1)" json:"delFlag"`                          // 删除标记0正常1删除
+	CreateTime        time.Time `excel:"" xorm:"created" json:"createTime"`                       // 创建时间
+	CreateBy          string    `excel:"" json:"createBy"`                                        // 创建人
+	UpdateTime        time.Time `excel:"" json:"updateTime"`                                      // 更新时间
+	UpdateBy          string    `excel:"" json:"updateBy"`                                        // 更新人
+	Remark            string    `excel:"" json:"remark"`                                          // 备注
+	MenuIds           []int64   `xorm:"-" json:"menuIds"`                                         // 菜单组
+	DeptIds           []int64   `xorm:"-" json:"deptIds"`                                         // 部门组
+}
+
+func (r SysRole) TableName() string {
+	return "sys_role"
+}

core/entity/sys_role_menu.go

@@ -0,0 +1,11 @@
+package entity
+
+// SysRoleMenu 角色菜单数据结构
+type SysRoleMenu struct {
+	RoleId int64 `xorm:"pk" json:"roleId"` // 角色id
+	MenuId int64 `xorm:"pk" json:"menuId"` // 菜单id
+}
+
+func (SysRoleMenu) TableName() string {
+	return "sys_role_menu"
+}

core/entity/sys_user.go

@@ -0,0 +1,40 @@
+package entity
+
+import (
+	"reflect"
+	"time"
+)
+
+// SysUser 用户表数据结构体
+type SysUser struct {
+	UserId      int64     `xorm:"pk autoincr" json:"userId"`      // 用户ID
+	DeptId      int64     `json:"deptId"`                         // 部门ID
+	UserName    string    `xorm:"varchar(128)" json:"userName"`   // 登录用户名
+	NickName    string    `xorm:"varchar(128)" json:"nickName"`   // 用户昵称
+	Email       string    `xorm:"varchar(1024)" json:"email"`     // 邮箱
+	PhoneNumber string    `xorm:"varchar(11)" json:"phoneNumber"` // 手机号
+	Sex         string    `xorm:"char(1)" json:"sex"`             // 性别0男1女
+	Avatar      string    `xorm:"varchar(128)" json:"avatar"`     // 头像路径
+	Password    string    `xorm:"varchar(128)" json:"-"`          // 密码
+	Status      string    `xorm:"char(1)" json:"status"`          // 状态 0正常1停用
+	DelFlag     string    `xorm:"char(1)" json:"delFlag"`         // 0正常1删除
+	LoginIp     string    `xorm:"varchar(128)" json:"loginIp"`    // 登录ip
+	LoginDate   time.Time `json:"loginDate"`                      // 登录时间
+	CreateTime  time.Time `xorm:"created" json:"createTime"`      // 创建时间
+	CreateBy    string    `json:"createBy"`                       // 创建人
+	UpdateTime  time.Time `json:"updateTime"`                     // 更新时间
+	UpdateBy    string    `json:"updateBy"`                       // 更新人
+}
+
+func (receiver SysUser) TableName() string {
+	return "sys_user"
+}
+
+// IsAdmin 判断用户是不是管理员
+func (u SysUser) IsAdmin(userId int64) bool {
+	return userId > 0 && 1 == userId
+}
+
+func (a SysUser) IsEmpty() bool {
+	return reflect.DeepEqual(a, SysUser{})
+}

core/entity/sys_user_post.go

@@ -0,0 +1,10 @@
+package entity
+
+type SysUserPost struct {
+	UserId int64 `json:"userId"` // 用户id
+	PostId int64 `json:"postId"` // 部门id
+}
+
+func (SysUserPost) TableName() string {
+	return "sys_user_post"
+}

core/entity/sys_user_role.go

@@ -0,0 +1,10 @@
+package entity
+
+type SysUserRole struct {
+	UserId int64 `xorm:"pk" json:"userId"` // 用户id
+	RoleId int64 `xorm:"pk" json:"roleId"` // 角色id
+}
+
+func (SysUserRole) TableName() string {
+	return "sys_user_role"
+}

core/job/index.go

@@ -0,0 +1,21 @@
+package job
+
+import (
+	"cutego/core/service"
+	"cutego/pkg/common"
+)
+
+// 定时任务: 别名与方法的映射
+var AliasFuncMap = make(map[string]func())
+
+// 注册任务
+func RegisterFunc(aliasName string, f func()) {
+	currentJob := service.CronJobService{}.GetInfoByAlias(aliasName)
+	AliasFuncMap[aliasName] = f
+	common.InfoLogf("注册定时任务 --- %s ---> Success", currentJob.JobName)
+}
+
+// 注册方法
+func init() {
+	//RegisterFunc("test1", TestJob)
+}

core/job/test_job.go

@@ -0,0 +1,7 @@
+package job
+
+import "fmt"
+
+func TestJob() {
+	fmt.Println("哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈")
+}

core/router/config_router.go

@@ -0,0 +1,29 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+func initConfigRouter(router *gin.RouterGroup) {
+	v := new(v1.ConfigApi)
+	group := router.Group("/config")
+	{
+		// 根据参数键名查询参数值
+		group.GET("", v.GetConfigValue)
+		// 查询设置列表
+		group.GET("/list", v.List)
+		// 添加
+		group.POST("/create", v.Add)
+		// 查询
+		group.GET("/:configId", v.Get)
+		// 修改
+		group.PUT("/modify", v.Edit)
+		// 批量删除
+		group.DELETE("/:ids", v.Delete)
+		// 刷新缓存
+		group.DELETE("/refreshCache", v.RefreshCache)
+		// 导出数据
+		group.GET("/export", v.Export)
+	}
+}

core/router/cron_job_router.go

@@ -0,0 +1,24 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+// 初始化定时任务路由
+func initCronJobRouter(router *gin.RouterGroup) {
+	v := new(v1.CronJobApi)
+	group := router.Group("/cronJob")
+	{
+		// 查询定时任务分页数据
+		group.GET("/list", v.List)
+		// 修改定时任务
+		group.PUT("/modify", v.Edit)
+		// 新增定时任务
+		group.POST("/create", v.Add)
+		// 删除定时任务
+		group.DELETE("/:jobId", v.Remove)
+		// 改变定时任务状态
+		group.DELETE("/changeStatus", v.ChangeStatus)
+	}
+}

core/router/dept_router.go

@@ -0,0 +1,30 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+// 部门接口操作
+func initDeptRouter(router *gin.RouterGroup) {
+	v := new(v1.DeptApi)
+	group := router.Group("/dept")
+	{
+		// 获取部门下拉树列表
+		group.GET("/treeSelect", v.DeptTreeSelect)
+		// 加载对应角色部门列表树
+		group.GET("/roleDeptTreeSelect/:roleId", v.RoleDeptTreeSelect)
+		// 查询部门列表
+		group.GET("/list", v.Find)
+		// 查询部门列表（排除节点）
+		group.GET("/list/exclude/:deptId", v.ExcludeChild)
+		// 根据部门编号获取详细信息
+		group.GET("/:deptId", v.GetInfo)
+		// 添加部门
+		group.POST("/create", v.Add)
+		// 删除部门
+		group.DELETE("/:deptId", v.Delete)
+		// 修改部门
+		group.PUT("/modify", v.Edit)
+	}
+}

core/router/dict_data_router.go

@@ -0,0 +1,28 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+// 初始化字典数据路由
+func initDictDataRouter(router *gin.RouterGroup) {
+	v := new(v1.DictDataApi)
+	group := router.Group("/dict/data")
+	{
+		// 根据字典类型查询字典数据信息
+		group.GET("/type/:dictType", v.GetByType)
+		// 查询字典数据集合
+		group.GET("/list", v.List)
+		// 根据id查询字典数据
+		group.GET("/:dictCode", v.Get)
+		// 添加字点数据
+		group.POST("/create", v.Add)
+		// 删除字典数据
+		group.DELETE("/:dictCode", v.Delete)
+		// 导出字典数据
+		group.GET("/export", v.Export)
+		// 编辑字典数据
+		group.PUT("/modify", v.Edit)
+	}
+}

core/router/dict_type_router.go

@@ -0,0 +1,28 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+// 初始化字典类型路由
+func initDictTypeRouter(router *gin.RouterGroup) {
+	v := new(v1.DictTypeApi)
+	group := router.Group("/dict/type")
+	{
+		// 查询字典类型分页数据
+		group.GET("/list", v.List)
+		// 根据id查询字典类型数据
+		group.GET("/:dictTypeId", v.Get)
+		// 修改字典类型
+		group.PUT("/modify", v.Edit)
+		// 新增字典类型
+		group.POST("/create", v.Add)
+		// 删除字典类型
+		group.DELETE("/:dictId", v.Remove)
+		// 刷新缓存
+		group.DELETE("/refreshCache", v.RefreshCache)
+		// 导出excel
+		group.GET("/export", v.Export)
+	}
+}

core/router/login_router.go

@@ -0,0 +1,21 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+// 登录调用路由
+func initLoginRouter(router *gin.RouterGroup) {
+	loginApi := new(v1.LoginApi)
+	loginRouter := router.Group("/")
+	{
+		// 登录
+		loginRouter.POST("/login", loginApi.Login)
+		loginRouter.GET("/getInfo", loginApi.GetUserInfo)
+		loginRouter.GET("/getRouters", loginApi.GetRouters)
+		loginRouter.GET("/getLoginHistory", loginApi.GetLoginHistory)
+		// 退出登录
+		loginRouter.POST("/logout", loginApi.Logout)
+	}
+}

core/router/menu_router.go

@@ -0,0 +1,27 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+func initMenuRouter(router *gin.RouterGroup) {
+	v := new(v1.MenuApi)
+	vg := router.Group("/menu")
+	{
+		// 查询菜单数据
+		vg.GET("/:menuId", v.GetInfo)
+		// 查询菜单列表
+		vg.GET("/list", v.List)
+		// 加载对应角色菜单列表树
+		vg.GET("/roleMenuTreeSelect/:roleId", v.RoleMenuTreeSelect)
+		// 获取菜单下拉树列表
+		vg.GET("/treeSelect", v.TreeSelect)
+		// 添加菜单数据
+		vg.POST("/create", v.Add)
+		// 修改菜单数据
+		vg.PUT("/modify", v.Edit)
+		// 删除菜单数据
+		vg.DELETE("/:menuId", v.Delete)
+	}
+}

core/router/notice_router.go

@@ -0,0 +1,22 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+func initNoticeRouter(router *gin.RouterGroup) {
+	v := new(v1.NoticeApi)
+	group := router.Group("/notice")
+	{
+		group.GET("/list", v.List)
+		// 添加公告
+		group.POST("/create", v.Add)
+		// 删除
+		group.DELETE("/:ids", v.Delete)
+		// 查询
+		group.GET("/:id", v.Get)
+		// 修改
+		group.PUT("/modify", v.Edit)
+	}
+}

core/router/post_router.go

@@ -0,0 +1,26 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+// 初始化岗位路由
+func initPostRouter(router *gin.RouterGroup) {
+	v := new(v1.PostApi)
+	group := router.Group("/post")
+	{
+		// 查询岗位数据
+		group.GET("/list", v.List)
+		// 添加岗位
+		group.POST("/create", v.Add)
+		// 查询岗位详情
+		group.GET("/:postId", v.Get)
+		// 删除岗位数据
+		group.DELETE("/:postId", v.Delete)
+		// 修改岗位数据接口
+		group.PUT("/modify", v.Edit)
+		// 导出excel
+		group.GET("/export", v.Export)
+	}
+}

core/router/role_router.go

@@ -0,0 +1,35 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+func initRoleRouter(router *gin.RouterGroup) {
+	roleApi := new(v1.RoleApi)
+	group := router.Group("/role")
+	{
+		// 查询角色数据
+		group.GET("/findList", roleApi.Find)
+		// 根据id查询角色数据
+		group.GET("/:roleId", roleApi.GetRoleId)
+		// 添加角色
+		group.POST("/create", roleApi.Add)
+		// 修改角色
+		group.PUT("/modify", roleApi.Edit)
+		// 删除角色
+		group.DELETE("/:roleId", roleApi.Delete)
+		// 修改角色状态
+		group.PUT("/changeStatus", roleApi.ChangeStatus)
+		// 查看分配角色列表
+		group.GET("/authUser/allocatedList", roleApi.AllocatedList)
+		// 查询未分配用户角色列表
+		group.GET("/authUser/unallocatedList", roleApi.UnallocatedList)
+		// 取消授权
+		group.PUT("/authUser/cancel", roleApi.CancelAuthUser)
+		// 批量选择用户授权
+		group.PUT("/authUser/selectAll", roleApi.UpdateAuthUserAll)
+		// 导出excel
+		group.GET("/export", roleApi.Export)
+	}
+}

core/router/router.go

@@ -0,0 +1,49 @@
+package router
+
+import (
+	"cutego/pkg/filter"
+	"cutego/pkg/jwt"
+	"cutego/pkg/middleware"
+	"cutego/pkg/middleware/logger"
+	"cutego/pkg/websocket"
+	"github.com/gin-gonic/gin"
+)
+
+func Init() *gin.Engine {
+	router := gin.New()
+	router.Use(gin.Logger())
+	router.Use(gin.Recovery())
+	router.Use(logger.LoggerToFile())
+	router.Use(middleware.Recover)
+	router.Use(jwt.JWTAuth())
+	router.Use(filter.DemoHandler())
+	// websocket
+	router.GET("/websocket", websocket.HandleWebSocketMessage)
+	// v1版本api
+	v1Router := router.Group("/api/v1")
+	{
+		// 登录接口
+		initLoginRouter(v1Router)
+		// 用户路由接口
+		initUserRouter(v1Router)
+		// 部门路由注册
+		initDeptRouter(v1Router)
+		// 初始化字典数据路由
+		initDictDataRouter(v1Router)
+		// 注册配置路由
+		initConfigRouter(v1Router)
+		// 注册角色路由
+		initRoleRouter(v1Router)
+		// 注册菜单路由
+		initMenuRouter(v1Router)
+		// 注册岗位路由
+		initPostRouter(v1Router)
+		// 注册字典类型路由
+		initDictTypeRouter(v1Router)
+		// 注册公告路由
+		initNoticeRouter(v1Router)
+		// 注册定时任务路由
+		initCronJobRouter(v1Router)
+	}
+	return router
+}

core/router/user_router.go

@@ -0,0 +1,36 @@
+package router
+
+import (
+	"cutego/core/api/v1"
+	"github.com/gin-gonic/gin"
+)
+
+// 用户路由
+func initUserRouter(router *gin.RouterGroup) {
+	userApi := new(v1.UserApi)
+	userRouter := router.Group("/user")
+	{
+		userRouter.GET("/list", userApi.Find)
+		userRouter.GET("/getInfo/:userId", userApi.GetInfo)
+		userRouter.GET("/getInfo", userApi.GetInfo)
+		userRouter.GET("/authRole/:userId", userApi.AuthRole)
+		// 新增用户
+		userRouter.POST("/create", userApi.Add)
+		// 修改用户
+		userRouter.PUT("/modify", userApi.Edit)
+		// 删除用户
+		userRouter.DELETE("/remove/:userId", userApi.Remove)
+		// 重置密码
+		userRouter.PUT("/resetPwd", userApi.ResetPwd)
+		userRouter.GET("/export", userApi.Export)
+		userRouter.GET("/profile", userApi.Profile)
+		// 修改个人数据
+		userRouter.PUT("/profile", userApi.UpdateProfile)
+		// 修改个人密码
+		userRouter.PUT("/profile/updatePwd", userApi.UpdatePwd)
+		// 修改头像
+		userRouter.POST("/profile/avatar", userApi.Avatar)
+		// 修改可用状态
+		userRouter.PUT("/changeStatus", userApi.ChangeStatus)
+	}
+}

core/service/config_service.go

@@ -0,0 +1,64 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	cache2 "cutego/core/cache"
+	"cutego/core/dao"
+	"cutego/core/entity"
+)
+
+type ConfigService struct {
+	configDao dao.ConfigDao
+}
+
+// GetConfigKey 根据键名查询参数配置信息
+func (s ConfigService) GetConfigKey(param string) *entity.SysConfig {
+	// 从缓存中取出数据判断是否存在, 存在直接使用, 不存在就从数据库查询
+	val := cache2.GetRedisConfig(param)
+	if val != nil {
+		return val
+	}
+	configKey := s.configDao.SelectByConfigKey(param)
+	cache2.SetRedisConfig(*configKey)
+	return configKey
+}
+
+// FindPage 分页查询数据
+func (s ConfigService) FindPage(query request.ConfigQuery) (*[]entity.SysConfig, int64) {
+	return s.configDao.SelectPage(query)
+}
+
+// CheckConfigKeyUnique 校验是否存在
+func (s ConfigService) CheckConfigKeyUnique(config entity.SysConfig) bool {
+	return s.configDao.CheckConfigKeyUnique(config) > 0
+}
+
+// Save 添加数据
+func (s ConfigService) Save(config entity.SysConfig) int64 {
+	return s.configDao.Insert(config)
+}
+
+// GetInfo 查询数据
+func (s ConfigService) GetInfo(id int64) *entity.SysConfig {
+	return s.configDao.SelectById(id)
+}
+
+// Edit 修改数据
+func (s ConfigService) Edit(config entity.SysConfig) int64 {
+	return s.configDao.Update(config)
+}
+
+// Remove 批量删除
+func (s ConfigService) Remove(list []int64) bool {
+	return s.configDao.Delete(list)
+}
+
+// CheckConfigByIds 根据id集合查询
+func (s ConfigService) CheckConfigByIds(list []int64) *[]entity.SysConfig {
+	return s.configDao.CheckConfigByIds(list)
+}
+
+// FindAll 查询所有数据
+func (s ConfigService) FindAll() *[]entity.SysConfig {
+	return s.configDao.SelectAll()
+}

core/service/cron_job_service.go

@@ -0,0 +1,41 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/dao"
+	"cutego/core/entity"
+)
+
+type CronJobService struct {
+	cronJobService dao.CronJobDao
+}
+
+// FindPage 分页查询数据
+func (s CronJobService) FindPage(query request.CronJobQuery) ([]entity.SysCronJob, int64) {
+	return s.cronJobService.SelectPage(query)
+}
+
+// Save 添加数据
+func (s CronJobService) Save(config entity.SysCronJob) int64 {
+	return s.cronJobService.Insert(config)
+}
+
+// GetInfo 查询数据
+func (s CronJobService) GetInfo(id int64) *entity.SysCronJob {
+	return s.cronJobService.SelectById(id)
+}
+
+// GetInfo 查询数据
+func (s CronJobService) GetInfoByAlias(funcAlias string) *entity.SysCronJob {
+	return s.cronJobService.SelectByFuncAlias(funcAlias)
+}
+
+// Edit 修改数据
+func (s CronJobService) Edit(config entity.SysCronJob) int64 {
+	return s.cronJobService.Update(config)
+}
+
+// Remove 批量删除
+func (s CronJobService) Remove(list []int64) bool {
+	return s.cronJobService.Delete(list)
+}

core/service/dept_service.go

@@ -0,0 +1,67 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	dao2 "cutego/core/dao"
+	"cutego/core/entity"
+)
+
+type DeptService struct {
+	deptDao dao2.DeptDao
+	roleDao dao2.RoleDao
+}
+
+// TreeSelect 根据条件查询部门树
+func (s DeptService) FindTreeSelect(query request.DeptQuery) *[]entity.SysDept {
+	treeSelect := s.deptDao.SelectTree(query)
+	return treeSelect
+}
+
+// FindDeptListByRoleId 根据角色ID查询部门树信息
+func (s DeptService) FindDeptListByRoleId(id int64) *[]int64 {
+	role := s.roleDao.SelectRoleByRoleId(id)
+	return s.deptDao.SelectDeptListByRoleId(id, role.DeptCheckStrictly)
+}
+
+// FindDeptList 查询部门列表
+func (s DeptService) FindDeptList(query request.DeptQuery) *[]entity.SysDept {
+	return s.deptDao.GetList(query)
+}
+
+// GetDeptById 根据部门编号获取详细信息
+func (s DeptService) GetDeptById(id int) *entity.SysDept {
+	return s.deptDao.SelectDeptById(id)
+}
+
+// Save 添加部门数据
+func (s DeptService) Save(dept entity.SysDept) int64 {
+	return s.deptDao.Insert(dept)
+}
+
+// CheckDeptNameUnique 校验部门名称是否唯一
+func (s DeptService) CheckDeptNameUnique(dept entity.SysDept) bool {
+	if s.deptDao.CheckDeptNameUnique(dept) > 0 {
+		return true
+	}
+	return false
+}
+
+// Remove 删除部门
+func (s DeptService) Remove(id int) int64 {
+	return s.deptDao.Delete(id)
+}
+
+// HasChildByDeptId 是否存在部门子节点
+func (s DeptService) HasChildByDeptId(id int) int64 {
+	return s.deptDao.HasChildByDeptId(id)
+}
+
+// CheckDeptExistUser 查询部门是否存在用户
+func (s DeptService) CheckDeptExistUser(id int) int64 {
+	return s.deptDao.CheckDeptExistUser(id)
+}
+
+// 修改部门
+func (s DeptService) Edit(dept entity.SysDept) bool {
+	return s.deptDao.Update(dept) > 0
+}

core/service/dict_data_service.go

@@ -0,0 +1,76 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	cache2 "cutego/core/cache"
+	"cutego/core/dao"
+	"cutego/core/entity"
+	"cutego/pkg/constant"
+)
+
+type DictDataService struct {
+	dictDataDao dao.DictDataDao
+}
+
+// FindByDictType 根据字典类型查询字典数据
+func (s DictDataService) FindByDictType(dictType string) []entity.SysDictData {
+	// 先从缓存中拉数据
+	key := cache2.GetRedisDict(dictType)
+	if key != nil {
+		return key.([]entity.SysDictData)
+	} else {
+		// 缓存中为空, 从数据库中取数据
+		return s.dictDataDao.SelectByDictType(dictType)
+	}
+}
+
+// FindPage 查询字段数据集合
+func (s DictDataService) FindPage(query request.DiceDataQuery) (*[]entity.SysDictData, int64) {
+	return s.dictDataDao.SelectPage(query)
+}
+
+// GetByCode 根据code查询字典数据
+// @Param code int64
+// @Return *entity.SysDictData
+func (s DictDataService) GetByCode(code int64) *entity.SysDictData {
+	return s.dictDataDao.SelectByDictCode(code)
+}
+
+// Save 新增字典数据
+// @Param data entity.SysDictData
+// @Return bool
+func (s DictDataService) Save(data entity.SysDictData) bool {
+	insert := s.dictDataDao.Insert(data)
+	if insert > 0 {
+		// 刷新缓存数据
+		byType := s.GetNoCacheByType(data.DictType)
+		cache2.SetRedisDict(data.DictType, byType)
+	}
+	return insert > 0
+}
+
+// Remove 删除数据
+// @Param codes 字典code集合
+// @Return bool
+func (s DictDataService) Remove(codes []int64) bool {
+	dictType := s.GetByCode(codes[0]).DictType
+	remove := s.dictDataDao.Delete(codes)
+	if remove {
+		// 刷新缓存
+		code := s.GetNoCacheByType(dictType)
+		cache2.SetRedisDict(dictType, code)
+	}
+	return remove
+}
+
+// GetNoCacheByType 根据字典类型查询字典数据
+// @Param dictType 字典类型
+// @Return []entity.SysDictData
+func (s DictDataService) GetNoCacheByType(dictType string) []entity.SysDictData {
+	return s.dictDataDao.SelectByDictType(constant.RedisConst{}.GetRedisDictKey() + dictType)
+}
+
+// 修改字典数据
+func (s DictDataService) Edit(data entity.SysDictData) bool {
+	return s.dictDataDao.Update(data)
+}

core/service/dict_type_service.go

@@ -0,0 +1,98 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	cache2 "cutego/core/cache"
+	dao2 "cutego/core/dao"
+	models2 "cutego/core/entity"
+)
+
+type DictTypeService struct {
+	dictTypeDao dao2.DictTypeDao
+	dictDataDao dao2.DictDataDao
+}
+
+// FindPage 分页查询字典类型数据
+func (s DictTypeService) FindPage(query request.DictTypeQuery) (*[]models2.SysDictType, int64) {
+	return s.dictTypeDao.SelectPage(query)
+}
+
+// GetById 根据id查询字典类型数据
+func (s DictTypeService) GetById(id int64) *models2.SysDictType {
+	return s.dictTypeDao.SelectById(id)
+}
+
+// CheckDictTypeUnique 检验字典类型是否存在
+func (s DictTypeService) CheckDictTypeUnique(dictType models2.SysDictType) bool {
+	return s.dictTypeDao.CheckDictTypeUnique(dictType) > 0
+}
+
+// Edit 修改字典数据
+func (s DictTypeService) Edit(dictType models2.SysDictType) bool {
+	return s.dictTypeDao.Update(dictType)
+}
+
+// Save 新增字典类型
+func (s DictTypeService) Save(dictType models2.SysDictType) bool {
+	insert := s.dictTypeDao.Insert(dictType)
+	if insert > 0 {
+		cache2.SetRedisDict(dictType.DictType, nil)
+	}
+	return insert > 0
+}
+
+// Remove 批量删除
+func (s DictTypeService) Remove(ids []int64) bool {
+	return s.dictTypeDao.Delete(ids)
+}
+
+// FindAll 查询所有字典类型数据
+func (s DictTypeService) FindAll() []*models2.SysDictType {
+	return s.dictTypeDao.SelectAll()
+}
+
+// RemoveAllCache 删除所有字典缓存
+func (s DictTypeService) RemoveAllCache() []string {
+	typeList := make([]string, 0)
+	allType := s.FindAll()
+	for _, dictType := range allType {
+		typeList = append(typeList, dictType.DictType)
+	}
+	// 删除缓存
+	cache2.RemoveRedisDictList(typeList)
+	return typeList
+}
+
+// LoadDictCache 将字典数据存入缓存
+func (s DictTypeService) LoadDictCache() {
+	typeList := make([]string, 0)
+	allType := s.FindAll()
+	for _, dictType := range allType {
+		typeList = append(typeList, dictType.DictType)
+	}
+	allData := s.dictDataDao.GetDiceDataAll()
+	for _, key := range typeList {
+		list := make([]models2.SysDictData, 0)
+		for _, data := range *allData {
+			if key == data.DictType {
+				list = append(list, data)
+			}
+		}
+		cache2.SetRedisDict(key, list)
+	}
+}
+
+// RefreshCache 刷新缓存数据
+func (s DictTypeService) RefreshCache() {
+	typeList := s.RemoveAllCache()
+	allData := s.dictDataDao.GetDiceDataAll()
+	for _, key := range typeList {
+		list := make([]models2.SysDictData, 0)
+		for _, data := range *allData {
+			if key == data.DictType {
+				list = append(list, data)
+			}
+		}
+		cache2.SetRedisDict(key, list)
+	}
+}

core/service/login_info_service.go

@@ -0,0 +1,57 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/dao"
+	"cutego/core/entity"
+	"cutego/pkg/config"
+	"github.com/gin-gonic/gin"
+	"github.com/yinheli/qqwry"
+	"net"
+	"os"
+)
+
+type LoginInfoService struct {
+	loginInfoDao dao.LoginInfoDao
+}
+
+// FindPage 分页查询数据
+func (s LoginInfoService) FindPage(query request.LoginInfoQuery) (*[]entity.SysLoginInfo, int64) {
+	return s.loginInfoDao.SelectPage(query)
+}
+
+// Save 添加登录记录业务逻辑
+func (s LoginInfoService) Save(body entity.SysLoginInfo) bool {
+	// 添加登录记录数据库操作
+	user := s.loginInfoDao.Insert(body)
+	if user != nil {
+		return true
+	}
+	return false
+}
+
+// GetRequestClientIp 获取请求客户端的ip
+func (s LoginInfoService) GetRequestClientIp(c *gin.Context) string {
+	reqIP := c.ClientIP()
+	if reqIP == "::1" {
+		reqIP = "127.0.0.1"
+	}
+	return reqIP
+}
+
+// 纯真数据库获取ip地址
+// @return {"Ip": "180.89.94.90","Country": "北京市","City": "鹏博士宽带"}
+func (s LoginInfoService) GetLocationByIp(ipAddr string) *qqwry.QQwry {
+	address := net.ParseIP(ipAddr)
+	if ipAddr == "" || address == nil {
+		panic("参数ipAddr是空的")
+	} else {
+		dir, err := os.Getwd()
+		if err != nil {
+			panic("无法获取当前路径, " + err.Error())
+		}
+		q := qqwry.NewQQwry(dir + "/" + config.BaseConfigDirPath + "/scanip/qqwry.dat")
+		q.Find(ipAddr)
+		return q
+	}
+}

core/service/login_service.go

@@ -0,0 +1,46 @@
+package service
+
+import (
+	"cutego/core/api/v1/response"
+	"cutego/pkg/common"
+	"cutego/pkg/jwt"
+	"github.com/druidcaesa/gotool"
+	"github.com/gin-gonic/gin"
+	"strings"
+)
+
+type LoginService struct {
+	userService UserService
+}
+
+// Login 用户登录业务处理
+func (s LoginService) Login(name string, password string) (bool, string) {
+	user := s.userService.GetUserByUserName(name)
+	if user == nil {
+		return false, "用户不存在"
+	}
+	if !gotool.BcryptUtils.CompareHash(user.Password, password) {
+		return false, "密码错误"
+	}
+	// 生成token
+	token, err := jwt.CreateUserToken(s.userService.GetUserById(user.UserId))
+	if err != nil {
+		common.ErrorLog(err)
+		return false, ""
+	}
+	// 数据存储到redis中
+	return true, token
+}
+
+// GetCurrentUser 获取当前登录用户
+func (s LoginService) GetCurrentUser(c *gin.Context) *response.UserResponse {
+	token := c.Request.Header.Get("Authorization")
+	str := strings.Split(token, " ")
+	// parseToken 解析token包含的信息
+	claims, err := jwt.ParseToken(str[1])
+	if err != nil {
+		common.ErrorLog(err)
+	}
+	info := claims.UserInfo
+	return &info
+}

core/service/menu_service.go

@@ -0,0 +1,62 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/api/v1/response"
+	dao2 "cutego/core/dao"
+	models2 "cutego/core/entity"
+)
+
+type MenuService struct {
+	menuDao dao2.MenuDao
+	roleDao dao2.RoleDao
+}
+
+// GetMenuTreeByUserId 根据用户ID查询菜单
+func (s MenuService) GetMenuTreeByUserId(user *response.UserResponse) *[]models2.SysMenu {
+	var menuList *[]models2.SysMenu
+	// 判断是否是管理员
+	flag := models2.SysUser{}.IsAdmin(user.UserId)
+	if flag {
+		menuList = s.menuDao.GetMenuAll()
+	} else {
+		menuList = s.menuDao.GetMenuByUserId(user.UserId)
+	}
+	return menuList
+}
+
+// FindMenuListByRoleId 根据角色ID查询菜单树信息
+func (s MenuService) FindMenuListByRoleId(id int64) *[]int64 {
+	role := s.roleDao.SelectRoleByRoleId(id)
+	return s.menuDao.SelectMenuByRoleId(id, role.MenuCheckStrictly)
+}
+
+// GetMenuList 获取菜单列表
+func (s MenuService) FindMenuList(query request.MenuQuery, info *response.UserResponse) *[]models2.SysMenu {
+	if info.IsAdmin() {
+		return s.menuDao.SelectMenuList(query)
+	} else {
+		query.UserId = info.UserId
+		return s.menuDao.SelectMenuListByUserId(query)
+	}
+}
+
+// GetMenuByMenuId 根据菜单ID查询信息
+func (s MenuService) GetMenuByMenuId(id int) *models2.SysMenu {
+	return s.menuDao.SelectMenuByMenuId(id)
+}
+
+// Save 添加菜单数据
+func (s MenuService) Save(menu models2.SysMenu) int64 {
+	return s.menuDao.Insert(menu)
+}
+
+// Edit 修改菜单数据
+func (s MenuService) Edit(menu models2.SysMenu) int64 {
+	return s.menuDao.Update(menu)
+}
+
+// Remove 删除菜单操作
+func (s MenuService) Remove(id int) int64 {
+	return s.menuDao.Delete(id)
+}

core/service/notice_service.go

@@ -0,0 +1,36 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/dao"
+	"cutego/core/entity"
+)
+
+type NoticeService struct {
+	noticeDao dao.NoticeDao
+}
+
+// FindPage 查询集合数据
+func (s NoticeService) FindPage(query request.NoticeQuery) (*[]entity.SysNotice, int64) {
+	return s.noticeDao.SelectPage(query)
+}
+
+// Save 添加公告
+func (s NoticeService) Save(notice entity.SysNotice) bool {
+	return s.noticeDao.Insert(notice) > 0
+}
+
+// Remove 批量删除
+func (s NoticeService) Remove(list []int64) bool {
+	return s.noticeDao.Delete(list) > 0
+}
+
+// GetById 查询
+func (s NoticeService) GetById(id int64) *entity.SysNotice {
+	return s.noticeDao.SelectById(id)
+}
+
+// Edit 修改
+func (s NoticeService) Edit(notice entity.SysNotice) bool {
+	return s.noticeDao.Update(notice) > 0
+}

core/service/permission_service.go

@@ -0,0 +1,43 @@
+package service
+
+import (
+	"cutego/core/api/v1/response"
+	dao2 "cutego/core/dao"
+	"cutego/core/entity"
+	"github.com/druidcaesa/gotool"
+)
+
+type PermissionService struct {
+	roleDao dao2.RoleDao
+	menuDao dao2.MenuDao
+}
+
+// GetRolePermissionByUserId 查询用户角色集合
+func (s PermissionService) GetRolePermissionByUserId(user *response.UserResponse) *[]string {
+	admin := entity.SysUser{}.IsAdmin(user.UserId)
+	roleKeys := s.roleDao.SelectRolePermissionByUserId(user.UserId)
+	if admin && roleKeys != nil {
+		*roleKeys = append(*roleKeys, "admin")
+	}
+	duplication := gotool.StrArrayUtils.ArrayDuplication(*roleKeys)
+	return &duplication
+}
+
+// GetMenuPermission 获取菜单数据权限
+func (s PermissionService) GetMenuPermission(user *response.UserResponse) *[]string {
+	flag := entity.SysUser{}.IsAdmin(user.UserId)
+	// 查询菜单数据权限
+	permission := s.menuDao.GetMenuPermission(user.UserId)
+	if flag && permission != nil {
+		*permission = append(*permission, "*:*:*")
+	}
+	var ret []string
+	duplication := gotool.StrArrayUtils.ArrayDuplication(*permission)
+	for i := 0; i < len(duplication); i++ {
+		if (i > 0 && duplication[i-1] == duplication[i]) || len(duplication[i]) == 0 {
+			continue
+		}
+		ret = append(ret, duplication[i])
+	}
+	return &ret
+}

core/service/post_service.go

@@ -0,0 +1,77 @@
+package service
+
+import (
+	"bytes"
+	"cutego/core/api/v1/request"
+	"cutego/core/dao"
+	"cutego/core/entity"
+	"github.com/druidcaesa/gotool"
+)
+
+type PostService struct {
+	postDao dao.PostDao
+}
+
+// FindAll 查询所有岗位业务方法
+func (s PostService) FindAll() []*entity.SysPost {
+	return s.postDao.SelectAll()
+}
+
+// FindPostListByUserId 根据用户id查询岗位id集合
+func (s PostService) FindPostListByUserId(userId int64) *[]int64 {
+	return s.postDao.SelectPostListByUserId(userId)
+}
+
+// FindList 查询岗位分页列表
+func (s PostService) FindPage(query request.PostQuery) (*[]entity.SysPost, int64) {
+	return s.postDao.SelectPage(query)
+}
+
+// CheckPostNameUnique 校验岗位名称是否存在
+func (s PostService) CheckPostNameUnique(post entity.SysPost) bool {
+	return s.postDao.CheckPostNameUnique(post) > 0
+}
+
+// CheckPostCodeUnique 校验岗位编码是否存在
+func (s PostService) CheckPostCodeUnique(post entity.SysPost) bool {
+	return s.postDao.CheckPostCodeUnique(post) > 0
+}
+
+// Save 添加岗位数据
+func (s PostService) Save(post entity.SysPost) bool {
+	return s.postDao.Insert(post) > 0
+}
+
+// GetPostById 根据id查询岗位数据
+func (s PostService) GetPostById(id int64) *entity.SysPost {
+	post := entity.SysPost{
+		PostId: id,
+	}
+	return s.postDao.GetPostById(post)
+}
+
+// Remove 批量删除岗位信息
+func (s PostService) Remove(ids []int64) bool {
+	return s.postDao.Delete(ids) > 0
+}
+
+// Edit 修改岗位数据
+func (s PostService) Edit(post entity.SysPost) bool {
+	return s.postDao.Update(post)
+}
+
+// FindPostByUserName 获取岗位数据
+func (s PostService) FindPostByUserName(name string) string {
+	list := s.postDao.SelectPostByUserName(name)
+	var buffer bytes.Buffer
+	var postName string
+	for _, post := range *list {
+		buffer.WriteString(post.PostName)
+		buffer.WriteString(",")
+	}
+	s2 := buffer.String()
+	if gotool.StrUtils.HasNotEmpty(s2) {
+		postName = s2[0:(len(s2) - 1)]
+	}
+	return postName
+}

core/service/role_service.go

@@ -0,0 +1,133 @@
+package service
+
+import (
+	"bytes"
+	req2 "cutego/core/api/v1/request"
+	dao2 "cutego/core/dao"
+	models2 "cutego/core/entity"
+	"github.com/druidcaesa/gotool"
+)
+
+type RoleService struct {
+	roleDao     dao2.RoleDao
+	roleMenuDao dao2.RoleMenuDao
+	userRoleDao dao2.UserRoleDao
+}
+
+// FindAll 查询所有角色
+func (s RoleService) FindAll(query *req2.RoleQuery) ([]*models2.SysRole, int64) {
+	if query == nil {
+		all := s.roleDao.SelectAll()
+		return all, 0
+	}
+	return s.roleDao.SelectPage(query)
+}
+
+// FindRoleListByUserId 根据用户id查询角色id集合
+func (s RoleService) FindRoleListByUserId(parseInt int64) *[]int64 {
+	return s.roleDao.SelectRoleListByUserId(parseInt)
+}
+
+// GetRoleListByUserId 根据用户ID查询角色
+func (s RoleService) GetRoleListByUserId(id int64) *[]models2.SysRole {
+	return s.roleDao.GetRoleListByUserId(id)
+}
+
+// FindPage 分页查询角色数据
+func (s RoleService) FindPage(query req2.RoleQuery) ([]*models2.SysRole, int64) {
+	return s.roleDao.SelectPage(&query)
+}
+
+// GetRoleByRoleId 根据角色id查询角色数据
+func (s RoleService) GetRoleByRoleId(id int64) *models2.SysRole {
+	return s.roleDao.SelectRoleByRoleId(id)
+}
+
+// CheckRoleNameUnique 判断角色名城是否存在
+func (s RoleService) CheckRoleNameUnique(role models2.SysRole) int64 {
+	return s.roleDao.CheckRoleNameUnique(role)
+}
+
+// CheckRoleKeyUnique 校验角色权限是否唯一
+func (s RoleService) CheckRoleKeyUnique(role models2.SysRole) int64 {
+	return s.roleDao.CheckRoleKeyUnique(role)
+
+}
+
+// Save 添加角色数据
+func (s RoleService) Save(role models2.SysRole) int64 {
+	role = s.roleDao.Insert(role)
+	return s.BindRoleMenu(role)
+}
+
+// 添加角色菜单关系
+func (s RoleService) BindRoleMenu(role models2.SysRole) int64 {
+	list := make([]models2.SysRoleMenu, 0)
+	for _, id := range role.MenuIds {
+		menu := models2.SysRoleMenu{
+			RoleId: role.RoleId,
+			MenuId: id,
+		}
+		list = append(list, menu)
+	}
+	return s.roleMenuDao.Insert(list)
+}
+
+// Edit 修改角色数据
+func (s RoleService) Edit(role models2.SysRole) int64 {
+	// 删除菜单关联关系
+	s.roleMenuDao.Delete(role)
+	s.BindRoleMenu(role)
+	// 修改数据
+	return s.roleDao.Update(role)
+}
+
+// Remove 删除角色
+func (s RoleService) Remove(id int64) int64 {
+	role := models2.SysRole{
+		RoleId: id,
+	}
+	// 删除菜单角色关系
+	s.roleMenuDao.Delete(role)
+	// 删除角色
+	return s.roleDao.Delete(role)
+}
+
+// CheckRoleAllowed 校验是否可以操作
+func (s RoleService) CheckRoleAllowed(id int64) (bool, string) {
+	if id == 1 {
+		return false, "超级管理员不允许操作"
+	}
+	return true, ""
+}
+
+// EditRoleStatus 角色状态修改
+func (s RoleService) EditRoleStatus(role *models2.SysRole) int64 {
+	return s.roleDao.UpdateRoleStatus(role)
+}
+
+// DeleteAuthUser 取消授权用户
+func (s RoleService) DeleteAuthUser(userRole models2.SysUserRole) int64 {
+	return s.userRoleDao.DeleteAuthUser(userRole)
+}
+
+// InsertAuthUsers 批量选择用户授权
+func (s RoleService) InsertAuthUsers(body req2.UserRoleBody) int64 {
+	return s.userRoleDao.InsertAuthUsers(body)
+}
+
+// GetRolesByUserName 查询所属角色组
+func (s RoleService) GetRolesByUserName(name string) string {
+	list := s.roleDao.SelectRolesByUserName(name)
+	var buffer bytes.Buffer
+	var roleName string
+	for _, role := range *list {
+		buffer.WriteString(role.RoleName)
+		buffer.WriteString(",")
+	}
+	s2 := buffer.String()
+	if gotool.StrUtils.HasNotEmpty(s2) {
+		roleName = s2[0:(len(s2) - 1)]
+	}
+	return roleName
+}

core/service/user_post_service.go

@@ -0,0 +1,19 @@
+package service
+
+import (
+	"cutego/core/dao"
+)
+
+type UserPostService struct {
+	userPostDao dao.UserPostDao
+}
+
+// CountUserPostById 统计岗位数据数量
+func (s UserPostService) CountUserPostById(ids []int64) int64 {
+	for _, id := range ids {
+		if s.userPostDao.CountById(id) > 0 {
+			return id
+		}
+	}
+	return 0
+}

core/service/user_service.go

@@ -0,0 +1,151 @@
+package service
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/api/v1/response"
+	dao2 "cutego/core/dao"
+	models2 "cutego/core/entity"
+)
+
+// UserService 用户操作业务逻辑
+type UserService struct {
+	userDao     dao2.UserDao
+	userPostDao dao2.UserPostDao
+	userRoleDao dao2.UserRoleDao
+}
+
+// FindList 查询用户集合业务方法
+func (s UserService) FindList(query request.UserQuery) ([]*response.UserResponse, int64) {
+	return s.userDao.SelectPage(query)
+}
+
+// GetUserById 根据id查询用户数据
+func (s UserService) GetUserById(parseInt int64) *response.UserResponse {
+	return s.userDao.GetUserById(parseInt)
+}
+
+// GetUserByUserName 根据用户名查询用户
+func (s UserService) GetUserByUserName(name string) *models2.SysUser {
+	user := models2.SysUser{}
+	user.UserName = name
+	return s.userDao.GetUserByUserName(user)
+}
+
+// CheckEmailUnique 校验邮箱是否存在
+func (s UserService) CheckEmailUnique(user request.UserBody) *models2.SysUser {
+	return s.userDao.CheckEmailUnique(user)
+}
+
+// CheckPhoneNumUnique 校验手机号是否存在
+func (s UserService) CheckPhoneNumUnique(body request.UserBody) *models2.SysUser {
+	return s.userDao.CheckPhoneNumUnique(body)
+}
+
+// Insert 添加用户业务逻辑
+func (s UserService) Save(body request.UserBody) bool {
+	// 添加用户数据库操作
+	user := s.userDao.Insert(body)
+	if user != nil {
+		s.BindUserPost(user)
+		s.BindUserRole(user)
+		return true
+	}
+	return false
+}
+
+// 新增用户岗位信息
+func (s UserService) BindUserPost(user *request.UserBody) {
+	postIds := user.PostIds
+	if len(postIds) > 0 {
+		sysUserPosts := make([]models2.SysUserPost, 0)
+		for i := 0; i < len(postIds); i++ {
+			m := models2.SysUserPost{
+				UserId: user.UserId,
+				PostId: postIds[i],
+			}
+			sysUserPosts = append(sysUserPosts, m)
+		}
+		s.userPostDao.BatchInsert(sysUserPosts)
+	}
+}
+
+// 新增用户角色信息
+func (s UserService) BindUserRole(user *request.UserBody) {
+	roleIds := user.RoleIds
+	if len(roleIds) > 0 {
+		roles := make([]models2.SysUserRole, 0)
+		for i := 0; i < len(roleIds); i++ {
+			role := models2.SysUserRole{
+				RoleId: roleIds[i],
+				UserId: user.UserId,
+			}
+			roles = append(roles, role)
+		}
+		s.userRoleDao.BatchInsert(roles)
+	}
+}
+
+// Edit 修改用户数据
+func (s UserService) Edit(body request.UserBody) int64 {
+	// 删除原有用户和角色关系
+	s.userRoleDao.Delete(body.UserId)
+	// 重新添加用具角色关系
+	s.BindUserRole(&body)
+	// 删除原有用户岗位关系
+	s.userPostDao.Delete(body.UserId)
+	// 添加新的用户岗位关系
+	s.BindUserPost(&body)
+	// 修改用户数据
+	return s.userDao.Update(body)
+}
+
+// Remove 根据用户id删除用户相关数据
+func (s UserService) Remove(id int64) int64 {
+	// 删除原有用户和角色关系
+	s.userRoleDao.Delete(id)
+	// 删除原有用户岗位关系
+	s.userPostDao.Delete(id)
+	// 删除用户数据
+	return s.userDao.Delete(id)
+}
+
+// CheckUserAllowed 校验是否可以修改用户密码
+func (s UserService) CheckUserAllowed(body request.UserBody) bool {
+	user := models2.SysUser{}
+	return user.IsAdmin(body.UserId)
+}
+
+// ResetPwd 修改用户密码
+func (s UserService) ResetPwd(body request.UserBody) int64 {
+	return s.userDao.ResetPwd(body)
+}
+
+// GetAllocatedList 查询未分配用户角色列表
+func (s UserService) GetAllocatedList(query request.UserQuery) ([]*response.UserResponse, int64) {
+	return s.userDao.GetAllocatedList(query)
+}
+
+// GetUnallocatedList 查询未分配用户角色列表
+func (s UserService) GetUnallocatedList(query request.UserQuery) ([]*response.UserResponse, int64) {
+	return s.userDao.GetUnallocatedList(query)
+}
+
+// EditProfile 修改数据
+func (s UserService) EditProfile(user request.UserBody) int64 {
+	return s.userDao.Update(user)
+}
+
+// EditPwd 修改密码
+func (s UserService) EditPwd(id int64, hash string) bool {
+	return s.userDao.UpdatePwd(id, hash) > 0
+}
+
+// EditAvatar 修改头像
+func (s UserService) EditAvatar(info *response.UserResponse) bool {
+	return s.userDao.UpdateAvatar(info) > 0
+}
+
+// EditStatus 修改可用状态
+func (s UserService) EditStatus(info request.UserBody) bool {
+	return s.userDao.UpdateStatus(info) > 0
+}

pkg/base/model.go

@@ -0,0 +1,19 @@
+package base
+
+import "time"
+
+// GlobalModel 全局映射实体
+type GlobalModel struct {
+	CreateTime time.Time `json:"createTime"` // 创建时间
+	CreateBy   string    `json:"createBy"`   // 创建人
+	UpdateTime time.Time `json:"updateTime"` // 更新时间
+	UpdateBy   string    `json:"updateBy"`   // 更新人
+}
+
+// GlobalQuery 全局Query通用条件
+type GlobalQuery struct {
+	BeginTime string `form:"beginTime"` // 开始时间
+	EndTime   string `form:"endTime"`   // 结束时间
+	PageNum   int    `form:"pageNum"`   // 当前页码
+	PageSize  int    `form:"pageSize"`  // 显示条数
+}

pkg/cache/index.go

@@ -0,0 +1,58 @@
+package cache
+
+import (
+	"cutego/core/dao"
+	"cutego/pkg/common"
+	"cutego/pkg/constant"
+)
+
+// RemoveList 批量根据Key删除数据
+// @Param list []string 键合集
+func RemoveList(list []string) {
+	dao.RedisDB.DELALL(list)
+}
+
+// RemoveKey 根据key删除
+// @Param key 键
+// @Return int 删除的数量
+func RemoveCache(key string) int {
+	del, err := dao.RedisDB.DEL(key)
+	if err != nil {
+		common.ErrorLog(err)
+	}
+	return del
+}
+
+// GetCache 获取缓存数据
+// @Param key 键
+// @Return string 值
+func GetCache(key string) string {
+	val, err := dao.RedisDB.GET(key)
+	if err != nil {
+		common.ErrorLog(constant.RedisConst{}.GetRedisError(), err.Error())
+		return ""
+	}
+	return val
+}
+
+// SetCache 设置缓存数据
+// @Param key 键
+// @Param value 值
+// @Return 新增的行数
+func SetCache(key string, value interface{}) int {
+	n, err := dao.RedisDB.SET(key, common.StructToJson(value))
+	if err != nil {
+		common.ErrorLog(constant.RedisConst{}.GetRedisError(), err.Error())
+		return 0
+	}
+	return int(n)
+}
+
+// SetCache 设置缓存数据, 并指定过期时间
+// @Param key 键
+// @Param value 值
+// @Param sec 过期时间(单位: 秒)
+// @Return 新增的行数
+func SetCacheTTL(key string, value interface{}, sec int) {
+	dao.RedisDB.SETEX(key, sec, common.StructToJson(value))
+}

pkg/common/interface.go

@@ -0,0 +1,51 @@
+package common
+
+// RedisData 存储数据结构
+type RedisData struct {
+	Key    string
+	Field  string
+	Value  string
+	Expire int64
+}
+
+// RedisDataArray RedisData of array
+type RedisDataArray []*RedisData
+
+// IRedis redis client interface
+type IRedis interface {
+	// KEYS get patten key array
+	KEYS(patten string) ([]string, error)
+
+	// SCAN get patten key array
+	SCAN(patten string) ([]string, error)
+
+	// DEL delete k-v
+	DEL(key string) (int, error)
+
+	// DELALL delete key array
+	DELALL(key []string) (int, error)
+
+	// GET get k-v
+	GET(key string) (string, error)
+
+	// SET set k-v
+	//SET(key string, value string) (int64, error)
+
+	// SETEX set k-v expire seconds
+	SETEX(key string, sec int, value string) (int64, error)
+
+	// EXPIRE set key expire seconds
+	EXPIRE(key string, sec int64) (int64, error)
+
+	// HGETALL get map of key
+	HGETALL(key string) (map[string]string, error)
+
+	// HGET get value of key-field
+	HGET(key string, field string) (string, error)
+
+	// HSET set value of key-field
+	//HSET(key string, field string, value string) (int64, error)
+
+	// Write 向redis中写入多组数据
+	Write(data RedisDataArray)
+}

pkg/common/log.go

@@ -0,0 +1,23 @@
+package common
+
+import "github.com/druidcaesa/gotool"
+
+func ErrorLog(v ...interface{}) {
+	gotool.Logs.ErrorLog().Println(v)
+}
+
+func FatalfLog(format string, v ...interface{}) {
+	gotool.Logs.ErrorLog().Fatalf(format, v)
+}
+
+func InfoLog(v ...interface{}) {
+	gotool.Logs.InfoLog().Println(v)
+}
+
+func InfoLogf(format string, v ...interface{}) {
+	gotool.Logs.InfoLog().Printf(format+"\n", v)
+}
+
+func DebugLogf(format string, v ...interface{}) {
+	gotool.Logs.DebugLog().Printf(format+"\n", v)
+}

pkg/common/util.go

@@ -0,0 +1,142 @@
+package common
+
+import (
+	"cutego/pkg/config"
+	"encoding/json"
+	"fmt"
+	"os"
+	"runtime"
+	"strconv"
+)
+
+// IntToString int转string
+func IntToString(n int) string {
+	return strconv.Itoa(n)
+}
+func mapToBytes(data map[string]interface{}) []byte {
+	bytes, _ := json.Marshal(data)
+	return bytes
+}
+
+// MapToStruct map转struct
+func MapToStruct(data map[string]interface{}, v interface{}) {
+	_ = json.Unmarshal(mapToBytes(data), v)
+}
+
+// GetDirPath 获取目录路径
+func GetDirPath(resType string) string {
+	sysType := runtime.GOOS
+	switch sysType {
+	case "linux":
+		if resType == "log" {
+			return config.AppCoreConfig.CuteGoConfig.File.Linux.Logs
+		} else if resType == "avatar" {
+			return config.AppCoreConfig.CuteGoConfig.File.Linux.Avatar
+		} else if resType == "file" {
+			return config.AppCoreConfig.CuteGoConfig.File.Linux.Path
+		}
+		break
+	case "windows":
+		if resType == "log" {
+			return config.AppCoreConfig.CuteGoConfig.File.Windows.Logs
+		} else if resType == "avatar" {
+			return config.AppCoreConfig.CuteGoConfig.File.Windows.Avatar
+		} else if resType == "file" {
+			return config.AppCoreConfig.CuteGoConfig.File.Windows.Path
+		}
+		break
+	case "mac":
+		if resType == "log" {
+			return config.AppCoreConfig.CuteGoConfig.File.Mac.Logs
+		} else if resType == "avatar" {
+			return config.AppCoreConfig.CuteGoConfig.File.Mac.Avatar
+		} else if resType == "file" {
+			return config.AppCoreConfig.CuteGoConfig.File.Mac.Path
+		}
+		break
+	case "darwin":
+		if resType == "log" {
+			return config.AppCoreConfig.CuteGoConfig.File.Mac.Logs
+		} else if resType == "avatar" {
+			return config.AppCoreConfig.CuteGoConfig.File.Mac.Avatar
+		} else if resType == "file" {
+			return config.AppCoreConfig.CuteGoConfig.File.Mac.Path
+		}
+	}
+	return config.AppCoreConfig.CuteGoConfig.File.Linux.Logs
+}
+
+// CreateAllDir 递归创建文件夹
+func CreateAllDir(filePath string) error {
+	if !IsFileOrDirExist(filePath) {
+		err := os.MkdirAll(filePath, os.ModePerm)
+		if err != nil {
+			fmt.Println("创建文件夹失败, error info:", err)
+			return err
+		}
+		return err
+	}
+	return nil
+}
+
+// IsFileOrDirExist 判断所给路径文件/文件夹是否存在(返回true是存在)
+func IsFileOrDirExist(path string) bool {
+	// os.Stat获取文件信息
+	_, err := os.Stat(path)
+	if err != nil {
+		if os.IsExist(err) {
+			return true
+		}
+		return false
+	}
+	return true
+}
+
+// 类三元表达式
+// condition 成立条件
+// trueVal 当条件为true时返回
+// false 当条件为false时返回
+func If(condition bool, trueVal, falseVal interface{}) interface{} {
+	if condition {
+		return trueVal
+	}
+	return falseVal
+}
+
+// 结构体、Map等转Json字符串
+// @Param v interface{}
+// @Return Json字符串
+func StructToJson(v interface{}) string {
+	jsonBytes, err := json.Marshal(&v)
+	if err != nil {
+		ErrorLog(err)
+		return ""
+	}
+	s := string(jsonBytes)
+	DebugLogf("StructToJson, json=%s", s)
+	return s
+}
+
+// Json字符串转结构体、Map等
+//
+// 单个对象
+// s := new(models2.SysConfig)
+// return common.JsonToStruct(get, s).(*models2.SysConfig)
+//
+// 切片(interface{}.(期望类型))
+// s := make([]interface {}, 0)
+// target := common.JsonToStruct(get, s)
+// target.([]entity.SysDictData)
+//
+// @Param data Json字符串
+// @Param s 容器(结构体、Map等)
+// @Return interface{}
+func JsonToStruct(data string, s interface{}) interface{} {
+	err := json.Unmarshal([]byte(data), &s)
+	if err != nil {
+		ErrorLog(err)
+		return nil
+	}
+	DebugLogf("JsonToStruct, obj=%v", s)
+	return s
+}

pkg/config/index.go

@@ -0,0 +1,96 @@
+package config
+
+import (
+	config "cutego/pkg/config/models"
+	"fmt"
+	"gopkg.in/yaml.v2"
+	"io/ioutil"
+	"os"
+)
+
+var (
+	// AppCoreConfig 核心配置
+	AppCoreConfig *config.ApplicationCoreStruct
+	// AppEnvConfig 环境配置
+	AppEnvConfig *config.ApplicationEnvStruct
+)
+
+// GetRootPath 获取项目根路径
+func GetRootPath() string {
+	rootPath, _ := os.Getwd()
+	return rootPath
+}
+
+// GetPathSeparator 获取路径分隔符
+func GetPathSeparator() string {
+	return string(os.PathSeparator)
+}
+
+// PathExists 判断文件或文件夹是否存在
+// 如果返回的错误为nil,说明文件或文件夹存在
+// 如果返回的错误类型使用os.IsNotExist()判断为true,说明文件或文件夹不存在
+// 如果返回的错误为其它类型,则不确定是否在存在
+func PathExists(path string) (bool, error) {
+	_, err := os.Stat(path)
+	if err == nil {
+		return true, nil
+	}
+	if os.IsNotExist(err) {
+		return false, nil
+	}
+	return false, err
+}
+
+// LoadYamlFile 加载yaml文件
+func LoadYamlFile(filename string, v interface{}) {
+	data, err := ioutil.ReadFile(filename)
+	if err != nil {
+		panic(err.Error())
+	}
+	err = yaml.Unmarshal(data, v)
+	if err != nil {
+		panic(err.Error())
+	}
+}
+
+// 配置文件所在路径
+const BaseConfigDirPath = "configs"
+
+func readAppYmlFile(resourcePath string) {
+
+	// 读取主配置文件
+	applicationCoreFileName := BaseConfigDirPath + "/application.yml"
+	applicationCoreFilePath := resourcePath + GetPathSeparator() + applicationCoreFileName
+	exists, _ := PathExists(applicationCoreFilePath)
+	if !exists {
+		panic(applicationCoreFileName + "配置文件不存在!")
+	}
+	AppCoreConfig = &config.ApplicationCoreStruct{}
+	// 由于要改变appConfig内部的值, 所以这里要取址
+	LoadYamlFile(applicationCoreFilePath, AppCoreConfig)
+
+	// 读取环境文件
+	applicationEnvFileName := fmt.Sprintf(BaseConfigDirPath+"/application-%s.yml", AppCoreConfig.CuteGoConfig.Active)
+	applicationEnvFilePath := resourcePath + GetPathSeparator() + applicationEnvFileName
+	exists, _ = PathExists(applicationEnvFilePath)
+	if !exists {
+		panic(applicationEnvFileName + "配置文件不存在!")
+	}
+	AppEnvConfig = &config.ApplicationEnvStruct{}
+	// 由于要改变appConfig内部的值, 所以这里要取址
+	LoadYamlFile(applicationEnvFilePath, AppEnvConfig)
+}
+
+// ExecuteTip 执行日志
+func ExecuteTip(message string) {
+	fmt.Println(fmt.Sprintf("--------------------  %s  --------------------", message))
+}
+
+func init() {
+	// 资源文件所在的路径
+	resourcePath := GetRootPath()
+	ExecuteTip("初始化应用配置 start")
+	readAppYmlFile(resourcePath)
+	ExecuteTip("初始化应用配置 end")
+	return
+}

pkg/config/models/application_core.go

@@ -0,0 +1,67 @@
+package config
+
+type ApplicationCoreStruct struct {
+	CuteGoConfig CuteGoConfig `yaml:"cutego"`
+}
+
+// CuteGoConfig 总配置
+type CuteGoConfig struct {
+	// 默认激活dev配置
+	Active string `yaml:"active" default:"dev"`
+	// 开启演示模式
+	DemoMode bool           `yaml:"demo-mode"`
+	Mail     MailConfig     `yaml:"mail"`
+	TaskPool TaskPoolConfig `yaml:"task-pool"`
+	Captcha  CaptchaConfig  `yaml:"captcha"`
+	File     FileConfig     `yaml:"file"`
+}
+
+// MailConfig 邮件
+type MailConfig struct {
+	// 服务地址
+	Host string `yaml:"host"`
+	// 服务端口
+	Port int `yaml:"port"`
+	// 用户名
+	Username string `yaml:"username"`
+	// 密码
+	Password string `yaml:"password"`
+	// 默认编码
+	DefaultEncoding string `yaml:"default-encoding"`
+}
+
+// TaskPoolConfig 线程池
+type TaskPoolConfig struct {
+	// 核心线程池大小
+	CorePoolSize int `yaml:"core-pool-size"`
+	// 最大线程数(尽可能的大)
+	MaxPoolSize int `yaml:"max-pool-size"`
+	// 活跃时间(单位: s)
+	KeepAliveSeconds int `yaml:"keep-alive-seconds"`
+	// 队列容量
+	QueueCapacity int `yaml:"queue-capacity"`
+}
+
+// CaptchaConfig 验证码有效时间(单位: s)
+type CaptchaConfig struct {
+	// 邮箱
+	Email int `yaml:"email"`
+	// 手机短信
+	Sms int `yaml:"sms"`
+}
+
+// FileConfig 文件上传
+type FileConfig struct {
+	// 文件大小(单位: mb)
+	FileMaxSize int `yaml:"file-max-size"`
+	// 头像大小(单位: mb)
+	AvatarMaxSize int      `yaml:"avatar-max-size"`
+	Mac           FilePath `yaml:"mac"`
+	Linux         FilePath `yaml:"linux"`
+	Windows       FilePath `yaml:"windows"`
+}
+type FilePath struct {
+	Path   string `yaml:"path"`
+	Avatar string `yaml:"avatar"`
+	Logs   string `yaml:"logs"`
+}

pkg/config/models/application_env.go

@@ -0,0 +1,111 @@
+package config
+
+type ApplicationEnvStruct struct {
+	Server     ServerConfig     `yaml:"server"`
+	DataSource DataSourceConfig `yaml:"datasource"`
+	Redis      RedisConfig      `yaml:"redis"`
+	MongoDb    MongoDbConfig    `yaml:"mongodb"`
+	Login      LoginConfig      `yaml:"login"`
+	Jwt        JwtConfig        `yaml:"jwt"`
+	Logger     LoggerConfig     `yaml:"logger"`
+}
+
+// ServerConfig web服务
+type ServerConfig struct {
+	// Running in "debug" mode. Switch to "release" mode in production
+	RunMode string `yaml:"run-mode"`
+	// web服务监听端口(生产的端口有可能不一样,所以根据环境隔离开)
+	Port int `yaml:"port"`
+}
+
+// DataSourceConfig 数据源
+type DataSourceConfig struct {
+	// 数据库类型
+	DbType string `yaml:"db-type" default:"mysql"`
+	// 服务地址
+	Host string `yaml:"host"`
+	// 服务端口
+	Port int `yaml:"port"`
+	// 用户名称
+	Username string `yaml:"username"`
+	// 用户密码
+	Password string `yaml:"password"`
+	// 数据库名称
+	Database string `yaml:"database"`
+	// 编码
+	Charset string `yaml:"charset"`
+	// 空闲时的最大连接数
+	MaxIdleSize int `yaml:"max-idle-size"`
+	// 数据库的最大打开连接数
+	MaxOpenSize int `yaml:"max-open-size"`
+}
+
+// RedisConfig 缓存
+type RedisConfig struct {
+	// 数据库索引
+	Database int `yaml:"database"`
+	// 服务地址
+	Host string `yaml:"host"`
+	// 服务端口
+	Port int `yaml:"port"`
+	// 服务密码
+	Password string `yaml:"password"`
+	// 连接超时时间
+	Timeout int             `yaml:"timeout"`
+	Pool    RedisPoolConfig `yaml:"pool"`
+}
+
+// RedisPoolConfig redis连接池配置
+type RedisPoolConfig struct {
+	// 连接池最大连接数（使用负值表示没有限制, 最佳配置为cpu核数+1）
+	MaxActive int `yaml:"max-active"`
+	// 连接池中的最大空闲连接
+	MaxIdle int `yaml:"max-idle"`
+	// 连接池最大阻塞等待时间（使用负值表示没有限制）
+	MaxWait int `yaml:"max-wait"`
+}
+
+// MongoDbConfig MongoDB
+type MongoDbConfig struct {
+	Url      string `yaml:"url"`
+	Port     string `yaml:"port"`
+	DB       string `yaml:"db"`
+	Username string `yaml:"username"`
+	Password string `yaml:"password"`
+}
+
+// LoginConfig 登录相关
+type LoginConfig struct {
+	// 是否限制单用户登录
+	Single bool `yaml:"single"`
+}
+
+// JwtConfig jwt参数
+type JwtConfig struct {
+	// 请求头前缀
+	Header string `yaml:"header" json:"header,omitempty"`
+	// 令牌前缀
+	TokenStartWith string `yaml:"token-start-with" json:"token_start_with,omitempty"`
+	// 加密密钥
+	TokenSecret string `yaml:"token-secret" json:"token_secret,omitempty"`
+	// 令牌过期时间 此处单位: h , 默认1小时
+	TokenExpired int `yaml:"token-expired" json:"token_expired,omitempty"`
+	// token在cookie中的别称
+	CookieKey string `yaml:"cookie-key"`
+	// 在线用户key
+	OnlineKey string `yaml:"online-key" json:"online_key,omitempty"`
+	// token 续期检查时间范围（默认30分钟, 单位毫秒）, 在token即将过期的一段时间内用户操作了, 则给用户的token续期
+	Detect int `yaml:"detect" json:"detect,omitempty"`
+	// 续期时间范围, 默认1小时, 单位毫秒
+	Renew int `yaml:"renew" json:"renew,omitempty"`
+}
+
+// LoggerConfig 日志文件
+type LoggerConfig struct {
+	// 最大保存时间(单位: d)
+	MaxSaveAge int `yaml:"max-save-age"`
+	// 日志切割时间间隔(单位: d)
+	RotationTime int `yaml:"rotation-time"`
+	// 日志级别
+	Level string `yaml:"level"`
+}

pkg/constant/index.go

@@ -0,0 +1,5 @@
+package constant
+
+const (
+	RedisOnlineUserKey = "online:"
+)

pkg/constant/mysql_const.go

@@ -0,0 +1,12 @@
+package constant
+
+const (
+	mysqlErrorMsg = "调用MySQL发生异常, %s"
+)
+
+type MysqlConst struct{}
+
+// GetMysqlError Mysql异常拼接常量
+func (c MysqlConst) GetMysqlError() string {
+	return mysqlErrorMsg
+}

pkg/constant/redis_const.go

@@ -0,0 +1,25 @@
+package constant
+
+const (
+	redisErrorMsg  = "调用Redis发生异常, %s"
+	redisDictKey   = "dict:"
+	redisConfigKey = "config:"
+)
+
+// RedisConst Redis相关操作常量
+type RedisConst struct{}
+
+// GetRedisError Redis异常拼接常量
+func (c RedisConst) GetRedisError() string {
+	return redisErrorMsg
+}
+
+// GetRedisDictKey 获取Redis的Dict的key
+func (c RedisConst) GetRedisDictKey() string {
+	return redisDictKey
+}
+
+// GetRedisConfigKey 获取redis的config的key
+func (c RedisConst) GetRedisConfigKey() string {
+	return redisConfigKey
+}

pkg/cronjob/index.go

@@ -0,0 +1,70 @@
+package cronjob
+
+import (
+	"cutego/core/api/v1/request"
+	"cutego/core/job"
+	"cutego/core/service"
+	"cutego/pkg/common"
+	"github.com/robfig/cron"
+	"time"
+)
+
+// Cron表达式参考
+// 每隔5秒执行一次：*/5 * * * * ?
+// 每隔1分钟执行一次：0 */1 * * * ?
+// 每天23点执行一次：0 0 23 * * ?
+// 每天凌晨1点执行一次：0 0 1 * * ?
+// 每月1号凌晨1点执行一次：0 0 1 1 * ?
+// 每月最后一天23点执行一次：0 0 23 L * ?
+// 每周星期天凌晨1点实行一次：0 0 1 ? * L
+// 在26分、29分、33分执行一次：0 26,29,33 * * * ?
+// 每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?
+
+// 定时任务: 别名与调度器的映射
+var AliasCronMap = make(map[string]*cron.Cron)
+
+// 停止任务, 不会停止已开始的任务
+func StopCronFunc(aliasName string) {
+	common.InfoLogf("停止任务 %s ---> Start", aliasName)
+	AliasCronMap[aliasName].Stop()
+	common.InfoLogf("停止任务 %s ---> Finish", aliasName)
+}
+
+// 开始任务
+func StartCronFunc(aliasName string) {
+	common.InfoLogf("唤起任务 %s ---> Start", aliasName)
+	AliasCronMap[aliasName].Start()
+	common.InfoLogf("唤起任务 %s ---> Finish", aliasName)
+}
+
+func init() {
+	if len(job.AliasFuncMap) > 0 {
+		//go test()
+		index := 1
+		for true {
+			q := request.CronJobQuery{}
+			q.PageNum = index
+			data, _ := service.CronJobService{}.FindPage(q)
+			if len(data) == 0 {
+				break
+			}
+			for _, datum := range data {
+				c := cron.New()
+				c.AddFunc(datum.JobCron, job.AliasFuncMap[datum.FuncAlias])
+				c.Start()
+
+				AliasCronMap[datum.FuncAlias] = c
+				common.InfoLogf("调度定时任务 --- %s ---> Success", datum.JobName)
+			}
+			index += 1
+		}
+	}
+}
+
+// 测试通过
+func test() {
+	time.Sleep(time.Second * 10)
+	StopCronFunc("test1")
+	time.Sleep(time.Second * 10)
+	StartCronFunc("test1")
+}

pkg/excels/export.go

@@ -0,0 +1,143 @@
+package excels
+
+import (
+	"github.com/druidcaesa/gotool"
+	"github.com/xuri/excelize/v2"
+	"reflect"
+	"strconv"
+)
+
+// 获取title头list
+func getTitle(list []map[string]string) []string {
+	titleList := make([]string, 0)
+	for _, item := range list {
+		for _, s := range item {
+			titleList = append(titleList, s)
+		}
+	}
+	return titleList
+}
+
+// ExportExcel 导出excel
+func ExportExcel(list []interface{}, title string) (error, *excelize.File) {
+	// 获取标题
+	headerList, expList := ExcelCreate(list[0])
+	headers := getTitle(headerList)
+	// 默认存在第一个工作簿是 Sheet1 首字母要大写, 否则会报错。
+	// 如果想额外的创建工作簿, 可以使用, sheet2 := file.NewSheet("Sheet2"), 工作簿的名称不区分大小写。
+	// 如果有多个工作簿, 可以使用 file.SetActiveSheet(index) 来指定打开文件时focus到哪个工作簿
+	sheet1 := "Sheet1"
+	files := excelize.NewFile()
+	character := string(65 + len(headers) - 1)
+	/* -------------------- 第一行大标题 -------------------- */
+	// 设置行高
+	err := files.SetRowHeight(sheet1, 1, 25)
+	if err != nil {
+		return err, nil
+	}
+	// 合并单元格
+	err = files.MergeCell(sheet1, "A1", character+"1")
+	if err != nil {
+		return err, nil
+	}
+	// 设置单元格样式：对齐；字体, 大小；单元格边框
+	styleTitle, _ := files.NewStyle(`{"alignment":{"horizontal":"center","vertical":"center"},"font":{"bold":true,"italic":false,"family":"Calibri","size":16,"color":"#000000"},"border":[{"type":"left","color":"#3FAD08","style":0},{"type":"top","color":"#3FAD08","style":0},{"type":"bottom","color":"#3FAD08","style":2},{"type":"right","color":"#3FAD08","style":0}]}`)
+	err = files.SetCellStyle(sheet1, "A1", character+"1", styleTitle)
+	if err != nil {
+		return err, nil
+	}
+
+	err = files.SetCellValue(sheet1, "A1", title)
+	if err != nil {
+		return err, nil
+	}
+
+	/* -------------------- 字段标题 -------------------- */
+	styleHeader, _ := files.NewStyle(`{"alignment":{"horizontal":"center","vertical":"center"},"font":{"bold":false,"italic":false,"family":"Calibri","size":10,"color":"#000000"}}`)
+	err = files.SetCellStyle(sheet1, "A2", character+"2", styleHeader)
+	if err != nil {
+		return err, nil
+	}
+	for k, v := range headers {
+		err = files.SetCellValue(sheet1, string(65+k)+"2", v)
+		if err != nil {
+			return err, nil
+		}
+	}
+	// 设置最后一列宽度
+	err = files.SetColWidth(sheet1, "C", character, 20)
+	if err != nil {
+		return err, nil
+	}
+	// 冻结窗口：冻结第一行和第二行
+	err = files.SetPanes(sheet1, `{"freeze":true,"split":false,"x_split":0,"y_split":2}`)
+	if err != nil {
+		return err, nil
+	}
+	///* -------------------- 填充行数据 -------------------- */
+	line := 3
+	for _, v := range list {
+		var num = 0
+		lineChr := strconv.Itoa(line)
+		// 设置样式
+		err = files.SetCellStyle(sheet1, "A"+lineChr, character+lineChr, styleHeader)
+		if err != nil {
+			return err, nil
+		}
+		// 反射获取数据和类型
+		getValue := reflect.ValueOf(v)
+		getType := reflect.TypeOf(v)
+		n := getValue.NumField()
+		for i := 0; i < n; i++ {
+			val := getValue.Field(i)
+			name := getType.Field(i).Name
+			if !getIsTitle(name, headerList) {
+				continue
+			}
+			err = files.SetCellValue(sheet1, string(65+num)+lineChr, getExp(name, expList, val.Interface()))
+			if err != nil {
+				return err, nil
+			}
+			num++
+		}
+		line++
+	}
+	return nil, files
+}
+
+func getIsTitle(name string, headerList []map[string]string) bool {
+	flag := false
+	for _, m := range headerList {
+		if gotool.StrUtils.HasNotEmpty(m[name]) {
+			flag = true
+		}
+	}
+	return flag
+}
+
+func getExp(name string, expList []map[string][]map[string]string, value interface{}) interface{} {
+	for _, m := range expList {
+		if len(m[name]) > 0 {
+			maps := m[name]
+			for _, m2 := range maps {
+				if gotool.StrUtils.HasNotEmpty(m2[interfaceToString(value)]) {
+					value = m2[interfaceToString(value)]
+				}
+			}
+		}
+	}
+	return value
+}
+
+func interfaceToString(inter interface{}) string {
+	switch inter.(type) {
+	case string:
+		return inter.(string)
+	case int:
+		return strconv.Itoa(inter.(int))
+	case int64:
+		return strconv.FormatInt(inter.(int64), 10)
+	default:
+		return inter.(string)
+	}
+}

pkg/excels/tag.go

@@ -0,0 +1,84 @@
+package excels
+
+import (
+	"reflect"
+	"strings"
+)
+
+// 定义tagName名称
+const tagName = "excel"
+
+// Excels 定义Excel接口
+type Excels interface {
+	Excels(interface{}) (bool, string)
+}
+
+// DefaultExcels 默认Excel配置
+type DefaultExcels struct {
+}
+
+// Excels 实现接口
+func (e DefaultExcels) Excels(val interface{}) (bool, string) {
+	return true, ""
+}
+
+// `excel:"name='',readConverterExp=''"`
+// 获取标题头
+func getExcelFromTagTitle(proName string, tag string) map[string]string {
+	args := strings.SplitN(tag, ",", 2)
+	m := make(map[string]string)
+	for i := 0; i < len(args); i++ {
+		contains := strings.Contains(args[i], "name")
+		if contains {
+			m[proName] = strings.Split(args[i], "=")[1]
+			break
+		}
+	}
+	return m
+}
+
+// `excel:"name='',readConverterExp='Y=1,N=2'"`
+func getReadConverterExp(proName string, tag string) map[string][]map[string]string {
+	list := make(map[string][]map[string]string, 0)
+	args := strings.SplitN(tag, ",", 2)
+	for i := 0; i < len(args); i++ {
+		if strings.Contains(args[i], "format") {
+			maps := make([]map[string]string, 0)
+			converter := strings.SplitN(args[i], "=", 2)[1]
+			values := strings.Split(converter, ",")
+			for j := 0; j < len(values); j++ {
+				split := strings.Split(values[j], "=")
+				m := make(map[string]string)
+				m[split[0]] = split[1]
+				maps = append(maps, m)
+			}
+			list[proName] = maps
+			break
+		}
+	}
+	return list
+}
+
+// ExcelCreate 获取name名称和readConverterExp集合
+func ExcelCreate(s interface{}) ([]map[string]string, []map[string][]map[string]string) {
+	titleList := make([]map[string]string, 0)
+	expList := make([]map[string][]map[string]string, 0)
+	// 获取值域
+	v := reflect.ValueOf(s)
+	t := reflect.TypeOf(s)
+	var title map[string]string
+	var exp map[string][]map[string]string
+	// 遍历反射树形
+	for i := 0; i < t.NumField(); i++ {
+		tag := v.Type().Field(i).Tag.Get(tagName)
+		if tag == "" || tag == "-" {
+			continue
+		}
+		name := t.Field(i).Name
+		title = getExcelFromTagTitle(name, tag)
+		exp = getReadConverterExp(name, tag)
+		titleList = append(titleList, title)
+		expList = append(expList, exp)
+	}
+	return titleList, expList
+}