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

- remove useless legacy codes.

Browse Source 
- refactor models
This commit is contained in:
gazebo
2018-10-16 10:47:44 +08:00
parent df19812e97
commit d7de24715b
39 changed files with 93 additions and 1248 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
legacy/controllers/business.go
View File

@@ -1,46 +0,0 @@
package controllers
import (
"git.rosy.net.cn/jx-callback/business/legacymodel"
"git.rosy.net.cn/jx-callback/globals"
"github.com/astaxie/beego/orm"
)
const (
JD_VENDORID = 0
ELM_VENDORID = 2
)
func OnNewOrder(orderID string, vendorID int, userMobile string, jxStoreID int, db orm.Ormer, handler func(accepted bool)) int {
handleType := 0
if userMobile != "" {
if db == nil {
db = orm.NewOrm()
}
user := &legacymodel.BlackClient{
Mobile: userMobile,
}
if err := db.Read(user, "Mobile"); err != nil {
if err != orm.ErrNoRows {
globals.SugarLogger.Errorf("read data error:%v, data:%v, vendorID:%d", err, user, vendorID)
}
// 在访问数据库出错的情况下，也需要自动接单
handleType = 1
} else {
// 强制拒单
globals.SugarLogger.Infof("force reject order:%s, vendorID:%d", orderID, vendorID)
handleType = -1
}
} else {
globals.SugarLogger.Infof("order:%s, vendorID:%d, mobile is empty, should accept it", orderID, vendorID)
handleType = 1
}
if handleType == 1 {
handler(true)
} else if handleType == -1 {
handler(false)
}
return handleType
}

20
legacy/dada/controller/order.go
View File

@@ -1,20 +0,0 @@
package controller
import (
"git.rosy.net.cn/baseapi/platformapi/dadaapi"
"git.rosy.net.cn/jx-callback/legacy/freshfood"
)
type OrderController struct {
}
func Error2Response(err error) *dadaapi.CallbackResponse {
if err != nil {
return dadaapi.FailedResponse
}
return dadaapi.SuccessResponse
}
func (o *OrderController) OrderStatusChanged(msg *dadaapi.CallbackMsg) *dadaapi.CallbackResponse {
return Error2Response(freshfood.FreshFoodAPI.DadaOrderStatusChanged(msg))
}

151
legacy/elm/controller/order.go
View File

