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

Merge branch 'jdshop' of https://e.coding.net/rosydev/jx-callback into jdshop

Browse Source
This commit is contained in:
richboo111
2022-11-29 09:05:21 +08:00
parent a1304627c8 3df9487a73
commit 5b8fca3e93
7 changed files with 101 additions and 165 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
business/jxcallback/scheduler/defsch/defsch.go
View File

@@ -764,6 +764,7 @@ func (s *DefScheduler) OnWaybillStatusChanged(bill *model.Waybill, isPending boo
if err2 != nil {
partner.CurOrderManager.OnOrderMsg(order, "送达设置失败", err2.Error())
}
}
if !s.isBillCandidate(order, bill) {
// 一般只会消息乱序才会到这里，即新订单消息在运单接单消息后到达
@@ -781,6 +782,9 @@ func (s *DefScheduler) OnWaybillStatusChanged(bill *model.Waybill, isPending boo
// if order.WaybillVendorID == model.VendorIDUnknown {
// s.createWaybillOn3rdProviders(savedOrderInfo, 0, nil)
// }
// 将订单修改为完成状态
order.Status = model.OrderStatusFinished
partner.CurOrderManager.UpdateOrderFields(order, []string{"status"})
default:
s.resetTimer(savedOrderInfo, bill, isPending)
}

2
business/jxstore/cms/store.go
View File

@@ -4442,7 +4442,7 @@ func RefreshTiktokShopToken(ctx *jxcontext.Context) (err error) {
v.Token = string(token)
v.UpdatedAt = time.Now()
v.StoreBrandName = "定时任务更新"
dao.UpdateEntity(db, v, "Token", "UpdatedAt", "Comment")
dao.UpdateEntity(db, v, "Token", "UpdatedAt", "StoreBrandName")
}
}
}

38
business/partner/delivery/mtps/waybill.go
View File

@@ -126,6 +126,44 @@ func (c *DeliveryHandler) onWaybillMsg(msg *mtpsapi.CallbackOrderMsg) (retVal *m
// 加入调度器
err := mtpsapi.Err2CallbackResponse(partner.CurOrderManager.OnWaybillStatusChanged(order), order.VendorStatus)
defer delivery.GetOrderRiderInfoToPlatform(order.VendorOrderID, order.Status) // 骑手位置更新
if order.OrderVendorID == model.VendorIDDD {
result := &mtpsapi.RiderInfo{
OrderId: order.VendorOrderID,
ThirdCarrierOrderId: order.VendorOrderID,
CourierName: order.CourierName,
CourierPhone: order.CourierMobile,
LogisticsProviderCode: "10032",
LogisticsStatus: order.Status,
OpCode: "",
}
switch msg.Status {
case mtpsapi.OrderStatusWaitingForSchedule: // 待接单,召唤骑手
result.LogisticsStatus = model.WaybillStatusNew
result.LogisticsContext = model.RiderWaitRider
case mtpsapi.OrderStatusAccepted: // 已接单
result.LogisticsStatus = model.WaybillStatusCourierAssigned // 分配骑手
result.LogisticsContext = model.RiderWaitGetGoods
case mtpsapi.OrderStatusDeliverred: // 完成
result.LogisticsStatus = model.WaybillStatusDelivered
result.LogisticsContext = model.RiderGetOrderDelivered
case mtpsapi.OrderStatusCanceled: // 取消
result.LogisticsStatus = model.WaybillStatusCanceled
result.LogisticsContext = model.RiderGetOrderCanceled
case mtpsapi.OrderStatusPickedUp: // 骑手到店
result.LogisticsStatus = model.WaybillStatusCourierArrived
result.LogisticsContext = model.RiderToStore
default:
result.LogisticsStatus = 0
result.LogisticsContext = model.RiderGetOrderDeliverOther
}
delivery.PullTiktokRiderInfo(result)
if result.LogisticsStatus == model.WaybillStatusCourierArrived {
result.LogisticsStatus = model.WaybillStatusDelivering
result.LogisticsContext = model.RiderGetOrderDelivering
delivery.PullTiktokRiderInfo(result)
}
}
return err
}

51
business/partner/purchase/tiktok_store/callback.go
View File

