1048 lines
43 KiB
Go
1048 lines
43 KiB
Go
package activitytemplate
|
||
|
||
import (
|
||
"context"
|
||
"crypto/sha256"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"net/url"
|
||
"regexp"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
"unicode/utf8"
|
||
|
||
"google.golang.org/grpc"
|
||
walletv1 "hyapp.local/api/proto/wallet/v1"
|
||
"hyapp/pkg/appcode"
|
||
"hyapp/pkg/xerr"
|
||
domain "hyapp/services/activity-service/internal/domain/activitytemplate"
|
||
)
|
||
|
||
const (
|
||
defaultLeaderboardSize = int32(100)
|
||
maxActivityDurationMS = int64((366 * 24 * time.Hour) / time.Millisecond)
|
||
maxDisplayConfigBytes = 64 * 1024
|
||
maxRankRewardRanges = 100
|
||
)
|
||
|
||
var (
|
||
templateCodePattern = regexp.MustCompile(`^[a-z][a-z0-9_-]{2,63}$`)
|
||
taskKeyPattern = regexp.MustCompile(`^[a-z][a-z0-9_-]{1,63}$`)
|
||
localePattern = regexp.MustCompile(`^[a-z]{2,3}(?:-[a-z0-9]{2,8})*$`)
|
||
assetKeyPattern = regexp.MustCompile(`^[a-z][a-z0-9_.-]{1,63}$`)
|
||
)
|
||
|
||
// Repository 是活动模版聚合的持久化边界。完整子配置、版本快照和状态必须由 activity-service 同库事务维护。
|
||
type Repository interface {
|
||
ListActivityTemplates(ctx context.Context, query domain.ListQuery) ([]domain.Summary, int64, error)
|
||
GetActivityTemplate(ctx context.Context, templateID string) (domain.Template, error)
|
||
CreateActivityTemplate(ctx context.Context, template domain.Template, operatorAdminID int64, nowMS int64) (domain.Template, error)
|
||
UpdateActivityTemplate(ctx context.Context, command domain.UpdateCommand, nowMS int64) (domain.Template, error)
|
||
SetActivityTemplateStatus(ctx context.Context, command domain.StatusCommand, nowMS int64) (domain.Template, error)
|
||
ListActivityTemplateVersions(ctx context.Context, templateID string, page int32, pageSize int32) ([]domain.Version, int64, error)
|
||
GetActivityTemplateVersion(ctx context.Context, templateID string, versionNo int64) (domain.Version, error)
|
||
}
|
||
|
||
// Service 拥有活动模版校验、乐观锁、发布状态机和克隆语义；HTTP/gRPC 层只做协议适配。
|
||
type Service struct {
|
||
repository Repository
|
||
catalog CatalogClient
|
||
regions RegionSource
|
||
runtime RuntimeRepository
|
||
runtimeWallet RuntimeWallet
|
||
rewardSnapshots RewardSnapshotWallet
|
||
notices NoticeService
|
||
now func() time.Time
|
||
}
|
||
|
||
// CatalogClient 是发布时确认礼物和奖励资源组仍由 owner service 激活的最小契约。
|
||
// 后台提交的名称、价格和 ID 都只是候选输入，不能代替 wallet-service 当前事实。
|
||
type CatalogClient interface {
|
||
ListGiftConfigs(ctx context.Context, req *walletv1.ListGiftConfigsRequest, opts ...grpc.CallOption) (*walletv1.ListGiftConfigsResponse, error)
|
||
GetResourceGroup(ctx context.Context, req *walletv1.GetResourceGroupRequest, opts ...grpc.CallOption) (*walletv1.GetResourceGroupResponse, error)
|
||
}
|
||
|
||
type RewardSnapshotWallet interface {
|
||
PinResourceGroupSnapshot(ctx context.Context, req *walletv1.PinResourceGroupSnapshotRequest, opts ...grpc.CallOption) (*walletv1.PinResourceGroupSnapshotResponse, error)
|
||
}
|
||
|
||
// RegionSource 复用 user-service 区域主数据适配器，发布时拒绝已停用或不存在的定向区域。
|
||
type RegionSource interface {
|
||
ListActiveRegionIDs(ctx context.Context) ([]int64, error)
|
||
}
|
||
|
||
func New(repository Repository, catalog CatalogClient, regions RegionSource) *Service {
|
||
service := &Service{repository: repository, catalog: catalog, regions: regions, now: time.Now}
|
||
// Production MySQL/wallet clients implement the runtime surfaces. Type assertions keep configuration-only
|
||
// fakes source-compatible while still failing closed when a runtime RPC is invoked without real dependencies.
|
||
service.runtime, _ = repository.(RuntimeRepository)
|
||
service.runtimeWallet, _ = catalog.(RuntimeWallet)
|
||
service.rewardSnapshots, _ = catalog.(RewardSnapshotWallet)
|
||
return service
|
||
}
|
||
|
||
func (s *Service) List(ctx context.Context, query domain.ListQuery) ([]domain.Summary, int64, error) {
|
||
if err := s.requireRepository(); err != nil {
|
||
return nil, 0, err
|
||
}
|
||
query.Keyword = strings.TrimSpace(query.Keyword)
|
||
query.Status = normalizeStatus(query.Status)
|
||
query.NowMS = s.now().UTC().UnixMilli()
|
||
if !validListStatus(query.Status) {
|
||
return nil, 0, xerr.New(xerr.InvalidArgument, "status filter is invalid")
|
||
}
|
||
if query.StartMS > 0 && query.EndMS > 0 && query.EndMS <= query.StartMS {
|
||
return nil, 0, xerr.New(xerr.InvalidArgument, "time range must use [start_ms,end_ms)")
|
||
}
|
||
if query.StartMS < 0 || query.EndMS < 0 {
|
||
return nil, 0, xerr.New(xerr.InvalidArgument, "start_ms and end_ms must not be negative")
|
||
}
|
||
if query.RegionID != nil && *query.RegionID <= 0 {
|
||
return nil, 0, xerr.New(xerr.InvalidArgument, "region_id must be positive")
|
||
}
|
||
items, total, err := s.repository.ListActivityTemplates(ctx, query)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
for index := range items {
|
||
items[index].LifecycleStatus = lifecycleStatus(items[index].Status, items[index].StartMS, items[index].EndMS, query.NowMS)
|
||
}
|
||
return items, total, nil
|
||
}
|
||
|
||
func (s *Service) Get(ctx context.Context, templateID string) (domain.Template, error) {
|
||
if err := s.requireRepository(); err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
templateID = strings.TrimSpace(templateID)
|
||
if templateID == "" {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "template_id is required")
|
||
}
|
||
item, err := s.repository.GetActivityTemplate(ctx, templateID)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
item.LifecycleStatus = lifecycleStatus(item.Status, item.StartMS, item.EndMS, s.now().UTC().UnixMilli())
|
||
return item, nil
|
||
}
|
||
|
||
func (s *Service) Create(ctx context.Context, template domain.Template, operatorAdminID int64) (domain.Template, error) {
|
||
if err := s.requireRepository(); err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
if operatorAdminID <= 0 {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "operator_admin_id is required")
|
||
}
|
||
template = normalizeTemplate(template)
|
||
// 新记录只能先落草稿。发布会额外执行完整校验、区间冲突检查和版本快照，不允许 create 绕过发布状态机。
|
||
template.Status = domain.StatusDraft
|
||
template.TemplateID = ""
|
||
template.Revision = 0
|
||
template.PublishedVersion = 0
|
||
nowMS := s.now().UTC().UnixMilli()
|
||
if issues := validateTemplate(template, false, nowMS); len(issues) > 0 {
|
||
return domain.Template{}, issueError(issues[0])
|
||
}
|
||
stored, err := s.repository.CreateActivityTemplate(ctx, template, operatorAdminID, nowMS)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
stored.LifecycleStatus = lifecycleStatus(stored.Status, stored.StartMS, stored.EndMS, nowMS)
|
||
return stored, nil
|
||
}
|
||
|
||
func (s *Service) Update(ctx context.Context, command domain.UpdateCommand) (domain.Template, error) {
|
||
if err := s.requireRepository(); err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
command.Template = normalizeTemplate(command.Template)
|
||
command.Template.TemplateID = strings.TrimSpace(command.Template.TemplateID)
|
||
if command.Template.TemplateID == "" {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "template_id is required")
|
||
}
|
||
if command.OperatorAdminID <= 0 {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "operator_admin_id is required")
|
||
}
|
||
if command.ExpectedRevision <= 0 {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "expected_revision is required")
|
||
}
|
||
current, err := s.repository.GetActivityTemplate(ctx, command.Template.TemplateID)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
if current.Revision != command.ExpectedRevision {
|
||
return domain.Template{}, xerr.New(xerr.Conflict, "activity template revision changed")
|
||
}
|
||
// template_code 是 App deep link、运行版本和统计维度的长期业务身份；创建后改码会让已发布历史
|
||
// 与当前编辑态分裂。需要新编码时必须 clone 成新模版，由新 ID 重新走发布流程。
|
||
if command.Template.TemplateCode != current.TemplateCode {
|
||
return domain.Template{}, xerr.New(xerr.Conflict, "activity template_code is immutable; clone the template to use a new code")
|
||
}
|
||
if current.Status != domain.StatusDraft && current.Status != domain.StatusDisabled {
|
||
// 已发布配置必须先停用再编辑；这样 published_version 始终对应运行侧实际使用的不可变快照。
|
||
return domain.Template{}, xerr.New(xerr.Conflict, "published activity template must be disabled before editing")
|
||
}
|
||
command.Template.Status = current.Status
|
||
nowMS := s.now().UTC().UnixMilli()
|
||
if issues := validateTemplate(command.Template, false, nowMS); len(issues) > 0 {
|
||
return domain.Template{}, issueError(issues[0])
|
||
}
|
||
stored, err := s.repository.UpdateActivityTemplate(ctx, command, nowMS)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
stored.LifecycleStatus = lifecycleStatus(stored.Status, stored.StartMS, stored.EndMS, nowMS)
|
||
return stored, nil
|
||
}
|
||
|
||
func (s *Service) SetStatus(ctx context.Context, command domain.StatusCommand) (domain.Template, error) {
|
||
if err := s.requireRepository(); err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
command.TemplateID = strings.TrimSpace(command.TemplateID)
|
||
command.Status = normalizeStatus(command.Status)
|
||
if command.TemplateID == "" || command.OperatorAdminID <= 0 || command.ExpectedRevision <= 0 {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "template_id, operator_admin_id and expected_revision are required")
|
||
}
|
||
if command.Status != domain.StatusPublished && command.Status != domain.StatusDisabled {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "status must be published or disabled")
|
||
}
|
||
current, err := s.repository.GetActivityTemplate(ctx, command.TemplateID)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
if current.Revision != command.ExpectedRevision {
|
||
return domain.Template{}, xerr.New(xerr.Conflict, "activity template revision changed")
|
||
}
|
||
if current.Status == command.Status {
|
||
current.LifecycleStatus = lifecycleStatus(current.Status, current.StartMS, current.EndMS, s.now().UTC().UnixMilli())
|
||
return current, nil
|
||
}
|
||
nowMS := s.now().UTC().UnixMilli()
|
||
switch command.Status {
|
||
case domain.StatusPublished:
|
||
if current.Status != domain.StatusDraft && current.Status != domain.StatusDisabled {
|
||
return domain.Template{}, xerr.New(xerr.Conflict, "only draft or disabled activity template can be published")
|
||
}
|
||
if issues := validateTemplate(normalizeTemplate(current), true, nowMS); len(issues) > 0 {
|
||
return domain.Template{}, issueError(issues[0])
|
||
}
|
||
referenceIssues, err := s.validateReferences(ctx, current)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
if len(referenceIssues) > 0 {
|
||
return domain.Template{}, issueError(referenceIssues[0])
|
||
}
|
||
if current.EndMS <= nowMS {
|
||
return domain.Template{}, xerr.New(xerr.Conflict, "ended activity template cannot be published")
|
||
}
|
||
rewardSnapshots, err := s.pinRewardSnapshots(ctx, current, current.PublishedVersion+1, command.OperatorAdminID)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
command.RewardSnapshots = rewardSnapshots
|
||
case domain.StatusDisabled:
|
||
if current.Status != domain.StatusPublished {
|
||
return domain.Template{}, xerr.New(xerr.Conflict, "only published activity template can be disabled")
|
||
}
|
||
}
|
||
stored, err := s.repository.SetActivityTemplateStatus(ctx, command, nowMS)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
stored.LifecycleStatus = lifecycleStatus(stored.Status, stored.StartMS, stored.EndMS, nowMS)
|
||
return stored, nil
|
||
}
|
||
|
||
func (s *Service) pinRewardSnapshots(ctx context.Context, item domain.Template, nextVersion int64, operatorAdminID int64) (map[int64]domain.RewardSnapshot, error) {
|
||
groupIDs := make(map[int64]struct{})
|
||
for _, task := range item.Tasks {
|
||
if task.RewardResourceGroupID > 0 {
|
||
groupIDs[task.RewardResourceGroupID] = struct{}{}
|
||
}
|
||
}
|
||
for _, reward := range item.RankRewards {
|
||
if reward.ResourceGroupID > 0 {
|
||
groupIDs[reward.ResourceGroupID] = struct{}{}
|
||
}
|
||
}
|
||
if len(groupIDs) == 0 {
|
||
return map[int64]domain.RewardSnapshot{}, nil
|
||
}
|
||
if s.rewardSnapshots == nil {
|
||
return nil, xerr.New(xerr.Unavailable, "wallet reward snapshot client is not configured")
|
||
}
|
||
ordered := make([]int64, 0, len(groupIDs))
|
||
for groupID := range groupIDs {
|
||
ordered = append(ordered, groupID)
|
||
}
|
||
sort.Slice(ordered, func(left, right int) bool { return ordered[left] < ordered[right] })
|
||
result := make(map[int64]domain.RewardSnapshot, len(ordered))
|
||
for _, groupID := range ordered {
|
||
groupResp, err := s.catalog.GetResourceGroup(ctx, &walletv1.GetResourceGroupRequest{
|
||
RequestId: "activity-template-pin-source:" + item.TemplateID + ":" + strconv.FormatInt(groupID, 10),
|
||
AppCode: appcode.FromContext(ctx), GroupId: groupID,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
sourceUpdatedAtMS := groupResp.GetGroup().GetUpdatedAtMs()
|
||
sourceContentHash := strings.ToLower(strings.TrimSpace(groupResp.GetSourceContentHash()))
|
||
if groupResp.GetGroup() == nil || sourceUpdatedAtMS <= 0 || !validSHA256Hex(sourceContentHash) {
|
||
return nil, xerr.New(xerr.Conflict, "resource group source version is missing")
|
||
}
|
||
// Revision distinguishes a new edit after a failed cross-service publish attempt. Retrying the same
|
||
// revision reuses identical bytes; editing first produces a new pin even though published_version has
|
||
// not advanced yet.
|
||
pinIdentity := "activity-template:" + item.TemplateID + ":revision:" + strconv.FormatInt(item.Revision, 10) +
|
||
":v" + strconv.FormatInt(nextVersion, 10) + ":group:" + strconv.FormatInt(groupID, 10) +
|
||
":source:" + sourceContentHash
|
||
pinSum := sha256.Sum256([]byte(pinIdentity))
|
||
pinKey := "activity-template-pin:" + hex.EncodeToString(pinSum[:])
|
||
resp, err := s.rewardSnapshots.PinResourceGroupSnapshot(ctx, &walletv1.PinResourceGroupSnapshotRequest{
|
||
RequestId: pinKey, AppCode: appcode.FromContext(ctx), GroupId: groupID,
|
||
PinKey: pinKey, OperatorUserId: operatorAdminID, ExpectedGroupUpdatedAtMs: sourceUpdatedAtMS,
|
||
ExpectedSourceContentHash: sourceContentHash,
|
||
RequiredRegionIds: append([]int64(nil), item.RegionIDs...),
|
||
RequiredAllRegions: item.AllRegions,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
snapshot := rewardSnapshotFromWallet(resp.GetSnapshot())
|
||
if snapshot.SnapshotID == "" || snapshot.SourceGroupID != groupID || len(snapshot.Items) == 0 ||
|
||
resp.GetSnapshot().GetSourceGroupUpdatedAtMs() != sourceUpdatedAtMS ||
|
||
resp.GetSnapshot().GetSourceContentHash() != sourceContentHash || snapshot.SnapshotHash != sourceContentHash {
|
||
return nil, xerr.New(xerr.Internal, "wallet returned an incomplete resource group snapshot")
|
||
}
|
||
result[groupID] = snapshot
|
||
}
|
||
return result, nil
|
||
}
|
||
|
||
func validSHA256Hex(value string) bool {
|
||
if len(value) != sha256.Size*2 {
|
||
return false
|
||
}
|
||
decoded, err := hex.DecodeString(value)
|
||
return err == nil && len(decoded) == sha256.Size
|
||
}
|
||
|
||
func rewardSnapshotFromWallet(item *walletv1.ResourceGroupSnapshot) domain.RewardSnapshot {
|
||
if item == nil || item.GetGroup() == nil {
|
||
return domain.RewardSnapshot{}
|
||
}
|
||
out := domain.RewardSnapshot{
|
||
SourceGroupID: item.GetSourceGroupId(), SnapshotID: item.GetSnapshotId(), VersionNo: item.GetVersionNo(),
|
||
SnapshotHash: item.GetSnapshotHash(), Name: item.GetGroup().GetName(), Items: []domain.RewardItem{},
|
||
}
|
||
for _, value := range item.GetGroup().GetItems() {
|
||
reward := domain.RewardItem{
|
||
ItemType: value.GetItemType(), ResourceID: value.GetResourceId(), Quantity: value.GetQuantity(),
|
||
DurationMS: value.GetDurationMs(), WalletAssetType: value.GetWalletAssetType(),
|
||
WalletAssetAmount: value.GetWalletAssetAmount(), SortOrder: value.GetSortOrder(),
|
||
}
|
||
if value.GetResource() != nil {
|
||
reward.ResourceType = value.GetResource().GetResourceType()
|
||
reward.Name = value.GetResource().GetName()
|
||
reward.IconURL = value.GetResource().GetPreviewUrl()
|
||
if reward.IconURL == "" {
|
||
reward.IconURL = value.GetResource().GetAssetUrl()
|
||
}
|
||
} else if reward.WalletAssetType != "" {
|
||
reward.Name = strings.ToUpper(reward.WalletAssetType)
|
||
}
|
||
out.Items = append(out.Items, reward)
|
||
}
|
||
return out
|
||
}
|
||
|
||
func (s *Service) Delete(ctx context.Context, command domain.StatusCommand) (domain.Template, bool, error) {
|
||
if err := s.requireRepository(); err != nil {
|
||
return domain.Template{}, false, err
|
||
}
|
||
command.TemplateID = strings.TrimSpace(command.TemplateID)
|
||
command.Status = domain.StatusArchived
|
||
if command.TemplateID == "" || command.OperatorAdminID <= 0 || command.ExpectedRevision <= 0 {
|
||
return domain.Template{}, false, xerr.New(xerr.InvalidArgument, "template_id, operator_admin_id and expected_revision are required")
|
||
}
|
||
current, err := s.repository.GetActivityTemplate(ctx, command.TemplateID)
|
||
if err != nil {
|
||
return domain.Template{}, false, err
|
||
}
|
||
if current.Revision != command.ExpectedRevision {
|
||
return domain.Template{}, false, xerr.New(xerr.Conflict, "activity template revision changed")
|
||
}
|
||
if current.Status == domain.StatusArchived {
|
||
current.LifecycleStatus = domain.LifecycleArchived
|
||
return current, false, nil
|
||
}
|
||
nowMS := s.now().UTC().UnixMilli()
|
||
if current.Status == domain.StatusPublished && lifecycleStatus(current.Status, current.StartMS, current.EndMS, nowMS) != domain.LifecycleEnded {
|
||
// 正在生效或尚未开始的活动必须先停用，避免 DELETE 瞬间让客户端运行配置消失。
|
||
return domain.Template{}, false, xerr.New(xerr.Conflict, "scheduled or ongoing activity template must be disabled before archive")
|
||
}
|
||
stored, err := s.repository.SetActivityTemplateStatus(ctx, command, nowMS)
|
||
if err != nil {
|
||
return domain.Template{}, false, err
|
||
}
|
||
stored.LifecycleStatus = domain.LifecycleArchived
|
||
return stored, true, nil
|
||
}
|
||
|
||
func (s *Service) ListVersions(ctx context.Context, templateID string, page int32, pageSize int32) ([]domain.Version, int64, error) {
|
||
if err := s.requireRepository(); err != nil {
|
||
return nil, 0, err
|
||
}
|
||
templateID = strings.TrimSpace(templateID)
|
||
if templateID == "" {
|
||
return nil, 0, xerr.New(xerr.InvalidArgument, "template_id is required")
|
||
}
|
||
items, total, err := s.repository.ListActivityTemplateVersions(ctx, templateID, page, pageSize)
|
||
if err != nil {
|
||
return nil, 0, err
|
||
}
|
||
nowMS := s.now().UTC().UnixMilli()
|
||
for index := range items {
|
||
items[index].Snapshot.LifecycleStatus = RuntimeLifecycleStatus(
|
||
items[index].Snapshot, items[index].RuntimeFromMS, items[index].RuntimeToMS, nowMS,
|
||
)
|
||
}
|
||
return items, total, nil
|
||
}
|
||
|
||
func (s *Service) Clone(ctx context.Context, command domain.CloneCommand) (domain.Template, error) {
|
||
if err := s.requireRepository(); err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
command.SourceTemplateID = strings.TrimSpace(command.SourceTemplateID)
|
||
command.TemplateCode = strings.ToLower(strings.TrimSpace(command.TemplateCode))
|
||
command.Name = strings.TrimSpace(command.Name)
|
||
if command.SourceTemplateID == "" || command.OperatorAdminID <= 0 {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "source_template_id and operator_admin_id are required")
|
||
}
|
||
if command.SourceVersion < 0 {
|
||
return domain.Template{}, xerr.New(xerr.InvalidArgument, "source_version must not be negative")
|
||
}
|
||
var source domain.Template
|
||
if command.SourceVersion > 0 {
|
||
version, err := s.repository.GetActivityTemplateVersion(ctx, command.SourceTemplateID, command.SourceVersion)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
source = version.Snapshot
|
||
} else {
|
||
var err error
|
||
source, err = s.repository.GetActivityTemplate(ctx, command.SourceTemplateID)
|
||
if err != nil {
|
||
return domain.Template{}, err
|
||
}
|
||
}
|
||
// 克隆只复用内容，不复制排期和运行身份；清空时间能防止旧活动日期被误发布。
|
||
source.TemplateID = ""
|
||
source.TemplateCode = command.TemplateCode
|
||
source.Name = command.Name
|
||
source.Status = domain.StatusDraft
|
||
source.StartMS = 0
|
||
source.EndMS = 0
|
||
source.Revision = 0
|
||
source.PublishedVersion = 0
|
||
source.CreatedByAdminID = 0
|
||
source.UpdatedByAdminID = 0
|
||
source.PublishedByAdminID = 0
|
||
source.CreatedAtMS = 0
|
||
source.UpdatedAtMS = 0
|
||
source.PublishedAtMS = 0
|
||
source.ArchivedAtMS = 0
|
||
return s.Create(ctx, source, command.OperatorAdminID)
|
||
}
|
||
|
||
// Validate 返回完整字段问题集合，供编辑页一次性标出错误；写接口仍只返回首个错误以保持现有 gRPC 错误模型。
|
||
func (s *Service) Validate(ctx context.Context, template domain.Template, forPublish bool) ([]domain.ValidationIssue, error) {
|
||
template = normalizeTemplate(template)
|
||
issues := validateTemplate(template, forPublish, s.now().UTC().UnixMilli())
|
||
if !forPublish || len(issues) > 0 {
|
||
return issues, nil
|
||
}
|
||
referenceIssues, err := s.validateReferences(ctx, template)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return append(issues, referenceIssues...), nil
|
||
}
|
||
|
||
func (s *Service) requireRepository() error {
|
||
if s == nil || s.repository == nil {
|
||
return xerr.New(xerr.Unavailable, "activity template repository is not configured")
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) validateReferences(ctx context.Context, item domain.Template) ([]domain.ValidationIssue, error) {
|
||
if s == nil || s.catalog == nil {
|
||
return nil, xerr.New(xerr.Unavailable, "wallet catalog client is not configured")
|
||
}
|
||
appCode := appcode.FromContext(ctx)
|
||
requestPrefix := "activity-template-validate:" + item.TemplateID + ":" + strings.TrimSpace(item.TemplateCode)
|
||
issues := make([]domain.ValidationIssue, 0)
|
||
if !item.AllRegions {
|
||
if s.regions == nil {
|
||
return nil, xerr.New(xerr.Unavailable, "region catalog client is not configured")
|
||
}
|
||
activeRegionIDs, err := s.regions.ListActiveRegionIDs(ctx)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
activeRegions := make(map[int64]struct{}, len(activeRegionIDs))
|
||
for _, regionID := range activeRegionIDs {
|
||
activeRegions[regionID] = struct{}{}
|
||
}
|
||
for _, regionID := range item.RegionIDs {
|
||
if _, active := activeRegions[regionID]; !active {
|
||
issues = append(issues, domain.ValidationIssue{Field: "region_ids", Code: "region_not_active", Message: "region " + strconv.FormatInt(regionID, 10) + " does not exist or is not active"})
|
||
}
|
||
}
|
||
}
|
||
for _, snapshot := range item.Gifts {
|
||
resp, err := s.catalog.ListGiftConfigs(ctx, &walletv1.ListGiftConfigsRequest{
|
||
RequestId: requestPrefix + ":gift:" + snapshot.GiftID,
|
||
AppCode: appCode,
|
||
Keyword: snapshot.GiftID,
|
||
Status: "active",
|
||
Page: 1,
|
||
PageSize: 500,
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
var current *walletv1.GiftConfig
|
||
for _, candidate := range resp.GetGifts() {
|
||
if candidate.GetGiftId() == snapshot.GiftID {
|
||
current = candidate
|
||
break
|
||
}
|
||
}
|
||
if current == nil || current.GetResource() == nil || current.GetResource().GetStatus() != "active" {
|
||
issues = append(issues, domain.ValidationIssue{Field: "gifts.gift_id", Code: "gift_not_active", Message: "gift " + snapshot.GiftID + " does not exist or is not active"})
|
||
continue
|
||
}
|
||
// 礼物选择器优先展示 preview_url；未配置预览图时才回退资源原图。发布快照必须使用同一规则，
|
||
// 否则预览图与原图不同的正常礼物会被误判为旧快照。
|
||
ownerIconURL := current.GetResource().GetPreviewUrl()
|
||
if ownerIconURL == "" {
|
||
ownerIconURL = current.GetResource().GetAssetUrl()
|
||
}
|
||
// 发布快照必须与 owner 当前价格版本一致；只验证不自动改写，避免管理员在未察觉价格变化时发布旧展示值。
|
||
if snapshot.Name != current.GetName() || snapshot.IconURL != ownerIconURL || snapshot.CoinPrice != current.GetCoinPrice() || snapshot.PriceVersion != current.GetPriceVersion() {
|
||
issues = append(issues, domain.ValidationIssue{Field: "gifts", Code: "gift_snapshot_stale", Message: "gift " + snapshot.GiftID + " snapshot is stale; reselect the gift before publishing"})
|
||
}
|
||
// 礼物有效期必须覆盖完整活动区间。只检查“当前可用”会让未来活动在开场前或进行中失去计分礼物。
|
||
if (current.GetEffectiveFromMs() > 0 && current.GetEffectiveFromMs() > item.StartMS) ||
|
||
(current.GetEffectiveToMs() > 0 && current.GetEffectiveToMs() < item.EndMS) {
|
||
issues = append(issues, domain.ValidationIssue{Field: "gifts", Code: "gift_period_mismatch", Message: "gift " + snapshot.GiftID + " effective period does not cover the activity period"})
|
||
}
|
||
if !giftSupportsActivityScope(current.GetRegionIds(), item.AllRegions, item.RegionIDs) {
|
||
issues = append(issues, domain.ValidationIssue{Field: "gifts", Code: "gift_region_mismatch", Message: "gift " + snapshot.GiftID + " is not active for every activity region"})
|
||
}
|
||
}
|
||
|
||
groupIDs := map[int64]struct{}{}
|
||
for _, task := range item.Tasks {
|
||
if task.RewardResourceGroupID > 0 {
|
||
groupIDs[task.RewardResourceGroupID] = struct{}{}
|
||
}
|
||
}
|
||
for _, reward := range item.RankRewards {
|
||
if reward.ResourceGroupID > 0 {
|
||
groupIDs[reward.ResourceGroupID] = struct{}{}
|
||
}
|
||
}
|
||
for groupID := range groupIDs {
|
||
resp, err := s.catalog.GetResourceGroup(ctx, &walletv1.GetResourceGroupRequest{
|
||
RequestId: requestPrefix + ":resource-group:" + strconv.FormatInt(groupID, 10),
|
||
AppCode: appCode,
|
||
GroupId: groupID,
|
||
})
|
||
if err != nil {
|
||
if xerr.IsCode(err, xerr.NotFound) {
|
||
issues = append(issues, domain.ValidationIssue{Field: "resource_group_id", Code: "resource_group_not_found", Message: "resource group does not exist"})
|
||
continue
|
||
}
|
||
return nil, err
|
||
}
|
||
group := resp.GetGroup()
|
||
if group == nil || group.GetStatus() != "active" || len(group.GetItems()) == 0 || !validSHA256Hex(strings.ToLower(strings.TrimSpace(resp.GetSourceContentHash()))) {
|
||
issues = append(issues, domain.ValidationIssue{Field: "resource_group_id", Code: "resource_group_not_active", Message: "resource group must be active and contain at least one item"})
|
||
continue
|
||
}
|
||
for _, groupItem := range group.GetItems() {
|
||
if groupItem.GetItemType() == "wallet_asset" {
|
||
if strings.ToUpper(groupItem.GetWalletAssetType()) != "COIN" || groupItem.GetWalletAssetAmount() <= 0 || groupItem.GetResourceId() != 0 || groupItem.GetQuantity() != 1 || groupItem.GetDurationMs() != 0 {
|
||
issues = append(issues, domain.ValidationIssue{Field: "resource_group_id", Code: "resource_group_item_invalid", Message: "resource group contains an invalid wallet asset item"})
|
||
}
|
||
continue
|
||
}
|
||
resource := groupItem.GetResource()
|
||
if resource == nil || resource.GetStatus() != "active" || !resource.GetGrantable() || resource.GetResourceType() == "coin" || resource.GetResourceType() == "vip_trial_card" ||
|
||
groupItem.GetResourceId() <= 0 || groupItem.GetQuantity() <= 0 || groupItem.GetDurationMs() < 0 {
|
||
issues = append(issues, domain.ValidationIssue{Field: "resource_group_id", Code: "resource_group_item_invalid", Message: "resource group contains an inactive or unsupported resource"})
|
||
}
|
||
}
|
||
}
|
||
return deduplicateIssues(issues), nil
|
||
}
|
||
|
||
func giftSupportsActivityScope(giftRegionIDs []int64, allRegions bool, activityRegionIDs []int64) bool {
|
||
available := make(map[int64]struct{}, len(giftRegionIDs))
|
||
for _, regionID := range giftRegionIDs {
|
||
available[regionID] = struct{}{}
|
||
}
|
||
if _, global := available[0]; global {
|
||
return true
|
||
}
|
||
if allRegions {
|
||
return false
|
||
}
|
||
for _, regionID := range activityRegionIDs {
|
||
if _, ok := available[regionID]; !ok {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
func normalizeTemplate(item domain.Template) domain.Template {
|
||
item.TemplateID = strings.TrimSpace(item.TemplateID)
|
||
item.TemplateCode = strings.ToLower(strings.TrimSpace(item.TemplateCode))
|
||
item.Name = strings.TrimSpace(item.Name)
|
||
item.ActivityType = strings.ToLower(strings.TrimSpace(item.ActivityType))
|
||
if item.ActivityType == "" {
|
||
item.ActivityType = domain.ActivityTypeGiftChallenge
|
||
}
|
||
item.Status = normalizeStatus(item.Status)
|
||
if item.Status == "" {
|
||
item.Status = domain.StatusDraft
|
||
}
|
||
if item.DailyLeaderboardSize == 0 {
|
||
item.DailyLeaderboardSize = defaultLeaderboardSize
|
||
}
|
||
if item.TotalLeaderboardSize == 0 {
|
||
item.TotalLeaderboardSize = defaultLeaderboardSize
|
||
}
|
||
item.DisplayConfigJSON = strings.TrimSpace(item.DisplayConfigJSON)
|
||
if item.DisplayConfigJSON == "" {
|
||
item.DisplayConfigJSON = "{}"
|
||
}
|
||
|
||
regions := append([]int64(nil), item.RegionIDs...)
|
||
sort.Slice(regions, func(i, j int) bool { return regions[i] < regions[j] })
|
||
item.RegionIDs = regions
|
||
for index := range item.Locales {
|
||
item.Locales[index].Locale = normalizeLocale(item.Locales[index].Locale)
|
||
item.Locales[index].Title = strings.TrimSpace(item.Locales[index].Title)
|
||
item.Locales[index].Rules = strings.TrimSpace(item.Locales[index].Rules)
|
||
}
|
||
sort.SliceStable(item.Locales, func(i, j int) bool { return item.Locales[i].Locale < item.Locales[j].Locale })
|
||
for index := range item.Gifts {
|
||
item.Gifts[index].GiftID = strings.TrimSpace(item.Gifts[index].GiftID)
|
||
item.Gifts[index].Name = strings.TrimSpace(item.Gifts[index].Name)
|
||
item.Gifts[index].IconURL = strings.TrimSpace(item.Gifts[index].IconURL)
|
||
item.Gifts[index].PriceVersion = strings.TrimSpace(item.Gifts[index].PriceVersion)
|
||
}
|
||
sort.SliceStable(item.Gifts, func(i, j int) bool {
|
||
if item.Gifts[i].SortOrder == item.Gifts[j].SortOrder {
|
||
return item.Gifts[i].GiftID < item.Gifts[j].GiftID
|
||
}
|
||
return item.Gifts[i].SortOrder < item.Gifts[j].SortOrder
|
||
})
|
||
for index := range item.Tasks {
|
||
item.Tasks[index].TaskKey = strings.ToLower(strings.TrimSpace(item.Tasks[index].TaskKey))
|
||
item.Tasks[index].TaskType = strings.ToLower(strings.TrimSpace(item.Tasks[index].TaskType))
|
||
}
|
||
sort.SliceStable(item.Tasks, func(i, j int) bool {
|
||
if item.Tasks[i].SortOrder == item.Tasks[j].SortOrder {
|
||
return item.Tasks[i].TaskKey < item.Tasks[j].TaskKey
|
||
}
|
||
return item.Tasks[i].SortOrder < item.Tasks[j].SortOrder
|
||
})
|
||
for index := range item.RankRewards {
|
||
item.RankRewards[index].BoardType = strings.ToLower(strings.TrimSpace(item.RankRewards[index].BoardType))
|
||
}
|
||
sort.SliceStable(item.RankRewards, func(i, j int) bool {
|
||
if item.RankRewards[i].BoardType != item.RankRewards[j].BoardType {
|
||
return item.RankRewards[i].BoardType < item.RankRewards[j].BoardType
|
||
}
|
||
if item.RankRewards[i].RankFrom != item.RankRewards[j].RankFrom {
|
||
return item.RankRewards[i].RankFrom < item.RankRewards[j].RankFrom
|
||
}
|
||
return item.RankRewards[i].RankTo < item.RankRewards[j].RankTo
|
||
})
|
||
for index := range item.Assets {
|
||
item.Assets[index].AssetKey = strings.ToLower(strings.TrimSpace(item.Assets[index].AssetKey))
|
||
item.Assets[index].Locale = normalizeLocale(item.Assets[index].Locale)
|
||
if item.Assets[index].Locale == "" {
|
||
item.Assets[index].Locale = domain.SharedAssetLocale
|
||
}
|
||
item.Assets[index].URL = strings.TrimSpace(item.Assets[index].URL)
|
||
item.Assets[index].MediaType = strings.ToLower(strings.TrimSpace(item.Assets[index].MediaType))
|
||
}
|
||
sort.SliceStable(item.Assets, func(i, j int) bool {
|
||
if item.Assets[i].AssetKey != item.Assets[j].AssetKey {
|
||
return item.Assets[i].AssetKey < item.Assets[j].AssetKey
|
||
}
|
||
if item.Assets[i].Locale != item.Assets[j].Locale {
|
||
return item.Assets[i].Locale < item.Assets[j].Locale
|
||
}
|
||
return item.Assets[i].SortOrder < item.Assets[j].SortOrder
|
||
})
|
||
return item
|
||
}
|
||
|
||
func validateTemplate(item domain.Template, forPublish bool, nowMS int64) []domain.ValidationIssue {
|
||
issues := make([]domain.ValidationIssue, 0)
|
||
add := func(field string, code string, message string) {
|
||
issues = append(issues, domain.ValidationIssue{Field: field, Code: code, Message: message})
|
||
}
|
||
if !templateCodePattern.MatchString(item.TemplateCode) {
|
||
add("template_code", "invalid_format", "template_code must be 3-64 lowercase letters, numbers, underscore or hyphen")
|
||
}
|
||
if utf8.RuneCountInString(item.Name) == 0 || utf8.RuneCountInString(item.Name) > 128 {
|
||
add("name", "invalid_length", "name is required and must not exceed 128 characters")
|
||
}
|
||
if item.ActivityType != domain.ActivityTypeGiftChallenge {
|
||
add("activity_type", "unsupported", "activity_type is not supported")
|
||
}
|
||
if item.Status != domain.StatusDraft && item.Status != domain.StatusDisabled && item.Status != domain.StatusPublished {
|
||
add("status", "invalid", "status is invalid")
|
||
}
|
||
if item.StartMS != 0 || item.EndMS != 0 || forPublish {
|
||
if item.StartMS <= 0 || item.EndMS <= item.StartMS {
|
||
add("time_range", "invalid_range", "activity period must use [start_ms,end_ms)")
|
||
} else if item.EndMS-item.StartMS > maxActivityDurationMS {
|
||
add("time_range", "duration_too_long", "activity period must not exceed 366 days")
|
||
}
|
||
}
|
||
if forPublish && item.EndMS <= nowMS {
|
||
add("end_ms", "already_ended", "activity end_ms must be later than current UTC time")
|
||
}
|
||
|
||
seenRegions := map[int64]struct{}{}
|
||
for index, regionID := range item.RegionIDs {
|
||
if regionID <= 0 {
|
||
add("region_ids", "invalid_region", "region_ids must contain positive IDs")
|
||
}
|
||
if _, exists := seenRegions[regionID]; exists {
|
||
add("region_ids", "duplicate_region", "region_ids must not contain duplicates")
|
||
}
|
||
seenRegions[regionID] = struct{}{}
|
||
_ = index
|
||
}
|
||
if item.AllRegions && len(item.RegionIDs) > 0 {
|
||
add("region_ids", "scope_conflict", "all_regions cannot be combined with region_ids")
|
||
}
|
||
if forPublish && !item.AllRegions && len(item.RegionIDs) == 0 {
|
||
add("region_ids", "required", "at least one region is required when all_regions is false")
|
||
}
|
||
if len(item.RegionIDs) > 100 {
|
||
add("region_ids", "too_many", "region_ids must not exceed 100")
|
||
}
|
||
|
||
seenLocales := map[string]struct{}{}
|
||
hasEnglish := false
|
||
for _, locale := range item.Locales {
|
||
if len(locale.Locale) > 24 || !localePattern.MatchString(locale.Locale) {
|
||
add("locales", "invalid_locale", "locale must be a lowercase BCP-47 language tag")
|
||
}
|
||
if _, exists := seenLocales[locale.Locale]; exists {
|
||
add("locales", "duplicate_locale", "locale must be unique")
|
||
}
|
||
seenLocales[locale.Locale] = struct{}{}
|
||
if locale.Locale == "en" {
|
||
hasEnglish = true
|
||
}
|
||
if utf8.RuneCountInString(locale.Title) > 160 {
|
||
add("locales.title", "too_long", "localized title must not exceed 160 characters")
|
||
}
|
||
if len(locale.Rules) > 32*1024 {
|
||
add("locales.rules", "too_long", "localized rules must not exceed 32KB")
|
||
}
|
||
if forPublish && (locale.Title == "" || locale.Rules == "") {
|
||
add("locales", "content_required", "localized title and rules are required for publish")
|
||
}
|
||
}
|
||
if forPublish && !hasEnglish {
|
||
add("locales", "english_required", "English title and rules are required for publish")
|
||
}
|
||
if len(item.Locales) > 20 {
|
||
add("locales", "too_many", "locales must not exceed 20")
|
||
}
|
||
|
||
seenGifts := map[string]struct{}{}
|
||
for _, gift := range item.Gifts {
|
||
if gift.GiftID == "" {
|
||
add("gifts.gift_id", "required", "gift_id is required")
|
||
} else if len(gift.GiftID) > 96 {
|
||
add("gifts.gift_id", "too_long", "gift_id must not exceed 96 bytes")
|
||
}
|
||
if _, exists := seenGifts[gift.GiftID]; exists {
|
||
add("gifts", "duplicate_gift", "gift_id must be unique")
|
||
}
|
||
seenGifts[gift.GiftID] = struct{}{}
|
||
if gift.CoinPrice < 0 {
|
||
add("gifts.coin_price", "invalid", "coin_price must not be negative")
|
||
}
|
||
if utf8.RuneCountInString(gift.Name) > 128 || len(gift.IconURL) > 512 || len(gift.PriceVersion) > 64 {
|
||
add("gifts", "snapshot_too_long", "gift snapshot exceeds storage limits")
|
||
}
|
||
if gift.SortOrder < 0 {
|
||
add("gifts.sort_order", "invalid", "sort_order must not be negative")
|
||
}
|
||
if forPublish {
|
||
if gift.Name == "" || gift.IconURL == "" || gift.CoinPrice <= 0 || gift.PriceVersion == "" {
|
||
add("gifts", "snapshot_required", "published gifts require name, icon_url, positive coin_price and price_version snapshots")
|
||
} else if !validHTTPURL(gift.IconURL) {
|
||
add("gifts.icon_url", "invalid_url", "gift icon_url must be an absolute http or https URL")
|
||
}
|
||
}
|
||
}
|
||
if len(item.Gifts) > 20 {
|
||
add("gifts", "too_many", "gifts must not exceed 20")
|
||
} else if forPublish && len(item.Gifts) == 0 {
|
||
add("gifts", "required", "published activity requires at least one gift")
|
||
}
|
||
|
||
seenTasks := map[string]struct{}{}
|
||
dailyVisitTaskCount := 0
|
||
for _, task := range item.Tasks {
|
||
if !taskKeyPattern.MatchString(task.TaskKey) {
|
||
add("tasks.task_key", "invalid_format", "task_key format is invalid")
|
||
}
|
||
if _, exists := seenTasks[task.TaskKey]; exists {
|
||
add("tasks", "duplicate_task", "task_key must be unique")
|
||
}
|
||
seenTasks[task.TaskKey] = struct{}{}
|
||
if !validTaskType(task.TaskType) {
|
||
add("tasks.task_type", "unsupported", "task_type is not supported")
|
||
}
|
||
if task.TargetValue <= 0 {
|
||
add("tasks.target_value", "invalid", "target_value must be positive")
|
||
}
|
||
if task.TaskType == domain.TaskTypeDailyVisit && task.TargetValue != 1 {
|
||
add("tasks.target_value", "daily_visit_target", "daily_visit target_value must equal 1")
|
||
}
|
||
if task.TaskType == domain.TaskTypeDailyVisit {
|
||
dailyVisitTaskCount++
|
||
}
|
||
if task.SortOrder < 0 {
|
||
add("tasks.sort_order", "invalid", "sort_order must not be negative")
|
||
}
|
||
if forPublish && task.RewardResourceGroupID <= 0 {
|
||
add("tasks.reward_resource_group_id", "required", "task reward resource group is required for publish")
|
||
}
|
||
}
|
||
// daily_visit 的事实粒度固定为“用户 + 模版版本 + UTC 自然日”一次。允许配置多档会让同一次访问
|
||
// 同时生成多份入场奖励，既违背原型的单档语义，也容易被运营误配，因此 owner 层必须强制唯一。
|
||
if dailyVisitTaskCount > 1 {
|
||
add("tasks", "duplicate_daily_visit", "daily_visit task must not appear more than once")
|
||
}
|
||
if len(item.Tasks) > 30 {
|
||
add("tasks", "too_many", "tasks must not exceed 30")
|
||
} else if forPublish && len(item.Tasks) == 0 {
|
||
add("tasks", "required", "published activity requires at least one task")
|
||
}
|
||
|
||
if item.DailyLeaderboardSize < 3 || item.DailyLeaderboardSize > 1000 {
|
||
add("daily_leaderboard_size", "out_of_range", "daily_leaderboard_size must be between 3 and 1000")
|
||
}
|
||
if item.TotalLeaderboardSize < 3 || item.TotalLeaderboardSize > 1000 {
|
||
add("total_leaderboard_size", "out_of_range", "total_leaderboard_size must be between 3 and 1000")
|
||
}
|
||
for _, boardType := range []string{domain.BoardTypeDaily, domain.BoardTypeTotal} {
|
||
boardRewards := make([]domain.RankReward, 0)
|
||
for _, reward := range item.RankRewards {
|
||
if reward.BoardType == boardType {
|
||
boardRewards = append(boardRewards, reward)
|
||
}
|
||
}
|
||
sort.Slice(boardRewards, func(i, j int) bool { return boardRewards[i].RankFrom < boardRewards[j].RankFrom })
|
||
if forPublish && len(boardRewards) == 0 {
|
||
add("rank_rewards", "board_required", boardType+" leaderboard reward is required for publish")
|
||
}
|
||
previousTo := int32(0)
|
||
for _, reward := range boardRewards {
|
||
limit := item.DailyLeaderboardSize
|
||
if boardType == domain.BoardTypeTotal {
|
||
limit = item.TotalLeaderboardSize
|
||
}
|
||
if reward.RankFrom <= 0 || reward.RankTo < reward.RankFrom || reward.RankTo > limit {
|
||
add("rank_rewards", "invalid_range", "rank reward range is outside leaderboard size")
|
||
}
|
||
if previousTo > 0 && reward.RankFrom <= previousTo {
|
||
add("rank_rewards", "overlap", "rank reward ranges must not overlap")
|
||
}
|
||
if forPublish && reward.ResourceGroupID <= 0 {
|
||
add("rank_rewards.resource_group_id", "required", "rank reward resource group is required for publish")
|
||
}
|
||
previousTo = reward.RankTo
|
||
}
|
||
}
|
||
for _, reward := range item.RankRewards {
|
||
if reward.BoardType != domain.BoardTypeDaily && reward.BoardType != domain.BoardTypeTotal {
|
||
add("rank_rewards.board_type", "unsupported", "board_type must be daily or total")
|
||
}
|
||
if reward.SortOrder < 0 {
|
||
add("rank_rewards.sort_order", "invalid", "sort_order must not be negative")
|
||
}
|
||
}
|
||
if len(item.RankRewards) > maxRankRewardRanges {
|
||
add("rank_rewards", "too_many", "rank reward ranges must not exceed 100")
|
||
}
|
||
|
||
seenAssets := map[string]struct{}{}
|
||
for _, asset := range item.Assets {
|
||
if !assetKeyPattern.MatchString(asset.AssetKey) {
|
||
add("assets.asset_key", "invalid_format", "asset_key format is invalid")
|
||
}
|
||
if asset.Locale != domain.SharedAssetLocale && (len(asset.Locale) > 24 || !localePattern.MatchString(asset.Locale)) {
|
||
add("assets.locale", "invalid_locale", "asset locale must be * or a lowercase BCP-47 tag")
|
||
}
|
||
key := asset.AssetKey + "\x00" + asset.Locale
|
||
if _, exists := seenAssets[key]; exists {
|
||
add("assets", "duplicate_asset", "asset_key and locale combination must be unique")
|
||
}
|
||
seenAssets[key] = struct{}{}
|
||
if asset.URL == "" || len(asset.URL) > 1024 || !validHTTPURL(asset.URL) {
|
||
add("assets.url", "invalid_url", "asset URL must be an absolute http or https URL")
|
||
}
|
||
if !validMediaType(asset.MediaType) {
|
||
add("assets.media_type", "unsupported", "media_type must be image, webp, svga or pag")
|
||
}
|
||
if asset.SortOrder < 0 {
|
||
add("assets.sort_order", "invalid", "sort_order must not be negative")
|
||
}
|
||
}
|
||
if len(item.Assets) > 100 {
|
||
add("assets", "too_many", "assets must not exceed 100")
|
||
}
|
||
if len(item.DisplayConfigJSON) > maxDisplayConfigBytes {
|
||
add("display_config_json", "too_large", "display_config_json must not exceed 64KB")
|
||
} else {
|
||
var display map[string]any
|
||
if err := json.Unmarshal([]byte(item.DisplayConfigJSON), &display); err != nil || display == nil {
|
||
add("display_config_json", "invalid_json", "display_config_json must be a JSON object")
|
||
}
|
||
}
|
||
return deduplicateIssues(issues)
|
||
}
|
||
|
||
func lifecycleStatus(status string, startMS int64, endMS int64, nowMS int64) string {
|
||
switch status {
|
||
case domain.StatusDraft:
|
||
return domain.LifecycleDraft
|
||
case domain.StatusDisabled:
|
||
return domain.LifecycleDisabled
|
||
case domain.StatusArchived:
|
||
return domain.LifecycleArchived
|
||
case domain.StatusPublished:
|
||
// 边界与全局规则一致：[start_ms,end_ms)，开始毫秒立即 ongoing，结束毫秒立即 ended。
|
||
if nowMS < startMS {
|
||
return domain.LifecycleScheduled
|
||
}
|
||
if nowMS >= endMS {
|
||
return domain.LifecycleEnded
|
||
}
|
||
return domain.LifecycleOngoing
|
||
default:
|
||
return status
|
||
}
|
||
}
|
||
|
||
// RuntimeLifecycleStatus derives presentation state from an immutable version's actual runtime window.
|
||
// A mid-flight disable remains disabled even after a newer version is published; planned start/end alone
|
||
// would otherwise make both v1 and v2 appear ongoing for the same wall-clock instant.
|
||
func RuntimeLifecycleStatus(item domain.Template, runtimeFromMS int64, runtimeToMS int64, nowMS int64) string {
|
||
switch item.Status {
|
||
case domain.StatusDraft:
|
||
return domain.LifecycleDraft
|
||
case domain.StatusArchived:
|
||
return domain.LifecycleArchived
|
||
}
|
||
if runtimeFromMS <= 0 {
|
||
// Compatibility for versions created before runtime windows were materialized. New publishes always
|
||
// join a positive runtime_from_ms, but old data must still produce a useful planned lifecycle.
|
||
runtimeFromMS = item.StartMS
|
||
}
|
||
if runtimeToMS > 0 && runtimeToMS < item.EndMS && nowMS >= runtimeToMS {
|
||
return domain.LifecycleDisabled
|
||
}
|
||
if nowMS < runtimeFromMS {
|
||
return domain.LifecycleScheduled
|
||
}
|
||
if nowMS >= item.EndMS || (runtimeToMS > 0 && nowMS >= runtimeToMS) {
|
||
return domain.LifecycleEnded
|
||
}
|
||
return domain.LifecycleOngoing
|
||
}
|
||
|
||
func normalizeStatus(value string) string {
|
||
return strings.ToLower(strings.TrimSpace(value))
|
||
}
|
||
|
||
func normalizeLocale(value string) string {
|
||
return strings.ToLower(strings.ReplaceAll(strings.TrimSpace(value), "_", "-"))
|
||
}
|
||
|
||
func validTaskType(value string) bool {
|
||
switch value {
|
||
case domain.TaskTypeDailyVisit, domain.TaskTypeGiftCount, domain.TaskTypeGiftCoinAmount:
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func validMediaType(value string) bool {
|
||
switch value {
|
||
case "image", "webp", "svga", "pag":
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func validListStatus(value string) bool {
|
||
switch value {
|
||
case "", domain.StatusDraft, domain.StatusPublished, domain.StatusDisabled, domain.StatusArchived,
|
||
domain.LifecycleScheduled, domain.LifecycleOngoing, domain.LifecycleEnded, "active":
|
||
return true
|
||
default:
|
||
return false
|
||
}
|
||
}
|
||
|
||
func validHTTPURL(value string) bool {
|
||
parsed, err := url.ParseRequestURI(value)
|
||
return err == nil && parsed.Host != "" && (parsed.Scheme == "http" || parsed.Scheme == "https")
|
||
}
|
||
|
||
func issueError(issue domain.ValidationIssue) error {
|
||
return xerr.New(xerr.InvalidArgument, issue.Field+": "+issue.Message)
|
||
}
|
||
|
||
func deduplicateIssues(items []domain.ValidationIssue) []domain.ValidationIssue {
|
||
seen := map[string]struct{}{}
|
||
out := make([]domain.ValidationIssue, 0, len(items))
|
||
for _, item := range items {
|
||
key := item.Field + "\x00" + item.Code + "\x00" + item.Message
|
||
if _, exists := seen[key]; exists {
|
||
continue
|
||
}
|
||
seen[key] = struct{}{}
|
||
out = append(out, item)
|
||
}
|
||
return out
|
||
}
|