347 lines
14 KiB
Go
347 lines
14 KiB
Go
package wsc
|
|
|
|
import (
|
|
"errors"
|
|
"sort"
|
|
"time"
|
|
|
|
"git.rosy.net.cn/baseapi/platformapi/weimobapi"
|
|
"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/model/dao"
|
|
"git.rosy.net.cn/jx-callback/business/partner"
|
|
"git.rosy.net.cn/jx-callback/business/partner/delivery/dada"
|
|
"git.rosy.net.cn/jx-callback/globals"
|
|
"git.rosy.net.cn/jx-callback/globals/api"
|
|
)
|
|
|
|
const (
|
|
FakeOrderStatusAccepted = "fakeaccepted"
|
|
FakeOrderStatusFinishedPickup = "fakefinishedpickup"
|
|
)
|
|
|
|
const (
|
|
maxAddFee = 300 // 最大增加费用，单位为分，超过不发三方配送了
|
|
)
|
|
|
|
var (
|
|
VendorStatus2StatusMap = map[string]int{
|
|
utils.Int2Str(weimobapi.OrderStatusWait4Pay): model.OrderStatusWait4Pay,
|
|
utils.Int2Str(weimobapi.OrderStatusPayed): model.OrderStatusNew,
|
|
FakeOrderStatusAccepted: model.OrderStatusAccepted,
|
|
FakeOrderStatusFinishedPickup: model.OrderStatusFinishedPickup,
|
|
utils.Int2Str(weimobapi.OrderStatusDelivering): model.OrderStatusDelivering,
|
|
utils.Int2Str(weimobapi.OrderStatusFinished): model.OrderStatusFinished,
|
|
utils.Int2Str(weimobapi.OrderStatusCanceled): model.OrderStatusCanceled,
|
|
|
|
weimobapi.MsgEventCreateRights: model.OrderStatusLocked,
|
|
}
|
|
)
|
|
|
|
func (p *PurchaseHandler) onOrderMsg(msg *weimobapi.CallbackMsg) (response *weimobapi.CallbackResponse) {
|
|
if weimobapi.MsgEventCreateOrder == msg.Event {
|
|
order, err := p.GetOrder(utils.Int64ToStr(msg.OrderNo))
|
|
if err == nil {
|
|
order.StatusTime = msg.StatusTime
|
|
err = partner.CurOrderManager.OnOrderNew(order, order.VendorStatus)
|
|
}
|
|
return weimobapi.Err2CallbackResponse(err, "")
|
|
} else {
|
|
status, err := p.callbackMsg2Status(msg)
|
|
if status != nil {
|
|
err = partner.CurOrderManager.OnOrderStatusChanged(status)
|
|
}
|
|
response = weimobapi.Err2CallbackResponse(err, "")
|
|
}
|
|
return response
|
|
}
|
|
|
|
func (p *PurchaseHandler) callbackMsg2Status(msg *weimobapi.CallbackMsg) (orderStatus *model.OrderStatus, err error) {
|
|
orderID := utils.Int64ToStr(msg.OrderNo)
|
|
var vendorStatus string
|
|
if msg.IsFake {
|
|
vendorStatus = msg.Event
|
|
} else {
|
|
if msg.Event == weimobapi.MsgEventCreateRights {
|
|
vendorStatus = msg.Event
|
|
} else {
|
|
vendorStatus, err = p.getOrderStatus(msg.OrderNo)
|
|
}
|
|
}
|
|
if err == nil {
|
|
orderStatus = &model.OrderStatus{
|
|
VendorOrderID: orderID,
|
|
VendorID: model.VendorIDWSC,
|
|
OrderType: model.OrderTypeOrder,
|
|
RefVendorOrderID: orderID,
|
|
RefVendorID: model.VendorIDWSC,
|
|
VendorStatus: vendorStatus,
|
|
Status: p.GetStatusFromVendorStatus(vendorStatus),
|
|
StatusTime: msg.StatusTime,
|
|
Remark: "",
|
|
}
|
|
}
|
|
return orderStatus, err
|
|
}
|
|
|
|
func (p *PurchaseHandler) getOrderStatus(orderNo int64) (status string, err error) {
|
|
result, err := api.WeimobAPI.QueryOrderDetail(orderNo, false)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return utils.Int64ToStr(utils.MustInterface2Int64(result["orderStatus"])), nil
|
|
}
|
|
|
|
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) {
|
|
globals.SugarLogger.Debugf("wsc GetOrder orderID:%s", vendorOrderID)
|
|
result, err := api.WeimobAPI.QueryOrderDetail(utils.Str2Int64(vendorOrderID), false)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
order = p.Map2Order(result)
|
|
return order, err
|
|
}
|
|
|
|
func (p *PurchaseHandler) Map2Order(orderData map[string]interface{}) (order *model.GoodsOrder) {
|
|
result := orderData
|
|
vendorOrderID := utils.Int64ToStr(utils.MustInterface2Int64(result["orderNo"]))
|
|
deliveryDetail := result["deliveryDetail"].(map[string]interface{})
|
|
logisticsDeliveryDetail := deliveryDetail["logisticsDeliveryDetail"].(map[string]interface{})
|
|
// paymentInfo := result["paymentInfo"].(map[string]interface{})
|
|
order = &model.GoodsOrder{
|
|
VendorOrderID: vendorOrderID,
|
|
VendorID: model.VendorIDWSC,
|
|
VendorStoreID: utils.Int64ToStr(utils.MustInterface2Int64(result["processStoreId"])), // 这个不是通常意义上的vendor store id
|
|
// StoreID
|
|
StoreName: utils.Interface2String(logisticsDeliveryDetail["processStoreTitle"]),
|
|
ConsigneeName: utils.Interface2String(logisticsDeliveryDetail["receiverName"]),
|
|
ConsigneeMobile: utils.Interface2String(logisticsDeliveryDetail["receiverMobile"]),
|
|
ConsigneeAddress: utils.Interface2String(logisticsDeliveryDetail["receiverAddress"]),
|
|
CoordinateType: model.CoordinateTypeMars,
|
|
ConsigneeLng: jxutils.StandardCoordinate2Int(utils.Str2Float64(utils.Interface2String(logisticsDeliveryDetail["receiverLongitude"]))),
|
|
ConsigneeLat: jxutils.StandardCoordinate2Int(utils.Str2Float64(utils.Interface2String(logisticsDeliveryDetail["receiverLatitude"]))),
|
|
BuyerComment: utils.Interface2String(result["buyerRemark"]),
|
|
ExpectedDeliveredTime: utils.DefaultTimeValue,
|
|
PickDeadline: utils.DefaultTimeValue,
|
|
VendorStatus: utils.Int64ToStr(utils.MustInterface2Int64(result["orderStatus"])),
|
|
StatusTime: utils.Timestamp2Time(utils.MustInterface2Int64(result["createTime"]) / 1000),
|
|
OriginalData: string(utils.MustMarshal(result)),
|
|
ActualPayPrice: jxutils.StandardPrice2Int(utils.MustInterface2Float64(result["totalAmount"])),
|
|
BusinessType: model.BusinessTypeImmediate,
|
|
}
|
|
// if expectDeliveryTimeStr, ok := logisticsDeliveryDetail["expectDeliveryTime"].(string); ok {
|
|
// if expectDeliveryTimeStr =
|
|
// }
|
|
order.Status = p.GetStatusFromVendorStatus(order.VendorStatus)
|
|
itemList := result["itemList"].([]interface{})
|
|
for _, v := range itemList {
|
|
item := v.(map[string]interface{})
|
|
skuName := utils.Interface2String(item["goodsTitle"])
|
|
_, _, _, specUnit, _, specQuality := jxutils.SplitSkuName(skuName)
|
|
sku := &model.OrderSku{
|
|
VendorOrderID: vendorOrderID,
|
|
VendorID: model.VendorIDWSC,
|
|
Count: int(utils.MustInterface2Int64(item["skuNum"])),
|
|
SkuID: int(utils.Str2Int64(utils.Interface2String(item["skuCode"]))),
|
|
VendorSkuID: utils.Int64ToStr(utils.MustInterface2Int64(item["skuId"])),
|
|
SkuName: skuName,
|
|
Weight: jxutils.FormatSkuWeight(specQuality, specUnit), // 订单信息里没有重量，只有名字里尝试找
|
|
SalePrice: jxutils.StandardPrice2Int(utils.MustInterface2Float64(item["price"])),
|
|
}
|
|
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
|
|
}
|
|
p.arrangeSaleStore(order, utils.Interface2String(logisticsDeliveryDetail["receiverCity"]), utils.Interface2String(logisticsDeliveryDetail["receiverProvince"]))
|
|
p.setStoreOrderSeq(order)
|
|
return order
|
|
}
|
|
|
|
func (p *PurchaseHandler) GetStatusActionTimeout(statusType, status int) time.Duration {
|
|
return 0
|
|
}
|
|
|
|
func (p *PurchaseHandler) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptIt bool, userName string) (err error) {
|
|
if !isAcceptIt {
|
|
if globals.EnableStoreWrite && globals.EnableWscStoreWrite {
|
|
err = api.WeimobAPI.CancelOrder(utils.Str2Int64(order.VendorOrderID), "")
|
|
}
|
|
} else {
|
|
if jxutils.GetSaleStoreIDFromOrder(order) != 0 {
|
|
// 微商城没有确认，只有取消，模拟接受
|
|
p.postFakeMsg(utils.Str2Int64(order.VendorOrderID), FakeOrderStatusAccepted)
|
|
} else {
|
|
globals.SugarLogger.Debugf("weimob AcceptOrRefuseOrder orderID:%s can not find sale store", order.VendorOrderID)
|
|
if globals.EnableStoreWrite && globals.EnableWscStoreWrite {
|
|
err = api.WeimobAPI.CancelOrder(utils.Str2Int64(order.VendorOrderID), "没有找到合适的配送店")
|
|
}
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (p *PurchaseHandler) PickupGoods(order *model.GoodsOrder, userName string) (err error) {
|
|
if globals.EnableStoreWrite && globals.EnableWscStoreWrite {
|
|
_, err = dada.CurDeliveryHandler.CreateWaybill(order, func(deliveryFee, addFee int64) error {
|
|
if addFee > maxAddFee {
|
|
globals.SugarLogger.Infof("PickupGoods CreateWaybill orderID:%s addFee exceeded too much deliveryFee:%d, addFee:%d", order.VendorOrderID, deliveryFee, addFee)
|
|
return errors.New("配送超过基准价太多")
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
// 微商城没有拣货完成，模拟
|
|
p.postFakeMsg(utils.Str2Int64(order.VendorOrderID), FakeOrderStatusFinishedPickup)
|
|
return err
|
|
}
|
|
|
|
// 将订单从购物平台配送转为自送
|
|
func (p *PurchaseHandler) Swtich2SelfDeliver(order *model.GoodsOrder, userName string) (err error) {
|
|
if globals.EnableStoreWrite && globals.EnableWscStoreWrite {
|
|
err = api.WeimobAPI.DeliveryOrder(&weimobapi.DeliveryOrder{
|
|
OrderNo: utils.Str2Int64(order.VendorOrderID),
|
|
})
|
|
}
|
|
return err
|
|
}
|
|
|
|
// 将订单从购物平台配送转为自送后又送达
|
|
func (p *PurchaseHandler) Swtich2SelfDelivered(order *model.GoodsOrder, userName string) (err error) {
|
|
return err
|
|
}
|
|
|
|
// 完全自送的门店表示开始配送
|
|
func (p *PurchaseHandler) SelfDeliverDelivering(order *model.GoodsOrder, userName string) (err error) {
|
|
if globals.EnableStoreWrite && globals.EnableWscStoreWrite {
|
|
err = api.WeimobAPI.DeliveryOrder(&weimobapi.DeliveryOrder{
|
|
OrderNo: utils.Str2Int64(order.VendorOrderID),
|
|
})
|
|
}
|
|
return err
|
|
}
|
|
|
|
// 完全自送的门店表示配送完成
|
|
func (p *PurchaseHandler) SelfDeliverDelievered(order *model.GoodsOrder, userName string) (err error) {
|
|
return err
|
|
}
|
|
|
|
func (p *PurchaseHandler) postFakeMsg(orderNo int64, fakeStatus string) {
|
|
msg := &weimobapi.CallbackMsg{
|
|
IsFake: true,
|
|
Event: fakeStatus,
|
|
OrderNo: orderNo,
|
|
StatusTime: time.Now(),
|
|
}
|
|
utils.CallFuncAsync(func() {
|
|
OnCallbackMsg(msg)
|
|
})
|
|
}
|
|
|
|
func (p *PurchaseHandler) arrangeSaleStore(order *model.GoodsOrder, cityName, provinceName string) {
|
|
globals.SugarLogger.Debugf("arrangeSaleStore orderID:%s cityName:%s, provinceName:%s", order.VendorOrderID, cityName, provinceName)
|
|
const (
|
|
maxTryStoreWhenArrange = 5
|
|
)
|
|
db := dao.GetDB()
|
|
var selectedStore *model.Store
|
|
if true {
|
|
if storeDetail, err := dao.GetStoreDetailByVendorStoreID(db, order.VendorStoreID, model.VendorIDWSC); err == nil {
|
|
selectedStore = &storeDetail.Store
|
|
}
|
|
} else {
|
|
storeList, err := dao.GetPossibleStoresByPlaceName(db, cityName, provinceName)
|
|
if err != nil {
|
|
globals.SugarLogger.Errorf("arrangeSaleStore failed with error:%v", err)
|
|
}
|
|
globals.SugarLogger.Debugf("arrangeSaleStore possible stores orderID:%s", order.VendorOrderID)
|
|
for _, store := range storeList {
|
|
globals.SugarLogger.Debugf("orderID:%s %s:%d", order.VendorOrderID, store.Name, store.ID)
|
|
}
|
|
if len(storeList) > 0 {
|
|
distanceList := make(utils.SortList, 0)
|
|
userLng := jxutils.IntCoordinate2Standard(order.ConsigneeLng)
|
|
userLat := jxutils.IntCoordinate2Standard(order.ConsigneeLat)
|
|
for k, store := range storeList {
|
|
// 展示门店自身不参与派单
|
|
if store.VendorStoreID != order.VendorStoreID {
|
|
sortItem := &utils.SortItem{
|
|
CompareValue: int64(jxutils.EarthDistance(userLng, userLat, jxutils.IntCoordinate2Standard(store.Lng), jxutils.IntCoordinate2Standard(store.Lat)) * 1000),
|
|
Index: k,
|
|
}
|
|
distanceList = append(distanceList, sortItem)
|
|
}
|
|
}
|
|
sort.Sort(distanceList)
|
|
globals.SugarLogger.Debugf("arrangeSaleStore distance list orderID:%s", order.VendorOrderID)
|
|
for _, dist := range distanceList {
|
|
globals.SugarLogger.Debugf("orderID:%s %s:%d, distance:%d", order.VendorOrderID, storeList[dist.Index].Name, storeList[dist.Index].ID, dist.CompareValue)
|
|
}
|
|
if len(distanceList) > maxTryStoreWhenArrange {
|
|
distanceList = distanceList[:maxTryStoreWhenArrange]
|
|
}
|
|
for _, v := range distanceList {
|
|
selectedStore = &storeList[v.Index].Store
|
|
if selectedStore.DeliveryRangeType == model.DeliveryRangeTypeRadius {
|
|
distance := v.CompareValue
|
|
if distance < utils.Str2Int64(selectedStore.DeliveryRange) {
|
|
break
|
|
} else {
|
|
globals.SugarLogger.Debugf("arrangeSaleStore orderID:%s distance:%d, deliveryRange:%d", order.VendorOrderID, distance, utils.Str2Int64(selectedStore.DeliveryRange))
|
|
}
|
|
} else {
|
|
points := jxutils.CoordinateStr2Points(selectedStore.DeliveryRange)
|
|
if utils.IsPointInPolygon(userLng, userLat, points) {
|
|
break
|
|
} else {
|
|
globals.SugarLogger.Debugf("arrangeSaleStore orderID:%s userLng:%f, userLat:%f, deliveryRange:%s", order.VendorOrderID, userLng, userLat, selectedStore.DeliveryRange)
|
|
}
|
|
}
|
|
selectedStore = nil
|
|
}
|
|
}
|
|
}
|
|
if selectedStore != nil {
|
|
order.StoreID = selectedStore.ID
|
|
order.StoreName = selectedStore.Name
|
|
globals.SugarLogger.Debugf("arrangeSaleStore orderID:%s arranged to store:%d", order.VendorOrderID, selectedStore.ID)
|
|
} else {
|
|
globals.SugarLogger.Errorf("arrangeSaleStore orderID:%s 找不到门店", order.VendorOrderID)
|
|
}
|
|
}
|
|
|
|
func (p *PurchaseHandler) setStoreOrderSeq(order *model.GoodsOrder) {
|
|
if order.StoreID > 0 {
|
|
year, month, day := order.StatusTime.Date()
|
|
dateBegin := time.Date(year, month, day, 0, 0, 0, 0, order.StatusTime.Location())
|
|
// dateEnd := date1.Add(time.Hour * 24)
|
|
sql := `
|
|
SELECT COUNT(*) ct
|
|
FROM goods_order t1
|
|
WHERE t1.store_id = ? AND t1.order_created_at >= ? AND t1.vendor_id = ?
|
|
`
|
|
var count int
|
|
db := dao.GetDB()
|
|
if err := dao.GetRow(db, &count, sql, order.StoreID, dateBegin, model.VendorIDWSC); err == nil {
|
|
order.OrderSeq = count + 1
|
|
globals.SugarLogger.Debugf("setStoreOrderSeq orderID:%s, dateBegin:%s, orderSeq:%d", order.VendorOrderID, utils.Time2Str(dateBegin), order.OrderSeq)
|
|
} else {
|
|
globals.SugarLogger.Errorf("setStoreOrderSeq orderID:%s failed with error:%v", order.VendorOrderID, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (c *PurchaseHandler) RefreshRealMobile(ctx *jxcontext.Context, fromTime, toTime time.Time, isAsync, isContinueWhenError bool) (hint string, err error) {
|
|
return hint, err
|
|
}
|