junhong_cmp_fiber/internal/service/shop_commission/audit.go

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,
	}
}