@@ -1,19 +1,68 @@
package tiktok_store
import (
"encoding/json"
tiktokShop "git.rosy.net.cn/baseapi/platformapi/tiktok_shop/tiktok_api"
"git.rosy.net.cn/jx-callback/business/jxutils"
"git.rosy.net.cn/jx-callback/business/model"
"git.rosy.net.cn/jx-callback/globals/api"
"net/http"
"strings"
)
// OnOrderMsg 抖音
func OnOrderMsg(msgId string, msg interface{}) (response *tiktokShop.CallbackResponse) {
if CurPurchaseHandler != nil {
orderId, _ := api.TiktokStore.GetCallbackOrderId(msgId, msg)
orderId, shopId, _ := api.TiktokStore.GetCallbackOrderId(msgId, msg)
if shopId != 0 {
//storeDetail, err := dao.GetStoreDetailByVendorStoreID(dao.GetDB(), utils.Int64ToStr(shopId), model.VendorIDDD, "")
//globals.SugarLogger.Debugf("==storeDetail=: %s", utils.Format4Output(storeDetail, false))
//globals.SugarLogger.Debugf("==err=: %s", utils.Format4Output(err, false))
//if err != nil || storeDetail == nil || storeDetail.Store.ID == 0 {
// // 当前订单所属门店不属于菜市时,将消息推送到果园
// gyMsg := map[string]interface{}{"tag": msgId, "msg_id": utils.Int64ToStr(time.Now().Unix()) + msgId, "data": msg}
// // 通知到果园
// gyResult, err := HttpToGuoYuan(gyMsg, "order")
// if err != nil {
// return tiktokShop.Err2CallbackResponse(err, "")
// }
// result, _ := ioutil.ReadAll(gyResult.Body)
// var guoYuan *tiktokShop.CallbackResponse
// if err := json.Unmarshal(result, guoYuan); err != nil {
// return tiktokShop.Err2CallbackResponse(err, "")
// }
// return guoYuan
//}
}
jxutils.CallMsgHandler(func() {
response = CurPurchaseHandler.onOrderMsg(msgId, orderId, msg)
}, jxutils.ComposeUniversalOrderID(orderId, model.VendorIDDD))
}
return response
}
func HttpToGuoYuan(param map[string]interface{}, requestType string) (*http.Response, error) {
paramData, err := json.Marshal(param)
if err != nil {
return nil, err
}
body := strings.NewReader(string(paramData))
url := ""
switch requestType {
case "order": // 订单相关
url = "http://callback-jxgy.jxc4.com/tiktok/callbackTiktokOrderMsg"
case "token": // 授权相关
case "wayBill": // 授权相关
}
httpReq, err := http.NewRequest(http.MethodPost, url, body)
if err != nil {
return nil, err
}
httpReq.Header.Set("Content-Type", "application/json")
httpRes, err := http.DefaultClient.Do(httpReq)
return httpRes, err
}

8
business/partner/purchase/tiktok_store/order.go
View File

