email

cmd/email/cmd.go

+package email

pkg/email/biz/email.go

+package biz
+
+
+
+
+import (
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"context"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+type Email struct {
+	models.Email
+	xcommon.CommonBiz[xsf.ID,models.Email, Email]
+}
+
+var EmailTool = &Email{}
+
+func (*Email) GetIDs(rs []*Email) []xsf.ID {
+	return sliceUtils.GetIDs[xsf.ID](rs)
+}
+func (x *Email) GetTplIDs(rs []*Email) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetTplID())
+	}
+	return set.Slice()
+}
+
+type EmailOpts struct {
+}
+
+
+func (Email) NewFromModel(m *models.Email) *Email {
+	if m == nil {
+		return nil
+	}
+	return &Email{
+		Email: *m,
+	}
+}
+
+func (x *Email) ToModel() *models.Email {
+	if x == nil {
+		return nil
+	}
+	return &x.Email
+}
+
+func (x Email) Valid(ctx context.Context, email *Email, opts *EmailOpts) error {
+	if email == nil {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailOpts{}
+	}
+	return nil
+}
+
+func (x Email) ValidSlice(ctx context.Context, emailBizSlice []*Email, opts *EmailOpts) error {
+	if len(emailBizSlice) == 0 {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailOpts{}
+	}
+	return nil
+}

pkg/email/biz/email_receiver.go

+package biz
+
+
+
+
+import (
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"context"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+type EmailReceiver struct {
+	models.EmailReceiver
+	xcommon.CommonBiz[xsf.ID,models.EmailReceiver, EmailReceiver]
+}
+
+var EmailReceiverTool = &EmailReceiver{}
+
+func (*EmailReceiver) GetIDs(rs []*EmailReceiver) []xsf.ID {
+	return sliceUtils.GetIDs[xsf.ID](rs)
+}
+func (x *EmailReceiver) GetEmailIDs(rs []*EmailReceiver) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetEmailID())
+	}
+	return set.Slice()
+}
+
+type EmailReceiverOpts struct {
+}
+
+
+func (EmailReceiver) NewFromModel(m *models.EmailReceiver) *EmailReceiver {
+	if m == nil {
+		return nil
+	}
+	return &EmailReceiver{
+		EmailReceiver: *m,
+	}
+}
+
+func (x *EmailReceiver) ToModel() *models.EmailReceiver {
+	if x == nil {
+		return nil
+	}
+	return &x.EmailReceiver
+}
+
+func (x EmailReceiver) Valid(ctx context.Context, emailReceiver *EmailReceiver, opts *EmailReceiverOpts) error {
+	if emailReceiver == nil {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailReceiverOpts{}
+	}
+	return nil
+}
+
+func (x EmailReceiver) ValidSlice(ctx context.Context, emailReceiverBizSlice []*EmailReceiver, opts *EmailReceiverOpts) error {
+	if len(emailReceiverBizSlice) == 0 {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailReceiverOpts{}
+	}
+	return nil
+}

pkg/email/biz/email_send.go

+package biz
+
+
+
+
+import (
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"context"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+type EmailSend struct {
+	models.EmailSend
+	xcommon.CommonBiz[xsf.ID,models.EmailSend, EmailSend]
+}
+
+var EmailSendTool = &EmailSend{}
+
+func (*EmailSend) GetIDs(rs []*EmailSend) []xsf.ID {
+	return sliceUtils.GetIDs[xsf.ID](rs)
+}
+func (x *EmailSend) GetEmailIDs(rs []*EmailSend) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetEmailID())
+	}
+	return set.Slice()
+}
+
+type EmailSendOpts struct {
+}
+
+
+func (EmailSend) NewFromModel(m *models.EmailSend) *EmailSend {
+	if m == nil {
+		return nil
+	}
+	return &EmailSend{
+		EmailSend: *m,
+	}
+}
+
+func (x *EmailSend) ToModel() *models.EmailSend {
+	if x == nil {
+		return nil
+	}
+	return &x.EmailSend
+}
+
+func (x EmailSend) Valid(ctx context.Context, emailSend *EmailSend, opts *EmailSendOpts) error {
+	if emailSend == nil {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailSendOpts{}
+	}
+	return nil
+}
+
+func (x EmailSend) ValidSlice(ctx context.Context, emailSendBizSlice []*EmailSend, opts *EmailSendOpts) error {
+	if len(emailSendBizSlice) == 0 {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailSendOpts{}
+	}
+	return nil
+}

pkg/email/biz/email_send_log.go

+package biz
+
+
+
+
+import (
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"context"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+type EmailSendLog struct {
+	models.EmailSendLog
+	xcommon.CommonBiz[xsf.ID,models.EmailSendLog, EmailSendLog]
+}
+
+var EmailSendLogTool = &EmailSendLog{}
+
+func (*EmailSendLog) GetIDs(rs []*EmailSendLog) []xsf.ID {
+	return sliceUtils.GetIDs[xsf.ID](rs)
+}
+func (x *EmailSendLog) GetEmailSendIDs(rs []*EmailSendLog) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetEmailSendID())
+	}
+	return set.Slice()
+}
+
+type EmailSendLogOpts struct {
+}
+
+
+func (EmailSendLog) NewFromModel(m *models.EmailSendLog) *EmailSendLog {
+	if m == nil {
+		return nil
+	}
+	return &EmailSendLog{
+		EmailSendLog: *m,
+	}
+}
+
+func (x *EmailSendLog) ToModel() *models.EmailSendLog {
+	if x == nil {
+		return nil
+	}
+	return &x.EmailSendLog
+}
+
+func (x EmailSendLog) Valid(ctx context.Context, emailSendLog *EmailSendLog, opts *EmailSendLogOpts) error {
+	if emailSendLog == nil {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailSendLogOpts{}
+	}
+	return nil
+}
+
+func (x EmailSendLog) ValidSlice(ctx context.Context, emailSendLogBizSlice []*EmailSendLog, opts *EmailSendLogOpts) error {
+	if len(emailSendLogBizSlice) == 0 {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailSendLogOpts{}
+	}
+	return nil
+}

pkg/email/biz/email_tpl.go

+package biz
+
+
+
+
+import (
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"context"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+type EmailTpl struct {
+	models.EmailTpl
+	xcommon.CommonBiz[xsf.ID,models.EmailTpl, EmailTpl]
+}
+
+var EmailTplTool = &EmailTpl{}
+
+func (*EmailTpl) GetIDs(rs []*EmailTpl) []xsf.ID {
+	return sliceUtils.GetIDs[xsf.ID](rs)
+}
+
+type EmailTplOpts struct {
+}
+
+
+func (EmailTpl) NewFromModel(m *models.EmailTpl) *EmailTpl {
+	if m == nil {
+		return nil
+	}
+	return &EmailTpl{
+		EmailTpl: *m,
+	}
+}
+
+func (x *EmailTpl) ToModel() *models.EmailTpl {
+	if x == nil {
+		return nil
+	}
+	return &x.EmailTpl
+}
+
+func (x EmailTpl) Valid(ctx context.Context, emailTpl *EmailTpl, opts *EmailTplOpts) error {
+	if emailTpl == nil {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailTplOpts{}
+	}
+	return nil
+}
+
+func (x EmailTpl) ValidSlice(ctx context.Context, emailTplBizSlice []*EmailTpl, opts *EmailTplOpts) error {
+	if len(emailTplBizSlice) == 0 {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailTplOpts{}
+	}
+	return nil
+}

pkg/email/biz/email_tpl_receiver.go

+package biz
+
+
+
+
+import (
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"context"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+type EmailTplReceiver struct {
+	models.EmailTplReceiver
+	xcommon.CommonBiz[xsf.ID,models.EmailTplReceiver, EmailTplReceiver]
+}
+
+var EmailTplReceiverTool = &EmailTplReceiver{}
+
+func (*EmailTplReceiver) GetIDs(rs []*EmailTplReceiver) []xsf.ID {
+	return sliceUtils.GetIDs[xsf.ID](rs)
+}
+func (x *EmailTplReceiver) GetTplIDs(rs []*EmailTplReceiver) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetTplID())
+	}
+	return set.Slice()
+}
+
+type EmailTplReceiverOpts struct {
+}
+
+
+func (EmailTplReceiver) NewFromModel(m *models.EmailTplReceiver) *EmailTplReceiver {
+	if m == nil {
+		return nil
+	}
+	return &EmailTplReceiver{
+		EmailTplReceiver: *m,
+	}
+}
+
+func (x *EmailTplReceiver) ToModel() *models.EmailTplReceiver {
+	if x == nil {
+		return nil
+	}
+	return &x.EmailTplReceiver
+}
+
+func (x EmailTplReceiver) Valid(ctx context.Context, emailTplReceiver *EmailTplReceiver, opts *EmailTplReceiverOpts) error {
+	if emailTplReceiver == nil {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailTplReceiverOpts{}
+	}
+	return nil
+}
+
+func (x EmailTplReceiver) ValidSlice(ctx context.Context, emailTplReceiverBizSlice []*EmailTplReceiver, opts *EmailTplReceiverOpts) error {
+	if len(emailTplReceiverBizSlice) == 0 {
+		return nil
+	}
+	if opts == nil {
+		opts = &EmailTplReceiverOpts{}
+	}
+	return nil
+}

pkg/email/cache/email.go

+package cache
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/ocache"
+	"operator-qt/internal/modules/operator/models"
+)
+
+const (
+	emailCachePrefixKey = prefix + "email:"
+)
+
+type EmailCache ocache.OCache[models.Email]
+
+func NewEmailCache(cacheType string) *ocache.OCache[models.Email] {
+	return ocache.NewCache[models.Email](cacheType, emailCachePrefixKey, ocache.DefaultExpireTime)
+}
\ No newline at end of file

pkg/email/cache/email_receiver.go

+package cache
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/ocache"
+	"operator-qt/internal/modules/operator/models"
+)
+
+const (
+	emailReceiverCachePrefixKey = prefix + "emailReceiver:"
+)
+
+type EmailReceiverCache ocache.OCache[models.EmailReceiver]
+
+func NewEmailReceiverCache(cacheType string) *ocache.OCache[models.EmailReceiver] {
+	return ocache.NewCache[models.EmailReceiver](cacheType, emailReceiverCachePrefixKey, ocache.DefaultExpireTime)
+}
\ No newline at end of file

pkg/email/cache/email_send.go

+package cache
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/ocache"
+	"operator-qt/internal/modules/operator/models"
+)
+
+const (
+	emailSendCachePrefixKey = prefix + "emailSend:"
+)
+
+type EmailSendCache ocache.OCache[models.EmailSend]
+
+func NewEmailSendCache(cacheType string) *ocache.OCache[models.EmailSend] {
+	return ocache.NewCache[models.EmailSend](cacheType, emailSendCachePrefixKey, ocache.DefaultExpireTime)
+}
\ No newline at end of file

pkg/email/cache/email_send_log.go

+package cache
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/ocache"
+	"operator-qt/internal/modules/operator/models"
+)
+
+const (
+	emailSendLogCachePrefixKey = prefix + "emailSendLog:"
+)
+
+type EmailSendLogCache ocache.OCache[models.EmailSendLog]
+
+func NewEmailSendLogCache(cacheType string) *ocache.OCache[models.EmailSendLog] {
+	return ocache.NewCache[models.EmailSendLog](cacheType, emailSendLogCachePrefixKey, ocache.DefaultExpireTime)
+}
\ No newline at end of file

pkg/email/cache/email_tpl.go

+package cache
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/ocache"
+	"operator-qt/internal/modules/operator/models"
+)
+
+const (
+	emailTplCachePrefixKey = prefix + "emailTpl:"
+)
+
+type EmailTplCache ocache.OCache[models.EmailTpl]
+
+func NewEmailTplCache(cacheType string) *ocache.OCache[models.EmailTpl] {
+	return ocache.NewCache[models.EmailTpl](cacheType, emailTplCachePrefixKey, ocache.DefaultExpireTime)
+}
\ No newline at end of file

pkg/email/cache/email_tpl_receiver.go

+package cache
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/ocache"
+	"operator-qt/internal/modules/operator/models"
+)
+
+const (
+	emailTplReceiverCachePrefixKey = prefix + "emailTplReceiver:"
+)
+
+type EmailTplReceiverCache ocache.OCache[models.EmailTplReceiver]
+
+func NewEmailTplReceiverCache(cacheType string) *ocache.OCache[models.EmailTplReceiver] {
+	return ocache.NewCache[models.EmailTplReceiver](cacheType, emailTplReceiverCachePrefixKey, ocache.DefaultExpireTime)
+}
\ No newline at end of file

pkg/email/config/var.go

+package consts
+
+var (
+	Schema string = ""
+	Prefix string = ""
+)

pkg/email/controller/email.go

