liulei/jx-callback
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

- 结算初始版本

Browse Source
This commit is contained in:
renyutian
2019-03-21 16:12:54 +08:00
parent 5c8106a70b
commit 0ee04cdd4d
9 changed files with 642 additions and 13 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
business/partner/purchase/ebai/financial.go
View File

@@ -1,11 +1,125 @@
package ebai
import "git.rosy.net.cn/baseapi/platformapi/ebaiapi"
import (
"git.rosy.net.cn/baseapi/platformapi/ebaiapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxcallback/orderman"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/globals/api"
)
func OnFinancialMsg(msg *ebaiapi.CallbackMsg) (response *ebaiapi.CallbackResponse) {
return response
}
func (p *PurchaseHandler) OnOrderDetail(orderDetail map[string]interface{}) (err error) {
// 存储饿百退款订单结账信息
func OnFinancialMsg(msg *ebaiapi.CallbackMsg) (err error) {
if msg.Cmd == ebaiapi.CmdOrderPartRefund { // 部分退款处理
if utils.Interface2String(msg.Body["status"]) == ebaiapi.OrderPartRefundSuccess {
orderData, err2 := api.EbaiAPI.OrderPartrefundGet(utils.Interface2String(msg.Body["refund_id"]))
if err = err2; err == nil {
afsOrder := CurPurchaseHandler.AfsOrderDetail2Financial(orderData)
err = orderman.SaveAfsOrderFinancialInfo(afsOrder)
}
}
} else if msg.Cmd == ebaiapi.CmdOrderUserCancel { // 全额退款处理
if utils.Interface2String(msg.Body["cancel_type"]) == ebaiapi.AfterOrderFinishedCancelType && (utils.Interface2String(msg.Body["type"]) == ebaiapi.OrderUserCancelSuccessA || utils.Interface2String(msg.Body["type"]) == ebaiapi.OrderUserCancelSuccessB) {
globals.SugarLogger.Debug(utils.Interface2String(msg.Body["refund_id"])) // 获得退款订单ID，去本地数据库拿？饿百消息推送只给了订单号，但是没有查询全额退款的接口，只有部分退款才可以查询
}
}
return err
}
func (p *PurchaseHandler) AfsOrderDetail2Financial(orderData map[string]interface{}) (afsOrder *model.AfterSalesOrder) {
afsOrder = &model.AfterSalesOrder{
VendorID: model.VendorIDEBAI,
AfterSalesOrderID: utils.Interface2String(orderData["order_id"]),
VendorOrderID: utils.Interface2String(orderData["order_id"]),
}
order, err := partner.CurOrderManager.LoadOrder(afsOrder.VendorOrderID, afsOrder.VendorID)
if err == nil {
afsOrder.JxStoreID = order.JxStoreID
} else {
globals.SugarLogger.Warnf("ebai OnFinancialMsg, afsOrderID:%s is not found from partner.CurOrderManager.LoadOrder", afsOrder.VendorOrderID)
err = nil
}
if orderData["refund_detail"] != nil {
refundDetail := orderData["refund_detail"].([]interface{})
for _, refundInfo := range refundDetail {
xMap := refundInfo.(map[string]interface{})
orderSku := &model.AfterSalesOrderSku{
VendorID: model.VendorIDEBAI,
AfterSalesOrderID: afsOrder.AfterSalesOrderID,
VendorOrderID: afsOrder.VendorOrderID,
ConfirmTime: getTimeFromInterface(xMap["apply_time"]),
VendorSkuID: utils.Interface2String(xMap["sku_id"]),
SkuID: int(utils.Str2Int64(utils.Interface2String(xMap["custom_sku_id"]))),
Name: utils.Interface2String(xMap["name"]),
SkuUserMoney: utils.MustInterface2Int64(xMap["total_refund"]),
SkuVendorMoney: utils.MustInterface2Int64(xMap["shop_ele_refund"]),
}
afsOrder.Skus = append(afsOrder.Skus, orderSku)
}
if len(refundDetail) > 0 {
afsOrder.ConfirmTime = afsOrder.Skus[0].ConfirmTime
} else {
globals.SugarLogger.Warnf("ebai OnFinancialMsg, orderID:%s have no refund_detail", afsOrder.VendorOrderID)
}
} else {
globals.SugarLogger.Warnf("ebai OnFinancialMsg, orderID:% refund_detail is nil", afsOrder.VendorOrderID)
}
return afsOrder
}
// 存储饿百正向订单结账信息
func (p *PurchaseHandler) OnOrderDetail(result map[string]interface{}) (err error) {
err = orderman.SaveOrderFinancialInfo(p.OrderDetail2Financial(result))
return err
}
func (p *PurchaseHandler) OrderDetail2Financial(result map[string]interface{}) (orderDetail *model.OrderFinancial) {
orderDetail = &model.OrderFinancial{
VendorID: model.VendorIDEBAI,
}
order1 := result["order"].(map[string]interface{})
orderDetail.VendorOrderID = utils.Interface2String(order1["order_id"])
orderDetail.VendorOrderID2 = utils.Interface2String(order1["eleme_order_id"])
orderDetail.DeliveryConfirmTime = getTimeFromInterface(order1["finished_time"])
orderDetail.TotalDiscountMoney = utils.MustInterface2Int64(order1["discount_fee"])
orderDetail.ReceivableFreight = utils.MustInterface2Int64(order1["send_fee"])
if int(utils.MustInterface2Int64(order1["send_immediately"])) == ebaiapi.SendImmediatelySelf {
orderDetail.SelfDeliveryDiscountMoney = orderDetail.ReceivableFreight
}
orderDetail.BoxMoney = utils.MustInterface2Int64(order1["package_fee"])
orderDetail.ActualPayMoney = utils.MustInterface2Int64(order1["user_fee"])
orderDetail.PmMoney = utils.MustInterface2Int64(order1["commission"])
orderDetail.ShopMoney = utils.MustInterface2Int64(order1["shop_fee"])
order, err := partner.CurOrderManager.LoadOrder(orderDetail.VendorOrderID, orderDetail.VendorID)
if err == nil {
skus := order.Skus
if skus != nil {
for _, x := range skus {
orderDetail.ShopPriceMoney += x.ShopPrice
}
}
} else {
globals.SugarLogger.Warnf("ebai OnOrderDetail, orderID:%s is not found from partner.CurOrderManager.LoadOrder", orderDetail.VendorOrderID)
err = nil
}
if result["products"] != nil {
products := result["products"].([]interface{})
for _, x := range products {
for _, y := range x.([]interface{}) {
product := y.(map[string]interface{})
orderDetail.SalePriceMoney += utils.MustInterface2Int64(product["product_price"]) * utils.MustInterface2Int64(product["product_amount"])
}
}
}
if result["discount"] != nil {
discount := result["discount"].([]interface{})
for _, x := range discount {
xMap := x.(map[string]interface{})
orderDetail.DiscountMoney += utils.MustInterface2Int64(xMap["fee"])
orderDetail.PmSubsidyMoney += utils.MustInterface2Int64(xMap["baidu_rate"]) // 平台承担补贴
}
}
return orderDetail
}

19
business/partner/purchase/ebai/financial_test.go Normal file
View File

@@ -0,0 +1,19 @@
package ebai
import (
"fmt"
"testing"
"git.rosy.net.cn/baseapi/platformapi/ebaiapi"
)
func TestOnFinancialMsg(t *testing.T) {
msg := &ebaiapi.CallbackMsg{
Cmd: "order.partrefund.push",
Body: make(map[string]interface{}),
}
msg.Body["refund_id"] = "15518443822344"
msg.Body["status"] = "20"
res := OnFinancialMsg(msg)
fmt.Println(res)
}

143
business/partner/purchase/jd/financial.go
View File

@@ -1,7 +1,146 @@
package jd
import "git.rosy.net.cn/baseapi/platformapi/jdapi"
import (
"git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxcallback/orderman"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/globals/api"
)
// 京东正向/退款订单类型处理--存储
func OnFinancialMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
return retVal
var err error
if msg.StatusID == jdapi.OrderStatusPayFinishedSettle || msg.StatusID == jdapi.OrderStatusAdjustSettle || msg.StatusID == jdapi.OrderStatusSwitch2SelfSettle { // 如果是正向单
orderData, err2 := api.JdAPI.QuerySingleOrder(msg.BillID)
if err = err2; err == nil {
err = orderman.SaveOrderFinancialInfo(curPurchaseHandler.OrderDetail2Financial(orderData))
}
} else if msg.StatusID == jdapi.SaleBillStatusRefundSuccess || msg.StatusID == jdapi.SaleBillStatusSaleReturnSuccess { // 如果是退款单
orderData, err2 := api.JdAPI.GetAfsService(msg.BillID)
if err = err2; err == nil {
err = orderman.SaveAfsOrderFinancialInfo(curPurchaseHandler.AfsOrderDetail2Financial(orderData))
}
}
return jdapi.Err2CallbackResponse(err, "jd OnFinancialMsg")
}
// 处理京东正向订单信息
func (p *PurchaseHandler) OrderDetail2Financial(orderData map[string]interface{}) (orderDetail *model.OrderFinancial) {
orderDetail = &model.OrderFinancial{
VendorID: model.VendorIDJD,
VendorOrderID: utils.Int64ToStr(utils.MustInterface2Int64(orderData["orderId"])),
ReceivableFreight: utils.MustInterface2Int64(orderData["orderReceivableFreight"]),
FreightMoney: utils.MustInterface2Int64(orderData["orderFreightMoney"]),
ActualPayMoney: utils.MustInterface2Int64(orderData["orderBuyerPayableMoney"]),
DiscountMoney: utils.MustInterface2Int64(orderData["orderDiscountMoney"]),
DistanceFreightMoney: utils.MustInterface2Int64(orderData["merchantPaymentDistanceFreightMoney"]),
FreightTipsMoney: utils.MustInterface2Int64(orderData["tips"]),
// BoxFee: utils.MustInterface2Int64(orderData["packagingMoney"]), // 京东包装（塑料袋）由京东提供，相应钱款也归京东，不记录/记录之后优化算法
}
order, err := partner.CurOrderManager.LoadOrder(orderDetail.VendorOrderID, orderDetail.VendorID)
if err == nil {
skus := order.Skus
if skus != nil {
for _, x := range skus {
orderDetail.ShopPriceMoney += x.ShopPrice
}
}
} else {
globals.SugarLogger.Warnf("jd OnJdOrderinfo, orderID:%s is not found from partner.CurOrderManager.LoadOrder", orderDetail.VendorOrderID)
}
if orderData["product"] != nil {
product := orderData["product"].([]interface{})
for _, x := range product {
xMap := x.(map[string]interface{})
orderDetail.SalePriceMoney += utils.MustInterface2Int64(xMap["skuJdPrice"]) * utils.MustInterface2Int64(xMap["skuCount"])
}
}
orderDetail.DeliveryConfirmTime = utils.Str2TimeWithDefault(utils.Interface2String(orderData["deliveryConfirmTime"]), utils.DefaultTimeValue)
if utils.Interface2String(orderData["deliveryCarrierNo"]) == jdapi.SelfDeliveryCarrierNo {
orderDetail.SelfDeliveryDiscountMoney = utils.MustInterface2Int64(orderData["orderReceivableFreight"])
orderDetail.DistanceFreightMoney = 0
}
if orderData["discount"] != nil {
discount := orderData["discount"].([]interface{})
for _, x := range discount {
xMap := x.(map[string]interface{})
discountPrice := utils.MustInterface2Int64(xMap["discountPrice"])
discountType := int(utils.MustInterface2Int64(xMap["discountType"]))
if discountType == jdapi.FreightDiscountTypeByShop {
orderDetail.FreightDiscountMoney = discountPrice
}
if discountType == jdapi.FreightDiscountTypeByVip || discountType == jdapi.FreightDiscountTypeByActivity || discountType == jdapi.FreightDiscountTypeByCoupons {
orderDetail.VendorFreightDiscountMoney = discountPrice
}
orderDetail.TotalDiscountMoney += discountPrice
}
}
order1, err2 := api.JdAPI.OrderShoudSettlementService(orderDetail.VendorOrderID)
if err2 == nil {
orderDetail.ShopMoney = utils.Interface2Int64WithDefault(order1["settlementAmount"], 0)
orderDetail.PmMoney += utils.Interface2Int64WithDefault(order1["goodsCommission"], 0)
orderDetail.PmMoney += utils.Interface2Int64WithDefault(order1["freightCommission"], 0)
orderDetail.PmMoney += utils.Interface2Int64WithDefault(order1["packageCommission"], 0)
orderDetail.PmMoney += utils.Interface2Int64WithDefault(order1["guaranteedCommission"], 0)
orderDetail.PmSubsidyMoney += utils.Interface2Int64WithDefault(order1["platOrderGoodsDiscountMoney"], 0)
orderDetail.PmSubsidyMoney += utils.Interface2Int64WithDefault(order1["platSkuGoodsDiscountMoney"], 0)
}
return orderDetail
}
// 处理京东售后订单结账信息
func (p *PurchaseHandler) AfsOrderDetail2Financial(orderData map[string]interface{}) (afsOrder *model.AfterSalesOrder) {
afsOrder = &model.AfterSalesOrder{
VendorID: model.VendorIDJD,
AfterSalesOrderID: utils.Interface2String(orderData["afsServiceOrder"]),
VendorOrderID: utils.Interface2String(orderData["orderId"]),
VendorStoreID: utils.Interface2String(orderData["stationId"]),
StoreID: int(utils.Str2Int64(utils.Interface2String(orderData["stationNumOutSystem"]))),
ConfirmTime: utils.Timestamp2Time(utils.MustInterface2Int64(orderData["updateTime"].(map[string]interface{})["time"])),
FreightUserMoney: utils.MustInterface2Int64(orderData["orderFreightMoney"]),
AfsFreightMoney: utils.MustInterface2Int64(orderData["afsFreight"]),
BoxMoney: utils.MustInterface2Int64(orderData["packagingMoney"]),
TongchengFreightMoney: utils.MustInterface2Int64(orderData["tongchengFreightMoney"]),
MealBoxMoney: utils.MustInterface2Int64(orderData["mealBoxMoney"]),
}
order, err := partner.CurOrderManager.LoadOrder(afsOrder.VendorOrderID, afsOrder.VendorID)
if err == nil {
afsOrder.JxStoreID = order.JxStoreID
} else {
globals.SugarLogger.Warnf("jd OnFinancialMsg, afsOrderID:%s is not found from partner.CurOrderManager.LoadOrder", afsOrder.VendorOrderID)
}
if orderData["afsDetailList"] != nil {
refundDetail := orderData["afsDetailList"].([]interface{})
for _, x := range refundDetail {
xMap := x.(map[string]interface{})
orderSku := &model.AfterSalesOrderSku{
VendorID: model.VendorIDJD,
AfterSalesOrderID: afsOrder.AfterSalesOrderID,
VendorOrderID: afsOrder.VendorOrderID,
VendorStoreID: afsOrder.VendorStoreID,
StoreID: afsOrder.StoreID,
ConfirmTime: afsOrder.ConfirmTime,
VendorSkuID: utils.Int64ToStr(utils.MustInterface2Int64(xMap["wareId"])),
SkuID: int(utils.Str2Int64(utils.Interface2String(xMap["skuIdIsv"]))),
Name: utils.Interface2String(xMap["wareName"]),
SkuUserMoney: utils.MustInterface2Int64(xMap["afsMoney"]),
}
if xMap["afsSkuDiscountList"] != nil {
afsSkuDiscountList := xMap["afsSkuDiscountList"].([]interface{})
for _, y := range afsSkuDiscountList {
orderSku.SkuVendorMoney += utils.MustInterface2Int64(y.(map[string]interface{})["platPayMoney"])
}
}
afsOrder.Skus = append(afsOrder.Skus, orderSku)
}
if len(refundDetail) <= 0 {
globals.SugarLogger.Warnf("ebai OnFinancialMsg, orderID:%s have no refund_detail", afsOrder.VendorOrderID)
}
} else {
globals.SugarLogger.Warnf("ebai OnFinancialMsg, orderID:% refund_detail is nil", afsOrder.VendorOrderID)
}
return afsOrder
}