@@ -1,151 +0,0 @@
package controller
import (
"strings"
"time"
"git.rosy.net.cn/baseapi"
"git.rosy.net.cn/baseapi/platformapi/elmapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/globals/api"
"git.rosy.net.cn/jx-callback/legacy"
"git.rosy.net.cn/jx-callback/legacy/controllers"
"git.rosy.net.cn/jx-callback/legacy/elm/models"
"git.rosy.net.cn/jx-callback/legacy/freshfood"
"github.com/astaxie/beego/orm"
)
var (
errResponseInternal = &elmapi.CallbackResponse{Message: "internal error"}
errResponseDataError = &elmapi.CallbackResponse{Message: "elm data error"}
errResponseDBError = &elmapi.CallbackResponse{Message: "DB error"}
errResponseCallELMAPIError = &elmapi.CallbackResponse{Message: "call ELM API error"}
)
type OrderController struct {
}
func (o *OrderController) OrderMessage(msg *elmapi.CallbackMsg) (retVal *elmapi.CallbackResponse) {
var innerMsg map[string]interface{}
err := utils.UnmarshalUseNumber([]byte(msg.Message), &innerMsg)
if err != nil {
return errResponseDataError
}
retVal = elmapi.SuccessResponse
orderID := innerMsg["orderId"].(string)
legacy.RoutinePool.CallFun(func() {
if msg.Type == elmapi.MsgTypeOrderValid {
userMobile := ""
if phoneList, ok := innerMsg["phoneList"].([]interface{}); ok && len(phoneList) >= 1 {
userMobile = phoneList[0].(string)
} else {
baseapi.SugarLogger.Warnf("elm can not get mobile info from %v, error:%v", msg, err)
}
retVal = o.NewOrder(msg, orderID, userMobile)
} else if msg.Type >= elmapi.MsgTypeOrderAccepted && msg.Type <= elmapi.MsgTypeOrderFinished {
retVal = o.OrderStatusChanged(msg, orderID, innerMsg)
} else {
retVal = o.OrderOtherMsg(msg, orderID, innerMsg)
}
}, orderID)
return retVal
}
func OnNewOrder(orderID string, userMobile string) {
controllers.OnNewOrder(orderID, controllers.ELM_VENDORID, userMobile, 0, nil, func(acceptIt bool) {
if acceptIt {
time.AfterFunc(4*time.Minute, func() {
api.ElmAPI.ConfirmOrder(orderID)
})
} else {
api.ElmAPI.CancelOrder(orderID, elmapi.CancelOrderTypeOthers, "")
}
})
}
func (o *OrderController) NewOrder(msg *elmapi.CallbackMsg, orderId string, userMobile string) *elmapi.CallbackResponse {
db := orm.NewOrm()
rec := &models.ELMOrder{
OrderId: orderId,
Type: msg.Type,
}
retVal := elmapi.SuccessResponse
created, _, err := db.ReadOrCreate(rec, "OrderId")
if err != nil {
globals.SugarLogger.Warnf("error when calling ReadOrCreate, error:%v, rec:%v", err, rec)
retVal = errResponseDBError
} else {
if created || rec.Type < msg.Type {
result, err := api.ElmAPI.GetOrder(orderId)
if err != nil {
retVal = errResponseCallELMAPIError
} else {
rec.Data = utils.FilterMb4(string(utils.MustMarshal(result)))
rec.Consignee = result["consignee"].(string)
rec.Mobile = userMobile
if createdAt, ok := result["createdAt"].(string); ok {
rec.OrderCreatedAt = strings.Replace(createdAt, "T", " ", 1)
}
num, err := db.Update(rec, "Data", "Consignee", "Mobile", "OrderCreatedAt")
if err != nil || num != 1 {
globals.SugarLogger.Warnf("error in updating order data:%v, error:%v, num:%d", msg, err, num)
retVal = errResponseDataError
} else {
err = freshfood.FreshFoodAPI.NewELMOrder(result)
if err != nil {
retVal = errResponseInternal
}
}
}
OnNewOrder(orderId, userMobile)
} else {
globals.SugarLogger.Infof("duplicate elm msg received:%v", msg)
}
}
return retVal
}
func (o *OrderController) OrderStatusChanged(msg *elmapi.CallbackMsg, orderId string, innerMsg map[string]interface{}) *elmapi.CallbackResponse {
db := orm.NewOrm()
rec := &models.ELMOrder{
OrderId: orderId,
}
err := db.Read(rec, "OrderId")
if err != nil {
globals.SugarLogger.Warnf("error when calling ReadOrCreate, error:%v, rec:%v", err, rec)
} else {
if rec.Type < msg.Type {
err = freshfood.FreshFoodAPI.ELMOrderStatus(orderId, msg.Type, utils.GetCurTimeStr())
if err == nil {
rec.Type = msg.Type
err = utils.CallFuncLogError(func() error {
_, err := db.Update(rec, "Type")
return err
}, globals.ErrStrAccessDB)
}
} else {
globals.SugarLogger.Infof("duplicate elm msg received:%v", msg)
}
}
if err != nil {
return errResponseInternal
}
return elmapi.SuccessResponse
}
func (o *OrderController) OrderOtherMsg(msg *elmapi.CallbackMsg, orderId string, innerMsg map[string]interface{}) *elmapi.CallbackResponse {
var err error
if msg.Type == elmapi.MsgTypeUserUrgeOrder {
err = freshfood.FreshFoodAPI.ELMClientUrgeOrder(orderId)
}
if err != nil {
return errResponseInternal
}
return elmapi.SuccessResponse
}

18
legacy/elm/models/order.go
View File

@@ -1,18 +0,0 @@
package models
type ELMOrder struct {
Id int
OrderId string `orm:"size(50);unique;null;column(orderid)"`
Consignee string `orm:"size(32)"`
Mobile string `orm:"size(32)"`
Data string `orm:"type(text);null"`
Type int `orm:"null"`
OrderCreatedAt string `orm:"size(50);index"`
// CreatedAt time.Time `orm:"auto_now_add;type(datetime);null"`
// UpdatedAt time.Time `orm:"auto_now;type(datetime);null"`
// StatusTime string `orm:"size(50)"`
}
func (e *ELMOrder) TableName() string {
return "elemeorder"
}

