548 lines
16 KiB
Go
548 lines
16 KiB
Go
package mohong
|
||
|
||
import (
|
||
"context"
|
||
"crypto/rand"
|
||
"encoding/hex"
|
||
"encoding/json"
|
||
"fmt"
|
||
"strings"
|
||
"time"
|
||
|
||
"hfb_sys/backend/internal/model"
|
||
"hfb_sys/backend/internal/modules/notification"
|
||
"hfb_sys/backend/internal/timeutil"
|
||
"hfb_sys/backend/pkg/money"
|
||
|
||
"gorm.io/datatypes"
|
||
"gorm.io/gorm"
|
||
"gorm.io/gorm/clause"
|
||
)
|
||
|
||
func (r *Repository) CreateOrder(ctx context.Context, userID uint64, req CreateOrderRequest) (*OrderDTO, error) {
|
||
if userID == 0 {
|
||
return nil, ErrInvalidRequest
|
||
}
|
||
reqItems := normalizeCreateOrderItems(req)
|
||
if len(reqItems) == 0 {
|
||
return nil, ErrInvalidRequest
|
||
}
|
||
var createdID uint64
|
||
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
itemSnaps := make([]orderItemSnapshot, 0, len(reqItems))
|
||
var totalQty int
|
||
var totalAmount int64
|
||
var primary productSnapshot
|
||
|
||
for _, line := range reqItems {
|
||
var product model.MohongProduct
|
||
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&product, line.ProductID).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return ErrProductNotFound
|
||
}
|
||
return err
|
||
}
|
||
if product.Status != model.MohongProductStatusOnSale || product.PriceCent <= 0 {
|
||
return ErrProductUnavailable
|
||
}
|
||
if product.Stock >= 0 && product.Stock < line.Quantity {
|
||
return ErrStockInsufficient
|
||
}
|
||
// 下单时预扣库存，取消未支付订单时归还。
|
||
if product.Stock >= 0 {
|
||
product.Stock -= line.Quantity
|
||
if err := tx.Save(&product).Error; err != nil {
|
||
return err
|
||
}
|
||
}
|
||
images := decodeStringList(product.ImageURLs)
|
||
item := orderItemSnapshot{
|
||
ID: product.ID,
|
||
Title: product.Title,
|
||
CoverURL: product.CoverURL,
|
||
ImageURLs: images,
|
||
Description: product.Description,
|
||
PriceCent: product.PriceCent,
|
||
Unit: product.Unit,
|
||
QrcodeImageURL: product.QrcodeImageURL,
|
||
Quantity: line.Quantity,
|
||
}
|
||
itemSnaps = append(itemSnaps, item)
|
||
totalQty += line.Quantity
|
||
totalAmount += product.PriceCent * int64(line.Quantity)
|
||
if primary.ID == 0 {
|
||
primary = productSnapshot{
|
||
ID: product.ID, Title: product.Title, CoverURL: product.CoverURL,
|
||
ImageURLs: images, Description: product.Description, PriceCent: product.PriceCent,
|
||
Unit: product.Unit, QrcodeImageURL: product.QrcodeImageURL,
|
||
}
|
||
}
|
||
}
|
||
|
||
orderNo, err := newMohongOrderNo()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
primaryRaw, err := json.Marshal(primary)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
itemsRaw, err := json.Marshal(itemSnaps)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
// 展示字段：单商品保持原语义；多商品 quantity 为合计，unit_price 用首项单价。
|
||
order := model.MohongOrder{
|
||
OrderNo: orderNo,
|
||
UserID: userID,
|
||
ProductID: primary.ID,
|
||
Quantity: totalQty,
|
||
UnitPriceCent: primary.PriceCent,
|
||
AmountCent: totalAmount,
|
||
Status: model.MohongOrderStatusPendingPayment,
|
||
ProductSnapshot: datatypes.JSON(primaryRaw),
|
||
ItemsSnapshot: datatypes.JSON(itemsRaw),
|
||
CopyText: "",
|
||
}
|
||
if err := tx.Create(&order).Error; err != nil {
|
||
return err
|
||
}
|
||
orderID := order.ID
|
||
if err := notification.Append(tx, notification.Entry{
|
||
UserID: userID,
|
||
Type: "order",
|
||
Title: "撞车订单已创建",
|
||
Content: "订单已创建，请在有效时间内完成支付。",
|
||
BizType: "mohong_order",
|
||
BizID: &orderID,
|
||
}); err != nil {
|
||
return err
|
||
}
|
||
createdID = order.ID
|
||
return nil
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return r.FindOrderForUser(ctx, userID, createdID)
|
||
}
|
||
|
||
func normalizeCreateOrderItems(req CreateOrderRequest) []CreateOrderItemRequest {
|
||
// 优先 items；否则兼容旧单商品参数。
|
||
if len(req.Items) > 0 {
|
||
merged := map[uint64]int{}
|
||
orderIDs := make([]uint64, 0, len(req.Items))
|
||
for _, item := range req.Items {
|
||
if item.ProductID == 0 || item.Quantity < 1 || item.Quantity > 99 {
|
||
continue
|
||
}
|
||
if _, ok := merged[item.ProductID]; !ok {
|
||
orderIDs = append(orderIDs, item.ProductID)
|
||
}
|
||
merged[item.ProductID] += item.Quantity
|
||
if merged[item.ProductID] > 99 {
|
||
merged[item.ProductID] = 99
|
||
}
|
||
}
|
||
out := make([]CreateOrderItemRequest, 0, len(orderIDs))
|
||
for _, id := range orderIDs {
|
||
if qty := merged[id]; qty > 0 {
|
||
out = append(out, CreateOrderItemRequest{ProductID: id, Quantity: qty})
|
||
}
|
||
}
|
||
if len(out) > 50 {
|
||
return out[:50]
|
||
}
|
||
return out
|
||
}
|
||
if req.ProductID > 0 && req.Quantity >= 1 && req.Quantity <= 99 {
|
||
return []CreateOrderItemRequest{{ProductID: req.ProductID, Quantity: req.Quantity}}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (r *Repository) FindOrderForUser(ctx context.Context, userID, orderID uint64) (*OrderDTO, error) {
|
||
var row model.MohongOrder
|
||
if err := r.db.WithContext(ctx).Where("id = ? AND user_id = ?", orderID, userID).First(&row).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return nil, ErrOrderNotFound
|
||
}
|
||
return nil, err
|
||
}
|
||
return r.orderDTO(ctx, row, false)
|
||
}
|
||
|
||
func (r *Repository) AdminFindOrder(ctx context.Context, orderID uint64) (*OrderDTO, error) {
|
||
var row model.MohongOrder
|
||
if err := r.db.WithContext(ctx).First(&row, orderID).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return nil, ErrOrderNotFound
|
||
}
|
||
return nil, err
|
||
}
|
||
return r.orderDTO(ctx, row, true)
|
||
}
|
||
|
||
func (r *Repository) ListOrdersForUser(ctx context.Context, userID uint64, query OrderListQuery) (*PaginatedResult, error) {
|
||
query.UserID = userID
|
||
return r.listOrders(ctx, query, false)
|
||
}
|
||
|
||
func (r *Repository) AdminListOrders(ctx context.Context, query OrderListQuery) (*PaginatedResult, error) {
|
||
return r.listOrders(ctx, query, true)
|
||
}
|
||
|
||
func (r *Repository) listOrders(ctx context.Context, query OrderListQuery, includeAdmin bool) (*PaginatedResult, error) {
|
||
if query.Page < 1 {
|
||
query.Page = 1
|
||
}
|
||
if query.PageSize < 1 {
|
||
query.PageSize = 20
|
||
}
|
||
if query.PageSize > 100 {
|
||
query.PageSize = 100
|
||
}
|
||
db := r.db.WithContext(ctx).Model(&model.MohongOrder{})
|
||
if query.UserID > 0 {
|
||
db = db.Where("user_id = ?", query.UserID)
|
||
}
|
||
if status := strings.TrimSpace(query.Status); status != "" {
|
||
db = db.Where("status = ?", status)
|
||
}
|
||
if kw := strings.TrimSpace(query.Keyword); kw != "" {
|
||
like := "%" + kw + "%"
|
||
db = db.Where("order_no LIKE ? OR CAST(id AS CHAR) = ?", like, kw)
|
||
}
|
||
var total int64
|
||
if err := db.Count(&total).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
var rows []model.MohongOrder
|
||
if err := db.Order("id DESC").
|
||
Offset((query.Page - 1) * query.PageSize).
|
||
Limit(query.PageSize).
|
||
Find(&rows).Error; err != nil {
|
||
return nil, err
|
||
}
|
||
items := make([]OrderDTO, 0, len(rows))
|
||
for _, row := range rows {
|
||
dto, err := r.orderDTO(ctx, row, includeAdmin)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
items = append(items, *dto)
|
||
}
|
||
return &PaginatedResult{Items: items, Total: total, Page: query.Page, PageSize: query.PageSize}, nil
|
||
}
|
||
|
||
func (r *Repository) CancelOrder(ctx context.Context, userID, orderID uint64, reason string) (*OrderDTO, error) {
|
||
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
var order model.MohongOrder
|
||
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).
|
||
Where("id = ? AND user_id = ?", orderID, userID).
|
||
First(&order).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return ErrOrderNotFound
|
||
}
|
||
return err
|
||
}
|
||
if order.Status != model.MohongOrderStatusPendingPayment {
|
||
return ErrOrderCannotCancel
|
||
}
|
||
return r.cancelPendingOrderTx(tx, &order, firstNonEmpty(reason, "用户取消"))
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return r.FindOrderForUser(ctx, userID, orderID)
|
||
}
|
||
|
||
func (r *Repository) AdminCancelOrder(ctx context.Context, orderID uint64, reason string) (*OrderDTO, error) {
|
||
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
var order model.MohongOrder
|
||
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, orderID).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return ErrOrderNotFound
|
||
}
|
||
return err
|
||
}
|
||
if order.Status != model.MohongOrderStatusPendingPayment &&
|
||
order.Status != model.MohongOrderStatusPaid &&
|
||
order.Status != model.MohongOrderStatusReceiving {
|
||
return ErrOrderCannotCancel
|
||
}
|
||
if order.Status == model.MohongOrderStatusPendingPayment {
|
||
return r.cancelPendingOrderTx(tx, &order, firstNonEmpty(reason, "后台取消"))
|
||
}
|
||
// 已支付/接待中：仅标记取消（退款后续可接支付退款）。
|
||
now := time.Now()
|
||
order.Status = model.MohongOrderStatusCancelled
|
||
order.CancelledAt = &now
|
||
order.CancelReason = firstNonEmpty(reason, "后台取消")
|
||
return tx.Save(&order).Error
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return r.AdminFindOrder(ctx, orderID)
|
||
}
|
||
|
||
// AdminReceiveOrder 标记订单为接待中（已支付 → 接待中）。
|
||
func (r *Repository) AdminReceiveOrder(ctx context.Context, orderID uint64, remark string) (*OrderDTO, error) {
|
||
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
var order model.MohongOrder
|
||
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, orderID).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return ErrOrderNotFound
|
||
}
|
||
return err
|
||
}
|
||
if order.Status != model.MohongOrderStatusPaid {
|
||
return ErrOrderCannotReceive
|
||
}
|
||
order.Status = model.MohongOrderStatusReceiving
|
||
if strings.TrimSpace(remark) != "" {
|
||
order.AdminRemark = strings.TrimSpace(remark)
|
||
}
|
||
return tx.Save(&order).Error
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return r.AdminFindOrder(ctx, orderID)
|
||
}
|
||
|
||
func (r *Repository) AdminCompleteOrder(ctx context.Context, orderID uint64, remark string) (*OrderDTO, error) {
|
||
err := r.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
||
var order model.MohongOrder
|
||
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, orderID).Error; err != nil {
|
||
if err == gorm.ErrRecordNotFound {
|
||
return ErrOrderNotFound
|
||
}
|
||
return err
|
||
}
|
||
if order.Status != model.MohongOrderStatusPaid && order.Status != model.MohongOrderStatusReceiving {
|
||
return ErrOrderCannotComplete
|
||
}
|
||
now := time.Now()
|
||
order.Status = model.MohongOrderStatusCompleted
|
||
order.CompletedAt = &now
|
||
if strings.TrimSpace(remark) != "" {
|
||
order.AdminRemark = strings.TrimSpace(remark)
|
||
}
|
||
return tx.Save(&order).Error
|
||
})
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return r.AdminFindOrder(ctx, orderID)
|
||
}
|
||
|
||
// ConfirmPaidFromChannelTx 支付成功后推进撞车订单：固化二维码快照与可复制文案。
|
||
// 返回值固定为 0，兼容支付模块会话通知签名（撞车无订单群）。
|
||
func (r *Repository) ConfirmPaidFromChannelTx(tx *gorm.DB, orderID uint64) (uint64, error) {
|
||
var order model.MohongOrder
|
||
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&order, orderID).Error; err != nil {
|
||
return 0, err
|
||
}
|
||
if order.Status == model.MohongOrderStatusPaid ||
|
||
order.Status == model.MohongOrderStatusReceiving ||
|
||
order.Status == model.MohongOrderStatusCompleted {
|
||
return 0, nil
|
||
}
|
||
if order.Status != model.MohongOrderStatusPendingPayment {
|
||
return 0, ErrOrderCannotPay
|
||
}
|
||
|
||
var user model.User
|
||
if err := tx.First(&user, order.UserID).Error; err != nil {
|
||
return 0, err
|
||
}
|
||
items := decodeOrderItems(order)
|
||
snap := decodeProductSnapshot(order.ProductSnapshot)
|
||
qrcodeURL := r.resolveQrcodeURL(tx, resolveOrderQrcode(items, snap))
|
||
copyText := buildCopyText(r.loadCopyTemplate(tx), order, items, snap, user)
|
||
now := time.Now()
|
||
|
||
order.Status = model.MohongOrderStatusPaid
|
||
order.PaidAt = &now
|
||
order.QrcodeURLSnapshot = qrcodeURL
|
||
order.CopyText = copyText
|
||
if err := tx.Save(&order).Error; err != nil {
|
||
return 0, err
|
||
}
|
||
|
||
orderIDCopy := order.ID
|
||
if err := notification.Append(tx, notification.Entry{
|
||
UserID: order.UserID,
|
||
Type: "order",
|
||
Title: "撞车订单支付成功",
|
||
Content: "支付已完成，请在订单详情扫码联系客服，并复制订单信息发送。",
|
||
BizType: "mohong_order",
|
||
BizID: &orderIDCopy,
|
||
}); err != nil {
|
||
return 0, err
|
||
}
|
||
return 0, nil
|
||
}
|
||
|
||
// NotifyNewConversation 兼容支付模块接口；撞车不创建会话，空实现。
|
||
func (r *Repository) NotifyNewConversation(conversationID uint64) {}
|
||
|
||
func (r *Repository) cancelPendingOrderTx(tx *gorm.DB, order *model.MohongOrder, reason string) error {
|
||
// 归还预扣库存（支持多商品行）
|
||
for _, item := range decodeOrderItems(*order) {
|
||
if item.Quantity <= 0 || item.ID == 0 {
|
||
continue
|
||
}
|
||
var product model.MohongProduct
|
||
if err := tx.Clauses(clause.Locking{Strength: "UPDATE"}).First(&product, item.ID).Error; err != nil {
|
||
continue
|
||
}
|
||
if product.Stock >= 0 {
|
||
product.Stock += item.Quantity
|
||
if err := tx.Save(&product).Error; err != nil {
|
||
return err
|
||
}
|
||
}
|
||
}
|
||
now := time.Now()
|
||
order.Status = model.MohongOrderStatusCancelled
|
||
order.CancelledAt = &now
|
||
order.CancelReason = reason
|
||
return tx.Save(order).Error
|
||
}
|
||
|
||
func (r *Repository) orderDTO(ctx context.Context, row model.MohongOrder, includeAdmin bool) (*OrderDTO, error) {
|
||
snap := decodeProductSnapshot(row.ProductSnapshot)
|
||
items := decodeOrderItems(row)
|
||
var nickname, phone string
|
||
var user model.User
|
||
if err := r.db.WithContext(ctx).Select("id", "nickname", "phone").First(&user, row.UserID).Error; err == nil {
|
||
nickname = user.Nickname
|
||
phone = user.Phone
|
||
}
|
||
dto := toOrderDTO(row, snap, items, nickname, phone, includeAdmin)
|
||
return &dto, nil
|
||
}
|
||
|
||
func buildCopyText(template string, order model.MohongOrder, items []orderItemSnapshot, snap productSnapshot, user model.User) string {
|
||
if strings.TrimSpace(template) == "" {
|
||
template = defaultOrderCopyTemplate
|
||
}
|
||
buyerName := strings.TrimSpace(user.Nickname)
|
||
if buyerName == "" {
|
||
buyerName = "用户"
|
||
}
|
||
createdAt := timeutil.ShanghaiNow().Format("2006-01-02 15:04:05")
|
||
if !order.CreatedAt.IsZero() {
|
||
createdAt = order.CreatedAt.In(timeutil.ShanghaiLocation()).Format("2006-01-02 15:04:05")
|
||
}
|
||
productTitle := snap.Title
|
||
if productTitle == "" && len(items) > 0 {
|
||
productTitle = items[0].Title
|
||
}
|
||
if len(items) > 1 {
|
||
productTitle = fmt.Sprintf("%s 等%d种", productTitle, len(items))
|
||
}
|
||
unit := snap.Unit
|
||
if unit == "" && len(items) > 0 {
|
||
unit = items[0].Unit
|
||
}
|
||
replacer := strings.NewReplacer(
|
||
"{{order_no}}", order.OrderNo,
|
||
"{{created_at}}", createdAt,
|
||
"{{product_title}}", productTitle,
|
||
"{{items}}", formatItemsForCopy(items, snap, order.Quantity),
|
||
"{{quantity}}", fmt.Sprintf("%d", order.Quantity),
|
||
"{{amount}}", money.FormatWithSymbol(order.AmountCent),
|
||
"{{buyer_name}}", buyerName,
|
||
"{{buyer_phone}}", maskPhone(user.Phone),
|
||
"{{unit}}", unit,
|
||
)
|
||
return replacer.Replace(template)
|
||
}
|
||
|
||
func formatItemsForCopy(items []orderItemSnapshot, snap productSnapshot, fallbackQty int) string {
|
||
if len(items) == 0 && snap.ID > 0 {
|
||
items = []orderItemSnapshot{{
|
||
ID: snap.ID, Title: snap.Title, PriceCent: snap.PriceCent,
|
||
Unit: snap.Unit, Quantity: fallbackQty,
|
||
}}
|
||
}
|
||
if len(items) == 0 {
|
||
return "-"
|
||
}
|
||
lines := make([]string, 0, len(items))
|
||
for _, item := range items {
|
||
lineAmount := item.PriceCent * int64(item.Quantity)
|
||
unit := strings.TrimSpace(item.Unit)
|
||
if unit == "" {
|
||
unit = "件"
|
||
}
|
||
lines = append(lines, fmt.Sprintf(
|
||
"- %s ×%d%s 单价%s 小计%s",
|
||
item.Title,
|
||
item.Quantity,
|
||
unit,
|
||
money.FormatWithSymbol(item.PriceCent),
|
||
money.FormatWithSymbol(lineAmount),
|
||
))
|
||
}
|
||
return strings.Join(lines, "\n")
|
||
}
|
||
|
||
func decodeOrderItems(order model.MohongOrder) []orderItemSnapshot {
|
||
if len(order.ItemsSnapshot) > 0 {
|
||
var items []orderItemSnapshot
|
||
if err := json.Unmarshal(order.ItemsSnapshot, &items); err == nil && len(items) > 0 {
|
||
return items
|
||
}
|
||
}
|
||
// 兼容旧订单：从 product_snapshot 还原单行
|
||
snap := decodeProductSnapshot(order.ProductSnapshot)
|
||
if snap.ID == 0 && order.ProductID == 0 {
|
||
return nil
|
||
}
|
||
qty := order.Quantity
|
||
if qty < 1 {
|
||
qty = 1
|
||
}
|
||
id := snap.ID
|
||
if id == 0 {
|
||
id = order.ProductID
|
||
}
|
||
price := snap.PriceCent
|
||
if price <= 0 {
|
||
price = order.UnitPriceCent
|
||
}
|
||
return []orderItemSnapshot{{
|
||
ID: id,
|
||
Title: firstNonEmpty(snap.Title, "商品"),
|
||
CoverURL: snap.CoverURL,
|
||
ImageURLs: snap.ImageURLs,
|
||
Description: snap.Description,
|
||
PriceCent: price,
|
||
Unit: snap.Unit,
|
||
QrcodeImageURL: snap.QrcodeImageURL,
|
||
Quantity: qty,
|
||
}}
|
||
}
|
||
|
||
func resolveOrderQrcode(items []orderItemSnapshot, snap productSnapshot) string {
|
||
for _, item := range items {
|
||
if strings.TrimSpace(item.QrcodeImageURL) != "" {
|
||
return item.QrcodeImageURL
|
||
}
|
||
}
|
||
return snap.QrcodeImageURL
|
||
}
|
||
|
||
func newMohongOrderNo() (string, error) {
|
||
var b [4]byte
|
||
if _, err := rand.Read(b[:]); err != nil {
|
||
return "", err
|
||
}
|
||
return fmt.Sprintf("MH%s%s", time.Now().Format("20060102150405"), strings.ToUpper(hex.EncodeToString(b[:]))), nil
|
||
}
|