magic_admin/service/daytask/dt_system.go

package daytask

import (
	model "go_server/model/biz_modules/daytask"
	"go_server/model/common/response"
	"go_server/service/base"

	"github.com/gin-gonic/gin"
)

// DtAdminService 管理员服务
type DtAdminService struct {
	base.BizCommonService
}

func (s *DtAdminService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtAdmin()).Get(c, s.DB())
}

func (s *DtAdminService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id       *int64  `form:"id"`
		Username *string `form:"username"`
		Nickname *string `form:"nickname"`
		RoleId   *int64  `form:"roleId"`
		Status   *int8   `form:"status"`
	}
	req := new(request[model.DtAdmin])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.Username != nil && *req.Username != "" {
		db = db.Where("username LIKE ?", "%"+*req.Username+"%")
	}
	if req.Nickname != nil && *req.Nickname != "" {
		db = db.Where("nickname LIKE ?", "%"+*req.Nickname+"%")
	}
	if req.RoleId != nil && *req.RoleId != 0 {
		db = db.Where("role_id", req.RoleId)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtAdmin{})
	resp, err := base.NewQueryBaseHandler(model.NewDtAdmin()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtAdminService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtAdmin()).Create(c, s.DB())
}

func (s *DtAdminService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtAdmin()).UpdateOne(c, s.DB())
}

func (s *DtAdminService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtAdmin()).DeleteOne(c, s.DB())
}

// DtRoleService 角色服务
type DtRoleService struct {
	base.BizCommonService
}

func (s *DtRoleService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtRole()).Get(c, s.DB())
}

func (s *DtRoleService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id     *int64  `form:"id"`
		Name   *string `form:"name"`
		Code   *string `form:"code"`
		Status *int8   `form:"status"`
	}
	req := new(request[model.DtRole])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.Name != nil && *req.Name != "" {
		db = db.Where("name LIKE ?", "%"+*req.Name+"%")
	}
	if req.Code != nil && *req.Code != "" {
		db = db.Where("code", req.Code)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtRole{})
	resp, err := base.NewQueryBaseHandler(model.NewDtRole()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtRoleService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtRole()).Create(c, s.DB())
}

func (s *DtRoleService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtRole()).UpdateOne(c, s.DB())
}

func (s *DtRoleService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtRole()).DeleteOne(c, s.DB())
}

// DtMenuService 菜单服务
type DtMenuService struct {
	base.BizCommonService
}

func (s *DtMenuService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtMenu()).Get(c, s.DB())
}

func (s *DtMenuService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id       *int64  `form:"id"`
		ParentId *int64  `form:"parentId"`
		Name     *string `form:"name"`
		Type     *int8   `form:"type"`
		Status   *int8   `form:"status"`
	}
	req := new(request[model.DtMenu])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.ParentId != nil {
		db = db.Where("parent_id", req.ParentId)
	}
	if req.Name != nil && *req.Name != "" {
		db = db.Where("name LIKE ?", "%"+*req.Name+"%")
	}
	if req.Type != nil {
		db = db.Where("type", req.Type)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtMenu{})
	resp, err := base.NewQueryBaseHandler(model.NewDtMenu()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtMenuService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtMenu()).Create(c, s.DB())
}

func (s *DtMenuService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtMenu()).UpdateOne(c, s.DB())
}

func (s *DtMenuService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtMenu()).DeleteOne(c, s.DB())
}

// DtConfigService 系统配置服务
type DtConfigService struct {
	base.BizCommonService
}

func (s *DtConfigService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtConfig()).Get(c, s.DB())
}

func (s *DtConfigService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id     *int64  `form:"id"`
		Group  *string `form:"group"`
		Key    *string `form:"key"`
		Name   *string `form:"name"`
		Status *int8   `form:"status"`
	}
	req := new(request[model.DtConfig])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.Group != nil && *req.Group != "" {
		db = db.Where("`group`", req.Group)
	}
	if req.Key != nil && *req.Key != "" {
		db = db.Where("`key`", req.Key)
	}
	if req.Name != nil && *req.Name != "" {
		db = db.Where("name LIKE ?", "%"+*req.Name+"%")
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtConfig{})
	resp, err := base.NewQueryBaseHandler(model.NewDtConfig()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtConfigService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtConfig()).Create(c, s.DB())
}

