break
98c145fe70
Some checks failed
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Failing after 3m55s
新增收款商户、商户池轮询、微信授权配置独立管理；三类新支付 （C端套餐购买、C端资产钱包充值、代理在线预存款充值）无条件 经商户池选择并冻结路由，无旧综合配置回退。merchant_id 为空 历史支付继续按 payment_config_id 双读。凭证版本化加载与 ID+版本缓存保证轮换一致性。删除商户池新支付创建开关及全部 引用。
722 lines
32 KiB
Go
722 lines
32 KiB
Go
// Package merchantpayment provides merchant pool payment routing use cases.
|
|
package merchantpayment
|
|
|
|
import (
|
|
"context"
|
|
"reflect"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"gorm.io/gorm"
|
|
"gorm.io/gorm/clause"
|
|
|
|
systemconfigapp "github.com/break/junhong_cmp_fiber/internal/application/systemconfig"
|
|
|
|
"github.com/break/junhong_cmp_fiber/internal/model"
|
|
"github.com/break/junhong_cmp_fiber/internal/model/dto"
|
|
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
|
"github.com/break/junhong_cmp_fiber/pkg/errors"
|
|
"github.com/break/junhong_cmp_fiber/pkg/middleware"
|
|
"github.com/bytedance/sonic"
|
|
)
|
|
|
|
// ManagementService 负责商户、商户池与授权配置写入。
|
|
type ManagementService struct {
|
|
db *gorm.DB
|
|
audit systemconfigapp.AuditWriter
|
|
}
|
|
|
|
// NewManagementService 创建商户配置用例。
|
|
func NewManagementService(db *gorm.DB, audit systemconfigapp.AuditWriter) *ManagementService {
|
|
return &ManagementService{db: db, audit: audit}
|
|
}
|
|
|
|
func requireManager(ctx context.Context) error {
|
|
kind := middleware.GetUserTypeFromContext(ctx)
|
|
if kind != constants.UserTypeSuperAdmin && kind != constants.UserTypePlatform {
|
|
return errors.New(errors.CodeForbidden, "无权限访问支付商户配置")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func normalizePage(page, size int) (int, int) {
|
|
if page < 1 {
|
|
page = 1
|
|
}
|
|
if size < 1 {
|
|
size = 20
|
|
}
|
|
if size > 100 {
|
|
size = 100
|
|
}
|
|
return page, size
|
|
}
|
|
|
|
func validPaymentMethod(method string) bool {
|
|
return method == "wechat" || method == "alipay"
|
|
}
|
|
|
|
func validateMerchantConfiguration(paymentMethod, providerType, merchantIdentity string, credentials model.JSONB) error {
|
|
paymentMethod, providerType, merchantIdentity = strings.TrimSpace(paymentMethod), strings.TrimSpace(providerType), strings.TrimSpace(merchantIdentity)
|
|
if !validPaymentMethod(paymentMethod) || merchantIdentity == "" || len(credentials) == 0 {
|
|
return errors.New(errors.CodeInvalidParam, "支付商户配置不完整")
|
|
}
|
|
var config model.WechatConfig
|
|
raw, err := sonic.Marshal(credentials)
|
|
if err != nil || sonic.Unmarshal(raw, &config) != nil {
|
|
return errors.New(errors.CodeInvalidParam, "支付商户凭证格式无效")
|
|
}
|
|
switch paymentMethod {
|
|
case "wechat":
|
|
switch providerType {
|
|
case model.ProviderTypeWechat:
|
|
if config.WxMchID != merchantIdentity || strings.TrimSpace(config.WxAPIV3Key) == "" || strings.TrimSpace(config.WxCertContent) == "" || strings.TrimSpace(config.WxKeyContent) == "" || strings.TrimSpace(config.WxSerialNo) == "" || strings.TrimSpace(config.WxNotifyURL) == "" {
|
|
return errors.New(errors.CodeInvalidParam, "微信直连商户凭证不完整或身份不一致")
|
|
}
|
|
case model.ProviderTypeWechatV2:
|
|
if config.WxMchID != merchantIdentity || strings.TrimSpace(config.WxAPIV2Key) == "" || strings.TrimSpace(config.WxNotifyURL) == "" {
|
|
return errors.New(errors.CodeInvalidParam, "微信 v2 商户凭证不完整或身份不一致")
|
|
}
|
|
case model.ProviderTypeFuiou:
|
|
if config.FyMchntCd != merchantIdentity || strings.TrimSpace(config.FyInsCd) == "" || strings.TrimSpace(config.FyTermID) == "" || strings.TrimSpace(config.FyPrivateKey) == "" || strings.TrimSpace(config.FyPublicKey) == "" || strings.TrimSpace(config.FyAPIURL) == "" || strings.TrimSpace(config.FyNotifyURL) == "" {
|
|
return errors.New(errors.CodeInvalidParam, "富友商户凭证不完整或身份不一致")
|
|
}
|
|
default:
|
|
return errors.New(errors.CodeInvalidParam, "微信支付服务商类型无效")
|
|
}
|
|
case "alipay":
|
|
if providerType != "alipay" || config.AliAppID != merchantIdentity || strings.TrimSpace(config.AliPrivateKey) == "" || strings.TrimSpace(config.AliPublicKey) == "" || strings.TrimSpace(config.AliNotifyURL) == "" || strings.TrimSpace(config.AliReturnURL) == "" {
|
|
return errors.New(errors.CodeInvalidParam, "支付宝商户凭证不完整或身份不一致")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validatePoolRequest(req dto.PaymentMerchantPoolRequest) error {
|
|
if !validPaymentMethod(strings.TrimSpace(req.PaymentMethod)) {
|
|
return errors.New(errors.CodeInvalidParam, "支付方式仅支持微信或支付宝")
|
|
}
|
|
switch req.Strategy {
|
|
case model.PaymentMerchantStrategyAmount:
|
|
if req.ThresholdAmount == nil || *req.ThresholdAmount <= 0 || req.ThresholdCount != nil || req.StatisticCycle == nil || !validStatisticCycle(*req.StatisticCycle) || req.TimePeriodValue != nil || req.TimePeriodUnit != nil || req.TimePeriodStartedAt != nil {
|
|
return errors.New(errors.CodeInvalidParam, "金额轮询策略参数不完整")
|
|
}
|
|
case model.PaymentMerchantStrategyCount:
|
|
if req.ThresholdCount == nil || *req.ThresholdCount <= 0 || req.ThresholdAmount != nil || req.StatisticCycle == nil || !validStatisticCycle(*req.StatisticCycle) || req.TimePeriodValue != nil || req.TimePeriodUnit != nil || req.TimePeriodStartedAt != nil {
|
|
return errors.New(errors.CodeInvalidParam, "笔数轮询策略参数不完整")
|
|
}
|
|
case model.PaymentMerchantStrategyTime:
|
|
if req.TimePeriodValue == nil || *req.TimePeriodValue < 1 || req.TimePeriodUnit == nil || !validTimeUnit(*req.TimePeriodUnit) || req.TimePeriodStartedAt == nil || req.ThresholdAmount != nil || req.ThresholdCount != nil || req.StatisticCycle != nil {
|
|
return errors.New(errors.CodeInvalidParam, "时间轮询策略参数不完整")
|
|
}
|
|
default:
|
|
return errors.New(errors.CodeInvalidParam, "不支持的商户池轮询策略")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func validStatisticCycle(value string) bool {
|
|
return value == "round" || value == "day" || value == "month"
|
|
}
|
|
func validTimeUnit(value string) bool { return value == "minute" || value == "hour" || value == "day" }
|
|
|
|
func (s *ManagementService) writeAudit(ctx context.Context, tx *gorm.DB, operation, description, key, name string, id uint, identity, before, after map[string]any) error {
|
|
if s.audit == nil {
|
|
return errors.New(errors.CodeInvalidStatus, "支付商户管理审计接缝未配置")
|
|
}
|
|
resourceID := strconv.FormatUint(uint64(id), 10)
|
|
return s.audit.WriteConfigChange(ctx, tx, systemconfigapp.ChangeAudit{
|
|
OperatorID: middleware.GetUserIDFromContext(ctx), OperationType: operation, Description: description,
|
|
ConfigKey: key, Module: "payment_merchant", ResourceID: &resourceID, DisplayName: name,
|
|
Identity: identity, BeforeData: before, AfterData: after, Result: constants.AuditResultSuccess,
|
|
})
|
|
}
|
|
|
|
func merchantAuditIdentity(m *model.PaymentMerchant) map[string]any {
|
|
return map[string]any{"id": m.ID, "name": m.Name, "payment_method": m.PaymentMethod, "provider_type": m.ProviderType, "merchant_identity": m.MerchantIdentity, "status": m.Status, "credential_version": m.CredentialVersion}
|
|
}
|
|
|
|
func poolAuditIdentity(p *model.PaymentMerchantPool) map[string]any {
|
|
return map[string]any{"id": p.ID, "name": p.Name, "payment_method": p.PaymentMethod, "strategy": p.Strategy, "status": p.Status, "routing_epoch": p.RoutingEpoch}
|
|
}
|
|
|
|
func authorizationAuditIdentity(a *model.WechatAuthorization) map[string]any {
|
|
return map[string]any{"id": a.ID, "status": a.Status, "credential_version": a.CredentialVersion, "oa_app_id": a.OaAppID, "miniapp_app_id": a.MiniappAppID}
|
|
}
|
|
|
|
// CreateMerchant 创建独立管理的支付商户。
|
|
func (s *ManagementService) CreateMerchant(ctx context.Context, req dto.PaymentMerchantRequest) (*dto.PaymentMerchantResponse, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if s == nil || s.db == nil || strings.TrimSpace(req.Name) == "" || len(req.Credentials) == 0 {
|
|
return nil, errors.New(errors.CodeInvalidParam, "商户参数或凭证不完整")
|
|
}
|
|
if !validPaymentMethod(strings.TrimSpace(req.PaymentMethod)) {
|
|
return nil, errors.New(errors.CodeInvalidParam, "支付方式仅支持微信或支付宝")
|
|
}
|
|
m := &model.PaymentMerchant{Name: strings.TrimSpace(req.Name), PaymentMethod: strings.TrimSpace(req.PaymentMethod), ProviderType: strings.TrimSpace(req.ProviderType), MerchantIdentity: strings.TrimSpace(req.MerchantIdentity), Credentials: req.Credentials, CredentialVersion: 1, Remark: strings.TrimSpace(req.Remark), BaseModel: model.BaseModel{Creator: middleware.GetUserIDFromContext(ctx), Updater: middleware.GetUserIDFromContext(ctx)}}
|
|
if req.Enabled {
|
|
m.Status = model.PaymentMerchantStatusEnabled
|
|
}
|
|
if m.MerchantIdentity == "" || m.ProviderType == "" {
|
|
return nil, errors.New(errors.CodeInvalidParam, "商户身份或服务商类型不能为空")
|
|
}
|
|
if err := validateMerchantConfiguration(m.PaymentMethod, m.ProviderType, m.MerchantIdentity, m.Credentials); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Create(m).Error; err != nil {
|
|
return err
|
|
}
|
|
return s.writeAudit(ctx, tx, constants.AuditOperationPaymentConfigCreate, "创建支付商户", "payment_merchant:"+strconv.FormatUint(uint64(m.ID), 10), m.Name, m.ID, merchantAuditIdentity(m), nil, merchantAuditIdentity(m))
|
|
}); err != nil {
|
|
if appErr, ok := err.(*errors.AppError); ok {
|
|
return nil, appErr
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "创建支付商户失败")
|
|
}
|
|
return merchantResponse(m), nil
|
|
}
|
|
|
|
// ListMerchants returns the privileged configuration projection.
|
|
|
|
// ListPools returns one page of merchant pools and their ordered members without per-pool member queries.
|
|
func (s *ManagementService) ListPools(ctx context.Context, req dto.PaymentMerchantPoolListRequest) ([]*dto.PaymentMerchantPoolResponse, int64, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
page, size := normalizePage(req.Page, req.PageSize)
|
|
query := s.db.WithContext(ctx).Model(&model.PaymentMerchantPool{})
|
|
var total int64
|
|
if err := query.Count(&total).Error; err != nil {
|
|
return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "统计商户池失败")
|
|
}
|
|
var pools []model.PaymentMerchantPool
|
|
if err := query.Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&pools).Error; err != nil {
|
|
return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "查询商户池失败")
|
|
}
|
|
poolIDs := make([]uint, 0, len(pools))
|
|
for index := range pools {
|
|
poolIDs = append(poolIDs, pools[index].ID)
|
|
}
|
|
membersByPool := make(map[uint][]uint, len(pools))
|
|
if len(poolIDs) > 0 {
|
|
var members []model.PaymentMerchantPoolMember
|
|
if err := s.db.WithContext(ctx).Where("pool_id IN ?", poolIDs).Order("pool_id ASC, sort_order ASC").Find(&members).Error; err != nil {
|
|
return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "查询商户池成员失败")
|
|
}
|
|
for index := range members {
|
|
member := &members[index]
|
|
membersByPool[member.PoolID] = append(membersByPool[member.PoolID], member.MerchantID)
|
|
}
|
|
}
|
|
result := make([]*dto.PaymentMerchantPoolResponse, 0, len(pools))
|
|
for index := range pools {
|
|
pool := &pools[index]
|
|
result = append(result, &dto.PaymentMerchantPoolResponse{ID: pool.ID, Name: pool.Name, PaymentMethod: pool.PaymentMethod, Enabled: pool.Status == model.PaymentMerchantStatusEnabled, Strategy: pool.Strategy, ThresholdAmount: pool.ThresholdAmount, ThresholdCount: pool.ThresholdCount, StatisticCycle: pool.StatisticCycle, TimePeriodValue: pool.TimePeriodValue, TimePeriodUnit: pool.TimePeriodUnit, TimePeriodStartedAt: pool.TimePeriodStartedAt, RoutingEpoch: pool.RoutingEpoch, MemberIDs: membersByPool[pool.ID], Remark: pool.Remark})
|
|
}
|
|
return result, total, nil
|
|
}
|
|
|
|
// GetPool 查询一个商户池及其有序成员。
|
|
func (s *ManagementService) GetPool(ctx context.Context, id uint) (*dto.PaymentMerchantPoolResponse, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
var pool model.PaymentMerchantPool
|
|
if err := s.db.WithContext(ctx).First(&pool, id).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, errors.New(errors.CodeNotFound, "商户池不存在")
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询商户池失败")
|
|
}
|
|
return poolResponse(ctx, s.db, &pool)
|
|
}
|
|
|
|
// ListMerchants 分页查询特权商户配置。
|
|
func (s *ManagementService) ListMerchants(ctx context.Context, req dto.PaymentMerchantListRequest) ([]*dto.PaymentMerchantResponse, int64, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, 0, err
|
|
}
|
|
page, size := normalizePage(req.Page, req.PageSize)
|
|
query := s.db.WithContext(ctx).Model(&model.PaymentMerchant{})
|
|
if req.PaymentMethod != nil {
|
|
query = query.Where("payment_method = ?", strings.TrimSpace(*req.PaymentMethod))
|
|
}
|
|
if req.Enabled != nil {
|
|
status := model.PaymentMerchantStatusDisabled
|
|
if *req.Enabled {
|
|
status = model.PaymentMerchantStatusEnabled
|
|
}
|
|
query = query.Where("status = ?", status)
|
|
}
|
|
var total int64
|
|
if err := query.Count(&total).Error; err != nil {
|
|
return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "查询支付商户失败")
|
|
}
|
|
var rows []model.PaymentMerchant
|
|
if err := query.Order("id DESC").Offset((page - 1) * size).Limit(size).Find(&rows).Error; err != nil {
|
|
return nil, 0, errors.Wrap(errors.CodeDatabaseError, err, "查询支付商户失败")
|
|
}
|
|
result := make([]*dto.PaymentMerchantResponse, 0, len(rows))
|
|
for index := range rows {
|
|
result = append(result, merchantResponse(&rows[index]))
|
|
}
|
|
return result, total, nil
|
|
}
|
|
|
|
// GetMerchant 查询一个特权商户配置。
|
|
func (s *ManagementService) GetMerchant(ctx context.Context, id uint) (*dto.PaymentMerchantResponse, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
var m model.PaymentMerchant
|
|
if err := s.db.WithContext(ctx).First(&m, id).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, errors.New(errors.CodeNotFound, "支付商户不存在")
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询支付商户失败")
|
|
}
|
|
return merchantResponse(&m), nil
|
|
}
|
|
|
|
// UpdateMerchant 更新商户凭证和可变配置。
|
|
func (s *ManagementService) UpdateMerchant(ctx context.Context, id uint, req dto.PaymentMerchantUpdateRequest) (*dto.PaymentMerchantResponse, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if req.PaymentMethod != nil && !validPaymentMethod(strings.TrimSpace(*req.PaymentMethod)) {
|
|
return nil, errors.New(errors.CodeInvalidParam, "支付方式仅支持微信或支付宝")
|
|
}
|
|
var m model.PaymentMerchant
|
|
if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&m, id).Error; err != nil {
|
|
return err
|
|
}
|
|
before := merchantAuditIdentity(&m)
|
|
previous := m
|
|
var refs int64
|
|
if err := tx.Model(&model.Payment{}).Where("merchant_id = ?", id).Count(&refs).Error; err != nil {
|
|
return err
|
|
}
|
|
if refs > 0 && ((req.PaymentMethod != nil && *req.PaymentMethod != m.PaymentMethod) || (req.ProviderType != nil && *req.ProviderType != m.ProviderType) || (req.MerchantIdentity != nil && *req.MerchantIdentity != m.MerchantIdentity)) {
|
|
return errors.New(errors.CodeConflict, "已被支付单引用，不能修改收款身份")
|
|
}
|
|
if req.Name != nil {
|
|
m.Name = strings.TrimSpace(*req.Name)
|
|
}
|
|
if req.PaymentMethod != nil {
|
|
m.PaymentMethod = strings.TrimSpace(*req.PaymentMethod)
|
|
}
|
|
if req.ProviderType != nil {
|
|
m.ProviderType = strings.TrimSpace(*req.ProviderType)
|
|
}
|
|
if req.MerchantIdentity != nil {
|
|
m.MerchantIdentity = strings.TrimSpace(*req.MerchantIdentity)
|
|
}
|
|
if req.Remark != nil {
|
|
m.Remark = strings.TrimSpace(*req.Remark)
|
|
}
|
|
if req.Enabled != nil {
|
|
m.Status = model.PaymentMerchantStatusDisabled
|
|
if *req.Enabled {
|
|
m.Status = model.PaymentMerchantStatusEnabled
|
|
}
|
|
}
|
|
if req.Credentials != nil && !reflect.DeepEqual(m.Credentials, *req.Credentials) {
|
|
m.Credentials = *req.Credentials
|
|
}
|
|
if previous.Name != m.Name || previous.PaymentMethod != m.PaymentMethod || previous.ProviderType != m.ProviderType || previous.MerchantIdentity != m.MerchantIdentity || previous.Status != m.Status || !reflect.DeepEqual(previous.Credentials, m.Credentials) {
|
|
m.CredentialVersion++
|
|
}
|
|
if err := validateMerchantConfiguration(m.PaymentMethod, m.ProviderType, m.MerchantIdentity, m.Credentials); err != nil {
|
|
return err
|
|
}
|
|
if err := tx.Save(&m).Error; err != nil {
|
|
return err
|
|
}
|
|
return s.writeAudit(ctx, tx, constants.AuditOperationPaymentConfigUpdate, "更新支付商户", "payment_merchant:"+strconv.FormatUint(uint64(m.ID), 10), m.Name, m.ID, merchantAuditIdentity(&m), before, merchantAuditIdentity(&m))
|
|
}); err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, errors.New(errors.CodeNotFound, "支付商户不存在")
|
|
}
|
|
if appErr, ok := err.(*errors.AppError); ok {
|
|
return nil, appErr
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "更新支付商户失败")
|
|
}
|
|
return merchantResponse(&m), nil
|
|
}
|
|
|
|
// DeleteMerchant 仅在未被引用且二次确认后删除商户。
|
|
func (s *ManagementService) DeleteMerchant(ctx context.Context, id uint, confirm bool) error {
|
|
if err := requireManager(ctx); err != nil {
|
|
return err
|
|
}
|
|
if !confirm {
|
|
return errors.New(errors.CodeInvalidParam, "删除商户必须二次确认")
|
|
}
|
|
return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
var refs, members int64
|
|
var merchant model.PaymentMerchant
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&merchant, id).Error; err != nil {
|
|
return err
|
|
}
|
|
before := merchantAuditIdentity(&merchant)
|
|
if err := tx.Model(&model.Payment{}).Where("merchant_id = ?", id).Count(&refs).Error; err != nil {
|
|
return err
|
|
}
|
|
if refs > 0 {
|
|
return errors.New(errors.CodeConflict, "已被支付单引用的商户不能删除")
|
|
}
|
|
if err := tx.Model(&model.PaymentMerchantPoolMember{}).Where("merchant_id = ?", id).Count(&members).Error; err != nil {
|
|
return err
|
|
}
|
|
if members > 0 {
|
|
return errors.New(errors.CodeConflict, "商户仍属于商户池")
|
|
}
|
|
r := tx.Delete(&model.PaymentMerchant{}, id)
|
|
if r.Error != nil {
|
|
return r.Error
|
|
}
|
|
if r.RowsAffected == 0 {
|
|
return errors.New(errors.CodeNotFound, "支付商户不存在")
|
|
}
|
|
if err := s.writeAudit(ctx, tx, constants.AuditOperationPaymentConfigDelete, "删除支付商户", "payment_merchant:"+strconv.FormatUint(uint64(merchant.ID), 10), merchant.Name, merchant.ID, before, before, nil); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
// SavePool 创建或更新商户池，并原子替换有序成员。
|
|
func (s *ManagementService) SavePool(ctx context.Context, id uint, req dto.PaymentMerchantPoolRequest) (*dto.PaymentMerchantPoolResponse, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if err := validatePoolRequest(req); err != nil {
|
|
return nil, err
|
|
}
|
|
if len(req.MemberIDs) == 0 {
|
|
return nil, errors.New(errors.CodeInvalidParam, "商户池至少需要一个商户")
|
|
}
|
|
var pool model.PaymentMerchantPool
|
|
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
creating := id == 0
|
|
var previousMemberIDs []uint
|
|
if !creating {
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&pool, id).Error; err != nil {
|
|
return err
|
|
}
|
|
var previousMembers []model.PaymentMerchantPoolMember
|
|
if err := tx.Where("pool_id = ?", pool.ID).Order("sort_order ASC").Find(&previousMembers).Error; err != nil {
|
|
return err
|
|
}
|
|
previousMemberIDs = make([]uint, 0, len(previousMembers))
|
|
for _, member := range previousMembers {
|
|
previousMemberIDs = append(previousMemberIDs, member.MerchantID)
|
|
}
|
|
} else {
|
|
pool.Creator = middleware.GetUserIDFromContext(ctx)
|
|
pool.RoutingEpoch = 1
|
|
}
|
|
before := poolAuditIdentity(&pool)
|
|
if err := validatePoolMembers(ctx, tx, req.PaymentMethod, req.MemberIDs); err != nil {
|
|
return err
|
|
}
|
|
if !creating && poolEpochChanged(&pool, &req, previousMemberIDs) {
|
|
pool.RoutingEpoch++
|
|
}
|
|
pool.Name, pool.PaymentMethod, pool.Strategy, pool.Remark = strings.TrimSpace(req.Name), strings.TrimSpace(req.PaymentMethod), strings.TrimSpace(req.Strategy), strings.TrimSpace(req.Remark)
|
|
pool.ThresholdAmount, pool.ThresholdCount, pool.StatisticCycle, pool.TimePeriodValue, pool.TimePeriodUnit, pool.TimePeriodStartedAt = req.ThresholdAmount, req.ThresholdCount, req.StatisticCycle, req.TimePeriodValue, req.TimePeriodUnit, req.TimePeriodStartedAt
|
|
if req.Enabled {
|
|
var others int64
|
|
if err := tx.Model(&model.PaymentMerchantPool{}).Where("payment_method = ? AND status = ? AND id <> ?", pool.PaymentMethod, model.PaymentMerchantStatusEnabled, pool.ID).Count(&others).Error; err != nil {
|
|
return err
|
|
}
|
|
if others > 0 {
|
|
return errors.New(errors.CodeConflict, "该支付方式已有启用商户池")
|
|
}
|
|
}
|
|
pool.Status = model.PaymentMerchantStatusDisabled
|
|
if req.Enabled {
|
|
pool.Status = model.PaymentMerchantStatusEnabled
|
|
}
|
|
pool.Updater = middleware.GetUserIDFromContext(ctx)
|
|
if creating {
|
|
if err := tx.Create(&pool).Error; err != nil {
|
|
return err
|
|
}
|
|
} else if err := tx.Save(&pool).Error; err != nil {
|
|
return err
|
|
}
|
|
if err := tx.Where("pool_id = ?", pool.ID).Delete(&model.PaymentMerchantPoolMember{}).Error; err != nil {
|
|
return err
|
|
}
|
|
members := make([]model.PaymentMerchantPoolMember, 0, len(req.MemberIDs))
|
|
for i, merchantID := range req.MemberIDs {
|
|
members = append(members, model.PaymentMerchantPoolMember{PoolID: pool.ID, MerchantID: merchantID, SortOrder: int64(i), BaseModel: model.BaseModel{Creator: middleware.GetUserIDFromContext(ctx), Updater: middleware.GetUserIDFromContext(ctx)}})
|
|
}
|
|
if err := tx.Create(&members).Error; err != nil {
|
|
return err
|
|
}
|
|
op := constants.AuditOperationPaymentConfigUpdate
|
|
summary := "更新商户池"
|
|
if creating {
|
|
op = constants.AuditOperationPaymentConfigCreate
|
|
summary = "创建商户池"
|
|
}
|
|
return s.writeAudit(ctx, tx, op, summary, "payment_merchant_pool:"+strconv.FormatUint(uint64(pool.ID), 10), pool.Name, pool.ID, poolAuditIdentity(&pool), before, poolAuditIdentity(&pool))
|
|
})
|
|
if err != nil {
|
|
if appErr, ok := err.(*errors.AppError); ok {
|
|
return nil, appErr
|
|
}
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, errors.New(errors.CodeNotFound, "商户池不存在")
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "保存商户池失败")
|
|
}
|
|
return poolResponse(ctx, s.db, &pool)
|
|
}
|
|
|
|
// SetPoolEnabled enables or disables a pool after rechecking the active-pool and member invariants.
|
|
func (s *ManagementService) SetPoolEnabled(ctx context.Context, id uint, enabled bool) (*dto.PaymentMerchantPoolResponse, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
var pool model.PaymentMerchantPool
|
|
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&pool, id).Error; err != nil {
|
|
return err
|
|
}
|
|
before := poolAuditIdentity(&pool)
|
|
if enabled {
|
|
var others int64
|
|
if err := tx.Model(&model.PaymentMerchantPool{}).Where("payment_method = ? AND status = ? AND id <> ?", pool.PaymentMethod, model.PaymentMerchantStatusEnabled, pool.ID).Count(&others).Error; err != nil {
|
|
return err
|
|
}
|
|
if others > 0 {
|
|
return errors.New(errors.CodeConflict, "该支付方式已有启用商户池")
|
|
}
|
|
var members []model.PaymentMerchantPoolMember
|
|
if err := tx.Where("pool_id = ?", pool.ID).Order("sort_order ASC").Find(&members).Error; err != nil {
|
|
return err
|
|
}
|
|
ids := make([]uint, 0, len(members))
|
|
for _, member := range members {
|
|
ids = append(ids, member.MerchantID)
|
|
}
|
|
if err := validatePoolMembers(ctx, tx, pool.PaymentMethod, ids); err != nil {
|
|
return err
|
|
}
|
|
pool.Status = model.PaymentMerchantStatusEnabled
|
|
} else {
|
|
pool.Status = model.PaymentMerchantStatusDisabled
|
|
}
|
|
pool.Updater = middleware.GetUserIDFromContext(ctx)
|
|
if err := tx.Save(&pool).Error; err != nil {
|
|
return err
|
|
}
|
|
op := constants.AuditOperationPaymentConfigDeactivate
|
|
summary := "停用商户池"
|
|
if enabled {
|
|
op = constants.AuditOperationPaymentConfigActivate
|
|
summary = "启用商户池"
|
|
}
|
|
return s.writeAudit(ctx, tx, op, summary, "payment_merchant_pool:"+strconv.FormatUint(uint64(pool.ID), 10), pool.Name, pool.ID, poolAuditIdentity(&pool), before, poolAuditIdentity(&pool))
|
|
})
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, errors.New(errors.CodeNotFound, "商户池不存在")
|
|
}
|
|
if appErr, ok := err.(*errors.AppError); ok {
|
|
return nil, appErr
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "更新商户池状态失败")
|
|
}
|
|
return poolResponse(ctx, s.db, &pool)
|
|
}
|
|
|
|
func validatePoolMembers(ctx context.Context, tx *gorm.DB, method string, ids []uint) error {
|
|
seen := map[uint]struct{}{}
|
|
|
|
for _, id := range ids {
|
|
if id == 0 {
|
|
return errors.New(errors.CodeInvalidParam, "商户ID无效")
|
|
}
|
|
if _, ok := seen[id]; ok {
|
|
return errors.New(errors.CodeInvalidParam, "商户池成员不能重复")
|
|
}
|
|
seen[id] = struct{}{}
|
|
}
|
|
var merchants []model.PaymentMerchant
|
|
if err := tx.WithContext(ctx).Where("id IN ? AND payment_method = ? AND status = ?", ids, method, model.PaymentMerchantStatusEnabled).Find(&merchants).Error; err != nil {
|
|
return err
|
|
}
|
|
if len(merchants) != len(ids) {
|
|
return errors.New(errors.CodeConflict, "商户池成员必须存在、启用且支付方式一致")
|
|
}
|
|
for index := range merchants {
|
|
merchant := &merchants[index]
|
|
if err := validateMerchantConfiguration(merchant.PaymentMethod, merchant.ProviderType, merchant.MerchantIdentity, merchant.Credentials); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
func poolEpochChanged(pool *model.PaymentMerchantPool, request *dto.PaymentMerchantPoolRequest, previousMemberIDs []uint) bool {
|
|
if pool.PaymentMethod != strings.TrimSpace(request.PaymentMethod) ||
|
|
pool.Strategy != request.Strategy ||
|
|
!sameString(pool.StatisticCycle, request.StatisticCycle) ||
|
|
!sameInt64(pool.TimePeriodValue, request.TimePeriodValue) ||
|
|
!sameString(pool.TimePeriodUnit, request.TimePeriodUnit) ||
|
|
!sameTime(pool.TimePeriodStartedAt, request.TimePeriodStartedAt) {
|
|
return true
|
|
}
|
|
if sameMemberOrder(previousMemberIDs, request.MemberIDs) {
|
|
return false
|
|
}
|
|
return pool.StatisticCycle == nil || (*pool.StatisticCycle != "day" && *pool.StatisticCycle != "month") || !sameMemberSet(previousMemberIDs, request.MemberIDs)
|
|
}
|
|
|
|
func sameMemberOrder(left, right []uint) bool {
|
|
if len(left) != len(right) {
|
|
return false
|
|
}
|
|
for i := range left {
|
|
if left[i] != right[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func sameMemberSet(left, right []uint) bool {
|
|
if len(left) != len(right) {
|
|
return false
|
|
}
|
|
seen := make(map[uint]struct{}, len(left))
|
|
for _, id := range left {
|
|
seen[id] = struct{}{}
|
|
}
|
|
for _, id := range right {
|
|
if _, ok := seen[id]; !ok {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func sameString(left, right *string) bool {
|
|
if left == nil || right == nil {
|
|
return left == right
|
|
}
|
|
return *left == *right
|
|
}
|
|
|
|
func sameInt64(left, right *int64) bool {
|
|
if left == nil || right == nil {
|
|
return left == right
|
|
}
|
|
return *left == *right
|
|
}
|
|
|
|
func sameTime(a, b *time.Time) bool {
|
|
if a == nil || b == nil {
|
|
return a == b
|
|
}
|
|
return a.Equal(*b)
|
|
}
|
|
func merchantResponse(m *model.PaymentMerchant) *dto.PaymentMerchantResponse {
|
|
return &dto.PaymentMerchantResponse{ID: m.ID, Name: m.Name, PaymentMethod: m.PaymentMethod, ProviderType: m.ProviderType, MerchantIdentity: m.MerchantIdentity, Credentials: m.Credentials, CredentialVersion: m.CredentialVersion, Enabled: m.Status == model.PaymentMerchantStatusEnabled, Remark: m.Remark, CreatedAt: m.CreatedAt, UpdatedAt: m.UpdatedAt}
|
|
}
|
|
func poolResponse(ctx context.Context, db *gorm.DB, p *model.PaymentMerchantPool) (*dto.PaymentMerchantPoolResponse, error) {
|
|
var rows []model.PaymentMerchantPoolMember
|
|
if err := db.WithContext(ctx).Where("pool_id = ?", p.ID).Order("sort_order ASC").Find(&rows).Error; err != nil {
|
|
return nil, err
|
|
}
|
|
ids := make([]uint, 0, len(rows))
|
|
for _, row := range rows {
|
|
ids = append(ids, row.MerchantID)
|
|
}
|
|
return &dto.PaymentMerchantPoolResponse{ID: p.ID, Name: p.Name, PaymentMethod: p.PaymentMethod, Enabled: p.Status == model.PaymentMerchantStatusEnabled, Strategy: p.Strategy, ThresholdAmount: p.ThresholdAmount, ThresholdCount: p.ThresholdCount, StatisticCycle: p.StatisticCycle, TimePeriodValue: p.TimePeriodValue, TimePeriodUnit: p.TimePeriodUnit, TimePeriodStartedAt: p.TimePeriodStartedAt, RoutingEpoch: p.RoutingEpoch, MemberIDs: ids, Remark: p.Remark}, nil
|
|
}
|
|
|
|
// GetAuthorization 查询特权全局授权配置。
|
|
func (s *ManagementService) GetAuthorization(ctx context.Context) (*dto.WechatAuthorizationResponse, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
var a model.WechatAuthorization
|
|
if err := s.db.WithContext(ctx).First(&a).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, nil
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询微信授权配置失败")
|
|
}
|
|
return authorizationResponse(&a), nil
|
|
}
|
|
|
|
// SaveAuthorization 创建或更新唯一启用的授权配置。
|
|
func (s *ManagementService) SaveAuthorization(ctx context.Context, req dto.WechatAuthorizationRequest) (*dto.WechatAuthorizationResponse, error) {
|
|
if err := requireManager(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
if req.Enabled && (strings.TrimSpace(req.OaAppID) == "" || strings.TrimSpace(req.OaAppSecret) == "" || strings.TrimSpace(req.MiniappAppID) == "" || strings.TrimSpace(req.MiniappAppSecret) == "") {
|
|
return nil, errors.New(errors.CodeInvalidParam, "启用微信授权配置时公众号和小程序凭证必须完整")
|
|
}
|
|
var authorization model.WechatAuthorization
|
|
err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&authorization).Error
|
|
if err != nil && err != gorm.ErrRecordNotFound {
|
|
return err
|
|
}
|
|
previousStatus := authorization.Status
|
|
creating := err == gorm.ErrRecordNotFound
|
|
before := authorizationAuditIdentity(&authorization)
|
|
if creating {
|
|
authorization.Creator = middleware.GetUserIDFromContext(ctx)
|
|
authorization.CredentialVersion = 1
|
|
}
|
|
changed := authorization.OaAppID != req.OaAppID || authorization.OaAppSecret != req.OaAppSecret || authorization.OaToken != req.OaToken || authorization.OaAesKey != req.OaAesKey || authorization.OaOAuthRedirectURL != req.OaOAuthRedirectURL || authorization.MiniappAppID != req.MiniappAppID || authorization.MiniappAppSecret != req.MiniappAppSecret
|
|
authorization.OaAppID, authorization.OaAppSecret, authorization.OaToken, authorization.OaAesKey, authorization.OaOAuthRedirectURL, authorization.MiniappAppID, authorization.MiniappAppSecret = req.OaAppID, req.OaAppSecret, req.OaToken, req.OaAesKey, req.OaOAuthRedirectURL, req.MiniappAppID, req.MiniappAppSecret
|
|
authorization.Status = model.PaymentMerchantStatusDisabled
|
|
if req.Enabled {
|
|
authorization.Status = model.PaymentMerchantStatusEnabled
|
|
}
|
|
if !creating && (changed || previousStatus != authorization.Status) {
|
|
authorization.CredentialVersion++
|
|
}
|
|
authorization.Updater = middleware.GetUserIDFromContext(ctx)
|
|
if creating {
|
|
if err := tx.Create(&authorization).Error; err != nil {
|
|
return err
|
|
}
|
|
} else {
|
|
if err := tx.Save(&authorization).Error; err != nil {
|
|
return err
|
|
}
|
|
}
|
|
op := constants.AuditOperationPaymentConfigUpdate
|
|
summary := "更新微信授权配置"
|
|
if creating {
|
|
op = constants.AuditOperationPaymentConfigCreate
|
|
summary = "创建微信授权配置"
|
|
}
|
|
return s.writeAudit(ctx, tx, op, summary, "wechat_authorization:"+strconv.FormatUint(uint64(authorization.ID), 10), "微信授权配置", authorization.ID, authorizationAuditIdentity(&authorization), before, authorizationAuditIdentity(&authorization))
|
|
})
|
|
if err != nil {
|
|
if appErr, ok := err.(*errors.AppError); ok {
|
|
return nil, appErr
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "保存微信授权配置失败")
|
|
}
|
|
return authorizationResponse(&authorization), nil
|
|
}
|
|
func authorizationResponse(a *model.WechatAuthorization) *dto.WechatAuthorizationResponse {
|
|
return &dto.WechatAuthorizationResponse{ID: a.ID, OaAppID: a.OaAppID, OaAppSecret: a.OaAppSecret, OaToken: a.OaToken, OaAesKey: a.OaAesKey, OaOAuthRedirectURL: a.OaOAuthRedirectURL, MiniappAppID: a.MiniappAppID, MiniappAppSecret: a.MiniappAppSecret, CredentialVersion: a.CredentialVersion, Enabled: a.Status == model.PaymentMerchantStatusEnabled, UpdatedAt: a.UpdatedAt}
|
|
}
|