magic_admin/service/daytask/dt_content.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"
)

// DtNoticeService 公告服务
type DtNoticeService struct {
	base.BizCommonService
}

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

func (s *DtNoticeService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id      *int64  `form:"id"`
		Title   *string `form:"title"`
		Type    *int8   `form:"type"`
		IsPopup *int8   `form:"isPopup"`
		IsTop   *int8   `form:"isTop"`
		Status  *int8   `form:"status"`
	}
	req := new(request[model.DtNotice])
	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.Title != nil && *req.Title != "" {
		db = db.Where("title LIKE ?", "%"+*req.Title+"%")
	}
	if req.Type != nil {
		db = db.Where("type", req.Type)
	}
	if req.IsPopup != nil {
		db = db.Where("is_popup", req.IsPopup)
	}
	if req.IsTop != nil {
		db = db.Where("is_top", req.IsTop)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("is_top DESC, sort ASC, created_at DESC")

	colInfo := s.GetColumnCommentFromStruct(model.DtNotice{})
	resp, err := base.NewQueryBaseHandler(model.NewDtNotice()).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 *DtNoticeService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtNotice()).Create(c, s.DB())
}

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

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

// DtBannerService Banner服务
type DtBannerService struct {
	base.BizCommonService
}

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

func (s *DtBannerService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id       *int64  `form:"id"`
		Title    *string `form:"title"`
		Position *string `form:"position"`
		Status   *int8   `form:"status"`
	}
	req := new(request[model.DtBanner])
	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.Title != nil && *req.Title != "" {
		db = db.Where("title LIKE ?", "%"+*req.Title+"%")
	}
	if req.Position != nil && *req.Position != "" {
		db = db.Where("position", req.Position)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtBanner{})
	resp, err := base.NewQueryBaseHandler(model.NewDtBanner()).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 *DtBannerService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtBanner()).Create(c, s.DB())
}

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

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

// DtHelpCategoryService 帮助分类服务
type DtHelpCategoryService struct {
	base.BizCommonService
}

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

func (s *DtHelpCategoryService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id     *int64  `form:"id"`
		Name   *string `form:"name"`
		Status *int8   `form:"status"`
	}
	req := new(request[model.DtHelpCategory])
	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.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtHelpCategory{})
	resp, err := base.NewQueryBaseHandler(model.NewDtHelpCategory()).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 *DtHelpCategoryService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtHelpCategory()).Create(c, s.DB())
}

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

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

// DtHelpService 帮助中心服务
type DtHelpService struct {
	base.BizCommonService
}

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

func (s *DtHelpService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id         *int64  `form:"id"`
		CategoryId *int64  `form:"categoryId"`
		Title      *string `form:"title"`
		Status     *int8   `form:"status"`
	}
	req := new(request[model.DtHelp])
	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.CategoryId != nil && *req.CategoryId != 0 {
		db = db.Where("category_id", req.CategoryId)
	}
	if req.Title != nil && *req.Title != "" {
		db = db.Where("title LIKE ?", "%"+*req.Title+"%")
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtHelp{})
	resp, err := base.NewQueryBaseHandler(model.NewDtHelp()).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 *DtHelpService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtHelp()).Create(c, s.DB())
}

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

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

// DtCustomerServiceService 客服配置服务
type DtCustomerServiceService struct {
	base.BizCommonService
}

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

func (s *DtCustomerServiceService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id     *int64  `form:"id"`
		Name   *string `form:"name"`
		Type   *string `form:"type"`
		Status *int8   `form:"status"`
	}
	req := new(request[model.DtCustomerService])
	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.Type != nil && *req.Type != "" {
		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.DtCustomerService{})
	resp, err := base.NewQueryBaseHandler(model.NewDtCustomerService()).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 *DtCustomerServiceService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtCustomerService()).Create(c, s.DB())
}

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

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