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

import cycle not allowed

This commit is contained in:
骑着蜗牛追导弹 2023-01-18 17:46:25 +08:00
parent 8d3a64b26e
commit 26f46f1eb6
35 changed files with 355 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
main.go
View File

@ -2,10 +2,10 @@ package main
// init函数执行顺序自上而下, 最后执行main包里面的init函数 // init函数执行顺序自上而下, 最后执行main包里面的init函数
import ( import (
"cutego/pkg/common"
"cutego/pkg/config" "cutego/pkg/config"
_ "cutego/pkg/cronjob" _ "cutego/pkg/cronjob"
_ "cutego/pkg/gin" _ "cutego/pkg/gin"
"cutego/pkg/logging"
"cutego/pkg/util" "cutego/pkg/util"
"cutego/refs" "cutego/refs"
"fmt" "fmt"
@ -17,7 +17,7 @@ func main() {
gin.SetMode(util.IF(config.AppEnvConfig.Server.RunMode == "", "debug", config.AppEnvConfig.Server.RunMode).(string)) gin.SetMode(util.IF(config.AppEnvConfig.Server.RunMode == "", "debug", config.AppEnvConfig.Server.RunMode).(string))
err := refs.CoolGin.Run(fmt.Sprintf(":%d", config.AppEnvConfig.Server.Port)) err := refs.CoolGin.Run(fmt.Sprintf(":%d", config.AppEnvConfig.Server.Port))
if err != nil { if err != nil {
common.FatalfLog("Start server: %+v", err) logging.FatalfLog("Start server: %+v", err)
} }
} }

9
modules/core/api/v1/user_api.go
View File

@ -7,6 +7,7 @@ import (
"cutego/modules/core/service" "cutego/modules/core/service"
"cutego/pkg/common" "cutego/pkg/common"
"cutego/pkg/excels" "cutego/pkg/excels"
"cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/pkg/resp" "cutego/pkg/resp"
"cutego/pkg/util" "cutego/pkg/util"
@ -92,7 +93,7 @@ func (a UserApi) AuthRole(c *gin.Context) {
userId := c.Param("userId") userId := c.Param("userId")
parseInt, err := strconv.ParseInt(userId, 10, 64) parseInt, err := strconv.ParseInt(userId, 10, 64)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
c.JSON(http.StatusInternalServerError, resp.ErrorResp(err)) c.JSON(http.StatusInternalServerError, resp.ErrorResp(err))
} }
user := a.userService.GetUserById(parseInt) user := a.userService.GetUserById(parseInt)
@ -173,7 +174,7 @@ func (a UserApi) Remove(c *gin.Context) {
param := c.Param("userId") param := c.Param("userId")
userId, err := strconv.ParseInt(param, 10, 64) userId, err := strconv.ParseInt(param, 10, 64)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
c.JSON(http.StatusInternalServerError, resp.ErrorResp("参数错误")) c.JSON(http.StatusInternalServerError, resp.ErrorResp("参数错误"))
return return
} }
@ -293,13 +294,13 @@ func (a UserApi) Avatar(c *gin.Context) {
fileAppend, err := gotool.FileUtils.OpenFileAppend(filePath) fileAppend, err := gotool.FileUtils.OpenFileAppend(filePath)
defer fileAppend.Close() defer fileAppend.Close()
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
resp.Error(c) resp.Error(c)
return return
} }
_, err = io.Copy(fileAppend, file) _, err = io.Copy(fileAppend, file)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
resp.Error(c) resp.Error(c)
return return
} }

21
modules/core/dao/config_dao.go
View File

