127 lines
4.0 KiB
Go
127 lines
4.0 KiB
Go
package feedback
|
|
|
|
import (
|
|
"context"
|
|
"crypto/rand"
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// Service handles answer feedback domain logic. It validates incoming
|
|
// commands, normalizes fields, generates cryptographically random IDs,
|
|
// and delegates persistence to a Repository.
|
|
type Service struct {
|
|
tenantKey string
|
|
channel string
|
|
repo Repository
|
|
gen IDGenerator
|
|
}
|
|
|
|
// NewService creates a feedback Service. It rejects empty tenant, empty
|
|
// channel, and nil repo. An optional IDGenerator can be provided for
|
|
// deterministic testing; if nil, a crypto/rand UUIDv4 generator is used.
|
|
func NewService(tenantKey, channel string, repo Repository, gen ...IDGenerator) (*Service, error) {
|
|
if strings.TrimSpace(tenantKey) == "" {
|
|
return nil, errors.New("tenant_key must not be empty")
|
|
}
|
|
if strings.TrimSpace(channel) == "" {
|
|
return nil, errors.New("channel must not be empty")
|
|
}
|
|
if repo == nil {
|
|
return nil, errors.New("repository must not be nil")
|
|
}
|
|
if len(gen) > 1 {
|
|
return nil, errors.New("at most one IDGenerator allowed")
|
|
}
|
|
var idGen IDGenerator
|
|
if len(gen) == 1 {
|
|
idGen = gen[0]
|
|
} else {
|
|
idGen = &defaultIDGenerator{}
|
|
}
|
|
if idGen == nil {
|
|
return nil, errors.New("IDGenerator must not be nil")
|
|
}
|
|
return &Service{
|
|
tenantKey: strings.TrimSpace(tenantKey),
|
|
channel: strings.TrimSpace(channel),
|
|
repo: repo,
|
|
gen: idGen,
|
|
}, nil
|
|
}
|
|
|
|
// defaultIDGenerator produces UUIDv4-style 128-bit random IDs.
|
|
type defaultIDGenerator struct{}
|
|
|
|
func (g *defaultIDGenerator) Generate() (string, error) {
|
|
b := make([]byte, 16)
|
|
if _, err := rand.Read(b); err != nil {
|
|
return "", err
|
|
}
|
|
b[6] = (b[6] & 0x0f) | 0x40 // version 4
|
|
b[8] = (b[8] & 0x3f) | 0x80 // variant 8-9-a-b
|
|
return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x",
|
|
b[0:4], b[4:6], b[6:8], b[8:10], b[10:16]), nil
|
|
}
|
|
|
|
// Apply validates and processes a feedback Command. It trims inputs,
|
|
// validates allowed values, normalizes reason codes, generates IDs,
|
|
// and delegates to the Repository.
|
|
func (s *Service) Apply(ctx context.Context, cmd Command) (Result, error) {
|
|
cmd.ExternalActorID = strings.TrimSpace(cmd.ExternalActorID)
|
|
cmd.OutTrackID = strings.TrimSpace(cmd.OutTrackID)
|
|
cmd.Value = strings.TrimSpace(cmd.Value)
|
|
cmd.ReasonCode = strings.TrimSpace(cmd.ReasonCode)
|
|
cmd.Source = strings.TrimSpace(cmd.Source)
|
|
|
|
if cmd.ExternalActorID == "" || len(cmd.ExternalActorID) > 256 {
|
|
return Result{}, fmt.Errorf("%w: external actor ID", ErrInvalidCommand)
|
|
}
|
|
if cmd.OutTrackID == "" || len(cmd.OutTrackID) > 256 {
|
|
return Result{}, fmt.Errorf("%w: outTrackID", ErrInvalidCommand)
|
|
}
|
|
if cmd.Value != ValueUp && cmd.Value != ValueDown {
|
|
return Result{}, fmt.Errorf("%w: value", ErrInvalidCommand)
|
|
}
|
|
if cmd.Source != SourceDingTalkCard {
|
|
return Result{}, fmt.Errorf("%w: source", ErrInvalidCommand)
|
|
}
|
|
if cmd.Value == ValueUp {
|
|
cmd.ReasonCode = ReasonEmpty
|
|
} else if !validReason(cmd.ReasonCode) {
|
|
return Result{}, fmt.Errorf("%w: reason code", ErrInvalidCommand)
|
|
}
|
|
|
|
feedbackID, err := s.gen.Generate()
|
|
if err != nil {
|
|
return Result{}, fmt.Errorf("generate feedback ID: %w", err)
|
|
}
|
|
if strings.TrimSpace(feedbackID) == "" {
|
|
return Result{}, errors.New("generate feedback ID: empty ID")
|
|
}
|
|
actorID, err := s.gen.Generate()
|
|
if err != nil {
|
|
return Result{}, fmt.Errorf("generate actor ID: %w", err)
|
|
}
|
|
if strings.TrimSpace(actorID) == "" {
|
|
return Result{}, errors.New("generate actor ID: empty ID")
|
|
}
|
|
|
|
return s.repo.RecordFeedback(ctx, Record{
|
|
ID: feedbackID, TenantKey: s.tenantKey, Channel: s.channel, ActorID: actorID,
|
|
ExternalActorID: cmd.ExternalActorID, OutTrackID: cmd.OutTrackID,
|
|
Value: cmd.Value, ReasonCode: cmd.ReasonCode, Source: cmd.Source,
|
|
})
|
|
}
|
|
|
|
func validReason(reason string) bool {
|
|
switch reason {
|
|
case ReasonEmpty, ReasonIncorrect, ReasonNotResolved, ReasonIrrelevant, ReasonUnclear, ReasonOutdated, ReasonOther,
|
|
ReasonContentMismatch, ReasonContentIncomplete, ReasonIllogical, ReasonFactualError, ReasonSensitiveContent, ReasonAnswerNotWanted:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|