func (s *DtConfigService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	var req model.DtConfig
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	if req.Id == 0 {
		response.Resp(c, "id is zero")
		return
	}
	var existing model.DtConfig
	if err := s.DB().First(&existing, req.Id).Error; err != nil {
		response.Resp(c, err.Error())
		return
	}
	dbEx := s.DB().Model(&existing).Updates(map[string]interface{}{
		"group":       req.Group,
		"key":         req.Key,
		"value":       req.Value,
		"type":        req.Type,
		"name":        req.Name,
		"description": req.Description,
		"status":      req.Status,
		"sort":        req.Sort,
	})
	if dbEx.Error != nil {
		response.Resp(c, dbEx.Error.Error())
		return
	}
	if dbEx.RowsAffected == 0 {
		response.Resp(c, "update fail")
		return
	}
	if err := s.DB().First(&existing, req.Id).Error; err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]any{
		"info":         existing,
		"rowsAffected": dbEx.RowsAffected,
	})
}

func (s *DtConfigService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtConfig()).DeleteOne(c, s.DB())
}

// GetByGroup 按分组获取配置
func (s *DtConfigService) GetByGroup(c *gin.Context) {
	s.SetDbAlias("daytask")
	group := c.Query("group")
	if group == "" {
		response.Resp(c, "分组不能为空")
		return
	}
	var configs []model.DtConfig
	err := s.DB().Where("`group` = ?", group).Order("sort ASC").Find(&configs).Error
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, configs)
}

// DtOperationLogService 操作日志服务
type DtOperationLogService struct {
	base.BizCommonService
}

func (s *DtOperationLogService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtOperationLog()).Get(c, s.DB())
}

func (s *DtOperationLogService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		AdminId   *int64  `form:"adminId"`
		AdminName *string `form:"adminName"`
		Module    *string `form:"module"`
		Action    *string `form:"action"`
		Status    *int8   `form:"status"`
		BeginTime *int64  `form:"beginTime"`
		EndTime   *int64  `form:"endTime"`
	}
	req := new(request[model.DtOperationLog])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.AdminId != nil && *req.AdminId != 0 {
		db = db.Where("admin_id", req.AdminId)
	}
	if req.AdminName != nil && *req.AdminName != "" {
		db = db.Where("admin_name LIKE ?", "%"+*req.AdminName+"%")
	}
	if req.Module != nil && *req.Module != "" {
		db = db.Where("module", req.Module)
	}
	if req.Action != nil && *req.Action != "" {
		db = db.Where("action", req.Action)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	if req.BeginTime != nil && *req.BeginTime > 0 && req.EndTime != nil && *req.EndTime > 0 {
		db = db.Where("created_at BETWEEN ? AND ?", *req.BeginTime, *req.EndTime)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtOperationLog{})
	resp, err := base.NewQueryBaseHandler(model.NewDtOperationLog()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

// DtDailyStatsService 每日统计服务
type DtDailyStatsService struct {
	base.BizCommonService
}

func (s *DtDailyStatsService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtDailyStats()).Get(c, s.DB())
}

func (s *DtDailyStatsService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		StartDate *string `form:"startDate"`
		EndDate   *string `form:"endDate"`
	}
	req := new(request[model.DtDailyStats])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.StartDate != nil && *req.StartDate != "" && req.EndDate != nil && *req.EndDate != "" {
		db = db.Where("date BETWEEN ? AND ?", *req.StartDate, *req.EndDate)
	}
	db = db.Order("date DESC")

	colInfo := s.GetColumnCommentFromStruct(model.DtDailyStats{})
	resp, err := base.NewQueryBaseHandler(model.NewDtDailyStats()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}