@@ -285,7 +285,7 @@ func (c *PurchaseHandler) onOrderMsg(msgId, orderId string, msg interface{}) (re
}
// 已经支付的订单,当做新订单创建在平台内部 -----------------
if msgId == tiktokShop.CallbackPayOrderMsgTagId {
if msgId == tiktokShop.CallbackPayOrderMsgTagId || msgId == tiktokShop.CallbackChangeMoneyMsgTagId {
order, err := c.GetOrder(utils.Int64ToStr(appOrgCode), orderId, "") // 获取平台订单详情,制作本地订单
if err != nil {
return tiktokShop.Err2CallbackResponse(err, "")
@@ -552,11 +552,7 @@ func (c *PurchaseHandler) AcceptOrRefuseOrder(order *model.GoodsOrder, isAcceptI
// PickupGoods 拣货完成 (抖音无拣货接口)
func (c *PurchaseHandler) PickupGoods(order *model.GoodsOrder, isSelfDelivery bool, userName string) (err error) {
// 通知平台拣货完成,抖店只需要本地拣货完成
//if !isSelfDelivery {
// if globals.EnableMtwmStoreWrite {
// err = getAPI(order.VendorOrgCode, jxutils.GetSaleStoreIDFromOrder(order), "").PreparationMealComplete(utils.Str2Int64(order.VendorOrderID))
// }
//}
// 抖音需要订单在门店的营业时间范围内最多超过营业时间内才自动拣货
c.postFakeMsg(order.VendorOrderID, FakeMsgType, fakeFinishedPickup, order.VendorOrgCode)
return nil
}

157
controllers/tiktok_order.go
View File

@@ -1,11 +1,7 @@
package controllers
import (
"encoding/json"
"git.rosy.net.cn/baseapi/platformapi/tiktok_shop/tiktok_api"
"git.rosy.net.cn/baseapi/utils"
"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/purchase/tiktok_store"
"git.rosy.net.cn/jx-callback/globals/api"
"github.com/astaxie/beego/server/web"
@@ -54,156 +50,3 @@ func (t *TiktokController) CallbackTiktokOrderMsg() {
t.ServeJSON()
}
func TiktokMsgChange(orderStatus []byte) (map[string][]interface{}, *tiktok_api.CallbackResponse) {
var resp []*tiktok_api.OrderCallback
if err := json.Unmarshal(orderStatus, &resp); err != nil {
return nil, &tiktok_api.CallbackResponse{Code: tiktok_api.CallbackFailCode, Msg: tiktok_api.CallbackFail}
}
callbackResult := make(map[string][]interface{}, 0)
for _, data := range resp {
switch data.Tag {
case tiktok_api.CallbackCreatedOrderMsgTagId: // 创建订单
create := tiktok_api.CreateOrderData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackCreatedOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackCreatedOrderMsgTagId], create)
vendorStoreId := utils.Int64ToStr(create.ShopId)
storeDetail, _ := dao.GetStoreDetailByVendorStoreID(dao.GetDB(), vendorStoreId, model.VendorIDDD, "")
if storeDetail != nil && storeDetail.Store.ID != 0 && storeDetail.Store.BrandID == model.BrandIdChengShan { // 成山农场订单
} else if storeDetail != nil && storeDetail.Store.ID != 0 { // 当前菜市系统订单
continue
} else { // 果园订单
}
case tiktok_api.CallbackPayOrderMsgTagId: // 支付订单
create := tiktok_api.PayOrderData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackPayOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackPayOrderMsgTagId], create)
case tiktok_api.CallbackWaitOrderMsgTagId: // 支付订单待处理(风控审核)
create := tiktok_api.WaitOrderData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackWaitOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackWaitOrderMsgTagId], create)
case tiktok_api.CallbackPartGoodsMsgTagId: // 卖家部分发货
create := tiktok_api.SomeSendOrderData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackPartGoodsMsgTagId] = append(callbackResult[tiktok_api.CallbackPartGoodsMsgTagId], create)
case tiktok_api.CallbackPartAllGoodsMsgTagId: // 卖家发货
create := tiktok_api.BusinessDeliveryData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackPartAllGoodsMsgTagId] = append(callbackResult[tiktok_api.CallbackPartAllGoodsMsgTagId], create)
case tiktok_api.CallbackCancelOrderMsgTagId: // 取消订单
create := tiktok_api.CreateOrderData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackCancelOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackCancelOrderMsgTagId], create)
case tiktok_api.CallbackSuccessOrderMsgTagId: // 卖家确认收货时,会自动完成
create := tiktok_api.SuccessOrderData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackSuccessOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackSuccessOrderMsgTagId], create)
case tiktok_api.CallbackWayBillChangeOrderMsgTagId: // 发货物流消息便跟
create := tiktok_api.WayBillChangeData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackWayBillChangeOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackWayBillChangeOrderMsgTagId], create)
case tiktok_api.CallbackReceivingChangeOrderMsgTagId: // 收货地址消息变更(商家审核通过触发)
create := tiktok_api.ReceivingAddressChangeData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackReceivingChangeOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackReceivingChangeOrderMsgTagId], create)
case tiktok_api.CallbackChangeMoneyMsgTagId: // 卖家修改订单/运单金额回调
create := tiktok_api.UpdateAmountChangeData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackChangeMoneyMsgTagId] = append(callbackResult[tiktok_api.CallbackChangeMoneyMsgTagId], create)
case tiktok_api.CallbackBusinessRemarkMsgTagId: // 买家收货消息变更(手机,地址,姓名),用户C端修改触发(需要上面审核接口)
create := tiktok_api.BuyerUpdateWayBillData{}
if err := json.Unmarshal([]byte(data.Data), create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackBusinessRemarkMsgTagId] = append(callbackResult[tiktok_api.CallbackBusinessRemarkMsgTagId], create)
case tiktok_api.CallbackApplyUpdateAddressMsgTagId: // 商家修改交易备注回调
create := tiktok_api.BusinessUpdateRemakeData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackApplyUpdateAddressMsgTagId] = append(callbackResult[tiktok_api.CallbackApplyUpdateAddressMsgTagId], create)
case tiktok_api.CallbackSendOrderTimeChangeMsgTagId: // 订单发货时消息变更回调
create := tiktok_api.AppointmentChangeData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackSendOrderTimeChangeMsgTagId] = append(callbackResult[tiktok_api.CallbackSendOrderTimeChangeMsgTagId], create)
/*********下面属于订单退货消息************/
case tiktok_api.CallbackRefundOrderMsgTagId: // 买家发起售后申请消息
create := tiktok_api.BuyerRefundCreatedData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackRefundOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackRefundOrderMsgTagId], create)
case tiktok_api.CallbackUpdateRefundOrderMsgTagId: // 买家修改售后申请消息
create := tiktok_api.BuyerRefundModifiedData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackUpdateRefundOrderMsgTagId] = append(callbackResult[tiktok_api.CallbackUpdateRefundOrderMsgTagId], create)
case tiktok_api.CallbackRefundOrderSuccessMsgTagId: // 退款成功消息
create := tiktok_api.BusinessRefundSuccessData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackRefundOrderSuccessMsgTagId] = append(callbackResult[tiktok_api.CallbackRefundOrderSuccessMsgTagId], create)
case tiktok_api.CallbackRefundOrderRefuseMsgTagId: // 拒绝退款消息
create := tiktok_api.BusinessNotRefundRefusedData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackRefundOrderRefuseMsgTagId] = append(callbackResult[tiktok_api.CallbackRefundOrderRefuseMsgTagId], create)
case tiktok_api.CallbackRefundShopMsgTagId: // 拒绝退货申请消息
create := tiktok_api.BusinessNotReturnApplyRefusedData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackRefundShopMsgTagId] = append(callbackResult[tiktok_api.CallbackRefundShopMsgTagId], create)
case tiktok_api.CallbackReturnApplyAgreedMsgTagId: // 卖家同意时，推送此消息
create := tiktok_api.BusinessReturnApplyAgreedData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackReturnApplyAgreedMsgTagId] = append(callbackResult[tiktok_api.CallbackReturnApplyAgreedMsgTagId], create)
case tiktok_api.CallbackReturnRefundAgreedMsgTagId: // 同意退款消息
create := tiktok_api.BusinessRefundAgreedData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackReturnRefundAgreedMsgTagId] = append(callbackResult[tiktok_api.CallbackReturnRefundAgreedMsgTagId], create)
case tiktok_api.CallbackRefundClosedMsgTagId:
create := tiktok_api.UserCancelRefundOrderData{}
if err := json.Unmarshal([]byte(data.Data), &create); err != nil {
return nil, tiktok_api.CallbackResponseErr(false)
}
callbackResult[tiktok_api.CallbackRefundClosedMsgTagId] = append(callbackResult[tiktok_api.CallbackRefundClosedMsgTagId], create)
default:
return nil, tiktok_api.CallbackResponseErr(false)
}
}
return callbackResult, &tiktok_api.CallbackResponse{Code: tiktok_api.CallbackSuccessCode, Msg: tiktok_api.CallbackSuccess}
}

6
controllers/tiktok_store.go
View File

@@ -149,6 +149,12 @@ func (c *TiktokShopController) TokenMsg() {
c.ServeJSON()
return
}
// 授权码发生变化,通知到果园
{
}
c.Data["json"] = tiktok_api.CallbackResponse{Code: tiktok_api.CallbackSuccessCode, Msg: tiktok_api.CallbackSuccess}
c.ServeJSON()
}