jx-callback/business/controller/jd/order.go

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/controller"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/scheduler"
	"git.rosy.net.cn/jx-callback/globals"
	"git.rosy.net.cn/jx-callback/globals/api"
)

type OrderController struct {
	scheduler.BasePurchasePlatform
}

func init() {
	scheduler.CurrentScheduler.RegisterPurchasePlatform(model.VendorIDJD, new(OrderController))
}

func (c *OrderController) OnOrderMsg(msg *jdapi.CallbackOrderMsg) (retVal *jdapi.CallbackResponse) {
	controller.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)
		switch msg.StatusID {
		case jdapi.OrderStatusWaitOutStore:
			status.Status = model.OrderStatusAccepted
		case jdapi.OrderStatusFinishedPickup:
			status.Status = model.OrderStatusFinishedPickup
		case jdapi.OrderStatusDelivering:
			status.Status = model.OrderStatusDelivering
		case jdapi.OrderStatusDelivered:
			status.Status = model.OrderStatusDelivered
		case jdapi.OrderStatusCanceled:
			status.Status = model.OrderStatusCanceled
		case jdapi.OrderStatusUserApplyCancel:
			status.Status = model.OrderStatusApplyCancel
		default:
			status.Status = model.OrderStatusUnknown
		}
		err := controller.OrderManager.OnOrderStatusChanged(status)
		// if globals.HandleLegacyJxOrder && err == nil {
		// 	c.legacyJdOrderStatusChanged(status)
		// }
		retVal = jdapi.Err2CallbackResponse(err, status.VendorStatus)
	}
	return retVal
}

func (c *OrderController) getOrderInfo(msg *jdapi.CallbackOrderMsg) (order *model.GoodsOrder, err error) {
	result, err := api.JdAPI.QuerySingleOrder(msg.BillID)
	// globals.SugarLogger.Info(result)
	if err == nil {
		order = &model.GoodsOrder{
			VendorOrderID:         msg.BillID,
			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:          msg.StatusID,
			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{},
		}
		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: msg.BillID,
				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
		}
	}
	return order, err
}

//
func (c *OrderController) onOrderNew(msg *jdapi.CallbackOrderMsg) (response *jdapi.CallbackResponse) {
	order, err := c.getOrderInfo(msg)
	if err == nil {
		order.Status = model.OrderStatusNew
		err = controller.OrderManager.OnOrderNew(order)
		// 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.getOrderInfo(msg)
	if err == nil {
		order.Status = model.OrderStatusAdjust
		err = controller.OrderManager.OnOrderAdjust(order)
		// 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,
		StatusTime:       utils.Str2Time(msg.Timestamp),
	}
	return orderStatus
}

// PurchasePlatformHandler
func (c *OrderController) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool) (err error) {
	globals.SugarLogger.Infof("AcceptOrRefuseOrder order:%v", order.VendorOrderID)
	return nil

	_, err = api.JdAPI.OrderAcceptOperate(order.VendorOrderID, isAcceptIt)
	return err
}

func (c *OrderController) PickedUpGoods(order *model.GoodsOrder) (err error) {
	globals.SugarLogger.Infof("PickedUpGoods order:%v", order)
	return nil

	_, err = api.JdAPI.OrderJDZBDelivery(order.VendorOrderID)
	return c.translateOrderRelatedErr(err)
}

func (c *OrderController) Swtich2SelfDeliver(vendorOrderID string) (err error) {
	globals.SugarLogger.Infof("Swtich2SelfDeliver order:%v", vendorOrderID)
	return nil

	_, err = api.JdAPI.ModifySellerDelivery(vendorOrderID)
	return c.translateOrderRelatedErr(err)
}

func (c *OrderController) SelfDeliverDelievering(order *model.GoodsOrder) (err error) {
	globals.SugarLogger.Infof("SelfDeliverDelievering order:%v", order)
	return nil

	_, err = api.JdAPI.OrderSerllerDelivery(order.VendorOrderID)
	return c.translateOrderRelatedErr(err)
}

func (c *OrderController) SelfDeliverDelievered(order *model.GoodsOrder) (err error) {
	globals.SugarLogger.Infof("SelfDeliverDelievered order:%v", order)
	return nil

	_, err = api.JdAPI.DeliveryEndOrder(order.VendorOrderID)
	return err
}

func (c *OrderController) translateOrderRelatedErr(err error) (retVal error) {
	if err != nil {
		if errWithCode, ok := err.(*utils.ErrorWithCode); ok {
			if errWithCode.Level() == 1 && errWithCode.Code() == jdapi.ResponseInnerCodeOrderAlreadyPickedUp {
				return nil
			}
		}
		return scheduler.ErrStatusIsNotOKForOperation
	}
	return nil
}