Files
go-sms-V2/internal/service/channel/service.go
T

748 lines
26 KiB
Go

// Package channel 通道领域服务(Day 35):CRUD、测试工具(单条测试短信验证连通性)、
// 拦截配置(夜发/日限/屏蔽地区)与当日计数。
package channel
import (
"context"
stderrors "errors"
"fmt"
"sort"
"strings"
"sync"
"time"
"gorm.io/gorm"
"go-sms/internal/model/entity"
errs "go-sms/internal/pkg/errors"
"go-sms/internal/protocol/httpadapter"
"go-sms/internal/protocol/sgip"
"go-sms/internal/protocol/smpp"
"go-sms/internal/repository/mysql"
"go-sms/internal/service/channel/pool"
)
// 支持的接入协议。
var validProtocols = map[string]bool{"cmpp": true, "http": true, "sgip": true, "smpp": true}
// 拦截结果码(CheckIntercept 返回)。
const (
ResultPass int8 = 0 // 放行
ResultNightBlock int8 = -1 // 夜发拦截
ResultRegionHit int8 = -2 // 屏蔽地区命中
ResultDayLimit int8 = -3 // 日限超出(计划验收:-3)
)
// Service 通道服务。
type Service struct {
db *gorm.DB
dao *mysql.BaseDAO[*entity.ChannelChannel]
mu sync.Mutex
dayCnt map[int64]*dayCounter // 通道当日计数(单实例;生产切 Redis)
links *pool.Manager // 常驻链路(Day 31+:cmpp.Pool 业务挂载;S1-B P2 拆 pool 子包)
logs *ChannelLogger // 通道日志(Day 40 · A-3.14;db nil 时为 nil=no-op)
mon *Monitor // 实时统计(Day 40 · A-3.13;WS 2s 推送源)
alerts *ChannelAlertService // 通道告警(Day 40 · A-3.12)
}
// dayCounter 当日计数(跨日自动清零)。
type dayCounter struct {
date string
n int
}
// NewService 构造(db 为 nil 时日志/告警降级 no-op,监控统计仍可用)。
func NewService(db *gorm.DB) *Service {
s := &Service{db: db, dao: mysql.NewBaseDAO[*entity.ChannelChannel](db), dayCnt: map[int64]*dayCounter{}, mon: NewMonitor()}
if db != nil {
s.logs = NewChannelLogger(db)
}
s.links = pool.NewManager(s)
s.alerts = NewChannelAlertService(db, s.mon, s.links.Status, nil)
s.alerts.SetLogHook(func(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) {
s.logs.Log(channelID, kind, level, msgID, detail, latencyMs)
})
return s
}
// SetUplinkSink 注入上行处理器(nil=维持 Day48 前仅日志/环形缓冲行为;接口定义在 pool 包)。
func (s *Service) SetUplinkSink(u pool.UplinkSink) { s.links.SetUplinkSink(u) }
// SetReportSink 注入回执出口(Day 56;nil=维持 Day55 前仅日志/环形缓冲行为)。
func (s *Service) SetReportSink(r pool.ReportSink) { s.links.SetReportSink(r) }
// ---- pool.Deps 适配(S1-B P2:pool 子包断环;口径与拆分前 linkManager 经 svc.* 直调
// 一一对应;Get 直接复用既有方法,此处补齐其余五个适配) ----
// Pool 常驻链路管理器访问器(S1-B P2;装配层/链路测试注入回执用)。
func (s *Service) Pool() *pool.Manager { return s.links }
// RestartLink 重建链路(S1-B P2 补齐包装:与 StartLink/StopLink 家族对齐)。
func (s *Service) RestartLink(ctx context.Context, id int64) (*pool.LinkStatus, error) {
return s.links.RestartLink(ctx, id)
}
// ListCMPPActive 启用中的 CMPP 通道清单(pool.Deps;原 Bootstrap 内联查询)。
func (s *Service) ListCMPPActive(ctx context.Context) ([]entity.ChannelChannel, error) {
list, _, err := s.List(ctx, &ListQuery{Page: 1, PageSize: 100, Protocol: "cmpp", Status: 1})
return list, err
}
// LogChannel 通道日志(pool.Deps;原 svc.logs.Log)。
func (s *Service) LogChannel(channelID int64, kind string, level int8, msgID, detail string, latencyMs int) {
s.logs.Log(channelID, kind, level, msgID, detail, latencyMs)
}
// EvaluateChannel 告警评估(pool.Deps;原 svc.alerts.EvaluateChannel)。
func (s *Service) EvaluateChannel(ctx context.Context, channelID int64) {
s.alerts.EvaluateChannel(ctx, channelID)
}
// ReportSubmit 提交计数(pool.Deps;原 svc.mon.ReportSubmit)。
func (s *Service) ReportSubmit(channelID int64, ok bool, latencyMs int) {
s.mon.ReportSubmit(channelID, ok, latencyMs)
}
// ReportDeliver 回执计数(pool.Deps;原 svc.mon.ReportDeliver)。
func (s *Service) ReportDeliver(channelID int64, ok bool) { s.mon.ReportDeliver(channelID, ok) }
// DB 只读访问器(S1-B P2:pool_test 外部包断环后,链路测试直查库断言用)。
func (s *Service) DB() *gorm.DB { return s.db }
// FlushChannelLogs 立即冲刷通道日志缓冲(nil 安全;pool_test 演练断言用)。
func (s *Service) FlushChannelLogs() {
if s.logs != nil {
s.logs.FlushNow()
}
}
// LinkReceiptsPersist 持久化回执查询(Day 56):状态报告=message_report_seg
// (report_at 非空行),上行=message_uplink;按时间倒序归并截取 n 条。
// 重启后回执可查(环形缓冲 100 条/进程内,本方法为持久层真源);
// 查询失败返回 error(调用方降级内存环形)。
func (s *Service) LinkReceiptsPersist(ctx context.Context, channelID int64, n int) ([]pool.Receipt, error) {
if s.db == nil || n <= 0 {
return []pool.Receipt{}, nil
}
var segs []entity.MessageReportSeg
if err := s.db.WithContext(ctx).
Where("channel_id = ? AND report_at IS NOT NULL", channelID).
Order("report_at DESC").Limit(n).Find(&segs).Error; err != nil {
return nil, err
}
var mos []entity.MessageUplink
if err := s.db.WithContext(ctx).
Where("channel_id = ?", channelID).
Order("recv_at DESC").Limit(n).Find(&mos).Error; err != nil {
return nil, err
}
out := make([]pool.Receipt, 0, len(segs)+len(mos))
for _, sg := range segs {
at := sg.ReportAt.Format("2006-01-02 15:04:05")
out = append(out, pool.Receipt{
ChannelID: channelID, IsReport: true, MsgID: sg.MsgID,
Stat: sg.RawCode, Dest: sg.Mobile, At: at,
})
}
for _, mo := range mos {
out = append(out, pool.Receipt{
ChannelID: channelID, IsReport: false,
Src: mo.SrcMobile, Content: mo.Content,
At: mo.RecvAt.Format("2006-01-02 15:04:05"),
})
}
// 归并倒序截 n(两路各自倒序,线性归并)。
sort.Slice(out, func(i, j int) bool { return out[i].At > out[j].At })
if len(out) > n {
out = out[:n]
}
return out, nil
}
// Close 优雅收尾:冲刷通道日志落库并停止 writer(进程退出/测试 Cleanup 调用)。
func (s *Service) Close() {
if s.logs != nil {
s.logs.Close()
}
}
// AlertService 暴露告警服务(gateway cron 装配扫描任务)。
func (s *Service) AlertService() *ChannelAlertService { return s.alerts }
// MonitorSnapshot 全通道实时快照(A-3.13:WS 2s 推送/HTTP 轮询共用)。
func (s *Service) MonitorSnapshot(ctx context.Context) ([]ChannelSnapshot, error) {
list, _, err := s.List(ctx, &ListQuery{Page: 1, PageSize: 100, Status: -1}) // Status=-1 全量(含停用,运维视图)
if err != nil {
return nil, err
}
out := make([]ChannelSnapshot, 0, len(list))
now := time.Now().Format("2006-01-02 15:04:05")
for _, ch := range list {
st := s.links.Status(ch.ID)
submit, fail, deliver, _, latP50 := s.mon.Stats(ch.ID)
snap := ChannelSnapshot{
ChannelID: ch.ID, Name: ch.Name, Protocol: ch.Protocol, Status: ch.Status,
SubmitPs: float64(submit) / float64(monWindowSec),
DeliverPs: float64(deliver) / float64(monWindowSec),
LatencyP50: latP50, UpdatedAt: now,
}
if submit > 0 {
snap.FailRate = float64(fail) / float64(submit)
}
if st != nil {
snap.Running, snap.Total, snap.Healthy = st.Running, st.Total, st.Healthy
}
out = append(out, snap)
}
return out, nil
}
// ListLogs 通道日志查询(A-3.14:连接/提交/回执完整记录;倒序分页)。
func (s *Service) ListLogs(ctx context.Context, channelID int64, kind string, page, pageSize int) ([]entity.ChannelLog, int64, error) {
if s.db == nil {
return nil, 0, pool.ErrLinkUnavailable
}
q := s.db.WithContext(ctx).Model(&entity.ChannelLog{}).Where("channel_id = ?", channelID)
if kind != "" {
q = q.Where("kind = ?", kind)
}
var total int64
if err := q.Count(&total).Error; err != nil {
return nil, 0, err
}
if page < 1 {
page = 1
}
if pageSize < 1 || pageSize > 100 {
pageSize = 20
}
var list []entity.ChannelLog
if err := q.Order("id DESC").Offset((page - 1) * pageSize).Limit(pageSize).Find(&list).Error; err != nil {
return nil, 0, err
}
return list, total, nil
}
// ---- 常驻链路(Day 31+):导出包装 ----
// StartLink 为通道建立常驻长连接(幂等)。
func (s *Service) StartLink(ctx context.Context, id int64) (*pool.LinkStatus, error) {
return s.links.StartLink(ctx, id)
}
// StopLink 拆除链路(幂等)。
func (s *Service) StopLink(id int64) { s.links.StopLink(id) }
// LinkStatus 链路状态。
func (s *Service) LinkStatus(id int64) *pool.LinkStatus { return s.links.Status(id) }
// LinkReceipts 最近 n 条回执(倒序;channelID 过滤)。
func (s *Service) LinkReceipts(channelID int64, n int) []pool.Receipt {
return s.links.Receipts(channelID, n)
}
// BootstrapLinks 启动时为启用中的 cmpp 通道建链。
func (s *Service) BootstrapLinks(ctx context.Context) { go s.links.Bootstrap(ctx) }
// ShutdownLinks 拆除全部链路。
func (s *Service) ShutdownLinks() { s.links.Shutdown() }
// CreateReq 创建通道请求。
type CreateReq struct {
Name string `json:"name" binding:"required"`
Code string `json:"code" binding:"required"`
Protocol string `json:"protocol" binding:"required"`
Host string `json:"host" binding:"required"`
Port int `json:"port"`
Username string `json:"username"`
Password string `json:"password"`
Speed int `json:"speed"`
ConnCount int `json:"conn_count"` // Day 31 联调补:此前缺失导致提交值被忽略(落默认 1)
UpstreamID int64 `json:"upstream_id"`
Priority int `json:"priority"`
Weight int `json:"weight"`
IsDefault int8 `json:"is_default"`
Remark string `json:"remark"`
// 协议接入参数(Day 31)。
SpID string `json:"sp_id"` // 企业代码(cmpp/sgip;cmpp ≤6B)
ProtocolVersion int8 `json:"protocol_version"` // cmpp:20|30 sgip:12 smpp:34(缺省按协议填充)
HeartbeatInterval int `json:"heartbeat_interval"`
ReconnectMax int `json:"reconnect_max"`
ServiceID string `json:"service_id"`
// 运营属性(Day 31)。
Carrier string `json:"carrier"` // 逗号分隔 cmcc,cucc,ctcc
BillingLength int `json:"billing_length"`
PaymentType string `json:"payment_type"`
BillingMode string `json:"billing_mode"`
Price float64 `json:"price"`
Category string `json:"category"`
MOForwardChannelID int64 `json:"mo_forward_channel_id"`
NumberRule int8 `json:"number_rule"`
CodeTruncate int8 `json:"code_truncate"`
ExtParams string `json:"ext_params"`
ServiceRemark string `json:"service_remark"`
}
// 合法运营属性白名单。
var (
validCarriers = map[string]bool{"cmcc": true, "cucc": true, "ctcc": true}
validPaymentType = map[string]bool{"": true, "prepay_monthly": true, "postpaid_monthly": true, "prepay_realtime": true}
validBillingMode = map[string]bool{"": true, "success_unknown": true, "success": true, "all": true}
)
// validateExt 校验 Day 31 扩展字段(返回规范化后的值)。
func (s *Service) validateExt(req *CreateReq) error {
req.SpID = strings.TrimSpace(req.SpID)
if len(req.SpID) > 6 {
return errs.InvalidParam.WithMsg("企业代码(sp_id)不得超过 6 字节")
}
// 版本:缺省按协议填充;cmpp 显式拒绝 3.0(协议栈未实现)。
switch req.Protocol {
case "cmpp":
if req.ProtocolVersion == 0 {
req.ProtocolVersion = 20
}
if req.ProtocolVersion == 30 {
return errs.InvalidParam.WithMsg("CMPP 3.0 协议栈未实现(当前仅支持 2.0)")
}
if req.ProtocolVersion != 20 {
return errs.InvalidParam.WithMsg("CMPP 版本仅支持 2.0")
}
case "sgip":
req.ProtocolVersion = 12
case "smpp":
req.ProtocolVersion = 34
default: // http
req.ProtocolVersion = 0
}
if req.HeartbeatInterval < 0 || req.HeartbeatInterval > 600 {
return errs.InvalidParam.WithMsg("心跳周期须在 0~600 秒(0 取默认 30)")
}
if req.HeartbeatInterval == 0 {
req.HeartbeatInterval = 30
}
if req.ReconnectMax < 0 || req.ReconnectMax > 3600 {
return errs.InvalidParam.WithMsg("重连上限须在 0~3600 秒(0 取默认 30)")
}
if req.ReconnectMax == 0 {
req.ReconnectMax = 30
}
// 运营商:每项须合法。
for _, c := range strings.Split(req.Carrier, ",") {
c = strings.TrimSpace(c)
if c != "" && !validCarriers[c] {
return errs.InvalidParam.WithMsg("运营商仅支持 cmcc/cucc/ctcc: " + c)
}
}
if !validPaymentType[req.PaymentType] {
return errs.InvalidParam.WithMsg("付款方式非法(仅 prepay_monthly/postpaid_monthly/prepay_realtime)")
}
if !validBillingMode[req.BillingMode] {
return errs.InvalidParam.WithMsg("计费方式非法(仅 success_unknown/success/all)")
}
if req.BillingLength < 0 || req.BillingLength > 1000 {
return errs.InvalidParam.WithMsg("计费长度须在 0~1000 字(0 取默认 70)")
}
if req.BillingLength == 0 {
req.BillingLength = 70
}
if req.Price < 0 {
return errs.InvalidParam.WithMsg("通道价格不能为负")
}
if req.NumberRule < 0 || req.NumberRule > 3 {
return errs.InvalidParam.WithMsg("号码组装规则仅 0~3")
}
if req.CodeTruncate < 0 || req.CodeTruncate > 20 {
return errs.InvalidParam.WithMsg("通道号截断位数须在 0~20")
}
if len(req.ExtParams) > 255 || len(req.ServiceRemark) > 255 {
return errs.InvalidParam.WithMsg("扩展参数/客服备注不得超过 255 字")
}
return nil
}
// Create 创建通道(协议白名单 + code 唯一)。
func (s *Service) Create(ctx context.Context, req *CreateReq) (*entity.ChannelChannel, error) {
req.Code = strings.TrimSpace(req.Code)
req.Protocol = strings.ToLower(strings.TrimSpace(req.Protocol))
if !validProtocols[req.Protocol] {
return nil, errs.InvalidParam.WithMsg("协议仅支持 cmpp/http/sgip/smpp")
}
if err := s.validateExt(req); err != nil {
return nil, err
}
var n int64
s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("code = ?", req.Code).Count(&n)
if n > 0 {
return nil, errs.InvalidParam.WithMsg(fmt.Sprintf("通道编码 %s 已存在", req.Code))
}
if req.Weight <= 0 {
req.Weight = 1
}
ch := &entity.ChannelChannel{
Name: req.Name, Code: req.Code, Protocol: req.Protocol,
Host: req.Host, Port: req.Port, Username: req.Username, Password: req.Password,
Speed: req.Speed, ConnCount: req.ConnCount, UpstreamID: req.UpstreamID,
Priority: req.Priority, Weight: req.Weight,
IsDefault: req.IsDefault, Status: 1, Remark: req.Remark,
SpID: req.SpID, ProtocolVersion: req.ProtocolVersion,
HeartbeatInterval: req.HeartbeatInterval, ReconnectMax: req.ReconnectMax,
ServiceID: req.ServiceID, Carrier: req.Carrier, BillingLength: req.BillingLength,
PaymentType: req.PaymentType, BillingMode: req.BillingMode, Price: req.Price,
Category: req.Category, MOForwardChannelID: req.MOForwardChannelID,
NumberRule: req.NumberRule, CodeTruncate: req.CodeTruncate,
ExtParams: req.ExtParams, ServiceRemark: req.ServiceRemark,
}
if err := s.dao.Create(ctx, ch); err != nil {
return nil, err
}
return ch, nil
}
// Update 白名单字段更新(code/protocol/status 不可改;status 走独立端点)。
func (s *Service) Update(ctx context.Context, id int64, fields map[string]any) error {
allowed := map[string]bool{
"name": true, "host": true, "port": true, "username": true, "password": true,
"speed": true, "priority": true, "weight": true, "remark": true, "is_default": true,
// 连接/拦截(Day 31 补:此前缺失导致前端表单全量提交被拒)。
"conn_count": true, "upstream_id": true, "ext_length": true, "sign_mode": true,
"template_mode": true, "day_limit": true, "night_limit": true,
"black_keywords": true, "block_regions": true,
// 协议接入参数(Day 31)。
"sp_id": true, "protocol_version": true, "heartbeat_interval": true,
"reconnect_max": true, "service_id": true,
// 运营属性(Day 31)。
"carrier": true, "billing_length": true, "payment_type": true, "billing_mode": true,
"price": true, "category": true, "mo_forward_channel_id": true, "number_rule": true,
"code_truncate": true, "ext_params": true, "service_remark": true,
}
for k := range fields {
if !allowed[k] {
return errs.InvalidParam.WithMsg(fmt.Sprintf("不允许更新字段 %q", k))
}
}
if v, ok := fields["sp_id"].(string); ok && len(strings.TrimSpace(v)) > 6 {
return errs.InvalidParam.WithMsg("企业代码(sp_id)不得超过 6 字节")
}
// 数值经 JSON 绑定为 float64,Go 调用方可能传 int/int64——统一归一化后校验。
if v, ok := numField(fields, "protocol_version"); ok && v == 30 {
return errs.InvalidParam.WithMsg("CMPP 3.0 协议栈未实现(当前仅支持 2.0)")
}
res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Updates(fields)
if res.Error != nil {
return res.Error
}
if res.RowsAffected == 0 {
return errs.NotFound.WithMsg("通道不存在")
}
return nil
}
// numField 归一化读取数值字段(float64/int/int64;JSON 与 Go 调用方两种来源)。
func numField(fields map[string]any, key string) (float64, bool) {
switch v := fields[key].(type) {
case float64:
return v, true
case int:
return float64(v), true
case int64:
return float64(v), true
case int8:
return float64(v), true
default:
return 0, false
}
}
// SetStatus 启用/停用。
func (s *Service) SetStatus(ctx context.Context, id int64, status int8) error {
if status != 0 && status != 1 {
return errs.InvalidParam.WithMsg("状态仅 0/1")
}
res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Update("status", status)
if res.Error != nil {
return res.Error
}
if res.RowsAffected == 0 {
return errs.NotFound.WithMsg("通道不存在")
}
return nil
}
// Get 详情(NotFound 语义化)。
func (s *Service) Get(ctx context.Context, id int64) (*entity.ChannelChannel, error) {
ch, err := s.dao.GetByID(ctx, id)
if err != nil {
if stderrors.Is(err, mysql.ErrNotFound) {
return nil, errs.NotFound.WithMsg("通道不存在")
}
return nil, err
}
return ch, nil
}
// ListQuery 列表过滤。
type ListQuery struct {
Page, PageSize int
Name string
Protocol string
Status int8 // -1 不过滤
}
// List 分页列表(优先级倒序+id 倒序)。
func (s *Service) List(ctx context.Context, q *ListQuery) ([]entity.ChannelChannel, int64, error) {
if q.Page <= 0 {
q.Page = 1
}
if q.PageSize <= 0 || q.PageSize > 100 {
q.PageSize = 20
}
tx := s.db.WithContext(ctx).Model(&entity.ChannelChannel{})
if q.Name != "" {
tx = tx.Where("name LIKE ?", "%"+q.Name+"%")
}
if q.Protocol != "" {
tx = tx.Where("protocol = ?", q.Protocol)
}
if q.Status >= 0 {
tx = tx.Where("status = ?", q.Status)
}
var total int64
if err := tx.Count(&total).Error; err != nil {
return nil, 0, err
}
var out []entity.ChannelChannel
if err := tx.Order("priority DESC").Order("id DESC").
Offset((q.Page - 1) * q.PageSize).Limit(q.PageSize).Find(&out).Error; err != nil {
return nil, 0, err
}
return out, total, nil
}
// Delete 删除(需先停用且不被组引用;Day 36 扩展引用守卫)。
func (s *Service) Delete(ctx context.Context, id int64) error {
ch, err := s.Get(ctx, id)
if err != nil {
return err
}
if ch.Status != 0 {
return errs.InvalidParam.WithMsg("通道启用中,须先停用再删除")
}
if n := s.channelInUse(ctx, id); n > 0 {
return errs.InvalidParam.WithMsg(fmt.Sprintf("通道被 %d 个通道组引用,须先移除组成员", n))
}
return s.dao.Delete(ctx, id)
}
// ---- 测试工具(Day 35):发送单条测试短信验证连通性 ----
// TestResult 测试工具结果。
type TestResult struct {
MessageID string `json:"message_id"`
Protocol string `json:"protocol"`
ElapsedMS int64 `json:"elapsed_ms"`
}
// TestChannel 用指定通道真实发送一条测试短信,返回上游 MsgID。
// 验收:测试工具发送通道返回正确 MsgID。
// SubmitViaLink 单号链路提交(Day56 起返回各段 msg_id;兼容旧调用取 [0])。
func (s *Service) SubmitViaLink(ctx context.Context, id int64, mobile, content string) ([]string, error) {
return s.links.SubmitViaLink(ctx, id, mobile, content)
}
func (s *Service) TestChannel(ctx context.Context, id int64, mobile, content string) (*TestResult, error) {
ch, err := s.Get(ctx, id)
if err != nil {
return nil, err
}
if ch.Status != 1 {
return nil, errs.InvalidParam.WithMsg("通道已停用,无法测试")
}
start := time.Now()
var messageID string
switch ch.Protocol {
case "http":
resp, err := httpadapter.New(httpadapter.Config{
Endpoint: ch.Host, AuthType: httpadapter.AuthNone, Timeout: 5 * time.Second,
}).Send(ctx, &httpadapter.SendReq{Mobile: mobile, Content: content})
if err != nil {
return nil, err
}
messageID = resp.MessageID
case "cmpp":
// Day 31+:经常驻链路提交(未建链自动建立,连接保持——网关生成下发记录的必要条件;
// 回执经 OnDeliver 进环形缓冲/结构化日志)。原短连接工具逻辑由 linkManager 承接。
mids, err := s.links.SubmitViaLink(ctx, id, mobile, content)
if err != nil {
return nil, err
}
if len(mids) > 0 {
messageID = mids[0] // 测试工具视图取首段(与历史展示口径一致)
}
case "sgip":
corpID := ch.SpID // 企业代码:优先 sp_id;空回退 username(历史兼容)
if corpID == "" {
corpID = ch.Username
}
spNumber := ch.Code // SP 接入码=通道号;空回退 username
if spNumber == "" {
spNumber = ch.Username
}
c := sgip.NewClient(sgip.Config{
Addr: fmt.Sprintf("%s:%d", ch.Host, ch.Port), Name: ch.Username, Password: ch.Password,
NodeID: 1, Timeout: 5 * time.Second,
})
if err := c.Connect(ctx); err != nil {
return nil, err
}
defer func() { _ = c.Close() }()
result, err := c.Submit(&sgip.SubmitReq{
SPNumber: spNumber, UserNumbers: []string{mobile}, CorpID: corpID,
ServiceType: "TEST", Content: []byte(content), ReportFlag: 1,
})
if err != nil {
return nil, err
}
if result != 0 {
return nil, errs.SendLimited.WithMsg(fmt.Sprintf("上游拒绝: result=%d", result))
}
messageID = "sgip-ok"
case "smpp":
// 心跳周期映射 enquire_link(0 值由 smpp.Config.withDefaults 兜底 30s)。
c := smpp.NewClient(smpp.Config{
Addr: fmt.Sprintf("%s:%d", ch.Host, ch.Port), SystemID: ch.Username, Password: ch.Password,
WindowSize: 1, Timeout: 5 * time.Second,
HeartbeatInterval: time.Duration(ch.HeartbeatInterval) * time.Second,
})
if err := c.Connect(ctx); err != nil {
return nil, err
}
defer func() { _ = c.Close() }()
srcAddr := ch.Code // 源地址=接入码;空回退 system_id
if srcAddr == "" {
srcAddr = ch.Username
}
mid, st, err := c.Submit(&smpp.SubmitReq{
Source: smpp.Addr{Ton: 1, Npi: 1, Address: srcAddr},
Dest: smpp.Addr{Ton: 1, Npi: 1, Address: mobile},
ShortMessage: []byte(content), RegisteredDelivery: 1,
})
if err != nil {
return nil, err
}
if st != smpp.StatusOK {
return nil, errs.SendLimited.WithMsg(fmt.Sprintf("上游拒绝: status=0x%08x", uint32(st)))
}
messageID = mid
default:
return nil, errs.InvalidParam.WithMsg("未知协议 " + ch.Protocol)
}
return &TestResult{MessageID: messageID, Protocol: ch.Protocol, ElapsedMS: time.Since(start).Milliseconds()}, nil
}
// ---- 拦截配置(Day 35):夜发/日限/屏蔽地区 ----
// InterceptConfig 拦截配置视图。
type InterceptConfig struct {
NightLimit int `json:"night_limit"` // >0 开启夜发拦截(22:00-08:00 禁发)
DayLimit int `json:"day_limit"` // >0 每日上限;超出 result=-3
BlockRegions string `json:"block_regions"` // 逗号分隔地区(前缀命中)
BlackKeywords string `json:"black_keywords"` // 展示(命中逻辑在 Day 42 拦截器链)
}
// GetIntercept 查询拦截配置。
func (s *Service) GetIntercept(ctx context.Context, id int64) (*InterceptConfig, error) {
ch, err := s.Get(ctx, id)
if err != nil {
return nil, err
}
return &InterceptConfig{
NightLimit: ch.NightLimit, DayLimit: ch.DayLimit,
BlockRegions: ch.BlockRegions, BlackKeywords: ch.BlackKeywords,
}, nil
}
// SetIntercept 设置拦截配置。
func (s *Service) SetIntercept(ctx context.Context, id int64, cfg *InterceptConfig) error {
if len(cfg.BlockRegions) > 512 {
return errs.InvalidParam.WithMsg("屏蔽地区列表过长(≤512)")
}
res := s.db.WithContext(ctx).Model(&entity.ChannelChannel{}).Where("id = ?", id).Updates(map[string]any{
"night_limit": cfg.NightLimit, "day_limit": cfg.DayLimit, "block_regions": cfg.BlockRegions,
})
if res.Error != nil {
return res.Error
}
if res.RowsAffected == 0 {
return errs.NotFound.WithMsg("通道不存在")
}
return nil
}
// InterceptVerdict 拦截判定。
type InterceptVerdict struct {
Blocked bool
Result int8 // 见 Result* 常量
Reason string
}
// CheckIntercept 判定是否拦截(顺序:夜发→地区→日限;now 注入便于测试)。
// 验收:拦截三配置生效;日限超出返回 -3。
func (s *Service) CheckIntercept(ch *entity.ChannelChannel, region string, now time.Time) InterceptVerdict {
if ch.NightLimit > 0 && isNight(now) {
return InterceptVerdict{Blocked: true, Result: ResultNightBlock,
Reason: "夜发时段禁止发送(22:00-08:00)"}
}
if region != "" && ch.BlockRegions != "" {
for _, r := range strings.Split(ch.BlockRegions, ",") {
r = strings.TrimSpace(r)
if r != "" && (r == region || strings.HasPrefix(region, r)) {
return InterceptVerdict{Blocked: true, Result: ResultRegionHit,
Reason: "命中屏蔽地区: " + region}
}
}
}
if ch.DayLimit > 0 {
if s.TodayCount(ch.ID) >= ch.DayLimit {
return InterceptVerdict{Blocked: true, Result: ResultDayLimit,
Reason: fmt.Sprintf("超出日限 %d(今日已发 %d)", ch.DayLimit, s.TodayCount(ch.ID))}
}
}
return InterceptVerdict{}
}
// IncrDayCount 放行后计数。
func (s *Service) IncrDayCount(channelID int64) int {
s.mu.Lock()
defer s.mu.Unlock()
today := time.Now().Format("2006-01-02")
c, ok := s.dayCnt[channelID]
if !ok || c.date != today {
c = &dayCounter{date: today}
s.dayCnt[channelID] = c
}
c.n++
return c.n
}
// TodayCount 当日已发数。
func (s *Service) TodayCount(channelID int64) int {
s.mu.Lock()
defer s.mu.Unlock()
today := time.Now().Format("2006-01-02")
if c, ok := s.dayCnt[channelID]; ok && c.date == today {
return c.n
}
return 0
}
// isNight 夜间时段判定(22:00-08:00,跨越零点)。
func isNight(t time.Time) bool {
h := t.Hour()
return h >= 22 || h < 8
}