fix:支付

constants/orders.go

@@ -24,16 +24,16 @@ type PayMethods string
 
 const (
 	PAY_METHOD_CARD PayMethods = "CARD"
-	PayMethodVISA   PayMethods = "VISA"
+	PAY_METHOD_VISA PayMethods = "VISA"
 )
 
 // 支付状态
 type PayStatusCode int64
 
 const (
-	PAYSTATUSUNPAID   PayStatusCode = 10 //10,未支付
-	PAYSTATUSPAID     PayStatusCode = 20 //20,已支付
-	PAYSTATUSREFUNDED PayStatusCode = 30 //30,已退款
+	PAY_STATUS_UNPAID   PayStatusCode = 10 //10,未支付
+	PAY_STATUS_PAID     PayStatusCode = 20 //20,已支付
+	PAY_STATUS_REFUNDED PayStatusCode = 30 //30,已退款
 )
 
 // 订单支付状态
@@ -45,11 +45,11 @@ type OrderPayStatusCode int64
 // 30,已付尾款
 // 40,已退尾款
 const (
-	ORDERPAYSTATUSUNPAIDDEPOSIT     OrderPayStatusCode = 0
-	ORDERPAYSTATUSPAIDDEPOSIT       OrderPayStatusCode = 10
-	ORDERPAYSTATUSREFUNDEDDEPOSIT   OrderPayStatusCode = 20
-	ORDERPAYSTATUSPAIDDREMAINING    OrderPayStatusCode = 30
-	ORDERPAYSTATUSREFUNDEDREMAINING OrderPayStatusCode = 40
+	ORDER_PAY_STATUS_UNPAIDDEPOSIT     OrderPayStatusCode = 0
+	ORDER_PAY_STATUS_PAIDDEPOSIT       OrderPayStatusCode = 10
+	ORDER_PAY_STATUS_REFUNDEDDEPOSIT   OrderPayStatusCode = 20
+	ORDER_PAY_STATUS_PAIDDREMAINING    OrderPayStatusCode = 30
+	ORDER_PAY_STATUS_REFUNDEDREMAINING OrderPayStatusCode = 40
 )
 
 // 订单状态