+package controller
+
+
+
+import (
+	"operator-qt/internal/modules/operator/service"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/response"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/request"
+	"github.com/gin-gonic/gin"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/ctxUtils"
+)
+
+type emailController struct {
+	*xcommon.Controller
+}
+
+var EmailController = newEmailController()
+
+func newEmailController() *emailController {
+	return &emailController{
+		Controller: xcommon.NewController(),
+	}
+}
+func (x *emailController) Create(c *gin.Context) {
+	in := &types.EmailCreateReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	id, err := service.EmailService.Create(ctxUtils.WrapCtx(c), in)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, id)
+}
+func (x *emailController) DeleteByID(c *gin.Context) {
+	in:= &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailService.DeleteByID(ctxUtils.WrapCtx(c), in.ID, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailController) DeleteByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailService.DeleteByIDs(ctxUtils.WrapCtx(c), in.IDs, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailController) UpdateByID(c *gin.Context) {
+	in := &types.EmailUpdateByIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailService.UpdateByID(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailController) UpdateByIDs(c *gin.Context) {
+	in := &types.EmailUpdateByIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailService.UpdateByIDs(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+// GetByID 
+// @Summary 查询邮件详情
+// @Description 通过id查询邮件详情,参数id必填
+// @Tags 麒兔运营商中台/athena服务/邮件
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body request.BaseIDReq true "id "
+// @Success 200 {object} response.BaseReply{data=types.EmailObjDetail}
+// @Router /qituAdmin/athena/api/v1/email/getByID [post]
+// @Security BearerAuth
+func (x *emailController) GetByID(c *gin.Context) {
+	in := &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	email, err := service.EmailService.GetByID(ctxUtils.WrapCtx(c),in.ID, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailObjDetailTool.NewFromBiz(email)
+	response.Success(c, data)
+}
+func (x *emailController) GetByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emails, err := service.EmailService.GetSliceByIDs(ctxUtils.WrapCtx(c), in.IDs, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailObjDetailTool.NewSliceFromBizSlice(emails)
+	response.SuccessWithList(c, data)
+}
+// Page
+// @Summary 分页查询邮件
+// @Description 分页查询邮件
+// @Tags 麒兔运营商中台/athena服务/邮件
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailPageReq true "query parameters"
+// @Success 200 {object} response.BaseReply{data=response.BasePageReply{list=[]types.EmailObjDetail}}
+// @Router /qituAdmin/athena/api/v1/email/page [post]
+// @Security BearerAuth
+func (x *emailController) Page(c *gin.Context) {
+	in := &types.EmailPageReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emails, total, err := service.EmailService.Page(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailObjDetailTool.NewSliceFromBizSlice(emails)
+	response.SuccessWithPage(c, data, total)
+}
+// ExportCSV
+// @Summary 导出csv
+// @Description 导出csv
+// @Tags 麒兔运营商中台/athena服务/邮件
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailExportReq true "export parameters"
+// @Success 200 {object} response.BaseReply{data=string}
+// @Router /qituAdmin/athena/api/v1/email/export/csv [post]
+// @Security BearerAuth
+func (x *emailController) ExportCSV(c *gin.Context) {
+	in := &types.EmailExportReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	url, err := service.EmailService.ExportCSV(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, url)
+}

pkg/email/controller/email_receiver.go

+package controller
+
+
+
+import (
+	"operator-qt/internal/modules/operator/service"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/response"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/request"
+	"github.com/gin-gonic/gin"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/ctxUtils"
+)
+
+type emailReceiverController struct {
+	*xcommon.Controller
+}
+
+var EmailReceiverController = newEmailReceiverController()
+
+func newEmailReceiverController() *emailReceiverController {
+	return &emailReceiverController{
+		Controller: xcommon.NewController(),
+	}
+}
+func (x *emailReceiverController) Create(c *gin.Context) {
+	in := &types.EmailReceiverCreateReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	id, err := service.EmailReceiverService.Create(ctxUtils.WrapCtx(c), in)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, id)
+}
+func (x *emailReceiverController) DeleteByID(c *gin.Context) {
+	in:= &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailReceiverService.DeleteByID(ctxUtils.WrapCtx(c), in.ID, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailReceiverController) DeleteByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailReceiverService.DeleteByIDs(ctxUtils.WrapCtx(c), in.IDs, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailReceiverController) UpdateByID(c *gin.Context) {
+	in := &types.EmailReceiverUpdateByIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailReceiverService.UpdateByID(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailReceiverController) UpdateByIDs(c *gin.Context) {
+	in := &types.EmailReceiverUpdateByIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailReceiverService.UpdateByIDs(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+// GetByID 
+// @Summary 查询邮件收件人详情
+// @Description 通过id查询邮件收件人详情,参数id必填
+// @Tags 麒兔运营商中台/athena服务/邮件收件人
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body request.BaseIDReq true "id "
+// @Success 200 {object} response.BaseReply{data=types.EmailReceiverObjDetail}
+// @Router /qituAdmin/athena/api/v1/emailReceiver/getByID [post]
+// @Security BearerAuth
+func (x *emailReceiverController) GetByID(c *gin.Context) {
+	in := &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailReceiver, err := service.EmailReceiverService.GetByID(ctxUtils.WrapCtx(c),in.ID, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailReceiverObjDetailTool.NewFromBiz(emailReceiver)
+	response.Success(c, data)
+}
+func (x *emailReceiverController) GetByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailReceivers, err := service.EmailReceiverService.GetSliceByIDs(ctxUtils.WrapCtx(c), in.IDs, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailReceiverObjDetailTool.NewSliceFromBizSlice(emailReceivers)
+	response.SuccessWithList(c, data)
+}
+// Page
+// @Summary 分页查询邮件收件人
+// @Description 分页查询邮件收件人
+// @Tags 麒兔运营商中台/athena服务/邮件收件人
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailReceiverPageReq true "query parameters"
+// @Success 200 {object} response.BaseReply{data=response.BasePageReply{list=[]types.EmailReceiverObjDetail}}
+// @Router /qituAdmin/athena/api/v1/emailReceiver/page [post]
+// @Security BearerAuth
+func (x *emailReceiverController) Page(c *gin.Context) {
+	in := &types.EmailReceiverPageReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailReceivers, total, err := service.EmailReceiverService.Page(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailReceiverObjDetailTool.NewSliceFromBizSlice(emailReceivers)
+	response.SuccessWithPage(c, data, total)
+}
+// ExportCSV
+// @Summary 导出csv
+// @Description 导出csv
+// @Tags 麒兔运营商中台/athena服务/邮件收件人
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailReceiverExportReq true "export parameters"
+// @Success 200 {object} response.BaseReply{data=string}
+// @Router /qituAdmin/athena/api/v1/emailReceiver/export/csv [post]
+// @Security BearerAuth
+func (x *emailReceiverController) ExportCSV(c *gin.Context) {
+	in := &types.EmailReceiverExportReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	url, err := service.EmailReceiverService.ExportCSV(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, url)
+}

pkg/email/controller/email_send.go

+package controller
+
+
+
+import (
+	"operator-qt/internal/modules/operator/service"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/response"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/request"
+	"github.com/gin-gonic/gin"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/ctxUtils"
+)
+
+type emailSendController struct {
+	*xcommon.Controller
+}
+
+var EmailSendController = newEmailSendController()
+
+func newEmailSendController() *emailSendController {
+	return &emailSendController{
+		Controller: xcommon.NewController(),
+	}
+}
+func (x *emailSendController) Create(c *gin.Context) {
+	in := &types.EmailSendCreateReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	id, err := service.EmailSendService.Create(ctxUtils.WrapCtx(c), in)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, id)
+}
+func (x *emailSendController) DeleteByID(c *gin.Context) {
+	in:= &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailSendService.DeleteByID(ctxUtils.WrapCtx(c), in.ID, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailSendController) DeleteByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailSendService.DeleteByIDs(ctxUtils.WrapCtx(c), in.IDs, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailSendController) UpdateByID(c *gin.Context) {
+	in := &types.EmailSendUpdateByIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailSendService.UpdateByID(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailSendController) UpdateByIDs(c *gin.Context) {
+	in := &types.EmailSendUpdateByIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailSendService.UpdateByIDs(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+// GetByID 
+// @Summary 查询邮件发送详情
+// @Description 通过id查询邮件发送详情,参数id必填
+// @Tags 麒兔运营商中台/athena服务/邮件发送
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body request.BaseIDReq true "id "
+// @Success 200 {object} response.BaseReply{data=types.EmailSendObjDetail}
+// @Router /qituAdmin/athena/api/v1/emailSend/getByID [post]
+// @Security BearerAuth
+func (x *emailSendController) GetByID(c *gin.Context) {
+	in := &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailSend, err := service.EmailSendService.GetByID(ctxUtils.WrapCtx(c),in.ID, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailSendObjDetailTool.NewFromBiz(emailSend)
+	response.Success(c, data)
+}
+func (x *emailSendController) GetByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailSends, err := service.EmailSendService.GetSliceByIDs(ctxUtils.WrapCtx(c), in.IDs, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailSendObjDetailTool.NewSliceFromBizSlice(emailSends)
+	response.SuccessWithList(c, data)
+}
+// Page
+// @Summary 分页查询邮件发送
+// @Description 分页查询邮件发送
+// @Tags 麒兔运营商中台/athena服务/邮件发送
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailSendPageReq true "query parameters"
+// @Success 200 {object} response.BaseReply{data=response.BasePageReply{list=[]types.EmailSendObjDetail}}
+// @Router /qituAdmin/athena/api/v1/emailSend/page [post]
+// @Security BearerAuth
+func (x *emailSendController) Page(c *gin.Context) {
+	in := &types.EmailSendPageReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailSends, total, err := service.EmailSendService.Page(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailSendObjDetailTool.NewSliceFromBizSlice(emailSends)
+	response.SuccessWithPage(c, data, total)
+}
+// ExportCSV
+// @Summary 导出csv
+// @Description 导出csv
+// @Tags 麒兔运营商中台/athena服务/邮件发送
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailSendExportReq true "export parameters"
+// @Success 200 {object} response.BaseReply{data=string}
+// @Router /qituAdmin/athena/api/v1/emailSend/export/csv [post]
+// @Security BearerAuth
+func (x *emailSendController) ExportCSV(c *gin.Context) {
+	in := &types.EmailSendExportReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	url, err := service.EmailSendService.ExportCSV(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, url)
+}

pkg/email/controller/email_send_log.go

+package controller
+
+
+
+import (
+	"operator-qt/internal/modules/operator/service"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/response"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/request"
+	"github.com/gin-gonic/gin"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/ctxUtils"
+)
+
+type emailSendLogController struct {
+	*xcommon.Controller
+}
+
+var EmailSendLogController = newEmailSendLogController()
+
+func newEmailSendLogController() *emailSendLogController {
+	return &emailSendLogController{
+		Controller: xcommon.NewController(),
+	}
+}
+func (x *emailSendLogController) Create(c *gin.Context) {
+	in := &types.EmailSendLogCreateReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	id, err := service.EmailSendLogService.Create(ctxUtils.WrapCtx(c), in)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, id)
+}
+func (x *emailSendLogController) DeleteByID(c *gin.Context) {
+	in:= &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailSendLogService.DeleteByID(ctxUtils.WrapCtx(c), in.ID, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailSendLogController) DeleteByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailSendLogService.DeleteByIDs(ctxUtils.WrapCtx(c), in.IDs, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailSendLogController) UpdateByID(c *gin.Context) {
+	in := &types.EmailSendLogUpdateByIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailSendLogService.UpdateByID(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailSendLogController) UpdateByIDs(c *gin.Context) {
+	in := &types.EmailSendLogUpdateByIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailSendLogService.UpdateByIDs(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+// GetByID 
+// @Summary 查询邮件发送记录详情
+// @Description 通过id查询邮件发送记录详情,参数id必填
+// @Tags 麒兔运营商中台/athena服务/邮件发送记录
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body request.BaseIDReq true "id "
+// @Success 200 {object} response.BaseReply{data=types.EmailSendLogObjDetail}
+// @Router /qituAdmin/athena/api/v1/emailSendLog/getByID [post]
+// @Security BearerAuth
+func (x *emailSendLogController) GetByID(c *gin.Context) {
+	in := &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailSendLog, err := service.EmailSendLogService.GetByID(ctxUtils.WrapCtx(c),in.ID, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailSendLogObjDetailTool.NewFromBiz(emailSendLog)
+	response.Success(c, data)
+}
+func (x *emailSendLogController) GetByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailSendLogs, err := service.EmailSendLogService.GetSliceByIDs(ctxUtils.WrapCtx(c), in.IDs, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailSendLogObjDetailTool.NewSliceFromBizSlice(emailSendLogs)
+	response.SuccessWithList(c, data)
+}
+// Page
+// @Summary 分页查询邮件发送记录
+// @Description 分页查询邮件发送记录
+// @Tags 麒兔运营商中台/athena服务/邮件发送记录
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailSendLogPageReq true "query parameters"
+// @Success 200 {object} response.BaseReply{data=response.BasePageReply{list=[]types.EmailSendLogObjDetail}}
+// @Router /qituAdmin/athena/api/v1/emailSendLog/page [post]
+// @Security BearerAuth
+func (x *emailSendLogController) Page(c *gin.Context) {
+	in := &types.EmailSendLogPageReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailSendLogs, total, err := service.EmailSendLogService.Page(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailSendLogObjDetailTool.NewSliceFromBizSlice(emailSendLogs)
+	response.SuccessWithPage(c, data, total)
+}
+// ExportCSV
+// @Summary 导出csv
+// @Description 导出csv
+// @Tags 麒兔运营商中台/athena服务/邮件发送记录
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailSendLogExportReq true "export parameters"
+// @Success 200 {object} response.BaseReply{data=string}
+// @Router /qituAdmin/athena/api/v1/emailSendLog/export/csv [post]
+// @Security BearerAuth
+func (x *emailSendLogController) ExportCSV(c *gin.Context) {
+	in := &types.EmailSendLogExportReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	url, err := service.EmailSendLogService.ExportCSV(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, url)
+}

pkg/email/controller/email_tpl.go

+package controller
+
+
+
+import (
+	"operator-qt/internal/modules/operator/service"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/response"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/request"
+	"github.com/gin-gonic/gin"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/ctxUtils"
+)
+
+type emailTplController struct {
+	*xcommon.Controller
+}
+
+var EmailTplController = newEmailTplController()
+
+func newEmailTplController() *emailTplController {
+	return &emailTplController{
+		Controller: xcommon.NewController(),
+	}
+}
+func (x *emailTplController) Create(c *gin.Context) {
+	in := &types.EmailTplCreateReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	id, err := service.EmailTplService.Create(ctxUtils.WrapCtx(c), in)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, id)
+}
+func (x *emailTplController) DeleteByID(c *gin.Context) {
+	in:= &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailTplService.DeleteByID(ctxUtils.WrapCtx(c), in.ID, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailTplController) DeleteByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailTplService.DeleteByIDs(ctxUtils.WrapCtx(c), in.IDs, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailTplController) UpdateByID(c *gin.Context) {
+	in := &types.EmailTplUpdateByIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailTplService.UpdateByID(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailTplController) UpdateByIDs(c *gin.Context) {
+	in := &types.EmailTplUpdateByIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailTplService.UpdateByIDs(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+// GetByID 
+// @Summary 查询邮件模板详情
+// @Description 通过id查询邮件模板详情,参数id必填
+// @Tags 麒兔运营商中台/athena服务/邮件模板
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body request.BaseIDReq true "id "
+// @Success 200 {object} response.BaseReply{data=types.EmailTplObjDetail}
+// @Router /qituAdmin/athena/api/v1/emailTpl/getByID [post]
+// @Security BearerAuth
+func (x *emailTplController) GetByID(c *gin.Context) {
+	in := &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailTpl, err := service.EmailTplService.GetByID(ctxUtils.WrapCtx(c),in.ID, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailTplObjDetailTool.NewFromBiz(emailTpl)
+	response.Success(c, data)
+}
+func (x *emailTplController) GetByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailTpls, err := service.EmailTplService.GetSliceByIDs(ctxUtils.WrapCtx(c), in.IDs, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailTplObjDetailTool.NewSliceFromBizSlice(emailTpls)
+	response.SuccessWithList(c, data)
+}
+// Page
+// @Summary 分页查询邮件模板
+// @Description 分页查询邮件模板
+// @Tags 麒兔运营商中台/athena服务/邮件模板
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailTplPageReq true "query parameters"
+// @Success 200 {object} response.BaseReply{data=response.BasePageReply{list=[]types.EmailTplObjDetail}}
+// @Router /qituAdmin/athena/api/v1/emailTpl/page [post]
+// @Security BearerAuth
+func (x *emailTplController) Page(c *gin.Context) {
+	in := &types.EmailTplPageReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailTpls, total, err := service.EmailTplService.Page(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailTplObjDetailTool.NewSliceFromBizSlice(emailTpls)
+	response.SuccessWithPage(c, data, total)
+}
+// ExportCSV
+// @Summary 导出csv
+// @Description 导出csv
+// @Tags 麒兔运营商中台/athena服务/邮件模板
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailTplExportReq true "export parameters"
+// @Success 200 {object} response.BaseReply{data=string}
+// @Router /qituAdmin/athena/api/v1/emailTpl/export/csv [post]
+// @Security BearerAuth
+func (x *emailTplController) ExportCSV(c *gin.Context) {
+	in := &types.EmailTplExportReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	url, err := service.EmailTplService.ExportCSV(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, url)
+}

pkg/email/controller/email_tpl_receiver.go

+package controller
+
+
+
+import (
+	"operator-qt/internal/modules/operator/service"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/response"
+	"gitlab.wanzhuangkj.com/tush/xpkg/gin/request"
+	"github.com/gin-gonic/gin"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/ctxUtils"
+)
+
+type emailTplReceiverController struct {
+	*xcommon.Controller
+}
+
+var EmailTplReceiverController = newEmailTplReceiverController()
+
+func newEmailTplReceiverController() *emailTplReceiverController {
+	return &emailTplReceiverController{
+		Controller: xcommon.NewController(),
+	}
+}
+func (x *emailTplReceiverController) Create(c *gin.Context) {
+	in := &types.EmailTplReceiverCreateReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	id, err := service.EmailTplReceiverService.Create(ctxUtils.WrapCtx(c), in)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, id)
+}
+func (x *emailTplReceiverController) DeleteByID(c *gin.Context) {
+	in:= &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailTplReceiverService.DeleteByID(ctxUtils.WrapCtx(c), in.ID, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailTplReceiverController) DeleteByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailTplReceiverService.DeleteByIDs(ctxUtils.WrapCtx(c), in.IDs, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailTplReceiverController) UpdateByID(c *gin.Context) {
+	in := &types.EmailTplReceiverUpdateByIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailTplReceiverService.UpdateByID(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+func (x *emailTplReceiverController) UpdateByIDs(c *gin.Context) {
+	in := &types.EmailTplReceiverUpdateByIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	if err := service.EmailTplReceiverService.UpdateByIDs(ctxUtils.WrapCtx(c), in, nil); err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c)
+}
+// GetByID 
+// @Summary 查询邮件模板收件人详情
+// @Description 通过id查询邮件模板收件人详情,参数id必填
+// @Tags 麒兔运营商中台/athena服务/邮件模板收件人
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body request.BaseIDReq true "id "
+// @Success 200 {object} response.BaseReply{data=types.EmailTplReceiverObjDetail}
+// @Router /qituAdmin/athena/api/v1/emailTplReceiver/getByID [post]
+// @Security BearerAuth
+func (x *emailTplReceiverController) GetByID(c *gin.Context) {
+	in := &request.BaseIDReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailTplReceiver, err := service.EmailTplReceiverService.GetByID(ctxUtils.WrapCtx(c),in.ID, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailTplReceiverObjDetailTool.NewFromBiz(emailTplReceiver)
+	response.Success(c, data)
+}
+func (x *emailTplReceiverController) GetByIDs(c *gin.Context) {
+	in := &request.BaseIDsReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailTplReceivers, err := service.EmailTplReceiverService.GetSliceByIDs(ctxUtils.WrapCtx(c), in.IDs, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailTplReceiverObjDetailTool.NewSliceFromBizSlice(emailTplReceivers)
+	response.SuccessWithList(c, data)
+}
+// Page
+// @Summary 分页查询邮件模板收件人
+// @Description 分页查询邮件模板收件人
+// @Tags 麒兔运营商中台/athena服务/邮件模板收件人
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailTplReceiverPageReq true "query parameters"
+// @Success 200 {object} response.BaseReply{data=response.BasePageReply{list=[]types.EmailTplReceiverObjDetail}}
+// @Router /qituAdmin/athena/api/v1/emailTplReceiver/page [post]
+// @Security BearerAuth
+func (x *emailTplReceiverController) Page(c *gin.Context) {
+	in := &types.EmailTplReceiverPageReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	emailTplReceivers, total, err := service.EmailTplReceiverService.Page(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	data := types.EmailTplReceiverObjDetailTool.NewSliceFromBizSlice(emailTplReceivers)
+	response.SuccessWithPage(c, data, total)
+}
+// ExportCSV
+// @Summary 导出csv
+// @Description 导出csv
+// @Tags 麒兔运营商中台/athena服务/邮件模板收件人
+// @accept json
+// @Produce json
+// @Param  X-Request-ID  header  string  true  "请求唯一ID,会在resp中以traceID返回,方便问题定位"
+// @Param data body types.EmailTplReceiverExportReq true "export parameters"
+// @Success 200 {object} response.BaseReply{data=string}
+// @Router /qituAdmin/athena/api/v1/emailTplReceiver/export/csv [post]
+// @Security BearerAuth
+func (x *emailTplReceiverController) ExportCSV(c *gin.Context) {
+	in := &types.EmailTplReceiverExportReq{}
+	if err := x.Bind(c, in); err != nil {
+		response.Error(c, err)
+		return
+	}
+	url, err := service.EmailTplReceiverService.ExportCSV(ctxUtils.WrapCtx(c), in, nil)
+	if err != nil {
+		response.Error(c, err)
+		return
+	}
+	response.Success(c, url)
+}

pkg/email/dao/email.go

+package dao
+import (
+	"context"
+	"operator-qt/internal/modules/operator/cache"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/odao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/eventbus"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/database"
+	"operator-qt/internal/consts"
+	"operator-qt/internal/global"
+)
+
+type emailDao struct {
+	*odao.ODao[models.Email]
+}
+
+var EmailDao = &emailDao{
+	ODao: odao.NewDao[models.Email](consts.Schema_operator),
+}
+
+func init() {
+	_ = global.Eb.Subscribe(eventbus.TopicCacheInitFinish, func(ctx context.Context) {
+		EmailDao.ODao.Cache = cache.NewEmailCache(database.GetCacheType())
+	})
+}
+func (x *emailDao) GetSliceByTplID(ctx context.Context, order string, tplID xsf.ID) ([]*models.Email, error) {
+	if tplID  <= 0  {
+		return nil, nil
+	}
+	return x.GetOrderSliceByWhere(ctx, order, "tpl_id = ?", tplID)
+}
+
+func (x *emailDao) GetSliceByTplIDs(ctx context.Context, order string, tplIDs []xsf.ID) ([]*models.Email, error) {
+	if len(tplIDs) == 0 {
+		return nil, nil
+	}
+	emails,err := x.GetOrderSliceByWhere(ctx, order, "tpl_id IN (?)", tplIDs)
+	if err != nil {
+		return nil, err
+	}
+	return emails, nil
+}
+
+func (x *emailDao) GetMapSliceByTplIDs(ctx context.Context,order string, tplIDs []xsf.ID) (map[xsf.ID][]*models.Email,int, error) {
+	if len(tplIDs) == 0 {
+		return nil,0, nil
+	}
+	emails,err := x.GetOrderSliceByWhere(ctx, order, "tpl_id IN (?)", tplIDs)
+	if err != nil {
+		return nil,0, err
+	}
+	itemMap := make(map[xsf.ID][]*models.Email)
+	for _, record := range emails {
+		itemMap[record.TplID] = append(itemMap[record.TplID], record)
+	}
+	return itemMap,len(emails), nil
+}

pkg/email/dao/email_receiver.go

+package dao
+import (
+	"context"
+	"operator-qt/internal/modules/operator/cache"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/odao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/eventbus"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/database"
+	"operator-qt/internal/consts"
+	"operator-qt/internal/global"
+)
+
+type emailReceiverDao struct {
+	*odao.ODao[models.EmailReceiver]
+}
+
+var EmailReceiverDao = &emailReceiverDao{
+	ODao: odao.NewDao[models.EmailReceiver](consts.Schema_operator),
+}
+
+func init() {
+	_ = global.Eb.Subscribe(eventbus.TopicCacheInitFinish, func(ctx context.Context) {
+		EmailReceiverDao.ODao.Cache = cache.NewEmailReceiverCache(database.GetCacheType())
+	})
+}
+func (x *emailReceiverDao) GetSliceByEmailID(ctx context.Context, order string, emailID xsf.ID) ([]*models.EmailReceiver, error) {
+	if emailID  <= 0  {
+		return nil, nil
+	}
+	return x.GetOrderSliceByWhere(ctx, order, "email_id = ?", emailID)
+}
+
+func (x *emailReceiverDao) GetSliceByEmailIDs(ctx context.Context, order string, emailIDs []xsf.ID) ([]*models.EmailReceiver, error) {
+	if len(emailIDs) == 0 {
+		return nil, nil
+	}
+	emailReceivers,err := x.GetOrderSliceByWhere(ctx, order, "email_id IN (?)", emailIDs)
+	if err != nil {
+		return nil, err
+	}
+	return emailReceivers, nil
+}
+
+func (x *emailReceiverDao) GetMapSliceByEmailIDs(ctx context.Context,order string, emailIDs []xsf.ID) (map[xsf.ID][]*models.EmailReceiver,int, error) {
+	if len(emailIDs) == 0 {
+		return nil,0, nil
+	}
+	emailReceivers,err := x.GetOrderSliceByWhere(ctx, order, "email_id IN (?)", emailIDs)
+	if err != nil {
+		return nil,0, err
+	}
+	itemMap := make(map[xsf.ID][]*models.EmailReceiver)
+	for _, record := range emailReceivers {
+		itemMap[record.EmailID] = append(itemMap[record.EmailID], record)
+	}
+	return itemMap,len(emailReceivers), nil
+}

pkg/email/dao/email_send.go

+package dao
+import (
+	"context"
+	"operator-qt/internal/modules/operator/cache"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/odao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/eventbus"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	"operator-qt/internal/modules/operator/models"
+	"operator-qt/internal/modules/operator/enums"
+	"gitlab.wanzhuangkj.com/tush/xpkg/database"
+	"operator-qt/internal/consts"
+	"operator-qt/internal/global"
+)
+
+type emailSendDao struct {
+	*odao.ODao[models.EmailSend]
+}
+
+var EmailSendDao = &emailSendDao{
+	ODao: odao.NewDao[models.EmailSend](consts.Schema_operator),
+}
+
+func init() {
+	_ = global.Eb.Subscribe(eventbus.TopicCacheInitFinish, func(ctx context.Context) {
+		EmailSendDao.ODao.Cache = cache.NewEmailSendCache(database.GetCacheType())
+	})
+}
+func (x *emailSendDao) GetSliceByState(ctx context.Context, order string, state enums.EmailSend_State_Enum) ([]*models.EmailSend, error) {
+	return x.GetOrderSliceByWhere(ctx, order, "state = ?", state)
+}
+
+func (x *emailSendDao) GetSliceByStates(ctx context.Context, order string, states []enums.EmailSend_State_Enum) ([]*models.EmailSend, error) {
+	if len(states) == 0{
+		return nil,nil
+	}
+	return x.GetOrderSliceByWhere(ctx, order, "state IN (?)", states)
+}
+
+func (x *emailSendDao) GetMapSliceByStates(ctx context.Context, order string, states []enums.EmailSend_State_Enum) (map[enums.EmailSend_State_Enum][]*models.EmailSend,int, error) {
+	if len(states) == 0{
+		return nil,0,nil
+	}
+	emailSends,err := x.GetOrderSliceByWhere(ctx, order, "state IN (?)", states)
+	if err != nil{
+		return nil,0,err
+	}
+	if len(emailSends) == 0{
+		return nil,0,nil
+	}
+	emailSendMapSlice := make(map[enums.EmailSend_State_Enum][]*models.EmailSend)
+	for i:=range emailSends{
+		emailSendMapSlice[emailSends[i].State] = append(emailSendMapSlice[emailSends[i].State],emailSends[i])
+	}
+	return emailSendMapSlice,len(emailSends),nil
+}
+func (x *emailSendDao) GetSliceByEmailID(ctx context.Context, order string, emailID xsf.ID) ([]*models.EmailSend, error) {
+	if emailID  <= 0  {
+		return nil, nil
+	}
+	return x.GetOrderSliceByWhere(ctx, order, "email_id = ?", emailID)
+}
+
+func (x *emailSendDao) GetSliceByEmailIDs(ctx context.Context, order string, emailIDs []xsf.ID) ([]*models.EmailSend, error) {
+	if len(emailIDs) == 0 {
+		return nil, nil
+	}
+	emailSends,err := x.GetOrderSliceByWhere(ctx, order, "email_id IN (?)", emailIDs)
+	if err != nil {
+		return nil, err
+	}
+	return emailSends, nil
+}
+
+func (x *emailSendDao) GetMapSliceByEmailIDs(ctx context.Context,order string, emailIDs []xsf.ID) (map[xsf.ID][]*models.EmailSend,int, error) {
+	if len(emailIDs) == 0 {
+		return nil,0, nil
+	}
+	emailSends,err := x.GetOrderSliceByWhere(ctx, order, "email_id IN (?)", emailIDs)
+	if err != nil {
+		return nil,0, err
+	}
+	itemMap := make(map[xsf.ID][]*models.EmailSend)
+	for _, record := range emailSends {
+		itemMap[record.EmailID] = append(itemMap[record.EmailID], record)
+	}
+	return itemMap,len(emailSends), nil
+}

pkg/email/dao/email_send_log.go

+package dao
+import (
+	"context"
+	"operator-qt/internal/modules/operator/cache"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/odao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/eventbus"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	"operator-qt/internal/modules/operator/models"
+	"operator-qt/internal/modules/operator/enums"
+	"gitlab.wanzhuangkj.com/tush/xpkg/database"
+	"operator-qt/internal/consts"
+	"operator-qt/internal/global"
+)
+
+type emailSendLogDao struct {
+	*odao.ODao[models.EmailSendLog]
+}
+
+var EmailSendLogDao = &emailSendLogDao{
+	ODao: odao.NewDao[models.EmailSendLog](consts.Schema_operator),
+}
+
+func init() {
+	_ = global.Eb.Subscribe(eventbus.TopicCacheInitFinish, func(ctx context.Context) {
+		EmailSendLogDao.ODao.Cache = cache.NewEmailSendLogCache(database.GetCacheType())
+	})
+}
+func (x *emailSendLogDao) GetSliceByState(ctx context.Context, order string, state enums.EmailSendLog_State_Enum) ([]*models.EmailSendLog, error) {
+	return x.GetOrderSliceByWhere(ctx, order, "state = ?", state)
+}
+
+func (x *emailSendLogDao) GetSliceByStates(ctx context.Context, order string, states []enums.EmailSendLog_State_Enum) ([]*models.EmailSendLog, error) {
+	if len(states) == 0{
+		return nil,nil
+	}
+	return x.GetOrderSliceByWhere(ctx, order, "state IN (?)", states)
+}
+
+func (x *emailSendLogDao) GetMapSliceByStates(ctx context.Context, order string, states []enums.EmailSendLog_State_Enum) (map[enums.EmailSendLog_State_Enum][]*models.EmailSendLog,int, error) {
+	if len(states) == 0{
+		return nil,0,nil
+	}
+	emailSendLogs,err := x.GetOrderSliceByWhere(ctx, order, "state IN (?)", states)
+	if err != nil{
+		return nil,0,err
+	}
+	if len(emailSendLogs) == 0{
+		return nil,0,nil
+	}
+	emailSendLogMapSlice := make(map[enums.EmailSendLog_State_Enum][]*models.EmailSendLog)
+	for i:=range emailSendLogs{
+		emailSendLogMapSlice[emailSendLogs[i].State] = append(emailSendLogMapSlice[emailSendLogs[i].State],emailSendLogs[i])
+	}
+	return emailSendLogMapSlice,len(emailSendLogs),nil
+}
+func (x *emailSendLogDao) GetSliceByEmailSendID(ctx context.Context, order string, emailSendID xsf.ID) ([]*models.EmailSendLog, error) {
+	if emailSendID  <= 0  {
+		return nil, nil
+	}
+	return x.GetOrderSliceByWhere(ctx, order, "email_send_id = ?", emailSendID)
+}
+
+func (x *emailSendLogDao) GetSliceByEmailSendIDs(ctx context.Context, order string, emailSendIDs []xsf.ID) ([]*models.EmailSendLog, error) {
+	if len(emailSendIDs) == 0 {
+		return nil, nil
+	}
+	emailSendLogs,err := x.GetOrderSliceByWhere(ctx, order, "email_send_id IN (?)", emailSendIDs)
+	if err != nil {
+		return nil, err
+	}
+	return emailSendLogs, nil
+}
+
+func (x *emailSendLogDao) GetMapSliceByEmailSendIDs(ctx context.Context,order string, emailSendIDs []xsf.ID) (map[xsf.ID][]*models.EmailSendLog,int, error) {
+	if len(emailSendIDs) == 0 {
+		return nil,0, nil
+	}
+	emailSendLogs,err := x.GetOrderSliceByWhere(ctx, order, "email_send_id IN (?)", emailSendIDs)
+	if err != nil {
+		return nil,0, err
+	}
+	itemMap := make(map[xsf.ID][]*models.EmailSendLog)
+	for _, record := range emailSendLogs {
+		itemMap[record.EmailSendID] = append(itemMap[record.EmailSendID], record)
+	}
+	return itemMap,len(emailSendLogs), nil
+}

pkg/email/dao/email_tpl.go

+package dao
+import (
+	"context"
+	"operator-qt/internal/modules/operator/cache"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/odao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/eventbus"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/database"
+	"operator-qt/internal/consts"
+	"operator-qt/internal/global"
+)
+
+type emailTplDao struct {
+	*odao.ODao[models.EmailTpl]
+}
+
+var EmailTplDao = &emailTplDao{
+	ODao: odao.NewDao[models.EmailTpl](consts.Schema_operator),
+}
+
+func init() {
+	_ = global.Eb.Subscribe(eventbus.TopicCacheInitFinish, func(ctx context.Context) {
+		EmailTplDao.ODao.Cache = cache.NewEmailTplCache(database.GetCacheType())
+	})
+}

pkg/email/dao/email_tpl_receiver.go

+package dao
+import (
+	"context"
+	"operator-qt/internal/modules/operator/cache"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon/odao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/eventbus"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/database"
+	"operator-qt/internal/consts"
+	"operator-qt/internal/global"
+)
+
+type emailTplReceiverDao struct {
+	*odao.ODao[models.EmailTplReceiver]
+}
+
+var EmailTplReceiverDao = &emailTplReceiverDao{
+	ODao: odao.NewDao[models.EmailTplReceiver](consts.Schema_operator),
+}
+
+func init() {
+	_ = global.Eb.Subscribe(eventbus.TopicCacheInitFinish, func(ctx context.Context) {
+		EmailTplReceiverDao.ODao.Cache = cache.NewEmailTplReceiverCache(database.GetCacheType())
+	})
+}
+func (x *emailTplReceiverDao) GetSliceByTplID(ctx context.Context, order string, tplID xsf.ID) ([]*models.EmailTplReceiver, error) {
+	if tplID  <= 0  {
+		return nil, nil
+	}
+	return x.GetOrderSliceByWhere(ctx, order, "tpl_id = ?", tplID)
+}
+
+func (x *emailTplReceiverDao) GetSliceByTplIDs(ctx context.Context, order string, tplIDs []xsf.ID) ([]*models.EmailTplReceiver, error) {
+	if len(tplIDs) == 0 {
+		return nil, nil
+	}
+	emailTplReceivers,err := x.GetOrderSliceByWhere(ctx, order, "tpl_id IN (?)", tplIDs)
+	if err != nil {
+		return nil, err
+	}
+	return emailTplReceivers, nil
+}
+
+func (x *emailTplReceiverDao) GetMapSliceByTplIDs(ctx context.Context,order string, tplIDs []xsf.ID) (map[xsf.ID][]*models.EmailTplReceiver,int, error) {
+	if len(tplIDs) == 0 {
+		return nil,0, nil
+	}
+	emailTplReceivers,err := x.GetOrderSliceByWhere(ctx, order, "tpl_id IN (?)", tplIDs)
+	if err != nil {
+		return nil,0, err
+	}
+	itemMap := make(map[xsf.ID][]*models.EmailTplReceiver)
+	for _, record := range emailTplReceivers {
+		itemMap[record.TplID] = append(itemMap[record.TplID], record)
+	}
+	return itemMap,len(emailTplReceivers), nil
+}

pkg/email/ecode/ecode.go

+package ecode

pkg/email/ecode/email_http.go

+package ecode
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/errcode"
+)
+
+// email business-level http error codes.
+// the emailNO value range is 1~100, if the same error code is used, it will cause panic.
+var (
+	EmailName     = "邮件"
+	emailBaseCode = errcode.HCode(emailNO)
+
+	ErrEmailAlreadyExists     = errcode.NewError(emailBaseCode+1, EmailName+"已存在")
+	ErrEmailCreate     = errcode.NewError(emailBaseCode+2, "创建"+EmailName+"失败")
+	ErrEmailDeleteByID = errcode.NewError(emailBaseCode+3, "通过id删除"+EmailName+"失败")
+	ErrEmailUpdateByID = errcode.NewError(emailBaseCode+4, "通过id更新"+EmailName+"失败")
+	ErrEmailGetByID    = errcode.NewError(emailBaseCode+5, "通过id查询"+EmailName+"失败")
+	ErrEmailPage       = errcode.NewError(emailBaseCode+6, "分页查询"+EmailName+"失败")
+
+	ErrEmailDeleteByIDs    = errcode.NewError(emailBaseCode+7, "通过ids删除"+EmailName+"失败")
+	ErrEmailGetSliceByCondition = errcode.NewError(emailBaseCode+8, "条件查询"+EmailName+"失败")
+	ErrEmailGetByIDs      = errcode.NewError(emailBaseCode+9, "通过ids批量查询"+EmailName+"失败")
+	ErrEmailListByLastID   = errcode.NewError(emailBaseCode+10, "通过lastID倒序查询"+EmailName+"失败")
+	ErrEmailNotFound       = errcode.NewError(emailBaseCode+11,"未查询到"+EmailName)
+	ErrEmailExport       = errcode.NewError(emailBaseCode+12,"导出"+EmailName+"失败")
+	
+	// error codes are globally unique, adding 1 to the previous error code
+)

pkg/email/ecode/email_receiver_http.go

+package ecode
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/errcode"
+)
+
+// emailReceiver business-level http error codes.
+// the emailReceiverNO value range is 1~100, if the same error code is used, it will cause panic.
+var (
+	EmailReceiverName     = "邮件收件人"
+	emailReceiverBaseCode = errcode.HCode(emailReceiverNO)
+
+	ErrEmailReceiverAlreadyExists     = errcode.NewError(emailReceiverBaseCode+1, EmailReceiverName+"已存在")
+	ErrEmailReceiverCreate     = errcode.NewError(emailReceiverBaseCode+2, "创建"+EmailReceiverName+"失败")
+	ErrEmailReceiverDeleteByID = errcode.NewError(emailReceiverBaseCode+3, "通过id删除"+EmailReceiverName+"失败")
+	ErrEmailReceiverUpdateByID = errcode.NewError(emailReceiverBaseCode+4, "通过id更新"+EmailReceiverName+"失败")
+	ErrEmailReceiverGetByID    = errcode.NewError(emailReceiverBaseCode+5, "通过id查询"+EmailReceiverName+"失败")
+	ErrEmailReceiverPage       = errcode.NewError(emailReceiverBaseCode+6, "分页查询"+EmailReceiverName+"失败")
+
+	ErrEmailReceiverDeleteByIDs    = errcode.NewError(emailReceiverBaseCode+7, "通过ids删除"+EmailReceiverName+"失败")
+	ErrEmailReceiverGetSliceByCondition = errcode.NewError(emailReceiverBaseCode+8, "条件查询"+EmailReceiverName+"失败")
+	ErrEmailReceiverGetByIDs      = errcode.NewError(emailReceiverBaseCode+9, "通过ids批量查询"+EmailReceiverName+"失败")
+	ErrEmailReceiverListByLastID   = errcode.NewError(emailReceiverBaseCode+10, "通过lastID倒序查询"+EmailReceiverName+"失败")
+	ErrEmailReceiverNotFound       = errcode.NewError(emailReceiverBaseCode+11,"未查询到"+EmailReceiverName)
+	ErrEmailReceiverExport       = errcode.NewError(emailReceiverBaseCode+12,"导出"+EmailReceiverName+"失败")
+	
+	// error codes are globally unique, adding 1 to the previous error code
+)

pkg/email/ecode/email_send_http.go

+package ecode
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/errcode"
+)
+
+// emailSend business-level http error codes.
+// the emailSendNO value range is 1~100, if the same error code is used, it will cause panic.
+var (
+	EmailSendName     = "邮件发送"
+	emailSendBaseCode = errcode.HCode(emailSendNO)
+
+	ErrEmailSendAlreadyExists     = errcode.NewError(emailSendBaseCode+1, EmailSendName+"已存在")
+	ErrEmailSendCreate     = errcode.NewError(emailSendBaseCode+2, "创建"+EmailSendName+"失败")
+	ErrEmailSendDeleteByID = errcode.NewError(emailSendBaseCode+3, "通过id删除"+EmailSendName+"失败")
+	ErrEmailSendUpdateByID = errcode.NewError(emailSendBaseCode+4, "通过id更新"+EmailSendName+"失败")
+	ErrEmailSendGetByID    = errcode.NewError(emailSendBaseCode+5, "通过id查询"+EmailSendName+"失败")
+	ErrEmailSendPage       = errcode.NewError(emailSendBaseCode+6, "分页查询"+EmailSendName+"失败")
+
+	ErrEmailSendDeleteByIDs    = errcode.NewError(emailSendBaseCode+7, "通过ids删除"+EmailSendName+"失败")
+	ErrEmailSendGetSliceByCondition = errcode.NewError(emailSendBaseCode+8, "条件查询"+EmailSendName+"失败")
+	ErrEmailSendGetByIDs      = errcode.NewError(emailSendBaseCode+9, "通过ids批量查询"+EmailSendName+"失败")
+	ErrEmailSendListByLastID   = errcode.NewError(emailSendBaseCode+10, "通过lastID倒序查询"+EmailSendName+"失败")
+	ErrEmailSendNotFound       = errcode.NewError(emailSendBaseCode+11,"未查询到"+EmailSendName)
+	ErrEmailSendExport       = errcode.NewError(emailSendBaseCode+12,"导出"+EmailSendName+"失败")
+	
+	// error codes are globally unique, adding 1 to the previous error code
+)

pkg/email/ecode/email_send_log_http.go

+package ecode
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/errcode"
+)
+
+// emailSendLog business-level http error codes.
+// the emailSendLogNO value range is 1~100, if the same error code is used, it will cause panic.
+var (
+	EmailSendLogName     = "邮件发送记录"
+	emailSendLogBaseCode = errcode.HCode(emailSendLogNO)
+
+	ErrEmailSendLogAlreadyExists     = errcode.NewError(emailSendLogBaseCode+1, EmailSendLogName+"已存在")
+	ErrEmailSendLogCreate     = errcode.NewError(emailSendLogBaseCode+2, "创建"+EmailSendLogName+"失败")
+	ErrEmailSendLogDeleteByID = errcode.NewError(emailSendLogBaseCode+3, "通过id删除"+EmailSendLogName+"失败")
+	ErrEmailSendLogUpdateByID = errcode.NewError(emailSendLogBaseCode+4, "通过id更新"+EmailSendLogName+"失败")
+	ErrEmailSendLogGetByID    = errcode.NewError(emailSendLogBaseCode+5, "通过id查询"+EmailSendLogName+"失败")
+	ErrEmailSendLogPage       = errcode.NewError(emailSendLogBaseCode+6, "分页查询"+EmailSendLogName+"失败")
+
+	ErrEmailSendLogDeleteByIDs    = errcode.NewError(emailSendLogBaseCode+7, "通过ids删除"+EmailSendLogName+"失败")
+	ErrEmailSendLogGetSliceByCondition = errcode.NewError(emailSendLogBaseCode+8, "条件查询"+EmailSendLogName+"失败")
+	ErrEmailSendLogGetByIDs      = errcode.NewError(emailSendLogBaseCode+9, "通过ids批量查询"+EmailSendLogName+"失败")
+	ErrEmailSendLogListByLastID   = errcode.NewError(emailSendLogBaseCode+10, "通过lastID倒序查询"+EmailSendLogName+"失败")
+	ErrEmailSendLogNotFound       = errcode.NewError(emailSendLogBaseCode+11,"未查询到"+EmailSendLogName)
+	ErrEmailSendLogExport       = errcode.NewError(emailSendLogBaseCode+12,"导出"+EmailSendLogName+"失败")
+	
+	// error codes are globally unique, adding 1 to the previous error code
+)

pkg/email/ecode/email_tpl_http.go

+package ecode
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/errcode"
+)
+
+// emailTpl business-level http error codes.
+// the emailTplNO value range is 1~100, if the same error code is used, it will cause panic.
+var (
+	EmailTplName     = "邮件模板"
+	emailTplBaseCode = errcode.HCode(emailTplNO)
+
+	ErrEmailTplAlreadyExists     = errcode.NewError(emailTplBaseCode+1, EmailTplName+"已存在")
+	ErrEmailTplCreate     = errcode.NewError(emailTplBaseCode+2, "创建"+EmailTplName+"失败")
+	ErrEmailTplDeleteByID = errcode.NewError(emailTplBaseCode+3, "通过id删除"+EmailTplName+"失败")
+	ErrEmailTplUpdateByID = errcode.NewError(emailTplBaseCode+4, "通过id更新"+EmailTplName+"失败")
+	ErrEmailTplGetByID    = errcode.NewError(emailTplBaseCode+5, "通过id查询"+EmailTplName+"失败")
+	ErrEmailTplPage       = errcode.NewError(emailTplBaseCode+6, "分页查询"+EmailTplName+"失败")
+
+	ErrEmailTplDeleteByIDs    = errcode.NewError(emailTplBaseCode+7, "通过ids删除"+EmailTplName+"失败")
+	ErrEmailTplGetSliceByCondition = errcode.NewError(emailTplBaseCode+8, "条件查询"+EmailTplName+"失败")
+	ErrEmailTplGetByIDs      = errcode.NewError(emailTplBaseCode+9, "通过ids批量查询"+EmailTplName+"失败")
+	ErrEmailTplListByLastID   = errcode.NewError(emailTplBaseCode+10, "通过lastID倒序查询"+EmailTplName+"失败")
+	ErrEmailTplNotFound       = errcode.NewError(emailTplBaseCode+11,"未查询到"+EmailTplName)
+	ErrEmailTplExport       = errcode.NewError(emailTplBaseCode+12,"导出"+EmailTplName+"失败")
+	
+	// error codes are globally unique, adding 1 to the previous error code
+)

pkg/email/ecode/email_tpl_receiver_http.go

+package ecode
+import (
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/errcode"
+)
+
+// emailTplReceiver business-level http error codes.
+// the emailTplReceiverNO value range is 1~100, if the same error code is used, it will cause panic.
+var (
+	EmailTplReceiverName     = "邮件模板收件人"
+	emailTplReceiverBaseCode = errcode.HCode(emailTplReceiverNO)
+
+	ErrEmailTplReceiverAlreadyExists     = errcode.NewError(emailTplReceiverBaseCode+1, EmailTplReceiverName+"已存在")
+	ErrEmailTplReceiverCreate     = errcode.NewError(emailTplReceiverBaseCode+2, "创建"+EmailTplReceiverName+"失败")
+	ErrEmailTplReceiverDeleteByID = errcode.NewError(emailTplReceiverBaseCode+3, "通过id删除"+EmailTplReceiverName+"失败")
+	ErrEmailTplReceiverUpdateByID = errcode.NewError(emailTplReceiverBaseCode+4, "通过id更新"+EmailTplReceiverName+"失败")
+	ErrEmailTplReceiverGetByID    = errcode.NewError(emailTplReceiverBaseCode+5, "通过id查询"+EmailTplReceiverName+"失败")
+	ErrEmailTplReceiverPage       = errcode.NewError(emailTplReceiverBaseCode+6, "分页查询"+EmailTplReceiverName+"失败")
+
+	ErrEmailTplReceiverDeleteByIDs    = errcode.NewError(emailTplReceiverBaseCode+7, "通过ids删除"+EmailTplReceiverName+"失败")
+	ErrEmailTplReceiverGetSliceByCondition = errcode.NewError(emailTplReceiverBaseCode+8, "条件查询"+EmailTplReceiverName+"失败")
+	ErrEmailTplReceiverGetByIDs      = errcode.NewError(emailTplReceiverBaseCode+9, "通过ids批量查询"+EmailTplReceiverName+"失败")
+	ErrEmailTplReceiverListByLastID   = errcode.NewError(emailTplReceiverBaseCode+10, "通过lastID倒序查询"+EmailTplReceiverName+"失败")
+	ErrEmailTplReceiverNotFound       = errcode.NewError(emailTplReceiverBaseCode+11,"未查询到"+EmailTplReceiverName)
+	ErrEmailTplReceiverExport       = errcode.NewError(emailTplReceiverBaseCode+12,"导出"+EmailTplReceiverName+"失败")
+	
+	// error codes are globally unique, adding 1 to the previous error code
+)

pkg/email/enums/email_send.go

+package enums
+
+
+func init() {
+	pdict.Add("operator_emailSend_state", EmailSend_State_Enums_Dict)
+	mdict.Add("emailSend_state", EmailSend_State_Enums_Dict)
+}
+	type EmailSend_State_Enum int8 
+	var (
+		EmailSend_State_Unknown EmailSend_State_Enum  = 0 // 未知
+		EmailSend_State_Wait EmailSend_State_Enum  = 1 // 待处理
+		EmailSend_State_Doing EmailSend_State_Enum  = 2 // 处理中
+		EmailSend_State_Success EmailSend_State_Enum  = 3 // 成功
+		EmailSend_State_Fail EmailSend_State_Enum  = 4 // 失败
+	EmailSend_State_Enums_ALL = []EmailSend_State_Enum{
+		EmailSend_State_Unknown,
+		EmailSend_State_Wait,
+		EmailSend_State_Doing,
+		EmailSend_State_Success,
+		EmailSend_State_Fail,
+	}
+	EmailSend_State_Enums_Dict = map[EmailSend_State_Enum]string{
+			EmailSend_State_Unknown: EmailSend_State_Unknown.Desc(),
+			EmailSend_State_Wait: EmailSend_State_Wait.Desc(),
+			EmailSend_State_Doing: EmailSend_State_Doing.Desc(),
+			EmailSend_State_Success: EmailSend_State_Success.Desc(),
+			EmailSend_State_Fail: EmailSend_State_Fail.Desc(),
+	}
+	)
+	func (x EmailSend_State_Enum) Desc() string {
+		desc := "未知"
+		switch x {
+		case EmailSend_State_Unknown:
+			desc = "未知"
+		case EmailSend_State_Wait:
+			desc = "待处理"
+		case EmailSend_State_Doing:
+			desc = "处理中"
+		case EmailSend_State_Success:
+			desc = "成功"
+		case EmailSend_State_Fail:
+			desc = "失败"
+		}
+		return desc
+	}

pkg/email/enums/email_send_log.go

+package enums
+
+
+func init() {
+	pdict.Add("operator_emailSendLog_state", EmailSendLog_State_Enums_Dict)
+	mdict.Add("emailSendLog_state", EmailSendLog_State_Enums_Dict)
+}
+	type EmailSendLog_State_Enum int8 
+	var (
+		EmailSendLog_State_Unknown EmailSendLog_State_Enum  = 0 // 未知
+		EmailSendLog_State_Wait EmailSendLog_State_Enum  = 1 // 待处理
+		EmailSendLog_State_Doing EmailSendLog_State_Enum  = 2 // 处理中
+		EmailSendLog_State_Success EmailSendLog_State_Enum  = 3 // 成功
+		EmailSendLog_State_Fail EmailSendLog_State_Enum  = 4 // 失败
+	EmailSendLog_State_Enums_ALL = []EmailSendLog_State_Enum{
+		EmailSendLog_State_Unknown,
+		EmailSendLog_State_Wait,
+		EmailSendLog_State_Doing,
+		EmailSendLog_State_Success,
+		EmailSendLog_State_Fail,
+	}
+	EmailSendLog_State_Enums_Dict = map[EmailSendLog_State_Enum]string{
+			EmailSendLog_State_Unknown: EmailSendLog_State_Unknown.Desc(),
+			EmailSendLog_State_Wait: EmailSendLog_State_Wait.Desc(),
+			EmailSendLog_State_Doing: EmailSendLog_State_Doing.Desc(),
+			EmailSendLog_State_Success: EmailSendLog_State_Success.Desc(),
+			EmailSendLog_State_Fail: EmailSendLog_State_Fail.Desc(),
+	}
+	)
+	func (x EmailSendLog_State_Enum) Desc() string {
+		desc := "未知"
+		switch x {
+		case EmailSendLog_State_Unknown:
+			desc = "未知"
+		case EmailSendLog_State_Wait:
+			desc = "待处理"
+		case EmailSendLog_State_Doing:
+			desc = "处理中"
+		case EmailSendLog_State_Success:
+			desc = "成功"
+		case EmailSendLog_State_Fail:
+			desc = "失败"
+		}
+		return desc
+	}

pkg/email/init.go

+package xemail

pkg/email/models/email.go

+package models
+import (
+	"gorm.io/gorm"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+//Email 邮件
+type Email struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" gorm:"column:id;type:bigint(20);primaryKey;autoIncrement;comment:主键"  example:"1" csv:"用户主键id"` //主键
+	TplID xsf.ID `json:"tplID" form:"tplID" swaggertype:"string" gorm:"column:tpl_id;type:bigint(20);comment:模板id" example:"1" csv:"模板id"` //模板id
+	From string `json:"from" form:"from"  gorm:"column:from;type:varchar(255);comment:发件人" example:"月饼<mooncake2026@163.com>" csv:"发件人"` //发件人
+	Content string `json:"content" form:"content"  gorm:"column:content;type:text;comment:邮件内容" example:"<div>hello moon! </div>" csv:"邮件内容"` //邮件内容
+    CreatedAt xtime.DateTime `json:"createdAt" form:"createdAt" gorm:"column:created_at;type:datetime;comment:创建时间" example:"2024-03-27 17:11:00" csv:"创建时间"`   //创建时间
+    UpdatedAt xtime.DateTime `json:"updatedAt" form:"updatedAt" gorm:"column:updated_at;type:datetime;comment:更新时间" example:"2024-03-27 17:11:00" csv:"更新时间"`   //更新时间
+}
+
+const TBEmail = "email"
+
+func (Email) TableName() string {
+    return TBEmail
+}
+
+func (x Email) GetID() xsf.ID{
+	return x.ID
+}
+func (x *Email) GetTplID() xsf.ID{
+	return x.TplID
+}
+func (x *Email) GetTplIDs(rs []*Email) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetTplID())
+	}
+	return set.Slice()
+}
+func (x Email) GetOrder() string{
+	return "id asc"
+}
+
+func (x *Email) BeforeCreate(tx *gorm.DB) (err error) {
+	if x.CreatedAt.IsZero() {
+		x.CreatedAt = xtime.Now()
+	}
+	return nil
+}
+
+func (x *Email) BeforeUpdate(tx *gorm.DB) (err error) {
+	if x.UpdatedAt.IsZero() {
+		x.UpdatedAt = xtime.Now()
+	}
+	return nil
+}
+
+var EmailTool = Email{}

pkg/email/models/email_receiver.go

+package models
+import (
+	"gorm.io/gorm"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+//EmailReceiver 邮件收件人
+type EmailReceiver struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" gorm:"column:id;type:bigint(20);primaryKey;autoIncrement;comment:主键"  example:"1" csv:"用户主键id"` //主键
+	EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" gorm:"column:email_id;type:bigint(20);comment:邮件id" example:"1" csv:"邮件id"` //邮件id
+	Receiver string `json:"receiver" form:"receiver"  gorm:"column:receiver;type:varchar(255);comment:收件人" example:"月饼<mooncake2026@163.com>" csv:"收件人"` //收件人
+    CreatedAt xtime.DateTime `json:"createdAt" form:"createdAt" gorm:"column:created_at;type:datetime;comment:创建时间" example:"2024-03-27 17:11:00" csv:"创建时间"`   //创建时间
+    UpdatedAt xtime.DateTime `json:"updatedAt" form:"updatedAt" gorm:"column:updated_at;type:datetime;comment:更新时间" example:"2024-03-27 17:11:00" csv:"更新时间"`   //更新时间
+}
+
+const TBEmailReceiver = "email_receiver"
+
+func (EmailReceiver) TableName() string {
+    return TBEmailReceiver
+}
+
+func (x EmailReceiver) GetID() xsf.ID{
+	return x.ID
+}
+func (x *EmailReceiver) GetEmailID() xsf.ID{
+	return x.EmailID
+}
+func (x *EmailReceiver) GetEmailIDs(rs []*EmailReceiver) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetEmailID())
+	}
+	return set.Slice()
+}
+func (x EmailReceiver) GetOrder() string{
+	return "id asc"
+}
+
+func (x *EmailReceiver) BeforeCreate(tx *gorm.DB) (err error) {
+	if x.CreatedAt.IsZero() {
+		x.CreatedAt = xtime.Now()
+	}
+	return nil
+}
+
+func (x *EmailReceiver) BeforeUpdate(tx *gorm.DB) (err error) {
+	if x.UpdatedAt.IsZero() {
+		x.UpdatedAt = xtime.Now()
+	}
+	return nil
+}
+
+var EmailReceiverTool = EmailReceiver{}

pkg/email/models/email_send.go

+package models
+import (
+	"gorm.io/gorm"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"operator-qt/internal/modules/operator/enums"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+//EmailSend 邮件发送
+type EmailSend struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" gorm:"column:id;type:bigint(20);primaryKey;autoIncrement;comment:主键"  example:"1" csv:"用户主键id"` //主键
+	EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" gorm:"column:email_id;type:bigint(20);comment:邮件id" example:"1" csv:"邮件id"` //邮件id
+    State enums.EmailSend_State_Enum `json:"state" form:"state"  gorm:"column:state;type:tinyint(4);default:1;comment:发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]" example:"1" csv:"发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]"` //发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+    CreatedAt xtime.DateTime `json:"createdAt" form:"createdAt" gorm:"column:created_at;type:datetime;comment:创建时间" example:"2024-03-27 17:11:00" csv:"创建时间"`   //创建时间
+    UpdatedAt xtime.DateTime `json:"updatedAt" form:"updatedAt" gorm:"column:updated_at;type:datetime;comment:更新时间" example:"2024-03-27 17:11:00" csv:"更新时间"`   //更新时间
+}
+
+const TBEmailSend = "email_send"
+
+func (EmailSend) TableName() string {
+    return TBEmailSend
+}
+
+func (x EmailSend) GetID() xsf.ID{
+	return x.ID
+}
+func (x *EmailSend) GetEmailID() xsf.ID{
+	return x.EmailID
+}
+func (x *EmailSend) GetEmailIDs(rs []*EmailSend) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetEmailID())
+	}
+	return set.Slice()
+}
+func (x EmailSend) GetOrder() string{
+	return "id asc"
+}
+
+func (x *EmailSend) BeforeCreate(tx *gorm.DB) (err error) {
+	if x.CreatedAt.IsZero() {
+		x.CreatedAt = xtime.Now()
+	}
+	return nil
+}
+
+func (x *EmailSend) BeforeUpdate(tx *gorm.DB) (err error) {
+	if x.UpdatedAt.IsZero() {
+		x.UpdatedAt = xtime.Now()
+	}
+	return nil
+}
+
+var EmailSendTool = EmailSend{}

pkg/email/models/email_send_log.go

+package models
+import (
+	"gorm.io/gorm"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"operator-qt/internal/modules/operator/enums"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+//EmailSendLog 邮件发送记录
+type EmailSendLog struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" gorm:"column:id;type:bigint(20);primaryKey;autoIncrement;comment:主键"  example:"1" csv:"用户主键id"` //主键
+	EmailSendID xsf.ID `json:"emailSendID" form:"emailSendID" swaggertype:"string" gorm:"column:email_send_id;type:bigint(20);comment:邮件发送id" example:"1" csv:"邮件发送id"` //邮件发送id
+    State enums.EmailSendLog_State_Enum `json:"state" form:"state"  gorm:"column:state;type:tinyint(4);default:1;comment:发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]" example:"1" csv:"发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]"` //发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+    CreatedAt xtime.DateTime `json:"createdAt" form:"createdAt" gorm:"column:created_at;type:datetime;comment:创建时间" example:"2024-03-27 17:11:00" csv:"创建时间"`   //创建时间
+    UpdatedAt xtime.DateTime `json:"updatedAt" form:"updatedAt" gorm:"column:updated_at;type:datetime;comment:更新时间" example:"2024-03-27 17:11:00" csv:"更新时间"`   //更新时间
+}
+
+const TBEmailSendLog = "email_send_log"
+
+func (EmailSendLog) TableName() string {
+    return TBEmailSendLog
+}
+
+func (x EmailSendLog) GetID() xsf.ID{
+	return x.ID
+}
+func (x *EmailSendLog) GetEmailSendID() xsf.ID{
+	return x.EmailSendID
+}
+func (x *EmailSendLog) GetEmailSendIDs(rs []*EmailSendLog) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetEmailSendID())
+	}
+	return set.Slice()
+}
+func (x EmailSendLog) GetOrder() string{
+	return "id asc"
+}
+
+func (x *EmailSendLog) BeforeCreate(tx *gorm.DB) (err error) {
+	if x.CreatedAt.IsZero() {
+		x.CreatedAt = xtime.Now()
+	}
+	return nil
+}
+
+func (x *EmailSendLog) BeforeUpdate(tx *gorm.DB) (err error) {
+	if x.UpdatedAt.IsZero() {
+		x.UpdatedAt = xtime.Now()
+	}
+	return nil
+}
+
+var EmailSendLogTool = EmailSendLog{}

pkg/email/models/email_tpl.go

+package models
+import (
+	"gorm.io/gorm"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+//EmailTpl 邮件模板
+type EmailTpl struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" gorm:"column:id;type:bigint(20);primaryKey;autoIncrement;comment:主键"  example:"1" csv:"用户主键id"` //主键
+	Code int `json:"code" form:"code"  gorm:"column:code;type:tinyint(8);comment:模板代码" example:"SMS_NOTICE" csv:"模板代码"` //模板代码
+	Tpl string `json:"tpl" form:"tpl"  gorm:"column:tpl;type:text;comment:模板" example:"<div>hello moon! </div>" csv:"模板"` //模板
+    CreatedAt xtime.DateTime `json:"createdAt" form:"createdAt" gorm:"column:created_at;type:datetime;comment:创建时间" example:"2024-03-27 17:11:00" csv:"创建时间"`   //创建时间
+    UpdatedAt xtime.DateTime `json:"updatedAt" form:"updatedAt" gorm:"column:updated_at;type:datetime;comment:更新时间" example:"2024-03-27 17:11:00" csv:"更新时间"`   //更新时间
+}
+
+const TBEmailTpl = "email_tpl"
+
+func (EmailTpl) TableName() string {
+    return TBEmailTpl
+}
+
+func (x EmailTpl) GetID() xsf.ID{
+	return x.ID
+}
+func (x EmailTpl) GetOrder() string{
+	return "id asc"
+}
+
+func (x *EmailTpl) BeforeCreate(tx *gorm.DB) (err error) {
+	if x.CreatedAt.IsZero() {
+		x.CreatedAt = xtime.Now()
+	}
+	return nil
+}
+
+func (x *EmailTpl) BeforeUpdate(tx *gorm.DB) (err error) {
+	if x.UpdatedAt.IsZero() {
+		x.UpdatedAt = xtime.Now()
+	}
+	return nil
+}
+
+var EmailTplTool = EmailTpl{}

pkg/email/models/email_tpl_receiver.go

+package models
+import (
+	"gorm.io/gorm"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/setUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+
+//EmailTplReceiver 邮件模板收件人
+type EmailTplReceiver struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" gorm:"column:id;type:bigint(20);primaryKey;autoIncrement;comment:主键"  example:"1" csv:"用户主键id"` //主键
+	TplID xsf.ID `json:"tplID" form:"tplID" swaggertype:"string" gorm:"column:tpl_id;type:bigint(20);comment:模板id" example:"1" csv:"模板id"` //模板id
+	Receiver string `json:"receiver" form:"receiver"  gorm:"column:receiver;type:varchar(255);comment:收件人" example:"月饼<mooncake2026@163.com>" csv:"收件人"` //收件人
+    CreatedAt xtime.DateTime `json:"createdAt" form:"createdAt" gorm:"column:created_at;type:datetime;comment:创建时间" example:"2024-03-27 17:11:00" csv:"创建时间"`   //创建时间
+    UpdatedAt xtime.DateTime `json:"updatedAt" form:"updatedAt" gorm:"column:updated_at;type:datetime;comment:更新时间" example:"2024-03-27 17:11:00" csv:"更新时间"`   //更新时间
+}
+
+const TBEmailTplReceiver = "email_tpl_receiver"
+
+func (EmailTplReceiver) TableName() string {
+    return TBEmailTplReceiver
+}
+
+func (x EmailTplReceiver) GetID() xsf.ID{
+	return x.ID
+}
+func (x *EmailTplReceiver) GetTplID() xsf.ID{
+	return x.TplID
+}
+func (x *EmailTplReceiver) GetTplIDs(rs []*EmailTplReceiver) []xsf.ID{
+	set := setUtils.NewSet[xsf.ID]()
+	for _, r := range rs {
+		set.Add(r.GetTplID())
+	}
+	return set.Slice()
+}
+func (x EmailTplReceiver) GetOrder() string{
+	return "id asc"
+}
+
+func (x *EmailTplReceiver) BeforeCreate(tx *gorm.DB) (err error) {
+	if x.CreatedAt.IsZero() {
+		x.CreatedAt = xtime.Now()
+	}
+	return nil
+}
+
+func (x *EmailTplReceiver) BeforeUpdate(tx *gorm.DB) (err error) {
+	if x.UpdatedAt.IsZero() {
+		x.UpdatedAt = xtime.Now()
+	}
+	return nil
+}
+
+var EmailTplReceiverTool = EmailTplReceiver{}

pkg/email/service/common.go

+package service

pkg/email/service/email.go

+package service
+import (
+	"context"
+	"operator-qt/internal/modules/operator/biz"
+	"operator-qt/internal/ecode"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"operator-qt/internal/modules/operator/dao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
+	"github.com/jinzhu/copier"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	xsfUtils "operator-qt/internal/modules/operator/utils/xsf_utils"
+	csvexporter "gitlab.wanzhuangkj.com/tush/xpkg/utils/csv_exporter"
+)
+
+type emailService struct {
+	*xcommon.Service
+	*commonService
+}
+
+var EmailService = newEmailService()
+
+func newEmailService() *emailService {
+	return &emailService{
+		Service: xcommon.NewService(),
+		commonService: newCommonService(),
+	}
+}
+
+func (x *emailService) Create(ctx context.Context, in *types.EmailCreateReq) (id xsf.ID,err error) {
+	email := &models.Email{}
+	_ = copier.Copy(email, in)
+	email.ID = xsfUtils.EmailID(ctx)
+	if err = dao.EmailDao.Create(ctx, email); err != nil {
+		return 0, err
+	}
+	return email.ID, nil
+}
+
+func (x *emailService) DeleteByID(ctx context.Context, id xsf.ID, opts *biz.EmailOpts) error {
+	if id <= 0 {
+		return nil
+	}
+	if _, err := x.ErrNotFound(ctx, id, opts); err != nil {
+		return err
+	}
+	return dao.EmailDao.DeleteByID(ctx, id)
+}
+
+func (x *emailService) DeleteByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailOpts) error {
+	if len(ids) == 0{
+		return nil
+	}
+	emails, err := x.GetSliceByIDs(ctx, ids, opts)
+	if err != nil {
+		return err
+	}
+	if err = sliceUtils.CompareSlice(ids, emails, ecode.ErrEmailNotFound); err != nil {
+		return err
+	}
+	return dao.EmailDao.DeleteByIDs(ctx, ids)
+}
+
+func (x *emailService) UpdateByID(ctx context.Context, in *types.EmailUpdateByIDReq, opts *biz.EmailOpts) error {
+	if in.ID <= 0{
+		return nil
+	}
+	if _, err := x.ErrNotFound(ctx, in.ID, opts); err != nil {
+		return err
+	}
+	emailUpd := &models.Email{}
+	_ = copier.Copy(emailUpd, in)
+	return dao.EmailDao.UpdateByID(ctx, in.ID,emailUpd)
+}
+
+func (x *emailService) UpdateByIDs(ctx context.Context, in *types.EmailUpdateByIDsReq, opts *biz.EmailOpts) error {
+	if len(in.IDs) == 0 {
+		return nil
+	}
+	emails, err := x.GetSliceByIDs(ctx, in.IDs, opts)
+	if err != nil {
+		return err
+	}
+	if err = sliceUtils.CompareSlice(in.IDs, emails, ecode.ErrEmailNotFound); err != nil {
+		return err
+	}
+	emailUpd := &models.Email{}
+	_ = copier.Copy(emailUpd, in)
+	return dao.EmailDao.UpdateByIDs(ctx, in.IDs, emailUpd)
+}
+
+
+func (x *emailService) ErrFound(ctx context.Context, id xsf.ID, opts *biz.EmailOpts) (emailBiz *biz.Email, err error) {
+	if id <= 0 {
+		return nil, nil
+	}
+	emailBiz, err = x.GetByID(ctx, id, opts)
+	if err != nil {
+		return nil, err
+	}
+	if emailBiz != nil {
+		return nil, xerror.NewC(ecode.ErrEmailAlreadyExists.ToXerror())
+	}
+	return emailBiz, nil
+}
+
+func (x *emailService) ErrNotFound(ctx context.Context, id xsf.ID, opts *biz.EmailOpts) (emailBiz *biz.Email, err error) {
+	if id <= 0 {
+		return nil, nil
+	}
+	emailBiz, err = x.GetByID(ctx, id, opts)
+	if err != nil {
+		return nil, err
+	}
+	if emailBiz == nil {
+		return nil, xerror.NewC(ecode.ErrEmailNotFound.ToXerror())
+	}
+	return emailBiz, nil
+}
+
+
+func (x *emailService) GetByID(ctx context.Context, id xsf.ID, opts *biz.EmailOpts) (emailBiz *biz.Email,err error) {
+	if id <= 0{
+		return nil,nil
+	}
+	email, err := dao.EmailDao.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if email == nil {
+		return nil, nil 
+	}
+	return x.ToBiz(ctx, email, opts)
+}
+
+func (x *emailService) GetSliceByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailOpts) ([]*biz.Email, error) {
+	if len(ids) == 0{
+		return nil, nil
+	}
+	emails, err := dao.EmailDao.GetSliceByIDs(ctx, ids)
+	if err != nil {
+		return nil, err
+	}
+	if len(emails) == 0{
+		return nil,nil
+	}
+	return x.ToSliceBiz(ctx, emails, opts)
+}
+
+func (x *emailService) GetMapByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailOpts) (map[xsf.ID]*biz.Email, error) {
+	if len(ids) == 0{
+		return nil, nil
+	}
+	emailBizSlice,err := x.GetSliceByIDs(ctx, ids, opts)
+	if err != nil{
+		return nil,err
+	}
+	if len(emailBizSlice) == 0{
+		return nil, nil 
+	}
+	emailBizIDMap := biz.EmailTool.SliceToIDMapBiz(emailBizSlice)
+	return emailBizIDMap, nil
+}
+
+func (x *emailService) Page(ctx context.Context, in *types.EmailPageReq, opts *biz.EmailOpts) ([]*biz.Email, int64, error) {
+	emails, total, err := dao.EmailDao.Page(ctx, in)
+	if err != nil {
+		return nil, 0, err
+	}
+	if len(emails) == 0{
+		return nil,total,nil
+	}
+	emailBizSlice, err := x.ToSliceBiz(ctx, emails, opts)
+	if err != nil {
+		return nil, 0, err
+	}
+	return emailBizSlice, total, nil
+}
+func (x *emailService) GetSliceByTplID(ctx context.Context, tplID xsf.ID,opts *biz.EmailOpts) ([]*biz.Email, error) {
+	if tplID ==  0{
+		return nil, nil
+	}
+	emails, err := dao.EmailDao.GetSliceByTplID(ctx, models.EmailTool.GetOrder(), tplID)
+	if err != nil {
+		return nil, err
+	}
+	if len(emails) == 0{
+		return nil, nil
+	}
+	return x.ToSliceBiz(ctx, emails, opts)
+}
+
+func (x *emailService) GetSliceByTplIDs(ctx context.Context,tplIDs []xsf.ID,opts *biz.EmailOpts) ([]*biz.Email, error) {
+	if len(tplIDs) == 0{
+		return nil, nil
+	}
+	emails, err := dao.EmailDao.GetSliceByTplIDs(ctx,models.EmailTool.GetOrder(), tplIDs)
+	if err != nil {
+		return nil, err
+	}
+	if len(emails) == 0 {
+		return nil,nil
+	}
+	return x.ToSliceBiz(ctx, emails, opts)
+}
+
+func (x *emailService) GetMapSliceByTplIDs(ctx context.Context, tplIDs []xsf.ID,opts *biz.EmailOpts) (map[xsf.ID][]*biz.Email, int, error) {
+	if len(tplIDs) == 0{
+		return nil,0, nil
+	}
+	emailBizSlice,err := x.GetSliceByTplIDs(ctx, tplIDs,opts)
+	if err != nil {
+		return nil,0, err
+	}
+	if len(emailBizSlice) == 0{
+		return nil,0, nil
+	}
+	ret := make(map[xsf.ID][]*biz.Email)
+	for _,r := range emailBizSlice {
+		ret[r.TplID] = append(ret[r.TplID],r)
+	}
+	return ret,len(emailBizSlice), nil
+}
+
+func (x *emailService) ToBiz(ctx context.Context, email *models.Email, opts *biz.EmailOpts) (emailBiz *biz.Email, err error) {
+	if email == nil {
+		return nil, nil
+	}
+	emailBiz = biz.EmailTool.NewFromModel(email)
+	if err = x.Fill(ctx, emailBiz, opts); err != nil {
+		return nil, err
+	}
+	return emailBiz, nil
+}
+
+func (x *emailService) ToSliceBiz(ctx context.Context, emails []*models.Email, opts *biz.EmailOpts) (emailBizSlice []*biz.Email, err error) {
+	if len(emails) == 0 {
+		return nil, nil
+	}
+	emailBizSlice = biz.EmailTool.NewSliceFromModelsBiz(emails)
+	if err = x.SliceFill(ctx, emailBizSlice, opts); err != nil {
+		return nil, err
+	}
+	if err = biz.EmailTool.ValidSlice(ctx, emailBizSlice, opts); err != nil {
+		return nil, err
+	}
+	return emailBizSlice, nil
+}
+
+func (x *emailService) Fill(ctx context.Context, emailBiz *biz.Email,opts *biz.EmailOpts) error {
+	if emailBiz == nil {
+		return nil
+	}
+	if opts != nil{
+	}
+	return  nil
+}
+
+func (x *emailService) SliceFill(ctx context.Context, emailBizSlice []*biz.Email,opts *biz.EmailOpts) error {
+	if len(emailBizSlice) == 0 {
+		return nil
+	}
+	if opts != nil{
+	}
+	return  nil
+}
+
+func (x *emailService) GetAll(ctx context.Context,opts *biz.EmailOpts) ( []*biz.Email, error) {
+	emails,err := dao.EmailDao.GetAll(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if len(emails) == 0{
+		return nil, nil
+	}
+	return x.ToSliceBiz(ctx, emails, opts)
+}
+func (x *emailService) ExportCSV(ctx context.Context, in *types.EmailExportReq, opts *biz.EmailOpts) (string, error) {
+	req := &types.EmailPageReq{}
+	_ = copier.Copy(req, in)
+	var total = func() (int64, error) {
+		return dao.EmailDao.GetTotal(ctx, in)
+	}
+	var page = func(offset int) ([]*biz.Email, error) {
+		rs, err := dao.EmailDao.QueryPageSlice(ctx, req, batchSize, offset)
+		if err != nil {
+			return nil, err
+		}
+		if len(rs) == 0 {
+			return nil, nil
+		}
+		bizs, err := x.ToSliceBiz(ctx, rs, opts)
+		if err != nil {
+			return nil, err
+		}
+		return bizs, nil
+	}
+	var fileURL = func() string {
+		return csvName(ctx, models.EmailTool.TableName())
+	}
+	return csvexporter.New(batchSize, total, page, fileURL).Export().Upload().URI()
+}

pkg/email/service/email_receiver.go

+package service
+import (
+	"context"
+	"operator-qt/internal/modules/operator/biz"
+	"operator-qt/internal/ecode"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"operator-qt/internal/modules/operator/dao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
+	"github.com/jinzhu/copier"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	xsfUtils "operator-qt/internal/modules/operator/utils/xsf_utils"
+	csvexporter "gitlab.wanzhuangkj.com/tush/xpkg/utils/csv_exporter"
+)
+
+type emailReceiverService struct {
+	*xcommon.Service
+	*commonService
+}
+
+var EmailReceiverService = newEmailReceiverService()
+
+func newEmailReceiverService() *emailReceiverService {
+	return &emailReceiverService{
+		Service: xcommon.NewService(),
+		commonService: newCommonService(),
+	}
+}
+
+func (x *emailReceiverService) Create(ctx context.Context, in *types.EmailReceiverCreateReq) (id xsf.ID,err error) {
+	emailReceiver := &models.EmailReceiver{}
+	_ = copier.Copy(emailReceiver, in)
+	emailReceiver.ID = xsfUtils.EmailReceiverID(ctx)
+	if err = dao.EmailReceiverDao.Create(ctx, emailReceiver); err != nil {
+		return 0, err
+	}
+	return emailReceiver.ID, nil
+}
+
+func (x *emailReceiverService) DeleteByID(ctx context.Context, id xsf.ID, opts *biz.EmailReceiverOpts) error {
+	if id <= 0 {
+		return nil
+	}
+	if _, err := x.ErrNotFound(ctx, id, opts); err != nil {
+		return err
+	}
+	return dao.EmailReceiverDao.DeleteByID(ctx, id)
+}
+
+func (x *emailReceiverService) DeleteByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailReceiverOpts) error {
+	if len(ids) == 0{
+		return nil
+	}
+	emailReceivers, err := x.GetSliceByIDs(ctx, ids, opts)
+	if err != nil {
+		return err
+	}
+	if err = sliceUtils.CompareSlice(ids, emailReceivers, ecode.ErrEmailReceiverNotFound); err != nil {
+		return err
+	}
+	return dao.EmailReceiverDao.DeleteByIDs(ctx, ids)
+}
+
+func (x *emailReceiverService) UpdateByID(ctx context.Context, in *types.EmailReceiverUpdateByIDReq, opts *biz.EmailReceiverOpts) error {
+	if in.ID <= 0{
+		return nil
+	}
+	if _, err := x.ErrNotFound(ctx, in.ID, opts); err != nil {
+		return err
+	}
+	emailReceiverUpd := &models.EmailReceiver{}
+	_ = copier.Copy(emailReceiverUpd, in)
+	return dao.EmailReceiverDao.UpdateByID(ctx, in.ID,emailReceiverUpd)
+}
+
+func (x *emailReceiverService) UpdateByIDs(ctx context.Context, in *types.EmailReceiverUpdateByIDsReq, opts *biz.EmailReceiverOpts) error {
+	if len(in.IDs) == 0 {
+		return nil
+	}
+	emailReceivers, err := x.GetSliceByIDs(ctx, in.IDs, opts)
+	if err != nil {
+		return err
+	}
+	if err = sliceUtils.CompareSlice(in.IDs, emailReceivers, ecode.ErrEmailReceiverNotFound); err != nil {
+		return err
+	}
+	emailReceiverUpd := &models.EmailReceiver{}
+	_ = copier.Copy(emailReceiverUpd, in)
+	return dao.EmailReceiverDao.UpdateByIDs(ctx, in.IDs, emailReceiverUpd)
+}
+
+
+func (x *emailReceiverService) ErrFound(ctx context.Context, id xsf.ID, opts *biz.EmailReceiverOpts) (emailReceiverBiz *biz.EmailReceiver, err error) {
+	if id <= 0 {
+		return nil, nil
+	}
+	emailReceiverBiz, err = x.GetByID(ctx, id, opts)
+	if err != nil {
+		return nil, err
+	}
+	if emailReceiverBiz != nil {
+		return nil, xerror.NewC(ecode.ErrEmailReceiverAlreadyExists.ToXerror())
+	}
+	return emailReceiverBiz, nil
+}
+
+func (x *emailReceiverService) ErrNotFound(ctx context.Context, id xsf.ID, opts *biz.EmailReceiverOpts) (emailReceiverBiz *biz.EmailReceiver, err error) {
+	if id <= 0 {
+		return nil, nil
+	}
+	emailReceiverBiz, err = x.GetByID(ctx, id, opts)
+	if err != nil {
+		return nil, err
+	}
+	if emailReceiverBiz == nil {
+		return nil, xerror.NewC(ecode.ErrEmailReceiverNotFound.ToXerror())
+	}
+	return emailReceiverBiz, nil
+}
+
+
+func (x *emailReceiverService) GetByID(ctx context.Context, id xsf.ID, opts *biz.EmailReceiverOpts) (emailReceiverBiz *biz.EmailReceiver,err error) {
+	if id <= 0{
+		return nil,nil
+	}
+	emailReceiver, err := dao.EmailReceiverDao.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if emailReceiver == nil {
+		return nil, nil 
+	}
+	return x.ToBiz(ctx, emailReceiver, opts)
+}
+
+func (x *emailReceiverService) GetSliceByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailReceiverOpts) ([]*biz.EmailReceiver, error) {
+	if len(ids) == 0{
+		return nil, nil
+	}
+	emailReceivers, err := dao.EmailReceiverDao.GetSliceByIDs(ctx, ids)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailReceivers) == 0{
+		return nil,nil
+	}
+	return x.ToSliceBiz(ctx, emailReceivers, opts)
+}
+
+func (x *emailReceiverService) GetMapByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailReceiverOpts) (map[xsf.ID]*biz.EmailReceiver, error) {
+	if len(ids) == 0{
+		return nil, nil
+	}
+	emailReceiverBizSlice,err := x.GetSliceByIDs(ctx, ids, opts)
+	if err != nil{
+		return nil,err
+	}
+	if len(emailReceiverBizSlice) == 0{
+		return nil, nil 
+	}
+	emailReceiverBizIDMap := biz.EmailReceiverTool.SliceToIDMapBiz(emailReceiverBizSlice)
+	return emailReceiverBizIDMap, nil
+}
+
+func (x *emailReceiverService) Page(ctx context.Context, in *types.EmailReceiverPageReq, opts *biz.EmailReceiverOpts) ([]*biz.EmailReceiver, int64, error) {
+	emailReceivers, total, err := dao.EmailReceiverDao.Page(ctx, in)
+	if err != nil {
+		return nil, 0, err
+	}
+	if len(emailReceivers) == 0{
+		return nil,total,nil
+	}
+	emailReceiverBizSlice, err := x.ToSliceBiz(ctx, emailReceivers, opts)
+	if err != nil {
+		return nil, 0, err
+	}
+	return emailReceiverBizSlice, total, nil
+}
+func (x *emailReceiverService) GetSliceByEmailID(ctx context.Context, emailID xsf.ID,opts *biz.EmailReceiverOpts) ([]*biz.EmailReceiver, error) {
+	if emailID ==  0{
+		return nil, nil
+	}
+	emailReceivers, err := dao.EmailReceiverDao.GetSliceByEmailID(ctx, models.EmailReceiverTool.GetOrder(), emailID)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailReceivers) == 0{
+		return nil, nil
+	}
+	return x.ToSliceBiz(ctx, emailReceivers, opts)
+}
+
+func (x *emailReceiverService) GetSliceByEmailIDs(ctx context.Context,emailIDs []xsf.ID,opts *biz.EmailReceiverOpts) ([]*biz.EmailReceiver, error) {
+	if len(emailIDs) == 0{
+		return nil, nil
+	}
+	emailReceivers, err := dao.EmailReceiverDao.GetSliceByEmailIDs(ctx,models.EmailReceiverTool.GetOrder(), emailIDs)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailReceivers) == 0 {
+		return nil,nil
+	}
+	return x.ToSliceBiz(ctx, emailReceivers, opts)
+}
+
+func (x *emailReceiverService) GetMapSliceByEmailIDs(ctx context.Context, emailIDs []xsf.ID,opts *biz.EmailReceiverOpts) (map[xsf.ID][]*biz.EmailReceiver, int, error) {
+	if len(emailIDs) == 0{
+		return nil,0, nil
+	}
+	emailReceiverBizSlice,err := x.GetSliceByEmailIDs(ctx, emailIDs,opts)
+	if err != nil {
+		return nil,0, err
+	}
+	if len(emailReceiverBizSlice) == 0{
+		return nil,0, nil
+	}
+	ret := make(map[xsf.ID][]*biz.EmailReceiver)
+	for _,r := range emailReceiverBizSlice {
+		ret[r.EmailID] = append(ret[r.EmailID],r)
+	}
+	return ret,len(emailReceiverBizSlice), nil
+}
+
+func (x *emailReceiverService) ToBiz(ctx context.Context, emailReceiver *models.EmailReceiver, opts *biz.EmailReceiverOpts) (emailReceiverBiz *biz.EmailReceiver, err error) {
+	if emailReceiver == nil {
+		return nil, nil
+	}
+	emailReceiverBiz = biz.EmailReceiverTool.NewFromModel(emailReceiver)
+	if err = x.Fill(ctx, emailReceiverBiz, opts); err != nil {
+		return nil, err
+	}
+	return emailReceiverBiz, nil
+}
+
+func (x *emailReceiverService) ToSliceBiz(ctx context.Context, emailReceivers []*models.EmailReceiver, opts *biz.EmailReceiverOpts) (emailReceiverBizSlice []*biz.EmailReceiver, err error) {
+	if len(emailReceivers) == 0 {
+		return nil, nil
+	}
+	emailReceiverBizSlice = biz.EmailReceiverTool.NewSliceFromModelsBiz(emailReceivers)
+	if err = x.SliceFill(ctx, emailReceiverBizSlice, opts); err != nil {
+		return nil, err
+	}
+	if err = biz.EmailReceiverTool.ValidSlice(ctx, emailReceiverBizSlice, opts); err != nil {
+		return nil, err
+	}
+	return emailReceiverBizSlice, nil
+}
+
+func (x *emailReceiverService) Fill(ctx context.Context, emailReceiverBiz *biz.EmailReceiver,opts *biz.EmailReceiverOpts) error {
+	if emailReceiverBiz == nil {
+		return nil
+	}
+	if opts != nil{
+	}
+	return  nil
+}
+
+func (x *emailReceiverService) SliceFill(ctx context.Context, emailReceiverBizSlice []*biz.EmailReceiver,opts *biz.EmailReceiverOpts) error {
+	if len(emailReceiverBizSlice) == 0 {
+		return nil
+	}
+	if opts != nil{
+	}
+	return  nil
+}
+
+func (x *emailReceiverService) GetAll(ctx context.Context,opts *biz.EmailReceiverOpts) ( []*biz.EmailReceiver, error) {
+	emailReceivers,err := dao.EmailReceiverDao.GetAll(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailReceivers) == 0{
+		return nil, nil
+	}
+	return x.ToSliceBiz(ctx, emailReceivers, opts)
+}
+func (x *emailReceiverService) ExportCSV(ctx context.Context, in *types.EmailReceiverExportReq, opts *biz.EmailReceiverOpts) (string, error) {
+	req := &types.EmailReceiverPageReq{}
+	_ = copier.Copy(req, in)
+	var total = func() (int64, error) {
+		return dao.EmailReceiverDao.GetTotal(ctx, in)
+	}
+	var page = func(offset int) ([]*biz.EmailReceiver, error) {
+		rs, err := dao.EmailReceiverDao.QueryPageSlice(ctx, req, batchSize, offset)
+		if err != nil {
+			return nil, err
+		}
+		if len(rs) == 0 {
+			return nil, nil
+		}
+		bizs, err := x.ToSliceBiz(ctx, rs, opts)
+		if err != nil {
+			return nil, err
+		}
+		return bizs, nil
+	}
+	var fileURL = func() string {
+		return csvName(ctx, models.EmailReceiverTool.TableName())
+	}
+	return csvexporter.New(batchSize, total, page, fileURL).Export().Upload().URI()
+}

pkg/email/service/email_tpl.go

+package service
+import (
+	"context"
+	"operator-qt/internal/modules/operator/biz"
+	"operator-qt/internal/ecode"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"operator-qt/internal/modules/operator/dao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
+	"github.com/jinzhu/copier"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	xsfUtils "operator-qt/internal/modules/operator/utils/xsf_utils"
+	csvexporter "gitlab.wanzhuangkj.com/tush/xpkg/utils/csv_exporter"
+)
+
+type emailTplService struct {
+	*xcommon.Service
+	*commonService
+}
+
+var EmailTplService = newEmailTplService()
+
+func newEmailTplService() *emailTplService {
+	return &emailTplService{
+		Service: xcommon.NewService(),
+		commonService: newCommonService(),
+	}
+}
+
+func (x *emailTplService) Create(ctx context.Context, in *types.EmailTplCreateReq) (id xsf.ID,err error) {
+	emailTpl := &models.EmailTpl{}
+	_ = copier.Copy(emailTpl, in)
+	emailTpl.ID = xsfUtils.EmailTplID(ctx)
+	if err = dao.EmailTplDao.Create(ctx, emailTpl); err != nil {
+		return 0, err
+	}
+	return emailTpl.ID, nil
+}
+
+func (x *emailTplService) DeleteByID(ctx context.Context, id xsf.ID, opts *biz.EmailTplOpts) error {
+	if id <= 0 {
+		return nil
+	}
+	if _, err := x.ErrNotFound(ctx, id, opts); err != nil {
+		return err
+	}
+	return dao.EmailTplDao.DeleteByID(ctx, id)
+}
+
+func (x *emailTplService) DeleteByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailTplOpts) error {
+	if len(ids) == 0{
+		return nil
+	}
+	emailTpls, err := x.GetSliceByIDs(ctx, ids, opts)
+	if err != nil {
+		return err
+	}
+	if err = sliceUtils.CompareSlice(ids, emailTpls, ecode.ErrEmailTplNotFound); err != nil {
+		return err
+	}
+	return dao.EmailTplDao.DeleteByIDs(ctx, ids)
+}
+
+func (x *emailTplService) UpdateByID(ctx context.Context, in *types.EmailTplUpdateByIDReq, opts *biz.EmailTplOpts) error {
+	if in.ID <= 0{
+		return nil
+	}
+	if _, err := x.ErrNotFound(ctx, in.ID, opts); err != nil {
+		return err
+	}
+	emailTplUpd := &models.EmailTpl{}
+	_ = copier.Copy(emailTplUpd, in)
+	return dao.EmailTplDao.UpdateByID(ctx, in.ID,emailTplUpd)
+}
+
+func (x *emailTplService) UpdateByIDs(ctx context.Context, in *types.EmailTplUpdateByIDsReq, opts *biz.EmailTplOpts) error {
+	if len(in.IDs) == 0 {
+		return nil
+	}
+	emailTpls, err := x.GetSliceByIDs(ctx, in.IDs, opts)
+	if err != nil {
+		return err
+	}
+	if err = sliceUtils.CompareSlice(in.IDs, emailTpls, ecode.ErrEmailTplNotFound); err != nil {
+		return err
+	}
+	emailTplUpd := &models.EmailTpl{}
+	_ = copier.Copy(emailTplUpd, in)
+	return dao.EmailTplDao.UpdateByIDs(ctx, in.IDs, emailTplUpd)
+}
+
+
+func (x *emailTplService) ErrFound(ctx context.Context, id xsf.ID, opts *biz.EmailTplOpts) (emailTplBiz *biz.EmailTpl, err error) {
+	if id <= 0 {
+		return nil, nil
+	}
+	emailTplBiz, err = x.GetByID(ctx, id, opts)
+	if err != nil {
+		return nil, err
+	}
+	if emailTplBiz != nil {
+		return nil, xerror.NewC(ecode.ErrEmailTplAlreadyExists.ToXerror())
+	}
+	return emailTplBiz, nil
+}
+
+func (x *emailTplService) ErrNotFound(ctx context.Context, id xsf.ID, opts *biz.EmailTplOpts) (emailTplBiz *biz.EmailTpl, err error) {
+	if id <= 0 {
+		return nil, nil
+	}
+	emailTplBiz, err = x.GetByID(ctx, id, opts)
+	if err != nil {
+		return nil, err
+	}
+	if emailTplBiz == nil {
+		return nil, xerror.NewC(ecode.ErrEmailTplNotFound.ToXerror())
+	}
+	return emailTplBiz, nil
+}
+
+
+func (x *emailTplService) GetByID(ctx context.Context, id xsf.ID, opts *biz.EmailTplOpts) (emailTplBiz *biz.EmailTpl,err error) {
+	if id <= 0{
+		return nil,nil
+	}
+	emailTpl, err := dao.EmailTplDao.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if emailTpl == nil {
+		return nil, nil 
+	}
+	return x.ToBiz(ctx, emailTpl, opts)
+}
+
+func (x *emailTplService) GetSliceByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailTplOpts) ([]*biz.EmailTpl, error) {
+	if len(ids) == 0{
+		return nil, nil
+	}
+	emailTpls, err := dao.EmailTplDao.GetSliceByIDs(ctx, ids)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailTpls) == 0{
+		return nil,nil
+	}
+	return x.ToSliceBiz(ctx, emailTpls, opts)
+}
+
+func (x *emailTplService) GetMapByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailTplOpts) (map[xsf.ID]*biz.EmailTpl, error) {
+	if len(ids) == 0{
+		return nil, nil
+	}
+	emailTplBizSlice,err := x.GetSliceByIDs(ctx, ids, opts)
+	if err != nil{
+		return nil,err
+	}
+	if len(emailTplBizSlice) == 0{
+		return nil, nil 
+	}
+	emailTplBizIDMap := biz.EmailTplTool.SliceToIDMapBiz(emailTplBizSlice)
+	return emailTplBizIDMap, nil
+}
+
+func (x *emailTplService) Page(ctx context.Context, in *types.EmailTplPageReq, opts *biz.EmailTplOpts) ([]*biz.EmailTpl, int64, error) {
+	emailTpls, total, err := dao.EmailTplDao.Page(ctx, in)
+	if err != nil {
+		return nil, 0, err
+	}
+	if len(emailTpls) == 0{
+		return nil,total,nil
+	}
+	emailTplBizSlice, err := x.ToSliceBiz(ctx, emailTpls, opts)
+	if err != nil {
+		return nil, 0, err
+	}
+	return emailTplBizSlice, total, nil
+}
+
+func (x *emailTplService) ToBiz(ctx context.Context, emailTpl *models.EmailTpl, opts *biz.EmailTplOpts) (emailTplBiz *biz.EmailTpl, err error) {
+	if emailTpl == nil {
+		return nil, nil
+	}
+	emailTplBiz = biz.EmailTplTool.NewFromModel(emailTpl)
+	if err = x.Fill(ctx, emailTplBiz, opts); err != nil {
+		return nil, err
+	}
+	return emailTplBiz, nil
+}
+
+func (x *emailTplService) ToSliceBiz(ctx context.Context, emailTpls []*models.EmailTpl, opts *biz.EmailTplOpts) (emailTplBizSlice []*biz.EmailTpl, err error) {
+	if len(emailTpls) == 0 {
+		return nil, nil
+	}
+	emailTplBizSlice = biz.EmailTplTool.NewSliceFromModelsBiz(emailTpls)
+	if err = x.SliceFill(ctx, emailTplBizSlice, opts); err != nil {
+		return nil, err
+	}
+	if err = biz.EmailTplTool.ValidSlice(ctx, emailTplBizSlice, opts); err != nil {
+		return nil, err
+	}
+	return emailTplBizSlice, nil
+}
+
+func (x *emailTplService) Fill(ctx context.Context, emailTplBiz *biz.EmailTpl,opts *biz.EmailTplOpts) error {
+	if emailTplBiz == nil {
+		return nil
+	}
+	if opts != nil{
+	}
+	return  nil
+}
+
+func (x *emailTplService) SliceFill(ctx context.Context, emailTplBizSlice []*biz.EmailTpl,opts *biz.EmailTplOpts) error {
+	if len(emailTplBizSlice) == 0 {
+		return nil
+	}
+	if opts != nil{
+	}
+	return  nil
+}
+
+func (x *emailTplService) GetAll(ctx context.Context,opts *biz.EmailTplOpts) ( []*biz.EmailTpl, error) {
+	emailTpls,err := dao.EmailTplDao.GetAll(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailTpls) == 0{
+		return nil, nil
+	}
+	return x.ToSliceBiz(ctx, emailTpls, opts)
+}
+func (x *emailTplService) ExportCSV(ctx context.Context, in *types.EmailTplExportReq, opts *biz.EmailTplOpts) (string, error) {
+	req := &types.EmailTplPageReq{}
+	_ = copier.Copy(req, in)
+	var total = func() (int64, error) {
+		return dao.EmailTplDao.GetTotal(ctx, in)
+	}
+	var page = func(offset int) ([]*biz.EmailTpl, error) {
+		rs, err := dao.EmailTplDao.QueryPageSlice(ctx, req, batchSize, offset)
+		if err != nil {
+			return nil, err
+		}
+		if len(rs) == 0 {
+			return nil, nil
+		}
+		bizs, err := x.ToSliceBiz(ctx, rs, opts)
+		if err != nil {
+			return nil, err
+		}
+		return bizs, nil
+	}
+	var fileURL = func() string {
+		return csvName(ctx, models.EmailTplTool.TableName())
+	}
+	return csvexporter.New(batchSize, total, page, fileURL).Export().Upload().URI()
+}

pkg/email/service/email_tpl_receiver.go

+package service
+import (
+	"context"
+	"operator-qt/internal/modules/operator/biz"
+	"operator-qt/internal/ecode"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/xcommon"
+	"operator-qt/internal/modules/operator/types"
+	"operator-qt/internal/modules/operator/dao"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
+	"github.com/jinzhu/copier"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+	xsfUtils "operator-qt/internal/modules/operator/utils/xsf_utils"
+	csvexporter "gitlab.wanzhuangkj.com/tush/xpkg/utils/csv_exporter"
+)
+
+type emailTplReceiverService struct {
+	*xcommon.Service
+	*commonService
+}
+
+var EmailTplReceiverService = newEmailTplReceiverService()
+
+func newEmailTplReceiverService() *emailTplReceiverService {
+	return &emailTplReceiverService{
+		Service: xcommon.NewService(),
+		commonService: newCommonService(),
+	}
+}
+
+func (x *emailTplReceiverService) Create(ctx context.Context, in *types.EmailTplReceiverCreateReq) (id xsf.ID,err error) {
+	emailTplReceiver := &models.EmailTplReceiver{}
+	_ = copier.Copy(emailTplReceiver, in)
+	emailTplReceiver.ID = xsfUtils.EmailTplReceiverID(ctx)
+	if err = dao.EmailTplReceiverDao.Create(ctx, emailTplReceiver); err != nil {
+		return 0, err
+	}
+	return emailTplReceiver.ID, nil
+}
+
+func (x *emailTplReceiverService) DeleteByID(ctx context.Context, id xsf.ID, opts *biz.EmailTplReceiverOpts) error {
+	if id <= 0 {
+		return nil
+	}
+	if _, err := x.ErrNotFound(ctx, id, opts); err != nil {
+		return err
+	}
+	return dao.EmailTplReceiverDao.DeleteByID(ctx, id)
+}
+
+func (x *emailTplReceiverService) DeleteByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailTplReceiverOpts) error {
+	if len(ids) == 0{
+		return nil
+	}
+	emailTplReceivers, err := x.GetSliceByIDs(ctx, ids, opts)
+	if err != nil {
+		return err
+	}
+	if err = sliceUtils.CompareSlice(ids, emailTplReceivers, ecode.ErrEmailTplReceiverNotFound); err != nil {
+		return err
+	}
+	return dao.EmailTplReceiverDao.DeleteByIDs(ctx, ids)
+}
+
+func (x *emailTplReceiverService) UpdateByID(ctx context.Context, in *types.EmailTplReceiverUpdateByIDReq, opts *biz.EmailTplReceiverOpts) error {
+	if in.ID <= 0{
+		return nil
+	}
+	if _, err := x.ErrNotFound(ctx, in.ID, opts); err != nil {
+		return err
+	}
+	emailTplReceiverUpd := &models.EmailTplReceiver{}
+	_ = copier.Copy(emailTplReceiverUpd, in)
+	return dao.EmailTplReceiverDao.UpdateByID(ctx, in.ID,emailTplReceiverUpd)
+}
+
+func (x *emailTplReceiverService) UpdateByIDs(ctx context.Context, in *types.EmailTplReceiverUpdateByIDsReq, opts *biz.EmailTplReceiverOpts) error {
+	if len(in.IDs) == 0 {
+		return nil
+	}
+	emailTplReceivers, err := x.GetSliceByIDs(ctx, in.IDs, opts)
+	if err != nil {
+		return err
+	}
+	if err = sliceUtils.CompareSlice(in.IDs, emailTplReceivers, ecode.ErrEmailTplReceiverNotFound); err != nil {
+		return err
+	}
+	emailTplReceiverUpd := &models.EmailTplReceiver{}
+	_ = copier.Copy(emailTplReceiverUpd, in)
+	return dao.EmailTplReceiverDao.UpdateByIDs(ctx, in.IDs, emailTplReceiverUpd)
+}
+
+
+func (x *emailTplReceiverService) ErrFound(ctx context.Context, id xsf.ID, opts *biz.EmailTplReceiverOpts) (emailTplReceiverBiz *biz.EmailTplReceiver, err error) {
+	if id <= 0 {
+		return nil, nil
+	}
+	emailTplReceiverBiz, err = x.GetByID(ctx, id, opts)
+	if err != nil {
+		return nil, err
+	}
+	if emailTplReceiverBiz != nil {
+		return nil, xerror.NewC(ecode.ErrEmailTplReceiverAlreadyExists.ToXerror())
+	}
+	return emailTplReceiverBiz, nil
+}
+
+func (x *emailTplReceiverService) ErrNotFound(ctx context.Context, id xsf.ID, opts *biz.EmailTplReceiverOpts) (emailTplReceiverBiz *biz.EmailTplReceiver, err error) {
+	if id <= 0 {
+		return nil, nil
+	}
+	emailTplReceiverBiz, err = x.GetByID(ctx, id, opts)
+	if err != nil {
+		return nil, err
+	}
+	if emailTplReceiverBiz == nil {
+		return nil, xerror.NewC(ecode.ErrEmailTplReceiverNotFound.ToXerror())
+	}
+	return emailTplReceiverBiz, nil
+}
+
+
+func (x *emailTplReceiverService) GetByID(ctx context.Context, id xsf.ID, opts *biz.EmailTplReceiverOpts) (emailTplReceiverBiz *biz.EmailTplReceiver,err error) {
+	if id <= 0{
+		return nil,nil
+	}
+	emailTplReceiver, err := dao.EmailTplReceiverDao.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if emailTplReceiver == nil {
+		return nil, nil 
+	}
+	return x.ToBiz(ctx, emailTplReceiver, opts)
+}
+
+func (x *emailTplReceiverService) GetSliceByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailTplReceiverOpts) ([]*biz.EmailTplReceiver, error) {
+	if len(ids) == 0{
+		return nil, nil
+	}
+	emailTplReceivers, err := dao.EmailTplReceiverDao.GetSliceByIDs(ctx, ids)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailTplReceivers) == 0{
+		return nil,nil
+	}
+	return x.ToSliceBiz(ctx, emailTplReceivers, opts)
+}
+
+func (x *emailTplReceiverService) GetMapByIDs(ctx context.Context, ids []xsf.ID, opts *biz.EmailTplReceiverOpts) (map[xsf.ID]*biz.EmailTplReceiver, error) {
+	if len(ids) == 0{
+		return nil, nil
+	}
+	emailTplReceiverBizSlice,err := x.GetSliceByIDs(ctx, ids, opts)
+	if err != nil{
+		return nil,err
+	}
+	if len(emailTplReceiverBizSlice) == 0{
+		return nil, nil 
+	}
+	emailTplReceiverBizIDMap := biz.EmailTplReceiverTool.SliceToIDMapBiz(emailTplReceiverBizSlice)
+	return emailTplReceiverBizIDMap, nil
+}
+
+func (x *emailTplReceiverService) Page(ctx context.Context, in *types.EmailTplReceiverPageReq, opts *biz.EmailTplReceiverOpts) ([]*biz.EmailTplReceiver, int64, error) {
+	emailTplReceivers, total, err := dao.EmailTplReceiverDao.Page(ctx, in)
+	if err != nil {
+		return nil, 0, err
+	}
+	if len(emailTplReceivers) == 0{
+		return nil,total,nil
+	}
+	emailTplReceiverBizSlice, err := x.ToSliceBiz(ctx, emailTplReceivers, opts)
+	if err != nil {
+		return nil, 0, err
+	}
+	return emailTplReceiverBizSlice, total, nil
+}
+func (x *emailTplReceiverService) GetSliceByTplID(ctx context.Context, tplID xsf.ID,opts *biz.EmailTplReceiverOpts) ([]*biz.EmailTplReceiver, error) {
+	if tplID ==  0{
+		return nil, nil
+	}
+	emailTplReceivers, err := dao.EmailTplReceiverDao.GetSliceByTplID(ctx, models.EmailTplReceiverTool.GetOrder(), tplID)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailTplReceivers) == 0{
+		return nil, nil
+	}
+	return x.ToSliceBiz(ctx, emailTplReceivers, opts)
+}
+
+func (x *emailTplReceiverService) GetSliceByTplIDs(ctx context.Context,tplIDs []xsf.ID,opts *biz.EmailTplReceiverOpts) ([]*biz.EmailTplReceiver, error) {
+	if len(tplIDs) == 0{
+		return nil, nil
+	}
+	emailTplReceivers, err := dao.EmailTplReceiverDao.GetSliceByTplIDs(ctx,models.EmailTplReceiverTool.GetOrder(), tplIDs)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailTplReceivers) == 0 {
+		return nil,nil
+	}
+	return x.ToSliceBiz(ctx, emailTplReceivers, opts)
+}
+
+func (x *emailTplReceiverService) GetMapSliceByTplIDs(ctx context.Context, tplIDs []xsf.ID,opts *biz.EmailTplReceiverOpts) (map[xsf.ID][]*biz.EmailTplReceiver, int, error) {
+	if len(tplIDs) == 0{
+		return nil,0, nil
+	}
+	emailTplReceiverBizSlice,err := x.GetSliceByTplIDs(ctx, tplIDs,opts)
+	if err != nil {
+		return nil,0, err
+	}
+	if len(emailTplReceiverBizSlice) == 0{
+		return nil,0, nil
+	}
+	ret := make(map[xsf.ID][]*biz.EmailTplReceiver)
+	for _,r := range emailTplReceiverBizSlice {
+		ret[r.TplID] = append(ret[r.TplID],r)
+	}
+	return ret,len(emailTplReceiverBizSlice), nil
+}
+
+func (x *emailTplReceiverService) ToBiz(ctx context.Context, emailTplReceiver *models.EmailTplReceiver, opts *biz.EmailTplReceiverOpts) (emailTplReceiverBiz *biz.EmailTplReceiver, err error) {
+	if emailTplReceiver == nil {
+		return nil, nil
+	}
+	emailTplReceiverBiz = biz.EmailTplReceiverTool.NewFromModel(emailTplReceiver)
+	if err = x.Fill(ctx, emailTplReceiverBiz, opts); err != nil {
+		return nil, err
+	}
+	return emailTplReceiverBiz, nil
+}
+
+func (x *emailTplReceiverService) ToSliceBiz(ctx context.Context, emailTplReceivers []*models.EmailTplReceiver, opts *biz.EmailTplReceiverOpts) (emailTplReceiverBizSlice []*biz.EmailTplReceiver, err error) {
+	if len(emailTplReceivers) == 0 {
+		return nil, nil
+	}
+	emailTplReceiverBizSlice = biz.EmailTplReceiverTool.NewSliceFromModelsBiz(emailTplReceivers)
+	if err = x.SliceFill(ctx, emailTplReceiverBizSlice, opts); err != nil {
+		return nil, err
+	}
+	if err = biz.EmailTplReceiverTool.ValidSlice(ctx, emailTplReceiverBizSlice, opts); err != nil {
+		return nil, err
+	}
+	return emailTplReceiverBizSlice, nil
+}
+
+func (x *emailTplReceiverService) Fill(ctx context.Context, emailTplReceiverBiz *biz.EmailTplReceiver,opts *biz.EmailTplReceiverOpts) error {
+	if emailTplReceiverBiz == nil {
+		return nil
+	}
+	if opts != nil{
+	}
+	return  nil
+}
+
+func (x *emailTplReceiverService) SliceFill(ctx context.Context, emailTplReceiverBizSlice []*biz.EmailTplReceiver,opts *biz.EmailTplReceiverOpts) error {
+	if len(emailTplReceiverBizSlice) == 0 {
+		return nil
+	}
+	if opts != nil{
+	}
+	return  nil
+}
+
+func (x *emailTplReceiverService) GetAll(ctx context.Context,opts *biz.EmailTplReceiverOpts) ( []*biz.EmailTplReceiver, error) {
+	emailTplReceivers,err := dao.EmailTplReceiverDao.GetAll(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if len(emailTplReceivers) == 0{
+		return nil, nil
+	}
+	return x.ToSliceBiz(ctx, emailTplReceivers, opts)
+}
+func (x *emailTplReceiverService) ExportCSV(ctx context.Context, in *types.EmailTplReceiverExportReq, opts *biz.EmailTplReceiverOpts) (string, error) {
+	req := &types.EmailTplReceiverPageReq{}
+	_ = copier.Copy(req, in)
+	var total = func() (int64, error) {
+		return dao.EmailTplReceiverDao.GetTotal(ctx, in)
+	}
+	var page = func(offset int) ([]*biz.EmailTplReceiver, error) {
+		rs, err := dao.EmailTplReceiverDao.QueryPageSlice(ctx, req, batchSize, offset)
+		if err != nil {
+			return nil, err
+		}
+		if len(rs) == 0 {
+			return nil, nil
+		}
+		bizs, err := x.ToSliceBiz(ctx, rs, opts)
+		if err != nil {
+			return nil, err
+		}
+		return bizs, nil
+	}
+	var fileURL = func() string {
+		return csvName(ctx, models.EmailTplReceiverTool.TableName())
+	}
+	return csvexporter.New(batchSize, total, page, fileURL).Export().Upload().URI()
+}

pkg/email/types/email.go

+package types
+import (
+	"operator-qt/internal/modules/operator/biz"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/pkg/errcode"
+    "gitlab.wanzhuangkj.com/tush/xpkg/pkg/sgorm/query"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+    "gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+var _ xtime.DateTime
+
+// EmailCreateReq request params 邮件
+type EmailCreateReq struct {
+    TplID xsf.ID `json:"tplID" form:"tplID" swaggertype:"string" validate:"required" example:"1"` // 模板id
+    From string `json:"from" form:"from"   example:"月饼<mooncake2026@163.com>"` // 发件人
+    Content string `json:"content" form:"content"   example:"<div>hello moon! </div>"` // 邮件内容
+}
+
+func (x *EmailCreateReq) Valid() error {
+    if x.TplID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[tplID]不合法")
+    }
+	return nil
+}
+// EmailGetByTplIDReq request params
+type EmailGetByTplIDReq struct {
+    TplID xsf.ID `json:"tplID" form:"tplID" swaggertype:"string" validate:"required" example:"1"` //模板id 
+}
+
+func (x *EmailGetByTplIDReq) Valid() error {
+    if x.TplID  <= 0  {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[tplID]不合法")
+    }
+	return nil
+}
+
+// EmailUpdateByIDReq request params
+type EmailUpdateByIDReq struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" validate:"required" example:"1"` //用户主键id
+    TplID xsf.ID `json:"tplID" form:"tplID" swaggertype:"string" validate:"required" example:"1"` // 模板id
+    From string `json:"from" form:"from"   example:"月饼<mooncake2026@163.com>"` // 发件人
+    Content string `json:"content" form:"content"   example:"<div>hello moon! </div>"` // 邮件内容
+}
+
+func (x *EmailUpdateByIDReq) Valid() error {
+    if x.ID <= 0 {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[id]不合法")
+    }
+    if x.TplID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[tplID]不合法")
+    }
+	return nil
+}
+
+// EmailUpdateByIDsReq request params
+type EmailUpdateByIDsReq struct {
+    IDs []xsf.ID `json:"ids" swaggertype:"array,string" form:"ids" validate:"required"  example:"1"` //用户主键id
+    TplID xsf.ID `json:"tplID" form:"tplID" swaggertype:"string" validate:"required" example:"1"` // 模板id
+    From string `json:"from" form:"from"   example:"月饼<mooncake2026@163.com>"` // 发件人
+    Content string `json:"content" form:"content"   example:"<div>hello moon! </div>"` // 邮件内容
+}
+
+func (x *EmailUpdateByIDsReq) Valid() error {
+    if len(x.IDs) == 0 {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[ids]不能为空")
+    }
+    if x.TplID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[tplID]不合法")
+    }
+	return nil
+}
+
+// EmailPageReq request params
+type EmailPageReq struct {
+	query.Pagination
+    IDs []xsf.ID `json:"ids" form:"ids" swaggertype:"array,string" query:"type:in" example:"1"`  //用户主键id
+        TplID xsf.ID `json:"tplID" form:"tplID" swaggertype:"string" query:"" example:"1"` // 模板id
+        From string `json:"from" form:"from"  query:"" example:"月饼<mooncake2026@163.com>"` // 发件人
+        Content string `json:"content" form:"content"  query:"" example:"<div>hello moon! </div>"` // 邮件内容
+        CreatedAtBegin xtime.DateTime `json:"createdAtBegin" form:"createdAtBegin" query:"type:gte;column:created_at" example:"2024-03-27 17:11:00"` //创建时间起始 (>=)    
+        CreatedAtEnd xtime.DateTime `json:"createdAtEnd" form:"createdAtEnd" query:"type:lt;column:created_at" example:"2024-03-27 17:11:00"` //创建时间截止 (<)
+        UpdatedAtBegin xtime.DateTime `json:"updatedAtBegin" form:"updatedAtBegin" query:"type:gte;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间起始 (>=)    
+        UpdatedAtEnd xtime.DateTime `json:"updatedAtEnd" form:"updatedAtEnd" query:"type:lt;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间截止 (<)
+}
+
+func (x *EmailPageReq) Valid() error {
+	return nil
+}
+
+func (EmailPageReq) TableName() string {
+    return models.TBEmail
+}
+
+// EmailExportReq request params
+type EmailExportReq struct {
+    IDs []xsf.ID `json:"ids" form:"ids" swaggertype:"array,string" query:"type:in" example:"1"`  //用户主键id
+        TplID xsf.ID `json:"tplID" form:"tplID" swaggertype:"string" query:"" example:"1"` // 模板id
+        From string `json:"from" form:"from"  query:"" example:"月饼<mooncake2026@163.com>"` // 发件人
+        Content string `json:"content" form:"content"  query:"" example:"<div>hello moon! </div>"` // 邮件内容
+        CreatedAtBegin xtime.DateTime `json:"createdAtBegin" form:"createdAtBegin" query:"type:gte;column:created_at" example:"2024-03-27 17:11:00"` //创建时间起始 (>=)    
+        CreatedAtEnd xtime.DateTime `json:"createdAtEnd" form:"createdAtEnd" query:"type:lt;column:created_at" example:"2024-03-27 17:11:00"` //创建时间截止 (<)
+        UpdatedAtBegin xtime.DateTime `json:"updatedAtBegin" form:"updatedAtBegin" query:"type:gte;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间起始 (>=)    
+        UpdatedAtEnd xtime.DateTime `json:"updatedAtEnd" form:"updatedAtEnd" query:"type:lt;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间截止 (<)
+}
+
+func (x *EmailExportReq) Valid() error {
+	return nil
+}
+
+func (EmailExportReq) TableName() string {
+    return models.TBEmail
+}
+
+type EmailObjDetail struct {
+	biz.Email
+
+}
+
+var EmailObjDetailTool = EmailObjDetail{}
+
+func (x EmailObjDetail) NewFromBiz(emailBiz *biz.Email) *EmailObjDetail {
+	if emailBiz == nil {
+		return nil
+	}
+	return &EmailObjDetail{
+	Email:*emailBiz,
+	}
+}
+
+func (x EmailObjDetail) NewSliceFromBizSlice(emailBizSlice []*biz.Email) []*EmailObjDetail {
+	ret := make([]*EmailObjDetail, 0, len(emailBizSlice))
+	for i := range emailBizSlice {
+		ret = append(ret, x.NewFromBiz(emailBizSlice[i]))
+	}
+	return ret
+}