17
business/partner/purchase/jd/financial_test.go Normal file
View File

@@ -0,0 +1,17 @@
package jd
import (
"fmt"
"testing"
"git.rosy.net.cn/baseapi/platformapi/jdapi"
)
func TestOnFinancialMsg(t *testing.T) {
msg := &jdapi.CallbackOrderMsg{
BillID: "817102100000041",
StatusID: "330901",
}
res := OnFinancialMsg(msg)
fmt.Println(res)
}

122
business/partner/purchase/mtwm/financial.go
View File

@@ -1,11 +1,123 @@
package mtwm
import "git.rosy.net.cn/baseapi/platformapi/mtwmapi"
import (
"net/url"
func OnFinancialMsg(msg *mtwmapi.CallbackMsg) (response *mtwmapi.CallbackResponse) {
return response
}
"git.rosy.net.cn/baseapi/platformapi/mtwmapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxcallback/orderman"
"git.rosy.net.cn/jx-callback/business/jxutils"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/business/partner"
"git.rosy.net.cn/jx-callback/globals"
)
func (p *PurchaseHandler) OnOrderDetail(orderDetail map[string]interface{}) (err error) {
// 存储美团退款订单结账信息
func OnFinancialMsg(msg *mtwmapi.CallbackMsg) (err error) {
if msg.Cmd == mtwmapi.MsgTypeOrderPartialRefund { // 部分退款处理
orderData := msg.Data
if orderData.Get("notify_type") == mtwmapi.NotifyTypeSuccess {
err = orderman.SaveAfsOrderFinancialInfo(curPurchaseHandler.AfsOrderDetail2Financial(orderData))
}
}
if msg.Cmd == mtwmapi.MsgTypeOrderRefund { // todo 全额退款处理
orderData := msg.Data
if orderData.Get("notify_type") == mtwmapi.NotifyTypeSuccess {
globals.SugarLogger.Debug(orderData.Get("order_id")) // 获得退款订单ID，去本地数据库拿？饿百消息推送只给了订单号，也没有通过订单号查询退款信息的接口
}
}
return err
}
func (p *PurchaseHandler) AfsOrderDetail2Financial(orderData url.Values) (afsOrder *model.AfterSalesOrder) {
afsOrder = &model.AfterSalesOrder{
VendorID: model.VendorIDMTWM,
AfterSalesOrderID: orderData.Get("order_id"),
VendorOrderID: orderData.Get("order_id"),
ConfirmTime: utils.Timestamp2Time(utils.Str2Int64(orderData.Get("timestamp"))),
RefundMoney: jxutils.StandardPrice2Int(utils.Str2Float64(orderData.Get("money"))),
}
order, err := partner.CurOrderManager.LoadOrder(afsOrder.VendorOrderID, afsOrder.VendorID)
if err == nil {
afsOrder.JxStoreID = order.JxStoreID
} else {
globals.SugarLogger.Warnf("mtwm OnFinancialMsg, afsOrderID:%s is not found from partner.CurOrderManager.LoadOrder", afsOrder.VendorOrderID)
err = nil
}
food := orderData.Get("food")
var refundDetail []map[string]interface{}
utils.UnmarshalUseNumber([]byte(food), &refundDetail)
for _, xMap := range refundDetail {
orderSku := &model.AfterSalesOrderSku{
VendorID: model.VendorIDMTWM,
AfterSalesOrderID: afsOrder.AfterSalesOrderID,
VendorOrderID: afsOrder.VendorOrderID,
ConfirmTime: afsOrder.ConfirmTime,
VendorSkuID: utils.Interface2String(xMap["app_food_code"]),
SkuID: int(utils.Str2Int64(utils.Interface2String(xMap["sku_id"]))),
Name: utils.Interface2String(xMap["food_name"]),
SkuUserMoney: jxutils.StandardPrice2Int(utils.MustInterface2Float64(xMap["refund_price"]))*utils.MustInterface2Int64(xMap["count"]) + jxutils.StandardPrice2Int(utils.MustInterface2Float64(xMap["box_price"]))*int64(utils.MustInterface2Float64(xMap["box_num"])),
}
afsOrder.Skus = append(afsOrder.Skus, orderSku)
}
if len(refundDetail) <= 0 {
globals.SugarLogger.Warnf("ebai OnFinancialMsg, orderID:%s have no refund_detail", afsOrder.VendorOrderID)
}
return afsOrder
}
// 存储美团正向订单结账信息
func (p *PurchaseHandler) OnOrderDetail(result map[string]interface{}) (err error) {
err = orderman.SaveOrderFinancialInfo(p.OrderDetail2Financial(result))
return err
}
func (p *PurchaseHandler) OrderDetail2Financial(result map[string]interface{}) (orderDetail *model.OrderFinancial) {
orderDetail = &model.OrderFinancial{
VendorID: model.VendorIDMTWM,
VendorOrderID: utils.Int64ToStr(utils.MustInterface2Int64(result["order_id"])),
}
orderDetail.DeliveryConfirmTime = utils.Str2TimeWithDefault(utils.Interface2String(result["order_completed_time"]), utils.DefaultTimeValue)
order, err := partner.CurOrderManager.LoadOrder(orderDetail.VendorOrderID, orderDetail.VendorID)
if err == nil {
if order.Skus != nil {
for _, x := range order.Skus {
orderDetail.ShopPriceMoney += x.ShopPrice
}
}
} else {
globals.SugarLogger.Warnf("mtwm OrderDetail2Financial, orderID:%s is not found from partner.CurOrderManager.LoadOrder", orderDetail.VendorOrderID)
err = nil
}
detail := result["detail"]
if detail != nil {
var data []map[string]interface{}
utils.UnmarshalUseNumber([]byte(utils.Interface2String(detail)), &data)
for _, x := range data {
orderDetail.SalePriceMoney += jxutils.StandardPrice2Int(utils.MustInterface2Float64(x["price"])) * utils.MustInterface2Int64(x["quantity"])
orderDetail.BoxMoney += jxutils.StandardPrice2Int(utils.MustInterface2Float64(x["box_price"])) * utils.MustInterface2Int64(x["box_num"])
}
} else {
globals.SugarLogger.Warnf("mtwm OrderDetail2Financial, orderID:%s have no detail", orderDetail.VendorOrderID)
}
poiReceiveDetail := result["poi_receive_detail"]
if poiReceiveDetail != nil {
var data map[string]interface{}
utils.UnmarshalUseNumber([]byte(utils.Interface2String(poiReceiveDetail)), &data)
orderDetail.ReceivableFreight = utils.MustInterface2Int64(data["logisticsFee"])
orderDetail.FreightMoney = utils.MustInterface2Int64(data["logisticsFee"])
orderDetail.ActualPayMoney = utils.MustInterface2Int64(data["onlinePayment"])
orderDetail.PmMoney = utils.MustInterface2Int64(data["foodShareFeeChargeByPoi"])
orderDetail.ShopMoney = utils.MustInterface2Int64(data["wmPoiReceiveCent"])
for _, x := range data["actOrderChargeByMt"].([]interface{}) {
orderDetail.TotalDiscountMoney += utils.MustInterface2Int64(x.(map[string]interface{})["moneyCent"])
orderDetail.PmSubsidyMoney += utils.MustInterface2Int64(x.(map[string]interface{})["moneyCent"])
}
for _, x := range data["actOrderChargeByPoi"].([]interface{}) {
orderDetail.TotalDiscountMoney += utils.MustInterface2Int64(x.(map[string]interface{})["moneyCent"])
}
} else {
globals.SugarLogger.Warnf("mtwm OrderDetail2Financial, orderID:%s have no poi_receive_detail", orderDetail.VendorOrderID)
}
return orderDetail
}

45
business/partner/purchase/mtwm/financial_test.go Normal file
View File

@@ -0,0 +1,45 @@
package mtwm
import (
"fmt"
"net/url"
"testing"
"time"
"git.rosy.net.cn/baseapi/platformapi/mtwmapi"
"git.rosy.net.cn/baseapi/utils"
)
func TestOnFinancialMsg(t *testing.T) {
msg := &mtwmapi.CallbackMsg{
Cmd: "orderPartialRefund",
Data: url.Values{},
}
msg.Data.Set("timestamp", utils.Int64ToStr(time.Now().Unix()))
msg.Data.Set("order_id", "123458")
msg.Data.Set("notify_type", "agree")
msg.Data.Set("money", "23.56")
food := []map[string]interface{}{
map[string]interface{}{
"app_food_code": "123",
"food_name": "商品1",
"sku_id": "123",
"refund_price": 3.14,
"count": 2,
"box_num": 1,
"box_price": 1,
},
map[string]interface{}{
"app_food_code": "124",
"food_name": "商品2",
"sku_id": "124",
"refund_price": 3.15,
"count": 2,
"box_num": 1,
"box_price": 1,
},
}
msg.Data.Set("food", string(utils.MustMarshal(food)))
res := OnFinancialMsg(msg)
fmt.Println(res)
}