feat: 完善移动端会员业务流程

internal/store/accounts.go

@@ -62,7 +62,7 @@ func (s *Store) RegisterAccount(ctx context.Context, input AccountRegistration)
 		(tenant_id,member_no,username,mobile,password_hash,
 		 level_id,parent_id,level,tree,invite_code,member_status,risk_status,auto_dispatch,
 		 credit_score,is_test_account,created_by,updated_by)
-		VALUES(?,?,?,?,?,?,?,?,?,?,1,1,2,100,2,0,0)`,
+		VALUES(?,?,?,?,?,?,?,?,?,?,1,1,1,100,2,0,0)`,
 		input.TenantID, input.MemberNo, input.Username, input.Mobile, input.PasswordHash,
 		levelID, parentID, teamLevel, tree, input.InviteCode)
 	if err != nil {

internal/store/attachments.go

@@ -0,0 +1,34 @@
+package store
+
+import "context"
+
+type AttachmentCreation struct {
+	MemberID int64
+	Name     string
+	MimeType string
+	Path     string
+	URL      string
+	Size     int64
+	Ext      string
+	MD5      string
+}
+
+type Attachment struct {
+	ID  int64  `json:"id"`
+	URL string `json:"url"`
+}
+
+func (s *Store) CreateAttachment(ctx context.Context, input AttachmentCreation) (*Attachment, error) {
+	result, err := s.db.ExecContext(ctx, `INSERT INTO hg_sys_attachment
+		(app_id,member_id,cate_id,drive,name,kind,mime_type,naive_type,path,file_url,size,ext,md5,status,created_at,updated_at)
+		VALUES('olons_server',?,0,'local',?,'image',?,'image',?,?,?, ?,?,1,UTC_TIMESTAMP(),UTC_TIMESTAMP())`,
+		input.MemberID, input.Name, input.MimeType, input.Path, input.URL, input.Size, input.Ext, input.MD5)
+	if err != nil {
+		return nil, err
+	}
+	id, err := result.LastInsertId()
+	if err != nil {
+		return nil, err
+	}
+	return &Attachment{ID: id, URL: input.URL}, nil
+}

internal/store/mysql.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	"git.118im.com/im_team/im_workbench/internal/config"
+	"git.118im.com/im_team/olons_server/internal/config"
 	"github.com/jmoiron/sqlx"
 )
 

internal/store/portal.go

@@ -161,6 +161,49 @@ func (s *Store) ActiveMemberNotices(ctx context.Context, tenantID, memberID int6
 	return rows, err
 }
 