pkg/email/types/email_receiver.go

+package types
+import (
+	"operator-qt/internal/modules/operator/biz"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/pkg/errcode"
+    "gitlab.wanzhuangkj.com/tush/xpkg/pkg/sgorm/query"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+    "gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+var _ xtime.DateTime
+
+// EmailReceiverCreateReq request params 邮件收件人
+type EmailReceiverCreateReq struct {
+    EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" validate:"required" example:"1"` // 邮件id
+    Receiver string `json:"receiver" form:"receiver"   example:"月饼<mooncake2026@163.com>"` // 收件人
+}
+
+func (x *EmailReceiverCreateReq) Valid() error {
+    if x.EmailID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailID]不合法")
+    }
+	return nil
+}
+// EmailReceiverGetByEmailIDReq request params
+type EmailReceiverGetByEmailIDReq struct {
+    EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" validate:"required" example:"1"` //邮件id 
+}
+
+func (x *EmailReceiverGetByEmailIDReq) Valid() error {
+    if x.EmailID  <= 0  {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailID]不合法")
+    }
+	return nil
+}
+
+// EmailReceiverUpdateByIDReq request params
+type EmailReceiverUpdateByIDReq struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" validate:"required" example:"1"` //用户主键id
+    EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" validate:"required" example:"1"` // 邮件id
+    Receiver string `json:"receiver" form:"receiver"   example:"月饼<mooncake2026@163.com>"` // 收件人
+}
+
+func (x *EmailReceiverUpdateByIDReq) Valid() error {
+    if x.ID <= 0 {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[id]不合法")
+    }
+    if x.EmailID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailID]不合法")
+    }
+	return nil
+}
+
+// EmailReceiverUpdateByIDsReq request params
+type EmailReceiverUpdateByIDsReq struct {
+    IDs []xsf.ID `json:"ids" swaggertype:"array,string" form:"ids" validate:"required"  example:"1"` //用户主键id
+    EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" validate:"required" example:"1"` // 邮件id
+    Receiver string `json:"receiver" form:"receiver"   example:"月饼<mooncake2026@163.com>"` // 收件人
+}
+
+func (x *EmailReceiverUpdateByIDsReq) Valid() error {
+    if len(x.IDs) == 0 {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[ids]不能为空")
+    }
+    if x.EmailID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailID]不合法")
+    }
+	return nil
+}
+
+// EmailReceiverPageReq request params
+type EmailReceiverPageReq struct {
+	query.Pagination
+    IDs []xsf.ID `json:"ids" form:"ids" swaggertype:"array,string" query:"type:in" example:"1"`  //用户主键id
+        EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" query:"" example:"1"` // 邮件id
+        Receiver string `json:"receiver" form:"receiver"  query:"" example:"月饼<mooncake2026@163.com>"` // 收件人
+        CreatedAtBegin xtime.DateTime `json:"createdAtBegin" form:"createdAtBegin" query:"type:gte;column:created_at" example:"2024-03-27 17:11:00"` //创建时间起始 (>=)    
+        CreatedAtEnd xtime.DateTime `json:"createdAtEnd" form:"createdAtEnd" query:"type:lt;column:created_at" example:"2024-03-27 17:11:00"` //创建时间截止 (<)
+        UpdatedAtBegin xtime.DateTime `json:"updatedAtBegin" form:"updatedAtBegin" query:"type:gte;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间起始 (>=)    
+        UpdatedAtEnd xtime.DateTime `json:"updatedAtEnd" form:"updatedAtEnd" query:"type:lt;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间截止 (<)
+}
+
+func (x *EmailReceiverPageReq) Valid() error {
+	return nil
+}
+
+func (EmailReceiverPageReq) TableName() string {
+    return models.TBEmailReceiver
+}
+
+// EmailReceiverExportReq request params
+type EmailReceiverExportReq struct {
+    IDs []xsf.ID `json:"ids" form:"ids" swaggertype:"array,string" query:"type:in" example:"1"`  //用户主键id
+        EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" query:"" example:"1"` // 邮件id
+        Receiver string `json:"receiver" form:"receiver"  query:"" example:"月饼<mooncake2026@163.com>"` // 收件人
+        CreatedAtBegin xtime.DateTime `json:"createdAtBegin" form:"createdAtBegin" query:"type:gte;column:created_at" example:"2024-03-27 17:11:00"` //创建时间起始 (>=)    
+        CreatedAtEnd xtime.DateTime `json:"createdAtEnd" form:"createdAtEnd" query:"type:lt;column:created_at" example:"2024-03-27 17:11:00"` //创建时间截止 (<)
+        UpdatedAtBegin xtime.DateTime `json:"updatedAtBegin" form:"updatedAtBegin" query:"type:gte;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间起始 (>=)    
+        UpdatedAtEnd xtime.DateTime `json:"updatedAtEnd" form:"updatedAtEnd" query:"type:lt;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间截止 (<)
+}
+
+func (x *EmailReceiverExportReq) Valid() error {
+	return nil
+}
+
+func (EmailReceiverExportReq) TableName() string {
+    return models.TBEmailReceiver
+}
+
+type EmailReceiverObjDetail struct {
+	biz.EmailReceiver
+
+}
+
+var EmailReceiverObjDetailTool = EmailReceiverObjDetail{}
+
+func (x EmailReceiverObjDetail) NewFromBiz(emailReceiverBiz *biz.EmailReceiver) *EmailReceiverObjDetail {
+	if emailReceiverBiz == nil {
+		return nil
+	}
+	return &EmailReceiverObjDetail{
+	EmailReceiver:*emailReceiverBiz,
+	}
+}
+
+func (x EmailReceiverObjDetail) NewSliceFromBizSlice(emailReceiverBizSlice []*biz.EmailReceiver) []*EmailReceiverObjDetail {
+	ret := make([]*EmailReceiverObjDetail, 0, len(emailReceiverBizSlice))
+	for i := range emailReceiverBizSlice {
+		ret = append(ret, x.NewFromBiz(emailReceiverBizSlice[i]))
+	}
+	return ret
+}

