csxj2026/junhong_cmp_fiber
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

收口审计治理与套餐任务进展

Browse Source 
Constraint: 在线热修前必须保存当前迭代分支全部有效代码进展
Confidence: medium
Scope-risk: broad
Directive: 后续修改需保持审计事件与业务事务边界一致
Tested: git diff --cached --check
Not-tested: 未运行全量测试，提交用于切换分支前保存既有工作
This commit is contained in:
break
2026-08-05 14:30:54 +08:00
parent b3499adfca
commit 5e552d99bc
178 changed files with 16797 additions and 5674 deletions
Download Patch File Download Diff File Expand all files Collapse all files

148
internal/service/shop_commission/audit.go Normal file
View File

@@ -0,0 +1,148 @@
package shop_commission
import (
"context"
"strconv"
"gorm.io/gorm"
"github.com/break/junhong_cmp_fiber/internal/infrastructure/audit"
"github.com/break/junhong_cmp_fiber/internal/model"
"github.com/break/junhong_cmp_fiber/pkg/constants"
"github.com/break/junhong_cmp_fiber/pkg/errors"
)
func (s *Service) appendWithdrawalRequestAudit(ctx context.Context, tx *gorm.DB, withdrawal *model.CommissionWithdrawalRequest, wallet *model.AgentWallet, transaction *model.AgentWalletTransaction) error {
if s.auditWriter == nil {
return errors.New(errors.CodeInvalidStatus, "佣金提现统一审计接缝未配置")
}
var saved model.CommissionWithdrawalRequest
if err := tx.WithContext(ctx).First(&saved, withdrawal.ID).Error; err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "查询提现申请审计快照失败")
}
var shop model.Shop
if err := tx.WithContext(ctx).First(&shop, saved.ShopID).Error; err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "查询提现店铺审计快照失败")
}
primary := audit.CommissionWithdrawalResource(&saved, constants.AuditResourceRelationPrimary, constants.AuditResourceRoleWithdrawalTarget,
nil, withdrawalAuditState(&saved))
primary.SubjectVisibility = constants.AuditSubjectDetail
primary.SubjectSummary = "提现申请已提交"
primary.SubjectData = map[string]any{
"amount": saved.Amount, "fee": saved.Fee, "actual_amount": saved.ActualAmount,
"withdrawal_method": saved.WithdrawalMethod, "status": saved.Status,
}
walletResource := audit.AgentWalletResource(wallet, constants.AuditResourceRelationAffected, constants.AuditResourceRoleWithdrawalWallet,
map[string]any{"balance": wallet.Balance, "frozen_balance": wallet.FrozenBalance},
map[string]any{"balance": wallet.Balance, "frozen_balance": wallet.FrozenBalance + saved.Amount})
walletResource.SubjectVisibility = constants.AuditSubjectInternalOnly
transactionResource := audit.AgentWalletTransactionResource(transaction, constants.AuditResourceRelationAffected, constants.AuditResourceRoleWithdrawalTransaction)
transactionResource.SubjectVisibility = constants.AuditSubjectInternalOnly
shopResource := audit.ShopResource(&shop, constants.AuditResourceRelationReference, constants.AuditResourceRoleWithdrawalShop)
shopResource.SubjectVisibility = constants.AuditSubjectInternalOnly
return s.auditWriter.Append(ctx, tx, audit.AppendInput{
EventID: "commission-withdrawal:" + strconv.FormatUint(uint64(saved.ID), 10) + ":requested",
ActionCode: constants.AuditActionCommissionWithdrawalRequested, Summary: "提交佣金提现申请",
ScopeType: constants.AuditScopePlatform, Result: constants.AuditResultSuccess,
CorrelationID: saved.WithdrawalNo,
Metadata: map[string]any{"amount": saved.Amount, "fee": saved.Fee, "actual_amount": saved.ActualAmount},
Resources: []audit.ResourceInput{primary, walletResource, transactionResource, shopResource},
})
}
func (s *Service) recordWithdrawalRequestFailure(ctx context.Context, withdrawal *model.CommissionWithdrawalRequest, wallet *model.AgentWallet, businessErr error) {
if businessErr == nil || withdrawal == nil || withdrawal.WithdrawalNo == "" || s.auditWriter == nil || s.db == nil {
return
}
primary := audit.CommissionWithdrawalResource(withdrawal, constants.AuditResourceRelationPrimary, constants.AuditResourceRoleWithdrawalTarget, nil, nil)
primary.SubjectVisibility = constants.AuditSubjectInternalOnly
resources := []audit.ResourceInput{primary}
if wallet != nil {
resource := audit.AgentWalletResource(wallet, constants.AuditResourceRelationReference, constants.AuditResourceRoleWithdrawalWallet, nil, nil)
resource.SubjectVisibility = constants.AuditSubjectInternalOnly
resources = append(resources, resource)
}
s.auditWriter.RecordFailure(ctx, s.db, audit.AppendInput{
ActionCode: constants.AuditActionCommissionWithdrawalRequested, Summary: "提交佣金提现申请失败",
ScopeType: constants.AuditScopePlatform, CorrelationID: withdrawal.WithdrawalNo, Resources: resources,
}, businessErr)
}
func (s *Service) appendCommissionResolutionAudit(ctx context.Context, tx *gorm.DB, before *model.CommissionRecord, wallet *model.AgentWallet, actionCode, summary string) error {
if s.auditWriter == nil {
return errors.New(errors.CodeInvalidStatus, "佣金统一审计接缝未配置")
}
var saved model.CommissionRecord
if err := tx.WithContext(ctx).First(&saved, before.ID).Error; err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "查询佣金修正审计快照失败")
}
var order model.Order
if err := tx.WithContext(ctx).First(&order, saved.OrderID).Error; err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "查询佣金修正关联订单审计快照失败")
}
var shop model.Shop
if err := tx.WithContext(ctx).First(&shop, saved.ShopID).Error; err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "查询佣金修正关联店铺审计快照失败")
}
primary := audit.CommissionRecordResource(&saved,
map[string]any{"amount": before.Amount, "status": before.Status, "balance_after": before.BalanceAfter, "remark": before.Remark},
map[string]any{"amount": saved.Amount, "status": saved.Status, "balance_after": saved.BalanceAfter, "released_at": saved.ReleasedAt, "remark": saved.Remark})
primary.Relation = constants.AuditResourceRelationPrimary
primary.Role = constants.AuditResourceRoleCommissionRecord
primary.SubjectVisibility = constants.AuditSubjectInternalOnly
orderResource := audit.OrderResource(&order, constants.AuditResourceRelationReference, constants.AuditResourceRoleCommissionOrder)
orderResource.SubjectVisibility = constants.AuditSubjectInternalOnly
shopResource := audit.ShopResource(&shop, constants.AuditResourceRelationReference, constants.AuditResourceRoleCommissionShop)
shopResource.SubjectVisibility = constants.AuditSubjectInternalOnly
resources := []audit.ResourceInput{primary, orderResource, shopResource}
if wallet != nil {
resource := audit.AgentWalletResource(wallet, constants.AuditResourceRelationAffected, constants.AuditResourceRoleCommissionWallet,
map[string]any{"balance": wallet.Balance, "frozen_balance": wallet.FrozenBalance},
map[string]any{"balance": wallet.Balance + saved.Amount, "frozen_balance": wallet.FrozenBalance})
resource.SubjectVisibility = constants.AuditSubjectInternalOnly
resources = append(resources, resource)
}
if order.SeriesID != nil {
var series model.PackageSeries
if err := tx.WithContext(ctx).First(&series, *order.SeriesID).Error; err != nil {
return errors.Wrap(errors.CodeDatabaseError, err, "查询佣金修正关联系列审计快照失败")
}
resource := audit.PackageSeriesResource(&series, constants.AuditResourceRelationReference, constants.AuditResourceRoleCommissionSeries, nil, nil)
resource.SubjectVisibility = constants.AuditSubjectInternalOnly
resources = append(resources, resource)
}
suffix := "invalidated"
if actionCode == constants.AuditActionCommissionCredited {
suffix = "credited"
}
return s.auditWriter.Append(ctx, tx, audit.AppendInput{
EventID: "commission:record:" + strconv.FormatUint(uint64(saved.ID), 10) + ":" + suffix,
ActionCode: actionCode, Summary: summary, ScopeType: constants.AuditScopePlatform,
Result: constants.AuditResultSuccess, CorrelationID: order.OrderNo,
Metadata: map[string]any{"amount": saved.Amount, "status": saved.Status}, Resources: resources,
})
}
func (s *Service) recordCommissionResolutionFailure(ctx context.Context, record *model.CommissionRecord, actionCode, summary string, businessErr error) {
if businessErr == nil || record == nil || record.ID == 0 || s.auditWriter == nil || s.db == nil {
return
}
primary := audit.CommissionRecordResource(record, map[string]any{"amount": record.Amount, "status": record.Status}, nil)
primary.Relation = constants.AuditResourceRelationPrimary
primary.Role = constants.AuditResourceRoleCommissionRecord
primary.SubjectVisibility = constants.AuditSubjectInternalOnly
s.auditWriter.RecordFailure(ctx, s.db, audit.AppendInput{
ActionCode: actionCode, Summary: summary, ScopeType: constants.AuditScopePlatform,
Resources: []audit.ResourceInput{primary},
}, businessErr)
}
func withdrawalAuditState(withdrawal *model.CommissionWithdrawalRequest) map[string]any {
return map[string]any{
"amount": withdrawal.Amount, "fee": withdrawal.Fee, "actual_amount": withdrawal.ActualAmount,
"withdrawal_method": withdrawal.WithdrawalMethod, "payment_type": withdrawal.PaymentType,
"status": withdrawal.Status, "processor_id": withdrawal.ProcessorID,
"processed_at": withdrawal.ProcessedAt, "paid_at": withdrawal.PaidAt,
"reject_reason": withdrawal.RejectReason, "remark": withdrawal.Remark,
}
}

