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

- refactor file structure.

Browse Source
This commit is contained in:
gazebo
2018-08-17 13:59:15 +08:00
parent d872d4d0ec
commit d40186e930
25 changed files with 153 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files

237
business/partner/purchase/jd/order.go Normal file
View File

@@ -0,0 +1,237 @@
package jd
import (
"strings"
"git.rosy.net.cn/baseapi/platformapi/autonavi"
"git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jxcallback/scheduler"
"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"
"git.rosy.net.cn/jx-callback/globals/api"
"git.rosy.net.cn/jx-callback/legacy/freshfood"
)
var (
VendorStatus2StatusMap = map[string]int{
jdapi.OrderStatusPurchased: model.OrderStatusNew,
jdapi.OrderStatusNew: model.OrderStatusNew,
jdapi.OrderStatusAdjust: model.OrderStatusNew,
jdapi.OrderStatusWaitOutStore: model.OrderStatusAccepted,
jdapi.OrderStatusFinishedPickup: model.OrderStatusFinishedPickup,
jdapi.OrderStatusDelivering: model.OrderStatusDelivering,
jdapi.OrderStatusDelivered: model.OrderStatusDelivered,
jdapi.OrderStatusCanceled: model.OrderStatusCanceled,
jdapi.OrderStatusUserApplyCancel: model.OrderStatusApplyCancel,
jdapi.OrderStatusLocked: model.OrderStatusLocked,
jdapi.OrderStatusUnlocked: model.OrderStatusUnlocked,
}
)
type OrderController struct {
scheduler.BasePurchasePlatform
}
func init() {
scheduler.CurrentScheduler.RegisterPurchasePlatform(model.VendorIDJD, new(OrderController))
}
func (c *OrderController) OnOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
jxutils.CallMsgHandler(func() {
retVal = c.onOrderMsg(msg)
}, jxutils.ComposeUniversalOrderID(msg.BillID, model.VendorIDJD))
return retVal
}
func (c *OrderController) onOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
if jdapi.OrderStatusNew == msg.StatusID {
retVal = c.onOrderNew(msg)
} else if jdapi.OrderStatusAdjust == msg.StatusID {
retVal = c.onOrderAdjust(msg)
} else {
status := c.callbackMsg2Status(msg)
if msg.StatusID == jdapi.OrderStatusAddComment || msg.StatusID == jdapi.OrderStatusModifyComment {
if globals.ReallyCallPlatformAPI {
freshfood.FreshFoodAPI.JDOrderComment(msg)
}
}
err := partner.CurOrderManager.OnOrderStatusChanged(status)
// if globals.HandleLegacyJxOrder && err == nil {
// c.legacyJdOrderStatusChanged(status)
// }
retVal = jdapi.Err2CallbackResponse(err, status.VendorStatus)
}
return retVal
}
func (c *OrderController) GetOrder(orderID string) (order *model.GoodsOrder, err error) {
result, err := api.JdAPI.QuerySingleOrder(orderID)
// globals.SugarLogger.Info(result)
if err == nil {
order = &model.GoodsOrder{
VendorOrderID: orderID,
VendorID: model.VendorIDJD,
VendorStoreID: result["produceStationNo"].(string),
StoreID: int(utils.Str2Int64WithDefault(utils.Interface2String(result["produceStationNoIsv"]), 0)),
StoreName: result["produceStationName"].(string),
ConsigneeName: utils.FilterMb4(result["buyerFullName"].(string)),
ConsigneeMobile: result["buyerMobile"].(string),
ConsigneeAddress: utils.FilterMb4(result["buyerFullAddress"].(string)),
CoordinateType: model.CoordinateTypeMars,
BuyerComment: utils.FilterMb4(strings.Trim(utils.Interface2String(result["orderBuyerRemark"]), "\n\r\t ")),
ExpectedDeliveredTime: utils.Str2TimeWithDefault(utils.Interface2String(result["orderPreEndDeliveryTime"]), utils.DefaultTimeValue),
VendorStatus: utils.Int64ToStr(utils.MustInterface2Int64(result["orderStatus"])),
OrderSeq: int(utils.MustInterface2Int64(result["orderNum"])),
StatusTime: utils.Str2Time(result["orderPurchaseTime"].(string)),
OriginalData: utils.FilterMb4(string(utils.MustMarshal(result))),
ActualPayPrice: utils.MustInterface2Int64(result["orderBuyerPayableMoney"]),
Skus: []*model.OrderSku{},
}
order.Status = c.GetStatusFromVendorStatus(order.VendorStatus)
businessTage := utils.Interface2String(result["businessTag"])
if strings.Index(businessTage, "dj_aging_immediately") >= 0 {
order.BusinessType = model.BusinessTypeImmediate
} else {
order.BusinessType = model.BusinessTypeDingshida
}
coordinateType := utils.Interface2Int64WithDefault(result["buyerCoordType"], 1)
originalLng := utils.MustInterface2Float64(result["buyerLng"])
originalLat := utils.MustInterface2Float64(result["buyerLat"])
if coordinateType == 1 {
lng, lat, err2 := api.AutonaviAPI.CoordinateConvert(originalLng, originalLat, autonavi.CoordSysGPS)
if err2 == nil {
originalLng = lng
originalLat = lat
} else {
// 如果没有转成功，保留原始数据
order.CoordinateType = model.CoordinateTypeGPS
}
}
order.ConsigneeLng = jxutils.StandardCoordinate2Int(originalLng)
order.ConsigneeLat = jxutils.StandardCoordinate2Int(originalLat)
// discounts := result["discount"].(map[string]interface{})
for _, product2 := range result["product"].([]interface{}) {
product := product2.(map[string]interface{})
sku := &model.OrderSku{
VendorOrderID: orderID,
VendorID: model.VendorIDJD,
Count: int(utils.MustInterface2Int64(product["skuCount"])),
SkuID: int(utils.Str2Int64WithDefault(utils.Interface2String(product["skuIdIsv"]), 0)),
VendorSkuID: utils.Int64ToStr(utils.MustInterface2Int64(product["skuId"])),
SkuName: product["skuName"].(string),
Weight: int(utils.MustInterface2Float64(product["skuWeight"]) * 1000),
SalePrice: utils.MustInterface2Int64(product["skuJdPrice"]),
PromotionType: int(utils.MustInterface2Int64(product["promotionType"])),
}
if product["isGift"].(bool) {
sku.SkuType = 1
}
order.Skus = append(order.Skus, sku)
order.SkuCount++
order.GoodsCount += sku.Count
order.SalePrice += sku.SalePrice * int64(sku.Count)
order.Weight += sku.Weight * sku.Count
}
setOrederDetailFee(result, order)
}
return order, err
}
func setOrederDetailFee(result map[string]interface{}, order *model.GoodsOrder) {
order.BoxFee = utils.MustInterface2Int64(result["packagingMoney"])
order.PlatformFeeRate = model.JdPlatformFeeRate
order.BillStoreFreightFee = utils.MustInterface2Int64(result["merchantPaymentDistanceFreightMoney"]) + utils.MustInterface2Int64(result["tips"])
}
//
func (c *OrderController) onOrderNew(msg *jdapi.CallbackOrderMsg) (response *jdapi.CallbackResponse) {
order, err := c.GetOrder(msg.BillID)
if err == nil {
err = partner.CurOrderManager.OnOrderNew(order, msg.StatusID)
// if err == nil {
// c.legacyWriteJdOrder(order, false)
// }
}
return jdapi.Err2CallbackResponse(err, "jd onOrderNew")
}
func (c *OrderController) onOrderAdjust(msg *jdapi.CallbackOrderMsg) *jdapi.CallbackResponse {
order, err := c.GetOrder(msg.BillID)
if err == nil {
err = partner.CurOrderManager.OnOrderAdjust(order, msg.StatusID)
// if globals.HandleLegacyJxOrder && err == nil {
// c.legacyWriteJdOrder(order, true)
// }
}
return jdapi.Err2CallbackResponse(err, "jd onOrderAdjust")
}
func (c *OrderController) callbackMsg2Status(msg *jdapi.CallbackOrderMsg) *model.OrderStatus {
orderStatus := &model.OrderStatus{
VendorOrderID: msg.BillID,
VendorID: model.VendorIDJD,
OrderType: model.OrderTypeOrder,
RefVendorOrderID: msg.BillID,
RefVendorID: model.VendorIDJD,
VendorStatus: msg.StatusID,
Status: c.GetStatusFromVendorStatus(msg.StatusID),
StatusTime: utils.Str2Time(msg.Timestamp),
Remark: msg.Remark,
}
return orderStatus
}
// IPurchasePlatformHandler
func (c *OrderController) GetStatusFromVendorStatus(vendorStatus string) int {
if status, ok := VendorStatus2StatusMap[vendorStatus]; ok {
return status
}
return model.OrderStatusUnknown
}
func (c *OrderController) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool) (err error) {
_, err = api.JdAPI.OrderAcceptOperate(order.VendorOrderID, isAcceptIt)
return err
}
func (c *OrderController) PickupGoods(order *model.GoodsOrder) (err error) {
_, err = api.JdAPI.OrderJDZBDelivery(order.VendorOrderID)
return err
}
func (c *OrderController) Swtich2SelfDeliver(order *model.GoodsOrder) (err error) {
_, err = api.JdAPI.ModifySellerDelivery(order.VendorOrderID)
if err != nil {
if errWithCode, ok := err.(*utils.ErrorWithCode); ok && errWithCode.Level() == 1 {
globals.SugarLogger.Infof("Swtich2SelfDeliver failed with error:%v try get current status", err)
if order2, err2 := c.GetOrder(order.VendorOrderID); err2 == nil {
var mapData map[string]interface{}
if err2 = utils.UnmarshalUseNumber([]byte(order2.OriginalData), &mapData); err2 == nil {
if utils.Interface2String(mapData["deliveryCarrierNo"]) == "2938" { // 当前已经是自送状态了
err = nil
}
}
}
}
}
return err
}
func (c *OrderController) Swtich2SelfDelivered(order *model.GoodsOrder) (err error) {
_, err = api.JdAPI.DeliveryEndOrder(order.VendorOrderID)
return err
}
func (c *OrderController) SelfDeliverDelievering(order *model.GoodsOrder) (err error) {
_, err = api.JdAPI.OrderSerllerDelivery(order.VendorOrderID)
return err
}
// 京东送达接口都是一样的
func (c *OrderController) SelfDeliverDelievered(order *model.GoodsOrder) (err error) {
return c.Swtich2SelfDelivered(order)
}