207
legacy/freshfood/freshfood.go
View File

@@ -6,89 +6,14 @@ import (
"net/url"
"time"
"git.rosy.net.cn/baseapi/platformapi/dadaapi"
"github.com/astaxie/beego"
"git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/platformapi/mtpsapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/legacy/controllers"
"git.rosy.net.cn/jx-callback/legacy/jd/models"
)
const (
URL_FRESHFOOD_ORDER_CREATE_JDDJ = "order"
URL_FRESHFOOD_ORDER_STATUS = "order/status"
URL_FRESHFOOD_ORDER_COMMENT = "comments/pushJdBadComments"
URL_FRESHFOOD_DELIVERY_STATUS = "delivery/status"
URL_FRESHFOOD_ORDER_MODIFY = "order/modify"
URL_FRESHFOOD_ELEME_TOKENUPDATE = "eleme/token/update"
URL_FRESHFOOD_ORDER_CREATE_ELEME = "order/eleme"
URL_FRESHFOOD_ELEME_USER_URGE_ORDER = "reminders/pushElmSmsReminders"
URL_FRESHFOOD_MTPS_DELIVERYSTATUS = "mtps/status"
URL_FRESHFOOD_MTPS_EXCEPTION = "mtps/except"
)
const (
URL_FRESHFOOD_PARA_JDORDER = "jdOrder"
URL_FRESHFOOD_PARA_VENDORID = "venderId"
URL_FRESHFOOD_PARA_ORDERID = "orderId"
URL_FRESHFOOD_PARA_ORDERSTATUS = "orderStatus"
URL_FRESHFOOD_PARA_ORDERSTATUSTIME = "orderStatusTime"
URL_FRESHFOOD_PARA_CITYNAME = "cityName"
URL_FRESHFOOD_PARA_BILLID = "billId"
URL_FRESHFOOD_PARA_STATUSID = "statusId"
URL_FRESHFOOD_PARA_DELIVERYSTATUS = "deliveryStatus"
URL_FRESHFOOD_PARA_DLIVERYSTATUSTIME = "deliveryStatusTime"
URL_FRESHFOOD_PARA_DELIVERYCARRIERNO = "deliveryCarrierNo"
URL_FRESHFOOD_PARA_DELIVERYCARRIERNAME = "deliveryCarrierName"
URL_FRESHFOOD_PARA_DELIVERYMANNO = "deliveryManNo"
URL_FRESHFOOD_PARA_DELIVERYMANNAME = "deliveryManName"
URL_FRESHFOOD_PARA_DELIVERYMANPHONE = "deliveryManPhone"
URL_FRESHFOOD_PARA_ELEMEORDER = "elemeOrder"
)
const (
URL_FRESHFOOD_PARA_DELIVERYID = "deliveryId"
URL_FRESHFOOD_PARA_MTPEISONID = "mtPeisongId"
// URL_FRESHFOOD_PARA_ORDERID = "orderId"
URL_FRESHFOOD_PARA_STATUS = "status"
URL_FRESHFOOD_PARA_COURIERNAME = "courierName"
URL_FRESHFOOD_PARA_COURIERPHONE = "courierPhone"
URL_FRESHFOOD_PARA_CANCELREASONID = "cancelReasonId"
URL_FRESHFOOD_PARA_CANCELREASON = "cancelReason"
URL_FRESHFOOD_PARA_APPKEY = "appkey"
URL_FRESHFOOD_PARA_TIMESTAMP = "timestamp"
URL_FRESHFOOD_PARA_SIGN = "sign"
//转发美团配送异常消息
URL_FRESHFOOD_PARA_EXCEPTIONID = "exceptionId"
URL_FRESHFOOD_PARA_EXCEPTIONCODE = "exceptionCode"
URL_FRESHFOOD_PARA_EXCEPTIONDESC = "exceptionDesc"
URL_FRESHFOOD_PARA_EXCEPTIONTIME = "exceptionTime"
)
const (
//转发美团配送配送状态
URL_FRESHFOOD_DADADELIVERY_STATUS = "dadadelivery/status"
URL_FRESHFOOD_PARA_CLIENTID = "clientId"
URL_FRESHFOOD_PARA_CANCELFROM = "cancelFrom"
URL_FRESHFOOD_PARA_UPDATETIME = "updateTime"
URL_FRESHFOOD_PARA_DMID = "dmId"
URL_FRESHFOOD_PARA_DMNAME = "dmName"
URL_FRESHFOOD_PARA_DMMOBILE = "dmMobile"
)
const (
URL_WX_UPDATE_ACCESSTOKEN = "weixin/accesstoken/update"
URL_WX_UPDATE_ACCESSTOKEN = "weixin/accesstoken/update"
URL_FRESHFOOD_ELEME_TOKENUPDATE = "eleme/token/update"
)
const (
@@ -146,134 +71,6 @@ func (f *API) AccessFreshFood(apiStr string, params url.Values) error {
return nil
}
// jd api
func (f *API) NewJDOrder(jdorder *models.Jdorder, isNew bool) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_JDORDER, string(utils.MustMarshal(jdorder)))
if isNew {
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_CREATE_JDDJ, params)
}
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_MODIFY, params)
}
func (f *API) JDOrderStatus(msg *jdapi.CallbackOrderMsg) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_VENDORID, utils.Int2Str(controllers.JD_VENDORID))
params.Set(URL_FRESHFOOD_PARA_ORDERID, msg.BillID)
params.Set(URL_FRESHFOOD_PARA_ORDERSTATUS, msg.StatusID)
params.Set(URL_FRESHFOOD_PARA_ORDERSTATUSTIME, msg.Timestamp)
params.Set(URL_FRESHFOOD_PARA_CITYNAME, "all")
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_STATUS, params)
}
func (f *API) JDOrderComment(msg *jdapi.CallbackOrderMsg) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_BILLID, msg.BillID)
params.Set(URL_FRESHFOOD_PARA_STATUSID, msg.StatusID)
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_COMMENT, params)
}
func (f *API) JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.CallbackDeliveryStatusMsg) error {
params := make(url.Values)
cityName := "all"
params.Set(URL_FRESHFOOD_PARA_VENDORID, utils.Int2Str(controllers.JD_VENDORID))
params.Set(URL_FRESHFOOD_PARA_ORDERID, jdOrderDeliveryStatusMsg.OrderID)
params.Set(URL_FRESHFOOD_PARA_DELIVERYSTATUS, jdOrderDeliveryStatusMsg.DeliveryStatus)
params.Set(URL_FRESHFOOD_PARA_DLIVERYSTATUSTIME, jdOrderDeliveryStatusMsg.DeliveryStatusTime)
params.Set(URL_FRESHFOOD_PARA_DELIVERYCARRIERNO, jdOrderDeliveryStatusMsg.DeliveryCarrierNo)
params.Set(URL_FRESHFOOD_PARA_DELIVERYCARRIERNAME, jdOrderDeliveryStatusMsg.DeliveryCarrierName)
params.Set(URL_FRESHFOOD_PARA_DELIVERYMANNO, jdOrderDeliveryStatusMsg.DeliveryManNo)
params.Set(URL_FRESHFOOD_PARA_DELIVERYMANNAME, jdOrderDeliveryStatusMsg.DeliveryManName)
params.Set(URL_FRESHFOOD_PARA_DELIVERYMANPHONE, jdOrderDeliveryStatusMsg.DeliveryManPhone)
params.Set(URL_FRESHFOOD_PARA_CITYNAME, cityName)
return f.AccessFreshFood(URL_FRESHFOOD_DELIVERY_STATUS, params)
}
// elm api
func (f *API) NewELMOrder(order map[string]interface{}) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_ELEMEORDER, string(utils.MustMarshal(order)))
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_CREATE_ELEME, params)
}
func (f *API) ELMOrderStatus(orderId string, status int, statusTime string) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_VENDORID, utils.Int2Str(controllers.ELM_VENDORID))
params.Set(URL_FRESHFOOD_PARA_ORDERID, orderId)
params.Set(URL_FRESHFOOD_PARA_ORDERSTATUS, utils.Int2Str(status))
params.Set(URL_FRESHFOOD_PARA_ORDERSTATUSTIME, statusTime)
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_STATUS, params)
}
func (f *API) ELMClientUrgeOrder(orderId string) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_VENDORID, utils.Int2Str(controllers.ELM_VENDORID))
params.Set(URL_FRESHFOOD_PARA_ORDERID, orderId)
return f.AccessFreshFood(URL_FRESHFOOD_ELEME_USER_URGE_ORDER, params)
}
// mtps api
func (f *API) MtpsOrderStatusChanged(order *mtpsapi.CallbackOrderMsg) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_DELIVERYID, utils.Int64ToStr(order.DeliveryID))
params.Set(URL_FRESHFOOD_PARA_MTPEISONID, order.MtPeisongID)
params.Set(URL_FRESHFOOD_PARA_ORDERID, order.OrderID)
params.Set(URL_FRESHFOOD_PARA_STATUS, utils.Int2Str(order.Status))
params.Set(URL_FRESHFOOD_PARA_COURIERNAME, order.CourierName)
params.Set(URL_FRESHFOOD_PARA_COURIERPHONE, order.CourierPhone)
params.Set(URL_FRESHFOOD_PARA_CANCELREASONID, utils.Int2Str(order.CancelReasonId))
params.Set(URL_FRESHFOOD_PARA_CANCELREASON, order.CancelReason)
params.Set(URL_FRESHFOOD_PARA_APPKEY, order.AppKey)
params.Set(URL_FRESHFOOD_PARA_TIMESTAMP, utils.Int64ToStr(order.Timestamp))
params.Set(URL_FRESHFOOD_PARA_SIGN, order.Sign)
return f.AccessFreshFood(URL_FRESHFOOD_MTPS_DELIVERYSTATUS, params)
}
func (f *API) MtpsOrderException(order *mtpsapi.CallbackOrderExceptionMsg) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_DELIVERYID, utils.Int64ToStr(order.DeliveryID))
params.Set(URL_FRESHFOOD_PARA_MTPEISONID, order.MtPeisongID)
params.Set(URL_FRESHFOOD_PARA_ORDERID, order.OrderID)
params.Set(URL_FRESHFOOD_PARA_EXCEPTIONID, utils.Int64ToStr(order.ExceptionID))
params.Set(URL_FRESHFOOD_PARA_EXCEPTIONCODE, utils.Int2Str(order.ExceptionCode))
params.Set(URL_FRESHFOOD_PARA_EXCEPTIONDESC, order.ExceptionDescr)
params.Set(URL_FRESHFOOD_PARA_EXCEPTIONTIME, utils.Int64ToStr(order.ExceptionTime))
params.Set(URL_FRESHFOOD_PARA_COURIERNAME, order.CourierName)
params.Set(URL_FRESHFOOD_PARA_COURIERPHONE, order.CourierPhone)
params.Set(URL_FRESHFOOD_PARA_APPKEY, order.AppKey)
params.Set(URL_FRESHFOOD_PARA_TIMESTAMP, utils.Int64ToStr(order.Timestamp))
params.Set(URL_FRESHFOOD_PARA_SIGN, order.Sign)
return f.AccessFreshFood(URL_FRESHFOOD_MTPS_EXCEPTION, params)
}
// dada
func (f *API) DadaOrderStatusChanged(msg *dadaapi.CallbackMsg) error {
params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_CLIENTID, msg.ClientID)
params.Set(URL_FRESHFOOD_PARA_ORDERID, msg.OrderID)
params.Set(URL_FRESHFOOD_PARA_ORDERSTATUS, utils.Int2Str(msg.OrderStatus))
params.Set(URL_FRESHFOOD_PARA_CANCELREASON, msg.CancelReason)
params.Set(URL_FRESHFOOD_PARA_CANCELFROM, utils.Int2Str(msg.CancelFrom))
params.Set(URL_FRESHFOOD_PARA_UPDATETIME, utils.Int2Str(msg.UpdateTime))
params.Set(URL_FRESHFOOD_PARA_DMID, utils.Int2Str(msg.DmID))
params.Set(URL_FRESHFOOD_PARA_DMNAME, msg.DmName)
params.Set(URL_FRESHFOOD_PARA_DMMOBILE, msg.DmMobile)
return f.AccessFreshFood(URL_FRESHFOOD_DADADELIVERY_STATUS, params)
}
func (f *API) RefreshWeixinToken() error {
return f.AccessFreshFood(URL_WX_UPDATE_ACCESSTOKEN, nil)
}