@ -5,6 +5,7 @@ import (
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/common"
"cutego/pkg/constant" "cutego/pkg/constant"
"cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -23,7 +24,7 @@ func (d ConfigDao) SelectByConfigKey(configKey string) *dataobject.SysConfig {
config := dataobject.SysConfig{} config := dataobject.SysConfig{}
_, err := d.sql(refs.SqlDB.NewSession()).Where("config_key = ?", configKey).Get(&config) _, err := d.sql(refs.SqlDB.NewSession()).Where("config_key = ?", configKey).Get(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &config return &config
@ -51,7 +52,7 @@ func (d ConfigDao) SelectPage(query request.ConfigQuery) (*[]dataobject.SysConfi
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&configs) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&configs)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return &configs, total return &configs, total
@ -65,7 +66,7 @@ func (d ConfigDao) CheckConfigKeyUnique(config dataobject.SysConfig) int64 {
} }
count, err := session.And("config_key = ?", config.ConfigKey).Cols("config_id").Count() count, err := session.And("config_key = ?", config.ConfigKey).Cols("config_id").Count()
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
return count return count
@ -77,7 +78,7 @@ func (d ConfigDao) Insert(config dataobject.SysConfig) int64 {
session.Begin() session.Begin()
insert, err := session.Insert(&config) insert, err := session.Insert(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -91,7 +92,7 @@ func (d ConfigDao) SelectById(id int64) *dataobject.SysConfig {
session := d.sql(refs.SqlDB.NewSession()) session := d.sql(refs.SqlDB.NewSession())
_, err := session.Where("config_id = ?", id).Get(&config) _, err := session.Where("config_id = ?", id).Get(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &config return &config
@ -103,7 +104,7 @@ func (d ConfigDao) Update(config dataobject.SysConfig) int64 {
session.Begin() session.Begin()
update, err := session.Where("config_id = ?", config.ConfigId).Update(&config) update, err := session.Where("config_id = ?", config.ConfigId).Update(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -116,7 +117,7 @@ func (d ConfigDao) CheckConfigByIds(list []int64) *[]dataobject.SysConfig {
configs := make([]dataobject.SysConfig, 0) configs := make([]dataobject.SysConfig, 0)
err := d.sql(refs.SqlDB.NewSession()).In("config_id", list).Find(&configs) err := d.sql(refs.SqlDB.NewSession()).In("config_id", list).Find(&configs)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &configs return &configs
@ -128,7 +129,7 @@ func (d ConfigDao) Delete(list []int64) bool {
session.Begin() session.Begin()
_, err := session.In("config_id", list).Delete(&dataobject.SysConfig{}) _, err := session.In("config_id", list).Delete(&dataobject.SysConfig{})
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return false return false
} }
@ -142,7 +143,7 @@ func (d ConfigDao) SelectAll() *[]dataobject.SysConfig {
session := refs.SqlDB.NewSession() session := refs.SqlDB.NewSession()
err := session.Find(&configs) err := session.Find(&configs)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &configs return &configs
@ -155,7 +156,7 @@ func init() {
configs := make([]*dataobject.SysConfig, 0) configs := make([]*dataobject.SysConfig, 0)
err := configSession.Find(&configs) err := configSession.Find(&configs)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return return
} }
for _, sysConfig := range configs { for _, sysConfig := range configs {

16
modules/core/dao/cron_job_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -30,7 +30,7 @@ func (d CronJobDao) SelectPage(query request.CronJobQuery) ([]dataobject.SysCron
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&configs) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&configs)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return configs, total return configs, total
@ -42,7 +42,7 @@ func (d CronJobDao) Insert(config dataobject.SysCronJob) int64 {
session.Begin() session.Begin()
insert, err := session.Insert(&config) insert, err := session.Insert(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -56,7 +56,7 @@ func (d CronJobDao) SelectById(id int64) *dataobject.SysCronJob {
session := d.sql(refs.SqlDB.NewSession()) session := d.sql(refs.SqlDB.NewSession())
_, err := session.Where("job_id = ?", id).Get(&config) _, err := session.Where("job_id = ?", id).Get(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &config return &config
@ -68,7 +68,7 @@ func (d CronJobDao) Update(config dataobject.SysCronJob) int64 {
session.Begin() session.Begin()
update, err := session.Where("job_id = ?", config.JobId).Update(&config) update, err := session.Where("job_id = ?", config.JobId).Update(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -82,7 +82,7 @@ func (d CronJobDao) Delete(list []int64) bool {
session.Begin() session.Begin()
_, err := session.In("job_id", list).Delete(&dataobject.SysCronJob{}) _, err := session.In("job_id", list).Delete(&dataobject.SysCronJob{})
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return false return false
} }
@ -96,7 +96,7 @@ func (d CronJobDao) SelectByFuncAlias(funcAlias string) *dataobject.SysCronJob {
session := d.sql(refs.SqlDB.NewSession()) session := d.sql(refs.SqlDB.NewSession())
_, err := session.Where("func_alias = ?", funcAlias).Get(&config) _, err := session.Where("func_alias = ?", funcAlias).Get(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &config return &config
@ -108,7 +108,7 @@ func (d CronJobDao) SelectAll() ([]dataobject.SysCronJob, int) {
session := d.sql(refs.SqlDB.NewSession()) session := d.sql(refs.SqlDB.NewSession())
err := session.Where("status = ?", 1).Find(&configs) err := session.Where("status = ?", 1).Find(&configs)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return configs, len(configs) return configs, len(configs)

18
modules/core/dao/dept_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
) )
@ -26,7 +26,7 @@ func (d DeptDao) SelectTree(query request.DeptQuery) *[]dataobject.SysDept {
} }
err := session.OrderBy("parent_id").OrderBy("order_num").Find(&depts) err := session.OrderBy("parent_id").OrderBy("order_num").Find(&depts)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &depts return &depts
@ -43,7 +43,7 @@ func (d DeptDao) SelectDeptListByRoleId(id int64, strictly bool) *[]int64 {
} }
err := session.OrderBy("d.parent_id").OrderBy("d.order_num").Find(&list) err := session.OrderBy("d.parent_id").OrderBy("d.order_num").Find(&list)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &list return &list
@ -65,7 +65,7 @@ func (d DeptDao) GetList(query request.DeptQuery) *[]dataobject.SysDept {
} }
err := session.Find(&list) err := session.Find(&list)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &list return &list
@ -76,7 +76,7 @@ func (d DeptDao) SelectDeptById(id int) *dataobject.SysDept {
dept := dataobject.SysDept{} dept := dataobject.SysDept{}
_, err := refs.SqlDB.NewSession().Where("dept_id = ?", id).Get(&dept) _, err := refs.SqlDB.NewSession().Where("dept_id = ?", id).Get(&dept)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &dept return &dept
@ -88,7 +88,7 @@ func (d DeptDao) Insert(dept dataobject.SysDept) int64 {
session.Begin() session.Begin()
insert, err := session.Insert(&dept) insert, err := session.Insert(&dept)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -101,7 +101,7 @@ func (d DeptDao) CheckDeptNameUnique(dept dataobject.SysDept) int64 {
session := refs.SqlDB.NewSession() session := refs.SqlDB.NewSession()
count, err := session.Table("sys_dept").Cols("dept_id").Where("dept_name=?", dept.DeptName).And("parent_id = ?", dept.ParentId).Limit(1).Count() 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 { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return 1 return 1
} }
return count return count
@ -132,7 +132,7 @@ func (d DeptDao) Delete(id int) int64 {
i, err := session.Where("dept_id = ?", id).Delete(&dept) i, err := session.Where("dept_id = ?", id).Delete(&dept)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()
@ -146,7 +146,7 @@ func (d DeptDao) Update(dept dataobject.SysDept) int64 {
update, err := session.Where("dept_id = ?", dept.DeptId).Update(&dept) update, err := session.Where("dept_id = ?", dept.DeptId).Update(&dept)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()

15
modules/core/dao/dict_data_dao.go
View File

@ -5,6 +5,7 @@ import (
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/common"
"cutego/pkg/constant" "cutego/pkg/constant"
"cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -27,7 +28,7 @@ func (d *DictDataDao) SelectByDictType(dictType string) []dataobject.SysDictData
err := session.Where("status = '0' ").And("dict_type = ?", dictType).OrderBy("dict_sort").Asc("dict_sort"). err := session.Where("status = '0' ").And("dict_type = ?", dictType).OrderBy("dict_sort").Asc("dict_sort").
Find(&data) Find(&data)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return data return data
@ -41,7 +42,7 @@ func (d DictDataDao) GetDiceDataAll() *[]dataobject.SysDictData {
err := session.Where("status = '0' ").OrderBy("dict_sort").Asc("dict_sort"). err := session.Where("status = '0' ").OrderBy("dict_sort").Asc("dict_sort").
Find(&data) Find(&data)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &data return &data
@ -66,7 +67,7 @@ func (d *DictDataDao) SelectPage(query request.DiceDataQuery) (*[]dataobject.Sys
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&list) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&list)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return &list, total return &list, total
@ -80,7 +81,7 @@ func (d *DictDataDao) SelectByDictCode(dictCode int64) *dataobject.SysDictData {
session := refs.SqlDB.NewSession() session := refs.SqlDB.NewSession()
_, err := session.Where("dict_code = ?", dictCode).Get(&data) _, err := session.Where("dict_code = ?", dictCode).Get(&data)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &data return &data
@ -95,7 +96,7 @@ func (d *DictDataDao) Insert(data dataobject.SysDictData) int64 {
insert, err := session.Insert(&data) insert, err := session.Insert(&data)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()
@ -108,7 +109,7 @@ func (d *DictDataDao) Delete(codes []int64) bool {
session.Begin() session.Begin()
_, err := session.In("dict_code", codes).Delete(&dataobject.SysDictData{}) _, err := session.In("dict_code", codes).Delete(&dataobject.SysDictData{})
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return false return false
} }
@ -123,7 +124,7 @@ func (d *DictDataDao) Update(data dataobject.SysDictData) bool {
_, err := session.Where("dict_code = ?", data.DictCode).Update(&data) _, err := session.Where("dict_code = ?", data.DictCode).Update(&data)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return false return false
} }
session.Commit() session.Commit()

16
modules/core/dao/dict_type_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -22,7 +22,7 @@ func (d DictTypeDao) SelectAll() []*dataobject.SysDictType {
types := make([]*dataobject.SysDictType, 0) types := make([]*dataobject.SysDictType, 0)
err := d.sql(refs.SqlDB.NewSession()).Where("status = '0'").Find(&types) err := d.sql(refs.SqlDB.NewSession()).Where("status = '0'").Find(&types)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return types return types
@ -50,7 +50,7 @@ func (d DictTypeDao) SelectPage(query request.DictTypeQuery) (*[]dataobject.SysD
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&list) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&list)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return &list, total return &list, total
@ -61,7 +61,7 @@ func (d DictTypeDao) SelectById(id int64) *dataobject.SysDictType {
dictType := dataobject.SysDictType{} dictType := dataobject.SysDictType{}
_, err := refs.SqlDB.NewSession().Where("dict_id = ?", id).Get(&dictType) _, err := refs.SqlDB.NewSession().Where("dict_id = ?", id).Get(&dictType)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &dictType return &dictType
@ -75,7 +75,7 @@ func (d DictTypeDao) CheckDictTypeUnique(dictType dataobject.SysDictType) int64
} }
count, err := session.Where("dict_type = ?", dictType.DictType).Cols("dict_id").Count() count, err := session.Where("dict_type = ?", dictType.DictType).Cols("dict_id").Count()
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
return count return count
@ -87,7 +87,7 @@ func (d DictTypeDao) Update(dictType dataobject.SysDictType) bool {
session.Begin() session.Begin()
_, err := session.Where("dict_id = ?", dictType.DictId).Update(&dictType) _, err := session.Where("dict_id = ?", dictType.DictId).Update(&dictType)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return false return false
} }
@ -101,7 +101,7 @@ func (d DictTypeDao) Insert(dictType dataobject.SysDictType) int64 {
session.Begin() session.Begin()
insert, err := session.Insert(&dictType) insert, err := session.Insert(&dictType)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -116,7 +116,7 @@ func (d DictTypeDao) Delete(ids []int64) bool {
_, err := session.In("dict_id", ids).Delete(dataobject.SysDictType{}) _, err := session.In("dict_id", ids).Delete(dataobject.SysDictType{})
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return false return false
} }
session.Commit() session.Commit()

6
modules/core/dao/log_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -30,7 +30,7 @@ func (d LogDao) SelectPage(query request.LogQuery) ([]dataobject.SysLog, int64)
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&configs) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&configs)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return configs, total return configs, total
@ -42,7 +42,7 @@ func (d LogDao) Insert(config dataobject.SysLog) int64 {
session.Begin() session.Begin()
insert, err := session.Insert(&config) insert, err := session.Insert(&config)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }

6
modules/core/dao/login_info_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/go-xorm/xorm" "github.com/go-xorm/xorm"
@ -25,7 +25,7 @@ func (d LoginInfoDao) SelectPage(query request.LoginInfoQuery) (*[]dataobject.Sy
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&loginInfos) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&loginInfos)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return &loginInfos, total return &loginInfos, total
@ -37,7 +37,7 @@ func (d LoginInfoDao) Insert(body dataobject.SysLoginInfo) *dataobject.SysLoginI
session.Begin() session.Begin()
_, err := session.Table("sys_login_info").Insert(&body) _, err := session.Table("sys_login_info").Insert(&body)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
} }
session.Commit() session.Commit()

22
modules/core/dao/menu_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
) )
@ -21,7 +21,7 @@ func (d MenuDao) GetMenuPermission(id int64) *[]string {
Join("LEFT", []string{"sys_role", "r"}, "r.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) Where("m.status = '0'").And("r.status = '0'").And("ur.user_id = ?", id).Find(&perms)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &perms return &perms
@ -34,7 +34,7 @@ func (d MenuDao) GetMenuAll() *[]dataobject.SysMenu {
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"). 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) Where("m.menu_type in ('M', 'C')").And("m.status = 0").OrderBy("m.parent_id").OrderBy("m.order_num").Find(&menus)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &menus return &menus
@ -51,7 +51,7 @@ func (d MenuDao) GetMenuByUserId(id int64) *[]dataobject.SysMenu {
Join("LEFT", []string{"sys_user", "u"}, "ur.user_id = u.user_id").Where("u.user_id = ?", 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) And("m.menu_type in ('M', 'C')").And("m.status = 0").OrderBy("m.parent_id").OrderBy("m.order_num").Find(&menus)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &menus return &menus
@ -68,7 +68,7 @@ func (d MenuDao) SelectMenuByRoleId(id int64, strictly bool) *[]int64 {
} }
err := session.OrderBy("m.parent_id").OrderBy("m.order_num").Cols("m.menu_id").Find(&list) err := session.OrderBy("m.parent_id").OrderBy("m.order_num").Cols("m.menu_id").Find(&list)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &list return &list
@ -89,7 +89,7 @@ func (d MenuDao) SelectMenuList(query request.MenuQuery) *[]dataobject.SysMenu {
} }
err := session.Find(&list) err := session.Find(&list)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &list return &list
@ -115,7 +115,7 @@ func (d MenuDao) SelectMenuListByUserId(query request.MenuQuery) *[]dataobject.S
} }
err := session.Find(&list) err := session.Find(&list)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &list return &list
@ -128,7 +128,7 @@ func (d MenuDao) SelectMenuByMenuId(id int) *dataobject.SysMenu {
} }
_, err := refs.SqlDB.NewSession().Where("menu_id = ?", menu.MenuId).Get(&menu) _, err := refs.SqlDB.NewSession().Where("menu_id = ?", menu.MenuId).Get(&menu)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &menu return &menu
@ -140,7 +140,7 @@ func (d MenuDao) Insert(menu dataobject.SysMenu) int64 {
session.Begin() session.Begin()
insert, err := session.Insert(&menu) insert, err := session.Insert(&menu)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -154,7 +154,7 @@ func (d MenuDao) Update(menu dataobject.SysMenu) int64 {
session.Begin() session.Begin()
update, err := session.Where("menu_id = ?", menu.MenuId).Update(&menu) update, err := session.Where("menu_id = ?", menu.MenuId).Update(&menu)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -171,7 +171,7 @@ func (d MenuDao) Delete(id int) int64 {
session.Begin() session.Begin()
i, err := session.Delete(&menu) i, err := session.Delete(&menu)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }

12
modules/core/dao/notice_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -28,7 +28,7 @@ func (d NoticeDao) SelectPage(query request.NoticeQuery) (*[]dataobject.SysNotic
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&notices) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&notices)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return &notices, total return &notices, total
@ -41,7 +41,7 @@ func (d NoticeDao) Insert(notice dataobject.SysNotice) int64 {
insert, err := session.Insert(&notice) insert, err := session.Insert(&notice)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()
@ -55,7 +55,7 @@ func (d NoticeDao) Delete(list []int64) int64 {
i, err := session.In("notice_id", list).Delete(&dataobject.SysNotice{}) i, err := session.In("notice_id", list).Delete(&dataobject.SysNotice{})
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()
@ -67,7 +67,7 @@ func (d NoticeDao) SelectById(id int64) *dataobject.SysNotice {
notice := dataobject.SysNotice{} notice := dataobject.SysNotice{}
_, err := refs.SqlDB.NewSession().Where("notice_id = ?", id).Get(&notice) _, err := refs.SqlDB.NewSession().Where("notice_id = ?", id).Get(&notice)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &notice return &notice
@ -80,7 +80,7 @@ func (d NoticeDao) Update(notice dataobject.SysNotice) int64 {
update, err := session.Where("notice_id = ?", notice.NoticeId).Update(&notice) update, err := session.Where("notice_id = ?", notice.NoticeId).Update(&notice)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()

18
modules/core/dao/post_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -25,7 +25,7 @@ func (d PostDao) SelectAll() []*dataobject.SysPost {
posts := make([]*dataobject.SysPost, 0) posts := make([]*dataobject.SysPost, 0)
err := session.Find(&posts) err := session.Find(&posts)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return posts return posts
@ -37,7 +37,7 @@ func (d PostDao) SelectPostListByUserId(userId int64) *[]int64 {
selectSql := d.sqlSelectJoin(refs.SqlDB.NewSession()) selectSql := d.sqlSelectJoin(refs.SqlDB.NewSession())
err := selectSql.Where("u.user_id = ?", userId).Cols("p.post_id").Find(&ids) err := selectSql.Where("u.user_id = ?", userId).Cols("p.post_id").Find(&ids)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &ids return &ids
@ -59,7 +59,7 @@ func (d PostDao) SelectPage(query request.PostQuery) (*[]dataobject.SysPost, int
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&posts) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&posts)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return &posts, total return &posts, total
@ -94,7 +94,7 @@ func (d PostDao) Insert(post dataobject.SysPost) int64 {
insert, err := session.Insert(&post) insert, err := session.Insert(&post)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()
@ -105,7 +105,7 @@ func (d PostDao) Insert(post dataobject.SysPost) int64 {
func (d PostDao) GetPostById(post dataobject.SysPost) *dataobject.SysPost { func (d PostDao) GetPostById(post dataobject.SysPost) *dataobject.SysPost {
_, err := refs.SqlDB.NewSession().Where("post_id = ?", post.PostId).Get(&post) _, err := refs.SqlDB.NewSession().Where("post_id = ?", post.PostId).Get(&post)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &post return &post
@ -119,7 +119,7 @@ func (d PostDao) Delete(posts []int64) int64 {
i, err := session.In("post_id", posts).Delete(&dataobject.SysPost{}) i, err := session.In("post_id", posts).Delete(&dataobject.SysPost{})
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()
@ -133,7 +133,7 @@ func (d PostDao) Update(post dataobject.SysPost) bool {
_, err := session.Where("post_id = ?", post.PostId).Update(&post) _, err := session.Where("post_id = ?", post.PostId).Update(&post)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return false return false
} }
session.Commit() session.Commit()
@ -147,7 +147,7 @@ func (d PostDao) SelectPostByUserName(name string) *[]dataobject.SysPost {
Join("LEFT", []string{"sys_user_post", "up"}, "up.post_id = p.post_id"). 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) Join("LEFT", []string{"sys_user", "u"}, "u.user_id = up.user_id").Where("u.user_name = ?", name).Find(&posts)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &posts return &posts

26
modules/core/dao/role_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -61,7 +61,7 @@ func (d RoleDao) SelectAll() []*dataobject.SysRole {
roles := make([]*dataobject.SysRole, 0) roles := make([]*dataobject.SysRole, 0)
err := sql.Find(&roles) err := sql.Find(&roles)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return roles return roles
@ -73,7 +73,7 @@ func (d RoleDao) SelectRoleListByUserId(userId int64) *[]int64 {
var roleIds []int64 var roleIds []int64
err := sqlSelectRoleAndUser.Cols("r.role_id").Where("u.user_id = ?", userId).Find(&roleIds) err := sqlSelectRoleAndUser.Cols("r.role_id").Where("u.user_id = ?", userId).Find(&roleIds)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &roleIds return &roleIds
@ -84,7 +84,7 @@ func (d RoleDao) SelectRolePermissionByUserId(id int64) *[]string {
var roleKeys []string var roleKeys []string
err := d.sqlSelectJoin().Cols("r.role_key").Where("r.del_flag = '0'").And("ur.user_id = ?", id).Find(&roleKeys) err := d.sqlSelectJoin().Cols("r.role_key").Where("r.del_flag = '0'").And("ur.user_id = ?", id).Find(&roleKeys)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &roleKeys return &roleKeys
@ -95,7 +95,7 @@ func (d RoleDao) GetRoleListByUserId(id int64) *[]dataobject.SysRole {
roles := make([]dataobject.SysRole, 0) roles := make([]dataobject.SysRole, 0)
err := d.sqlSelectJoin().Where("r.del_flag = '0'").And("ur.user_id = ?", id).Find(&roles) err := d.sqlSelectJoin().Where("r.del_flag = '0'").And("ur.user_id = ?", id).Find(&roles)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &roles return &roles
@ -106,7 +106,7 @@ func (d RoleDao) SelectRoleByRoleId(id int64) *dataobject.SysRole {
role := dataobject.SysRole{} role := dataobject.SysRole{}
_, err := d.sqlSelectJoin().Where("r.role_id = ?", id).Get(&role) _, err := d.sqlSelectJoin().Where("r.role_id = ?", id).Get(&role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &role return &role
@ -120,7 +120,7 @@ func (d RoleDao) CheckRoleNameUnique(role dataobject.SysRole) int64 {
} }
count, err := session.Count(&role) count, err := session.Count(&role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
} }
return count return count
} }
@ -133,7 +133,7 @@ func (d RoleDao) CheckRoleKeyUnique(role dataobject.SysRole) int64 {
} }
count, err := session.Count(&role) count, err := session.Count(&role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
} }
return count return count
} }
@ -144,7 +144,7 @@ func (d RoleDao) Insert(role dataobject.SysRole) dataobject.SysRole {
session.Begin() session.Begin()
_, err := session.Insert(&role) _, err := session.Insert(&role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
} }
session.Commit() session.Commit()
@ -157,7 +157,7 @@ func (d RoleDao) Update(role dataobject.SysRole) int64 {
session.Begin() session.Begin()
update, err := session.Where("role_id = ?", role.RoleId).Update(&role) update, err := session.Where("role_id = ?", role.RoleId).Update(&role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -171,7 +171,7 @@ func (d RoleDao) Delete(role dataobject.SysRole) int64 {
session.Begin() session.Begin()
i, err := session.Delete(&role) i, err := session.Delete(&role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -185,7 +185,7 @@ func (d RoleDao) UpdateRoleStatus(role *dataobject.SysRole) int64 {
session.Begin() session.Begin()
update, err := session.Where("role_id = ?", role.RoleId).Cols("status", "update_by", "update_time").Update(role) update, err := session.Where("role_id = ?", role.RoleId).Cols("status", "update_by", "update_time").Update(role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -199,7 +199,7 @@ func (d RoleDao) SelectRolesByUserName(name string) *[]dataobject.SysRole {
session := d.sqlSelectJoin() session := d.sqlSelectJoin()
err := session.Where("r.del_flag = '0'").And("u.user_name = ?", name).Find(&roles) err := session.Where("r.del_flag = '0'").And("u.user_name = ?", name).Find(&roles)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
return &roles return &roles

6
modules/core/dao/role_menu_dao.go
View File

@ -2,7 +2,7 @@ package dao
import ( import (
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/refs" "cutego/refs"
) )
@ -15,7 +15,7 @@ func (d RoleMenuDao) Insert(list []dataobject.SysRoleMenu) int64 {
session.Begin() session.Begin()
insert, err := session.Insert(&list) insert, err := session.Insert(&list)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
} }
session.Commit() session.Commit()
@ -31,7 +31,7 @@ func (d RoleMenuDao) Delete(role dataobject.SysRole) {
session.Begin() session.Begin()
_, err := session.Delete(&menu) _, err := session.Delete(&menu)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
} }
session.Commit() session.Commit()

26
modules/core/dao/user_dao.go
View File

@ -4,7 +4,7 @@ import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/api/v1/response" "cutego/modules/core/api/v1/response"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/pkg/page" "cutego/pkg/page"
"cutego/refs" "cutego/refs"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
@ -48,7 +48,7 @@ func (d UserDao) SelectPage(query request.UserQuery) ([]*response.UserResponse,
total, _ := page.GetTotal(sql.Clone()) total, _ := page.GetTotal(sql.Clone())
err := sql.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp) err := sql.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return resp, total return resp, total
@ -59,7 +59,7 @@ func (d UserDao) GetUserById(userId int64) *response.UserResponse {
var resp response.UserResponse var resp response.UserResponse
get, err := d.sqlSelectJoin().Where("u.user_id = ?", userId).Get(&resp) get, err := d.sqlSelectJoin().Where("u.user_id = ?", userId).Get(&resp)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
} }
if !get { if !get {
return nil return nil
@ -71,7 +71,7 @@ func (d UserDao) GetUserById(userId int64) *response.UserResponse {
func (d UserDao) GetUserByUserName(user dataobject.SysUser) *dataobject.SysUser { func (d UserDao) GetUserByUserName(user dataobject.SysUser) *dataobject.SysUser {
i, err := refs.SqlDB.Get(&user) i, err := refs.SqlDB.Get(&user)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil return nil
} }
if i { if i {
@ -118,7 +118,7 @@ func (d UserDao) Insert(body request.UserBody) *request.UserBody {
session.Begin() session.Begin()
_, err := session.Table("sys_user").Insert(&body) _, err := session.Table("sys_user").Insert(&body)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
} }
session.Commit() session.Commit()
@ -132,7 +132,7 @@ func (d UserDao) Update(body request.UserBody) int64 {
_, err := session.Where("user_id = ?", body.UserId).Update(&body) _, err := session.Where("user_id = ?", body.UserId).Update(&body)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()
@ -148,7 +148,7 @@ func (d UserDao) Delete(id int64) int64 {
session.Begin() session.Begin()
i, err := session.Delete(&user) i, err := session.Delete(&user)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
} }
session.Commit() session.Commit()
@ -165,7 +165,7 @@ func (d UserDao) ResetPwd(body request.UserBody) int64 {
session.Begin() session.Begin()
_, err := session.Where("user_id = ?", user.UserId).Cols("password").Update(&user) _, err := session.Where("user_id = ?", user.UserId).Cols("password").Update(&user)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -190,7 +190,7 @@ func (d UserDao) GetAllocatedList(query request.UserQuery) ([]*response.UserResp
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return resp, total return resp, total
@ -214,7 +214,7 @@ func (d UserDao) GetUnallocatedList(query request.UserQuery) ([]*response.UserRe
total, _ := page.GetTotal(session.Clone()) total, _ := page.GetTotal(session.Clone())
err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp) err := session.Limit(query.PageSize, page.StartSize(query.PageNum, query.PageSize)).Find(&resp)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return nil, 0 return nil, 0
} }
return resp, total return resp, total
@ -229,7 +229,7 @@ func (d UserDao) UpdatePwd(id int64, hash string) int64 {
session.Begin() session.Begin()
update, err := session.Cols("password").Where("user_id = ?", id).Update(&user) update, err := session.Cols("password").Where("user_id = ?", id).Update(&user)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -250,7 +250,7 @@ func (d UserDao) UpdateAvatar(info *response.UserResponse) int64 {
update, err := session.Cols("avatar", "update_by", "update_time").Where("user_id = ?", user.UserId).Update(&user) update, err := session.Cols("avatar", "update_by", "update_time").Where("user_id = ?", user.UserId).Update(&user)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()
@ -269,7 +269,7 @@ func (d UserDao) UpdateStatus(info request.UserBody) int64 {
update, err := session.Cols("status", "update_by", "update_time").Where("user_id = ?", user.UserId).Update(&user) update, err := session.Cols("status", "update_by", "update_time").Where("user_id = ?", user.UserId).Update(&user)
if err != nil { if err != nil {
session.Rollback() session.Rollback()
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
session.Commit() session.Commit()

8
modules/core/dao/user_post_dao.go
View File

@ -2,7 +2,7 @@ package dao
import ( import (
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/refs" "cutego/refs"
) )
@ -15,7 +15,7 @@ func (d UserPostDao) BatchInsert(posts []dataobject.SysUserPost) {
session.Begin() session.Begin()
_, err := session.Table(dataobject.SysUserPost{}.TableName()).Insert(&posts) _, err := session.Table(dataobject.SysUserPost{}.TableName()).Insert(&posts)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return return
} }
@ -31,7 +31,7 @@ func (d UserPostDao) Delete(id int64) {
session.Begin() session.Begin()
_, err := session.Delete(&post) _, err := session.Delete(&post)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
} }
session.Commit() session.Commit()
@ -41,7 +41,7 @@ func (d UserPostDao) Delete(id int64) {
func (d UserPostDao) CountById(id int64) int64 { func (d UserPostDao) CountById(id int64) int64 {
count, err := refs.SqlDB.NewSession().Table("sys_user_post").Cols("post_id").Where("post_id = ?", id).Count() count, err := refs.SqlDB.NewSession().Table("sys_user_post").Cols("post_id").Where("post_id = ?", id).Count()
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return 0 return 0
} }
return count return count

10
modules/core/dao/user_role_dao.go
View File

@ -3,7 +3,7 @@ package dao
import ( import (
"cutego/modules/core/api/v1/request" "cutego/modules/core/api/v1/request"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common" "cutego/pkg/logging"
"cutego/refs" "cutego/refs"
) )
@ -16,7 +16,7 @@ func (d UserRoleDao) BatchInsert(roles []dataobject.SysUserRole) {
session.Begin() session.Begin()
_, err := session.Table(dataobject.SysUserRole{}.TableName()).Insert(&roles) _, err := session.Table(dataobject.SysUserRole{}.TableName()).Insert(&roles)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return return
} }
@ -32,7 +32,7 @@ func (d UserRoleDao) Delete(id int64) {
session.Begin() session.Begin()
_, err := session.Delete(&role) _, err := session.Delete(&role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return return
} }
@ -45,7 +45,7 @@ func (d UserRoleDao) DeleteAuthUser(role dataobject.SysUserRole) int64 {
session.Begin() session.Begin()
i, err := session.Delete(&role) i, err := session.Delete(&role)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }
@ -68,7 +68,7 @@ func (d UserRoleDao) InsertAuthUsers(body request.UserRoleBody) int64 {
session.Begin() session.Begin()
insert, err := session.Insert(&roles) insert, err := session.Insert(&roles)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
session.Rollback() session.Rollback()
return 0 return 0
} }

6
modules/core/service/login_service.go
View File

@ -2,8 +2,8 @@ package service
import ( import (
"cutego/modules/core/api/v1/response" "cutego/modules/core/api/v1/response"
"cutego/pkg/common"
"cutego/pkg/jwt" "cutego/pkg/jwt"
"cutego/pkg/logging"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"strings" "strings"
@ -25,7 +25,7 @@ func (s LoginService) Login(name string, password string) (bool, string) {
// 生成token // 生成token
token, err := jwt.CreateUserToken(s.userService.GetUserById(user.UserId)) token, err := jwt.CreateUserToken(s.userService.GetUserById(user.UserId))
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return false, "" return false, ""
} }
// 数据存储到redis中 // 数据存储到redis中
@ -39,7 +39,7 @@ func (s LoginService) GetCurrentUser(c *gin.Context) *response.UserResponse {
// parseToken 解析token包含的信息 // parseToken 解析token包含的信息
claims, err := jwt.ParseToken(str[1]) claims, err := jwt.ParseToken(str[1])
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
} }
info := claims.UserInfo info := claims.UserInfo
return &info return &info

18
modules/demo/dao/student_dao.go Normal file
View File

@ -0,0 +1,18 @@
package dao
import "cutego/modules/demo/dataobject"
type StudentDao struct {
}
// Insert 增加
func (d StudentDao) Insert(record dataobject.Student) {
}
// 修改
// 删除
// 批量删除
// 分页查询
// 通过id查询
// 通过属性查询

13
pkg/cache/index.go vendored
View File

@ -1,8 +1,9 @@
package cache package cache
import ( import (
"cutego/pkg/common"
"cutego/pkg/constant" "cutego/pkg/constant"
"cutego/pkg/logging"
"cutego/pkg/util"
"cutego/refs" "cutego/refs"
) )
@ -18,7 +19,7 @@ func RemoveList(list []string) {
func RemoveCache(key string) int { func RemoveCache(key string) int {
del, err := refs.RedisDB.DEL(key) del, err := refs.RedisDB.DEL(key)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
} }
return del return del
} }
@ -29,7 +30,7 @@ func RemoveCache(key string) int {
func GetCache(key string) string { func GetCache(key string) string {
val, err := refs.RedisDB.GET(key) val, err := refs.RedisDB.GET(key)
if err != nil { if err != nil {
common.ErrorLog(constant.RedisConst{}.GetRedisError(), err.Error()) logging.ErrorLog(constant.RedisConst{}.GetRedisError(), err.Error())
return "" return ""
} }
return val return val
@ -40,9 +41,9 @@ func GetCache(key string) string {
// @Param value 值 // @Param value 值
// @Return 新增的行数 // @Return 新增的行数
func SetCache(key string, value interface{}) int { func SetCache(key string, value interface{}) int {
n, err := refs.RedisDB.SET(key, common.StructToJson(value)) n, err := refs.RedisDB.SET(key, util.StructToJson(value))
if err != nil { if err != nil {
common.ErrorLog(constant.RedisConst{}.GetRedisError(), err.Error()) logging.ErrorLog(constant.RedisConst{}.GetRedisError(), err.Error())
return 0 return 0
} }
return int(n) return int(n)
@ -54,5 +55,5 @@ func SetCache(key string, value interface{}) int {
// @Param sec 过期时间(单位: 秒) // @Param sec 过期时间(单位: 秒)
// @Return 新增的行数 // @Return 新增的行数
func SetCacheTTL(key string, value interface{}, sec int) { func SetCacheTTL(key string, value interface{}, sec int) {
refs.RedisDB.SETEX(key, sec, common.StructToJson(value)) refs.RedisDB.SETEX(key, sec, util.StructToJson(value))
} }

166
pkg/common/index.go
View File

@ -1,166 +0,0 @@
package common
import (
"cutego/pkg/config"
"encoding/json"
"fmt"
"os"
"runtime"
"strconv"
)
// IntToString int转string
func IntToString(n int) string {
return strconv.Itoa(n)
}
// StringToInt string转int
func StringToInt(s string) int {
i, err := strconv.Atoi(s)
if err != nil {
panic(err)
}
return i
}
// StringToInt64 string转int64
func StringToInt64(s string) int64 {
i, err := strconv.ParseInt(s, 10, 64)
if err != nil {
panic(err)
}
return i
}
// Int64ToString int64转string
func Int64ToString(n int64) string {
return strconv.FormatInt(n, 10)
}
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.([]dataobject.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
}

117
pkg/config/index.go
View File

@ -2,10 +2,14 @@ package config
import ( import (
config "cutego/pkg/config/models" config "cutego/pkg/config/models"
"cutego/pkg/logging"
"encoding/json"
"fmt" "fmt"
"gopkg.in/yaml.v2" "gopkg.in/yaml.v2"
"io/ioutil" "io/ioutil"
"os" "os"
"runtime"
"strconv"
) )
var ( var (
@ -80,16 +84,117 @@ func readAppYmlFile(resourcePath string) {
LoadYamlFile(applicationEnvFilePath, AppEnvConfig) LoadYamlFile(applicationEnvFilePath, AppEnvConfig)
} }
// ExecuteTip 执行日志 // IntToString int转string
func ExecuteTip(message string) { func IntToString(n int) string {
fmt.Println(fmt.Sprintf("-------------------- %s --------------------", message)) return strconv.Itoa(n)
}
// StringToInt string转int
func StringToInt(s string) int {
i, err := strconv.Atoi(s)
if err != nil {
panic(err)
}
return i
}
// StringToInt64 string转int64
func StringToInt64(s string) int64 {
i, err := strconv.ParseInt(s, 10, 64)
if err != nil {
panic(err)
}
return i
}
// Int64ToString int64转string
func Int64ToString(n int64) string {
return strconv.FormatInt(n, 10)
}
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 == "logging" {
return AppCoreConfig.CuteGoConfig.File.Linux.Logs
} else if resType == "avatar" {
return AppCoreConfig.CuteGoConfig.File.Linux.Avatar
} else if resType == "file" {
return AppCoreConfig.CuteGoConfig.File.Linux.Path
}
break
case "windows":
if resType == "logging" {
return AppCoreConfig.CuteGoConfig.File.Windows.Logs
} else if resType == "avatar" {
return AppCoreConfig.CuteGoConfig.File.Windows.Avatar
} else if resType == "file" {
return AppCoreConfig.CuteGoConfig.File.Windows.Path
}
break
case "mac":
if resType == "logging" {
return AppCoreConfig.CuteGoConfig.File.Mac.Logs
} else if resType == "avatar" {
return AppCoreConfig.CuteGoConfig.File.Mac.Avatar
} else if resType == "file" {
return AppCoreConfig.CuteGoConfig.File.Mac.Path
}
break
case "darwin":
if resType == "logging" {
return AppCoreConfig.CuteGoConfig.File.Mac.Logs
} else if resType == "avatar" {
return AppCoreConfig.CuteGoConfig.File.Mac.Avatar
} else if resType == "file" {
return AppCoreConfig.CuteGoConfig.File.Mac.Path
}
}
return 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
} }
func init() { func init() {
// 资源文件所在的路径 // 资源文件所在的路径
resourcePath := GetRootPath() resourcePath := GetRootPath()
ExecuteTip("初始化应用配置 start") logging.InfoLog("application init start...")
readAppYmlFile(resourcePath) readAppYmlFile(resourcePath)
ExecuteTip("初始化应用配置 end") logging.InfoLog("application init start...")
return
} }

20
pkg/cronjob/index.go
View File

@ -3,7 +3,7 @@ package cronjob
import ( import (
"cutego/modules/core/job" "cutego/modules/core/job"
"cutego/modules/core/service" "cutego/modules/core/service"
"cutego/pkg/common" "cutego/pkg/logging"
"github.com/robfig/cron" "github.com/robfig/cron"
) )
@ -23,24 +23,24 @@ var aliasCronMap = make(map[string]*cron.Cron)
// StopCronFunc 停止任务, 不会停止已开始的任务 // StopCronFunc 停止任务, 不会停止已开始的任务
func StopCronFunc(aliasName string) { func StopCronFunc(aliasName string) {
common.InfoLogf("停止任务 %s ---> Start", aliasName) logging.InfoLogf("停止任务 %s ---> Start", aliasName)
go aliasCronMap[aliasName].Stop() go aliasCronMap[aliasName].Stop()
common.InfoLogf("停止任务 %s ---> Finish", aliasName) logging.InfoLogf("停止任务 %s ---> Finish", aliasName)
} }
// StartCronFunc 开始任务 // StartCronFunc 开始任务
func StartCronFunc(aliasName string) { func StartCronFunc(aliasName string) {
common.InfoLogf("唤起任务 %s ---> Start", aliasName) logging.InfoLogf("唤起任务 %s ---> Start", aliasName)
go aliasCronMap[aliasName].Start() go aliasCronMap[aliasName].Start()
common.InfoLogf("唤起任务 %s ---> Finish", aliasName) logging.InfoLogf("唤起任务 %s ---> Finish", aliasName)
} }
// RemoveCronFunc 移除任务 // RemoveCronFunc 移除任务
func RemoveCronFunc(aliasName string) { func RemoveCronFunc(aliasName string) {
common.InfoLogf("移除任务 %s ---> Start", aliasName) logging.InfoLogf("移除任务 %s ---> Start", aliasName)
go StopCronFunc(aliasName) go StopCronFunc(aliasName)
delete(aliasCronMap, aliasName) delete(aliasCronMap, aliasName)
common.InfoLogf("移除任务 %s ---> Finish", aliasName) logging.InfoLogf("移除任务 %s ---> Finish", aliasName)
} }
// AppendCronFunc 新增任务 // AppendCronFunc 新增任务
@ -49,7 +49,7 @@ func AppendCronFunc(jobCron string, aliasName string, status string) {
aliasCronMap[aliasName].Stop() aliasCronMap[aliasName].Stop()
aliasCronMap[aliasName] = nil aliasCronMap[aliasName] = nil
} }
common.InfoLogf("新增任务 %s ---> Start", aliasName) logging.InfoLogf("新增任务 %s ---> Start", aliasName)
c := cron.New() c := cron.New()
err := c.AddFunc(jobCron, job.AliasFuncMap[aliasName]) err := c.AddFunc(jobCron, job.AliasFuncMap[aliasName])
if err != nil { if err != nil {
@ -59,10 +59,10 @@ func AppendCronFunc(jobCron string, aliasName string, status string) {
go func() { go func() {
c.Start() c.Start()
aliasCronMap[aliasName] = c aliasCronMap[aliasName] = c
common.InfoLogf("调度定时任务 --- %s ---> Success", aliasName) logging.InfoLogf("调度定时任务 --- %s ---> Success", aliasName)
}() }()
} }
common.InfoLogf("新增任务 %s ---> Finish", aliasName) logging.InfoLogf("新增任务 %s ---> Finish", aliasName)
} }
func init() { func init() {

5
pkg/gin/index.go
View File

@ -4,16 +4,16 @@ import (
"cutego/modules/core/router" "cutego/modules/core/router"
"cutego/pkg/filter" "cutego/pkg/filter"
"cutego/pkg/jwt" "cutego/pkg/jwt"
"cutego/pkg/logging"
"cutego/pkg/middleware" "cutego/pkg/middleware"
"cutego/pkg/middleware/logger" "cutego/pkg/middleware/logger"
"cutego/pkg/websocket" "cutego/pkg/websocket"
"cutego/refs" "cutego/refs"
"fmt"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
) )
func init() { func init() {
fmt.Println("CoolGin init...") logging.InfoLog("CoolGin init start...")
refs.CoolGin = gin.New() refs.CoolGin = gin.New()
refs.CoolGin.Use(gin.Logger()) refs.CoolGin.Use(gin.Logger())
refs.CoolGin.Use(gin.Recovery()) refs.CoolGin.Use(gin.Recovery())
@ -27,4 +27,5 @@ func init() {
v1Router := refs.CoolGin.Group("/api/v1") v1Router := refs.CoolGin.Group("/api/v1")
// 加载: 模块路由 // 加载: 模块路由
router.LoadCoreRouter(v1Router) router.LoadCoreRouter(v1Router)
logging.InfoLog("CoolGin init end...")
} }

2
pkg/common/log.go → pkg/logging/index.go
View File

@ -1,4 +1,4 @@
package common package logging
import "github.com/druidcaesa/gotool" import "github.com/druidcaesa/gotool"

9
pkg/middleware/logger/logger.go
View File

@ -3,6 +3,7 @@ package logger
import ( import (
"cutego/pkg/common" "cutego/pkg/common"
"cutego/pkg/config" "cutego/pkg/config"
"cutego/pkg/logging"
"fmt" "fmt"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
@ -16,18 +17,18 @@ import (
// LoggerToFile 日志记录到文件 // LoggerToFile 日志记录到文件
func LoggerToFile() gin.HandlerFunc { func LoggerToFile() gin.HandlerFunc {
dirPath := common.GetDirPath("log") dirPath := common.GetDirPath("logging")
fileName := path.Join(dirPath, "application.log") fileName := path.Join(dirPath, "application.logging")
if !common.IsFileOrDirExist(dirPath) { if !common.IsFileOrDirExist(dirPath) {
err := common.CreateAllDir(dirPath) err := common.CreateAllDir(dirPath)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
} }
} }
if !gotool.FileUtils.Exists(fileName) { if !gotool.FileUtils.Exists(fileName) {
create, err := os.Create(fileName) create, err := os.Create(fileName)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
} }
defer create.Close() defer create.Close()
} }

4
pkg/middleware/recover.go
View File

@ -1,7 +1,7 @@
package middleware package middleware
import ( import (
"cutego/pkg/common" "cutego/pkg/logging"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"net/http" "net/http"
"runtime/debug" "runtime/debug"
@ -10,7 +10,7 @@ import (
func Recover(c *gin.Context) { func Recover(c *gin.Context) {
defer func() { defer func() {
if r := recover(); r != nil { if r := recover(); r != nil {
common.ErrorLog("panic: %v\n", r) logging.ErrorLog("panic: %v\n", r)
debug.PrintStack() debug.PrintStack()
c.JSON(http.StatusOK, gin.H{ c.JSON(http.StatusOK, gin.H{
"code": http.StatusInternalServerError, "code": http.StatusInternalServerError,

4
pkg/page/page.go
View File

@ -1,7 +1,7 @@
package page package page
import ( import (
"cutego/pkg/common" "cutego/pkg/logging"
"github.com/go-xorm/xorm" "github.com/go-xorm/xorm"
) )
@ -34,7 +34,7 @@ func GetTotal(engine *xorm.Session, args ...interface{}) (int64, error) {
} }
count, err := engine.Count() count, err := engine.Count()
if err != nil { if err != nil {
common.ErrorLog(err.Error()) logging.ErrorLog(err.Error())
return 0, err return 0, err
} }
return count, nil return count, nil

11
pkg/redispool/index.go
View File

@ -3,6 +3,7 @@ package redispool
import ( import (
"cutego/pkg/common" "cutego/pkg/common"
"cutego/pkg/config" "cutego/pkg/config"
"cutego/pkg/logging"
"fmt" "fmt"
"github.com/druidcaesa/gotool" "github.com/druidcaesa/gotool"
"github.com/gomodule/redigo/redis" "github.com/gomodule/redigo/redis"
@ -41,19 +42,19 @@ func newPool() *redis.Pool {
Dial: func() (redis.Conn, error) { Dial: func() (redis.Conn, error) {
c, err := redis.Dial("tcp", fmt.Sprintf("%s:%d", config.AppEnvConfig.Redis.Host, config.AppEnvConfig.Redis.Port)) c, err := redis.Dial("tcp", fmt.Sprintf("%s:%d", config.AppEnvConfig.Redis.Host, config.AppEnvConfig.Redis.Port))
if err != nil { if err != nil {
common.FatalfLog("Redis.Dial: %v", err) logging.FatalfLog("Redis.Dial: %v", err)
return nil, err return nil, err
} }
if gotool.StrUtils.HasNotEmpty(config.AppEnvConfig.Redis.Password) { if gotool.StrUtils.HasNotEmpty(config.AppEnvConfig.Redis.Password) {
if _, err := c.Do("AUTH", config.AppEnvConfig.Redis.Password); err != nil { if _, err := c.Do("AUTH", config.AppEnvConfig.Redis.Password); err != nil {
c.Close() c.Close()
common.FatalfLog("Redis.AUTH: %v", err) logging.FatalfLog("Redis.AUTH: %v", err)
return nil, err return nil, err
} }
} }
if _, err := c.Do("SELECT", config.AppEnvConfig.Redis.Database); err != nil { if _, err := c.Do("SELECT", config.AppEnvConfig.Redis.Database); err != nil {
c.Close() c.Close()
common.FatalfLog("Redis.SELECT: %v", err) logging.FatalfLog("Redis.SELECT: %v", err)
return nil, err return nil, err
} }
return c, nil return c, nil
@ -91,11 +92,11 @@ func (r *RedisClient) loopRead() {
if len(it.Key) > 0 { if len(it.Key) > 0 {
if len(it.Field) > 0 { if len(it.Field) > 0 {
if _, err := r.HSET(it.Key, it.Field, it.Value); err != nil { if _, err := r.HSET(it.Key, it.Field, it.Value); err != nil {
common.DebugLogf("[%s, %s, %s]: %s\n", it.Key, it.Field, it.Value, err.Error()) logging.DebugLogf("[%s, %s, %s]: %s\n", it.Key, it.Field, it.Value, err.Error())
} }
} else { } else {
if _, err := r.SET(it.Key, it.Value); err != nil { if _, err := r.SET(it.Key, it.Value); err != nil {
common.DebugLogf("[%s, %s, %s]: %s\n", it.Key, it.Field, it.Value, err.Error()) logging.DebugLogf("[%s, %s, %s]: %s\n", it.Key, it.Field, it.Value, err.Error())
} }
} }
if it.Expire > 0 { if it.Expire > 0 {

43
pkg/util/my_util.go
View File

@ -1,5 +1,10 @@
package util package util
import (
"cutego/pkg/logging"
"encoding/json"
)
// IF 三元表达式 // IF 三元表达式
func IF(condition bool, trueValue interface{}, falseValue interface{}) interface{} { func IF(condition bool, trueValue interface{}, falseValue interface{}) interface{} {
if condition { if condition {
@ -7,3 +12,41 @@ func IF(condition bool, trueValue interface{}, falseValue interface{}) interface
} }
return falseValue return falseValue
} }
// 结构体、Map等转Json字符串
// @Param v interface{}
// @Return Json字符串
func StructToJson(v interface{}) string {
jsonBytes, err := json.Marshal(&v)
if err != nil {
logging.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.([]dataobject.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 {
logging.ErrorLog(err)
return nil
}
//common.DebugLogf("JsonToStruct, obj=%v", s)
return s
}

4
pkg/util/struct_util.go
View File

@ -2,7 +2,7 @@ package util
import ( import (
"bytes" "bytes"
"cutego/pkg/common" "cutego/pkg/logging"
"encoding/gob" "encoding/gob"
) )
@ -21,7 +21,7 @@ func DeepCopy(src, dst interface{}) interface{} {
} }
err := gob.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dst) err := gob.NewDecoder(bytes.NewBuffer(buf.Bytes())).Decode(dst)
if err != nil { if err != nil {
common.ErrorLogf("src(%v)---> dst(%v), error", src, dst) logging.ErrorLogf("src(%v)---> dst(%v), error", src, dst)
} }
return dst return dst
} }

6
pkg/util/token_util.go
View File

@ -3,9 +3,9 @@ package util
import ( import (
"cutego/modules/core/api/v1/response" "cutego/modules/core/api/v1/response"
"cutego/modules/core/dataobject" "cutego/modules/core/dataobject"
"cutego/pkg/common"
"cutego/pkg/config" "cutego/pkg/config"
"cutego/pkg/jwt" "cutego/pkg/jwt"
"cutego/pkg/logging"
"cutego/refs" "cutego/refs"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"strings" "strings"
@ -21,7 +21,7 @@ func GetUserInfo(c *gin.Context) *response.UserResponse {
// parseToken 解析token包含的信息 // parseToken 解析token包含的信息
claims, err := jwt.ParseToken(s[1]) claims, err := jwt.ParseToken(s[1])
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
} }
info := claims.UserInfo info := claims.UserInfo
return &info return &info
@ -34,7 +34,7 @@ func CheckLockToken(c *gin.Context) bool {
info := GetUserInfo(c) info := GetUserInfo(c)
get, err := refs.RedisDB.GET(info.UserName) get, err := refs.RedisDB.GET(info.UserName)
if err != nil { if err != nil {
common.ErrorLog(err) logging.ErrorLog(err)
return false return false
} }
token := c.Request.Header.Get(config.AppEnvConfig.Jwt.Header) token := c.Request.Header.Get(config.AppEnvConfig.Jwt.Header)

12
pkg/websocket/index.go
View File

@ -1,7 +1,7 @@
package websocket package websocket
import ( import (
"cutego/pkg/common" "cutego/pkg/logging"
"github.com/gin-gonic/gin" "github.com/gin-gonic/gin"
"github.com/gorilla/websocket" "github.com/gorilla/websocket"
"net/http" "net/http"
@ -12,16 +12,16 @@ import (
// var ws = new WebSocket("ws://127.0.0.1:21366/websocket?user=admin&code=notice"); // var ws = new WebSocket("ws://127.0.0.1:21366/websocket?user=admin&code=notice");
// // 连接打开时触发 // // 连接打开时触发
// ws.onopen = function(evt) { // ws.onopen = function(evt) {
// console.log("Connection open ..."); // console.logging("Connection open ...");
// ws.send("Hello WebSockets!"); // ws.send("Hello WebSockets!");
// }; // };
// // 接收到消息时触发 // // 接收到消息时触发
// ws.onmessage = function(evt) { // ws.onmessage = function(evt) {
// console.log("Received Message: " + evt.data); // console.logging("Received Message: " + evt.data);
// }; // };
// // 连接关闭时触发 // // 连接关闭时触发
// ws.onclose = function(evt) { // ws.onclose = function(evt) {
// console.log("Connection closed."); // console.logging("Connection closed.");
// }; // };
// </script> // </script>
@ -69,8 +69,8 @@ func HandleWebSocketMessage(c *gin.Context) {
// 回调函数的具体实现 // 回调函数的具体实现
func HandleAdminNotice(messageType int, content []byte) error { func HandleAdminNotice(messageType int, content []byte) error {
common.InfoLog("messageType=%d\n", messageType) logging.InfoLog("messageType=%d\n", messageType)
common.InfoLog("content=%s\n", string(content)) logging.InfoLog("content=%s\n", string(content))
return nil return nil
} }

10
refs/database.go
View File

@ -1,8 +1,8 @@
package refs package refs
import ( import (
"cutego/pkg/common"
"cutego/pkg/config" "cutego/pkg/config"
"cutego/pkg/logging"
"fmt" "fmt"
_ "github.com/go-sql-driver/mysql" _ "github.com/go-sql-driver/mysql"
"github.com/go-xorm/xorm" "github.com/go-xorm/xorm"
@ -11,6 +11,7 @@ import (
// 配置数据库 // 配置数据库
func init() { func init() {
logging.InfoLog("database init start...")
var err error var err error
// 配置mysql数据库 // 配置mysql数据库
ds := config.AppEnvConfig.DataSource ds := config.AppEnvConfig.DataSource
@ -23,11 +24,11 @@ func init() {
ds.Charset) ds.Charset)
SqlDB, err = xorm.NewEngine(ds.DbType, jdbc) SqlDB, err = xorm.NewEngine(ds.DbType, jdbc)
if err != nil { if err != nil {
common.FatalfLog("db error: %#v\n", err.Error()) logging.FatalfLog("db error: %#v\n", err.Error())
} }
err = SqlDB.Ping() err = SqlDB.Ping()
if err != nil { if err != nil {
common.FatalfLog("db connect error: %#v\n", err.Error()) logging.FatalfLog("db connect error: %#v\n", err.Error())
} }
SqlDB.SetMaxIdleConns(ds.MaxIdleSize) SqlDB.SetMaxIdleConns(ds.MaxIdleSize)
SqlDB.SetMaxOpenConns(ds.MaxOpenSize) SqlDB.SetMaxOpenConns(ds.MaxOpenSize)
@ -36,11 +37,12 @@ func init() {
for _ = range timer.C { for _ = range timer.C {
err = x.Ping() err = x.Ping()
if err != nil { if err != nil {
common.FatalfLog("db connect error: %#v\n", err.Error()) logging.FatalfLog("db connect error: %#v\n", err.Error())
} }
} }
}(SqlDB) }(SqlDB)
SqlDB.ShowSQL(true) SqlDB.ShowSQL(true)
// 开启缓存 // 开启缓存
SqlDB.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000)) SqlDB.SetDefaultCacher(xorm.NewLRUCacher(xorm.NewMemoryStore(), 1000))
logging.InfoLog("database init end...")
} }

7
refs/redis.go
View File

@ -1,8 +1,13 @@
package refs package refs
import redisTool "cutego/pkg/redispool" import (
"cutego/pkg/logging"
redisTool "cutego/pkg/redispool"
)
// 配置redis数据库 // 配置redis数据库
func init() { func init() {
logging.InfoLog("redis init start...")
RedisDB = redisTool.NewRedis() RedisDB = redisTool.NewRedis()
logging.InfoLog("redis init end...")
} }