feat: 实名即生效套餐沉默期、延期办理与资产出库时间
Some checks failed
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Failing after 8m39s
Some checks failed
构建并部署到测试环境(无 SSH) / build-and-deploy (push) Failing after 8m39s
- 迁移 000259~000265:套餐记录沉默期字段与扫描索引、套餐默认沉默期、延期政策/流水/订单/批次/明细 5 张表、默认政策与系统配置(总开关默认关闭)、企微审批白名单、卡与设备出库时间及出库记录 - 沉默期设置(订单发放、自动购包、钱包续费)、后台购买时调整(超默认值按政策免审或企微审批)、统一判定与激活闸门、排队与孤儿扫描跳过过期套餐、过期套餐禁止退款、每 10 分钟扫描 - 总开关专用接口与打开前 4 项检查;延期政策;延期资格与计费;H5 自助与后台二维码在线支付(商户池路由)、支付回调与查单恢复、线下登记、特殊/批量延期、异常重试与原路退款;沉默期审批场景与终态处理 - 换货沉默期流水与出库时间;卡/设备列表、详情、导出与出库记录接口;延期订单与即将过期套餐列表及导出;财务流水纳入延期支付 - 沉默期与出库时间回填工具 cmd/silence-backfill;前端接口变更说明 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
679
internal/application/packagesilence/online_order.go
Normal file
679
internal/application/packagesilence/online_order.go
Normal file
@@ -0,0 +1,679 @@
|
||||
package packagesilence
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/sha256"
|
||||
"encoding/hex"
|
||||
stderrors "errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"go.uber.org/zap"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/clause"
|
||||
|
||||
agentrechargeApp "github.com/break/junhong_cmp_fiber/internal/application/agentrecharge"
|
||||
"github.com/break/junhong_cmp_fiber/internal/application/merchantpayment"
|
||||
packagedomain "github.com/break/junhong_cmp_fiber/internal/domain/package"
|
||||
"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"
|
||||
)
|
||||
|
||||
// OnlineOrderCommand 是在线付费延期下单命令(H5 客户自助或运营后台生成二维码)。
|
||||
type OnlineOrderCommand struct {
|
||||
Request dto.SilenceOnlineOrderRequest
|
||||
Scope Scope
|
||||
PayerClientIP string
|
||||
}
|
||||
|
||||
// CreateOnlineOrder 创建在线付费延期订单与支付单(技术方案 §8.4):
|
||||
// 冻结月数、单价、金额与政策快照;商户按支付方式经商户池路由并冻结;事务外调用渠道生成支付内容。
|
||||
// 同一套餐已有待支付订单时先查单:未支付则关闭旧单再新建,已支付则按已支付处理并返回旧单。
|
||||
func (s *ExtensionService) CreateOnlineOrder(ctx context.Context, command OnlineOrderCommand) (*dto.SilenceExtensionOrderResponse, error) {
|
||||
if err := s.requireEnabled(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if s.runtime == nil || s.payments.Wechat == nil || s.payments.Alipay == nil || s.payments.Fuiou == nil {
|
||||
return nil, errors.New(errors.CodeServiceUnavailable, "沉默期在线支付能力未配置")
|
||||
}
|
||||
req := command.Request
|
||||
source := constants.SilenceOrderSourceClient
|
||||
var createdBy *uint
|
||||
if command.Scope.CustomerID == 0 {
|
||||
if err := s.requirePermission(ctx, constants.PermissionPackageSilenceExtend); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
source = constants.SilenceOrderSourceAdmin
|
||||
operatorID := middleware.GetUserIDFromContext(ctx)
|
||||
createdBy = &operatorID
|
||||
}
|
||||
requestKey := scopedRequestKey(source, command.Scope.CustomerID, createdBy, req.RequestID)
|
||||
if existing, err := postgres.NewPackageSilenceOrderStore(s.db).FindByRequestID(ctx, requestKey); err != nil {
|
||||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询延期订单幂等记录失败")
|
||||
} else if existing != nil {
|
||||
if existing.PackageUsageID != req.PackageUsageID || existing.InputDays != req.Days || existing.PaymentMethod != req.PaymentMethod {
|
||||
return nil, errors.New(errors.CodeConflict, "同一请求标识对应的延期内容不一致")
|
||||
}
|
||||
return s.orderResponse(ctx, existing, true)
|
||||
}
|
||||
usage, err := s.loadUsage(ctx, s.db, req.PackageUsageID, command.Scope)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if _, err := s.resolver.Resolve(ctx, usage.ID, ResolveOptions{Trigger: constants.SilenceTriggerEligibilityRead, AllowExpire: true}); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if replaced, err := s.settleOpenOrder(ctx, usage.ID); err != nil {
|
||||
return nil, err
|
||||
} else if replaced != nil {
|
||||
return s.orderResponse(ctx, replaced, false)
|
||||
}
|
||||
usage, err = s.loadUsage(ctx, s.db, req.PackageUsageID, command.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.canPay() {
|
||||
return nil, facts.paidError()
|
||||
}
|
||||
quote := packagedomain.QuoteSilenceExtension(packagedomain.SilenceQuoteInput{
|
||||
DeadlineAt: *usage.SilenceDeadlineAt, Now: now, InputDays: req.Days, Policy: facts.match.Snapshot,
|
||||
PaidExtendedDays: usage.SilencePaidExtendedDays, Kind: packagedomain.SilenceQuotePaid,
|
||||
})
|
||||
if !quote.InputValid {
|
||||
return nil, errors.NewWithData(errors.CodeSilenceExtensionMonthsInvalid, map[string]any{
|
||||
"min_days": quote.MinDays, "max_days": quote.MaxDays, "months": quote.Months,
|
||||
})
|
||||
}
|
||||
order, payment, config, adapter, err := s.createOnlineFacts(ctx, usage, facts, quote, req, source, command.Scope.CustomerID, createdBy, requestKey, now)
|
||||
if err != nil {
|
||||
if existing, findErr := postgres.NewPackageSilenceOrderStore(s.db).FindByRequestID(ctx, requestKey); findErr == nil && existing != nil {
|
||||
return s.orderResponse(ctx, existing, true)
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
paymentResult, err := adapter.CreatePaymentURL(ctx, agentrechargeApp.OnlinePaymentRequest{
|
||||
PaymentID: payment.ID, PaymentNo: payment.PaymentNo, CorrelationID: payment.PaymentNo,
|
||||
Description: "沉默期延期", Amount: payment.Amount, ExpireAt: *payment.ExpireAt,
|
||||
PayerClientIP: command.PayerClientIP, Config: config,
|
||||
})
|
||||
if err != nil {
|
||||
if merchantpayment.ShouldDisableMerchant(err) {
|
||||
if disableErr := merchantpayment.DisableMerchantAfterExplicitFailure(ctx, s.db, payment, "payment_precreate_failed", time.Now()); disableErr != nil {
|
||||
return nil, disableErr
|
||||
}
|
||||
}
|
||||
if !isUnknownPayment(err) {
|
||||
_ = s.closeOrder(ctx, order.ID, "支付内容生成失败")
|
||||
}
|
||||
return nil, err
|
||||
}
|
||||
if strings.TrimSpace(paymentResult.QRContent) == "" {
|
||||
_ = s.closeOrder(ctx, order.ID, "支付渠道未返回支付内容")
|
||||
return nil, errors.New(errors.CodeServiceUnavailable, "支付渠道未返回支付内容")
|
||||
}
|
||||
if err := s.db.WithContext(ctx).Model(&model.Payment{}).
|
||||
Where("id = ? AND status = ? AND (qr_content IS NULL OR qr_content = '')", payment.ID, model.PaymentRecordStatusPending).
|
||||
Update("qr_content", paymentResult.QRContent).Error; err != nil {
|
||||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "保存支付内容失败")
|
||||
}
|
||||
return s.orderResponse(ctx, order, true)
|
||||
}
|
||||
|
||||
func (s *ExtensionService) createOnlineFacts(ctx context.Context, usage *model.PackageUsage, facts *eligibility, quote packagedomain.SilenceQuote,
|
||||
req dto.SilenceOnlineOrderRequest, source string, customerID uint, createdBy *uint, requestKey string, now time.Time,
|
||||
) (*model.PackageSilenceExtensionOrder, *model.Payment, *model.WechatConfig, agentrechargeApp.OnlinePaymentPort, error) {
|
||||
identifier, err := assetIdentifier(ctx, s.db, usage)
|
||||
if err != nil {
|
||||
return nil, nil, nil, nil, err
|
||||
}
|
||||
shopID := assetShopID(ctx, s.db, usage)
|
||||
var order *model.PackageSilenceExtensionOrder
|
||||
var payment *model.Payment
|
||||
var config *model.WechatConfig
|
||||
var adapter agentrechargeApp.OnlinePaymentPort
|
||||
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
if err := lockCarrier(ctx, tx, usage); err != nil {
|
||||
return err
|
||||
}
|
||||
route, err := s.runtime.SelectForNewPaymentWithTx(ctx, tx, req.PaymentMethod, now)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
config, err = s.runtime.MerchantConfigWithAuthorization(ctx, route.Merchant)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
adapter = s.adapter(req.PaymentMethod, config)
|
||||
if adapter == nil || !adapter.Available(config) {
|
||||
return errors.New(errors.CodeNoPaymentConfig)
|
||||
}
|
||||
expireAt := onlineExpireAt(config, now)
|
||||
snapshot := facts.match.Snapshot
|
||||
batch := &model.PackageSilenceExtensionBatch{
|
||||
BatchNo: generateNo(constants.SilenceExtensionBatchNoPrefix, now), Path: constants.SilencePathOnline,
|
||||
ExtensionType: constants.SilenceExtensionTypeStandardPaid, EvidenceRefs: model.StringJSONBArray(nonNil(req.EvidenceRefs)),
|
||||
PolicyID: &snapshot.PolicyID, PolicyNameSnapshot: snapshot.Name, UnitPriceSnapshot: snapshot.UnitPrice,
|
||||
ApprovalExemptTypesSnapshot: model.StringJSONBArray(nonNil(snapshot.ApprovalExemptTypes)),
|
||||
FreeExtensionLimitSnapshot: snapshot.FreeExtensionLimit, PaidMaxMonthsSnapshot: snapshot.PaidMaxMonths,
|
||||
SingleMaxMonthsSnapshot: snapshot.SingleMaxMonths, Amount: quote.Amount,
|
||||
RequestedBy: requesterID(customerID, createdBy), RequestedByType: requesterType(customerID),
|
||||
RequestedAt: now, Status: constants.SilenceBatchStatusPendingPayment, RequestedCount: 1,
|
||||
PaymentVoucherKeys: model.StringJSONBArray{}, ShopIDTag: shopID,
|
||||
}
|
||||
if err := postgres.NewPackageSilenceBatchStore(tx).Create(ctx, batch); err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "创建延期批次失败")
|
||||
}
|
||||
order = &model.PackageSilenceExtensionOrder{
|
||||
OrderNo: generateNo(constants.SilenceExtensionOrderNoPrefix, now), BatchID: batch.ID,
|
||||
PackageUsageID: usage.ID, PackageID: usage.PackageID, PackageNameSnapshot: usage.PackageName,
|
||||
AssetIdentifierSnapshot: identifier, ShopID: shopID, Source: source, CreatedBy: createdBy,
|
||||
EvidenceRefs: model.StringJSONBArray(nonNil(req.EvidenceRefs)), InputDays: req.Days,
|
||||
Months: quote.Months, ExtensionDays: quote.BilledDays, PolicyID: &snapshot.PolicyID,
|
||||
PolicyNameSnapshot: snapshot.Name, UnitPrice: snapshot.UnitPrice,
|
||||
ApprovalExemptTypesSnapshot: model.StringJSONBArray(nonNil(snapshot.ApprovalExemptTypes)),
|
||||
FreeExtensionLimitSnapshot: snapshot.FreeExtensionLimit, PaidMaxMonthsSnapshot: snapshot.PaidMaxMonths,
|
||||
SingleMaxMonthsSnapshot: snapshot.SingleMaxMonths, Amount: quote.Amount,
|
||||
BeforeDeadlineAt: *usage.SilenceDeadlineAt, ExpectedDeadlineAt: quote.NewDeadline,
|
||||
Status: constants.SilenceOrderStatusPendingPayment, PaymentMethod: req.PaymentMethod,
|
||||
PaymentVoucherKeys: model.StringJSONBArray{}, ExpireAt: &expireAt, RequestID: &requestKey, ShopIDTag: shopID,
|
||||
}
|
||||
order.AssetType, order.AssetID = usageAsset(usage)
|
||||
if customerID > 0 {
|
||||
order.CustomerID = &customerID
|
||||
}
|
||||
if err := postgres.NewPackageSilenceOrderStore(tx).Create(ctx, order); err != nil {
|
||||
if isUniqueViolation(err) {
|
||||
return errors.New(errors.CodeSilenceExtensionOrderPending)
|
||||
}
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "创建延期订单失败")
|
||||
}
|
||||
extension := &model.PackageSilenceExtension{
|
||||
BatchID: batch.ID, PackageUsageID: usage.ID, PackageID: usage.PackageID, PackageNameSnapshot: usage.PackageName,
|
||||
AssetType: order.AssetType, AssetID: order.AssetID, AssetIdentifierSnapshot: identifier,
|
||||
ExtensionType: constants.SilenceExtensionTypeStandardPaid, InputDays: req.Days, Months: quote.Months,
|
||||
ExtensionDays: quote.BilledDays, UnitPriceSnapshot: snapshot.UnitPrice, Amount: quote.Amount,
|
||||
ExtensionOrderID: &order.ID, BeforeDeadlineAt: usage.SilenceDeadlineAt,
|
||||
Status: constants.SilenceExtensionStatusPendingPayment,
|
||||
}
|
||||
if err := postgres.NewPackageSilenceExtensionStore(tx).Create(ctx, extension); err != nil {
|
||||
if isUniqueViolation(err) {
|
||||
return errors.New(errors.CodeSilenceExtensionOrderPending)
|
||||
}
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "创建延期明细失败")
|
||||
}
|
||||
paymentNo := generateNo("PAY", now)
|
||||
payment = &model.Payment{
|
||||
PaymentNo: paymentNo, OrderID: order.ID, OrderType: constants.PaymentOrderTypeSilenceExtension,
|
||||
PaymentMethod: req.PaymentMethod, Amount: quote.Amount, Status: model.PaymentRecordStatusPending, ExpireAt: &expireAt,
|
||||
}
|
||||
merchantpayment.FreezeRoute(payment, route)
|
||||
if err := tx.Create(payment).Error; err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "创建延期支付单失败")
|
||||
}
|
||||
if err := merchantpayment.RecordRoutingAttempt(ctx, tx, payment); err != nil {
|
||||
return err
|
||||
}
|
||||
return s.writeOrderAudit(ctx, tx, order, "", "创建在线付费延期订单")
|
||||
})
|
||||
if err != nil {
|
||||
return nil, nil, nil, nil, err
|
||||
}
|
||||
return order, payment, config, adapter, nil
|
||||
}
|
||||
|
||||
// settleOpenOrder 处理同一套餐的未结束订单:待支付订单先查单,未支付关闭、已支付按已支付处理并返回该订单。
|
||||
func (s *ExtensionService) settleOpenOrder(ctx context.Context, usageID uint) (*model.PackageSilenceExtensionOrder, error) {
|
||||
open, err := postgres.NewPackageSilenceOrderStore(s.db).FindOpenByUsage(ctx, usageID)
|
||||
if err != nil {
|
||||
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询未结束延期订单失败")
|
||||
}
|
||||
if open == nil {
|
||||
return nil, nil
|
||||
}
|
||||
if open.Status == constants.SilenceOrderStatusPendingApproval {
|
||||
return nil, errors.New(errors.CodeSilenceExtensionOrderPending, "该套餐有待审批的线下延期订单")
|
||||
}
|
||||
paid, err := s.queryAndConfirm(ctx, open)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if paid {
|
||||
current, getErr := postgres.NewPackageSilenceOrderStore(s.db).GetByID(ctx, open.ID)
|
||||
if getErr != nil {
|
||||
return nil, errors.Wrap(errors.CodeDatabaseError, getErr, "查询延期订单失败")
|
||||
}
|
||||
return current, nil
|
||||
}
|
||||
if err := s.closeOrder(ctx, open.ID, constants.SilenceExtensionOrderCloseReasonSuperseded); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// queryAndConfirm 对订单的待支付支付单查单;已支付时走支付确认,返回是否已支付。
|
||||
// 渠道无法确认时保守返回错误,避免旧单已付又新建。
|
||||
func (s *ExtensionService) queryAndConfirm(ctx context.Context, order *model.PackageSilenceExtensionOrder) (bool, error) {
|
||||
var payments []model.Payment
|
||||
if err := s.db.WithContext(ctx).Where("order_type = ? AND order_id = ?", constants.PaymentOrderTypeSilenceExtension, order.ID).
|
||||
Order("id DESC").Find(&payments).Error; err != nil {
|
||||
return false, errors.Wrap(errors.CodeDatabaseError, err, "查询延期支付单失败")
|
||||
}
|
||||
for index := range payments {
|
||||
payment := &payments[index]
|
||||
if payment.Status == model.PaymentRecordStatusPaid {
|
||||
return true, nil
|
||||
}
|
||||
if payment.Status != model.PaymentRecordStatusPending {
|
||||
continue
|
||||
}
|
||||
state, result, err := s.queryPayment(ctx, payment)
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
switch state {
|
||||
case agentrechargeApp.OnlinePaymentStatePaid:
|
||||
paidAt := s.now()
|
||||
if result.PaidAt != nil {
|
||||
paidAt = *result.PaidAt
|
||||
}
|
||||
if err := s.ConfirmPayment(ctx, PaymentConfirmCommand{
|
||||
PaymentNo: payment.PaymentNo, ThirdPartyTradeNo: result.ThirdPartyTradeNo, Amount: result.Amount, PaidAt: paidAt,
|
||||
}); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return true, nil
|
||||
case agentrechargeApp.OnlinePaymentStatePending, agentrechargeApp.OnlinePaymentStateUnknown:
|
||||
if payment.QRContent == "" && state == agentrechargeApp.OnlinePaymentStateUnknown {
|
||||
// 支付内容从未生成成功:客户无法付款,可以安全关闭。
|
||||
continue
|
||||
}
|
||||
if state == agentrechargeApp.OnlinePaymentStateUnknown {
|
||||
return false, errors.New(errors.CodeServiceUnavailable, "原待支付订单状态暂时无法确认,请稍后重试")
|
||||
}
|
||||
}
|
||||
}
|
||||
return false, nil
|
||||
}
|
||||
|
||||
func (s *ExtensionService) queryPayment(ctx context.Context, payment *model.Payment) (string, agentrechargeApp.OnlinePaymentQueryResult, error) {
|
||||
config, err := s.paymentConfig(ctx, payment)
|
||||
if err != nil {
|
||||
return "", agentrechargeApp.OnlinePaymentQueryResult{}, err
|
||||
}
|
||||
adapter := s.adapter(payment.PaymentMethod, config)
|
||||
if adapter == nil {
|
||||
return "", agentrechargeApp.OnlinePaymentQueryResult{}, errors.New(errors.CodeNoPaymentConfig)
|
||||
}
|
||||
result, err := adapter.Query(ctx, agentrechargeApp.OnlinePaymentRequest{
|
||||
PaymentID: payment.ID, PaymentNo: payment.PaymentNo, CorrelationID: payment.PaymentNo, Config: config,
|
||||
})
|
||||
if err != nil {
|
||||
return agentrechargeApp.OnlinePaymentStateUnknown, result, nil
|
||||
}
|
||||
return result.State, result, nil
|
||||
}
|
||||
|
||||
// paymentConfig 按支付单冻结的商户加载凭证,不按当前商户池推断。
|
||||
func (s *ExtensionService) paymentConfig(ctx context.Context, payment *model.Payment) (*model.WechatConfig, error) {
|
||||
if s.runtime == nil {
|
||||
return nil, errors.New(errors.CodeServiceUnavailable, "商户池运行时未配置")
|
||||
}
|
||||
if payment.MerchantID == nil {
|
||||
return nil, errors.New(errors.CodeNoPaymentConfig, "延期支付单缺少冻结商户")
|
||||
}
|
||||
merchant, err := s.runtime.LoadMerchant(ctx, *payment.MerchantID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return s.runtime.MerchantConfigWithAuthorization(ctx, merchant)
|
||||
}
|
||||
|
||||
func (s *ExtensionService) adapter(paymentMethod string, config *model.WechatConfig) agentrechargeApp.OnlinePaymentPort {
|
||||
switch paymentMethod {
|
||||
case model.PaymentByWechat:
|
||||
if config != nil && config.ProviderType == model.ProviderTypeFuiou {
|
||||
return s.payments.Fuiou
|
||||
}
|
||||
return s.payments.Wechat
|
||||
case model.PaymentByAlipay:
|
||||
return s.payments.Alipay
|
||||
default:
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// PaymentConfirmCommand 是支付回调或查单确认的支付事实(已验签、已按冻结商户核对)。
|
||||
type PaymentConfirmCommand struct {
|
||||
PaymentNo string
|
||||
ThirdPartyTradeNo string
|
||||
Amount int64
|
||||
PaidAt time.Time
|
||||
}
|
||||
|
||||
// ConfirmPayment 处理延期支付成功(回调或查单):pending_payment → paid → completed,重复回调幂等。
|
||||
// 金额不一致或执行校验不通过时进入 exception,并在提交后按冻结商户原路退款。
|
||||
// 总开关关闭时照常处理(避免收钱不延期)。
|
||||
func (s *ExtensionService) ConfirmPayment(ctx context.Context, command PaymentConfirmCommand) error {
|
||||
var orderID uint
|
||||
var usageID uint
|
||||
completed, needRefund := false, false
|
||||
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
var payment model.Payment
|
||||
if err := tx.WithContext(ctx).Clauses(clause.Locking{Strength: "UPDATE"}).
|
||||
Where("payment_no = ? AND order_type = ?", command.PaymentNo, constants.PaymentOrderTypeSilenceExtension).
|
||||
First(&payment).Error; err != nil {
|
||||
if err == gorm.ErrRecordNotFound {
|
||||
return errors.New(errors.CodeNotFound, "延期支付单不存在")
|
||||
}
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "锁定延期支付单失败")
|
||||
}
|
||||
if payment.Status == model.PaymentRecordStatusPaid || payment.Status == model.PaymentRecordStatusRefunded {
|
||||
return nil
|
||||
}
|
||||
paidAt := command.PaidAt
|
||||
if paidAt.IsZero() {
|
||||
paidAt = s.now()
|
||||
}
|
||||
if err := tx.Model(&model.Payment{}).Where("id = ? AND status IN ?", payment.ID, []int{model.PaymentRecordStatusPending, model.PaymentRecordStatusFailed}).
|
||||
Updates(map[string]any{"status": model.PaymentRecordStatusPaid, "third_party_trade_no": command.ThirdPartyTradeNo, "paid_at": paidAt, "updated_at": s.now()}).Error; err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "更新延期支付单失败")
|
||||
}
|
||||
order, err := postgres.NewPackageSilenceOrderStore(tx).LockByID(ctx, payment.OrderID)
|
||||
if err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "锁定延期订单失败")
|
||||
}
|
||||
orderID, usageID = order.ID, order.PackageUsageID
|
||||
paidValues := map[string]any{"paid_payment_id": payment.ID, "paid_amount": command.Amount, "paid_at": paidAt}
|
||||
if order.Status != constants.SilenceOrderStatusPendingPayment {
|
||||
// 订单已关闭(超时或被新订单替换)后才到达的成功支付:收到钱但不能延期,进入异常并原路退款。
|
||||
needRefund = true
|
||||
return s.orderToException(ctx, tx, order, []string{order.Status}, paidValues, constants.SilenceFailureUsageInvalid, "订单已关闭后收到支付")
|
||||
}
|
||||
if command.Amount != order.Amount {
|
||||
needRefund = true
|
||||
return s.orderToException(ctx, tx, order, []string{constants.SilenceOrderStatusPendingPayment}, paidValues, constants.SilenceFailureAmountMismatch, "回调金额与订单金额不一致")
|
||||
}
|
||||
if _, err := postgres.NewPackageSilenceOrderStore(tx).TransitionStatus(ctx, order.ID, []string{constants.SilenceOrderStatusPendingPayment}, constants.SilenceOrderStatusPaid, paidValues); err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "更新延期订单为已支付失败")
|
||||
}
|
||||
before := order.Status
|
||||
order.Status = constants.SilenceOrderStatusPaid
|
||||
if err := s.writeOrderAudit(ctx, tx, order, before, "延期订单支付成功"); err != nil {
|
||||
return err
|
||||
}
|
||||
ok, err := s.executeOrderInTx(ctx, tx, order)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
completed, needRefund = ok, !ok
|
||||
return nil
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if completed {
|
||||
s.afterExecuted(ctx, []uint{usageID})
|
||||
}
|
||||
if needRefund && orderID > 0 {
|
||||
if refundErr := s.refundOrder(ctx, orderID, "延期执行异常原路退款"); refundErr != nil {
|
||||
s.logger.Warn("延期异常订单原路退款失败,等待恢复任务重试", zap.Uint("order_id", orderID), zap.Error(refundErr))
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// executeOrderInTx 执行已支付订单对应的明细;成功订单 completed,失败订单与明细进入 exception。
|
||||
func (s *ExtensionService) executeOrderInTx(ctx context.Context, tx *gorm.DB, order *model.PackageSilenceExtensionOrder) (bool, error) {
|
||||
var extension model.PackageSilenceExtension
|
||||
if err := tx.WithContext(ctx).Clauses(clause.Locking{Strength: "UPDATE"}).Where("extension_order_id = ?", order.ID).First(&extension).Error; err != nil {
|
||||
return false, errors.Wrap(errors.CodeDatabaseError, err, "查询延期明细失败")
|
||||
}
|
||||
if extension.Status == constants.SilenceExtensionStatusCompleted {
|
||||
return true, nil
|
||||
}
|
||||
from := []string{constants.SilenceExtensionStatusPendingPayment, constants.SilenceExtensionStatusPendingApproval,
|
||||
constants.SilenceExtensionStatusApproved, constants.SilenceExtensionStatusExecuting, constants.SilenceExtensionStatusException}
|
||||
outcome, err := s.executeExtensionInTx(ctx, tx, &extension, executeKind{paid: true}, paidSnapshot{
|
||||
paidMaxMonths: order.PaidMaxMonthsSnapshot, singleMaxMonths: order.SingleMaxMonthsSnapshot, freeLimit: order.FreeExtensionLimitSnapshot,
|
||||
}, from)
|
||||
if err != nil {
|
||||
if isAlreadyExecuted(err) {
|
||||
return true, nil
|
||||
}
|
||||
return false, err
|
||||
}
|
||||
now := s.now()
|
||||
if !outcome.executed {
|
||||
if err := s.markExtensionFailedInTx(ctx, tx, &extension, constants.SilenceExtensionStatusException, from, outcome.failureCode, outcome.failureText); err != nil {
|
||||
return false, err
|
||||
}
|
||||
if err := s.orderToException(ctx, tx, order, []string{constants.SilenceOrderStatusPaid, constants.SilenceOrderStatusPendingApproval}, nil, outcome.failureCode, outcome.failureText); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return false, refreshBatchCountsInTx(ctx, tx, order.BatchID, now)
|
||||
}
|
||||
if _, err := postgres.NewPackageSilenceOrderStore(tx).TransitionStatus(ctx, order.ID,
|
||||
[]string{constants.SilenceOrderStatusPaid, constants.SilenceOrderStatusPendingApproval, constants.SilenceOrderStatusException},
|
||||
constants.SilenceOrderStatusCompleted, map[string]any{"extension_id": extension.ID, "completed_at": now, "exception_code": "", "exception_summary": ""}); err != nil {
|
||||
return false, errors.Wrap(errors.CodeDatabaseError, err, "更新延期订单为已完成失败")
|
||||
}
|
||||
before := order.Status
|
||||
order.Status = constants.SilenceOrderStatusCompleted
|
||||
if err := s.writeOrderAudit(ctx, tx, order, before, "延期订单执行完成"); err != nil {
|
||||
return false, err
|
||||
}
|
||||
return true, refreshBatchCountsInTx(ctx, tx, order.BatchID, now)
|
||||
}
|
||||
|
||||
func (s *ExtensionService) orderToException(ctx context.Context, tx *gorm.DB, order *model.PackageSilenceExtensionOrder, from []string, values map[string]any, code, text string) error {
|
||||
updates := map[string]any{"exception_code": code, "exception_summary": truncate(text, 500)}
|
||||
for key, value := range values {
|
||||
updates[key] = value
|
||||
}
|
||||
if _, err := postgres.NewPackageSilenceOrderStore(tx).TransitionStatus(ctx, order.ID, from, constants.SilenceOrderStatusException, updates); err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "更新延期订单为异常失败")
|
||||
}
|
||||
before := order.Status
|
||||
order.Status = constants.SilenceOrderStatusException
|
||||
order.ExceptionCode, order.ExceptionSummary = code, text
|
||||
return s.writeOrderAudit(ctx, tx, order, before, "延期订单执行异常:"+text)
|
||||
}
|
||||
|
||||
// closeOrder 关闭待支付订单(超时、被替换或支付内容生成失败):订单 closed、支付单失败、明细与批次关闭。
|
||||
func (s *ExtensionService) closeOrder(ctx context.Context, orderID uint, reason string) error {
|
||||
return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
order, err := postgres.NewPackageSilenceOrderStore(tx).LockByID(ctx, orderID)
|
||||
if err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "锁定延期订单失败")
|
||||
}
|
||||
if order.Status != constants.SilenceOrderStatusPendingPayment {
|
||||
return nil
|
||||
}
|
||||
now := s.now()
|
||||
if _, err := postgres.NewPackageSilenceOrderStore(tx).TransitionStatus(ctx, order.ID, []string{constants.SilenceOrderStatusPendingPayment},
|
||||
constants.SilenceOrderStatusClosed, map[string]any{"closed_at": now, "close_reason": truncate(reason, 200)}); err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "关闭延期订单失败")
|
||||
}
|
||||
if err := tx.Model(&model.Payment{}).Where("order_type = ? AND order_id = ? AND status = ?", constants.PaymentOrderTypeSilenceExtension, order.ID, model.PaymentRecordStatusPending).
|
||||
Update("status", model.PaymentRecordStatusFailed).Error; err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "关闭延期支付单失败")
|
||||
}
|
||||
if err := tx.Model(&model.PackageSilenceExtension{}).Where("extension_order_id = ? AND status = ?", order.ID, constants.SilenceExtensionStatusPendingPayment).
|
||||
Updates(map[string]any{"status": constants.SilenceExtensionStatusClosed, "failure_summary": truncate(reason, 500), "updated_at": now}).Error; err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "关闭延期明细失败")
|
||||
}
|
||||
if _, err := postgres.NewPackageSilenceBatchStore(tx).TransitionStatus(ctx, order.BatchID, []string{constants.SilenceBatchStatusPendingPayment},
|
||||
constants.SilenceBatchStatusClosed, map[string]any{"completed_at": now}); err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "关闭延期批次失败")
|
||||
}
|
||||
before := order.Status
|
||||
order.Status = constants.SilenceOrderStatusClosed
|
||||
return s.writeOrderAudit(ctx, tx, order, before, "关闭延期订单:"+reason)
|
||||
})
|
||||
}
|
||||
|
||||
// refundOrder 对异常订单按支付单冻结商户原路退款(延期费正常不退,只在执行异常时退)。
|
||||
func (s *ExtensionService) refundOrder(ctx context.Context, orderID uint, reason string) error {
|
||||
if s.refunder == nil || s.runtime == nil {
|
||||
return errors.New(errors.CodeServiceUnavailable, "原路退款能力未配置")
|
||||
}
|
||||
order, err := postgres.NewPackageSilenceOrderStore(s.db).GetByID(ctx, orderID)
|
||||
if err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "查询延期订单失败")
|
||||
}
|
||||
if order.Status != constants.SilenceOrderStatusException || order.PaidPaymentID == nil || order.PaymentMethod == model.PaymentByOffline {
|
||||
return nil
|
||||
}
|
||||
refundNo := ""
|
||||
if order.RefundNo != nil {
|
||||
refundNo = *order.RefundNo
|
||||
} else {
|
||||
refundNo = generateNo("SR", s.now())
|
||||
result := s.db.WithContext(ctx).Model(&model.PackageSilenceExtensionOrder{}).Where("id = ? AND refund_no IS NULL", order.ID).
|
||||
Updates(map[string]any{"refund_no": refundNo, "refund_reason": truncate(reason, 500), "updated_at": s.now()})
|
||||
if result.Error != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, result.Error, "登记延期订单退款单号失败")
|
||||
}
|
||||
if result.RowsAffected == 0 {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
var payment model.Payment
|
||||
if err := s.db.WithContext(ctx).Where("id = ?", *order.PaidPaymentID).First(&payment).Error; err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "查询延期支付单失败")
|
||||
}
|
||||
config, err := s.paymentConfig(ctx, &payment)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
merchant, err := s.runtime.LoadMerchant(ctx, *payment.MerchantID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
amount := payment.Amount
|
||||
if order.PaidAmount != nil && *order.PaidAmount > 0 {
|
||||
amount = *order.PaidAmount
|
||||
}
|
||||
target := refundTarget(order, &payment, config, merchant.ProviderType, refundNo, amount)
|
||||
result, err := s.refunder.Refund(ctx, target)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if result.State != "success" {
|
||||
return errors.New(errors.CodeServiceUnavailable, "原路退款未确认成功:"+result.FailureMessage)
|
||||
}
|
||||
return s.markRefunded(ctx, order.ID, payment.ID, amount)
|
||||
}
|
||||
|
||||
func (s *ExtensionService) markRefunded(ctx context.Context, orderID, paymentID uint, amount int64) error {
|
||||
return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||||
order, err := postgres.NewPackageSilenceOrderStore(tx).LockByID(ctx, orderID)
|
||||
if err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "锁定延期订单失败")
|
||||
}
|
||||
now := s.now()
|
||||
affected, err := postgres.NewPackageSilenceOrderStore(tx).TransitionStatus(ctx, orderID, []string{constants.SilenceOrderStatusException},
|
||||
constants.SilenceOrderStatusRefunded, map[string]any{"refund_amount": amount, "refunded_at": now})
|
||||
if err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "更新延期订单为已退款失败")
|
||||
}
|
||||
if affected == 0 {
|
||||
return nil
|
||||
}
|
||||
if err := tx.Model(&model.Payment{}).Where("id = ? AND status = ?", paymentID, model.PaymentRecordStatusPaid).
|
||||
Update("status", model.PaymentRecordStatusRefunded).Error; err != nil {
|
||||
return errors.Wrap(errors.CodeDatabaseError, err, "更新延期支付单为已退款失败")
|
||||
}
|
||||
before := order.Status
|
||||
order.Status = constants.SilenceOrderStatusRefunded
|
||||
return s.writeOrderAudit(ctx, tx, order, before, "延期异常订单已原路退款")
|
||||
})
|
||||
}
|
||||
|
||||
// writeOrderAudit 写延期订单状态变化审计(主资源为套餐记录)。
|
||||
func (s *ExtensionService) writeOrderAudit(ctx context.Context, tx *gorm.DB, order *model.PackageSilenceExtensionOrder, before, summary string) error {
|
||||
if s.audit == nil {
|
||||
return nil
|
||||
}
|
||||
var usage model.PackageUsage
|
||||
if err := tx.WithContext(ctx).Where("id = ?", order.PackageUsageID).First(&usage).Error; err != nil {
|
||||
return nil
|
||||
}
|
||||
return s.audit.AppendSilenceUsage(ctx, tx, orderAuditInput(&usage, order, before, summary))
|
||||
}
|
||||
|
||||
func onlineExpireAt(config *model.WechatConfig, now time.Time) time.Time {
|
||||
minutes := model.DefaultAliPayExpireMinutes
|
||||
if config != nil && config.AliPayExpireMinutes > 0 {
|
||||
minutes = config.AliPayExpireMinutes
|
||||
}
|
||||
expireAt := now.Add(time.Duration(minutes) * time.Minute)
|
||||
// 支付截止不跨天:降低跨天支付导致新截止不再晚于当天的概率(技术方案 Risks)。
|
||||
if endOfDay := packagedomain.SilenceDeadline(now, 0); expireAt.After(endOfDay) {
|
||||
expireAt = endOfDay
|
||||
}
|
||||
return expireAt
|
||||
}
|
||||
|
||||
func scopedRequestKey(source string, customerID uint, createdBy *uint, requestID string) string {
|
||||
actor := uint(0)
|
||||
if createdBy != nil {
|
||||
actor = *createdBy
|
||||
}
|
||||
digest := sha256.Sum256([]byte(fmt.Sprintf("%s:%d:%d:%s", source, customerID, actor, strings.TrimSpace(requestID))))
|
||||
return hex.EncodeToString(digest[:])
|
||||
}
|
||||
|
||||
func requesterID(customerID uint, createdBy *uint) uint {
|
||||
if customerID > 0 {
|
||||
return customerID
|
||||
}
|
||||
if createdBy != nil {
|
||||
return *createdBy
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func requesterType(customerID uint) string {
|
||||
if customerID > 0 {
|
||||
return constants.SilenceOperatorCustomer
|
||||
}
|
||||
return constants.SilenceOperatorAccount
|
||||
}
|
||||
|
||||
func nonNil(values []string) []string {
|
||||
if values == nil {
|
||||
return []string{}
|
||||
}
|
||||
return values
|
||||
}
|
||||
|
||||
func isUnknownPayment(err error) bool {
|
||||
var appErr *errors.AppError
|
||||
return stderrors.As(err, &appErr) && appErr.Code == errors.CodeTimeout
|
||||
}
|
||||
|
||||
func isUniqueViolation(err error) bool {
|
||||
return err != nil && (strings.Contains(err.Error(), "23505") || strings.Contains(err.Error(), "duplicate key"))
|
||||
}
|
||||
|
||||
// assetShopID 返回套餐载体当前所属店铺(数据范围与对账用)。
|
||||
func assetShopID(ctx context.Context, db *gorm.DB, usage *model.PackageUsage) uint {
|
||||
assetType, assetID := usageAsset(usage)
|
||||
var shopID *uint
|
||||
_ = db.WithContext(ctx).Table(outboundTable(assetType)).Select("shop_id").Where("id = ?", assetID).Scan(&shopID).Error
|
||||
if shopID == nil {
|
||||
return 0
|
||||
}
|
||||
return *shopID
|
||||
}
|
||||
Reference in New Issue
Block a user