232
legacy/jd/controller/order.go
View File

@@ -1,232 +0,0 @@
package controller
import (
"encoding/json"
"git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/globals/api"
"git.rosy.net.cn/jx-callback/legacy/controllers"
"git.rosy.net.cn/jx-callback/legacy/freshfood"
"git.rosy.net.cn/jx-callback/legacy/jd/models"
"github.com/astaxie/beego/orm"
)
const (
MsgNotHandledCode = "NH"
)
var (
orderMsgChan chan jdapi.CallbackOrderMsg
)
type OrderController struct {
}
func InitOrder() {
orderMsgChan = make(chan jdapi.CallbackOrderMsg, 128)
go orderMsgHandlerRoutine()
// 另外当前这个模式可能会出现同一个订单的消息，虽然远程推送过来顺序是对的，但经过处理后推送到freshfood时乱序（因为每个消息的处理时间是不确定的）
handlePendingOrderMsg()
}
func handlePendingOrderMsg() {
var ordersInfo []models.Jdorder
db := orm.NewOrm()
_, err := db.Raw("SELECT * FROM jdorder WHERE orderstatustime >= DATE_FORMAT(DATE_ADD(NOW(), interval -1 day), '%Y-%m-%d %H:%i:%s') AND code = ?", MsgNotHandledCode).QueryRows(&ordersInfo)
if err != nil {
globals.SugarLogger.Errorf("can not get jdorder from db, error:%v", err)
} else {
for _, jdOrderInfo := range ordersInfo {
orderMsg := &jdapi.CallbackOrderMsg{
ID: jdOrderInfo.ID,
BillID: utils.Int64ToStr(jdOrderInfo.JdOrderID),
StatusID: utils.Int2Str(jdOrderInfo.OrderStatus),
Timestamp: jdOrderInfo.OrderStatusTime,
}
addOrderMsg(orderMsg)
}
}
}
func orderMsgHandlerRoutine() {
for {
msg := <-orderMsgChan
globals.SugarLogger.Debugf("orderMsgHandlerRoutine:%v", msg)
go handleOrderMsg(&msg)
}
}
func addOrderMsg(msg *jdapi.CallbackOrderMsg) {
globals.SugarLogger.Debugf("addOrderMsg:%v", msg)
orderMsgChan <- *msg
}
func handleOrderMsg(msg *jdapi.CallbackOrderMsg) {
globals.SugarLogger.Debugf("handleOrderMsg:%v", msg)
switch msg.StatusID {
case jdapi.OrderStatusNew:
newOrder(msg)
case jdapi.OrderStatusAdjust:
adjustOrder(msg)
default:
normalOrderStatus(msg)
}
}
// --------------
func (c *OrderController) OrderStatus(msg *jdapi.CallbackOrderMsg) *jdapi.CallbackResponse {
if msg.StatusID != jdapi.OrderStatusNew && msg.StatusID != jdapi.OrderStatusAdjust {
err := normalOrderStatus(msg)
if err != nil {
return jdapi.Err2CallbackResponse(err, "")
}
} else {
db := orm.NewOrm()
jdorderid := utils.Str2Int64(msg.BillID)
status := int(utils.Str2Int64(msg.StatusID))
rec := &models.Jdorder{
Code: MsgNotHandledCode,
JdOrderID: jdorderid,
OrderStatus: status,
OrderStatusTime: msg.Timestamp,
}
if created, _, err := db.ReadOrCreate(rec, "JdOrderID"); err == nil {
msg.ID = rec.ID
if created {
if msg.StatusID != jdapi.OrderStatusNew && msg.StatusID != jdapi.OrderStatusAdjust {
globals.SugarLogger.Warnf("order:%v get before create", msg)
oldStatusID := msg.StatusID
msg.StatusID = jdapi.OrderStatusNew
addOrderMsg(msg)
msg.StatusID = oldStatusID
}
addOrderMsg(msg)
} else {
if rec.OrderStatus != status {
if msg.StatusID == jdapi.OrderStatusNew {
globals.SugarLogger.Warnf("order:%v get after some other message:%d", msg, rec.OrderStatus)
} else {
rec.OrderStatus = status
rec.OrderStatusTime = msg.Timestamp
rec.Code = MsgNotHandledCode
utils.CallFuncLogError(func() error {
_, err := db.Update(rec, "OrderStatus", "OrderStatusTime", "Code")
return err
}, globals.ErrStrAccessDB)
addOrderMsg(msg)
}
} else {
globals.SugarLogger.Warnf("duplicated jd order msg:%v", msg)
}
}
} else {
globals.SugarLogger.Errorf("error when calling ReadOrCreate:%v", err)
return jdapi.Err2CallbackResponse(err, "")
}
}
return jdapi.SuccessResponse
}
func (c *OrderController) OrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.CallbackDeliveryStatusMsg) *jdapi.CallbackResponse {
if err := freshfood.FreshFoodAPI.JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg); err != nil {
return jdapi.Err2CallbackResponse(err, "")
}
return jdapi.SuccessResponse
}
//-----------
func OnNewOrder(msg *jdapi.CallbackOrderMsg, userMobile string, db orm.Ormer) {
controllers.OnNewOrder(msg.BillID, controllers.JD_VENDORID, userMobile, 0, db, func(acceptIt bool) {
globals.SugarLogger.Infof("OrderAcceptOperate billid:%v, acceptIt:%v", msg.BillID, acceptIt)
api.JdAPI.OrderAcceptOperate(msg.BillID, acceptIt, "")
})
}
func newOrder(msg *jdapi.CallbackOrderMsg) error {
result, err := api.JdAPI.LegacyQuerySingleOrder(msg.BillID)
userMobile := ""
var db orm.Ormer
if err == nil {
rec := &models.Jdorder{
ID: msg.ID,
}
rec.Code, _ = result["code"].(string)
rec.Msg, _ = result["msg"].(string)
rec.Success, _ = result["success"].(bool)
rec.CityName = "all"
data := result["data"].(map[string]interface{})
dataResult := data["result"].(map[string]interface{})
resultList, ok := dataResult["resultList"].([]interface{})
if ok && len(resultList) == 1 {
resultList0 := resultList[0].(map[string]interface{})
orderStatus, _ := resultList0["orderStatus"].(json.Number).Int64()
rec.JdOrderID = utils.Str2Int64(msg.BillID)
rec.OrderStatus = int(orderStatus)
rec.OrderStatusTime = resultList0["orderStatusTime"].(string)
resultByteArr := utils.MustMarshal(data)
rec.Data = utils.FilterMb4(string(resultByteArr))
rec.Data4Json = data
userMobile = resultList0["buyerMobile"].(string)
err = utils.CallFuncLogError(func() error {
db = orm.NewOrm()
_, err := db.Update(rec, "Data", "Code", "Msg", "Success", "CityName", "OrderStatus", "OrderStatusTime")
return err
}, globals.ErrStrAccessDB)
freshfood.FreshFoodAPI.NewJDOrder(rec, msg.StatusID == jdapi.OrderStatusNew)
} else {
globals.SugarLogger.Errorf("can not get jdorder info:%v", msg.BillID)
}
}
OnNewOrder(msg, userMobile, db)
return err
}
func adjustOrder(msg *jdapi.CallbackOrderMsg) error {
return newOrder(msg)
}
func normalOrderStatus(msg *jdapi.CallbackOrderMsg) (err error) {
if msg.StatusID == jdapi.OrderStatusAddComment || msg.StatusID == jdapi.OrderStatusModifyComment {
err = freshfood.FreshFoodAPI.JDOrderComment(msg)
} else {
db := orm.NewOrm()
rec := &models.Jdorder{
JdOrderID: utils.Str2Int64(msg.BillID),
}
err = db.Read(rec, "JdOrderId")
if err != nil {
if err == orm.ErrNoRows {
err = nil // 如果没有查到，不当成错误
} else {
globals.SugarLogger.Warnf("error when accessing db err:%v, rec:%v", err, rec)
}
} else {
if rec.OrderStatus == int(utils.Str2Int64(msg.StatusID)) {
globals.SugarLogger.Infof("Duplicate message msg:%v", msg)
} else {
if msg.StatusID != jdapi.OrderStatusWaitOutStore { // 老系统没有处理OrderStatusWaitOutStore，不转发
if err = freshfood.FreshFoodAPI.JDOrderStatus(msg); err == nil {
rec.OrderStatus = int(utils.Str2Int64(msg.StatusID))
rec.OrderStatusTime = msg.Timestamp
rec.Code = "0"
err = utils.CallFuncLogError(func() error {
_, err := db.Update(rec, "OrderStatus", "OrderStatusTime", "Code")
return err
}, globals.ErrStrAccessDB)
}
}
}
}
}
return err
}