49
business/partner/purchase/jd/order_legacy.go Normal file
View File

@@ -0,0 +1,49 @@
package jd
import (
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/legacymodel"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/globals"
"github.com/astaxie/beego/orm"
)
// 为了兼容之前的表，造出原来需要的数据
func (c *OrderController) legacyWriteJdOrder(order *model.GoodsOrder, delOldFirst bool) (err error) {
db := orm.NewOrm()
if delOldFirst {
db.Raw("DELETE FROM jdorder2 WHERE jdorderid = ?", utils.Str2Int64(order.VendorOrderID)).Exec()
}
legacyOrder := &legacymodel.Jdorder2{
Code: "0",
Jdorderid: utils.Str2Int64(order.VendorOrderID),
Orderstatus: int(utils.Str2Int64(order.VendorStatus)),
Orderstatustime: utils.Time2Str(order.StatusTime),
Success: 1,
Cityname: "all",
}
_, err = db.Insert(legacyOrder)
if err != nil {
globals.SugarLogger.Infof("legacyWriteJdOrder orderID:%s insert error:%v", order.VendorOrderID, err)
}
return err
}
func (c *OrderController) legacyJdOrderStatusChanged(status *model.OrderStatus) (err error) {
db := orm.NewOrm()
legacyOrder := &legacymodel.Jdorder2{
Jdorderid: utils.Str2Int64(status.VendorOrderID),
}
if err = db.Read(legacyOrder, "Jdorderid"); err == nil {
utils.CallFuncLogError(func() error {
legacyOrder.Orderstatus = int(utils.Str2Int64(status.VendorStatus))
legacyOrder.Orderstatustime = utils.Time2Str(status.StatusTime)
_, err = db.Update(legacyOrder, "Orderstatus", "Orderstatustime")
return err
}, "legacyJdOrderStatusChanged, status:%v", status)
} else {
globals.SugarLogger.Infof("legacyJdOrderStatusChanged db.Read status:%v, error:%v", status, err)
}
return err
}

