fusen/fusenapi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix:支付

Browse Source
This commit is contained in:
momo 2023-09-27 17:23:58 +08:00
parent 6eccd11386
commit fef541dfe5
9 changed files with 405 additions and 250 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
constants/orders.go
View File

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

29
model/gmodel/fs_order_gen.go
View File

@ -7,17 +7,24 @@ import (
// fs_order 订单表 // fs_order 订单表
type FsOrder struct { type FsOrder struct {
Id int64 `gorm:"primary_key;default:0;auto_increment;" json:"id"` // 订单ID Id int64 `gorm:"primary_key;default:0;auto_increment;" json:"id"` // 订单ID
UserId *int64 `gorm:"index;default:0;" json:"user_id"` // 用户ID UserId *int64 `gorm:"index;default:0;" json:"user_id"` // 用户ID
DeliveryMethod *int64 `gorm:"index;default:0;" json:"delivery_method"` // 物流类型 DeliveryMethod *int64 `gorm:"index;default:0;" json:"delivery_method"` // 物流类型
OrderSn *string `gorm:"unique_key;default:'';" json:"order_sn"` // OrderSn *string `gorm:"unique_key;default:'';" json:"order_sn"` //
OrderSource *string `gorm:"default:'';" json:"order_source"` // OrderSource *string `gorm:"default:'';" json:"order_source"` //
Status *int64 `gorm:"index;default:0;" json:"status"` // 订单状态 Status *int64 `gorm:"index;default:0;" json:"status"` // 订单状态
Metadata *[]byte `gorm:"default:'';" json:"metadata"` // Metadata *[]byte `gorm:"default:'';" json:"metadata"` //
Ctime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"` // Ctime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"` //
Utime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"utime"` // Utime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"utime"` //
IsDel *int64 `gorm:"default:0;" json:"is_del"` // 是否删除：0=否，1=是 IsDel *int64 `gorm:"default:0;" json:"is_del"` // 是否删除：0=否，1=是
PayStatus *int64 `gorm:"default:0;" json:"pay_status"` // 支付状态 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 { type FsOrderModel struct {
db *gorm.DB db *gorm.DB

53
model/gmodel/fs_order_logic.go
View File

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

2
model/gmodel/fs_product_model3d_gen.go
View File

@ -23,7 +23,7 @@ type FsProductModel3d struct {
Status *int64 `gorm:"default:0;" json:"status"` // 状态位 显示 删除 Status *int64 `gorm:"default:0;" json:"status"` // 状态位 显示 删除
Ctime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"` // Ctime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"` //
OptionTemplate *int64 `gorm:"default:0;" json:"option_template"` // 配件绑定的公共模板 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 Sku *string `gorm:"default:'';" json:"sku"` // sku
IsHot *int64 `gorm:"default:0;" json:"is_hot"` // 是否热门 IsHot *int64 `gorm:"default:0;" json:"is_hot"` // 是否热门
IsCloudRender *int64 `gorm:"default:0;" json:"is_cloud_render"` // 是否设置为云渲染模型 IsCloudRender *int64 `gorm:"default:0;" json:"is_cloud_render"` // 是否设置为云渲染模型

1
model/gmodel/fs_shopping_cart_logic.go
View File

@ -27,7 +27,6 @@ type FsShoppingCartData struct {
FittingId *int64 `gorm:"default:0;" json:"fitting_id"` // 配件id FittingId *int64 `gorm:"default:0;" json:"fitting_id"` // 配件id
PurchaseQuantity *int64 `gorm:"default:0;" json:"purchase_quantity"` // 购买数量 PurchaseQuantity *int64 `gorm:"default:0;" json:"purchase_quantity"` // 购买数量
Snapshot *map[string]interface{} `gorm:"default:'';" json:"snapshot"` // 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是 IsSelected *int64 `gorm:"default:0;" json:"is_selected"` // 是否被选中 0非 1是
IsHighlyCustomized *int64 `gorm:"default:0;" json:"is_highly_customized"` // 是否高度定制 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"` // Ctime *time.Time `gorm:"default:'0000-00-00 00:00:00';" json:"ctime"` //

2
server/order/internal/logic/createorderlogic.go
View File

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

7
server/shopping-cart/shopping-cart_test.go Normal file
View File

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

521
service/repositories/order.go
View File

@ -8,7 +8,6 @@ import (
"fusenapi/constants" "fusenapi/constants"
"fusenapi/model/gmodel" "fusenapi/model/gmodel"
"fusenapi/utils/basic" "fusenapi/utils/basic"
"fusenapi/utils/fssql"
"fusenapi/utils/handlers" "fusenapi/utils/handlers"
"fusenapi/utils/order" "fusenapi/utils/order"
"fusenapi/utils/pay" "fusenapi/utils/pay"
@ -141,7 +140,17 @@ type (
DetailRes struct { DetailRes struct {
ErrorCode basic.StatusResponse ErrorCode basic.StatusResponse
OrderDetail gmodel.OrderDetail 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 return err
} }
var ntime = time.Now().UTC() var ntime = time.Now().UTC()
if (payStage == "deposit" && *orderInfo.PayStatus == int64(constants.ORDERPAYSTATUSUNPAIDDEPOSIT)) || (payStage == "remaining_balance" && *orderInfo.PayStatus == int64(constants.ORDERPAYSTATUSPAIDDEPOSIT)) { 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.PAYSTATUSPAID) var payStatus = int64(constants.PAY_STATUS_PAID)
var payStageInt int64 var payStageInt int64
var orderPayStatusCode constants.OrderPayStatusCode var orderPayStatusCode constants.OrderPayStatusCode
// 订单状态--当前 // 订单状态--当前
var status gmodel.OrderStatus var status gmodel.OrderStatus
var statusLink []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 var payInfo PayInfo
payInfo.PayMethod = in.PaymentMethod payInfo.PayMethod = in.PaymentMethod
payInfo.PayTime = payTime payInfo.PayTime = payTime
@ -259,29 +269,26 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
statusCode = constants.ORDER_STATUS_CLOUDSTORE_ORDERED statusCode = constants.ORDER_STATUS_CLOUDSTORE_ORDERED
} }
payStageInt = 1 payStageInt = 1
orderPayStatusCode = constants.ORDERPAYSTATUSPAIDDEPOSIT orderPayStatusCode = constants.ORDER_PAY_STATUS_PAIDDEPOSIT
status = gmodel.OrderStatus{ status = gmodel.OrderStatus{
Ctime: &ntime, Ctime: &ntime,
Utime: &ntime, Utime: &ntime,
StatusCode: statusCode, StatusCode: statusCode,
StatusTitle: constants.OrderStatusMessage[statusCode], StatusTitle: constants.OrderStatusMessage[statusCode],
} }
statusLink = order.UpdateOrderStatusLink(ress.OrderDetailOriginal.OrderInfo.StatusLink, gmodel.OrderStatus{ statusLink = order.UpdateOrderStatusLink(ress.OrderDetailOriginal.StatusLink, gmodel.OrderStatus{
Ctime: &ntime, Ctime: &ntime,
Utime: &ntime, Utime: &ntime,
StatusCode: statusCode, StatusCode: statusCode,
StatusTitle: constants.OrderStatusMessage[statusCode], StatusTitle: constants.OrderStatusMessage[statusCode],
}) })
payInfo.Status = gmodel.PayStatus{ payInfo.Status = gmodel.PayStatus{
StatusCode: int64(constants.PAYSTATUSPAID), StatusCode: int64(constants.PAY_STATUS_PAID),
StatusTitle: constants.PayStatusMessage[constants.PAYSTATUSPAID], StatusTitle: constants.PayStatusMessage[constants.PAY_STATUS_PAID],
}
payInfo.StatusLink = append(ress.OrderDetail.OrderAmount.Deposit.StatusLink, payInfo.Status)
uOrderDetail["order_amount"] = struct {
Deposit PayInfo `json:"deposit"`
}{
Deposit: payInfo,
} }
payInfo.StatusLink = append(ress.OrderDetailOriginal.OrderAmount.Deposit.StatusLink, payInfo.Status)
payStatusLink = payInfo.StatusLink
orderAmount["deposit"] = payInfo
} }
if payStage == "remaining_balance" { if payStage == "remaining_balance" {
if *orderInfo.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL { if *orderInfo.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL {
@ -295,11 +302,11 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
statusCode = constants.ORDER_STATUS_CLOUDSTORE_ORDEREDMAINING statusCode = constants.ORDER_STATUS_CLOUDSTORE_ORDEREDMAINING
} }
payStageInt = 2 payStageInt = 2
orderPayStatusCode = constants.ORDERPAYSTATUSPAIDDREMAINING orderPayStatusCode = constants.ORDER_PAY_STATUS_PAIDDREMAINING
var statusChildren []*gmodel.OrderStatus var statusChildren []*gmodel.OrderStatus
// 更新订单状态链路--子状态 // 更新订单状态链路--子状态
for oStatusLinkKey, oStatusLink := range ress.OrderDetail.OrderInfo.StatusLink { for oStatusLinkKey, oStatusLink := range ress.OrderDetailOriginal.StatusLink {
if oStatusLink.StatusCode == statusCodePre { if oStatusLink.StatusCode == statusCodePre {
statusChildren = append(oStatusLink.Children, &gmodel.OrderStatus{ statusChildren = append(oStatusLink.Children, &gmodel.OrderStatus{
Ctime: &ntime, Ctime: &ntime,
@ -307,26 +314,41 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
StatusCode: statusCode, StatusCode: statusCode,
StatusTitle: constants.OrderStatusMessage[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 { if ress.OrderDetailOriginal.Status.StatusCode == constants.ORDER_STATUS_DIRECTMAIL_ORDERED || ress.OrderDetailOriginal.Status.StatusCode == constants.ORDER_STATUS_CLOUDSTORE_ORDERED {
status = ress.OrderDetail.OrderInfo.Status status = *ress.OrderDetailOriginal.Status
status.Children = statusChildren status.Children = statusChildren
} }
payInfo.Status = gmodel.PayStatus{ payInfo.Status = gmodel.PayStatus{
StatusCode: int64(constants.PAYSTATUSPAID), StatusCode: int64(constants.PAY_STATUS_PAID),
StatusTitle: constants.PayStatusMessage[constants.PAYSTATUSPAID], StatusTitle: constants.PayStatusMessage[constants.PAY_STATUS_PAID],
} }
payInfo.StatusLink = append(ress.OrderDetail.OrderAmount.RemainingBalance.StatusLink, payInfo.Status) payInfo.StatusLink = append(ress.OrderDetailOriginal.OrderAmount.RemainingBalance.StatusLink, payInfo.Status)
uOrderDetail["order_amount"] = struct { payStatusLink = payInfo.StatusLink
RemainingBalance PayInfo `json:"remaining_balance"` orderAmount["remaining_balance"] = payInfo
}{ }
RemainingBalance: 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,33 +369,23 @@ func (d *defaultOrder) PaymentSuccessful(ctx context.Context, in *PaymentSuccess
Utime: &ntime, Utime: &ntime,
PayTitle: &payTitle, PayTitle: &payTitle,
}) })
var sql string
// 更新数据库
var table = gmodel.NewAllModels(d.MysqlConn).FsOrder.TableName()
var resUpdate *gorm.DB
var resUpdateSql string
if *orderInfo.Status == int64(constants.ORDER_STATUS_UNPAIDDEPOSIT) { if *orderInfo.Status == int64(constants.ORDER_STATUS_UNPAIDDEPOSIT) {
sql = fmt.Sprintf(", `utime` = '%s', `pay_status` = %d, `status` = %d ", ntime, orderPayStatusCode, statusCode) resUpdateSql = fmt.Sprintf("UPDATE %s SET `status` = %d,`pay_status` = %d , `utime` = '%s'", table, statusCode, orderPayStatusCode, ntime)
} else { } else {
sql = fmt.Sprintf(", `utime` = '%s', `pay_status` = %d", ntime, orderPayStatusCode) resUpdateSql = fmt.Sprintf("UPDATE %s SET `pay_status` = %d , `utime` = '%s'", table, orderPayStatusCode, ntime)
} }
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
uOrderDetail["pay_status"] = orderPayStatusCode if err != nil {
uOrderDetail["order_info"] = struct { logc.Errorf(ctx, "PaymentSuccessful failed resUpdate,eventId:%s, err: %v", in.EventId, err)
Utime *time.Time `json:"utime"` return err
Status gmodel.OrderStatus `json:"status"`
StatusLink []gmodel.OrderStatus `json:"status_link"`
}{
Utime: &ntime,
Status: status,
StatusLink: statusLink,
} }
fmt.Printf("uOrderDetail :%+v", uOrderDetail)
if len(uOrderDetail) > 0 {
err = fssql.MetadataOrderPATCH(d.MysqlConn, sql, orderSn, gmodel.FsOrder{}, uOrderDetail, "id = ?", orderInfo.Id)
if err != nil {
logc.Errorf(ctx, "PaymentSuccessful failed MetadataOrderPATCH,eventId:%s, err: %v", in.EventId, err)
return err
}
}
} }
return nil return 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) { func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *CreatePrePaymentByBalanceReq) (res *CreatePrePaymentByBalanceRes, err error) {
var errorCode basic.StatusResponse var errorCode basic.StatusResponse
var order gmodel.FsOrder var orderInfo gmodel.FsOrder
model := d.MysqlConn.Where("is_del = ?", 0) model := d.MysqlConn.Where("is_del = ?", 0)
if in.UserId != 0 { if in.UserId != 0 {
model.Where("user_id = ?", in.UserId) model.Where("user_id = ?", in.UserId)
@ -391,7 +403,7 @@ func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *Create
if in.OrderSn != "" { if in.OrderSn != "" {
model.Where("order_sn = ?", in.OrderSn) model.Where("order_sn = ?", in.OrderSn)
} }
result := model.Take(&order) result := model.Take(&orderInfo)
if result.Error != nil { if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) { if errors.Is(result.Error, gorm.ErrRecordNotFound) {
errorCode = *basic.CodeErrOrderCreatePrePaymentInfoNoFound errorCode = *basic.CodeErrOrderCreatePrePaymentInfoNoFound
@ -404,7 +416,7 @@ func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *Create
}, result.Error }, result.Error
} }
// 非未支付 // 非未支付
if *order.PayStatus != int64(constants.ORDERPAYSTATUSPAIDDEPOSIT) { if *orderInfo.PayStatus != int64(constants.ORDER_PAY_STATUS_PAIDDEPOSIT) {
errorCode = *basic.CodeErrOrderCreatePrePaymentNoUnPaid errorCode = *basic.CodeErrOrderCreatePrePaymentNoUnPaid
err = errors.New("order balance pay status is not unPaid") err = errors.New("order balance pay status is not unPaid")
logc.Errorf(ctx, "create prePayment balance failed, err: %v", err) logc.Errorf(ctx, "create prePayment balance failed, err: %v", err)
@ -413,7 +425,7 @@ func (d *defaultOrder) CreatePrePaymentByBalance(ctx context.Context, in *Create
}, err }, err
} }
ress, err := d.OrderDetailHandler(ctx, &order, 1) ress, err := d.OrderDetailHandler(ctx, &orderInfo, 1)
if err != nil { if err != nil {
logc.Errorf(ctx, "create prePayment balance failed DetailOrderDetailHandler, err: %v", err) logc.Errorf(ctx, "create prePayment balance failed DetailOrderDetailHandler, err: %v", err)
errorCode = *basic.CodeServiceErr 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) { func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *CreatePrePaymentByDepositReq) (res *CreatePrePaymentByDepositRes, err error) {
var errorCode basic.StatusResponse var errorCode basic.StatusResponse
var order gmodel.FsOrder var orderInfo gmodel.FsOrder
model := d.MysqlConn.Where("is_del = ?", 0) model := d.MysqlConn.Where("is_del = ?", 0)
if in.UserId != 0 { if in.UserId != 0 {
model.Where("user_id = ?", in.UserId) model.Where("user_id = ?", in.UserId)
@ -477,7 +489,7 @@ func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *Create
if in.OrderSn != "" { if in.OrderSn != "" {
model.Where("order_sn = ?", in.OrderSn) model.Where("order_sn = ?", in.OrderSn)
} }
result := model.Take(&order) result := model.Take(&orderInfo)
if result.Error != nil { if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) { if errors.Is(result.Error, gorm.ErrRecordNotFound) {
errorCode = *basic.CodeErrOrderCreatePrePaymentInfoNoFound 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 errorCode = *basic.CodeErrOrderCreatePrePaymentNoUnPaid
err = errors.New("order pay status is not unPaidDeposit") err = errors.New("order pay status is not unPaidDeposit")
logc.Errorf(ctx, "create prePayment deposit failed, err: %v", err) 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() ntime := time.Now().UTC()
ctime := *order.Ctime ctime := *orderInfo.Ctime
ctimeTimeOut := ctime.Add(30 * time.Minute).UTC().Unix() ctimeTimeOut := ctime.Add(30 * time.Minute).UTC().Unix()
ntimeTimeOut := ntime.Unix() ntimeTimeOut := ntime.Unix()
@ -516,7 +528,7 @@ func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *Create
}, err }, err
} }
ress, err := d.OrderDetailHandler(ctx, &order, 0) ress, err := d.OrderDetailHandler(ctx, &orderInfo, 1)
if err != nil { if err != nil {
logc.Errorf(ctx, "create prePayment deposit failed DetailOrderDetailHandler, err: %v", err) logc.Errorf(ctx, "create prePayment deposit failed DetailOrderDetailHandler, err: %v", err)
errorCode = *basic.CodeServiceErr errorCode = *basic.CodeServiceErr
@ -525,62 +537,57 @@ func (d *defaultOrder) CreatePrePaymentByDeposit(ctx context.Context, in *Create
}, err }, err
} }
var uOrderDetail = make(map[string]interface{})
var orderAddress *gmodel.OrderAddress var orderAddress *gmodel.OrderAddress
var orderAddressByte []byte
var statusLinkByte []byte
if in.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL { if in.DeliveryMethod == constants.DELIVERYMETHODDIRECTMAIL {
orderAddress = &gmodel.OrderAddress{ orderAddress = &gmodel.OrderAddress{
Name: in.DeliveryAddress.Name, Name: in.DeliveryAddress.Name,
Mobile: in.DeliveryAddress.Mobile, Mobile: in.DeliveryAddress.Mobile,
Address: in.DeliveryAddress.Address, Address: in.DeliveryAddress.Address,
} }
} orderAddressByte, err = json.Marshal(orderAddress)
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)
if err != nil { if err != nil {
logc.Errorf(ctx, "create prePayment deposit failed orderAddressByte, err: %v", err)
errorCode = *basic.CodeServiceErr errorCode = *basic.CodeServiceErr
logc.Errorf(ctx, "create prePayment deposit failed MetadataOrderPATCH, err: %v", err)
return &CreatePrePaymentByDepositRes{ return &CreatePrePaymentByDepositRes{
ErrorCode: errorCode, 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.Utime = &ntime
ress.OrderDetail.OrderInfo.DeliveryMethod = in.DeliveryMethod ress.OrderDetail.OrderInfo.DeliveryMethod = in.DeliveryMethod
ress.OrderDetail.OrderInfo.StatusLink = statusLink
ress.OrderDetail.DeliveryAddress = orderAddress 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) { func (d *defaultOrder) Detail(ctx context.Context, in *DetailReq) (res *DetailRes, err error) {
var errorCode basic.StatusResponse var errorCode basic.StatusResponse
var order gmodel.FsOrder var orderInfo gmodel.FsOrder
model := d.MysqlConn.Where("is_del = ?", 0) model := d.MysqlConn.Where("is_del = ?", 0)
if in.UserId != 0 { if in.UserId != 0 {
model.Where("user_id = ?", in.UserId) model.Where("user_id = ?", in.UserId)
@ -699,7 +706,7 @@ func (d *defaultOrder) Detail(ctx context.Context, in *DetailReq) (res *DetailRe
if in.OrderSn != "" { if in.OrderSn != "" {
model.Where("order_sn = ?", in.OrderSn) model.Where("order_sn = ?", in.OrderSn)
} }
result := model.Take(&order) result := model.Take(&orderInfo)
if result.Error != nil { if result.Error != nil {
if errors.Is(result.Error, gorm.ErrRecordNotFound) { if errors.Is(result.Error, gorm.ErrRecordNotFound) {
errorCode = *basic.CodeErrOrderCreatePrePaymentInfoNoFound 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 { if err != nil {
logc.Errorf(ctx, "order detail failed, err: %v", err) logc.Errorf(ctx, "order detail failed, err: %v", err)
errorCode = *basic.CodeServiceErr 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 var shippingFee gmodel.AmountInfo
// 订单税费总价（厘） // 订单税费总价（厘）
@ -802,7 +811,9 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
var orderAddress *gmodel.OrderAddress 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 { 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 { if shoppingCart.ShoppingCartProduct.CoverResource != nil && shoppingCart.ShoppingCartProduct.CoverResource.Metadata != nil {
json.Unmarshal(*shoppingCart.ShoppingCartProduct.CoverResource.Metadata, &productCoverMetadata) json.Unmarshal(*shoppingCart.ShoppingCartProduct.CoverResource.Metadata, &productCoverMetadata)
} }
snapshot, err := d.OrderDetailSnapshotHandler(ctx, shoppingCart.FsShoppingCart.Snapshot)
if err != nil { productInter := gmodel.OrderProductInter{
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{
TotalPrice: order.GetAmountInfo(order.GetAmountInfoReq{ TotalPrice: order.GetAmountInfo(order.GetAmountInfoReq{
ExchangeRate: in.ExchangeRate, ExchangeRate: in.ExchangeRate,
Initiate: productTotalPrice, Initiate: productTotalPrice,
@ -887,12 +874,6 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
CurrentCurrency: in.CurrentCurrency, CurrentCurrency: in.CurrentCurrency,
OriginalCurrency: in.OriginalCurrency, 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{ ItemPrice: order.GetAmountInfo(order.GetAmountInfoReq{
ExchangeRate: in.ExchangeRate, ExchangeRate: in.ExchangeRate,
Initiate: productPrice, Initiate: productPrice,
@ -900,10 +881,21 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
CurrentCurrency: in.CurrentCurrency, CurrentCurrency: in.CurrentCurrency,
OriginalCurrency: in.OriginalCurrency, OriginalCurrency: in.OriginalCurrency,
}), }),
ProductSnapshot: shoppingCart.ShoppingCartProduct, ExpectedDelivery: &gmodel.ExpectedDelivery{
ShoppingCartSnapshot: shoppingCartSnapshotInter, Current: in.ExpectedDeliveryTime,
ProductSn: *shoppingCart.ShoppingCartProduct.Sn, Initiate: in.ExpectedDeliveryTime,
DiyInformation: &shoppingCartSnapshot.UserDiyInformation, },
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{ FittingInfo: &gmodel.OrderProductFittingInfo{
FittingID: *shoppingCart.FittingId, FittingID: *shoppingCart.FittingId,
FittingName: shoppingCartSnapshot.FittingInfo.FittingName, FittingName: shoppingCartSnapshot.FittingInfo.FittingName,
@ -918,7 +910,9 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
}, },
IsHighlyCustomized: *shoppingCart.IsHighlyCustomized, 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{ 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 depositInt int64 = orderTotal / 2
var deposit = gmodel.PayInfo{ var deposit = gmodel.PayInfo{
Status: gmodel.PayStatus{ Status: gmodel.PayStatus{
StatusCode: int64(constants.PAYSTATUSUNPAID), StatusCode: int64(constants.PAY_STATUS_UNPAID),
StatusTitle: constants.PayStatusMessage[constants.PAYSTATUSUNPAID], StatusTitle: constants.PayStatusMessage[constants.PAY_STATUS_UNPAID],
}, },
StatusLink: make([]gmodel.PayStatus, 0), StatusLink: make([]gmodel.PayStatus, 0),
PayAmount: order.GetAmountInfo(order.GetAmountInfoReq{ 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 remainingBalanceInt int64 = orderTotal - depositInt
var remainingBalance = gmodel.PayInfo{ var remainingBalance = gmodel.PayInfo{
Status: gmodel.PayStatus{ Status: gmodel.PayStatus{
StatusCode: int64(constants.PAYSTATUSUNPAID), StatusCode: int64(constants.PAY_STATUS_UNPAID),
StatusTitle: constants.PayStatusMessage[constants.PAYSTATUSUNPAID], StatusTitle: constants.PayStatusMessage[constants.PAY_STATUS_UNPAID],
}, },
StatusLink: make([]gmodel.PayStatus, 0), StatusLink: make([]gmodel.PayStatus, 0),
PayAmount: order.GetAmountInfo(order.GetAmountInfoReq{ PayAmount: order.GetAmountInfo(order.GetAmountInfoReq{
@ -980,56 +974,40 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
Total: total, 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 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{ byteOrderProduct, _ := json.Marshal(orderProductList)
DeliveryAddress: orderAddress, byteOrderAddress, _ := json.Marshal(orderAddress)
OrderAmount: orderAmount, byteOrderAmount, _ := json.Marshal(orderAmount)
OrderInfo: orderInfo, byteShoppingCartSnapshot, _ := json.Marshal(shoppingCartSnapshotList)
OrderProduct: orderProductList, byteShoppingProductSnapshot, _ := json.Marshal(shoppingProductSnapshotList)
PayStatus: payStatus, byteStatusLink, _ := json.Marshal(statusLink)
PayTimeout: 30 * time.Minute,
}
// 数据库操作
orderDetailByte, err := json.Marshal(orderDetail)
if err != nil {
return err
}
var order = gmodel.FsOrder{
UserId: &in.UserId,
DeliveryMethod: &in.DeliveryMethod,
OrderSn: &orderSn,
Status: (*int64)(&status.StatusCode),
PayStatus: (*int64)(&payStatus),
Ctime: &nowTime,
Metadata: &orderDetailByte,
}
// 创建订单 // 创建订单
resultCreate := tx.Create(&order) 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),
PayStatus: (*int64)(&payStatus),
Ctime: &nowTime,
})
if resultCreate.Error != nil { if resultCreate.Error != nil {
return resultCreate.Error return resultCreate.Error
} }
// 删除购物车 // // 删除购物车
resultDelete := tx.Delete(&gmodel.FsShoppingCart{}, in.CartIds) // resultDelete := tx.Delete(&gmodel.FsShoppingCart{}, in.CartIds)
if resultDelete.Error != nil { // if resultDelete.Error != nil {
return resultDelete.Error // return resultDelete.Error
} // }
return nil return nil
}) })
@ -1051,8 +1029,8 @@ func (d *defaultOrder) Create(ctx context.Context, in *CreateReq) (res *CreateRe
}, nil }, 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{} var snapshot map[string]interface{}
json.Unmarshal([]byte(*req), &snapshot) json.Unmarshal([]byte(*req), &snapshot)
snapshotFittingInfoData, snapshotFittingInfoEx := snapshot["fitting_info"] snapshotFittingInfoData, snapshotFittingInfoEx := snapshot["fitting_info"]
@ -1108,37 +1086,170 @@ func (d *defaultOrder) OrderDetailSnapshotHandler(ctx context.Context, req *stri
templateInfoMap["template_tag"] = templateTag templateInfoMap["template_tag"] = templateTag
} }
snapshot["template_info"] = templateInfoMap 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 return snapshot, nil
} }
// 详情处理 // 详情处理
func (d *defaultOrder) OrderDetailHandler(ctx context.Context, orderInfo *gmodel.FsOrder, original int64) (res *DetailRes, err error) { 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 { 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 return nil, err
} }
orderDetailOriginal := orderDetail
if original == 1 { var orderAddress *gmodel.OrderAddress
for orderProductKey, orderProduct := range orderDetail.OrderProduct { if orderInfo.OrderAddress != nil {
orderDetail.OrderProduct[orderProductKey].TotalPrice = order.GetAmountInfoFormat(&orderProduct.TotalPrice) err = json.Unmarshal(*orderInfo.OrderAddress, &orderAddress)
orderDetail.OrderProduct[orderProductKey].TotalPrice = order.GetAmountInfoFormat(&orderProduct.TotalPrice) if err != nil {
orderDetail.OrderProduct[orderProductKey].PurchaseQuantity = order.GetPurchaseQuantity(&orderProduct.PurchaseQuantity) logc.Errorf(ctx, "order detail handler unmarshal OrderAddress failed, err: %v", err)
orderDetail.OrderProduct[orderProductKey].ProductSnapshot = nil return nil, err
orderDetail.OrderProduct[orderProductKey].ShoppingCartSnapshot.SnapshotData = nil
} }
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.Deposit.PayAmount = order.GetAmountInfoFormat(&orderDetail.OrderAmount.Deposit.PayAmount)
orderDetail.OrderAmount.RemainingBalance.PayAmount = order.GetAmountInfoFormat(&orderDetail.OrderAmount.RemainingBalance.PayAmount) orderDetail.OrderAmount.RemainingBalance.PayAmount = order.GetAmountInfoFormat(&orderDetail.OrderAmount.RemainingBalance.PayAmount)
orderDetail.OrderAmount.Subtotal = order.GetAmountInfoFormat(&orderDetail.OrderAmount.Subtotal) orderDetail.OrderAmount.Subtotal = order.GetAmountInfoFormat(&orderDetail.OrderAmount.Subtotal)
orderDetail.OrderAmount.Total = order.GetAmountInfoFormat(&orderDetail.OrderAmount.Total) 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{ return &DetailRes{
OrderDetail: orderDetail, OrderDetail: orderDetail,
OrderDetailOriginal: orderDetailOriginal, OrderDetailOriginal: OrderDetailOriginal{
Status: &status,
OrderAmount: &orderAmount,
OrderAddress: orderAddress,
OrderProduct: orderProduct,
ShoppingCartSnapshot: shoppingCartSnapshot,
ShoppingProductSnapshot: shoppingProductSnapshot,
StatusLink: statusLink,
PayStatusLink: payStatusLink,
},
}, nil }, nil
} }

10
utils/order/order.go
View File

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