f

app/main/api/desc/front/pay.api

@@ -49,7 +49,7 @@ service main {
 type (
 	PaymentReq {
 		Id        string `json:"id"`
-		PayMethod string `json:"pay_method"` // 支付方式: wechat, alipay, appleiap, test(仅开发环境), test_empty(仅开发环境-空报告模式)
+		PayMethod string `json:"pay_method"` // 支付方式: wechat, alipay, easypay_alipay, appleiap, yunyinSignPay, yunyinSignPay_wechat, yunyinSignPay_alipay, test(仅开发环境), test_empty(仅开发环境-空报告模式)
 		// 系统简化：移除 agent_vip, agent_upgrade 支付类型
 		PayType   string `json:"pay_type" validate:"required,oneof=query"`
 	}

app/main/api/etc/main.dev.yaml

@@ -90,5 +90,16 @@ EasyPay:
     CIDs: ["12200"] # 支付渠道ID数组，可配置一个或多个，多个时会按RotateDays轮询
     # CIDs: ["12200", "12201", "12202"]  # 多个渠道示例，会按RotateDays天数轮询
     RotateDays: 3 # 渠道轮询天数，默认3天（仅在配置了多个CIDs时生效）
+    RotateMode: "count" # 轮询模式：day（天数轮询）或 count（次数轮询），默认count
     NotifyUrl: "https://www.dsjcq168.cn/api/v1/pay/easypay/callback"
     ReturnUrl: "https://www.dsjcq168.cn/payment/result"
+YunYinSignPay:
+  Enabled: true
+  ApiURL: "https://openapi.yunyinsign.com"
+  AppID: "7226242043420468"
+  AppSecret: "ceac4dc740e3443bbb1433fbe9723326"
+  Mobile: "18566214578"
+  Name: "陈立"
+  CorpName: "海口开麦贸易有限公司"
+  TemplateCode: "TP1461036991700317184"  # 需要配置实际的模板ID
+  TemplateName: "信息服务授权书"  # 需要配置实际的模板名称

app/main/api/etc/main.yaml

@@ -92,3 +92,13 @@ EasyPay:
     RotateDays: 3 # 渠道轮询天数，默认3天（仅在RotateMode=day时生效）
     NotifyUrl: "https://www.dsjcq168.cn/api/v1/pay/easypay/callback"
     ReturnUrl: "https://www.dsjcq168.cn/payment/result"
+YunYinSignPay:
+  Enabled: true
+  ApiURL: "https://openapi.yunyinsign.com"
+  AppID: "7226242043420468"
+  AppSecret: "ceac4dc740e3443bbb1433fbe9723326"
+  Mobile: "18566214578"
+  Name: "陈立"
+  CorpName: "海口开麦贸易有限公司"
+  TemplateCode: "TP1461036991700317184"  # 需要配置实际的模板ID
+  TemplateName: "信息服务授权书"  # 需要配置实际的模板名称

app/main/api/internal/config/config.go

@@ -16,6 +16,7 @@ type Config struct {
 	Wxpay         WxpayConfig
 	Applepay      ApplepayConfig
 	EasyPay       EasyPayConfig
+	YunYinSignPay YunYinSignPayConfig
 	Tianyuanapi   TianyuanapiConfig
 	SystemConfig  SystemConfig
 	WechatH5      WechatH5Config
@@ -135,3 +136,16 @@ type EasyPayConfig struct {
 	NotifyUrl  string   // 异步通知地址
 	ReturnUrl  string   // 页面跳转地址
 }
+
+// YunYinSignPayConfig 云印签支付配置
+type YunYinSignPayConfig struct {
+	Enabled      bool   // 是否启用云印签支付
+	ApiURL       string // 接口地址
+	AppID        string // 应用ID
+	AppSecret    string // 应用密钥
+	Mobile       string // 我方手机号
+	Name         string // 我方姓名
+	CorpName     string // 我方公司名称
+	TemplateCode string // 模板代码
+	TemplateName string // 模板名称
+}

app/main/api/internal/logic/pay/paymentchecklogic.go

@@ -95,6 +95,112 @@ func (l *PaymentCheckLogic) PaymentCheck(req *types.PaymentCheckReq) (resp *type
 		}
 	}
 
+	// 如果订单状态是 pending 且支付平台是云印签支付，主动查询云印签订单状态
+	if order.Status == "pending" && (order.PaymentPlatform == "yunyinSignPay" || order.PaymentPlatform == "yunyinSignPay_wechat" || order.PaymentPlatform == "yunyinSignPay_alipay") {
+		// 检查云印签支付服务是否启用
+		if l.svcCtx.YunYinSignPayService != nil {
+			// 主动查询云印签订单状态
+			queryResp, queryErr := l.svcCtx.YunYinSignPayService.QueryPayeeBill(l.ctx, req.OrderNo)
+			if queryErr != nil {
+				logx.Errorf("主动查询云印签订单状态失败，订单号: %s, 错误: %v", req.OrderNo, queryErr)
+				// 查询失败不影响返回，继续返回当前订单状态
+			} else {
+				// 根据云印签返回的支付状态更新本地订单状态
+				// 云印签 payStatus: 0-订单生成, 1-支付中, 2-支付成功, 3-支付失败, 4-已退款
+				// 我们的订单状态: pending, paid, failed, refunded
+				var newOrderStatus string
+				var shouldUpdate bool
+
+				switch queryResp.PayStatus {
+				case 2: // 支付成功
+					newOrderStatus = "paid"
+					shouldUpdate = true
+				case 3: // 支付失败
+					newOrderStatus = "failed"
+					shouldUpdate = true
+				case 4: // 已退款
+					newOrderStatus = "refunded"
+					shouldUpdate = true
+				case 0, 1: // 订单生成或支付中，保持 pending
+					// 不更新，继续返回 pending
+				}
+
+				if shouldUpdate {
+					logx.Infof("主动查询发现云印签订单状态已变更，订单号: %s, 支付状态: %d, 新订单状态: %s", req.OrderNo, queryResp.PayStatus, newOrderStatus)
+
+					// 重新查询订单（获取最新版本号）
+					order, err = l.svcCtx.OrderModel.FindOneByOrderNo(l.ctx, req.OrderNo)
+					if err != nil {
+						logx.Errorf("更新订单状态前重新查询订单失败: %v", err)
+					} else {
+						// 更新云印签订单表的支付状态（无论订单状态如何，都要同步云印签的状态）
+						yunyinOrder, findYunyinErr := l.svcCtx.YunyinSignPayOrderModel.FindOneByOrderId(l.ctx, order.Id)
+						if findYunyinErr == nil && yunyinOrder != nil {
+							// 更新支付状态
+							// 云印签 payStatus: 0-订单生成, 1-支付中, 2-支付成功, 3-支付失败, 4-已退款
+							// 我们的 payStatus: 0-待支付, 1-已支付, 2-已退款
+							var newPayStatus int64
+							if queryResp.PayStatus == 2 {
+								newPayStatus = 1 // 已支付
+							} else if queryResp.PayStatus == 4 {
+								newPayStatus = 2 // 已退款
+							} else if queryResp.PayStatus == 3 {
+								// 支付失败，保持待支付状态
+								newPayStatus = 0
+							}
+
+							if newPayStatus != yunyinOrder.PayStatus {
+								yunyinOrder.PayStatus = newPayStatus
+								if updateYunyinErr := l.svcCtx.YunyinSignPayOrderModel.Update(l.ctx, yunyinOrder); updateYunyinErr != nil {
+									logx.Errorf("更新云印签订单支付状态失败: %v", updateYunyinErr)
+								} else {
+									logx.Infof("成功更新云印签订单支付状态，订单ID: %s, 新支付状态: %d", order.Id, newPayStatus)
+								}
+							}
+						}
+
+						// 只有在订单状态是 pending 时才更新订单状态
+						if order.Status == "pending" {
+							// 更新订单状态
+							order.Status = newOrderStatus
+							if newOrderStatus == "paid" {
+								order.PayTime = lzUtils.TimeToNullTime(time.Now())
+								if queryResp.ChannelOrderNo != "" {
+									order.PlatformOrderId = lzUtils.StringToNullString(queryResp.ChannelOrderNo)
+								}
+							} else if newOrderStatus == "refunded" {
+								order.RefundTime = lzUtils.TimeToNullTime(time.Now())
+							}
+
+							if updateErr := l.svcCtx.OrderModel.UpdateWithVersion(l.ctx, nil, order); updateErr != nil {
+								logx.Errorf("主动查询后更新订单状态失败: %v", updateErr)
+							} else {
+								logx.Infof("主动查询后成功更新订单状态，订单号: %s, 新状态: %s", req.OrderNo, newOrderStatus)
+
+								// 如果订单已支付，发送异步任务处理后续流程
+								if newOrderStatus == "paid" {
+									if asyncErr := l.svcCtx.AsynqService.SendQueryTask(order.Id); asyncErr != nil {
+										logx.Errorf("主动查询后发送异步任务失败: %v", asyncErr)
+									}
+								}
+
+								// 返回更新后的状态
+								return &types.PaymentCheckResp{
+									Type:   "query",
+									Status: newOrderStatus,
+								}, nil
+							}
+						} else {
+							// 订单状态已经不是 pending，说明可能已经被其他流程处理
+							// 但仍然返回当前状态
+							logx.Infof("订单状态已不是 pending，当前状态: %s，跳过更新", order.Status)
+						}
+					}
+				}
+			}
+		}
+	}
+
 	return &types.PaymentCheckResp{
 		Type:   "query",
 		Status: order.Status,

app/main/api/internal/logic/pay/paymentlogic.go

@@ -3,13 +3,16 @@ package pay
 import (
 	"context"
 	"database/sql"
+	"encoding/hex"
 	"encoding/json"
 	"fmt"
+	"jnc-server/app/main/api/internal/service"
 	"jnc-server/app/main/api/internal/svc"
 	"jnc-server/app/main/api/internal/types"
 	"jnc-server/app/main/model"
 	"jnc-server/common/ctxdata"
 	"jnc-server/common/xerr"
+	"jnc-server/pkg/lzkit/crypto"
 	"os"
 	"strings"
 	"time"
@@ -31,6 +34,8 @@ type PaymentTypeResp struct {
 	outTradeNo  string
 	description string
 	orderID     string // 订单ID，用于开发环境测试支付模式
+	userName    string // 用户姓名（从查询缓存中获取）
+	userMobile  string // 用户手机号（从查询缓存中获取）
 }
 
 func NewPaymentLogic(ctx context.Context, svcCtx *svc.ServiceContext) *PaymentLogic {
@@ -111,6 +116,83 @@ func (l *PaymentLogic) Payment(req *types.PaymentReq) (resp *types.PaymentResp,
 			}
 		} else if req.PayMethod == "appleiap" {
 			prepayData = l.svcCtx.ApplePayService.GetIappayAppID(paymentTypeResp.outTradeNo)
+		} else if req.PayMethod == "yunyinSignPay" || req.PayMethod == "yunyinSignPay_wechat" || req.PayMethod == "yunyinSignPay_alipay" {
+			if l.svcCtx.YunYinSignPayService == nil {
+				return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "云印签支付服务未启用")
+			}
+
+			// 从查询缓存中获取用户姓名和手机号
+			if paymentTypeResp.userMobile == "" {
+				return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 查询缓存中未找到用户手机号，无法使用云印签支付")
+			}
+
+			// 获取用户ID
+			userID, getUidErr := ctxdata.GetUidFromCtx(l.ctx)
+			if getUidErr != nil {
+				return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取用户ID失败: %+v", getUidErr)
+			}
+
+			// 根据支付方式确定支付类型
+			payType := 0 // 默认微信支付
+			if req.PayMethod == "yunyinSignPay_alipay" {
+				payType = 1 // 支付宝支付
+			}
+
+			// 查询用户是否有未完成的签署（待签署且待支付）
+			var yunYinSignPayResult *service.CreateYunYinSignPayOrderResult
+			unfinishedOrder, findUnfinishedErr := l.svcCtx.YunyinSignPayOrderModel.FindUnfinishedByUserId(l.ctx, userID)
+			if findUnfinishedErr == nil && unfinishedOrder != nil {
+				// 复用未完成的签署，只获取新的支付链接
+				logx.Infof("复用未完成的云印签签署，任务ID: %s, 参与者ID: %s", unfinishedOrder.TaskId, unfinishedOrder.ParticipantId)
+
+				// 获取token和操作ID（带缓存）
+				accessToken, tokenErr := l.svcCtx.YunYinSignPayService.GetAccessToken(l.ctx)
+				if tokenErr != nil {
+					return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取云印签token失败: %+v", tokenErr)
+				}
+
+				operationUserId, userIdErr := l.svcCtx.YunYinSignPayService.GetUserId(l.ctx, accessToken)
+				if userIdErr != nil {
+					return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取云印签操作ID失败: %+v", userIdErr)
+				}
+
+				// 获取新的支付链接
+				payURL, payURLErr := l.svcCtx.YunYinSignPayService.GetPaymentURL(l.ctx, accessToken, operationUserId, unfinishedOrder.ParticipantId, payType)
+				if payURLErr != nil {
+					return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 获取云印签支付链接失败: %+v", payURLErr)
+				}
+
+				yunYinSignPayResult = &service.CreateYunYinSignPayOrderResult{
+					PayURL:        payURL,
+					ParticipantID: unfinishedOrder.ParticipantId,
+					TaskID:        unfinishedOrder.TaskId,
+				}
+			} else {
+				// 没有未完成的签署，创建新的签署流程
+				var createOrderErr error
+				yunYinSignPayResult, createOrderErr = l.svcCtx.YunYinSignPayService.CreateYunYinSignPayOrder(
+					l.ctx,
+					paymentTypeResp.userMobile,
+					paymentTypeResp.userName,
+					paymentTypeResp.amount,
+					paymentTypeResp.outTradeNo,
+					payType,
+				)
+				if createOrderErr != nil {
+					return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 创建云印签支付订单失败: %+v", createOrderErr)
+				}
+			}
+
+			prepayData = yunYinSignPayResult.PayURL
+
+			// 将云印签信息存储到context中，后续创建订单和云印签订单记录时使用
+			ctx = context.WithValue(ctx, "yunyin_sign_pay_result", yunYinSignPayResult)
+			ctx = context.WithValue(ctx, "yunyin_sign_pay_user_id", userID)
+			ctx = context.WithValue(ctx, "yunyin_sign_pay_user_mobile", paymentTypeResp.userMobile)
+			ctx = context.WithValue(ctx, "yunyin_sign_pay_user_name", paymentTypeResp.userName)
+			ctx = context.WithValue(ctx, "yunyin_sign_pay_amount", paymentTypeResp.amount)
+			ctx = context.WithValue(ctx, "yunyin_sign_pay_pay_type", payType)
+			l.ctx = ctx
 		}
 		if createOrderErr != nil {
 			return errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 创建支付订单失败: %+v", createOrderErr)
@@ -204,6 +286,27 @@ func (l *PaymentLogic) QueryOrderPayment(req *types.PaymentReq, session sqlx.Ses
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 解析缓存内容失败, %v", err)
 	}
 
+	// 解析查询参数，获取用户姓名和手机号（用于云印签支付）
+	var userName, userMobile string
+	if data.Params != "" {
+		secretKey := l.svcCtx.Config.Encrypt.SecretKey
+		key, decodeErr := hex.DecodeString(secretKey)
+		if decodeErr == nil {
+			decryptedData, decryptErr := crypto.AesDecrypt(data.Params, key)
+			if decryptErr == nil {
+				var params map[string]interface{}
+				if unmarshalErr := json.Unmarshal(decryptedData, &params); unmarshalErr == nil {
+					if name, ok := params["name"].(string); ok {
+						userName = name
+					}
+					if mobile, ok := params["mobile"].(string); ok {
+						userMobile = mobile
+					}
+				}
+			}
+		}
+	}
+
 	product, err := l.svcCtx.ProductModel.FindOneByProductEn(l.ctx, data.Product)
 	if err != nil {
 		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SERVER_COMMON_ERROR), "生成订单, 查找产品错误: %v", err)
@@ -252,6 +355,40 @@ func (l *PaymentLogic) QueryOrderPayment(req *types.PaymentReq, session sqlx.Ses
 	}
 	orderID := order.Id
 
+	// 如果是云印签支付，创建云印签订单记录
+	if req.PayMethod == "yunyinSignPay" || req.PayMethod == "yunyinSignPay_wechat" || req.PayMethod == "yunyinSignPay_alipay" {
+		yunYinSignPayResult, ok := l.ctx.Value("yunyin_sign_pay_result").(*service.CreateYunYinSignPayOrderResult)
+		if ok && yunYinSignPayResult != nil {
+			userID, _ := l.ctx.Value("yunyin_sign_pay_user_id").(string)
+			userMobile, _ := l.ctx.Value("yunyin_sign_pay_user_mobile").(string)
+			userName, _ := l.ctx.Value("yunyin_sign_pay_user_name").(string)
+			amount, _ := l.ctx.Value("yunyin_sign_pay_amount").(float64)
+			payType, _ := l.ctx.Value("yunyin_sign_pay_pay_type").(int)
+
+			yunyinSignPayOrder := model.YunyinSignPayOrder{
+				Id:              uuid.NewString(),
+				OrderId:         orderID,
+				UserId:          userID,
+				TaskId:          yunYinSignPayResult.TaskID,
+				ParticipantId:   yunYinSignPayResult.ParticipantID,
+				Amount:          amount,
+				PayType:         int64(payType),
+				SignStatus:      0, // 待签署
+				PayStatus:       0, // 待支付
+				SourceOrderCode: outTradeNo,
+				UserMobile:      sql.NullString{String: userMobile, Valid: userMobile != ""},
+				UserName:        sql.NullString{String: userName, Valid: userName != ""},
+				DelState:        0,
+				Version:         0,
+			}
+
+			_, insertYunYinErr := l.svcCtx.YunyinSignPayOrderModel.InsertWithSession(l.ctx, session, &yunyinSignPayOrder)
+			if insertYunYinErr != nil {
+				return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 保存云印签订单失败: %+v", insertYunYinErr)
+			}
+		}
+	}
+
 	// 如果是代理推广订单，创建完整的代理订单记录
 	if data.AgentIdentifier != "" && agentLinkModel != nil {
 		// 获取产品配置（必须存在）
@@ -302,5 +439,12 @@ func (l *PaymentLogic) QueryOrderPayment(req *types.PaymentReq, session sqlx.Ses
 			return nil, errors.Wrapf(xerr.NewErrCode(xerr.DB_ERROR), "生成订单, 保存代理订单失败: %+v", agentOrderInsert)
 		}
 	}
-	return &PaymentTypeResp{amount: amount, outTradeNo: outTradeNo, description: product.ProductName, orderID: orderID}, nil
+	return &PaymentTypeResp{
+		amount:      amount,
+		outTradeNo:  outTradeNo,
+		description: product.ProductName,
+		orderID:     orderID,
+		userName:    userName,
+		userMobile:  userMobile,
+	}, nil
 }

app/main/api/internal/service/yunyinSignPayService.go

@@ -0,0 +1,685 @@
+package service
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"jnc-server/app/main/api/internal/config"
+	"net/http"
+	"time"
+
+	"github.com/zeromicro/go-zero/core/logx"
+	"github.com/zeromicro/go-zero/core/stores/redis"
+)
+
+const (
+	// Redis key 前缀
+	YunYinSignPayTokenKey  = "yunyin_sign_pay:token"
+	YunYinSignPayUserIdKey = "yunyin_sign_pay:user_id"
+	TokenCacheExpire       = 2 * time.Hour // token 缓存2小时
+	UserIdCacheExpire      = 2 * time.Hour // 操作ID缓存2小时
+)
+
+// YunYinSignPayService 云印签支付服务
+type YunYinSignPayService struct {
+	config config.YunYinSignPayConfig
+	client *http.Client
+	redis  *redis.Redis
+}
+
+// NewYunYinSignPayService 创建云印签支付服务实例
+func NewYunYinSignPayService(c config.Config, redisClient *redis.Redis) *YunYinSignPayService {
+	return &YunYinSignPayService{
+		config: c.YunYinSignPay,
+		client: &http.Client{
+			Timeout: 30 * time.Second,
+		},
+		redis: redisClient,
+	}
+}
+
+// GetAccessTokenRequest 获取token请求
+type GetAccessTokenRequest struct {
+	AppID     string `json:"appId"`
+	AppSecret string `json:"appSecret"`
+}
+
+// GetAccessTokenResponse 获取token响应
+type GetAccessTokenResponse struct {
+	Code int              `json:"code"`
+	Msg  string           `json:"msg"`
+	Data *AccessTokenData `json:"data,omitempty"`
+}
+
+// AccessTokenData token数据
+type AccessTokenData struct {
+	AccessToken string `json:"accessToken"`
+	ExpireTime  int64  `json:"expireTime,omitempty"`
+}
+
+// GetAccessToken 获取访问token（带缓存）
+func (y *YunYinSignPayService) GetAccessToken(ctx context.Context) (string, error) {
+	// 先从Redis获取
+	token, err := y.redis.GetCtx(ctx, YunYinSignPayTokenKey)
+	if err == nil && token != "" {
+		logx.Infof("从Redis获取云印签token成功")
+		return token, nil
+	}
+
+	// Redis中没有，调用API获取
+	logx.Infof("从API获取云印签token")
+	reqBody := GetAccessTokenRequest{
+		AppID:     y.config.AppID,
+		AppSecret: y.config.AppSecret,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return "", fmt.Errorf("序列化请求参数失败: %v", err)
+	}
+
+	url := fmt.Sprintf("%s/service/getAccessToken", y.config.ApiURL)
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonData))
+	if err != nil {
+		return "", fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := y.client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("请求失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("读取响应失败: %v", err)
+	}
+
+	var tokenResp GetAccessTokenResponse
+	if err := json.Unmarshal(body, &tokenResp); err != nil {
+		return "", fmt.Errorf("解析响应失败: %v, 响应内容: %s", err, string(body))
+	}
+
+	if tokenResp.Code != 0 {
+		return "", fmt.Errorf("获取token失败: %s", tokenResp.Msg)
+	}
+
+	if tokenResp.Data == nil || tokenResp.Data.AccessToken == "" {
+		return "", fmt.Errorf("token数据为空")
+	}
+
+	accessToken := tokenResp.Data.AccessToken
+
+	// 存储到Redis，2小时过期
+	err = y.redis.SetexCtx(ctx, YunYinSignPayTokenKey, accessToken, int(TokenCacheExpire.Seconds()))
+	if err != nil {
+		logx.Errorf("存储token到Redis失败: %v", err)
+		// 不返回错误，因为token已经获取成功
+	}
+
+	logx.Infof("获取云印签token成功，已缓存到Redis")
+	return accessToken, nil
+}
+
+// GetUserIdRequest 获取操作ID请求
+type GetUserIdRequest struct {
+	Mobile string `json:"mobile"`
+}
+
+// GetUserIdResponse 获取操作ID响应
+type GetUserIdResponse struct {
+	Code int         `json:"code"`
+	Msg  string      `json:"msg"`
+	Data *UserIdData `json:"data,omitempty"`
+}
+
+// UserIdData 操作ID数据
+type UserIdData struct {
+	UserId string `json:"userId"`
+}
+
+// GetUserId 获取操作ID（带缓存）
+func (y *YunYinSignPayService) GetUserId(ctx context.Context, accessToken string) (string, error) {
+	// 先从Redis获取
+	userId, err := y.redis.GetCtx(ctx, YunYinSignPayUserIdKey)
+	if err == nil && userId != "" {
+		logx.Infof("从Redis获取云印签操作ID成功")
+		return userId, nil
+	}
+
+	// Redis中没有，调用API获取
+	logx.Infof("从API获取云印签操作ID")
+	reqBody := GetUserIdRequest{
+		Mobile: y.config.Mobile,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return "", fmt.Errorf("序列化请求参数失败: %v", err)
+	}
+
+	url := fmt.Sprintf("%s/member/infoByCorpId", y.config.ApiURL)
+	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonData))
+	if err != nil {
+		return "", fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("appId", y.config.AppID)
+	req.Header.Set("accessToken", accessToken)
+
+	resp, err := y.client.Do(req)
+	if err != nil {
+		return "", fmt.Errorf("请求失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("读取响应失败: %v", err)
+	}
+
+	var userIdResp GetUserIdResponse
+	if err := json.Unmarshal(body, &userIdResp); err != nil {
+		return "", fmt.Errorf("解析响应失败: %v, 响应内容: %s", err, string(body))
+	}
+
+	if userIdResp.Code != 0 {
+		return "", fmt.Errorf("获取操作ID失败: %s", userIdResp.Msg)
+	}
+
+	if userIdResp.Data == nil || userIdResp.Data.UserId == "" {
+		return "", fmt.Errorf("操作ID数据为空")
+	}
+
+	// 获取操作ID
+	operationUserId := userIdResp.Data.UserId
+
+	// 存储到Redis，2小时过期
+	err = y.redis.SetexCtx(ctx, YunYinSignPayUserIdKey, operationUserId, int(UserIdCacheExpire.Seconds()))
+	if err != nil {
+		logx.Errorf("存储操作ID到Redis失败: %v", err)
+		// 不返回错误，因为操作ID已经获取成功
+	}
+
+	logx.Infof("获取云印签操作ID成功，已缓存到Redis")
+	return operationUserId, nil
+}
+
+// ParticipantInfo 参与者信息
+type ParticipantInfo struct {
+	ParticipantFlag     string     `json:"participantFlag"`
+	PsnAccount          string     `json:"psnAccount"`
+	PsnName             string     `json:"psnName"`
+	ParticipantCorpName string     `json:"participantCorpName,omitempty"`
+	ParticipantType     int        `json:"participantType"`
+	PayeeContractFlag   int        `json:"payeeContractFlag,omitempty"`
+	Payee               *PayeeInfo `json:"payee,omitempty"`
+}
+
+// PayeeInfo 收款方信息
+type PayeeInfo struct {
+	Amount   float64 `json:"amount"`
+	Priority string  `json:"priority"`
+}
+
+// FillComponent 填充组件
+type FillComponent struct {
+	ComponentKey   string `json:"componentKey"`
+	ComponentValue string `json:"componentValue"`
+}
+
+// StartSignFlowRequest 发起签署请求
+type StartSignFlowRequest struct {
+	TemplateCode    string            `json:"templateCode"`
+	TemplateName    string            `json:"templateName"`
+	AutoFill        int               `json:"autoFill"`
+	SourceOrderCode string            `json:"sourceOrderCode"`
+	ParticipantList []ParticipantInfo `json:"participantList"`
+	FillComponents  []FillComponent   `json:"fillComponents"`
+}
+
+// StartSignFlowResponse 发起签署响应
+type StartSignFlowResponse struct {
+	Code interface{}        `json:"code"` // 可能是 int 或 string
+	Msg  string             `json:"msg"`
+	Data *StartSignFlowData `json:"data,omitempty"`
+}
+
+// StartSignFlowData 发起签署数据（API响应）
+type StartSignFlowData struct {
+	FlowID          string            `json:"flowId,omitempty"`
+	FlowStatus      int               `json:"flowStatus,omitempty"`
+	FlowDesc        string            `json:"flowDesc,omitempty"`
+	FlowTitle       string            `json:"flowTitle,omitempty"`
+	NextStatus      int               `json:"nextStatus,omitempty"`
+	ResultStatus    interface{}       `json:"resultStatus,omitempty"`
+	ErrorMessage    interface{}       `json:"errorMessage,omitempty"`
+	SourceOrderCode string            `json:"sourceOrderCode,omitempty"`
+	ParticipantList []ParticipantItem `json:"participantList,omitempty"`
+}
+
+// StartSignFlowResult 发起签署流程返回结果
+type StartSignFlowResult struct {
+	ParticipantID string // 签署方2的参与者ID
+	TaskID        string // 流程ID（flowId）
+}
+
+// ParticipantItem 参与者项（响应中的）
+type ParticipantItem struct {
+	ParticipantID       string      `json:"participantId"`
+	ParticipantFlag     string      `json:"participantFlag"`
+	SignStatus          interface{} `json:"signStatus,omitempty"`
+	ParticipantCorpID   string      `json:"participantCorpId,omitempty"`
+	ParticipantCorpName string      `json:"participantCorpName,omitempty"`
+	ParticipantType     int         `json:"participantType"`
+	ParticipateBizType  []string    `json:"participateBizType,omitempty"`
+	PsnID               string      `json:"psnId,omitempty"`
+	PsnName             string      `json:"psnName,omitempty"`
+	PayeeContractFlag   interface{} `json:"payeeContractFlag,omitempty"`
+	Payee               interface{} `json:"payee,omitempty"`
+}
+
+// GetCodeInt 获取 code 的 int 值
+func (r *StartSignFlowResponse) GetCodeInt() int {
+	switch v := r.Code.(type) {
+	case int:
+		return v
+	case float64:
+		return int(v)
+	case string:
+		if v == "200" {
+			return 200
+		}
+		return 0
+	default:
+		return 0
+	}
+}
+
+// StartSignFlow 发起签署流程
+func (y *YunYinSignPayService) StartSignFlow(ctx context.Context, accessToken, userId string, req *StartSignFlowRequest) (*StartSignFlowResult, error) {
+	jsonData, err := json.Marshal(req)
+	if err != nil {
+		return nil, fmt.Errorf("序列化请求参数失败: %v", err)
+	}
+
+	url := fmt.Sprintf("%s/signTask/startSignFlow", y.config.ApiURL)
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonData))
+	if err != nil {
+		return nil, fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("appId", y.config.AppID)
+	httpReq.Header.Set("accessToken", accessToken)
+	httpReq.Header.Set("userId", userId)
+	httpReq.Header.Set("source", "pc")
+
+	resp, err := y.client.Do(httpReq)
+	if err != nil {
+		return nil, fmt.Errorf("请求失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("读取响应失败: %v", err)
+	}
+
+	var signFlowResp StartSignFlowResponse
+	if err := json.Unmarshal(body, &signFlowResp); err != nil {
+		return nil, fmt.Errorf("解析响应失败: %v, 响应内容: %s", err, string(body))
+	}
+
+	// 检查响应码（可能是字符串"200"或数字200）
+	codeInt := signFlowResp.GetCodeInt()
+	if codeInt != 200 {
+		return nil, fmt.Errorf("发起签署失败: %s", signFlowResp.Msg)
+	}
+
+	if signFlowResp.Data == nil {
+		return nil, fmt.Errorf("签署数据为空")
+	}
+
+	// 从 participantList 中找到签署方2的 participantId
+	var participantID2 string
+	for _, participant := range signFlowResp.Data.ParticipantList {
+		if participant.ParticipantFlag == "签署方2" {
+			participantID2 = participant.ParticipantID
+			break
+		}
+	}
+
+	if participantID2 == "" {
+		return nil, fmt.Errorf("未找到签署方2的参与者ID")
+	}
+
+	logx.Infof("发起云印签签署流程成功，订单号: %s, 流程ID: %s, 签署方2参与者ID: %s", req.SourceOrderCode, signFlowResp.Data.FlowID, participantID2)
+
+	// 返回结果，包含签署方2的参与者ID和流程ID
+	return &StartSignFlowResult{
+		ParticipantID: participantID2,
+		TaskID:        signFlowResp.Data.FlowID, // 使用 flowId 作为 taskId
+	}, nil
+}
+
+// GetPaymentURLRequest 获取支付链接请求
+type GetPaymentURLRequest struct {
+	ParticipantID string `json:"participantId"`
+	Type          int    `json:"type"` // 0=微信支付，1=支付宝支付
+}
+
+// GetPaymentURLResponse 获取支付链接响应
+type GetPaymentURLResponse struct {
+	Code int             `json:"code"`
+	Msg  string          `json:"msg"`
+	Data *PaymentURLData `json:"data,omitempty"`
+}
+
+// PaymentURLData 支付链接数据
+type PaymentURLData struct {
+	PayURL string `json:"payUrl,omitempty"`
+	URL    string `json:"url,omitempty"`
+}
+
+// GetPaymentURL 获取支付链接
+func (y *YunYinSignPayService) GetPaymentURL(ctx context.Context, accessToken, userId string, participantID string, payType int) (string, error) {
+	reqBody := GetPaymentURLRequest{
+		ParticipantID: participantID,
+		Type:          payType,
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return "", fmt.Errorf("序列化请求参数失败: %v", err)
+	}
+
+	url := fmt.Sprintf("%s/signTask/contract/appletForParticipant", y.config.ApiURL)
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonData))
+	if err != nil {
+		return "", fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("appId", y.config.AppID)
+	httpReq.Header.Set("accessToken", accessToken)
+	httpReq.Header.Set("userId", userId)
+	httpReq.Header.Set("source", "pc")
+
+	resp, err := y.client.Do(httpReq)
+	if err != nil {
+		return "", fmt.Errorf("请求失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return "", fmt.Errorf("读取响应失败: %v", err)
+	}
+
+	var paymentURLResp GetPaymentURLResponse
+	if err := json.Unmarshal(body, &paymentURLResp); err != nil {
+		return "", fmt.Errorf("解析响应失败: %v, 响应内容: %s", err, string(body))
+	}
+
+	if paymentURLResp.Code != 0 {
+		return "", fmt.Errorf("获取支付链接失败: %s", paymentURLResp.Msg)
+	}
+
+	if paymentURLResp.Data == nil {
+		return "", fmt.Errorf("支付链接数据为空")
+	}
+
+	// 优先返回 PayURL，如果没有则返回 URL
+	payURL := paymentURLResp.Data.PayURL
+	if payURL == "" {
+		payURL = paymentURLResp.Data.URL
+	}
+
+	if payURL == "" {
+		return "", fmt.Errorf("支付链接为空")
+	}
+
+	logx.Infof("获取云印签支付链接成功，参与者ID: %s", participantID)
+	return payURL, nil
+}
+
+// CreateYunYinSignPayOrderResult 创建云印签支付订单结果
+type CreateYunYinSignPayOrderResult struct {
+	PayURL        string // 支付链接
+	ParticipantID string // 参与者ID
+	TaskID        string // 任务ID
+}
+
+// CreateYunYinSignPayOrder 创建云印签支付订单（封装完整流程）
+func (y *YunYinSignPayService) CreateYunYinSignPayOrder(ctx context.Context, userMobile, userName string, amount float64, outTradeNo string, payType int) (*CreateYunYinSignPayOrderResult, error) {
+	// 1. 获取token和操作ID（带缓存）
+	accessToken, err := y.GetAccessToken(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("获取云印签token失败: %v", err)
+	}
+
+	operationUserId, err := y.GetUserId(ctx, accessToken)
+	if err != nil {
+		return nil, fmt.Errorf("获取云印签操作ID失败: %v", err)
+	}
+
+	// 2. 构建参与者列表
+	participantList := []ParticipantInfo{
+		// 签署方1：我方
+		{
+			ParticipantFlag:     "签署方1",
+			PsnAccount:          y.config.Mobile,
+			PsnName:             y.config.Name,
+			ParticipantCorpName: y.config.CorpName,
+			ParticipantType:     1, // 1表示企业
+		},
+		// 签署方2：用户（支付方）
+		{
+			ParticipantFlag: "签署方2",
+			PsnAccount:      userMobile,
+			PsnName: func() string {
+				if userName != "" {
+					return userName
+				}
+				return "用户"
+			}(),
+			ParticipantType:   0, // 0表示个人
+			PayeeContractFlag: 1,
+			Payee: &PayeeInfo{
+				Amount:   amount,
+				Priority: "1",
+			},
+		},
+	}
+
+	// 3. 发起签署流程
+	startSignFlowReq := &StartSignFlowRequest{
+		TemplateCode:    y.config.TemplateCode,
+		TemplateName:    y.config.TemplateName,
+		AutoFill:        1,
+		SourceOrderCode: outTradeNo,
+		ParticipantList: participantList,
+		FillComponents:  []FillComponent{}, // 可以根据需要填充
+	}
+
+	signFlowData, err := y.StartSignFlow(ctx, accessToken, operationUserId, startSignFlowReq)
+	if err != nil {
+		return nil, fmt.Errorf("发起云印签签署失败: %v", err)
+	}
+
+	if signFlowData.ParticipantID == "" {
+		return nil, fmt.Errorf("签署流程返回的参与者ID为空")
+	}
+
+	// 4. 获取支付链接
+	payURL, err := y.GetPaymentURL(ctx, accessToken, operationUserId, signFlowData.ParticipantID, payType)
+	if err != nil {
+		return nil, fmt.Errorf("获取云印签支付链接失败: %v", err)
+	}
+
+	return &CreateYunYinSignPayOrderResult{
+		PayURL:        payURL,
+		ParticipantID: signFlowData.ParticipantID,
+		TaskID:        signFlowData.TaskID,
+	}, nil
+}
+
+// QueryPayeeBillRequest 查询收款单请求
+type QueryPayeeBillRequest struct {
+	SourceOrderCode string `json:"sourceOrderCode,omitempty"` // 来源订单号
+	PayOrderCode    string `json:"payOrderCode,omitempty"`    // 支付单号
+	ContractCode    string `json:"contractCode,omitempty"`    // 合同号
+	PayStatus       int    `json:"payStatus,omitempty"`       // 支付状态: 1-待支付, 2-支付成功, 3-退款成功
+	ChannelOrderNo  string `json:"channelOrderNo,omitempty"`  // 渠道单号
+	PayName         string `json:"payName,omitempty"`         // 付款方名称
+	ParticipantType int    `json:"participantType,omitempty"` // 付款方类型: 1-企业, 0-个人
+	PayeeName       string `json:"payeeName,omitempty"`       // 收款方名称
+	PayeeCorpName   string `json:"payeeCorpName,omitempty"`   // 收款方企业名称
+	FlowStartTime   string `json:"flowStartTime,omitempty"`   // 查询范围的开始时间
+	FlowFinishTime  string `json:"flowFinishTime,omitempty"`  // 查询范围的结束时间
+	ListPageNo      int    `json:"listPageNo,omitempty"`      // 当前页码，从1开始
+	ListPageSize    int    `json:"listPageSize,omitempty"`    // 每页返回的记录数量
+}
+
+// QueryPayeeBillResponse 查询收款单响应
+type QueryPayeeBillResponse struct {
+	Code          interface{}     `json:"code"`          // 返回码，可能是字符串"200"或数字200
+	Msg           string          `json:"msg"`           // 返回码的描述信息
+	TotalCount    int             `json:"totalCount"`    // 满足查询条件的总记录数
+	ListPageCount int             `json:"listPageCount"` // 总页数
+	Data          []PayeeBillItem `json:"data"`          // 收款单记录列表
+}
+
+// PayeeBillItem 收款单记录
+type PayeeBillItem struct {
+	ID                  int64   `json:"id"`                  // 消息ID
+	ContractName        string  `json:"contractName"`        // 合同名称
+	ContractCode        string  `json:"contractCode"`        // 合同号
+	FlowCode            string  `json:"flowCode"`            // 签署流程编码
+	PayOrderCode        string  `json:"payOrderCode"`        // 支付单号
+	Amount              float64 `json:"amount"`              // 支付金额
+	PayStatus           int     `json:"payStatus"`           // 支付状态: 0-订单生成, 1-支付中, 2-支付成功, 3-支付失败, 4-已退款
+	RefundAmount        float64 `json:"refundAmount"`        // 退款金额
+	ParticipateID       int64   `json:"participateId"`       // 付款参与方ID
+	PsnName             string  `json:"psnName"`             // 付款方经办人/个人名称
+	PsnAccount          string  `json:"psnAccount"`          // 付款方经办人手机
+	ParticipantType     int     `json:"participantType"`     // 付款方类型 (1-企业, 2-个人)
+	ParticipantCorpName string  `json:"participantCorpName"` // 付款方企业名称
+	ParticipateBizType  string  `json:"participateBizType"`  // 付款方参与方式
+	PayeeCorpName       string  `json:"payeeCorpName"`       // 收款方企业名称
+	CreateTime          string  `json:"createTime"`          // 订单创建时间
+	ChannelOrderNo      string  `json:"channelOrderNo"`      // 渠道单号 (如微信或支付宝的交易号)
+	ProviderCode        string  `json:"providerCode"`        // 支付方式编码
+	CallbackStatus      int     `json:"callbackStatus"`      // 异步回调通知状态
+}
+
+// QueryPayeeBillResult 查询收款单结果
+type QueryPayeeBillResult struct {
+	PayStatus      int     // 支付状态: 0-订单生成, 1-支付中, 2-支付成功, 3-支付失败, 4-已退款
+	PayOrderCode   string  // 支付单号
+	ChannelOrderNo string  // 渠道单号
+	Amount         float64 // 支付金额
+	RefundAmount   float64 // 退款金额
+}
+
+// GetCodeInt 获取 code 的 int 值
+func (r *QueryPayeeBillResponse) GetCodeInt() int {
+	switch v := r.Code.(type) {
+	case int:
+		return v
+	case float64:
+		return int(v)
+	case string:
+		if v == "200" {
+			return 200
+		}
+		return 0
+	default:
+		return 0
+	}
+}
+
+// QueryPayeeBill 查询收款单（根据sourceOrderCode查询）
+func (y *YunYinSignPayService) QueryPayeeBill(ctx context.Context, sourceOrderCode string) (*QueryPayeeBillResult, error) {
+	// 1. 获取token和操作ID（带缓存）
+	accessToken, err := y.GetAccessToken(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("获取云印签token失败: %v", err)
+	}
+
+	operationUserId, err := y.GetUserId(ctx, accessToken)
+	if err != nil {
+		return nil, fmt.Errorf("获取云印签操作ID失败: %v", err)
+	}
+
+	// 2. 构建查询请求
+	reqBody := QueryPayeeBillRequest{
+		SourceOrderCode: sourceOrderCode,
+		ListPageNo:      1,
+		ListPageSize:    10, // 只需要查询第一条匹配的记录
+	}
+
+	jsonData, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("序列化请求参数失败: %v", err)
+	}
+
+	// 3. 调用查询API
+	url := fmt.Sprintf("%s/signFlowBill/payeeBillList", y.config.ApiURL)
+	httpReq, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewReader(jsonData))
+	if err != nil {
+		return nil, fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("appId", y.config.AppID)
+	httpReq.Header.Set("accessToken", accessToken)
+	httpReq.Header.Set("userId", operationUserId)
+	httpReq.Header.Set("source", "pc")
+
+	resp, err := y.client.Do(httpReq)
+	if err != nil {
+		return nil, fmt.Errorf("请求失败: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("读取响应失败: %v", err)
+	}
+
+	var queryResp QueryPayeeBillResponse
+	if err := json.Unmarshal(body, &queryResp); err != nil {
+		return nil, fmt.Errorf("解析响应失败: %v, 响应内容: %s", err, string(body))
+	}
+
+	// 4. 检查响应码
+	codeInt := queryResp.GetCodeInt()
+	if codeInt != 200 {
+		return nil, fmt.Errorf("查询收款单失败: %s", queryResp.Msg)
+	}
+
+	// 5. 查找匹配的记录（根据sourceOrderCode）
+	if len(queryResp.Data) == 0 {
+		return nil, fmt.Errorf("未找到匹配的收款单记录")
+	}
+
+	// 取第一条记录（因为我们已经用sourceOrderCode精确查询）
+	billItem := queryResp.Data[0]
+
+	logx.Infof("查询云印签收款单成功，订单号: %s, 支付状态: %d", sourceOrderCode, billItem.PayStatus)
+
+	return &QueryPayeeBillResult{
+		PayStatus:      billItem.PayStatus,
+		PayOrderCode:   billItem.PayOrderCode,
+		ChannelOrderNo: billItem.ChannelOrderNo,
+		Amount:         billItem.Amount,
+		RefundAmount:   billItem.RefundAmount,
+	}, nil
+}

app/main/api/internal/svc/servicecontext.go

@@ -41,6 +41,7 @@ type ServiceContext struct {
 	QueryCleanupLogModel    model.QueryCleanupLogModel
 	QueryCleanupDetailModel model.QueryCleanupDetailModel
 	QueryCleanupConfigModel model.QueryCleanupConfigModel
+	YunyinSignPayOrderModel model.YunyinSignPayOrderModel
 
 	// 代理相关模型（新系统）
 	AgentModel              model.AgentModel
@@ -75,6 +76,7 @@ type ServiceContext struct {
 	WechatPayService     *service.WechatPayService
 	ApplePayService      *service.ApplePayService
 	EasyPayService       *service.EasyPayService
+	YunYinSignPayService *service.YunYinSignPayService
 	ApiRequestService    *service.ApiRequestService
 	AsynqServer          *asynq.Server
 	AsynqService         *service.AsynqService
@@ -116,6 +118,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
 	queryCleanupLogModel := model.NewQueryCleanupLogModel(db, cacheConf)
 	queryCleanupDetailModel := model.NewQueryCleanupDetailModel(db, cacheConf)
 	queryCleanupConfigModel := model.NewQueryCleanupConfigModel(db, cacheConf)
+	yunyinSignPayOrderModel := model.NewYunyinSignPayOrderModel(db, cacheConf)
 
 	// ============================== 代理相关模型（新系统） ==============================
 	agentModel := model.NewAgentModel(db, cacheConf)
@@ -191,6 +194,16 @@ func NewServiceContext(c config.Config) *ServiceContext {
 	} else {
 		logx.Info("易支付服务已禁用")
 	}
+
+	// 根据配置决定是否初始化云印签支付服务
+	var yunYinSignPayService *service.YunYinSignPayService
+	if c.YunYinSignPay.Enabled {
+		yunYinSignPayService = service.NewYunYinSignPayService(c, redisClient)
+		logx.Info("云印签支付服务已启用")
+	} else {
+		logx.Info("云印签支付服务已禁用")
+	}
+
 	apiRequestService := service.NewApiRequestService(c, featureModel, productFeatureModel, tianyuanapi)
 	verificationService := service.NewVerificationService(c, tianyuanapi, apiRequestService)
 	asynqService := service.NewAsynqService(c)
@@ -238,6 +251,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
 		QueryCleanupLogModel:    queryCleanupLogModel,
 		QueryCleanupDetailModel: queryCleanupDetailModel,
 		QueryCleanupConfigModel: queryCleanupConfigModel,
+		YunyinSignPayOrderModel: yunyinSignPayOrderModel,
 
 		// 代理相关模型（简化版 - 移除团队关系、返佣、升级、提现、实名认证、邀请码）
 		AgentModel:              agentModel,
@@ -272,6 +286,7 @@ func NewServiceContext(c config.Config) *ServiceContext {
 		WechatPayService:     wechatPayService,
 		ApplePayService:      applePayService,
 		EasyPayService:       easyPayService,
+		YunYinSignPayService: yunYinSignPayService,
 		ApiRequestService:    apiRequestService,
 		AsynqServer:          asynqServer,
 		AsynqService:         asynqService,

app/main/api/internal/types/pay.go

@@ -17,7 +17,7 @@ type PaymentCheckResp struct {
 
 type PaymentReq struct {
 	Id        string `json:"id"`
-	PayMethod string `json:"pay_method"` // 支付方式: wechat, alipay, appleiap, test(仅开发环境), test_empty(仅开发环境-空报告模式)
+	PayMethod string `json:"pay_method"` // 支付方式: wechat, alipay, easypay_alipay, appleiap, yunyinSignPay, yunyinSignPay_wechat, yunyinSignPay_alipay, test(仅开发环境), test_empty(仅开发环境-空报告模式)
 	PayType   string `json:"pay_type" validate:"required,oneof=query"`
 }