42
business/partner/purchase/jd/order_test.go Normal file
View File

@@ -0,0 +1,42 @@
package jd
import (
"testing"
"git.rosy.net.cn/jx-callback/business/jxcallback/orderman"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/globals/api"
"git.rosy.net.cn/jx-callback/globals/db"
"github.com/astaxie/beego"
)
func init() {
beego.InitBeegoBeforeTest("/Users/xujianhua/go/src/git.rosy.net.cn/jx-callback/conf/app.conf")
beego.BConfig.RunMode = "dev" // InitBeegoBeforeTest会将runmode设置为test
globals.Init()
db.Init()
api.Init()
}
func TestSwitch2SelfDeliver(t *testing.T) {
orderID := "817540316000041"
if order, err := orderman.CurOrderManager.LoadOrder(orderID, model.VendorIDJD); err == nil {
// globals.SugarLogger.Debug(order)
c := new(OrderController)
if err = c.Swtich2SelfDeliver(order); err == nil {
} else {
t.Fatal(err.Error())
}
} else {
t.Fatal(err.Error())
}
}
func TestGetOrder(t *testing.T) {
_, err := new(OrderController).GetOrder("815536199000222")
if err != nil {
t.Fatal(err.Error())
}
}

65
business/partner/purchase/jd/waybill.go Normal file
View File