+func (s *Store) LatestPopupNotice(ctx context.Context, tenantID, memberID int64) (*MemberNotice, error) {
+	if s == nil || s.db == nil {
+		return nil, errors.New("store is unavailable")
+	}
+	var row MemberNotice
+	err := s.db.GetContext(ctx, &row, `SELECT id,title,content,source_type,
+		DATE_FORMAT(start_at,'%Y-%m-%dT%H:%i:%sZ') AS start_at,
+		DATE_FORMAT(end_at,'%Y-%m-%dT%H:%i:%sZ') AS end_at,
+		DATE_FORMAT(created_at,'%Y-%m-%dT%H:%i:%sZ') AS created_at
+		FROM hg_app_member_notice
+		WHERE tenant_id=? AND member_id IN (0,?) AND notice_status=1
+		AND start_at<=UTC_TIMESTAMP(3) AND end_at>UTC_TIMESTAMP(3)
+		ORDER BY start_at DESC,id DESC LIMIT 1`, tenantID, memberID)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, nil
+	}
+	return &row, err
+}
+
+func (s *Store) MarkMemberNoticeRead(ctx context.Context, tenantID, memberID, noticeID int64) error {
+	if s == nil || s.db == nil {
+		return errors.New("store is unavailable")
+	}
+	result, err := s.db.ExecContext(ctx, `INSERT INTO hg_app_member_notice_read
+		(tenant_id,notice_id,member_id,read_at,created_at)
+		SELECT n.tenant_id,n.id,?,UTC_TIMESTAMP(3),UTC_TIMESTAMP(3)
+		FROM hg_app_member_notice n
+		WHERE n.tenant_id=? AND n.id=? AND n.member_id IN (0,?) AND n.notice_status=1
+		AND n.start_at<=UTC_TIMESTAMP(3) AND n.end_at>UTC_TIMESTAMP(3)
+		ON DUPLICATE KEY UPDATE read_at=VALUES(read_at)`, memberID, tenantID, noticeID, memberID)
+	if err != nil {
+		return err
+	}
+	affected, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+	if affected == 0 {
+		return ErrResourceNotFound
+	}
+	return nil
+}
+
 func (s *Store) MemberNotices(ctx context.Context, tenantID, memberID int64, offset, limit int) (*MemberNoticePage, error) {
 	if s == nil || s.db == nil {
 		return nil, errors.New("store is unavailable")

internal/store/profile.go

@@ -92,7 +92,7 @@ func (s *Store) UpdateAvatar(ctx context.Context, tenantID, memberID, attachment
 
 	var avatar Avatar
 	err = tx.GetContext(ctx, &avatar, `SELECT id AS attachment_id,COALESCE(file_url,'') AS url FROM hg_sys_attachment
-		WHERE id=? AND app_id='workbench' AND member_id=? AND status=1
+		WHERE id=? AND app_id='olons_server' AND member_id=? AND status=1
 		AND mime_type LIKE 'image/%' LIMIT 1 FOR UPDATE`, attachmentID, memberID)
 	if errors.Is(err, sql.ErrNoRows) {
 		return nil, ErrAttachmentInvalid

internal/store/recharges.go

@@ -56,6 +56,8 @@ type RechargePage struct {
 	Total int64
 }
 
+const rechargeStatusReview = 2
+
 func (s *Store) RechargeChannels(ctx context.Context, tenantID int64) ([]RechargeChannel, error) {
 	items := make([]RechargeChannel, 0)
 	err := s.db.SelectContext(ctx, &items, `SELECT id,channel_code,name,channel_type,min_amount,max_amount,
@@ -95,7 +97,7 @@ func (s *Store) CreateRecharge(ctx context.Context, input RechargeCreation) (*Re
 	for _, attachmentID := range input.VoucherAttachmentIDs {
 		var count int
 		if err = tx.GetContext(ctx, &count, `SELECT COUNT(*) FROM hg_sys_attachment WHERE tenant_id=? AND id=?
-			AND app_id='workbench' AND member_id=? AND status=1`, input.TenantID, attachmentID, input.MemberID); err != nil {
+			AND app_id='olons_server' AND member_id=? AND status=1`, input.TenantID, attachmentID, input.MemberID); err != nil {
 			return nil, err
 		}
 		if count != 1 {
@@ -109,8 +111,8 @@ func (s *Store) CreateRecharge(ctx context.Context, input RechargeCreation) (*Re
 	result, err := tx.ExecContext(ctx, `INSERT INTO hg_recharge_order
 		(tenant_id,recharge_no,member_id,channel_id,request_amount,paid_amount,currency,
 		 voucher_attachment_ids,recharge_type,recharge_status,remark,created_by,updated_by)
-		VALUES(?,?,?,?,?,0,?,?,1,1,?,?,?)`, input.TenantID, input.RechargeNo, input.MemberID,
-		input.ChannelID, input.RequestAmount, input.Currency, vouchers, input.Remark, input.MemberID, input.MemberID)
+		VALUES(?,?,?,?,?,0,?,?,1,?,?,?,?)`, input.TenantID, input.RechargeNo, input.MemberID,
+		input.ChannelID, input.RequestAmount, input.Currency, vouchers, rechargeStatusReview, input.Remark, input.MemberID, input.MemberID)
 	if err != nil {
 		return nil, err
 	}
@@ -123,7 +125,7 @@ func (s *Store) CreateRecharge(ctx context.Context, input RechargeCreation) (*Re
 	}
 	return &RechargeOrder{ID: id, RechargeNo: input.RechargeNo, ChannelID: channel.ID,
 		ChannelName: channel.Name, RequestAmount: input.RequestAmount, Currency: input.Currency,
-		VoucherAttachmentIDs: vouchers, Status: 1, Remark: input.Remark}, nil
+		VoucherAttachmentIDs: vouchers, Status: rechargeStatusReview, Remark: input.Remark}, nil
 }
 
 func (s *Store) RechargeOrders(ctx context.Context, tenantID, memberID int64, status, offset, limit int) (*RechargePage, error) {

internal/store/tasks.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"encoding/json"
 	"errors"
+	"fmt"
 	"time"
 
 	"github.com/jmoiron/sqlx"
@@ -104,12 +105,15 @@ type TaskStats struct {
 }
 
 type TaskSubmissionInput struct {
-	TenantID      int64
-	MemberID      int64
-	OrderID       int64
-	SubmissionNo  string
-	EvidenceText  string
-	AttachmentIDs []int64
+	TenantID       int64
+	MemberID       int64
+	OrderID        int64
+	SubmissionNo   string
+	EvidenceText   string
+	AttachmentIDs  []int64
+	LedgerNo       string
+	IdempotencyKey string
+	SettledAt      time.Time
 }
 
 type TaskSubmissionResult struct {
@@ -159,9 +163,10 @@ func (s *Store) ClaimTask(ctx context.Context, input ClaimTaskInput) (*TaskOrder
 	defer tx.Rollback()
 
 	var member struct {
-		LevelID int64 `db:"level_id"`
+		LevelID      int64 `db:"level_id"`
+		AutoDispatch int   `db:"auto_dispatch"`
 	}
-	err = tx.GetContext(ctx, &member, `SELECT level_id FROM hg_app_member
+	err = tx.GetContext(ctx, &member, `SELECT level_id,auto_dispatch FROM hg_app_member
 		WHERE tenant_id=? AND id=? AND member_status=1 AND deleted_at IS NULL LIMIT 1 FOR UPDATE`, input.TenantID, input.MemberID)
 	if errors.Is(err, sql.ErrNoRows) {
 		return nil, ErrAccountNotFound
@@ -227,34 +232,16 @@ func (s *Store) ClaimTask(ctx context.Context, input ClaimTaskInput) (*TaskOrder
 			return nil, ErrDailyLimitReached
 		}
 	}
-	var task struct {
-		ID               int64  `db:"id"`
-		Title            string `db:"title"`
-		CoverURL         string `db:"cover_url"`
-		CommissionAmount int64  `db:"commission_amount"`
-		CommissionRate   int    `db:"commission_rate"`
-		PerMemberLimit   int    `db:"per_member_limit"`
-	}
-	err = tx.GetContext(ctx, &task, `SELECT t.id,t.title,t.cover_url,t.commission_amount,t.commission_rate,t.per_member_limit
-		FROM hg_task t JOIN hg_task_level tl ON tl.tenant_id=t.tenant_id AND tl.task_id=t.id AND tl.level_id=?
-		WHERE t.tenant_id=? AND t.hall_id=? AND t.publish_status=3 AND t.deleted_at IS NULL
-		AND (t.start_at IS NULL OR t.start_at<=UTC_TIMESTAMP(3)) AND (t.end_at IS NULL OR t.end_at>UTC_TIMESTAMP(3))
-		AND (t.daily_limit=0 OR (SELECT COUNT(*) FROM hg_trade_order od WHERE od.tenant_id=t.tenant_id AND od.task_id=t.id
-			AND od.order_type=2 AND od.created_at>=UTC_DATE() AND od.created_at<UTC_DATE()+INTERVAL 1 DAY)<t.daily_limit)
-		AND (t.per_member_limit=0 OR (SELECT COUNT(*) FROM hg_trade_order om WHERE om.tenant_id=t.tenant_id
-			AND om.task_id=t.id AND om.member_id=? AND om.order_type=2 AND om.created_at>=UTC_DATE() AND om.created_at<UTC_DATE()+INTERVAL 1 DAY)<t.per_member_limit)
-		ORDER BY t.sort,t.id LIMIT 1 FOR UPDATE`, member.LevelID, input.TenantID, input.HallID, input.MemberID)
-	if errors.Is(err, sql.ErrNoRows) {
-		return nil, ErrNoTaskAvailable
-	}
-	if err != nil {
-		return nil, err
+	dispatchMode, message := "manual", "等待后台匹配订单"
+	if member.AutoDispatch == 1 {
+		dispatchMode, message = "auto", "正在自动匹配订单"
 	}
 	rules, err := json.Marshal(map[string]any{
-		"commission_amount": task.CommissionAmount,
-		"commission_rate":   task.CommissionRate,
-		"deadline_at":       input.DeadlineAt.UTC().Format(time.RFC3339),
-		"member_level_id":   member.LevelID,
+		"source":          "member_auto_claim",
+		"dispatch_mode":   dispatchMode,
+		"hall_id":         input.HallID,
+		"deadline_at":     input.DeadlineAt.UTC().Format(time.RFC3339),
+		"member_level_id": member.LevelID,
 	})
 	if err != nil {
 		return nil, err
@@ -262,10 +249,9 @@ func (s *Store) ClaimTask(ctx context.Context, input ClaimTaskInput) (*TaskOrder
 	result, err := tx.ExecContext(ctx, `INSERT INTO hg_trade_order
 		(tenant_id,order_no,member_id,task_id,product_id,product_name,order_type,quantity,
 		 unit_price_amount,total_amount,commission_amount,currency,member_level_id,rule_snapshot,
-		 message,order_status,freeze_status,matched_at,created_by,updated_by)
-		VALUES(?,?,?,?,0,?,2,1,0,0,?,'CNY',?,?,?,2,1,UTC_TIMESTAMP(3),0,0)`,
-		input.TenantID, input.OrderNo, input.MemberID, task.ID, task.Title, task.CommissionAmount,
-		member.LevelID, rules, "任务匹配成功，请在截止时间前完成")
+		 message,order_status,freeze_status,created_by,updated_by)
+		VALUES(?,?,?,0,0,'',2,0,0,0,0,'CNY',?,?,?,1,1,0,0)`,
+		input.TenantID, input.OrderNo, input.MemberID, member.LevelID, rules, message)
 	if err != nil {
 		if isDuplicate(err) {
 			return nil, ErrPendingOrderExists
@@ -279,11 +265,148 @@ func (s *Store) ClaimTask(ctx context.Context, input ClaimTaskInput) (*TaskOrder
 	if err := tx.Commit(); err != nil {
 		return nil, err
 	}
-	return &TaskOrder{ID: orderID, OrderNo: input.OrderNo, TaskID: task.ID, ProductName: task.Title,
-		CoverURL: task.CoverURL, Quantity: 1, CommissionAmount: task.CommissionAmount, Currency: "CNY",
-		MemberLevelID: member.LevelID, RuleSnapshot: rules, Message: "任务匹配成功，请在截止时间前完成",
-		OrderStatus: orderStatusPending, FreezeStatus: 1, DeadlineAt: input.DeadlineAt.UTC().Format(time.RFC3339),
-		MatchedAt: time.Now().UTC().Format(time.RFC3339), CreatedAt: time.Now().UTC().Format(time.RFC3339)}, nil
+	return &TaskOrder{ID: orderID, OrderNo: input.OrderNo, Currency: "CNY",
+		MemberLevelID: member.LevelID, RuleSnapshot: rules, Message: message,
+		OrderStatus: orderStatusMatching, FreezeStatus: 1, DeadlineAt: input.DeadlineAt.UTC().Format(time.RFC3339),
+		CreatedAt: time.Now().UTC().Format(time.RFC3339)}, nil
+}
+
+func (s *Store) AutoMatchTaskOrder(ctx context.Context, tenantID, memberID, orderID int64, delaySeconds int, minAmount, maxAmount int64) error {
+	tx, err := s.db.BeginTxx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	var order struct {
+		OrderNo       string          `db:"order_no"`
+		Status        int             `db:"order_status"`
+		MemberLevelID int64           `db:"member_level_id"`
+		RuleSnapshot  json.RawMessage `db:"rule_snapshot"`
+		AutoDispatch  int             `db:"auto_dispatch"`
+		CreatedAt     time.Time       `db:"created_at"`
+	}
+	err = tx.GetContext(ctx, &order, `SELECT o.order_no,o.order_status,o.member_level_id,o.rule_snapshot,o.created_at,m.auto_dispatch
+		FROM hg_trade_order o JOIN hg_app_member m ON m.tenant_id=o.tenant_id AND m.id=o.member_id
+		WHERE o.tenant_id=? AND o.member_id=? AND o.id=? AND o.order_type=2 LIMIT 1 FOR UPDATE`, tenantID, memberID, orderID)
+	if errors.Is(err, sql.ErrNoRows) {
+		return ErrOrderNotFound
+	}
+	if err != nil {
+		return err
+	}
+	if order.Status != orderStatusMatching {
+		return tx.Commit()
+	}
+	if order.AutoDispatch != 1 || delaySeconds > 0 && time.Now().UTC().Before(order.CreatedAt.UTC().Add(time.Duration(delaySeconds)*time.Second)) {
+		return tx.Commit()
+	}
+
+	var account struct {
+		ID              int64 `db:"id"`
+		AvailableAmount int64 `db:"available_amount"`
+		FrozenAmount    int64 `db:"frozen_amount"`
+		Version         int   `db:"version"`
+	}
+	err = tx.GetContext(ctx, &account, `SELECT id,available_amount,frozen_amount,version FROM hg_wallet_account
+		WHERE tenant_id=? AND member_id=? AND currency='CNY' AND account_status=1 LIMIT 1 FOR UPDATE`, tenantID, memberID)
+	if errors.Is(err, sql.ErrNoRows) {
+		return ErrAccountRestricted
+	}
+	if err != nil {
+		return err
+	}
+	lowerAmount := max(int64(1), minAmount)
+	upperAmount := account.AvailableAmount
+	if maxAmount > 0 && maxAmount < upperAmount {
+		upperAmount = maxAmount
+	}
+	if lowerAmount > upperAmount {
+		return ErrNoTaskAvailable
+	}
+	var product struct {
+		ID          int64  `db:"id"`
+		ProductNo   string `db:"product_no"`
+		Name        string `db:"name"`
+		PriceAmount int64  `db:"price_amount"`
+		Currency    string `db:"currency"`
+	}
+	err = tx.GetContext(ctx, &product, `SELECT id,product_no,name,price_amount,currency FROM hg_product
+		WHERE tenant_id=? AND publish_status=3 AND deleted_at IS NULL AND currency='CNY' AND price_amount>=? AND price_amount<=?
+		AND (start_at IS NULL OR start_at<=UTC_TIMESTAMP(3)) AND (end_at IS NULL OR end_at>UTC_TIMESTAMP(3))
+		ORDER BY RAND() LIMIT 1 FOR UPDATE`, tenantID, lowerAmount, upperAmount)
+	if errors.Is(err, sql.ErrNoRows) {
+		return ErrNoTaskAvailable
+	}
+	if err != nil {
+		return err
+	}
+
+	var levelRule struct {
+		VersionID      int64 `db:"version_id"`
+		CommissionRate int   `db:"commission_rate"`
+	}
+	err = tx.GetContext(ctx, &levelRule, `SELECT v.id AS version_id,v.commission_rate
+		FROM hg_app_member_level l JOIN hg_app_member_level_version v
+		ON v.tenant_id=l.tenant_id AND v.id=l.current_version_id AND v.publish_status=3
+		WHERE l.tenant_id=? AND l.id=? AND l.status=1 AND l.deleted_at IS NULL LIMIT 1`, tenantID, order.MemberLevelID)
+	if errors.Is(err, sql.ErrNoRows) {
+		return ErrLevelNotEligible
+	}
+	if err != nil {
+		return err
+	}
+
+	snapshot := map[string]any{}
+	if len(order.RuleSnapshot) > 0 {
+		_ = json.Unmarshal(order.RuleSnapshot, &snapshot)
+	}
+	snapshot["match_source"] = "system_auto_match"
+	snapshot["product_id"] = product.ID
+	snapshot["product_no"] = product.ProductNo
+	snapshot["unit_price_amount"] = product.PriceAmount
+	snapshot["quantity"] = 1
+	snapshot["level_version_id"] = levelRule.VersionID
+	snapshot["commission_rate"] = levelRule.CommissionRate
+	rules, err := json.Marshal(snapshot)
+	if err != nil {
+		return err
+	}
+	commissionAmount := product.PriceAmount * int64(levelRule.CommissionRate) / 10000
+	afterAvailable := account.AvailableAmount - product.PriceAmount
+	afterFrozen := account.FrozenAmount + product.PriceAmount
+	walletResult, err := tx.ExecContext(ctx, `UPDATE hg_wallet_account SET available_amount=?,frozen_amount=?,version=version+1,
+		updated_at=UTC_TIMESTAMP(3) WHERE tenant_id=? AND id=? AND version=? AND available_amount=? AND frozen_amount=?`,
+		afterAvailable, afterFrozen, tenantID, account.ID, account.Version, account.AvailableAmount, account.FrozenAmount)
+	if err != nil {
+		return err
+	}
+	if affected, _ := walletResult.RowsAffected(); affected != 1 {
+		return ErrConcurrentUpdate
+	}
+	if _, err = insertTaskLedger(ctx, tx, tenantID, memberID, account.ID, orderID, fmt.Sprintf("WL%dMA", orderID),
+		"task_principal_hold", order.OrderNo, "available", 2, product.PriceAmount, account.AvailableAmount, afterAvailable,
+		"match:available", "自动派单扣除可用余额"); err != nil {
+		return err
+	}
+	if _, err = insertTaskLedger(ctx, tx, tenantID, memberID, account.ID, orderID, fmt.Sprintf("WL%dMF", orderID),
+		"task_principal_hold", order.OrderNo, "frozen", 1, product.PriceAmount, account.FrozenAmount, afterFrozen,
+		"match:frozen", "自动派单冻结订单本金"); err != nil {
+		return err
+	}
+	result, err := tx.ExecContext(ctx, `UPDATE hg_trade_order SET product_id=?,product_name=?,quantity=1,
+		unit_price_amount=?,total_amount=?,commission_amount=?,currency=?,rule_snapshot=?,message=?,
+		order_status=2,freeze_status=1,matched_at=UTC_TIMESTAMP(3),updated_at=UTC_TIMESTAMP(3)
+		WHERE tenant_id=? AND member_id=? AND id=? AND order_type=2 AND order_status=1`, product.ID, product.Name,
+		product.PriceAmount, product.PriceAmount, commissionAmount, product.Currency, rules,
+		"系统已自动匹配订单，订单本金已扣除，请在截止时间前完成", tenantID, memberID, orderID)
+	if err != nil {
+		return err
+	}
+	if affected, _ := result.RowsAffected(); affected != 1 {
+		return ErrConcurrentUpdate
+	}
+	return tx.Commit()
 }
 
 func (s *Store) TaskOrders(ctx context.Context, tenantID, memberID int64, status, offset, limit int) (*TaskOrderPage, error) {
@@ -364,13 +487,15 @@ func (s *Store) SubmitTask(ctx context.Context, input TaskSubmissionInput) (*Tas
 	}
 	defer tx.Rollback()
 	var order struct {
+		OrderNo          string `db:"order_no"`
 		TaskID           int64  `db:"task_id"`
 		MemberLevelID    int64  `db:"member_level_id"`
+		TotalAmount      int64  `db:"total_amount"`
 		CommissionAmount int64  `db:"commission_amount"`
 		OrderStatus      int    `db:"order_status"`
 		DeadlineAt       string `db:"deadline_at"`
 	}
-	err = tx.GetContext(ctx, &order, `SELECT task_id,member_level_id,commission_amount,order_status,
+	err = tx.GetContext(ctx, &order, `SELECT order_no,task_id,member_level_id,total_amount,commission_amount,order_status,
 		COALESCE(JSON_UNQUOTE(JSON_EXTRACT(rule_snapshot,'$.deadline_at')),'') AS deadline_at
 		FROM hg_trade_order WHERE tenant_id=? AND member_id=? AND order_type=2 AND id=? LIMIT 1 FOR UPDATE`,
 		input.TenantID, input.MemberID, input.OrderID)
@@ -383,8 +508,48 @@ func (s *Store) SubmitTask(ctx context.Context, input TaskSubmissionInput) (*Tas
 	if order.OrderStatus != orderStatusPending {
 		return nil, ErrOrderState
 	}
+	var account struct {
+		ID              int64 `db:"id"`
+		AvailableAmount int64 `db:"available_amount"`
+		FrozenAmount    int64 `db:"frozen_amount"`
+		Status          int   `db:"account_status"`
+		Version         int   `db:"version"`
+	}
+	err = tx.GetContext(ctx, &account, `SELECT id,available_amount,frozen_amount,account_status,version FROM hg_wallet_account
+		WHERE tenant_id=? AND member_id=? AND currency='CNY' LIMIT 1 FOR UPDATE`, input.TenantID, input.MemberID)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, ErrAccountNotFound
+	}
+	if err != nil {
+		return nil, err
+	}
+	if account.Status != 1 || account.FrozenAmount < order.TotalAmount {
+		return nil, ErrAccountRestricted
+	}
 	if order.DeadlineAt != "" {
 		if deadline, parseErr := time.Parse(time.RFC3339, order.DeadlineAt); parseErr != nil || !time.Now().UTC().Before(deadline) {
+			now := time.Now().UTC()
+			afterAvailable := account.AvailableAmount + order.TotalAmount
+			afterFrozen := account.FrozenAmount - order.TotalAmount
+			walletResult, updateErr := tx.ExecContext(ctx, `UPDATE hg_wallet_account SET available_amount=?,frozen_amount=?,
+				version=version+1,updated_at=? WHERE tenant_id=? AND id=? AND version=?`, afterAvailable, afterFrozen,
+				now, input.TenantID, account.ID, account.Version)
+			if updateErr != nil {
+				return nil, updateErr
+			}
+			if affected, _ := walletResult.RowsAffected(); affected != 1 {
+				return nil, ErrConcurrentUpdate
+			}
+			if _, updateErr = insertTaskLedger(ctx, tx, input.TenantID, input.MemberID, account.ID, input.OrderID,
+				fmt.Sprintf("WL%dEF", input.OrderID), "task_principal_release", order.OrderNo, "frozen", 2,
+				order.TotalAmount, account.FrozenAmount, afterFrozen, "expire:frozen", "订单超时释放冻结本金"); updateErr != nil {
+				return nil, updateErr
+			}
+			if _, updateErr = insertTaskLedger(ctx, tx, input.TenantID, input.MemberID, account.ID, input.OrderID,
+				fmt.Sprintf("WL%dEA", input.OrderID), "task_principal_release", order.OrderNo, "available", 1,
+				order.TotalAmount, account.AvailableAmount, afterAvailable, "expire:available", "订单超时退回订单本金"); updateErr != nil {
+				return nil, updateErr
+			}
 			if _, updateErr := tx.ExecContext(ctx, `UPDATE hg_trade_order SET order_status=5,message='任务已超时',updated_at=UTC_TIMESTAMP(3)
 				WHERE tenant_id=? AND id=? AND order_status=2`, input.TenantID, input.OrderID); updateErr != nil {
 				return nil, updateErr
@@ -398,24 +563,64 @@ func (s *Store) SubmitTask(ctx context.Context, input TaskSubmissionInput) (*Tas
 	if err := validateEvidenceAttachments(ctx, tx, input.TenantID, input.MemberID, input.AttachmentIDs); err != nil {
 		return nil, err
 	}
+	if input.SubmissionNo == "" {
+		return nil, ErrOrderState
+	}
 	attachments, err := json.Marshal(input.AttachmentIDs)
 	if err != nil {
 		return nil, err
 	}
-	now := time.Now().UTC()
-	_, err = tx.ExecContext(ctx, `INSERT INTO hg_task_submission
+	now := input.SettledAt.UTC()
+	if now.IsZero() {
+		now = time.Now().UTC()
+	}
+	principalAfter := account.AvailableAmount + order.TotalAmount
+	afterAmount := principalAfter + order.CommissionAmount
+	afterFrozen := account.FrozenAmount - order.TotalAmount
+	accountResult, err := tx.ExecContext(ctx, `UPDATE hg_wallet_account SET available_amount=?,frozen_amount=?,total_income=total_income+?,
+		version=version+1,updated_at=? WHERE tenant_id=? AND id=? AND version=?`, afterAmount, afterFrozen,
+		order.CommissionAmount, now, input.TenantID, account.ID, account.Version)
+	if err != nil {
+		return nil, err
+	}
+	if affected, _ := accountResult.RowsAffected(); affected != 1 {
+		return nil, ErrOrderState
+	}
+	if _, err = insertTaskLedger(ctx, tx, input.TenantID, input.MemberID, account.ID, input.OrderID,
+		fmt.Sprintf("WL%dSF", input.OrderID), "task_principal_release", order.OrderNo, "frozen", 2,
+		order.TotalAmount, account.FrozenAmount, afterFrozen, "settle:frozen", "任务完成释放冻结本金"); err != nil {
+		return nil, err
+	}
+	if _, err = insertTaskLedger(ctx, tx, input.TenantID, input.MemberID, account.ID, input.OrderID,
+		fmt.Sprintf("WL%dSA", input.OrderID), "task_principal_return", order.OrderNo, "available", 1,
+		order.TotalAmount, account.AvailableAmount, principalAfter, "settle:available", "任务完成返回订单本金"); err != nil {
+		return nil, err
+	}
+	ledgerID, err := insertTaskLedger(ctx, tx, input.TenantID, input.MemberID, account.ID, input.OrderID,
+		fmt.Sprintf("WL%dSC", input.OrderID), "commission", input.SubmissionNo, "available", 1,
+		order.CommissionAmount, principalAfter, afterAmount, "settle:commission", "任务完成自动返佣")
+	if err != nil {
+		return nil, err
+	}
+	submissionResult, err := tx.ExecContext(ctx, `INSERT INTO hg_task_submission
 		(tenant_id,submission_no,trade_order_id,task_id,member_id,member_level_id,evidence_text,
-		 evidence_attachment_ids,submission_status,commission_amount,success_rate,allow_resubmit,created_by,updated_by)
-		VALUES(?,?,?,?,?,?,?,?,1,?,0,2,0,0)`, input.TenantID, input.SubmissionNo, input.OrderID,
-		order.TaskID, input.MemberID, order.MemberLevelID, input.EvidenceText, attachments, order.CommissionAmount)
+		 evidence_attachment_ids,submission_status,commission_amount,success_rate,reviewed_by,reviewed_at,
+		 review_reason_code,review_reason,allow_resubmit,ledger_id,settled_at,created_by,updated_by,created_at,updated_at)
+		VALUES(?,?,?,?,?,?,?,?,4,?,10000,0,?,'AUTO_SETTLED','会员提交后自动结算',2,?,?,0,0,?,?)`,
+		input.TenantID, input.SubmissionNo, input.OrderID, order.TaskID, input.MemberID, order.MemberLevelID,
+		input.EvidenceText, attachments, order.CommissionAmount, now, ledgerID, now, now, now)
 	if err != nil {
 		if isDuplicate(err) {
 			return nil, ErrOrderState
 		}
 		return nil, err
 	}
-	result, err := tx.ExecContext(ctx, `UPDATE hg_trade_order SET order_status=3,message='已提交，等待审核',updated_at=UTC_TIMESTAMP(3)
-		WHERE tenant_id=? AND id=? AND member_id=? AND order_status=2`, input.TenantID, input.OrderID, input.MemberID)
+	if affected, _ := submissionResult.RowsAffected(); affected != 1 {
+		return nil, ErrOrderState
+	}
+	result, err := tx.ExecContext(ctx, `UPDATE hg_trade_order SET order_status=4,message='订单完成，佣金已入账',
+		completed_at=?,updated_at=?
+		WHERE tenant_id=? AND id=? AND member_id=? AND order_status=2`, now, now, input.TenantID, input.OrderID, input.MemberID)
 	if err != nil {
 		return nil, err
 	}
@@ -425,7 +630,22 @@ func (s *Store) SubmitTask(ctx context.Context, input TaskSubmissionInput) (*Tas
 	if err := tx.Commit(); err != nil {
 		return nil, err
 	}
-	return &TaskSubmissionResult{SubmissionNo: input.SubmissionNo, OrderStatus: orderStatusProcessing, SubmittedAt: now}, nil
+	return &TaskSubmissionResult{SubmissionNo: input.SubmissionNo, OrderStatus: orderStatusCompleted, SubmittedAt: now}, nil
+}
+
+func insertTaskLedger(ctx context.Context, tx *sqlx.Tx, tenantID, memberID, accountID, orderID int64,
+	ledgerNo, bizType, bizNo, entryType string, direction int, amount, beforeAmount, afterAmount int64,
+	idempotencySuffix, remark string) (int64, error) {
+	result, err := tx.ExecContext(ctx, `INSERT INTO hg_wallet_ledger
+		(tenant_id,ledger_no,account_id,member_id,biz_type,biz_no,entry_type,direction,amount,
+		 before_amount,after_amount,currency,reversal_of,idempotency_key,remark,operator_id,occurred_at)
+		VALUES(?,?,?,?,?,?,?,?,?,?,?,'CNY',0,?,?,?,UTC_TIMESTAMP(3))`, tenantID, ledgerNo, accountID, memberID,
+		bizType, bizNo, entryType, direction, amount, beforeAmount, afterAmount,
+		fmt.Sprintf("task:%d:%s", orderID, idempotencySuffix), remark, memberID)
+	if err != nil {
+		return 0, err
+	}
+	return result.LastInsertId()
 }
 
 func validateEvidenceAttachments(ctx context.Context, tx *sqlx.Tx, tenantID, memberID int64, ids []int64) error {
@@ -433,7 +653,7 @@ func validateEvidenceAttachments(ctx context.Context, tx *sqlx.Tx, tenantID, mem
 		return nil
 	}
 	query, args, err := sqlx.In(`SELECT COUNT(*) FROM hg_sys_attachment WHERE id IN (?)
-		AND tenant_id=? AND app_id='workbench' AND member_id=? AND status=1
+		AND tenant_id=? AND app_id='olons_server' AND member_id=? AND status=1
 		AND (mime_type LIKE 'image/%' OR mime_type='application/pdf')`, ids, tenantID, memberID)
 	if err != nil {
 		return err

internal/store/withdrawals.go

@@ -10,39 +10,45 @@ import (
 )
 
 type PaymentAccount struct {
-	ID              int64  `db:"id"`
-	AccountType     int    `db:"account_type"`
-	BankCode        string `db:"bank_code"`
-	BankName        string `db:"bank_name"`
-	HolderCipher    string `db:"holder_cipher"`
-	HolderMask      string `db:"holder_mask"`
-	MobileCipher    string `db:"mobile_cipher"`
-	MobileMask      string `db:"mobile_mask"`
-	AccountNoCipher string `db:"account_no_cipher"`
-	AccountNoHash   string `db:"account_no_hash"`
-	AccountNoMask   string `db:"account_no_mask"`
-	QRAttachmentID  int64  `db:"qr_attachment_id"`
-	VerifyStatus    int    `db:"verify_status"`
-	IsDefault       int    `db:"is_default"`
-	CreatedAt       string `db:"created_at"`
-	UpdatedAt       string `db:"updated_at"`
+	ID                   int64  `db:"id"`
+	AccountType          int    `db:"account_type"`
+	BankCode             string `db:"bank_code"`
+	BankName             string `db:"bank_name"`
+	HolderCipher         string `db:"holder_cipher"`
+	HolderMask           string `db:"holder_mask"`
+	IdentityNoCipher     string `db:"identity_no_cipher"`
+	IdentityNoHash       string `db:"identity_no_hash"`
+	IdentityNoMask       string `db:"identity_no_mask"`
+	MobileCipher         string `db:"mobile_cipher"`
+	MobileMask           string `db:"mobile_mask"`
+	AccountNoCipher      string `db:"account_no_cipher"`
+	AccountNoHash        string `db:"account_no_hash"`
+	AccountNoMask        string `db:"account_no_mask"`
+	QRAttachmentID       int64  `db:"qr_attachment_id"`
+	WechatQRAttachmentID int64  `db:"wechat_qr_attachment_id"`
+	AlipayQRAttachmentID int64  `db:"alipay_qr_attachment_id"`
+	VerifyStatus         int    `db:"verify_status"`
+	IsDefault            int    `db:"is_default"`
+	CreatedAt            string `db:"created_at"`
+	UpdatedAt            string `db:"updated_at"`
 }
 
 type PaymentAccountCreation struct {
-	TenantID                  int64
-	MemberID                  int64
-	ExpectedTradePasswordHash string
-	AccountType               int
-	BankCode                  string
-	BankName                  string
-	HolderCipher              string
-	HolderMask                string
-	MobileCipher              string
-	MobileMask                string
-	AccountNoCipher           string
-	AccountNoHash             string
-	AccountNoMask             string
-	QRAttachmentID            int64
+	TenantID             int64
+	MemberID             int64
+	AccountType          int
+	BankCode             string
+	BankName             string
+	HolderCipher         string
+	HolderMask           string
+	IdentityNoCipher     string
+	IdentityNoHash       string
+	IdentityNoMask       string
+	AccountNoCipher      string
+	AccountNoHash        string
+	AccountNoMask        string
+	WechatQRAttachmentID int64
+	AlipayQRAttachmentID int64
 }
 
 type WithdrawalChannel struct {
@@ -67,30 +73,32 @@ type WithdrawalWallet struct {
 }
 
 type WithdrawalCreation struct {
-	TenantID                  int64
-	MemberID                  int64
-	ExpectedTradePasswordHash string
-	WithdrawalNo              string
-	PaymentAccountID          int64
-	ExpectedAccountType       int
-	ExpectedBankCode          string
-	ExpectedBankName          string
-	ExpectedHolderCipher      string
-	ExpectedMobileCipher      string
-	ExpectedAccountNoCipher   string
-	ExpectedAccountNoHash     string
-	ExpectedQRAttachmentID    int64
-	Channel                   WithdrawalChannel
-	RequestAmount             int64
-	FeeAmount                 int64
-	ActualAmount              int64
-	Currency                  string
-	AccountSnapshotCipher     string
-	AccountMask               string
-	BankName                  string
-	HolderMask                string
-	AvailableLedgerNo         string
-	FrozenLedgerNo            string
+	TenantID                     int64
+	MemberID                     int64
+	ExpectedTradePasswordHash    string
+	WithdrawalNo                 string
+	PaymentAccountID             int64
+	ExpectedAccountType          int
+	ExpectedBankCode             string
+	ExpectedBankName             string
+	ExpectedHolderCipher         string
+	ExpectedIdentityNoCipher     string
+	ExpectedIdentityNoHash       string
+	ExpectedAccountNoCipher      string
+	ExpectedAccountNoHash        string
+	ExpectedWechatQRAttachmentID int64
+	ExpectedAlipayQRAttachmentID int64
+	Channel                      WithdrawalChannel
+	RequestAmount                int64
+	FeeAmount                    int64
+	ActualAmount                 int64
+	Currency                     string
+	AccountSnapshotCipher        string
+	AccountMask                  string
+	BankName                     string
+	HolderMask                   string
+	AvailableLedgerNo            string
+	FrozenLedgerNo               string
 }
 
 type WithdrawalOrder struct {
@@ -126,8 +134,10 @@ type WithdrawalPage struct {
 
 func (s *Store) PaymentAccounts(ctx context.Context, tenantID, memberID int64) ([]PaymentAccount, error) {
 	items := make([]PaymentAccount, 0)
-	err := s.db.SelectContext(ctx, &items, `SELECT id,account_type,bank_code,bank_name,holder_mask,mobile_mask,
-		account_no_mask,qr_attachment_id,verify_status,is_default,
+	err := s.db.SelectContext(ctx, &items, `SELECT id,account_type,bank_code,bank_name,holder_mask,
+		COALESCE(identity_no_mask,'') AS identity_no_mask,account_no_mask,
+		COALESCE(wechat_qr_attachment_id,0) AS wechat_qr_attachment_id,
+		COALESCE(alipay_qr_attachment_id,0) AS alipay_qr_attachment_id,verify_status,is_default,
 		DATE_FORMAT(created_at,'%Y-%m-%dT%H:%i:%sZ') AS created_at,
 		DATE_FORMAT(updated_at,'%Y-%m-%dT%H:%i:%sZ') AS updated_at
 		FROM hg_app_member_payment_account WHERE tenant_id=? AND member_id=? AND deleted_at IS NULL
@@ -143,25 +153,22 @@ func (s *Store) CreatePaymentAccount(ctx context.Context, input PaymentAccountCr
 	defer tx.Rollback()
 	var memberID int64
 	err = tx.GetContext(ctx, &memberID, `SELECT id FROM hg_app_member WHERE tenant_id=? AND id=?
-		AND trade_password_hash=? AND member_status=1 AND deleted_at IS NULL LIMIT 1 FOR UPDATE`,
-		input.TenantID, input.MemberID, input.ExpectedTradePasswordHash)
+		AND member_status=1 AND deleted_at IS NULL LIMIT 1 FOR UPDATE`, input.TenantID, input.MemberID)
 	if errors.Is(err, sql.ErrNoRows) {
 		return nil, ErrConcurrentUpdate
 	}
 	if err != nil {
 		return nil, err
 	}
-	if input.QRAttachmentID > 0 {
-		var attachmentCount int
-		err = tx.GetContext(ctx, &attachmentCount, `SELECT COUNT(*) FROM hg_sys_attachment
-			WHERE tenant_id=? AND id=? AND app_id='workbench' AND member_id=? AND status=1 AND mime_type LIKE 'image/%'`,
-			input.TenantID, input.QRAttachmentID, input.MemberID)
-		if err != nil {
-			return nil, err
-		}
-		if attachmentCount != 1 {
-			return nil, ErrAttachmentInvalid
-		}
+	var attachmentCount int
+	err = tx.GetContext(ctx, &attachmentCount, `SELECT COUNT(*) FROM hg_sys_attachment
+		WHERE id IN (?,?) AND app_id='olons_server' AND member_id=? AND status=1 AND mime_type LIKE 'image/%'`,
+		input.WechatQRAttachmentID, input.AlipayQRAttachmentID, input.MemberID)
+	if err != nil {
+		return nil, err
+	}
+	if attachmentCount != 2 {
+		return nil, ErrAttachmentInvalid
 	}
 	var accountCount int
 	if err = tx.GetContext(ctx, &accountCount, `SELECT COUNT(*) FROM hg_app_member_payment_account
@@ -173,12 +180,15 @@ func (s *Store) CreatePaymentAccount(ctx context.Context, input PaymentAccountCr
 		isDefault = 1
 	}
 	result, err := tx.ExecContext(ctx, `INSERT INTO hg_app_member_payment_account
-		(tenant_id,member_id,account_type,bank_code,bank_name,holder_cipher,holder_mask,mobile_cipher,
-		 mobile_mask,account_no_cipher,account_no_hash,account_no_mask,qr_attachment_id,verify_status,
+		(tenant_id,member_id,account_type,bank_code,bank_name,holder_cipher,holder_mask,
+		 identity_no_cipher,identity_no_hash,identity_no_mask,account_no_cipher,account_no_hash,account_no_mask,
+		 wechat_qr_attachment_id,alipay_qr_attachment_id,verify_status,
 		 is_default,created_by,updated_by)
-		VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,1,?,?,?)`, input.TenantID, input.MemberID, input.AccountType,
-		input.BankCode, input.BankName, input.HolderCipher, input.HolderMask, nullableString(input.MobileCipher),
-		input.MobileMask, input.AccountNoCipher, input.AccountNoHash, input.AccountNoMask, input.QRAttachmentID,
+		VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,2,?,?,?)`, input.TenantID, input.MemberID, input.AccountType,
+		input.BankCode, input.BankName, input.HolderCipher, input.HolderMask,
+		input.IdentityNoCipher, input.IdentityNoHash, input.IdentityNoMask,
+		input.AccountNoCipher, input.AccountNoHash, input.AccountNoMask,
+		input.WechatQRAttachmentID, input.AlipayQRAttachmentID,
 		isDefault, input.MemberID, input.MemberID)
 	if err != nil {
 		if isDuplicate(err) {
@@ -194,9 +204,10 @@ func (s *Store) CreatePaymentAccount(ctx context.Context, input PaymentAccountCr
 		return nil, err
 	}
 	return &PaymentAccount{ID: id, AccountType: input.AccountType, BankCode: input.BankCode,
-		BankName: input.BankName, HolderMask: input.HolderMask, MobileMask: input.MobileMask,
-		AccountNoMask: input.AccountNoMask, QRAttachmentID: input.QRAttachmentID,
-		VerifyStatus: 1, IsDefault: isDefault}, nil
+		BankName: input.BankName, HolderMask: input.HolderMask, IdentityNoMask: input.IdentityNoMask,
+		AccountNoMask: input.AccountNoMask, WechatQRAttachmentID: input.WechatQRAttachmentID,
+		AlipayQRAttachmentID: input.AlipayQRAttachmentID,
+		VerifyStatus:         2, IsDefault: isDefault}, nil
 }
 
 func nullableString(value string) any {
@@ -209,8 +220,10 @@ func nullableString(value string) any {
 func (s *Store) PaymentAccountForWithdrawal(ctx context.Context, tenantID, memberID, accountID int64) (*PaymentAccount, error) {
 	var row PaymentAccount
 	err := s.db.GetContext(ctx, &row, `SELECT id,account_type,bank_code,bank_name,holder_cipher,holder_mask,
-		COALESCE(mobile_cipher,'') AS mobile_cipher,mobile_mask,account_no_cipher,account_no_hash,
-		account_no_mask,qr_attachment_id,verify_status,is_default,
+		COALESCE(identity_no_cipher,'') AS identity_no_cipher,COALESCE(identity_no_hash,'') AS identity_no_hash,
+		COALESCE(identity_no_mask,'') AS identity_no_mask,account_no_cipher,account_no_hash,account_no_mask,
+		COALESCE(wechat_qr_attachment_id,0) AS wechat_qr_attachment_id,
+		COALESCE(alipay_qr_attachment_id,0) AS alipay_qr_attachment_id,verify_status,is_default,
 		DATE_FORMAT(created_at,'%Y-%m-%dT%H:%i:%sZ') AS created_at,
 		DATE_FORMAT(updated_at,'%Y-%m-%dT%H:%i:%sZ') AS updated_at
 		FROM hg_app_member_payment_account WHERE tenant_id=? AND member_id=? AND id=? AND deleted_at IS NULL LIMIT 1`,
@@ -289,8 +302,11 @@ func (s *Store) CreateWithdrawal(ctx context.Context, input WithdrawalCreation)
 
 	var account PaymentAccount
 	err = tx.GetContext(ctx, &account, `SELECT id,account_type,bank_code,bank_name,holder_cipher,holder_mask,
-		COALESCE(mobile_cipher,'') AS mobile_cipher,mobile_mask,account_no_cipher,account_no_hash,
-		account_no_mask,qr_attachment_id,verify_status,is_default,'' AS created_at,'' AS updated_at
+		COALESCE(identity_no_cipher,'') AS identity_no_cipher,COALESCE(identity_no_hash,'') AS identity_no_hash,
+		COALESCE(identity_no_mask,'') AS identity_no_mask,account_no_cipher,account_no_hash,account_no_mask,
+		COALESCE(wechat_qr_attachment_id,0) AS wechat_qr_attachment_id,
+		COALESCE(alipay_qr_attachment_id,0) AS alipay_qr_attachment_id,
+		verify_status,is_default,'' AS created_at,'' AS updated_at
 		FROM hg_app_member_payment_account WHERE tenant_id=? AND member_id=? AND id=?
 		AND verify_status=2 AND deleted_at IS NULL LIMIT 1 FOR UPDATE`, input.TenantID, input.MemberID, input.PaymentAccountID)
 	if errors.Is(err, sql.ErrNoRows) {
@@ -301,8 +317,10 @@ func (s *Store) CreateWithdrawal(ctx context.Context, input WithdrawalCreation)
 	}
 	if account.AccountType != input.ExpectedAccountType || account.BankCode != input.ExpectedBankCode ||
 		account.BankName != input.ExpectedBankName || account.HolderCipher != input.ExpectedHolderCipher ||
-		account.MobileCipher != input.ExpectedMobileCipher || account.AccountNoCipher != input.ExpectedAccountNoCipher ||
-		account.AccountNoHash != input.ExpectedAccountNoHash || account.QRAttachmentID != input.ExpectedQRAttachmentID {
+		account.IdentityNoCipher != input.ExpectedIdentityNoCipher || account.IdentityNoHash != input.ExpectedIdentityNoHash ||
+		account.AccountNoCipher != input.ExpectedAccountNoCipher || account.AccountNoHash != input.ExpectedAccountNoHash ||
+		account.WechatQRAttachmentID != input.ExpectedWechatQRAttachmentID ||
+		account.AlipayQRAttachmentID != input.ExpectedAlipayQRAttachmentID {
 		return nil, ErrConcurrentUpdate
 	}
 	var channel WithdrawalChannel