pkg/email/types/email_send.go

+package types
+import (
+	"operator-qt/internal/modules/operator/biz"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/pkg/errcode"
+    "gitlab.wanzhuangkj.com/tush/xpkg/pkg/sgorm/query"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"operator-qt/internal/modules/operator/enums"
+    "gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+var _ xtime.DateTime
+
+// EmailSendCreateReq request params 邮件发送
+type EmailSendCreateReq struct {
+    EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" validate:"required" example:"1"` // 邮件id
+    State enums.EmailSend_State_Enum `json:"state" form:"state" validate:"required"  example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+}
+
+func (x *EmailSendCreateReq) Valid() error {
+    if x.EmailID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailID]不合法")
+    }
+    if sliceUtils.NotContains(enums.EmailSend_State_Enums_ALL, x.State) {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[state]不合法")
+    }
+	return nil
+}
+// EmailSendGetByEmailIDReq request params
+type EmailSendGetByEmailIDReq struct {
+    EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" validate:"required" example:"1"` //邮件id 
+}
+
+func (x *EmailSendGetByEmailIDReq) Valid() error {
+    if x.EmailID  <= 0  {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailID]不合法")
+    }
+	return nil
+}
+// EmailSendGetByStateReq request params
+type EmailSendGetByStateReq struct {
+    State enums.EmailSend_State_Enum `json:"state" form:"state"   validate:"required" example:"1"`    //发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败] 
+}
+
+func (x *EmailSendGetByStateReq) Valid() error {
+    if sliceUtils.NotContains(enums.EmailSend_State_Enums_ALL, x.State) {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[state]不合法")
+    }
+	return nil
+}
+
+// EmailSendUpdateByIDReq request params
+type EmailSendUpdateByIDReq struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" validate:"required" example:"1"` //用户主键id
+    EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" validate:"required" example:"1"` // 邮件id
+    State enums.EmailSend_State_Enum `json:"state" form:"state" validate:"required"  example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+}
+
+func (x *EmailSendUpdateByIDReq) Valid() error {
+    if x.ID <= 0 {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[id]不合法")
+    }
+    if x.EmailID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailID]不合法")
+    }
+    if sliceUtils.NotContains(enums.EmailSend_State_Enums_ALL, x.State) {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[state]不合法")
+    }
+	return nil
+}
+
+// EmailSendUpdateByIDsReq request params
+type EmailSendUpdateByIDsReq struct {
+    IDs []xsf.ID `json:"ids" swaggertype:"array,string" form:"ids" validate:"required"  example:"1"` //用户主键id
+    EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" validate:"required" example:"1"` // 邮件id
+    State enums.EmailSend_State_Enum `json:"state" form:"state" validate:"required"  example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+}
+
+func (x *EmailSendUpdateByIDsReq) Valid() error {
+    if len(x.IDs) == 0 {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[ids]不能为空")
+    }
+    if x.EmailID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailID]不合法")
+    }
+    if sliceUtils.NotContains(enums.EmailSend_State_Enums_ALL, x.State) {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[state]不合法")
+    }
+	return nil
+}
+
+// EmailSendPageReq request params
+type EmailSendPageReq struct {
+	query.Pagination
+    IDs []xsf.ID `json:"ids" form:"ids" swaggertype:"array,string" query:"type:in" example:"1"`  //用户主键id
+        EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" query:"" example:"1"` // 邮件id
+      States []enums.EmailSend_State_Enum `json:"state" form:"state" query:"type:in" example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+        CreatedAtBegin xtime.DateTime `json:"createdAtBegin" form:"createdAtBegin" query:"type:gte;column:created_at" example:"2024-03-27 17:11:00"` //创建时间起始 (>=)    
+        CreatedAtEnd xtime.DateTime `json:"createdAtEnd" form:"createdAtEnd" query:"type:lt;column:created_at" example:"2024-03-27 17:11:00"` //创建时间截止 (<)
+        UpdatedAtBegin xtime.DateTime `json:"updatedAtBegin" form:"updatedAtBegin" query:"type:gte;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间起始 (>=)    
+        UpdatedAtEnd xtime.DateTime `json:"updatedAtEnd" form:"updatedAtEnd" query:"type:lt;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间截止 (<)
+}
+
+func (x *EmailSendPageReq) Valid() error {
+	return nil
+}
+
+func (EmailSendPageReq) TableName() string {
+    return models.TBEmailSend
+}
+
+// EmailSendExportReq request params
+type EmailSendExportReq struct {
+    IDs []xsf.ID `json:"ids" form:"ids" swaggertype:"array,string" query:"type:in" example:"1"`  //用户主键id
+        EmailID xsf.ID `json:"emailID" form:"emailID" swaggertype:"string" query:"" example:"1"` // 邮件id
+      States []enums.EmailSend_State_Enum `json:"state" form:"state" query:"type:in" example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+        CreatedAtBegin xtime.DateTime `json:"createdAtBegin" form:"createdAtBegin" query:"type:gte;column:created_at" example:"2024-03-27 17:11:00"` //创建时间起始 (>=)    
+        CreatedAtEnd xtime.DateTime `json:"createdAtEnd" form:"createdAtEnd" query:"type:lt;column:created_at" example:"2024-03-27 17:11:00"` //创建时间截止 (<)
+        UpdatedAtBegin xtime.DateTime `json:"updatedAtBegin" form:"updatedAtBegin" query:"type:gte;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间起始 (>=)    
+        UpdatedAtEnd xtime.DateTime `json:"updatedAtEnd" form:"updatedAtEnd" query:"type:lt;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间截止 (<)
+}
+
+func (x *EmailSendExportReq) Valid() error {
+	return nil
+}
+
+func (EmailSendExportReq) TableName() string {
+    return models.TBEmailSend
+}
+
+type EmailSendObjDetail struct {
+	biz.EmailSend
+	StateZh string `json:"stateZh" form:"stateZh" example:"待处理"` // (中文)发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+
+}
+
+var EmailSendObjDetailTool = EmailSendObjDetail{}
+
+func (x EmailSendObjDetail) NewFromBiz(emailSendBiz *biz.EmailSend) *EmailSendObjDetail {
+	if emailSendBiz == nil {
+		return nil
+	}
+	return &EmailSendObjDetail{
+	EmailSend:*emailSendBiz,
+    StateZh: emailSendBiz.State.Desc(),
+	}
+}
+
+func (x EmailSendObjDetail) NewSliceFromBizSlice(emailSendBizSlice []*biz.EmailSend) []*EmailSendObjDetail {
+	ret := make([]*EmailSendObjDetail, 0, len(emailSendBizSlice))
+	for i := range emailSendBizSlice {
+		ret = append(ret, x.NewFromBiz(emailSendBizSlice[i]))
+	}
+	return ret
+}