@@ -0,0 +1,65 @@
package jd
import (
"git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/utils"
"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/api"
)
type WaybillController struct {
}
func (c *WaybillController) OnWaybillMsg(msg *jdapi.CallbackDeliveryStatusMsg) (retVal *jdapi.CallbackResponse) {
jxutils.CallMsgHandler(func() {
retVal = c.onWaybillMsg(msg)
}, jxutils.ComposeUniversalOrderID(msg.OrderID, model.VendorIDJD))
return retVal
}
func (c *WaybillController) onWaybillMsg(msg *jdapi.CallbackDeliveryStatusMsg) (retVal *jdapi.CallbackResponse) {
order := c.callbackMsg2Waybill(msg)
switch msg.DeliveryStatus {
case jdapi.DeliveryStatusWait4Grap:
order.Status = model.WaybillStatusNew
case jdapi.DeliveryStatusAccepted:
if result, err := api.JdAPI.QuerySingleOrder(msg.OrderID); err == nil {
// 默认配送费=订单应付运费(orderReceivableFreight)
//订单应付运费为未优惠前应付运费(满免优惠，运费优惠券，VIP免基础运费，用户小费)ps：用户小费是用户给配送员的小费
order.DesiredFee = utils.Interface2Int64WithDefault(result["orderReceivableFreight"], 0) +
utils.Interface2Int64WithDefault(result["merchantPaymentDistanceFreightMoney"], 0) +
utils.Interface2Int64WithDefault(result["tips"], 0)
}
order.Status = model.WaybillStatusAccepted
case jdapi.DeliveryStatusCourierCanceled:
order.Status = model.WaybillStatusCanceled
case jdapi.DeliveryStatusCourierArrived:
order.Status = model.WaybillStatusCourierArrived
case jdapi.DeliveryStatusGotGoods:
order.Status = model.WaybillStatusDelivering
case jdapi.DeliveryStatusFinished:
order.Status = model.WaybillStatusDelivered
case jdapi.DeliveryStatusFailedDelivery, jdapi.DeliveryStatusFailedGetGoods:
order.Status = model.WaybillStatusFailed
default:
order.Status = model.WaybillStatusUnknown
}
return jdapi.Err2CallbackResponse(partner.CurOrderManager.OnWaybillStatusChanged(order), order.VendorStatus)
}
func (c *WaybillController) callbackMsg2Waybill(msg *jdapi.CallbackDeliveryStatusMsg) (retVal *model.Waybill) {
retVal = &model.Waybill{
VendorOrderID: msg.OrderID,
OrderVendorID: model.VendorIDJD,
VendorWaybillID: msg.OrderID,
WaybillVendorID: model.VendorIDJD,
CourierName: msg.DeliveryManName,
CourierMobile: msg.DeliveryManPhone,
VendorStatus: msg.DeliveryStatus,
StatusTime: utils.Str2Time(msg.DeliveryStatusTime),
Remark: msg.Remark,
}
return retVal
}