14
legacy/jd/models/order.go
View File

@@ -1,14 +0,0 @@
package models
type Jdorder struct {
ID int `orm:"column(id)" json:"-"`
Code string `orm:"size(2);null" json:"code"`
Msg string `orm:"size(100);null" json:"msg"`
Data string `orm:"type(text)" json:"-"`
Data4Json map[string]interface{} `orm:"-" json:"data"`
Success bool `orm:"null" json:"success"`
JdOrderID int64 `orm:"unique;size(19);column(jdorderid);null" json:"jdOrderId"`
CityName string `orm:"size(20);column(cityname)" json:"cityName"`
OrderStatus int `orm:"column(orderstatus);null" json:"orderStatus"`
OrderStatusTime string `orm:"size(50);column(orderstatustime);null" json:"orderStatusTime"`
}

13
legacy/models/models.go
View File

@@ -1,13 +0,0 @@
package models
import (
elmmodels "git.rosy.net.cn/jx-callback/legacy/elm/models"
jdmodels "git.rosy.net.cn/jx-callback/legacy/jd/models"
"github.com/astaxie/beego/orm"
)
func RegisterModels() {
// register model
orm.RegisterModel(new(jdmodels.Jdorder))
orm.RegisterModel(new(elmmodels.ELMOrder))
}