@@ -88,9 +88,9 @@ var OrderStatusUserCLOUDSTORE []OrderStatusCode
 func init() {
 	// 订单状态名称
 	PayStatusMessage = make(map[PayStatusCode]string)
-	PayStatusMessage[PAYSTATUSUNPAID] = "Unpaid"
-	PayStatusMessage[PAYSTATUSPAID] = "Paid"
-	PayStatusMessage[PAYSTATUSREFUNDED] = "Refunded"
+	PayStatusMessage[PAY_STATUS_UNPAID] = "Unpaid"
+	PayStatusMessage[PAY_STATUS_PAID] = "Paid"
+	PayStatusMessage[PAY_STATUS_REFUNDED] = "Refunded"
 
 	// 订单状态名称
 	OrderStatusMessage = make(map[OrderStatusCode]string)
@@ -111,12 +111,14 @@ func init() {
 
 	// 订单状态--用户可见--直邮
 	OrderStatusUserDIRECTMAIL = []OrderStatusCode{
-		ORDER_STATUS_UNPAIDDEPOSIT, ORDER_STATUS_COMPLETE,
+		ORDER_STATUS_UNPAIDDEPOSIT,
 		ORDER_STATUS_DIRECTMAIL_ORDERED, ORDER_STATUS_DIRECTMAIL_STARTPRODUCTION, ORDER_STATUS_DIRECTMAIL_COMPLETEPRODUCTION, ORDER_STATUS_DIRECTMAIL_SHIPPED, ORDER_STATUS_DIRECTMAIL_ARRIVED,
+		ORDER_STATUS_COMPLETE,
 	}
 	// 订单状态--用户可见--云仓
 	OrderStatusUserCLOUDSTORE = []OrderStatusCode{
-		ORDER_STATUS_UNPAIDDEPOSIT, ORDER_STATUS_COMPLETE,
+		ORDER_STATUS_UNPAIDDEPOSIT,
 		ORDER_STATUS_CLOUDSTORE_ORDERED, ORDER_STATUS_CLOUDSTORE_STARTPRODUCTION, ORDER_STATUS_CLOUDSTORE_COMPLETEPRODUCTION, ORDER_STATUS_CLOUDSTORE_ARRIVEDWAREHOUSE,
+		ORDER_STATUS_COMPLETE,
 	}
 }

model/gmodel/fs_order_gen.go

@@ -18,6 +18,13 @@ type FsOrder struct {
 	Utime                   *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"utime"`     //
 	IsDel                   *int64     `gorm:"default:0;" json:"is_del"`                        // 是否删除：0=否，1=是
 	PayStatus               *int64     `gorm:"default:0;" json:"pay_status"`                    // 支付状态
+	StatusLink              *[]byte    `gorm:"default:'';" json:"status_link"`                  //
+	OrderProduct            *[]byte    `gorm:"default:'';" json:"order_product"`                //
+	OrderAddress            *[]byte    `gorm:"default:'';" json:"order_address"`                //
+	OrderAmount             *[]byte    `gorm:"default:'';" json:"order_amount"`                 //
+	PayStatusLink           *[]byte    `gorm:"default:'';" json:"pay_status_link"`              //
+	ShoppingCartSnapshot    *[]byte    `gorm:"default:'';" json:"shopping_cart_snapshot"`       //
+	ShoppingProductSnapshot *[]byte    `gorm:"default:'';" json:"shopping_product_snapshot"`    //
 }
 type FsOrderModel struct {
 	db   *gorm.DB

model/gmodel/fs_order_logic.go

@@ -73,6 +73,7 @@ type PayStatus struct {
 
 // 订单信息
 type OrderInfo struct {
+	UserId         int64                  `json:"user_id"`         // 物流类型
 	Ctime          *time.Time             `json:"ctime"`           // 创建日期
 	DeliveryMethod int64                  `json:"delivery_method"` // 物流类型
 	Metadata       map[string]interface{} `json:"metadata"`        // 额外参数
@@ -96,16 +97,17 @@ type OrderStatus struct {
 // 订单商品
 type OrderProduct struct {
 	TotalPrice           AmountInfo             `json:"total_price"`            // 商品总价
+	ItemPrice            AmountInfo             `json:"item_price"`             // 商品单价
 	ExpectedDeliveryTime *time.Time             `json:"expected_delivery_time"` // 预计到货时间
 	PurchaseQuantity     PurchaseQuantity       `json:"purchase_quantity"`      // 购买数量
-	ProductID            int64                    `json:"product_id"`             // 商品ID
+	ProductId            int64                  `json:"product_id"`             // 商品ID
+	ProductSn            string                 `json:"product_sn"`             // 商品编码
 	ProductName          string                 `json:"product_name"`           // 商品名称
-	ItemPrice            AmountInfo               `json:"item_price"`             // 商品单价
-	ProductSnapshot      interface{}              `json:"product_snapshot"`       // 商品快照
-	ShoppingCartSnapshot *FsShoppingCartData      `json:"shopping_cart_snapshot"` // 购物车快照
 	ProductCover         string                 `json:"product_cover"`          // 商品封面
 	ProductCoverMetadata map[string]interface{} `json:"product_cover_metadata"` // 商品封面
-	ProductSn            string                   `json:"product_sn"`             // 商品编码
+	ProductSnapshot      interface{}            `json:"product_snapshot"`       // 商品快照
+	ShoppingCartSnapshot *FsShoppingCartData    `json:"shopping_cart_snapshot"` // 购物车快照
+
 	DiyInformation     *UserDiyInformation      `json:"diy_information"`
 	SizeInfo           *OrderProductSizeInfo    `json:"size_info"`
 	FittingInfo        *OrderProductFittingInfo `json:"fitting_info"`
@@ -131,3 +133,24 @@ type OrderProductFittingInfo struct {
 	FittingID   int64  `json:"fitting_id"`   //配件ID
 	FittingName string `json:"fitting_name"` //配件名称
 }
+
+type ExpectedDelivery struct {
+	Current  time.Time `json:"current"`
+	Initiate time.Time `json:"initiate"`
+}
+
+type OrderProductInter struct {
+	TotalPrice           AmountInfo               `json:"total_price"`            // 商品总价
+	ItemPrice            AmountInfo               `json:"item_price"`             // 商品单价
+	ExpectedDelivery     *ExpectedDelivery        `json:"expected_delivery"`      // 预计到货
+	PurchaseQuantity     *PurchaseQuantity        `json:"purchase_quantity"`      // 购买数量
+	ProductId            int64                    `json:"product_id"`             // 商品ID
+	ProductName          string                   `json:"product_name"`           // 商品名称
+	ProductCover         string                   `json:"product_cover"`          // 商品封面
+	ProductCoverMetadata map[string]interface{}   `json:"product_cover_metadata"` // 商品封面
+	ProductSn            string                   `json:"product_sn"`             // 商品编码
+	DiyInformation       *UserDiyInformation      `json:"diy_information"`
+	SizeInfo             *OrderProductSizeInfo    `json:"size_info"`
+	FittingInfo          *OrderProductFittingInfo `json:"fitting_info"`
+	IsHighlyCustomized   int64                    `json:"is_highly_customized"`
+}

model/gmodel/fs_product_model3d_gen.go

@@ -23,7 +23,7 @@ type FsProductModel3d struct {
 	Status         *int64     `gorm:"default:0;" json:"status"`                        // 状态位 显示 删除
 	Ctime          *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"`     //
 	OptionTemplate *int64     `gorm:"default:0;" json:"option_template"`               // 配件绑定的公共模板
-	Price          *int64     `gorm:"default:0;" json:"price"`                         //
+	Price          *int64     `gorm:"default:0;" json:"price"`                         // 仅配件用，配件的价格, 单位：0.1美分
 	Sku            *string    `gorm:"default:'';" json:"sku"`                          // sku
 	IsHot          *int64     `gorm:"default:0;" json:"is_hot"`                        // 是否热门
 	IsCloudRender  *int64     `gorm:"default:0;" json:"is_cloud_render"`               // 是否设置为云渲染模型

model/gmodel/fs_shopping_cart_logic.go

@@ -27,7 +27,6 @@ type FsShoppingCartData struct {
 	FittingId          *int64                  `gorm:"default:0;" json:"fitting_id"`                    // 配件id
 	PurchaseQuantity   *int64                  `gorm:"default:0;" json:"purchase_quantity"`             // 购买数量
 	Snapshot           *map[string]interface{} `gorm:"default:'';" json:"snapshot"`                     //
-	SnapshotData       *string                 `gorm:"default:'';" json:"snapshot_data"`                //
 	IsSelected         *int64                  `gorm:"default:0;" json:"is_selected"`                   // 是否被选中 0非 1是
 	IsHighlyCustomized *int64                  `gorm:"default:0;" json:"is_highly_customized"`          // 是否高度定制 0非 1是（针对客人高度定制只能后台增加如购物车）
 	Ctime              *time.Time              `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"`     //

server/order/internal/logic/createorderlogic.go

@@ -40,7 +40,7 @@ func (l *CreateOrderLogic) CreateOrder(req *types.CreateOrderReq, userinfo *auth
 		// 如果是，返回未授权的错误码
 		return resp.SetStatus(basic.CodeUnAuth)
 	}
-	tPlus60Days := time.Now().AddDate(0, 0, 60)
+	tPlus60Days := time.Now().AddDate(0, 0, 60).UTC()
 	res, err := l.svcCtx.Repositories.NewOrder.Create(l.ctx, &repositories.CreateReq{
 		ExpectedDeliveryTime: tPlus60Days,
 		CurrentCurrency:      string(constants.CURRENCYUSD),

server/shopping-cart/shopping-cart_test.go

@@ -0,0 +1,7 @@
+package main
+
+import "testing"
+
+func TestMain(t *testing.T) {
+	main()
+}

service/repositories/order.go

@@ -8,7 +8,6 @@ import (
 	"fusenapi/constants"
 	"fusenapi/model/gmodel"
 	"fusenapi/utils/basic"
-	"fusenapi/utils/fssql"
 	"fusenapi/utils/handlers"
 	"fusenapi/utils/order"
 	"fusenapi/utils/pay"
@@ -141,7 +140,17 @@ type (
 	DetailRes struct {
 		ErrorCode           basic.StatusResponse
 		OrderDetail         gmodel.OrderDetail
-		OrderDetailOriginal gmodel.OrderDetail
+		OrderDetailOriginal OrderDetailOriginal
+	}
+	OrderDetailOriginal struct {
+		Status                  *gmodel.OrderStatus
+		OrderAmount             *gmodel.OrderAmount
+		OrderAddress            *gmodel.OrderAddress
+		OrderProduct            []gmodel.OrderProductInter
+		ShoppingCartSnapshot    []gmodel.FsShoppingCart
+		ShoppingProductSnapshot []gmodel.RelaFsProduct
+		StatusLink              []gmodel.OrderStatus
+		PayStatusLink           []gmodel.PayStatus
 	}
 	/* 详情 */
 
@@ -234,14 +243,15 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
 			return err
 		}
 		var ntime = time.Now().UTC()
-		if (payStage == "deposit" && *orderInfo.PayStatus == int64(constants.ORDERPAYSTATUSUNPAIDDEPOSIT)) || (payStage == "remaining_balance" && *orderInfo.PayStatus == int64(constants.ORDERPAYSTATUSPAIDDEPOSIT)) {
-			var payStatus = int64(constants.PAYSTATUSPAID)
+		if (payStage == "deposit" && *orderInfo.PayStatus == int64(constants.ORDER_PAY_STATUS_UNPAIDDEPOSIT)) || (payStage == "remaining_balance" && *orderInfo.PayStatus == int64(constants.ORDER_PAY_STATUS_PAIDDEPOSIT)) {
+			var payStatus = int64(constants.PAY_STATUS_PAID)
 			var payStageInt int64
 			var orderPayStatusCode constants.OrderPayStatusCode
 			// 订单状态--当前
 			var status gmodel.OrderStatus
 			var statusLink []gmodel.OrderStatus
-			var uOrderDetail = make(map[string]interface{})
+			var payStatusLink []gmodel.PayStatus
+			var orderAmount = make(map[string]interface{})
 			var payInfo PayInfo
 			payInfo.PayMethod = in.PaymentMethod
 			payInfo.PayTime = payTime
@@ -259,29 +269,26 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
 					statusCode = constants.ORDER_STATUS_CLOUDSTORE_ORDERED
 				}
 				payStageInt = 1
-				orderPayStatusCode = constants.ORDERPAYSTATUSPAIDDEPOSIT
+				orderPayStatusCode = constants.ORDER_PAY_STATUS_PAIDDEPOSIT
 				status = gmodel.OrderStatus{
 					Ctime:       &ntime,
 					Utime:       &ntime,
 					StatusCode:  statusCode,
 					StatusTitle: constants.OrderStatusMessage[statusCode],
 				}
-				statusLink = order.UpdateOrderStatusLink(ress.OrderDetailOriginal.OrderInfo.StatusLink, gmodel.OrderStatus{
+				statusLink = order.UpdateOrderStatusLink(ress.OrderDetailOriginal.StatusLink, gmodel.OrderStatus{
 					Ctime:       &ntime,
 					Utime:       &ntime,
 					StatusCode:  statusCode,
 					StatusTitle: constants.OrderStatusMessage[statusCode],
 				})
 				payInfo.Status = gmodel.PayStatus{
-					StatusCode:  int64(constants.PAYSTATUSPAID),
-					StatusTitle: constants.PayStatusMessage[constants.PAYSTATUSPAID],
-				}
-				payInfo.StatusLink = append(ress.OrderDetail.OrderAmount.Deposit.StatusLink, payInfo.Status)
-				uOrderDetail["order_amount"] = struct {
-					Deposit PayInfo `json:"deposit"`
-				}{
-					Deposit: payInfo,
+					StatusCode:  int64(constants.PAY_STATUS_PAID),
+					StatusTitle: constants.PayStatusMessage[constants.PAY_STATUS_PAID],
 				}
+				payInfo.StatusLink = append(ress.OrderDetailOriginal.OrderAmount.Deposit.StatusLink, payInfo.Status)
+				payStatusLink = payInfo.StatusLink
+				orderAmount["deposit"] = payInfo
 			}
 			if payStage == "remaining_balance" {
 				if *orderInfo.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL {
@@ -295,11 +302,11 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
 					statusCode = constants.ORDER_STATUS_CLOUDSTORE_ORDEREDMAINING
 				}
 				payStageInt = 2
-				orderPayStatusCode = constants.ORDERPAYSTATUSPAIDDREMAINING
+				orderPayStatusCode = constants.ORDER_PAY_STATUS_PAIDDREMAINING
 
 				var statusChildren []*gmodel.OrderStatus
 				// 更新订单状态链路--子状态
-				for oStatusLinkKey, oStatusLink := range ress.OrderDetail.OrderInfo.StatusLink {
+				for oStatusLinkKey, oStatusLink := range ress.OrderDetailOriginal.StatusLink {
 					if oStatusLink.StatusCode == statusCodePre {
 						statusChildren = append(oStatusLink.Children, &gmodel.OrderStatus{
 							Ctime:       &ntime,
@@ -307,26 +314,41 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
 							StatusCode:  statusCode,
 							StatusTitle: constants.OrderStatusMessage[statusCode],
 						})
-						ress.OrderDetail.OrderInfo.StatusLink[oStatusLinkKey].Children = statusChildren
+						ress.OrderDetailOriginal.StatusLink[oStatusLinkKey].Children = statusChildren
 					}
 				}
-				statusLink = ress.OrderDetail.OrderInfo.StatusLink
+				statusLink = ress.OrderDetailOriginal.StatusLink
 
-				if ress.OrderDetail.OrderInfo.Status.StatusCode == constants.ORDER_STATUS_DIRECTMAIL_ORDERED || ress.OrderDetail.OrderInfo.Status.StatusCode == constants.ORDER_STATUS_CLOUDSTORE_ORDERED {
-					status = ress.OrderDetail.OrderInfo.Status
+				if ress.OrderDetailOriginal.Status.StatusCode == constants.ORDER_STATUS_DIRECTMAIL_ORDERED || ress.OrderDetailOriginal.Status.StatusCode == constants.ORDER_STATUS_CLOUDSTORE_ORDERED {
+					status = *ress.OrderDetailOriginal.Status
 					status.Children = statusChildren
 				}
 				payInfo.Status = gmodel.PayStatus{
-					StatusCode:  int64(constants.PAYSTATUSPAID),
-					StatusTitle: constants.PayStatusMessage[constants.PAYSTATUSPAID],
+					StatusCode:  int64(constants.PAY_STATUS_PAID),
+					StatusTitle: constants.PayStatusMessage[constants.PAY_STATUS_PAID],
 				}
 
-				payInfo.StatusLink = append(ress.OrderDetail.OrderAmount.RemainingBalance.StatusLink, payInfo.Status)
-				uOrderDetail["order_amount"] = struct {
-					RemainingBalance PayInfo `json:"remaining_balance"`
-				}{
-					RemainingBalance: payInfo,
+				payInfo.StatusLink = append(ress.OrderDetailOriginal.OrderAmount.RemainingBalance.StatusLink, payInfo.Status)
+				payStatusLink = payInfo.StatusLink
+				orderAmount["remaining_balance"] = payInfo
 			}
+
+			orderAmountByte, err := json.Marshal(orderAmount)
+			if err != nil {
+				logc.Errorf(ctx, "PaymentSuccessful failed Marshal orderAmount,eventId:%s, err: %v", in.EventId, err)
+				return err
+			}
+
+			statusLinkByte, err := json.Marshal(statusLink)
+			if err != nil {
+				logc.Errorf(ctx, "PaymentSuccessful failed Marshal statusLink,eventId:%s, err: %v", in.EventId, err)
+				return err
+			}
+
+			payStatusLinkByte, err := json.Marshal(payStatusLink)
+			if err != nil {
+				logc.Errorf(ctx, "PaymentSuccessful failed Marshal payStatusLink,eventId:%s, err: %v", in.EventId, err)
+				return err
 			}
 
 			// 新增交易信息
@@ -347,34 +369,24 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
 				Utime:         &ntime,
 				PayTitle:      &payTitle,
 			})
-			var sql string
-			if *orderInfo.Status == int64(constants.ORDER_STATUS_UNPAIDDEPOSIT) {
-				sql = fmt.Sprintf(", `utime` = '%s', `pay_status` = %d, `status` = %d ", ntime, orderPayStatusCode, statusCode)
-			} else {
-				sql = fmt.Sprintf(", `utime` = '%s', `pay_status` = %d", ntime, orderPayStatusCode)
-			}
 
-			// 更新订单信息
-			uOrderDetail["pay_status"] = orderPayStatusCode
-			uOrderDetail["order_info"] = struct {
-				Utime      *time.Time           `json:"utime"`
-				Status     gmodel.OrderStatus   `json:"status"`
-				StatusLink []gmodel.OrderStatus `json:"status_link"`
-			}{
-				Utime:      &ntime,
-				Status:     status,
-				StatusLink: statusLink,
+			// 更新数据库
+			var table = gmodel.NewAllModels(d.MysqlConn).FsOrder.TableName()
+			var resUpdate *gorm.DB
+			var resUpdateSql string
+			if *orderInfo.Status == int64(constants.ORDER_STATUS_UNPAIDDEPOSIT) {
+				resUpdateSql = fmt.Sprintf("UPDATE %s SET `status` = %d,`pay_status` = %d , `utime` = '%s'", table, statusCode, orderPayStatusCode, ntime)
+			} else {
+				resUpdateSql = fmt.Sprintf("UPDATE %s SET `pay_status` = %d , `utime` = '%s'", table, orderPayStatusCode, ntime)
 			}
-			fmt.Printf("uOrderDetail :%+v", uOrderDetail)
-			if len(uOrderDetail) > 0 {
-				err = fssql.MetadataOrderPATCH(d.MysqlConn, sql, orderSn, gmodel.FsOrder{}, uOrderDetail, "id = ?", orderInfo.Id)
+			resUpdate = d.MysqlConn.Exec(fmt.Sprintf("%s ,`status_link`= JSON_MERGE_PATCH(`status_link`,?),`pay_status_link`= JSON_MERGE_PATCH(`pay_status_link`,?),`order_amount`= JSON_MERGE_PATCH(`order_amount`,?) WHERE `id` = %d", resUpdateSql, orderInfo.Id), statusLinkByte, payStatusLinkByte, orderAmountByte)
+
+			err = resUpdate.Error
 			if err != nil {
-					logc.Errorf(ctx, "PaymentSuccessful failed MetadataOrderPATCH,eventId:%s, err: %v", in.EventId, err)
+				logc.Errorf(ctx, "PaymentSuccessful failed resUpdate,eventId:%s, err: %v", in.EventId, err)
 				return err
 			}
 		}
-
-		}
 		return nil
 	})
 	return &PaymentSuccessfulRes{}, nil
@@ -383,7 +395,7 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
 // 预支付--尾款
 func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *CreatePrePaymentByBalanceReq) (res *CreatePrePaymentByBalanceRes, err error) {
 	var errorCode basic.StatusResponse
-	var order gmodel.FsOrder
+	var orderInfo gmodel.FsOrder
 	model := d.MysqlConn.Where("is_del = ?", 0)
 	if in.UserId != 0 {
 		model.Where("user_id = ?", in.UserId)
@@ -391,7 +403,7 @@ func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *Create
 	if in.OrderSn != "" {
 		model.Where("order_sn = ?", in.OrderSn)
 	}
-	result := model.Take(&order)
+	result := model.Take(&orderInfo)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			errorCode = *basic.CodeErrOrderCreatePrePaymentInfoNoFound
@@ -404,7 +416,7 @@ func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *Create
 		}, result.Error
 	}
 	// 非未支付
-	if *order.PayStatus != int64(constants.ORDERPAYSTATUSPAIDDEPOSIT) {
+	if *orderInfo.PayStatus != int64(constants.ORDER_PAY_STATUS_PAIDDEPOSIT) {
 		errorCode = *basic.CodeErrOrderCreatePrePaymentNoUnPaid
 		err = errors.New("order balance pay status is not unPaid")
 		logc.Errorf(ctx, "create prePayment balance failed, err: %v", err)
@@ -413,7 +425,7 @@ func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *Create
 		}, err
 	}
 
-	ress, err := d.OrderDetailHandler(ctx, &order, 1)
+	ress, err := d.OrderDetailHandler(ctx, &orderInfo, 1)
 	if err != nil {
 		logc.Errorf(ctx, "create prePayment balance failed DetailOrderDetailHandler, err: %v", err)
 		errorCode = *basic.CodeServiceErr
@@ -469,7 +481,7 @@ func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *Create
 // 预支付--定金
 func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *CreatePrePaymentByDepositReq) (res *CreatePrePaymentByDepositRes, err error) {
 	var errorCode basic.StatusResponse
-	var order gmodel.FsOrder
+	var orderInfo gmodel.FsOrder
 	model := d.MysqlConn.Where("is_del = ?", 0)
 	if in.UserId != 0 {
 		model.Where("user_id = ?", in.UserId)
@@ -477,7 +489,7 @@ func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *Create
 	if in.OrderSn != "" {
 		model.Where("order_sn = ?", in.OrderSn)
 	}
-	result := model.Take(&order)
+	result := model.Take(&orderInfo)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			errorCode = *basic.CodeErrOrderCreatePrePaymentInfoNoFound
@@ -491,7 +503,7 @@ func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *Create
 	}
 
 	// 非未支付
-	if *order.PayStatus != int64(constants.ORDERPAYSTATUSUNPAIDDEPOSIT) {
+	if *orderInfo.PayStatus != int64(constants.ORDER_PAY_STATUS_UNPAIDDEPOSIT) {
 		errorCode = *basic.CodeErrOrderCreatePrePaymentNoUnPaid
 		err = errors.New("order pay status is not unPaidDeposit")
 		logc.Errorf(ctx, "create prePayment deposit failed, err: %v", err)
@@ -502,7 +514,7 @@ func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *Create
 
 	// 是否超时支付
 	ntime := time.Now().UTC()
-	ctime := *order.Ctime
+	ctime := *orderInfo.Ctime
 	ctimeTimeOut := ctime.Add(30 * time.Minute).UTC().Unix()
 	ntimeTimeOut := ntime.Unix()
 
@@ -516,7 +528,7 @@ func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *Create
 		}, err
 	}
 
-	ress, err := d.OrderDetailHandler(ctx, &order, 0)
+	ress, err := d.OrderDetailHandler(ctx, &orderInfo, 1)
 	if err != nil {
 		logc.Errorf(ctx, "create prePayment deposit failed DetailOrderDetailHandler, err: %v", err)
 		errorCode = *basic.CodeServiceErr
@@ -525,62 +537,57 @@ func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *Create
 		}, err
 	}
 
-	var uOrderDetail = make(map[string]interface{})
-
 	var orderAddress *gmodel.OrderAddress
+	var orderAddressByte []byte
+	var statusLinkByte []byte
+
 	if in.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL {
 		orderAddress = &gmodel.OrderAddress{
 			Name:    in.DeliveryAddress.Name,
 			Mobile:  in.DeliveryAddress.Mobile,
 			Address: in.DeliveryAddress.Address,
 		}
-	}
-
-	var sql string = fmt.Sprintf(", `utime` = '%s'", ntime)
-	// 是否更新
-	if in.DeliveryMethod != *order.DeliveryMethod {
-		sql = sql + fmt.Sprintf(",`delivery_method` = %d", in.DeliveryMethod)
-		if in.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL {
-			uOrderDetail["delivery_address"] = orderAddress
-		} else {
-			uOrderDetail["delivery_address"] = nil
-		}
-		uOrderDetail["order_info"] = struct {
-			DeliveryMethod int64      `json:"delivery_method"`
-			Utime          *time.Time `json:"utime"`
-		}{
-			DeliveryMethod: in.DeliveryMethod,
-			Utime:          &ntime,
-		}
-	} else {
-		if in.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL {
-			// 更新收货地址
-			if orderAddress != nil {
-				uOrderDetail["delivery_address"] = orderAddress
-				uOrderDetail["order_info"] = struct {
-					DeliveryMethod int64      `json:"delivery_method"`
-					Utime          *time.Time `json:"utime"`
-				}{
-					DeliveryMethod: in.DeliveryMethod,
-					Utime:          &ntime,
-				}
-			}
-		}
-	}
-
-	if len(uOrderDetail) > 0 {
-		err = fssql.MetadataOrderPATCH(d.MysqlConn, sql, in.OrderSn, gmodel.FsOrder{}, uOrderDetail, "id = ?", order.Id)
+		orderAddressByte, err = json.Marshal(orderAddress)
 		if err != nil {
+			logc.Errorf(ctx, "create prePayment deposit failed orderAddressByte, err: %v", err)
 			errorCode = *basic.CodeServiceErr
-			logc.Errorf(ctx, "create prePayment deposit failed MetadataOrderPATCH, err: %v", err)
 			return &CreatePrePaymentByDepositRes{
 				ErrorCode: errorCode,
-			}, result.Error
+			}, err
 		}
 	}
+	// 订单状态--链路
+	tPlus60Days := ntime.AddDate(0, 0, 60).UTC()
+	var statusLink = order.GenerateOrderStatusLink(in.DeliveryMethod, ntime, tPlus60Days)
+	statusLinkByte, err = json.Marshal(statusLink)
+	if err != nil {
+		logc.Errorf(ctx, "create prePayment deposit failed statusLinkByte, err: %v", err)
+		errorCode = *basic.CodeServiceErr
+		return &CreatePrePaymentByDepositRes{
+			ErrorCode: errorCode,
+		}, err
+	}
+
+	// 更新数据库
+	var table = gmodel.NewAllModels(d.MysqlConn).FsOrder.TableName()
+	var resUpdate *gorm.DB
+	if in.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL {
+		resUpdate = d.MysqlConn.Exec(fmt.Sprintf("UPDATE %s SET `order_address` = JSON_MERGE_PATCH(`order_address`,?),`status_link` = JSON_MERGE_PATCH(`status_link`,?), `delivery_method` = ? , `utime` = ? WHERE `id` = ?", table), orderAddressByte, statusLinkByte, in.DeliveryMethod, ntime, orderInfo.Id)
+	} else {
+		resUpdate = d.MysqlConn.Exec(fmt.Sprintf("UPDATE %s SET `delivery_method` = ? , `utime` = ? WHERE `id` = ?", table), in.DeliveryMethod, ntime, orderInfo.Id)
+	}
+	err = resUpdate.Error
+	if err != nil {
+		logc.Errorf(ctx, "create prePayment deposit failed update Exec, err: %v", err)
+		errorCode = *basic.CodeServiceErr
+		return &CreatePrePaymentByDepositRes{
+			ErrorCode: errorCode,
+		}, err
+	}
 
 	ress.OrderDetail.OrderInfo.Utime = &ntime
 	ress.OrderDetail.OrderInfo.DeliveryMethod = in.DeliveryMethod
+	ress.OrderDetail.OrderInfo.StatusLink = statusLink
 	ress.OrderDetail.DeliveryAddress = orderAddress
 
 	// 支付初始化
@@ -691,7 +698,7 @@ func (d *defaultOrder) List(ctx context.Context, in *ListReq) (res *ListRes, err
 // 详情
 func (d *defaultOrder) Detail(ctx context.Context, in *DetailReq) (res *DetailRes, err error) {
 	var errorCode basic.StatusResponse
-	var order gmodel.FsOrder
+	var orderInfo gmodel.FsOrder
 	model := d.MysqlConn.Where("is_del = ?", 0)
 	if in.UserId != 0 {
 		model.Where("user_id = ?", in.UserId)
@@ -699,7 +706,7 @@ func (d *defaultOrder) Detail(ctx context.Context, in *DetailReq) (res *DetailRe
 	if in.OrderSn != "" {
 		model.Where("order_sn = ?", in.OrderSn)
 	}
-	result := model.Take(&order)
+	result := model.Take(&orderInfo)
 	if result.Error != nil {
 		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
 			errorCode = *basic.CodeErrOrderCreatePrePaymentInfoNoFound
@@ -727,7 +734,7 @@ func (d *defaultOrder) Detail(ctx context.Context, in *DetailReq) (res *DetailRe
 	// 	}
 	// }
 
-	ress, err := d.OrderDetailHandler(ctx, &order, 1)
+	ress, err := d.OrderDetailHandler(ctx, &orderInfo, 1)
 	if err != nil {
 		logc.Errorf(ctx, "order detail failed, err: %v", err)
 		errorCode = *basic.CodeServiceErr
@@ -774,7 +781,9 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 		}
 
 		// 订单商品列表
-		var orderProductList []gmodel.OrderProduct
+		var orderProductList []*gmodel.OrderProductInter
+		var shoppingProductSnapshotList []*gmodel.RelaFsProduct
+		var shoppingCartSnapshotList []*gmodel.FsShoppingCart
 
 		var shippingFee gmodel.AmountInfo
 		// 订单税费总价（厘）
@@ -802,7 +811,9 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 		var orderAddress *gmodel.OrderAddress
 
 		// 支付状态
-		var payStatus = constants.ORDERPAYSTATUSUNPAIDDEPOSIT
+		var payStatus = constants.ORDER_PAY_STATUS_UNPAIDDEPOSIT
+		// 订单状态
+		var status = constants.ORDER_STATUS_UNPAIDDEPOSIT
 
 		// 直邮
 		if in.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL {
@@ -854,32 +865,8 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 			if shoppingCart.ShoppingCartProduct.CoverResource != nil && shoppingCart.ShoppingCartProduct.CoverResource.Metadata != nil {
 				json.Unmarshal(*shoppingCart.ShoppingCartProduct.CoverResource.Metadata, &productCoverMetadata)
 			}
-			snapshot, err := d.OrderDetailSnapshotHandler(ctx, shoppingCart.FsShoppingCart.Snapshot)
-			if err != nil {
-				return err
-			}
-			var shoppingCartSnapshotInter = &gmodel.FsShoppingCartData{
-				Id:                 shoppingCart.FsShoppingCart.Id,
-				UserId:             shoppingCart.FsShoppingCart.UserId,
-				ProductId:          shoppingCart.FsShoppingCart.ProductId,
-				TemplateId:         shoppingCart.FsShoppingCart.TemplateId,
-				ModelId:            shoppingCart.FsShoppingCart.ModelId,
-				SizeId:             shoppingCart.FsShoppingCart.SizeId,
-				LightId:            shoppingCart.FsShoppingCart.LightId,
-				FittingId:          shoppingCart.FsShoppingCart.FittingId,
-				PurchaseQuantity:   shoppingCart.FsShoppingCart.PurchaseQuantity,
-				Snapshot:           &snapshot,
-				SnapshotData:       shoppingCart.FsShoppingCart.Snapshot,
-				IsSelected:         shoppingCart.FsShoppingCart.IsSelected,
-				IsHighlyCustomized: shoppingCart.FsShoppingCart.IsHighlyCustomized,
-				Ctime:              shoppingCart.FsShoppingCart.Ctime,
-				Utime:              shoppingCart.FsShoppingCart.Utime,
-			}
-			var purchaseQuantityInter = gmodel.PurchaseQuantity{
-				Current:  *shoppingCart.PurchaseQuantity,
-				Initiate: *shoppingCart.PurchaseQuantity,
-			}
-			productInter := gmodel.OrderProduct{
+
+			productInter := gmodel.OrderProductInter{
 				TotalPrice: order.GetAmountInfo(order.GetAmountInfoReq{
 					ExchangeRate:     in.ExchangeRate,
 					Initiate:         productTotalPrice,
@@ -887,12 +874,6 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 					CurrentCurrency:  in.CurrentCurrency,
 					OriginalCurrency: in.OriginalCurrency,
 				}),
-				ExpectedDeliveryTime: &in.ExpectedDeliveryTime,
-				PurchaseQuantity:     purchaseQuantityInter,
-				ProductID:            *shoppingCart.ProductId,
-				ProductCover:         *shoppingCart.ShoppingCartProduct.Cover,
-				ProductCoverMetadata: productCoverMetadata,
-				ProductName:          *shoppingCart.ShoppingCartProduct.Title,
 				ItemPrice: order.GetAmountInfo(order.GetAmountInfoReq{
 					ExchangeRate:     in.ExchangeRate,
 					Initiate:         productPrice,
@@ -900,8 +881,19 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 					CurrentCurrency:  in.CurrentCurrency,
 					OriginalCurrency: in.OriginalCurrency,
 				}),
-				ProductSnapshot:      shoppingCart.ShoppingCartProduct,
-				ShoppingCartSnapshot: shoppingCartSnapshotInter,
+				ExpectedDelivery: &gmodel.ExpectedDelivery{
+					Current:  in.ExpectedDeliveryTime,
+					Initiate: in.ExpectedDeliveryTime,
+				},
+				PurchaseQuantity: &gmodel.PurchaseQuantity{
+					Current:  *shoppingCart.PurchaseQuantity,
+					Initiate: *shoppingCart.PurchaseQuantity,
+				},
+				ProductId:            *shoppingCart.ProductId,
+				ProductCover:         *shoppingCart.ShoppingCartProduct.Cover,
+				ProductCoverMetadata: productCoverMetadata,
+				ProductName:          *shoppingCart.ShoppingCartProduct.Title,
+
 				ProductSn:      *shoppingCart.ShoppingCartProduct.Sn,
 				DiyInformation: &shoppingCartSnapshot.UserDiyInformation,
 				FittingInfo: &gmodel.OrderProductFittingInfo{
@@ -918,7 +910,9 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 				},
 				IsHighlyCustomized: *shoppingCart.IsHighlyCustomized,
 			}
-			orderProductList = append(orderProductList, productInter)
+			orderProductList = append(orderProductList, &productInter)
+			shoppingProductSnapshotList = append(shoppingProductSnapshotList, shoppingCart.ShoppingCartProduct)
+			shoppingCartSnapshotList = append(shoppingCartSnapshotList, &shoppingCart.FsShoppingCart)
 		}
 
 		subtotal = order.GetAmountInfo(order.GetAmountInfoReq{
@@ -941,8 +935,8 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 		var depositInt int64 = orderTotal / 2
 		var deposit = gmodel.PayInfo{
 			Status: gmodel.PayStatus{
-				StatusCode:  int64(constants.PAYSTATUSUNPAID),
-				StatusTitle: constants.PayStatusMessage[constants.PAYSTATUSUNPAID],
+				StatusCode:  int64(constants.PAY_STATUS_UNPAID),
+				StatusTitle: constants.PayStatusMessage[constants.PAY_STATUS_UNPAID],
 			},
 			StatusLink: make([]gmodel.PayStatus, 0),
 			PayAmount: order.GetAmountInfo(order.GetAmountInfoReq{
@@ -958,8 +952,8 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 		var remainingBalanceInt int64 = orderTotal - depositInt
 		var remainingBalance = gmodel.PayInfo{
 			Status: gmodel.PayStatus{
-				StatusCode:  int64(constants.PAYSTATUSUNPAID),
-				StatusTitle: constants.PayStatusMessage[constants.PAYSTATUSUNPAID],
+				StatusCode:  int64(constants.PAY_STATUS_UNPAID),
+				StatusTitle: constants.PayStatusMessage[constants.PAY_STATUS_UNPAID],
 			},
 			StatusLink: make([]gmodel.PayStatus, 0),
 			PayAmount: order.GetAmountInfo(order.GetAmountInfoReq{
@@ -980,56 +974,40 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 			Total:            total,
 		}
 
-		// 订单状态--当前
-		var status = gmodel.OrderStatus{
-			Ctime:       &nowTime,
-			Utime:       &nowTime,
-			StatusCode:  constants.ORDER_STATUS_UNPAIDDEPOSIT,
-			StatusTitle: constants.OrderStatusMessage[constants.ORDER_STATUS_UNPAIDDEPOSIT],
-		}
 		// 订单状态--链路
 		var statusLink = order.GenerateOrderStatusLink(in.DeliveryMethod, nowTime, in.ExpectedDeliveryTime)
-		var orderInfo = gmodel.OrderInfo{
-			Ctime:          &nowTime,
-			DeliveryMethod: in.DeliveryMethod,
-			OrderSn:        orderSn,
-			Status:         status,
-			StatusLink:     statusLink,
-		}
 
-		var orderDetail = gmodel.OrderDetail{
-			DeliveryAddress: orderAddress,
-			OrderAmount:     orderAmount,
-			OrderInfo:       orderInfo,
-			OrderProduct:    orderProductList,
-			PayStatus:       payStatus,
-			PayTimeout:      30 * time.Minute,
-		}
+		byteOrderProduct, _ := json.Marshal(orderProductList)
+		byteOrderAddress, _ := json.Marshal(orderAddress)
+		byteOrderAmount, _ := json.Marshal(orderAmount)
+		byteShoppingCartSnapshot, _ := json.Marshal(shoppingCartSnapshotList)
+		byteShoppingProductSnapshot, _ := json.Marshal(shoppingProductSnapshotList)
+		byteStatusLink, _ := json.Marshal(statusLink)
 
-		// 数据库操作
-		orderDetailByte, err := json.Marshal(orderDetail)
-		if err != nil {
-			return err
-		}
-		var order = gmodel.FsOrder{
+		// 创建订单
+		resultCreate := tx.Create(&gmodel.FsOrder{
+			OrderProduct:            &byteOrderProduct,
+			OrderAddress:            &byteOrderAddress,
+			OrderAmount:             &byteOrderAmount,
+			ShoppingCartSnapshot:    &byteShoppingCartSnapshot,
+			ShoppingProductSnapshot: &byteShoppingProductSnapshot,
+			StatusLink:              &byteStatusLink,
 			UserId:                  &in.UserId,
 			DeliveryMethod:          &in.DeliveryMethod,
 			OrderSn:                 &orderSn,
-			Status:         (*int64)(&status.StatusCode),
+			Status:                  (*int64)(&status),
 			PayStatus:               (*int64)(&payStatus),
 			Ctime:                   &nowTime,
-			Metadata:       &orderDetailByte,
-		}
-		// 创建订单
-		resultCreate := tx.Create(&order)
+		})
+
 		if resultCreate.Error != nil {
 			return resultCreate.Error
 		}
-		// 删除购物车
-		resultDelete := tx.Delete(&gmodel.FsShoppingCart{}, in.CartIds)
-		if resultDelete.Error != nil {
-			return resultDelete.Error
-		}
+		// // 删除购物车
+		// resultDelete := tx.Delete(&gmodel.FsShoppingCart{}, in.CartIds)
+		// if resultDelete.Error != nil {
+		// 	return resultDelete.Error
+		// }
 
 		return nil
 	})
@@ -1051,8 +1029,8 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
 	}, nil
 }
 
-// 处理订单购物车快照
-func (d *defaultOrder) OrderDetailSnapshotHandler(ctx context.Context, req *string) (res map[string]interface{}, err error) {
+// 订单购物车快照处理
+func (d *defaultOrder) OrderShoppingCartSnapshotHandler(ctx context.Context, req *string) (res map[string]interface{}, err error) {
 	var snapshot map[string]interface{}
 	json.Unmarshal([]byte(*req), &snapshot)
 	snapshotFittingInfoData, snapshotFittingInfoEx := snapshot["fitting_info"]
@@ -1108,37 +1086,170 @@ func (d *defaultOrder) OrderDetailSnapshotHandler(ctx context.Context, req *stri
 		templateInfoMap["template_tag"] = templateTag
 	}
 	snapshot["template_info"] = templateInfoMap
+
+	snapshotLightInfoData, snapshotLightInfoEx := snapshot["light_info"]
+	var lightInfoMap map[string]interface{}
+	if snapshotLightInfoEx {
+		var snapshotLightInfoJson map[string]interface{}
+		var lightTag string
+		snapshotLightInfo := snapshotLightInfoData.(map[string]interface{})
+		snapshotLightInfoJsonData, snapshotLightInfoJsonEx := snapshotLightInfo["light_json"]
+		if snapshotLightInfoJsonEx {
+			json.Unmarshal([]byte(snapshotLightInfoJsonData.(string)), &snapshotLightInfoJson)
+		}
+		lightTagData, lightTagEx := snapshotLightInfo["light_tag"]
+		if lightTagEx {
+			lightTag = lightTagData.(string)
+		}
+		lightInfoMap = make(map[string]interface{}, 2)
+		lightInfoMap["light_json"] = snapshotLightInfoJson
+		lightInfoMap["light_tag"] = lightTag
+	}
+	snapshot["light_info"] = lightInfoMap
 	return snapshot, nil
 }
 
 // 详情处理
 func (d *defaultOrder) OrderDetailHandler(ctx context.Context, orderInfo *gmodel.FsOrder, original int64) (res *DetailRes, err error) {
-	var orderDetail gmodel.OrderDetail
 
-	err = json.Unmarshal(*orderInfo.Metadata, &orderDetail)
+	var orderAmount gmodel.OrderAmount
+	err = json.Unmarshal(*orderInfo.OrderAmount, &orderAmount)
 	if err != nil {
-		logc.Errorf(ctx, "order detail handler unmarshal metadata failed, err: %v", err)
+		logc.Errorf(ctx, "order detail handler unmarshal OrderAmount failed, err: %v", err)
 		return nil, err
 	}
-	orderDetailOriginal := orderDetail
-	if original == 1 {
-		for orderProductKey, orderProduct := range orderDetail.OrderProduct {
-			orderDetail.OrderProduct[orderProductKey].TotalPrice = order.GetAmountInfoFormat(&orderProduct.TotalPrice)
-			orderDetail.OrderProduct[orderProductKey].TotalPrice = order.GetAmountInfoFormat(&orderProduct.TotalPrice)
-			orderDetail.OrderProduct[orderProductKey].PurchaseQuantity = order.GetPurchaseQuantity(&orderProduct.PurchaseQuantity)
-			orderDetail.OrderProduct[orderProductKey].ProductSnapshot = nil
-			orderDetail.OrderProduct[orderProductKey].ShoppingCartSnapshot.SnapshotData = nil
+
+	var orderAddress *gmodel.OrderAddress
+	if orderInfo.OrderAddress != nil {
+		err = json.Unmarshal(*orderInfo.OrderAddress, &orderAddress)
+		if err != nil {
+			logc.Errorf(ctx, "order detail handler unmarshal OrderAddress failed, err: %v", err)
+			return nil, err
 		}
-		orderDetail.OrderInfo.StatusLink = order.GetOrderStatusLinkUser(orderDetail.OrderInfo.DeliveryMethod, orderDetail.OrderInfo.StatusLink)
+	}
+
+	var orderProduct []gmodel.OrderProductInter
+	err = json.Unmarshal(*orderInfo.OrderProduct, &orderProduct)
+	if err != nil {
+		logc.Errorf(ctx, "order detail handler unmarshal OrderProduct failed, err: %v", err)
+		return nil, err
+	}
+
+	var shoppingCartSnapshot []gmodel.FsShoppingCart
+	err = json.Unmarshal(*orderInfo.ShoppingCartSnapshot, &shoppingCartSnapshot)
+	if err != nil {
+		logc.Errorf(ctx, "order detail handler unmarshal ShoppingCartSnapshot failed, err: %v", err)
+		return nil, err
+	}
+
+	var shoppingProductSnapshot []gmodel.RelaFsProduct
+	err = json.Unmarshal(*orderInfo.ShoppingProductSnapshot, &shoppingProductSnapshot)
+	if err != nil {
+		logc.Errorf(ctx, "order detail handler unmarshal ShoppingCartSnapshot failed, err: %v", err)
+		return nil, err
+	}
+
+	var statusLink []gmodel.OrderStatus
+	err = json.Unmarshal(*orderInfo.StatusLink, &statusLink)
+	if err != nil {
+		logc.Errorf(ctx, "order detail handler unmarshal StatusLink failed, err: %v", err)
+		return nil, err
+	}
+
+	var payStatusLink []gmodel.PayStatus
+	if orderInfo.PayStatusLink != nil {
+		err = json.Unmarshal(*orderInfo.PayStatusLink, &payStatusLink)
+		if err != nil {
+			logc.Errorf(ctx, "order detail handler unmarshal PayStatusLink failed, err: %v", err)
+			return nil, err
+		}
+	}
+	var status = order.GetOrderStatusCurrent(statusLink, constants.OrderStatusCode(*orderInfo.Status))
+	var orderDetail gmodel.OrderDetail
+	var orderMetadata map[string]interface{}
+	if orderInfo.Metadata != nil {
+		json.Unmarshal(*orderInfo.Metadata, &orderMetadata)
+	}
+	if original == 1 {
+		orderDetail.DeliveryAddress = orderAddress
+		orderDetail.OrderAmount = orderAmount
 		orderDetail.OrderAmount.Deposit.PayAmount = order.GetAmountInfoFormat(&orderDetail.OrderAmount.Deposit.PayAmount)
 		orderDetail.OrderAmount.RemainingBalance.PayAmount = order.GetAmountInfoFormat(&orderDetail.OrderAmount.RemainingBalance.PayAmount)
 		orderDetail.OrderAmount.Subtotal = order.GetAmountInfoFormat(&orderDetail.OrderAmount.Subtotal)
 		orderDetail.OrderAmount.Total = order.GetAmountInfoFormat(&orderDetail.OrderAmount.Total)
-		orderDetail.PayTimeout = time.Duration(orderDetail.OrderInfo.Ctime.Add(orderDetail.PayTimeout).UTC().Unix() - time.Now().UTC().Unix())
+		orderDetail.PayStatus = constants.OrderPayStatusCode(*orderInfo.PayStatus)
+		orderDetail.PayTimeout = time.Duration(orderInfo.Ctime.Add(30*time.Minute).UTC().Unix() - time.Now().UTC().Unix())
+		orderDetail.OrderInfo = gmodel.OrderInfo{
+			UserId:         *orderInfo.UserId,
+			DeliveryMethod: *orderInfo.DeliveryMethod,
+			OrderSn:        *orderInfo.OrderSn,
+			Ctime:          orderInfo.Ctime,
+			Utime:          orderInfo.Utime,
+			Status:         status,
+			StatusLink:     order.GetOrderStatusLinkUser(orderDetail.OrderInfo.DeliveryMethod, statusLink),
+			Metadata:       orderMetadata,
+		}
+
+		var orderProductList []gmodel.OrderProduct
+		for _, productValue := range orderProduct {
+			var shoppingCartSnapshotData gmodel.FsShoppingCartData
+			for _, shoppingCartSnapshotValue := range shoppingCartSnapshot {
+				snapshot, err := d.OrderShoppingCartSnapshotHandler(ctx, shoppingCartSnapshotValue.Snapshot)
+				if err != nil {
+					logc.Errorf(ctx, "OrderDetailHandler OrderShoppingCartSnapshotHandler failed, err: %v", err)
+					return nil, err
+				}
+				shoppingCartSnapshotData.Id = shoppingCartSnapshotValue.Id
+				shoppingCartSnapshotData.UserId = shoppingCartSnapshotValue.UserId
+				shoppingCartSnapshotData.ProductId = shoppingCartSnapshotValue.ProductId
+				shoppingCartSnapshotData.TemplateId = shoppingCartSnapshotValue.TemplateId
+				shoppingCartSnapshotData.ModelId = shoppingCartSnapshotValue.ModelId
+				shoppingCartSnapshotData.SizeId = shoppingCartSnapshotValue.SizeId
+				shoppingCartSnapshotData.LightId = shoppingCartSnapshotValue.LightId
+				shoppingCartSnapshotData.FittingId = shoppingCartSnapshotValue.FittingId
+				shoppingCartSnapshotData.PurchaseQuantity = shoppingCartSnapshotValue.PurchaseQuantity
+				shoppingCartSnapshotData.IsSelected = shoppingCartSnapshotValue.IsSelected
+				shoppingCartSnapshotData.IsSelected = shoppingCartSnapshotValue.IsSelected
+				shoppingCartSnapshotData.IsHighlyCustomized = shoppingCartSnapshotValue.IsHighlyCustomized
+				shoppingCartSnapshotData.Ctime = shoppingCartSnapshotValue.Ctime
+				shoppingCartSnapshotData.Utime = shoppingCartSnapshotValue.Utime
+				shoppingCartSnapshotData.Snapshot = &snapshot
+			}
+
+			orderProductItem := gmodel.OrderProduct{
+				TotalPrice:           order.GetAmountInfoFormat(&productValue.TotalPrice),
+				ItemPrice:            order.GetAmountInfoFormat(&productValue.ItemPrice),
+				ExpectedDeliveryTime: &productValue.ExpectedDelivery.Current,
+				PurchaseQuantity:     *productValue.PurchaseQuantity,
+				ProductId:            productValue.ProductId,
+				ProductSn:            productValue.ProductSn,
+				ProductName:          productValue.ProductName,
+				ProductCover:         productValue.ProductCover,
+				ProductCoverMetadata: productValue.ProductCoverMetadata,
+				ShoppingCartSnapshot: &shoppingCartSnapshotData,
+
+				DiyInformation:     productValue.DiyInformation,
+				SizeInfo:           productValue.SizeInfo,
+				FittingInfo:        productValue.FittingInfo,
+				IsHighlyCustomized: productValue.IsHighlyCustomized,
+			}
+
+			orderProductList = append(orderProductList, orderProductItem)
+		}
+		orderDetail.OrderProduct = orderProductList
 	}
 
 	return &DetailRes{
 		OrderDetail: orderDetail,
-		OrderDetailOriginal: orderDetailOriginal,
+		OrderDetailOriginal: OrderDetailOriginal{
+			Status:                  &status,
+			OrderAmount:             &orderAmount,
+			OrderAddress:            orderAddress,
+			OrderProduct:            orderProduct,
+			ShoppingCartSnapshot:    shoppingCartSnapshot,
+			ShoppingProductSnapshot: shoppingProductSnapshot,
+			StatusLink:              statusLink,
+			PayStatusLink:           payStatusLink,
+		},
 	}, nil
 }

utils/order/order.go

@@ -208,6 +208,12 @@ func GetOrderStatusLinkUser(deliveryMethod int64, statusLink []gmodel.OrderStatu
 }
 
 // 获取订单当前状态
-func GenerateOrderStatusCurrent() gmodel.OrderStatus {
-	return gmodel.OrderStatus{}
+func GetOrderStatusCurrent(statusLink []gmodel.OrderStatus, orderStatusCode constants.OrderStatusCode) gmodel.OrderStatus {
+	var status gmodel.OrderStatus
+	for _, v := range statusLink {
+		if v.StatusCode == orderStatusCode {
+			status = v
+		}
+	}
+	return status
 }