package packagesilence import ( "context" "slices" "strings" "time" "gorm.io/gorm" packagedomain "github.com/break/junhong_cmp_fiber/internal/domain/package" "github.com/break/junhong_cmp_fiber/internal/infrastructure/audit" "github.com/break/junhong_cmp_fiber/internal/model" "github.com/break/junhong_cmp_fiber/internal/model/dto" "github.com/break/junhong_cmp_fiber/internal/store/postgres" "github.com/break/junhong_cmp_fiber/pkg/constants" "github.com/break/junhong_cmp_fiber/pkg/errors" "github.com/break/junhong_cmp_fiber/pkg/middleware" ) // PolicyService 管理沉默期延期政策(技术方案 §3.6)。权限点 package_silence:policy 在路由层校验。 type PolicyService struct { db *gorm.DB audit *audit.Writer perms PermissionChecker now func() time.Time } // SetPermissionChecker 注入权限校验(package_silence:policy)。 func (s *PolicyService) SetPermissionChecker(checker PermissionChecker) { s.perms = checker } // NewPolicyService 创建延期政策用例。 func NewPolicyService(db *gorm.DB, writer *audit.Writer) *PolicyService { return &PolicyService{db: db, audit: writer, now: time.Now} } // List 分页查询延期政策。 func (s *PolicyService) List(ctx context.Context, req *dto.SilencePolicyListRequest) ([]*dto.SilencePolicyResponse, int64, error) { if err := requirePermission(ctx, s.perms, constants.PermissionPackageSilencePolicy); err != nil { return nil, 0, err } page, pageSize := normalizePage(req.Page, req.PageSize) query := s.db.WithContext(ctx).Model(&model.PackageSilenceExtensionPolicy{}) if name := strings.TrimSpace(req.Name); name != "" { query = query.Where("name LIKE ?", "%"+name+"%") } if req.ScopeType != "" { query = query.Where("scope_type = ?", req.ScopeType) } if req.Status != nil { query = query.Where("status = ?", *req.Status) } if req.EffectiveAt != "" { at, err := time.Parse(time.RFC3339, req.EffectiveAt) if err != nil { return nil, 0, errors.New(errors.CodeInvalidParam, "生效时间格式应为 RFC3339") } query = query.Where("effective_from <= ? AND (effective_to IS NULL OR effective_to > ?)", at, at) } var total int64 if err := query.Count(&total).Error; err != nil { return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "统计延期政策失败") } var policies []model.PackageSilenceExtensionPolicy if err := query.Order("id DESC").Offset((page - 1) * pageSize).Limit(pageSize).Find(&policies).Error; err != nil { return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "查询延期政策失败") } items := make([]*dto.SilencePolicyResponse, 0, len(policies)) for index := range policies { items = append(items, policyResponse(&policies[index])) } return items, total, nil } // Get 查询政策详情。 func (s *PolicyService) Get(ctx context.Context, id uint) (*dto.SilencePolicyResponse, error) { if err := requirePermission(ctx, s.perms, constants.PermissionPackageSilencePolicy); err != nil { return nil, err } policy, err := postgres.NewPackageSilencePolicyStore(s.db).GetByID(ctx, id) if err != nil { if err == gorm.ErrRecordNotFound { return nil, errors.New(errors.CodeNotFound, "延期政策不存在") } return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询延期政策失败") } return policyResponse(policy), nil } // Create 新增政策:校验字段、同级重叠,写审计。 func (s *PolicyService) Create(ctx context.Context, req *dto.SilencePolicyRequest) (*dto.SilencePolicyResponse, error) { if err := requirePermission(ctx, s.perms, constants.PermissionPackageSilencePolicy); err != nil { return nil, err } operatorID := middleware.GetUserIDFromContext(ctx) policy := &model.PackageSilenceExtensionPolicy{Creator: operatorID, Updater: operatorID, Status: constants.SilencePolicyStatusEnabled} if err := applyPolicyRequest(policy, req); err != nil { return nil, err } err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { store := postgres.NewPackageSilencePolicyStore(tx) if err := store.LockAll(ctx); err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "锁定延期政策失败") } if err := s.validateInTx(ctx, tx, policy); err != nil { return err } now := s.now() policy.CreatedAt, policy.UpdatedAt = now, now if err := store.Create(ctx, policy); err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "新增延期政策失败") } return s.writeAudit(ctx, tx, constants.AuditActionSilencePolicyCreated, "新增沉默期延期政策", policy, nil, policyAuditData(policy)) }) if err != nil { return nil, err } return policyResponse(policy), nil } // Update 编辑政策:只影响之后发起的延期,已创建订单与已提交审批按快照执行。 func (s *PolicyService) Update(ctx context.Context, id uint, req *dto.SilencePolicyRequest) (*dto.SilencePolicyResponse, error) { if err := requirePermission(ctx, s.perms, constants.PermissionPackageSilencePolicy); err != nil { return nil, err } var policy *model.PackageSilenceExtensionPolicy err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { store := postgres.NewPackageSilencePolicyStore(tx) if err := store.LockAll(ctx); err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "锁定延期政策失败") } current, err := store.GetByID(ctx, id) if err != nil { if err == gorm.ErrRecordNotFound { return errors.New(errors.CodeNotFound, "延期政策不存在") } return errors.Wrap(errors.CodeDatabaseError, err, "查询延期政策失败") } before := policyAuditData(current) if err := applyPolicyRequest(current, req); err != nil { return err } if err := s.validateInTx(ctx, tx, current); err != nil { return err } current.Updater = middleware.GetUserIDFromContext(ctx) current.UpdatedAt = s.now() if _, err := store.Update(ctx, current.ID, map[string]any{ "name": current.Name, "scope_type": current.ScopeType, "scope_ids": current.ScopeIDs, "unit_price": current.UnitPrice, "free_extension_limit": current.FreeExtensionLimit, "paid_max_months": current.PaidMaxMonths, "single_max_months": current.SingleMaxMonths, "approval_exempt_types": current.ApprovalExemptTypes, "effective_from": current.EffectiveFrom, "effective_to": current.EffectiveTo, "status": current.Status, "remark": current.Remark, "updater": current.Updater, "updated_at": current.UpdatedAt, }); err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "更新延期政策失败") } policy = current return s.writeAudit(ctx, tx, constants.AuditActionSilencePolicyUpdated, "修改沉默期延期政策", current, before, policyAuditData(current)) }) if err != nil { return nil, err } return policyResponse(policy), nil } // SetStatus 启停政策;启用时同样做重叠校验。 func (s *PolicyService) SetStatus(ctx context.Context, id uint, status int) (*dto.SilencePolicyResponse, error) { if err := requirePermission(ctx, s.perms, constants.PermissionPackageSilencePolicy); err != nil { return nil, err } if status != constants.SilencePolicyStatusEnabled && status != constants.SilencePolicyStatusDisabled { return nil, errors.New(errors.CodeInvalidParam, "政策状态非法") } var policy *model.PackageSilenceExtensionPolicy err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { store := postgres.NewPackageSilencePolicyStore(tx) if err := store.LockAll(ctx); err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "锁定延期政策失败") } current, err := store.GetByID(ctx, id) if err != nil { if err == gorm.ErrRecordNotFound { return errors.New(errors.CodeNotFound, "延期政策不存在") } return errors.Wrap(errors.CodeDatabaseError, err, "查询延期政策失败") } before := current.Status if before == status { policy = current return nil } current.Status = status if status == constants.SilencePolicyStatusEnabled { if err := s.validateOverlapInTx(ctx, tx, current); err != nil { return err } } current.Updater = middleware.GetUserIDFromContext(ctx) if _, err := store.Update(ctx, current.ID, map[string]any{"status": status, "updater": current.Updater, "updated_at": s.now()}); err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "更新延期政策状态失败") } policy = current return s.writeAudit(ctx, tx, constants.AuditActionSilencePolicyStatusChanged, "启停沉默期延期政策", current, map[string]any{"status": before}, map[string]any{"status": status}) }) if err != nil { return nil, err } return policyResponse(policy), nil } // MatchForPackage 查询某套餐当前匹配的政策。 func (s *PolicyService) MatchForPackage(ctx context.Context, packageID uint) (*dto.SilencePolicyMatchResponse, error) { match, _, err := matchPolicyForPackage(ctx, s.db, packageID, s.now()) if err != nil { return nil, err } resp := &dto.SilencePolicyMatchResponse{PackageID: packageID, Matched: match.Policy != nil} if match.Policy != nil { resp.Policy = policyResponse(match.Policy) } return resp, nil } func applyPolicyRequest(policy *model.PackageSilenceExtensionPolicy, req *dto.SilencePolicyRequest) error { name := strings.TrimSpace(req.Name) if name == "" || len([]rune(name)) > constants.SilencePolicyNameMaxLen { return errors.New(errors.CodeInvalidParam, "政策名称不能为空且不超过 100 字") } scopeIDs := dedupeUint(req.ScopeIDs) switch req.ScopeType { case constants.SilencePolicyScopeAll: scopeIDs = nil case constants.SilencePolicyScopeSeries, constants.SilencePolicyScopePackage: if len(scopeIDs) == 0 { return errors.New(errors.CodeInvalidParam, "按系列或指定套餐适用时必须选择适用范围") } default: return errors.New(errors.CodeInvalidParam, "适用范围非法") } for _, exempt := range req.ApprovalExemptTypes { if !slices.Contains(constants.SilenceApprovalExemptTypes, exempt) { return errors.New(errors.CodeInvalidParam, "免审批场景非法") } } if req.EffectiveTo != nil && !req.EffectiveTo.After(req.EffectiveFrom) { return errors.New(errors.CodeInvalidParam, "失效时间必须晚于生效时间") } if req.UnitPrice < 0 || req.FreeExtensionLimit < 0 || req.PaidMaxMonths < 0 { return errors.New(errors.CodeInvalidParam, "单价、免费次数与付费累计月数不能为负数") } policy.Name = name policy.ScopeType = req.ScopeType policy.ScopeIDs = model.UintJSONBArray(scopeIDs) if policy.ScopeIDs == nil { policy.ScopeIDs = model.UintJSONBArray{} } policy.UnitPrice = req.UnitPrice policy.FreeExtensionLimit = req.FreeExtensionLimit policy.PaidMaxMonths = req.PaidMaxMonths policy.SingleMaxMonths = req.SingleMaxMonths policy.ApprovalExemptTypes = model.StringJSONBArray(dedupeString(req.ApprovalExemptTypes)) if policy.ApprovalExemptTypes == nil { policy.ApprovalExemptTypes = model.StringJSONBArray{} } policy.EffectiveFrom = req.EffectiveFrom policy.EffectiveTo = req.EffectiveTo if req.Status != nil { policy.Status = *req.Status } policy.Remark = strings.TrimSpace(req.Remark) return nil } func (s *PolicyService) validateInTx(ctx context.Context, tx *gorm.DB, policy *model.PackageSilenceExtensionPolicy) error { var sameName int64 if err := tx.WithContext(ctx).Model(&model.PackageSilenceExtensionPolicy{}). Where("name = ? AND id <> ?", policy.Name, policy.ID).Count(&sameName).Error; err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "校验政策名称失败") } if sameName > 0 { return errors.New(errors.CodeConflict, "政策名称已存在") } if err := s.validateScopeIDs(ctx, tx, policy); err != nil { return err } return s.validateOverlapInTx(ctx, tx, policy) } func (s *PolicyService) validateScopeIDs(ctx context.Context, tx *gorm.DB, policy *model.PackageSilenceExtensionPolicy) error { if len(policy.ScopeIDs) == 0 { return nil } var count int64 var target any = &model.Package{} if policy.ScopeType == constants.SilencePolicyScopeSeries { target = &model.PackageSeries{} } if err := tx.WithContext(ctx).Model(target).Where("id IN ?", []uint(policy.ScopeIDs)).Count(&count).Error; err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "校验适用范围失败") } if int(count) != len(policy.ScopeIDs) { return errors.New(errors.CodeInvalidParam, "适用范围中存在不存在的系列或套餐") } return nil } // validateOverlapInTx 校验同一优先级的启用政策适用范围与生效时间段不重叠(silence_policy_overlap)。 func (s *PolicyService) validateOverlapInTx(ctx context.Context, tx *gorm.DB, policy *model.PackageSilenceExtensionPolicy) error { if policy.Status != constants.SilencePolicyStatusEnabled { return nil } existing, err := postgres.NewPackageSilencePolicyStore(tx).ListEnabled(ctx) if err != nil { return errors.Wrap(errors.CodeDatabaseError, err, "查询启用中的延期政策失败") } candidate := policyCandidate(policy) for index := range existing { other := &existing[index] if other.ID == policy.ID { continue } if packagedomain.SilencePolicyOverlaps(candidate, policyCandidate(other)) { return errors.NewWithData(errors.CodeSilencePolicyOverlap, map[string]any{"conflict_policy_id": other.ID, "conflict_policy_name": other.Name}) } } return nil } func (s *PolicyService) writeAudit(ctx context.Context, tx *gorm.DB, action, summary string, policy *model.PackageSilenceExtensionPolicy, before, after map[string]any) error { if s.audit == nil { return nil } return s.audit.AppendSilenceResource(ctx, tx, action, summary, audit.SilencePolicyResource(policy, before, after), nil) } func policyAuditData(policy *model.PackageSilenceExtensionPolicy) map[string]any { return map[string]any{ "name": policy.Name, "scope_type": policy.ScopeType, "scope_ids": []uint(policy.ScopeIDs), "unit_price": policy.UnitPrice, "free_extension_limit": policy.FreeExtensionLimit, "paid_max_months": policy.PaidMaxMonths, "single_max_months": policy.SingleMaxMonths, "approval_exempt_types": []string(policy.ApprovalExemptTypes), "effective_from": policy.EffectiveFrom, "effective_to": policy.EffectiveTo, "status": policy.Status, } } func policyResponse(policy *model.PackageSilenceExtensionPolicy) *dto.SilencePolicyResponse { scopeIDs := []uint(policy.ScopeIDs) if scopeIDs == nil { scopeIDs = []uint{} } exempt := []string(policy.ApprovalExemptTypes) if exempt == nil { exempt = []string{} } return &dto.SilencePolicyResponse{ ID: policy.ID, Name: policy.Name, ScopeType: policy.ScopeType, ScopeTypeName: policyScopeName(policy.ScopeType), ScopeIDs: scopeIDs, UnitPrice: policy.UnitPrice, FreeExtensionLimit: policy.FreeExtensionLimit, PaidMaxMonths: policy.PaidMaxMonths, SingleMaxMonths: policy.SingleMaxMonths, ApprovalExemptTypes: exempt, EffectiveFrom: policy.EffectiveFrom, EffectiveTo: policy.EffectiveTo, Status: policy.Status, Remark: policy.Remark, Creator: policy.Creator, Updater: policy.Updater, CreatedAt: policy.CreatedAt, UpdatedAt: policy.UpdatedAt, } } func policyScopeName(scope string) string { switch scope { case constants.SilencePolicyScopeAll: return "全部套餐" case constants.SilencePolicyScopeSeries: return "套餐系列" case constants.SilencePolicyScopePackage: return "指定套餐" default: return "" } } func normalizePage(page, pageSize int) (int, int) { if page < 1 { page = 1 } if pageSize < 1 { pageSize = constants.DefaultPageSize } if pageSize > constants.MaxPageSize { pageSize = constants.MaxPageSize } return page, pageSize } func dedupeUint(values []uint) []uint { result := make([]uint, 0, len(values)) for _, value := range values { if value > 0 && !slices.Contains(result, value) { result = append(result, value) } } return result } func dedupeString(values []string) []string { result := make([]string, 0, len(values)) for _, value := range values { if value != "" && !slices.Contains(result, value) { result = append(result, value) } } return result }