service.xpcool.com/internal/controller/notice/notice.go

// Package notice 通知模块控制器（绑定 admin 受权限保护组）。
package notice

import (
	"context"

	noticev1 "service.xpcool.com/api/notice"
	"service.xpcool.com/internal/model/dto"
	"service.xpcool.com/internal/service/notice"
)

// Controller 实现通知模块端点。
type Controller struct{}

// New 创建通知控制器。
func New() *Controller { return &Controller{} }

// ChannelList 通知渠道列表。
func (c *Controller) ChannelList(ctx context.Context, req *noticev1.NoticeChannelListReq) (res *noticev1.NoticeChannelListRes, err error) {
	list, err := notice.Notice().ChannelList(ctx)
	if err != nil {
		return nil, err
	}
	out := make([]*noticev1.NoticeChannelItem, 0, len(list))
	for i := range list {
		v := &list[i]
		out = append(out, &noticev1.NoticeChannelItem{Id: v.Id, Code: v.Code, Name: v.Name, Enabled: v.Enabled, Config: v.Config, Remark: v.Remark})
	}
	return &noticev1.NoticeChannelListRes{List: out}, nil
}

// ChannelSave 保存通知渠道。
func (c *Controller) ChannelSave(ctx context.Context, req *noticev1.NoticeChannelSaveReq) (res *noticev1.NoticeChannelSaveRes, err error) {
	id, err := notice.Notice().ChannelSave(ctx, dto.NoticeChannelInput{
		Id: req.Id, Code: req.Code, Name: req.Name, Enabled: req.Enabled, Config: req.Config, Remark: req.Remark,
	})
	if err != nil {
		return nil, err
	}
	return &noticev1.NoticeChannelSaveRes{Id: id}, nil
}

// RuleList 通知规则列表。
func (c *Controller) RuleList(ctx context.Context, req *noticev1.NoticeRuleListReq) (res *noticev1.NoticeRuleListRes, err error) {
	list, err := notice.Notice().RuleList(ctx, req.EventType)
	if err != nil {
		return nil, err
	}
	out := make([]*noticev1.NoticeRuleItem, 0, len(list))
	for i := range list {
		v := &list[i]
		out = append(out, &noticev1.NoticeRuleItem{
			Id: v.Id, Name: v.Name, EventType: v.EventType, ChannelCodes: v.ChannelCodes,
			UserIds: v.UserIds, TitleTemplate: v.TitleTemplate, BodyTemplate: v.BodyTemplate, Enabled: v.Enabled,
		})
	}
	return &noticev1.NoticeRuleListRes{List: out}, nil
}

// RuleSave 保存通知规则。
func (c *Controller) RuleSave(ctx context.Context, req *noticev1.NoticeRuleSaveReq) (res *noticev1.NoticeRuleSaveRes, err error) {
	id, err := notice.Notice().RuleSave(ctx, dto.NoticeRuleInput{
		Id: req.Id, Name: req.Name, EventType: req.EventType, ChannelCodes: req.ChannelCodes,
		UserIds: req.UserIds, TitleTemplate: req.TitleTemplate, BodyTemplate: req.BodyTemplate, Enabled: req.Enabled,
	})
	if err != nil {
		return nil, err
	}
	return &noticev1.NoticeRuleSaveRes{Id: id}, nil
}

// RuleDelete 删除通知规则。
func (c *Controller) RuleDelete(ctx context.Context, req *noticev1.NoticeRuleDeleteReq) (res *noticev1.NoticeRuleDeleteRes, err error) {
	if err = notice.Notice().RuleDelete(ctx, req.Id); err != nil {
		return nil, err
	}
	return &noticev1.NoticeRuleDeleteRes{}, nil
}

// LogList 通知发送记录分页。
func (c *Controller) LogList(ctx context.Context, req *noticev1.NoticeLogListReq) (res *noticev1.NoticeLogListRes, err error) {
	list, total, err := notice.Notice().LogList(ctx, dto.NoticeLogFilter{
		Page: req.Page, Size: req.Size, EventType: req.EventType,
		ChannelCode: req.ChannelCode, Result: req.Result, DateFrom: req.DateFrom, DateTo: req.DateTo,
	})
	if err != nil {
		return nil, err
	}
	out := make([]*noticev1.NoticeLogItem, 0, len(list))
	for i := range list {
		v := &list[i]
		out = append(out, &noticev1.NoticeLogItem{
			Id: v.Id, RuleId: v.RuleId, EventType: v.EventType, ChannelCode: v.ChannelCode,
			UserId: v.UserId, Target: v.Target, Title: v.Title, Body: v.Body,
			Result: v.Result, Error: v.Error, CreatedAt: v.CreatedAt,
		})
	}
	return &noticev1.NoticeLogListRes{List: out, Total: total}, nil
}

// Test 测试通知发送。
func (c *Controller) Test(ctx context.Context, req *noticev1.NoticeTestReq) (res *noticev1.NoticeTestRes, err error) {
	ok, msg, err := notice.Notice().Test(ctx, req.RuleId, req.ChannelCode, req.Target, req.UserIds, req.Title, req.Body)
	if err != nil {
		return nil, err
	}
	return &noticev1.NoticeTestRes{Result: ok, Message: msg}, nil
}