pkg/email/types/email_send_log.go

+package types
+import (
+	"operator-qt/internal/modules/operator/biz"
+	"operator-qt/internal/modules/operator/models"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/xerrors/xerror"
+	"gitlab.wanzhuangkj.com/tush/xpkg/pkg/pkg/errcode"
+    "gitlab.wanzhuangkj.com/tush/xpkg/pkg/sgorm/query"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/xtime"
+	"gitlab.wanzhuangkj.com/tush/xpkg/utils/sliceUtils"
+	"operator-qt/internal/modules/operator/enums"
+    "gitlab.wanzhuangkj.com/tush/xpkg/utils/xsf"
+)
+var _ xtime.DateTime
+
+// EmailSendLogCreateReq request params 邮件发送记录
+type EmailSendLogCreateReq struct {
+    EmailSendID xsf.ID `json:"emailSendID" form:"emailSendID" swaggertype:"string" validate:"required" example:"1"` // 邮件发送id
+    State enums.EmailSendLog_State_Enum `json:"state" form:"state" validate:"required"  example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+}
+
+func (x *EmailSendLogCreateReq) Valid() error {
+    if x.EmailSendID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailSendID]不合法")
+    }
+    if sliceUtils.NotContains(enums.EmailSendLog_State_Enums_ALL, x.State) {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[state]不合法")
+    }
+	return nil
+}
+// EmailSendLogGetByEmailSendIDReq request params
+type EmailSendLogGetByEmailSendIDReq struct {
+    EmailSendID xsf.ID `json:"emailSendID" form:"emailSendID" swaggertype:"string" validate:"required" example:"1"` //邮件发送id 
+}
+
+func (x *EmailSendLogGetByEmailSendIDReq) Valid() error {
+    if x.EmailSendID  <= 0  {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailSendID]不合法")
+    }
+	return nil
+}
+// EmailSendLogGetByStateReq request params
+type EmailSendLogGetByStateReq struct {
+    State enums.EmailSendLog_State_Enum `json:"state" form:"state"   validate:"required" example:"1"`    //发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败] 
+}
+
+func (x *EmailSendLogGetByStateReq) Valid() error {
+    if sliceUtils.NotContains(enums.EmailSendLog_State_Enums_ALL, x.State) {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[state]不合法")
+    }
+	return nil
+}
+
+// EmailSendLogUpdateByIDReq request params
+type EmailSendLogUpdateByIDReq struct {
+    ID xsf.ID `json:"id" form:"id" swaggertype:"string" validate:"required" example:"1"` //用户主键id
+    EmailSendID xsf.ID `json:"emailSendID" form:"emailSendID" swaggertype:"string" validate:"required" example:"1"` // 邮件发送id
+    State enums.EmailSendLog_State_Enum `json:"state" form:"state" validate:"required"  example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+}
+
+func (x *EmailSendLogUpdateByIDReq) Valid() error {
+    if x.ID <= 0 {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[id]不合法")
+    }
+    if x.EmailSendID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailSendID]不合法")
+    }
+    if sliceUtils.NotContains(enums.EmailSendLog_State_Enums_ALL, x.State) {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[state]不合法")
+    }
+	return nil
+}
+
+// EmailSendLogUpdateByIDsReq request params
+type EmailSendLogUpdateByIDsReq struct {
+    IDs []xsf.ID `json:"ids" swaggertype:"array,string" form:"ids" validate:"required"  example:"1"` //用户主键id
+    EmailSendID xsf.ID `json:"emailSendID" form:"emailSendID" swaggertype:"string" validate:"required" example:"1"` // 邮件发送id
+    State enums.EmailSendLog_State_Enum `json:"state" form:"state" validate:"required"  example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+}
+
+func (x *EmailSendLogUpdateByIDsReq) Valid() error {
+    if len(x.IDs) == 0 {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[ids]不能为空")
+    }
+    if x.EmailSendID <= 0{
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[emailSendID]不合法")
+    }
+    if sliceUtils.NotContains(enums.EmailSendLog_State_Enums_ALL, x.State) {
+		return xerror.NewC(errcode.InvalidParams.Code(), "参数[state]不合法")
+    }
+	return nil
+}
+
+// EmailSendLogPageReq request params
+type EmailSendLogPageReq struct {
+	query.Pagination
+    IDs []xsf.ID `json:"ids" form:"ids" swaggertype:"array,string" query:"type:in" example:"1"`  //用户主键id
+        EmailSendID xsf.ID `json:"emailSendID" form:"emailSendID" swaggertype:"string" query:"" example:"1"` // 邮件发送id
+      States []enums.EmailSendLog_State_Enum `json:"state" form:"state" query:"type:in" example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+        CreatedAtBegin xtime.DateTime `json:"createdAtBegin" form:"createdAtBegin" query:"type:gte;column:created_at" example:"2024-03-27 17:11:00"` //创建时间起始 (>=)    
+        CreatedAtEnd xtime.DateTime `json:"createdAtEnd" form:"createdAtEnd" query:"type:lt;column:created_at" example:"2024-03-27 17:11:00"` //创建时间截止 (<)
+        UpdatedAtBegin xtime.DateTime `json:"updatedAtBegin" form:"updatedAtBegin" query:"type:gte;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间起始 (>=)    
+        UpdatedAtEnd xtime.DateTime `json:"updatedAtEnd" form:"updatedAtEnd" query:"type:lt;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间截止 (<)
+}
+
+func (x *EmailSendLogPageReq) Valid() error {
+	return nil
+}
+
+func (EmailSendLogPageReq) TableName() string {
+    return models.TBEmailSendLog
+}
+
+// EmailSendLogExportReq request params
+type EmailSendLogExportReq struct {
+    IDs []xsf.ID `json:"ids" form:"ids" swaggertype:"array,string" query:"type:in" example:"1"`  //用户主键id
+        EmailSendID xsf.ID `json:"emailSendID" form:"emailSendID" swaggertype:"string" query:"" example:"1"` // 邮件发送id
+      States []enums.EmailSendLog_State_Enum `json:"state" form:"state" query:"type:in" example:"1"` // 发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+        CreatedAtBegin xtime.DateTime `json:"createdAtBegin" form:"createdAtBegin" query:"type:gte;column:created_at" example:"2024-03-27 17:11:00"` //创建时间起始 (>=)    
+        CreatedAtEnd xtime.DateTime `json:"createdAtEnd" form:"createdAtEnd" query:"type:lt;column:created_at" example:"2024-03-27 17:11:00"` //创建时间截止 (<)
+        UpdatedAtBegin xtime.DateTime `json:"updatedAtBegin" form:"updatedAtBegin" query:"type:gte;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间起始 (>=)    
+        UpdatedAtEnd xtime.DateTime `json:"updatedAtEnd" form:"updatedAtEnd" query:"type:lt;column:updated_at" example:"2024-03-27 17:11:00"` //更新时间截止 (<)
+}
+
+func (x *EmailSendLogExportReq) Valid() error {
+	return nil
+}
+
+func (EmailSendLogExportReq) TableName() string {
+    return models.TBEmailSendLog
+}
+
+type EmailSendLogObjDetail struct {
+	biz.EmailSendLog
+	StateZh string `json:"stateZh" form:"stateZh" example:"待处理"` // (中文)发送状态 枚举[0:未知 1:待处理 2:处理中 3:成功 4:失败]
+
+}
+
+var EmailSendLogObjDetailTool = EmailSendLogObjDetail{}
+
+func (x EmailSendLogObjDetail) NewFromBiz(emailSendLogBiz *biz.EmailSendLog) *EmailSendLogObjDetail {
+	if emailSendLogBiz == nil {
+		return nil
+	}
+	return &EmailSendLogObjDetail{
+	EmailSendLog:*emailSendLogBiz,
+    StateZh: emailSendLogBiz.State.Desc(),
+	}
+}
+
+func (x EmailSendLogObjDetail) NewSliceFromBizSlice(emailSendLogBizSlice []*biz.EmailSendLog) []*EmailSendLogObjDetail {
+	ret := make([]*EmailSendLogObjDetail, 0, len(emailSendLogBizSlice))
+	for i := range emailSendLogBizSlice {
+		ret = append(ret, x.NewFromBiz(emailSendLogBizSlice[i]))
+	}
+	return ret
+}