79
internal/service/shop_commission/service.go
View File

@@ -7,6 +7,7 @@ import (
"math/rand"
"time"
"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"
@@ -28,9 +29,15 @@ type Service struct {
commissionRecordStore *postgres.CommissionRecordStore
agentWalletTransactionStore *postgres.AgentWalletTransactionStore
db *gorm.DB
auditWriter *audit.Writer
logger *zap.Logger
}
// SetAuditWriter 注入佣金与提现统一审计 Writer。
func (s *Service) SetAuditWriter(writer *audit.Writer) {
s.auditWriter = writer
}
// New 创建代理商资金管理服务
func New(
shopStore *postgres.ShopStore,
@@ -460,7 +467,20 @@ func (s *Service) CreateWithdrawalRequest(ctx context.Context, shopID uint, req
}
accountInfoJSON, _ := json.Marshal(accountInfo)
var withdrawalRequest *model.CommissionWithdrawalRequest
withdrawalRequest := &model.CommissionWithdrawalRequest{
WithdrawalNo: withdrawalNo,
ShopID: shopID,
ApplicantID: currentUserID,
Amount: req.Amount,
FeeRate: setting.FeeRate,
Fee: fee,
ActualAmount: actualAmount,
WithdrawalMethod: req.WithdrawalMethod,
AccountInfo: accountInfoJSON,
Status: constants.WithdrawalStatusPending,
}
withdrawalRequest.Creator = currentUserID
withdrawalRequest.Updater = currentUserID
err = s.db.Transaction(func(tx *gorm.DB) error {
// 使用条件更新防并发
@@ -476,21 +496,6 @@ func (s *Service) CreateWithdrawalRequest(ctx context.Context, shopID uint, req
return errors.New(errors.CodeInsufficientBalance, "余额不足或并发冲突，请稍后重试")
}
withdrawalRequest = &model.CommissionWithdrawalRequest{
WithdrawalNo: withdrawalNo,
ShopID: shopID,
ApplicantID: currentUserID,
Amount: req.Amount,
FeeRate: setting.FeeRate,
Fee: fee,
ActualAmount: actualAmount,
WithdrawalMethod: req.WithdrawalMethod,
AccountInfo: accountInfoJSON,
Status: constants.WithdrawalStatusPending, // 待审核
}
withdrawalRequest.Creator = currentUserID
withdrawalRequest.Updater = currentUserID
if err := tx.WithContext(ctx).Create(withdrawalRequest).Error; err != nil {
return errors.Wrap(errors.CodeInternalError, err, "创建提现申请失败")
}
@@ -517,9 +522,10 @@ func (s *Service) CreateWithdrawalRequest(ctx context.Context, shopID uint, req
return errors.Wrap(errors.CodeInternalError, err, "创建钱包流水失败")
}
return nil
return s.appendWithdrawalRequestAudit(ctx, tx, withdrawalRequest, wallet, transaction)
})
if err != nil {
s.recordWithdrawalRequestFailure(ctx, withdrawalRequest, wallet, err)
return nil, err
}
@@ -625,7 +631,13 @@ func (s *Service) ResolveCommissionRecord(ctx context.Context, recordID uint, re
}
if record.Status != constants.CommissionStatusPendingReview {
return errors.New(errors.CodeInvalidParam, "该记录不是待修正状态")
actionCode := constants.AuditActionCommissionInvalidated
if req.Action == "release" {
actionCode = constants.AuditActionCommissionCredited
}
businessErr := errors.New(errors.CodeInvalidParam, "该记录不是待修正状态")
s.recordCommissionResolutionFailure(ctx, record, actionCode, "修正待审佣金失败", businessErr)
return businessErr
}
now := time.Now()
@@ -635,24 +647,37 @@ func (s *Service) ResolveCommissionRecord(ctx context.Context, recordID uint, re
}
if req.Action == "invalidate" {
return s.commissionRecordStore.UpdateByID(ctx, nil, recordID, map[string]any{
"status": constants.CommissionStatusInvalid,
"remark": resolveRemark,
err = s.db.Transaction(func(tx *gorm.DB) error {
if err := s.commissionRecordStore.UpdateByID(ctx, tx, recordID, map[string]any{
"status": constants.CommissionStatusInvalid,
"remark": resolveRemark,
}); err != nil {
return err
}
return s.appendCommissionResolutionAudit(ctx, tx, record, nil, constants.AuditActionCommissionInvalidated, "待审佣金已失效")
})
if err != nil {
s.recordCommissionResolutionFailure(ctx, record, constants.AuditActionCommissionInvalidated, "失效待审佣金失败", err)
}
return err
}
// release 入账
if req.Amount == nil || *req.Amount <= 0 {
return errors.New(errors.CodeInvalidParam, "入账操作必须指定金额")
businessErr := errors.New(errors.CodeInvalidParam, "入账操作必须指定金额")
s.recordCommissionResolutionFailure(ctx, record, constants.AuditActionCommissionCredited, "待审佣金入账失败", businessErr)
return businessErr
}
amount := *req.Amount
wallet, err := s.agentWalletStore.GetCommissionWallet(ctx, record.ShopID)
if err != nil {
return errors.Wrap(errors.CodeNotFound, err, "店铺佣金钱包不存在")
businessErr := errors.Wrap(errors.CodeNotFound, err, "店铺佣金钱包不存在")
s.recordCommissionResolutionFailure(ctx, record, constants.AuditActionCommissionCredited, "待审佣金入账失败", businessErr)
return businessErr
}
return s.db.Transaction(func(tx *gorm.DB) error {
err = s.db.Transaction(func(tx *gorm.DB) error {
if err := s.commissionRecordStore.UpdateByID(ctx, tx, recordID, map[string]any{
"status": constants.CommissionStatusReleased,
"amount": amount,
@@ -682,8 +707,12 @@ func (s *Service) ResolveCommissionRecord(ctx context.Context, recordID uint, re
return errors.Wrap(errors.CodeDatabaseError, err, "更新入账后余额失败")
}
return nil
return s.appendCommissionResolutionAudit(ctx, tx, record, wallet, constants.AuditActionCommissionCredited, "待审佣金已入账")
})
if err != nil {
s.recordCommissionResolutionFailure(ctx, record, constants.AuditActionCommissionCredited, "待审佣金入账失败", err)
}
return err
}
// generateWithdrawalNo 生成提现单号