26
legacy/mtps/controller/order.go
View File

@@ -1,26 +0,0 @@
package controller
import (
"git.rosy.net.cn/baseapi/platformapi/mtpsapi"
"git.rosy.net.cn/jx-callback/legacy/freshfood"
)
type OrderController struct {
}
func Error2Response(err error) *mtpsapi.CallbackResponse {
if err != nil {
return &mtpsapi.CallbackResponse{
Code: -1,
}
}
return mtpsapi.SuccessResponse
}
func (c *OrderController) OrderStatusChanged(order *mtpsapi.CallbackOrderMsg) *mtpsapi.CallbackResponse {
return Error2Response(freshfood.FreshFoodAPI.MtpsOrderStatusChanged(order))
}
func (c *OrderController) OrderException(order *mtpsapi.CallbackOrderExceptionMsg) *mtpsapi.CallbackResponse {
return Error2Response(freshfood.FreshFoodAPI.MtpsOrderException(order))
}

13
legacy/mtps/models/order.go
View File

@@ -1,13 +0,0 @@
package models
type MtpsOrder struct {
DeliveryId int64
MtPeisongId string `orm:"size(64);unique"`
OrderId string `orm:"size(64);unique"`
Status int
OperateTime int
CourierName string `orm:"size(16)"`
CourierPhone string `orm:"size(16)"`
CancelReasonId int
CancelReason string `orm:"size(256)"`
}

2
legacy/tasks/configrefresh.go
View File

@@ -4,7 +4,7 @@ import (
"fmt"
"time"
"git.rosy.net.cn/jx-callback/business/legacymodel"
"git.rosy.net.cn/jx-callback/business/model/legacymodel"
"git.rosy.net.cn/jx-callback/globals/api"
"git.rosy.net.cn/baseapi/utils"