platforms/backend/api/internal/logic/client/user/gasorder.go

package user

import (
	"errors"
	"time"

	"git.apinb.com/bsm-sdk/core/errcode"
	"git.apinb.com/bsm-sdk/core/infra"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/impl"
	common "git.apinb.com/heqiapp/platforms/backend/api/internal/logic/common"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/logic/payment"
	"git.apinb.com/heqiapp/platforms/backend/api/internal/models"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

// ServiceRelation 返回当前唯一有效服务归属的公开 identity。
func ServiceRelation(ctx *gin.Context) {
	account, ok := common.UserAccount(ctx)
	if !ok {
		return
	}
	var relation models.UserServiceRelation
	if impl.DBService.Where("user_account_id = ? AND status = ?", account.ID, common.StatusEnable).First(&relation).Error != nil {
		infra.Response.Success(ctx, nil)
		return
	}
	response := gin.H{}
	if relation.GasBasicID != 0 {
		var gas models.GasBasic
		if impl.DBService.First(&gas, relation.GasBasicID).Error == nil {
			response["gas_identity"], response["gas_name"] = gas.Identity, gas.Name
		}
	}
	if relation.DeliveryBasicID != 0 {
		var delivery models.DeliveryBasic
		if impl.DBService.First(&delivery, relation.DeliveryBasicID).Error == nil {
			response["delivery_identity"], response["delivery_name"] = delivery.Identity, delivery.Name
		}
	}
	infra.Response.Success(ctx, response)
}

// PayGasOrder 为本人未履约供气订单创建余额或第三方支付单。
func PayGasOrder(ctx *gin.Context) {
	account, ok := common.UserAccount(ctx)
	if !ok {
		return
	}
	var request struct {
		PaymentPassword string `json:"payment_password"`
		RequestNo       string `json:"request_no" binding:"required"`
		Channel         string `json:"channel" binding:"required,oneof=wallet alipay wechat"`
		PayType         string `json:"pay_type" binding:"required"`
		OpenID          string `json:"openid"`
	}
	if ctx.ShouldBindJSON(&request) != nil {
		infra.Response.Error(ctx, errcode.ErrInvalidArgument)
		return
	}
	if request.Channel == "wallet" {
		if err := payGasOrderWithWallet(account, ctx.Param("identity"), request.RequestNo, request.PaymentPassword); err != nil {
			infra.Response.Error(ctx, err)
			return
		}
		infra.Response.Success(ctx, gin.H{"paid": true})
		return
	}
	var order models.GasorderBasic
	if err := impl.DBService.Where("identity = ? AND user_account_id = ? AND order_status IN ?", ctx.Param("identity"), account.ID, []int{common.StatusCreated, common.StatusAssigned}).First(&order).Error; err != nil {
		infra.Response.Error(ctx, err)
		return
	}
	payOrder, err := payment.Create(ctx, payment.CreateInput{RequestNo: request.RequestNo, BusinessType: "gasorder", BusinessIdentity: order.Identity,
		UserIdentity: account.Identity, Channel: request.Channel, PayType: request.PayType, Subject: "和气供气订单 " + order.OrderNo, OpenID: request.OpenID, Amount: order.PayableAmount})
	if err != nil {
		infra.Response.Error(ctx, err)
		return
	}
	infra.Response.Success(ctx, payment.PublicResponse(payOrder))
}

// payGasOrderWithWallet 在同一事务内记录支付事实、扣减钱包并推进供气订单。
func payGasOrderWithWallet(account models.UserAccount, identity, requestNo, password string) error {
	return impl.DBService.Transaction(func(tx *gorm.DB) error {
		var existing models.PaymentOrder
		err := tx.Where("business_type = ? AND request_no = ?", "gasorder", requestNo).First(&existing).Error
		if err == nil {
			if existing.BusinessIdentity != identity || existing.UserIdentity != account.Identity || existing.Channel != "wallet" || existing.PaymentStatus != payment.StatusPaid {
				return errors.New("idempotency conflict")
			}
			return nil
		}
		if !errors.Is(err, gorm.ErrRecordNotFound) {
			return err
		}

		var order models.GasorderBasic
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
			Where("identity = ? AND user_account_id = ? AND order_status IN ?", identity, account.ID, []int{common.StatusCreated, common.StatusAssigned}).First(&order).Error; err != nil {
			return err
		}
		var wallet models.WalletBasic
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
			Where("owner_type = ? AND owner_identity = ?", "user", account.Identity).First(&wallet).Error; err != nil {
			return err
		}
		if !common.VerifyPaymentPassword(account.Identity, wallet, password) {
			return gorm.ErrInvalidData
		}
		if err := common.SpendWalletBalance(&wallet, order.PayableAmount); err != nil {
			return err
		}
		if err := common.SaveWalletBalances(tx, wallet); err != nil {
			return err
		}
		now := time.Now()
		if err := tx.Model(&order).Update("order_status", common.StatusPaid).Error; err != nil {
			return err
		}
		if err := payment.CompleteGasDeposits(tx, order.Identity, now); err != nil {
			return err
		}
		if err := tx.Create(&models.PaymentOrder{
			Entity: common.NewEntity(common.StatusEnable), PaymentStatus: payment.StatusPaid,
			PaymentNo: common.RecordNo("PAY"), RequestNo: requestNo, BusinessType: "gasorder",
			BusinessIdentity: order.Identity, UserIdentity: account.Identity, MerchantIdentity: "platform",
			Channel: "wallet", PayType: "balance", Amount: order.PayableAmount,
			Subject: "和气供气订单 " + order.OrderNo, ExpiresAt: now, PaidAt: &now,
		}).Error; err != nil {
			return err
		}
		date := now.In(time.Local)
		return tx.Create(&models.WalletRecord{
			Entity: common.NewEntity(common.StatusEnable), WalletBasicID: wallet.ID, RecordNo: common.RecordNo("WR"),
			RequestNo: requestNo, Direction: "expense", TradeType: "gasorder", Amount: order.PayableAmount,
			BalanceAfter: wallet.Balance, WithdrawalBalanceAfter: wallet.WithdrawalBalance,
			OutTradeNo: order.OrderNo, PayChannel: "wallet", OperatorIdentity: account.Identity,
			Ymd: int32(date.Year()*10000 + int(date.Month())*100 + date.Day()),
			Ym:  int32(date.Year()*100 + int(date.Month())),
		}).Error
	})
}

// ListGasContracts 返回用户自己的供气合同。
func ListGasContracts(ctx *gin.Context) {
	account, ok := common.UserAccount(ctx)
	if !ok {
		return
	}
	var list []models.GasorderContract
	if err := impl.DBService.Where("user_account_id = ? AND status <> ?", account.ID, common.StatusArchived).Order("created_at desc").Find(&list).Error; err != nil {
		infra.Response.Error(ctx, err)
		return
	}
	response := make([]gin.H, 0, len(list))
	contractIDs, stationIDs := []uint64{}, []uint64{}
	for _, contract := range list {
		contractIDs = append(contractIDs, contract.ID)
		stationIDs = append(stationIDs, contract.GasBasicID)
	}
	// 合同绑定属于合同，不得把合同主键误作订单主键读取气瓶。
	var bindings []models.GasorderContractProduct
	var stations []models.GasBasic
	if len(list) > 0 {
		if err := impl.DBService.Where("gasorder_contract_id IN ? AND status <> ?", contractIDs, common.StatusArchived).Find(&bindings).Error; err != nil {
			infra.Response.Error(ctx, err)
			return
		}
		if err := impl.DBService.Where("id IN ? AND status = ?", stationIDs, common.StatusEnable).Find(&stations).Error; err != nil {
			infra.Response.Error(ctx, err)
			return
		}
	}
	stationNames := map[uint64]string{}
	for _, station := range stations {
		stationNames[station.ID] = station.Name
	}
	for _, order := range list {
		items := []gin.H{}
		for _, binding := range bindings {
			if binding.GasorderContractID == order.ID {
				items = append(items, gin.H{"identity": binding.Identity, "product_code": binding.ProductCode, "product_type_name": binding.ProductTypeName, "unit_price": binding.UnitPrice, "bound_at": binding.BoundAt, "unbound_at": binding.UnboundAt})
			}
		}
		value := common.ResourceResponse(order).(map[string]any)
		// 旧字段保留空值以兼容客户端，私有附件不能以原始存储地址下发。
		value["file_uri"] = ""
		value["has_attachment"] = order.FileURI != ""
		value["station_name"] = stationNames[order.GasBasicID]
		value["items"] = items
		response = append(response, value)
	}
	infra.Response.Success(ctx, response)
}

// ListGasOrders 返回用户自己的供气订单。
func ListGasOrders(ctx *gin.Context) {
	account, ok := common.UserAccount(ctx)
	if !ok {
		return
	}
	query, page, ok := paginateClientList(ctx, impl.DBService.Where("user_account_id = ? AND status <> ?", account.ID, common.StatusArchived))
	if !ok {
		return
	}
	var list []models.GasorderBasic
	if err := query.Order("created_at desc, identity").Find(&list).Error; err != nil {
		infra.Response.Error(ctx, err)
		return
	}
	stationIDs := make([]uint64, 0, len(list))
	seenStations := map[uint64]struct{}{}
	for _, order := range list {
		if _, exists := seenStations[order.GasBasicID]; !exists {
			seenStations[order.GasBasicID] = struct{}{}
			stationIDs = append(stationIDs, order.GasBasicID)
		}
	}
	stationNames := map[uint64]string{}
	if len(stationIDs) > 0 {
		var stations []models.GasBasic
		if err := impl.DBService.Where("id IN ? AND status = ?", stationIDs, common.StatusEnable).Find(&stations).Error; err != nil {
			infra.Response.Error(ctx, err)
			return
		}
		for _, station := range stations {
			stationNames[station.ID] = station.Name
		}
	}
	response := make([]gin.H, 0, len(list))
	for _, order := range list {
		var items []models.GasorderItem
		if err := impl.DBService.Where("gasorder_basic_id = ?", order.ID).Find(&items).Error; err != nil {
			infra.Response.Error(ctx, err)
			return
		}
		value := common.ResourceResponse(order).(map[string]any)
		value["items"] = common.ResourceResponse(items)
		value["station_name"] = stationNames[order.GasBasicID]
		value["status_code"], value["status_name"] = order.OrderStatus, gasOrderStatusName(order.OrderStatus)
		value["allowed_actions"] = gasOrderActions(order.OrderStatus)
		response = append(response, value)
	}
	respondClientPage(ctx, page, response)
}

// CancelGasOrder 仅允许取消已创建或已分派的本人订单。
func CancelGasOrder(ctx *gin.Context) {
	account, ok := common.UserAccount(ctx)
	if !ok {
		return
	}
	err := impl.DBService.Transaction(func(tx *gorm.DB) error {
		var order models.GasorderBasic
		if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).Where("identity = ? AND user_account_id = ? AND order_status IN ?", ctx.Param("identity"), account.ID, []int{common.StatusCreated, common.StatusAssigned}).First(&order).Error; err != nil {
			return err
		}
		if err := tx.Model(&order).Updates(map[string]any{"order_status": common.StatusCancelled, "operator_identity": account.Identity}).Error; err != nil {
			return err
		}
		if err := tx.Model(&models.GasorderItem{}).Where("gasorder_basic_id = ?", order.ID).Update("active", false).Error; err != nil {
			return err
		}
		return tx.Model(&models.GasorderDeposit{}).Where("gasorder_basic_id = ? AND deposit_status = ?", order.ID, common.StatusPending).Update("deposit_status", common.StatusCancelled).Error
	})
	if err != nil {
		infra.Response.Error(ctx, errcode.ErrInvalidArgument)
		return
	}
	infra.Response.Success(ctx, gin.H{"cancelled": true})
}