jx-callback/business/partner/purchase/ebai/order.go

package ebai

import (
	"strings"
	"time"

	"git.rosy.net.cn/baseapi/platformapi/autonavi"
	"git.rosy.net.cn/baseapi/platformapi/ebaiapi"
	"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"
)

var (
	VendorStatus2StatusMap = map[string]int{
		ebaiapi.OrderStatusNew:             model.OrderStatusNew,
		ebaiapi.OrderStatusAccepted:        model.OrderStatusAccepted,
		ebaiapi.OrderStatusCourierAccepted: model.OrderStatusDelivering,
		ebaiapi.OrderStatusCourierPickedup: model.OrderStatusDelivering,
		ebaiapi.OrderStatusFinished:        model.OrderStatusFinished,
		ebaiapi.OrderStatusCanceled:        model.OrderStatusCanceled,
	}
)

func (p *PurchaseHandler) GetStatusFromVendorStatus(vendorStatus string) int {
	if status, ok := VendorStatus2StatusMap[vendorStatus]; ok {
		return status
	}
	return model.OrderStatusUnknown
}

func (p *PurchaseHandler) GetOrder(vendorOrderID string) (order *model.GoodsOrder, err error) {
	result, err := api.EbaiAPI.OrderGet(vendorOrderID)
	// globals.SugarLogger.Info(result)
	if err == nil {
		shopMap := result["shop"].(map[string]interface{})
		orderMap := result["order"].(map[string]interface{})
		userMap := result["user"].(map[string]interface{})
		order = &model.GoodsOrder{
			VendorOrderID:         vendorOrderID,
			VendorID:              model.VendorIDEBAI,
			VendorStoreID:         shopMap["baidu_shop_id"].(string),
			StoreID:               int(utils.Str2Int64WithDefault(utils.Interface2String(shopMap["id"]), 0)),
			StoreName:             shopMap["name"].(string),
			ConsigneeName:         utils.FilterMb4(userMap["name"].(string)),
			ConsigneeMobile:       userMap["phone"].(string),
			ConsigneeAddress:      utils.FilterMb4(userMap["address"].(string)),
			CoordinateType:        model.CoordinateTypeBaiDu,
			BuyerComment:          utils.FilterMb4(strings.Trim(utils.Interface2String(orderMap["remark"]), "\n\r\t ")),
			ExpectedDeliveredTime: getTimeFromTimestampStr(utils.Interface2String(orderMap["send_time"])),
			VendorStatus:          utils.Int64ToStr(utils.MustInterface2Int64(orderMap["status"])),
			OrderSeq:              int(utils.Str2Int64(utils.Interface2String(orderMap["order_index"]))),
			StatusTime:            getTimeFromTimestampStr(utils.Interface2String(orderMap["create_time"])),
			OriginalData:          utils.FilterMb4(string(utils.MustMarshal(result))),
			ActualPayPrice:        utils.MustInterface2Int64(orderMap["user_fee"]),
			Skus:                  []*model.OrderSku{},
		}
		order.Status = p.GetStatusFromVendorStatus(order.VendorStatus)
		if utils.MustInterface2Int64(orderMap["send_immediately"]) == 1 {
			order.BusinessType = model.BusinessTypeImmediate
		} else {
			order.BusinessType = model.BusinessTypeDingshida
		}

		deliveryGeo := userMap["coord"].(map[string]interface{})
		originalLng := utils.MustInterface2Float64(deliveryGeo["longitude"])
		originalLat := utils.MustInterface2Float64(deliveryGeo["latitude"])
		lng, lat, err2 := api.AutonaviAPI.CoordinateConvert(originalLng, originalLat, autonavi.CoordSysBaidu)
		if err2 == nil {
			originalLng = lng
			originalLat = lat
			order.CoordinateType = model.CoordinateTypeMars
		}
		order.ConsigneeLng = jxutils.StandardCoordinate2Int(originalLng)
		order.ConsigneeLat = jxutils.StandardCoordinate2Int(originalLat)

		products := result["products"].([]interface{})[0].([]interface{})
		// discounts := result["discount"].(map[string]interface{})
		for _, product2 := range products {
			product := product2.(map[string]interface{})
			sku := &model.OrderSku{
				VendorOrderID: order.VendorOrderID,
				VendorID:      model.VendorIDEBAI,
				Count:         int(utils.MustInterface2Int64(product["product_amount"])),
				SkuID:         int(utils.Str2Int64WithDefault(utils.Interface2String(product["custom_sku_id"]), 0)),
				VendorSkuID:   utils.Interface2String(product["baidu_product_id"]),
				SkuName:       product["product_name"].(string),
				Weight:        0, // todo
				SalePrice:     utils.MustInterface2Int64(product["product_price"]),
				// 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 (p *PurchaseHandler) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool, userName string) (err error) {
	if isAcceptIt {
		err = api.EbaiAPI.OrderConfirm(order.VendorOrderID)
	} else {
		err = api.EbaiAPI.OrderCancel(order.VendorOrderID, ebaiapi.CancelTypeCustom, "bu")
	}
	return err
}

func (p *PurchaseHandler) PickupGoods(order *model.GoodsOrder, userName string) (err error) {
	err = api.EbaiAPI.OrderCallDelivery(order.VendorOrderID)
	return err
}

// 将订单从购物平台配送转为自送
func (p *PurchaseHandler) Swtich2SelfDeliver(order *model.GoodsOrder, userName string) (err error) {
	err = api.EbaiAPI.OrderSwitchselfdelivery(order.VendorOrderID)
	return err
}

// 将订单从购物平台配送转为自送后又送达
func (p *PurchaseHandler) Swtich2SelfDelivered(order *model.GoodsOrder, userName string) (err error) {
	// todo 饿百转商家自送后，没有确认送达的概念，空操作
	return err
}

// 完全自送的门店表示开始配送
func (p *PurchaseHandler) SelfDeliverDelievering(order *model.GoodsOrder, userName string) (err error) {
	err = api.EbaiAPI.OrderSendOut(order.VendorOrderID, userName)
	return err
}

// 完全自送的门店表示配送完成
func (p *PurchaseHandler) SelfDeliverDelievered(order *model.GoodsOrder, userName string) (err error) {
	err = api.EbaiAPI.OrderComplete(order.VendorOrderID, userName)
	return err
}

//
func (c *PurchaseHandler) onOrderMsg(msg *ebaiapi.CallbackMsg) (retVal *ebaiapi.CallbackResponse) {
	if ebaiapi.CmdOrderCreate == msg.Cmd {
		retVal = c.onOrderNew(msg)
	} else {
		status := c.callbackMsg2Status(msg)
		err := partner.CurOrderManager.OnOrderStatusChanged(status)
		retVal = api.EbaiAPI.Err2CallbackResponse(msg.Cmd, err, status.VendorStatus)
	}
	return retVal
}

func (c *PurchaseHandler) onOrderNew(msg *ebaiapi.CallbackMsg) (response *ebaiapi.CallbackResponse) {
	order, err := c.GetOrder(msg.Body["order_id"].(string))
	if err == nil {
		err = partner.CurOrderManager.OnOrderNew(order, order.VendorStatus)
	}
	return api.EbaiAPI.Err2CallbackResponse(msg.Cmd, err, "ebai onOrderNew")
}

func (c *PurchaseHandler) callbackMsg2Status(msg *ebaiapi.CallbackMsg) *model.OrderStatus {
	body := msg.Body
	vendorStatus := utils.Int64ToStr(utils.MustInterface2Int64(body["status"]))
	orderStatus := &model.OrderStatus{
		VendorOrderID:    body["order_id"].(string),
		VendorID:         model.VendorIDEBAI,
		OrderType:        model.OrderTypeOrder,
		RefVendorOrderID: body["order_id"].(string),
		RefVendorID:      model.VendorIDEBAI,
		VendorStatus:     vendorStatus,
		Status:           c.GetStatusFromVendorStatus(vendorStatus),
		StatusTime:       utils.Timestamp2Time(msg.Timestamp),
		Remark:           utils.Interface2String(body["reason"]),
	}
	return orderStatus
}

func getTimeFromTimestampStr(sendTime string) time.Time {
	timeStamp := utils.Str2Int64WithDefault(sendTime, 0)
	if timeStamp == 0 {
		return utils.DefaultTimeValue
	}
	return utils.Timestamp2Time(timeStamp)
}