530 lines
22 KiB
Go
530 lines
22 KiB
Go
package jd
|
||
|
||
import (
|
||
"fmt"
|
||
"regexp"
|
||
"strings"
|
||
"time"
|
||
|
||
"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
|
||
|
||
"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/jxutils"
|
||
"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
|
||
"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"
|
||
)
|
||
|
||
var (
|
||
VendorStatus2StatusMap = map[string]int{
|
||
jdapi.OrderStatusPurchased: model.OrderStatusNew,
|
||
jdapi.OrderStatusWaitOutStore: model.OrderStatusAccepted,
|
||
jdapi.StatusIDWaitOutStore: model.OrderStatusAccepted,
|
||
jdapi.OrderStatusFinishedPickup: model.OrderStatusFinishedPickup,
|
||
jdapi.OrderStatusDelivering: model.OrderStatusDelivering,
|
||
jdapi.OrderStatusDelivered: model.OrderStatusFinished,
|
||
jdapi.OrderStatusFinished: model.OrderStatusFinished, // todo 这个状态不是真正都完成的意思?
|
||
jdapi.OrderStatusCanceled: model.OrderStatusCanceled,
|
||
|
||
jdapi.OrderStatusAdjust: model.OrderStatusAdjust,
|
||
jdapi.OrderStatusUserApplyCancel: model.OrderStatusApplyCancel,
|
||
jdapi.OrderStatusLocked: model.OrderStatusLocked,
|
||
jdapi.OrderStatusUnlocked: model.OrderStatusUnlocked,
|
||
|
||
jdapi.OrderStatusVenderAgreeCancel: model.OrderStatusVendorAgreeCancel,
|
||
jdapi.OrderStatusVenderRejectCancel: model.OrderStatusVendorRejectCancel,
|
||
jdapi.CallbackMsgOrderAddTips: model.OrderStatusWaybillTipChanged,
|
||
}
|
||
deliveryTypeMap = map[int]string{
|
||
jdapi.CarrierNoCrowdSourcing: model.OrderDeliveryTypePlatform,
|
||
jdapi.CarrierNoSelfDelivery: model.OrderDeliveryTypeStoreSelf,
|
||
jdapi.CarrierNoSelfTake: model.OrderDeliveryTypeSelfTake,
|
||
}
|
||
|
||
selfTakeCodeReg = regexp.MustCompile(`等待用户凭提货码(\d+)于`)
|
||
)
|
||
|
||
func (c *PurchaseHandler) OnOrderMsg(vendorOrgCode string, msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
|
||
jxutils.CallMsgHandler(func() {
|
||
retVal = c.onOrderMsg(vendorOrgCode, msg)
|
||
}, jxutils.ComposeUniversalOrderID(msg.BillID, model.VendorIDJD))
|
||
return retVal
|
||
}
|
||
|
||
func (c *PurchaseHandler) updateOrderFinancialInfo(a *jdapi.API, orderID string) (err error) {
|
||
order := &model.GoodsOrder{
|
||
VendorOrderID: orderID,
|
||
VendorID: model.VendorIDJD,
|
||
}
|
||
orderSettlement, err := a.OrderShoudSettlementService2(orderID)
|
||
if err == nil {
|
||
if orderSettlement != nil {
|
||
updateOrderBySettleMent(order, orderSettlement)
|
||
err = partner.CurOrderManager.UpdateOrderFields(order, []string{ /*"WaybillTipMoney", */ "TotalShopMoney", "PmSubsidyMoney"})
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) onOrderMsg(vendorOrgCode string, msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
|
||
a := getAPI(vendorOrgCode)
|
||
status := c.callbackMsg2Status(msg)
|
||
if jdapi.StatusIDNewOrder == msg.StatusID {
|
||
status.Status = model.OrderStatusNew // 因为京东将事件32000与状态32000混用，事件32000可能是新订单，也可能是已接单，统一当成新订单处理
|
||
}
|
||
if partner.CurOrderManager.GetStatusDuplicatedCount(status) > 0 {
|
||
return nil
|
||
}
|
||
if msg.MsgURL == jdapi.CallbackMsgOrderAccounting {
|
||
retVal = c.OnFinancialMsg(msg)
|
||
retVal = jdapi.Err2CallbackResponse(c.updateOrderFinancialInfo(a, msg.BillID), status.VendorStatus)
|
||
} else if msg.MsgURL == jdapi.CallbackMsgAfterSaleBillStatus {
|
||
retVal = c.OnAfsOrderMsg(a, msg)
|
||
} else {
|
||
// 新订单事件，与订单状态有点冲突
|
||
if jdapi.StatusIDNewOrder == msg.StatusID {
|
||
retVal = c.onOrderNew(a, msg, status)
|
||
} else if jdapi.OrderStatusAdjust == msg.StatusID {
|
||
retVal = c.onOrderAdjust(a, msg, status)
|
||
} else {
|
||
if msg.StatusID == jdapi.OrderStatusAddComment || msg.StatusID == jdapi.OrderStatusModifyComment {
|
||
utils.CallFuncAsync(func() {
|
||
c.onOrderComment2(a, msg)
|
||
})
|
||
}
|
||
err := partner.CurOrderManager.OnOrderStatusChanged(vendorOrgCode, status)
|
||
retVal = jdapi.Err2CallbackResponse(err, status.VendorStatus)
|
||
}
|
||
}
|
||
return retVal
|
||
}
|
||
|
||
func updateOrderBySettleMent(order *model.GoodsOrder, orderSettlement *jdapi.OrderSettlementInfo) {
|
||
if orderSettlement != nil {
|
||
// order.WaybillTipMoney = orderSettlement.VenderPaidTips
|
||
order.TotalShopMoney = orderSettlement.SettlementAmount
|
||
order.PmSubsidyMoney = orderSettlement.PlatOrderGoodsDiscountMoney + orderSettlement.PlatSkuGoodsDiscountMoney
|
||
}
|
||
}
|
||
|
||
func (c *PurchaseHandler) getOrder(a *jdapi.API, orderID string) (order *model.GoodsOrder, orderMap map[string]interface{}, err error) {
|
||
globals.SugarLogger.Debugf("jd getOrder orderID:%s", orderID)
|
||
var (
|
||
realMobile string
|
||
orderSettlement *jdapi.OrderSettlementInfo
|
||
)
|
||
task := tasksch.NewParallelTask("jd getOrder", tasksch.NewParallelConfig().SetIsContinueWhenError(true), jxcontext.AdminCtx,
|
||
func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
|
||
taskIndex := batchItemList[0].(int)
|
||
switch taskIndex {
|
||
case 0:
|
||
orderMap, err = a.QuerySingleOrder(orderID)
|
||
if err == nil {
|
||
order = c.Map2Order(orderMap)
|
||
realMobile, _ = a.GetRealMobile4Order(orderID, order.VendorStoreID)
|
||
if realMobile != "" {
|
||
order.ConsigneeMobile2 = jxutils.FormalizeMobile(realMobile)
|
||
}
|
||
}
|
||
case 1:
|
||
orderSettlement, _ = a.OrderShoudSettlementService2(orderID)
|
||
}
|
||
return nil, err
|
||
}, []int{0, 1})
|
||
task.Run()
|
||
_, err = task.GetResult(0)
|
||
if order != nil && orderSettlement != nil {
|
||
updateOrderBySettleMent(order, orderSettlement)
|
||
}
|
||
return order, orderMap, err
|
||
}
|
||
|
||
func (c *PurchaseHandler) GetOrder(vendorOrgCode, orderID string) (order *model.GoodsOrder, err error) {
|
||
order, _, err = c.getOrder(getAPI(vendorOrgCode), orderID)
|
||
return order, err
|
||
}
|
||
|
||
func (p *PurchaseHandler) GetOrderStatus(vendorOrgCode, vendorOrderID string) (status int, err error) {
|
||
order, err := getAPI(vendorOrgCode).QuerySingleOrder2(vendorOrderID)
|
||
if err == nil {
|
||
status = p.getStatusFromVendorStatus(utils.Int2Str(order.OrderStatus))
|
||
}
|
||
return status, err
|
||
}
|
||
|
||
func (c *PurchaseHandler) Map2Order(orderData map[string]interface{}) (order *model.GoodsOrder) {
|
||
result := orderData
|
||
orderID := utils.Int64ToStr(utils.MustInterface2Int64(result["orderId"]))
|
||
globals.SugarLogger.Debugf("jd Map2Order orderID:%s", orderID)
|
||
|
||
const defaultStatusTimeField = "orderPurchaseTime"
|
||
statusTimeField := defaultStatusTimeField
|
||
if result[statusTimeField] == nil { // 814560888003021 orderPurchaseTime为空
|
||
statusTimeField = "orderStartTime"
|
||
}
|
||
order = &model.GoodsOrder{
|
||
VendorOrderID: orderID,
|
||
VendorID: model.VendorIDJD,
|
||
VendorStoreID: utils.Interface2String(result["produceStationNo"]),
|
||
StoreID: int(utils.Str2Int64WithDefault(utils.Interface2String(result["produceStationNoIsv"]), 0)),
|
||
StoreName: utils.Interface2String(result["produceStationName"]),
|
||
VendorUserID: utils.Interface2String(result["buyerPin"]),
|
||
ConsigneeName: utils.Interface2String(result["buyerFullName"]),
|
||
ConsigneeMobile: jxutils.FormalizeMobile(utils.Interface2String(result["buyerMobile"])),
|
||
ConsigneeAddress: utils.Interface2String(result["buyerFullAddress"]),
|
||
CoordinateType: model.CoordinateTypeMars,
|
||
BuyerComment: utils.TrimBlankChar(utils.Interface2String(result["orderBuyerRemark"])),
|
||
ExpectedDeliveredTime: utils.Str2TimeWithDefault(utils.Interface2String(result["orderPreEndDeliveryTime"]), utils.DefaultTimeValue),
|
||
PickDeadline: utils.Str2TimeWithDefault(utils.Interface2String(result["pickDeadline"]), utils.DefaultTimeValue), // 813951615000022 pickDeadline为空
|
||
VendorStatus: utils.Int64ToStr(utils.MustInterface2Int64(result["orderStatus"])),
|
||
OrderSeq: int(utils.MustInterface2Int64(result["orderNum"])),
|
||
StatusTime: utils.Str2Time(result[statusTimeField].(string)),
|
||
OrderCreatedAt: utils.Str2Time(result[statusTimeField].(string)),
|
||
OrderFinishedAt: utils.Str2Time(result["orderStatusTime"].(string)),
|
||
OriginalData: string(utils.MustMarshal(result)),
|
||
ActualPayPrice: utils.MustInterface2Int64(result["orderBuyerPayableMoney"]),
|
||
BaseFreightMoney: utils.Interface2Int64WithDefault(result["orderBaseFreightMoney"], 0),
|
||
DistanceFreightMoney: utils.Interface2Int64WithDefault(result["merchantPaymentDistanceFreightMoney"], 0),
|
||
DeliveryType: deliveryTypeMap[int(utils.Str2Int64WithDefault(utils.Interface2String(result["deliveryCarrierNo"]), 0))],
|
||
VendorOrgCode: utils.Interface2String(result["orgCode"]),
|
||
}
|
||
if orderInvoice, ok := result["orderInvoice"].(map[string]interface{}); ok && orderInvoice != nil {
|
||
order.InvoiceTitle = utils.Interface2String(orderInvoice["invoiceTitle"])
|
||
order.InvoiceTaxerID = utils.Interface2String(orderInvoice["invoiceDutyNo"])
|
||
order.InvoiceEmail = utils.Interface2String(orderInvoice["invoiceMail"])
|
||
}
|
||
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"].([]interface{})
|
||
for _, v := range discounts {
|
||
discount := v.(map[string]interface{})
|
||
order.DiscountMoney += utils.Interface2Int64WithDefault(discount["discountPrice"], 0)
|
||
}
|
||
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: jxutils.FloatWeight2Int(float32(utils.MustInterface2Float64(product["skuWeight"]))),
|
||
VendorPrice: utils.MustInterface2Int64(product["skuStorePrice"]),
|
||
SalePrice: utils.MustInterface2Int64(product["skuJdPrice"]),
|
||
}
|
||
if jdPromotionType := int(utils.MustInterface2Int64(product["promotionType"])); jdPromotionType != 0 && jdPromotionType != jdapi.PromotionTypeNormal {
|
||
sku.StoreSubName = utils.Int2Str(jdPromotionType)
|
||
}
|
||
if skuCostumeProperty, ok := product["skuCostumeProperty"]; ok {
|
||
sku.SkuName += skuCostumeProperty.(string)
|
||
}
|
||
if isGift, ok := product["isGift"].(bool); ok && isGift {
|
||
sku.SkuType = 1
|
||
}
|
||
order.Skus = append(order.Skus, sku)
|
||
}
|
||
jxutils.RefreshOrderSkuRelated(order)
|
||
return order
|
||
}
|
||
|
||
//
|
||
func (c *PurchaseHandler) onOrderNew(a *jdapi.API, msg *jdapi.CallbackOrderMsg, orderStatus *model.OrderStatus) (response *jdapi.CallbackResponse) {
|
||
globals.SugarLogger.Debugf("onOrderNew orderID:%s", msg.BillID)
|
||
order, orderMap, err := c.getOrder(a, msg.BillID)
|
||
if err == nil {
|
||
globals.SugarLogger.Debugf("onOrderNew2 orderID:%s", msg.BillID)
|
||
if err = partner.CurOrderManager.OnOrderNew(order, orderStatus); err == nil {
|
||
utils.CallFuncAsync(func() {
|
||
c.OnOrderDetail(a, orderMap, partner.CreatedPeration)
|
||
})
|
||
}
|
||
}
|
||
return jdapi.Err2CallbackResponse(err, "jd onOrderNew")
|
||
}
|
||
|
||
func (c *PurchaseHandler) onOrderAdjust(a *jdapi.API, msg *jdapi.CallbackOrderMsg, orderStatus *model.OrderStatus) *jdapi.CallbackResponse {
|
||
order, orderMap, err := c.getOrder(a, msg.BillID)
|
||
if err == nil {
|
||
err = partner.CurOrderManager.OnOrderAdjust(order, orderStatus)
|
||
if err == nil {
|
||
utils.CallFuncAsync(func() {
|
||
c.OnOrderDetail(a, orderMap, partner.UpdatedPeration)
|
||
})
|
||
}
|
||
}
|
||
return jdapi.Err2CallbackResponse(err, "jd onOrderAdjust")
|
||
}
|
||
|
||
func (c *PurchaseHandler) 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,
|
||
StatusTime: utils.Str2Time(msg.Timestamp),
|
||
Remark: msg.Remark,
|
||
}
|
||
if msg.MsgURL == jdapi.CallbackMsgOrderAddTips {
|
||
orderStatus.VendorStatus = jdapi.CallbackMsgOrderAddTips
|
||
}
|
||
orderStatus.Status = c.getStatusFromVendorStatus(orderStatus.VendorStatus)
|
||
return orderStatus
|
||
}
|
||
|
||
func (c *PurchaseHandler) postFakeMsg(vendorOrgCode, vendorOrderID, vendorStatus string) {
|
||
msg := &jdapi.CallbackOrderMsg{
|
||
CallbackMsg: &jdapi.CallbackMsg{
|
||
AppKey: getAPI(vendorOrgCode).GetAppKey(),
|
||
},
|
||
BillID: vendorOrderID,
|
||
StatusID: vendorStatus,
|
||
Timestamp: utils.Time2Str(time.Now()),
|
||
}
|
||
utils.CallFuncAsync(func() {
|
||
OnOrderMsg(msg)
|
||
})
|
||
}
|
||
|
||
// IPurchasePlatformHandler
|
||
func (c *PurchaseHandler) getStatusFromVendorStatus(vendorStatus string) int {
|
||
if status, ok := VendorStatus2StatusMap[vendorStatus]; ok {
|
||
return status
|
||
}
|
||
return model.OrderStatusUnknown
|
||
}
|
||
|
||
func (c *PurchaseHandler) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool, userName string) (err error) {
|
||
globals.SugarLogger.Debugf("jd AcceptOrRefuseOrder orderID:%s, isAcceptIt:%t", order.VendorOrderID, isAcceptIt)
|
||
if globals.EnableJdStoreWrite {
|
||
err = getAPI(order.VendorOrgCode).OrderAcceptOperate(order.VendorOrderID, isAcceptIt, userName)
|
||
if isAcceptIt && err == nil {
|
||
c.postFakeMsg(order.VendorOrgCode, order.VendorOrderID, jdapi.StatusIDWaitOutStore)
|
||
}
|
||
} else {
|
||
if isAcceptIt {
|
||
c.postFakeMsg(order.VendorOrgCode, order.VendorOrderID, jdapi.StatusIDWaitOutStore)
|
||
} else {
|
||
|
||
c.postFakeMsg(order.VendorOrgCode, order.VendorOrderID, jdapi.OrderStatusCanceled)
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) PickupGoods(order *model.GoodsOrder, isSelfDelivery bool, userName string) (err error) {
|
||
globals.SugarLogger.Debugf("jd PickupGoods orderID:%s, isSelfDelivery:%t", order.VendorOrderID, isSelfDelivery)
|
||
if !isSelfDelivery && globals.EnableJdStoreWrite {
|
||
_, err = getAPI(order.VendorOrgCode).OrderJDZBDelivery(order.VendorOrderID, userName)
|
||
} else {
|
||
c.postFakeMsg(order.VendorOrgCode, order.VendorOrderID, jdapi.OrderStatusFinishedPickup)
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (p *PurchaseHandler) AcceptOrRefuseFailedGetOrder(ctx *jxcontext.Context, order *model.GoodsOrder, isAcceptIt bool) (err error) {
|
||
if globals.EnableJdStoreWrite {
|
||
err = getAPI(order.VendorOrgCode).ReceiveFailedAudit(order.VendorOrderID, isAcceptIt, ctx.GetUserName(), "")
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (p *PurchaseHandler) CallCourier(ctx *jxcontext.Context, order *model.GoodsOrder) (err error) { // 拣货失败后再次招唤平台配送
|
||
if globals.EnableJdStoreWrite {
|
||
err = getAPI(order.VendorOrgCode).UrgeDispatching(order.VendorOrderID, ctx.GetUserName())
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (p *PurchaseHandler) ConfirmReceiveGoods(ctx *jxcontext.Context, order *model.GoodsOrder) (err error) { // 投递失败后确认收到退货
|
||
if globals.EnableJdStoreWrite {
|
||
err = getAPI(order.VendorOrgCode).ConfirmReceiveGoods(order.VendorOrderID)
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) Swtich2SelfDeliver(order *model.GoodsOrder, userName string) (err error) {
|
||
globals.SugarLogger.Debugf("jd Swtich2SelfDeliver orderID:%s", order.VendorOrderID)
|
||
if globals.EnableJdStoreWrite {
|
||
_, err = getAPI(order.VendorOrgCode).ModifySellerDelivery(order.VendorOrderID, userName)
|
||
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.VendorOrgCode, 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 *PurchaseHandler) Swtich2SelfDelivered(order *model.GoodsOrder, userName string) (err error) {
|
||
globals.SugarLogger.Debugf("jd Swtich2SelfDelivered orderID:%s", order.VendorOrderID)
|
||
if globals.EnableJdStoreWrite {
|
||
_, err = getAPI(order.VendorOrgCode).DeliveryEndOrder(order.VendorOrderID, userName)
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) SelfDeliverDelivering(order *model.GoodsOrder, userName string) (err error) {
|
||
globals.SugarLogger.Debugf("jd SelfDeliverDelivering orderID:%s", order.VendorOrderID)
|
||
if globals.EnableJdStoreWrite {
|
||
_, err = getAPI(order.VendorOrgCode).OrderSerllerDelivery(order.VendorOrderID, userName)
|
||
}
|
||
return err
|
||
}
|
||
|
||
// 京东送达接口都是一样的
|
||
func (c *PurchaseHandler) SelfDeliverDelivered(order *model.GoodsOrder, userName string) (err error) {
|
||
globals.SugarLogger.Debugf("jd SelfDeliverDelivered orderID:%s", order.VendorOrderID)
|
||
if globals.EnableJdStoreWrite {
|
||
err = c.Swtich2SelfDelivered(order, userName)
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) GetOrderRealMobile(ctx *jxcontext.Context, order *model.GoodsOrder) (mobile string, err error) {
|
||
mobile, err = getAPI(order.VendorOrgCode).GetRealMobile4Order(order.VendorOrderID, order.VendorStoreID)
|
||
return mobile, err
|
||
}
|
||
|
||
func (c *PurchaseHandler) AgreeOrRefuseCancel(ctx *jxcontext.Context, order *model.GoodsOrder, isAgree bool, reason string) (err error) {
|
||
if globals.EnableJdStoreWrite {
|
||
err = getAPI(order.VendorOrgCode).OrderCancelOperate(order.VendorOrderID, isAgree, ctx.GetUserName(), reason)
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) CancelOrder(ctx *jxcontext.Context, order *model.GoodsOrder, reason string) (err error) {
|
||
if globals.EnableJdStoreWrite {
|
||
err1 := c.Swtich2SelfDeliver(order, ctx.GetUserName())
|
||
if err = getAPI(order.VendorOrgCode).CancelAndRefund(order.VendorOrderID, ctx.GetUserName(), reason); err != nil {
|
||
if err1 != nil {
|
||
err = fmt.Errorf("取消订单失败，京东取消订单是要先转为自送再处理，转自送失败:%v", err1)
|
||
}
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) AdjustOrder(ctx *jxcontext.Context, order *model.GoodsOrder, removedSkuList []*model.OrderSku, reason string) (err error) {
|
||
order = jxutils.RemoveSkuFromOrder(order, removedSkuList)
|
||
var oaosAdjustDTOList []*jdapi.OAOSAdjustDTO
|
||
dtoMap := make(map[int]*jdapi.OAOSAdjustDTO)
|
||
for _, sku := range order.Skus {
|
||
skuID := jxutils.GetSkuIDFromOrderSku(sku)
|
||
if dtoMap[skuID] == nil {
|
||
dtoMap[skuID] = &jdapi.OAOSAdjustDTO{
|
||
OutSkuID: utils.Int2Str(skuID),
|
||
SkuCount: sku.Count,
|
||
}
|
||
oaosAdjustDTOList = append(oaosAdjustDTOList, dtoMap[skuID])
|
||
} else {
|
||
dtoMap[skuID].SkuCount += sku.Count
|
||
}
|
||
}
|
||
if globals.EnableJdStoreWrite {
|
||
err = getAPI(order.VendorOrgCode).AdjustOrder(order.VendorOrderID, ctx.GetUserName(), reason, oaosAdjustDTOList)
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) ListOrders(ctx *jxcontext.Context, vendorOrgCode string, parentTask tasksch.ITask, queryDate time.Time, vendorStoreID string) (vendorOrderIDs []string, err error) {
|
||
if utils.IsTimeZero(queryDate) {
|
||
return nil, fmt.Errorf("queryDate必须指定")
|
||
}
|
||
fromDate := utils.Time2Date(queryDate)
|
||
toDate := fromDate.Add(24*time.Hour - 1)
|
||
queryParam := &jdapi.OrderQueryParam{
|
||
OrderPurchaseTimeBegin: utils.Time2Str(fromDate),
|
||
OrderPurchaseTimeEnd: utils.Time2Str(toDate),
|
||
PageNo: jdapi.AllPage,
|
||
}
|
||
if vendorStoreID != "" {
|
||
queryParam.DeliveryStationNo = vendorStoreID
|
||
}
|
||
orderList, _, err := getAPI(vendorOrgCode).OrderQuery2(queryParam)
|
||
if err == nil {
|
||
vendorOrderIDs = make([]string, len(orderList))
|
||
for k, v := range orderList {
|
||
vendorOrderIDs[k] = utils.Int64ToStr(v.OrderID)
|
||
}
|
||
}
|
||
return vendorOrderIDs, err
|
||
}
|
||
|
||
func (c *PurchaseHandler) GetWaybillTip(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID, vendorOrderID, vendorWaybillID, vendorWaybillID2 string) (tipFee int64, err error) {
|
||
orderInfo, err := getAPI(vendorOrgCode).QuerySingleOrder2(vendorOrderID)
|
||
if err == nil {
|
||
tipFee = int64(orderInfo.Tips)
|
||
}
|
||
return tipFee, err
|
||
}
|
||
|
||
func (c *PurchaseHandler) UpdateWaybillTip(ctx *jxcontext.Context, vendorOrgCode, vendorStoreID, vendorOrderID, vendorWaybillID, vendorWaybillID2, cityCode string, tipFee int64) (err error) {
|
||
curTipFee, err := c.GetWaybillTip(ctx, vendorOrgCode, vendorStoreID, vendorOrderID, vendorWaybillID, vendorWaybillID2)
|
||
if err == nil {
|
||
if tipFee2Add := tipFee - curTipFee; tipFee2Add > 0 {
|
||
if globals.EnableJdStoreWrite {
|
||
err = getAPI(vendorOrgCode).OrderAddTips(vendorOrderID, int(tipFee2Add), ctx.GetUserName())
|
||
}
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
func (c *PurchaseHandler) GetSelfTakeCode(ctx *jxcontext.Context, order *model.GoodsOrder) (selfTakeCode string, err error) {
|
||
orderTrackList, err := getAPI(order.VendorOrgCode).GetByOrderNoForOaos(order.VendorOrderID)
|
||
if err == nil {
|
||
for _, v := range orderTrackList {
|
||
if v.TagCode == 180 {
|
||
searchResult := selfTakeCodeReg.FindStringSubmatch(v.MsgContent)
|
||
if searchResult != nil && len(searchResult[1]) > 0 {
|
||
selfTakeCode = searchResult[1]
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
return selfTakeCode, err
|
||
}
|
||
|
||
func (c *PurchaseHandler) ConfirmSelfTake(ctx *jxcontext.Context, order *model.GoodsOrder, selfTakeCode string) (err error) {
|
||
if globals.EnableJdStoreWrite {
|
||
err = getAPI(order.VendorOrgCode).CheckSelfPickCode(selfTakeCode, order.VendorOrderID, ctx.GetUserName())
|
||
}
|
||
return err
|
||
}
|