feat(规则): 支持同一事件多规则按条件区分并全部发送

Motivation:
止盈、止损等不同策略信号会映射到同一事件(如 trade.close),但原有唯一约束要求每个事件只能有一条规则,无法按策略区分处理。放开该约束后,同一事件可配置多条规则,通过规则条件与精确/通配优先级区分,命中条件的规则全部发送;同时将去重键从消息原文改为信号维度,避免同一信号因时间戳等无关字段差异被误判为重复。

Changes:

* 移除规则 source_id+event 的唯一约束,改为普通索引
* 事件匹配改为返回命中优先级内所有启用规则,并按 ID 逐条派发
* 通知服务遍历多条规则,按条件过滤后聚合发送渠道
* 去重键由消息 body 哈希改为策略/币种/周期/方向/价格信号维度哈希
This commit is contained in:
2026-08-17 01:20:49 +08:00
parent f5f64f7653
commit d2e8476398
13 changed files with 349 additions and 115 deletions
+56 -33
View File
@@ -31,7 +31,7 @@ type Result struct {
}
type RuleMatcher interface {
Match(ctx context.Context, sourceID int, event string) (*model.Rule, error)
Match(ctx context.Context, sourceID int, event string) ([]model.Rule, error)
}
type TemplateStore interface {
@@ -59,27 +59,11 @@ func NewService(m RuleMatcher, t TemplateStore, r *engine.Renderer, rt ChannelRo
}
func (s *Service) Process(ctx context.Context, req Request) (Result, error) {
rule, err := s.matcher.Match(ctx, req.Source.ID, req.Event)
if err != nil {
rules, err := s.matcher.Match(ctx, req.Source.ID, req.Event)
if err != nil || len(rules) == 0 {
return Result{Matched: false}, nil
}
if rule.Conditions != nil {
var conds []model.Condition
if err := json.Unmarshal(*rule.Conditions, &conds); err != nil {
slog.Error("failed to unmarshal rule conditions", "rule_id", rule.ID, "error", err)
return Result{}, fmt.Errorf("%w: invalid rule conditions", ErrUnprocessable)
}
if !condition.Evaluate(conds, req.Data) {
return Result{Matched: true, Filtered: true, Reason: "condition not met"}, nil
}
}
tmpl, err := s.templates.GetTemplate(ctx, rule.TemplateID)
if err != nil {
return Result{}, fmt.Errorf("template not found")
}
if req.Data == nil {
req.Data = map[string]interface{}{}
}
@@ -90,24 +74,70 @@ func (s *Service) Process(ctx context.Context, req Request) (Result, error) {
req.Data["pushedAt"] = time.Now().In(time.Local).Format("2006.01.02 15:04:05")
}
var channels []string
accepted := 0
for i := range rules {
chs, filtered, err := s.dispatch(ctx, req, &rules[i])
if err != nil {
return Result{}, err
}
if filtered {
continue
}
accepted++
channels = append(channels, chs...)
}
if accepted == 0 {
return Result{Matched: true, Filtered: true, Reason: "condition not met"}, nil
}
slog.Info("notification accepted",
"source", req.Source.Name,
"event", req.Event,
"channels", channels,
)
return Result{Matched: true, Channels: channels}, nil
}
func (s *Service) dispatch(ctx context.Context, req Request, rule *model.Rule) ([]string, bool, error) {
if rule.Conditions != nil {
var conds []model.Condition
if err := json.Unmarshal(*rule.Conditions, &conds); err != nil {
slog.Error("failed to unmarshal rule conditions", "rule_id", rule.ID, "error", err)
return nil, false, fmt.Errorf("%w: invalid rule conditions", ErrUnprocessable)
}
if !condition.Evaluate(conds, req.Data) {
return nil, true, nil
}
}
tmpl, err := s.templates.GetTemplate(ctx, rule.TemplateID)
if err != nil {
return nil, false, fmt.Errorf("template not found")
}
content, err := s.renderer.Render(tmpl.Content, req.Data)
if err != nil {
return Result{}, fmt.Errorf("%w: template render failed: %s", ErrUnprocessable, err.Error())
return nil, false, fmt.Errorf("%w: template render failed: %s", ErrUnprocessable, err.Error())
}
title := req.Source.Name + ": " + req.Event
channels := s.router.Route(ctx, rule, title, content)
if s.logs != nil {
ruleID := rule.ID
srcName := req.Source.Name
event := req.Event
payloadJSON, _ := json.Marshal(req.Data)
chs := append([]string(nil), channels...)
go func() {
payloadJSON, _ := json.Marshal(req.Data)
logCtx := context.Background()
for _, chName := range channels {
for _, chName := range chs {
ml := &model.MessageLog{
RuleID: rule.ID,
RuleID: ruleID,
ChannelID: parseChannelID(chName),
Source: req.Source.Name,
Event: req.Event,
Source: srcName,
Event: event,
Payload: payloadJSON,
Content: content,
Status: "pending",
@@ -118,14 +148,7 @@ func (s *Service) Process(ctx context.Context, req Request) (Result, error) {
}
}()
}
slog.Info("notification accepted",
"source", req.Source.Name,
"event", req.Event,
"channels", channels,
)
return Result{Matched: true, Channels: channels}, nil
return channels, false, nil
}
func parseChannelID(chName string) int {
+76 -5
View File
@@ -12,12 +12,22 @@ import (
)
type fakeMatcher struct {
rule *model.Rule
err error
rule *model.Rule
rules []model.Rule
err error
}
func (f *fakeMatcher) Match(context.Context, int, string) (*model.Rule, error) {
return f.rule, f.err
func (f *fakeMatcher) Match(context.Context, int, string) ([]model.Rule, error) {
if f.err != nil {
return nil, f.err
}
if len(f.rules) > 0 {
return f.rules, nil
}
if f.rule != nil {
return []model.Rule{*f.rule}, nil
}
return nil, nil
}
type fakeTemplates struct {
@@ -33,11 +43,15 @@ type fakeRouter struct {
channels []string
title string
content string
ruleIDs []int
}
func (f *fakeRouter) Route(_ context.Context, _ *model.Rule, title, content string) []string {
func (f *fakeRouter) Route(_ context.Context, rule *model.Rule, title, content string) []string {
f.title = title
f.content = content
if rule != nil {
f.ruleIDs = append(f.ruleIDs, rule.ID)
}
return f.channels
}
@@ -165,3 +179,60 @@ func TestProcessTemplateMissing(t *testing.T) {
t.Fatalf("want retryable error, got %v", err)
}
}
func TestProcessMultipleRulesSameEvent(t *testing.T) {
rt := &fakeRouter{channels: []string{"safew:1"}}
svc := newSvc(
&fakeMatcher{rules: []model.Rule{
{ID: 17, TemplateID: 1, Event: "trade.close"},
{ID: 18, TemplateID: 1, Event: "trade.close"},
}},
&fakeTemplates{tmpl: &model.Template{ID: 1, Content: "ok"}},
rt,
)
res, err := svc.Process(context.Background(), Request{
Source: &model.Source{ID: 11, Name: "crypto-strategy"},
Event: "trade.close",
Data: map[string]interface{}{"symbol": "CRV"},
})
if err != nil {
t.Fatal(err)
}
if !res.Matched || res.Filtered {
t.Fatalf("%+v", res)
}
if len(rt.ruleIDs) != 2 || rt.ruleIDs[0] != 17 || rt.ruleIDs[1] != 18 {
t.Fatalf("routed=%v", rt.ruleIDs)
}
if len(res.Channels) != 2 {
t.Fatalf("channels=%v", res.Channels)
}
}
func TestProcessSkipsFilteredSiblingRule(t *testing.T) {
hlss := json.RawMessage(`[{"field":"strategyCode","op":"eq","value":"HLSS"}]`)
ai := json.RawMessage(`[{"field":"strategyCode","op":"eq","value":"ai-crypto-signals"}]`)
rt := &fakeRouter{channels: []string{"safew:1"}}
svc := newSvc(
&fakeMatcher{rules: []model.Rule{
{ID: 1, TemplateID: 1, Event: "trade.close", Conditions: &hlss},
{ID: 2, TemplateID: 1, Event: "trade.close", Conditions: &ai},
}},
&fakeTemplates{tmpl: &model.Template{ID: 1, Content: "ok"}},
rt,
)
res, err := svc.Process(context.Background(), Request{
Source: &model.Source{ID: 11, Name: "crypto-strategy"},
Event: "trade.close",
Data: map[string]interface{}{"strategyCode": "ai-crypto-signals"},
})
if err != nil {
t.Fatal(err)
}
if !res.Matched || res.Filtered {
t.Fatalf("%+v", res)
}
if len(rt.ruleIDs) != 1 || rt.ruleIDs[0] != 2 {
t.Fatalf("routed=%v want only rule 2", rt.ruleIDs)
}
}