package packagesilence import ( "context" "time" "go.uber.org/zap" "gorm.io/gorm" agentrechargeApp "github.com/break/junhong_cmp_fiber/internal/application/agentrecharge" approvalapp "github.com/break/junhong_cmp_fiber/internal/application/approval" "github.com/break/junhong_cmp_fiber/internal/application/merchantpayment" "github.com/break/junhong_cmp_fiber/internal/application/refundchannel" 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" ) // OwnershipChecker 校验 H5 客户是否拥有资产(由客户绑定服务实现)。 type OwnershipChecker interface { OwnsAsset(ctx context.Context, customerID uint, assetType string, assetID uint) (bool, error) } // PaymentPorts 是在线支付渠道 Adapter(与代理在线充值同一套)。 type PaymentPorts struct { Wechat agentrechargeApp.OnlinePaymentPort Alipay agentrechargeApp.OnlinePaymentPort Fuiou agentrechargeApp.OnlinePaymentPort } // ExtensionService 是沉默期延期用例集合(技术方案 §7、§8):资格、在线下单、支付确认、线下登记、特殊延期、执行与异常。 type ExtensionService struct { db *gorm.DB sw *Switch resolver *Resolver audit *audit.Writer approval approvalapp.Port perms PermissionChecker ownership OwnershipChecker runtime *merchantpayment.RuntimeLoader payments PaymentPorts refunder refundchannel.Refunder logger *zap.Logger now func() time.Time } // NewExtensionService 创建延期用例。 func NewExtensionService(db *gorm.DB, resolver *Resolver, writer *audit.Writer, logger *zap.Logger) *ExtensionService { if logger == nil { logger = zap.NewNop() } return &ExtensionService{db: db, sw: resolver.Switch(), resolver: resolver, audit: writer, logger: logger, now: time.Now} } // SetApprovalPort 注入审批创建接缝。 func (s *ExtensionService) SetApprovalPort(port approvalapp.Port) { s.approval = port } // SetPermissionChecker 注入权限校验。 func (s *ExtensionService) SetPermissionChecker(checker PermissionChecker) { s.perms = checker } // SetOwnershipChecker 注入 H5 资产归属校验。 func (s *ExtensionService) SetOwnershipChecker(checker OwnershipChecker) { s.ownership = checker } // SetPayment 注入商户池路由、在线支付渠道与原路退款渠道。 func (s *ExtensionService) SetPayment(runtime *merchantpayment.RuntimeLoader, ports PaymentPorts, refunder refundchannel.Refunder) { s.runtime = runtime s.payments = ports s.refunder = refunder } // Scope 描述调用方身份:CustomerID 为 0 表示后台账号(叠加店铺数据范围),否则为 H5 客户(校验资产归属)。 type Scope struct { CustomerID uint } // requireEnabled 在总开关关闭时拒绝新的延期申请(silence_feature_disabled);已发生的回调不调用它。 func (s *ExtensionService) requireEnabled(ctx context.Context) error { if !s.sw.Enabled(ctx) { return errors.New(errors.CodeSilenceFeatureDisabled) } return nil } func (s *ExtensionService) requirePermission(ctx context.Context, code string) error { return requirePermission(ctx, s.perms, code) } // requirePermission 校验后台账号权限点;超级管理员不受限。 func requirePermission(ctx context.Context, perms PermissionChecker, code string) error { if middleware.GetUserTypeFromContext(ctx) == constants.UserTypeSuperAdmin { return nil } if perms == nil { return errors.New(errors.CodeForbidden) } allowed, err := perms.CheckPermission(ctx, middleware.GetUserIDFromContext(ctx), code, constants.PlatformWeb) if err != nil { return err } if !allowed { return errors.New(errors.CodeForbidden, "缺少权限:"+code) } return nil } // loadUsage 读取套餐记录并校验调用方可见:后台叠加店铺数据范围,H5 校验资产归属。 func (s *ExtensionService) loadUsage(ctx context.Context, db *gorm.DB, usageID uint, scope Scope) (*model.PackageUsage, error) { var usage model.PackageUsage if err := db.WithContext(ctx).Where("id = ?", usageID).First(&usage).Error; err != nil { if err == gorm.ErrRecordNotFound { return nil, errors.New(errors.CodeNotFound, "套餐记录不存在") } return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询套餐记录失败") } assetType, assetID := usageAsset(&usage) if scope.CustomerID > 0 { if s.ownership == nil { return nil, errors.New(errors.CodeServiceUnavailable, "资产归属校验未配置") } owned, err := s.ownership.OwnsAsset(ctx, scope.CustomerID, assetType, assetID) if err != nil { return nil, err } if !owned { return nil, errors.New(errors.CodeForbidden, "无权限操作该资产或资源不存在") } return &usage, nil } var count int64 query := db.WithContext(ctx).Table(firstPurchaseTable(assetType)).Where("id = ? AND deleted_at IS NULL", assetID) if err := middleware.ApplyStrictShopFilter(ctx, query).Count(&count).Error; err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "校验资产数据范围失败") } if count == 0 { return nil, errors.New(errors.CodeForbidden, "无权限操作该资源或资源不存在") } return &usage, nil } // eligibility 是资格判定的中间事实。 type eligibility struct { usage *model.PackageUsage pkg *model.Package match PolicyMatch paid packagedomain.SilenceQuote special packagedomain.SilenceQuote effectiveStatus string expired bool reason string specialAvailable bool freeAvailable bool openOrder *model.PackageSilenceExtensionOrder openDetail bool } // computeEligibility 计算付费与特殊延期资格(技术方案 §8.1、§8.2)。 func (s *ExtensionService) computeEligibility(ctx context.Context, db *gorm.DB, usage *model.PackageUsage, now time.Time) (*eligibility, error) { result := &eligibility{usage: usage} if usage.SilenceStatus == nil || *usage.SilenceStatus == "" { result.reason = constants.SilenceReasonNoSilence return result, nil } result.effectiveStatus = *usage.SilenceStatus if usage.Status == constants.PackageUsageStatusInvalidated { result.reason = constants.SilenceReasonRefunded return result, nil } if usage.Status != constants.PackageUsageStatusPending || result.effectiveStatus == constants.SilenceStatusEnded { result.reason = constants.SilenceReasonActivated return result, nil } result.expired = packagedomain.IsSilenceEffectivelyExpired(result.effectiveStatus, usage.SilenceDeadlineAt, usage.SilenceAdjustPending, now) if result.expired { result.effectiveStatus = constants.SilenceStatusExpired } if !result.expired { result.reason = constants.SilenceReasonNotExpired if usage.SilenceAdjustPending { result.reason = constants.SilenceReasonAdjustPending } return result, nil } match, pkg, err := matchPolicyForPackage(ctx, db, usage.PackageID, now) if err != nil { return nil, err } result.match, result.pkg = match, pkg order, err := postgres.NewPackageSilenceOrderStore(db).FindOpenByUsage(ctx, usage.ID) if err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询未结束延期订单失败") } result.openOrder = order openDetail, err := postgres.NewPackageSilenceExtensionStore(db).HasOpenByUsage(ctx, usage.ID) if err != nil { return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询未结束延期明细失败") } result.openDetail = openDetail deadline := *usage.SilenceDeadlineAt result.paid = packagedomain.QuoteSilenceExtension(packagedomain.SilenceQuoteInput{ DeadlineAt: deadline, Now: now, Policy: match.Snapshot, PaidExtendedDays: usage.SilencePaidExtendedDays, Kind: packagedomain.SilenceQuotePaid, }) result.special = packagedomain.QuoteSilenceExtension(packagedomain.SilenceQuoteInput{ DeadlineAt: deadline, Now: now, Policy: match.Snapshot, Kind: packagedomain.SilenceQuoteSpecial, }) switch { case openDetail || order != nil: result.reason = constants.SilenceReasonOrderPending case !pkg.SilenceExtensionEnabled: result.reason = constants.SilenceReasonExtensionDisabled case match.Snapshot == nil: result.reason = constants.SilenceReasonNoPolicy case !result.paid.CanExtend: result.reason = constants.SilenceReasonExceedsLimit } result.specialAvailable = !openDetail && order == nil result.freeAvailable = result.specialAvailable && usage.SilenceFreeExtensionUsed < match.FreeExtensionLimit() return result, nil } // canPay 表示可以办理付费延期。 func (e *eligibility) canPay() bool { return e.expired && e.reason == "" } // paidError 把不能付费延期的原因转换为错误码。 func (e *eligibility) paidError() error { switch e.reason { case "": return nil case constants.SilenceReasonNotExpired, constants.SilenceReasonNoSilence, constants.SilenceReasonActivated, constants.SilenceReasonRefunded, constants.SilenceReasonAdjustPending: return errors.NewWithData(errors.CodeSilenceExtensionNotExpired, map[string]any{"reason": e.reason}) case constants.SilenceReasonOrderPending: return errors.New(errors.CodeSilenceExtensionOrderPending) case constants.SilenceReasonExtensionDisabled: return errors.New(errors.CodeSilenceExtensionDisabled) case constants.SilenceReasonNoPolicy: return errors.New(errors.CodeSilenceExtensionNoPolicy) case constants.SilenceReasonExceedsLimit: return errors.NewWithData(errors.CodeSilenceExtensionExceedsLimit, map[string]any{"min_months": e.paid.MinMonths, "max_months": e.paid.MaxMonths}) default: return errors.New(errors.CodeSilenceExtensionNotExpired) } } // Eligibility 查询延期资格(后台与 H5 同语义);waiting 但已到期的先判定为过期。 func (s *ExtensionService) Eligibility(ctx context.Context, usageID uint, scope Scope) (*dto.SilenceEligibilityResponse, error) { if err := s.requireEnabled(ctx); err != nil { return nil, err } if _, err := s.loadUsage(ctx, s.db, usageID, scope); err != nil { return nil, err } if _, err := s.resolver.Resolve(ctx, usageID, ResolveOptions{Trigger: constants.SilenceTriggerEligibilityRead, AllowExpire: true}); err != nil { return nil, err } usage, err := s.loadUsage(ctx, s.db, usageID, Scope{CustomerID: scope.CustomerID}) if err != nil { return nil, err } now := s.now() facts, err := s.computeEligibility(ctx, s.db, usage, now) if err != nil { return nil, err } return eligibilityResponse(facts), nil } // Quote 按输入天数试算付费延期。 func (s *ExtensionService) Quote(ctx context.Context, usageID uint, days int, scope Scope) (*dto.SilenceQuoteResponse, error) { if err := s.requireEnabled(ctx); err != nil { return nil, err } usage, err := s.loadUsage(ctx, s.db, usageID, scope) if err != nil { return nil, err } now := s.now() facts, err := s.computeEligibility(ctx, s.db, usage, now) if err != nil { return nil, err } if !facts.expired || usage.SilenceDeadlineAt == nil { return nil, facts.paidError() } quote := packagedomain.QuoteSilenceExtension(packagedomain.SilenceQuoteInput{ DeadlineAt: *usage.SilenceDeadlineAt, Now: now, InputDays: days, Policy: facts.match.Snapshot, PaidExtendedDays: usage.SilencePaidExtendedDays, Kind: packagedomain.SilenceQuotePaid, }) deadline := quote.NewDeadline return &dto.SilenceQuoteResponse{ InputDays: days, Months: quote.Months, BilledDays: quote.BilledDays, Amount: quote.Amount, NewDeadline: formatDate(&deadline), Valid: quote.InputValid && facts.canPay(), }, nil } func eligibilityResponse(facts *eligibility) *dto.SilenceEligibilityResponse { usage := facts.usage resp := &dto.SilenceEligibilityResponse{ PackageUsageID: usage.ID, SilenceStatus: facts.effectiveStatus, CanExtend: facts.canPay(), SpecialExtensionAvailable: facts.expired && facts.specialAvailable, Reason: facts.reason, ExtendedDays: usage.SilenceExtendedDays, PaidExtendedDays: usage.SilencePaidExtendedDays, FreeExtensionUsed: usage.SilenceFreeExtensionUsed, FreeExtensionLimit: facts.match.FreeExtensionLimit(), FreeExtensionAvailable: facts.expired && facts.freeAvailable, Options: []dto.SilenceExtensionOption{}, } if usage.SilenceDeadlineAt != nil { resp.OriginalDeadline = formatDate(usage.SilenceDeadlineAt) } if facts.pkg != nil { resp.ExtensionEnabled = facts.pkg.SilenceExtensionEnabled } if facts.match.Policy != nil { id := facts.match.Policy.ID resp.PolicyID = &id resp.PolicyName = facts.match.Policy.Name resp.UnitPrice = facts.match.Policy.UnitPrice } if facts.openOrder != nil { resp.PendingOrderNo = facts.openOrder.OrderNo } if !facts.expired { return resp } resp.OverdueDays = facts.paid.OverdueDays resp.MinDays = facts.paid.MinDays resp.MinMonths = facts.paid.MinMonths resp.MaxMonths = facts.paid.MaxMonths resp.MaxDays = facts.paid.MaxDays if facts.canPay() && usage.SilenceDeadlineAt != nil { for _, option := range packagedomain.SilenceQuoteOptions(facts.paid, *usage.SilenceDeadlineAt, constants.SilenceExtensionOptionsMax) { deadline := option.NewDeadline resp.Options = append(resp.Options, dto.SilenceExtensionOption{ Months: option.Months, BilledDays: option.BilledDays, Amount: option.Amount, NewDeadline: formatDate(&deadline), }) } } return resp }