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

- big refactor.

Browse Source
This commit is contained in:
gazebo
2018-07-05 12:21:25 +08:00
parent c43ec48837
commit bed727d3e5
21 changed files with 140 additions and 115 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
legacy/controllers/business.go Normal file
View File

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

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

@@ -0,0 +1,20 @@
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))
}

135
legacy/elm/controller/order.go Normal file
View File

@@ -0,0 +1,135 @@
package controller
import (
"strings"
"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.MsgTypeMerchantValid && msg.Type <= elmapi.MsgTypeOrderFinished {
retVal = o.OrderStatusChanged(msg, orderID)
}
}, orderID)
return retVal
}
func OnNewOrder(orderID string, userMobile string) {
controllers.OnNewOrder(orderID, controllers.ELM_VENDERID, userMobile, 0, nil, func(acceptIt bool) {
if acceptIt {
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 {
// todo 回调消息里已经有详情，这里是否有必要再取一次？
result, err := api.ElmAPI.GetOrder(orderId)
if err != nil {
retVal = errResponseCallELMAPIError
} else {
rec.Data = 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) *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
}

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

@@ -0,0 +1,18 @@
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"
}

274
legacy/freshfood/freshfood.go Normal file
View File

@@ -0,0 +1,274 @@
package freshfood
import (
"errors"
"net/http"
"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_MTPS_DELIVERYSTATUS = "mtps/status"
URL_FRESHFOOD_MTPS_EXCEPTION = "mtps/except"
)
const (
URL_FRESHFOOD_PARA_JDORDER = "jdOrder"
URL_FRESHFOOD_PARA_VENDERID = "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"
)
const (
retryCount = 2
)
type API struct {
baseURL string
client *http.Client
}
var (
ErrFreshFooddReturnNot200 = errors.New("freshfood return code is not 200")
)
var (
FreshFoodAPI *API
)
func init() {
FreshFoodAPI = New(beego.AppConfig.String("freshFoodServerURL"))
}
func New(baseURL string) *API {
return &API{baseURL, &http.Client{Timeout: time.Second * 5}}
}
func (f *API) AccessFreshFood(apiStr string, params url.Values) error {
var err error
var response *http.Response
fullURL := f.baseURL + "/" + apiStr
for i := 0; i < retryCount; i++ {
if params != nil {
// globals.SugarLogger.Debug(params.Encode())
response, err = f.client.PostForm(fullURL, params)
} else {
response, err = f.client.Get(fullURL)
}
// err = error(nil)
// globals.SugarLogger.Debug(fullURL)
// globals.SugarLogger.Debug(params)
if err == nil && response != nil && response.StatusCode == 200 {
break
} else {
globals.SugarLogger.Infof("Call %s error:%v, response: %v", fullURL, err, response)
}
}
if err != nil || response.StatusCode != 200 {
globals.SugarLogger.Errorf("Call %s error:%v, url:%s, response: %v", fullURL, err, fullURL, response)
if err != nil {
return err
}
return ErrFreshFooddReturnNot200
}
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_VENDERID, utils.Int2Str(controllers.JD_VENDERID))
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_VENDERID, utils.Int2Str(controllers.JD_VENDERID))
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_VENDERID, utils.Int2Str(controllers.ELM_VENDERID))
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)
}
// 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)
}
func (f *API) RefreshElmToken() error {
return f.AccessFreshFood(URL_FRESHFOOD_ELEME_TOKENUPDATE, nil)
}

228
legacy/jd/controller/order.go Normal file
View File

@@ -0,0 +1,228 @@
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()
// todo 这样操作在有多个进程时，会有问题
// 另外当前这个模式可能会出现同一个定单的消息，虽然远程推送过来顺序是对的，但经过处理后推送到freshfood时乱序（因为每个消息的处理时间是不确定的）
handlePendingOrderMsg()
}
func handlePendingOrderMsg() {
var ordersInfo []models.Jdorder
db := orm.NewOrm()
_, err := db.Raw("SELECT * FROM jdorder WHERE orderstatustime >= DATE_ADD(NOW(), interval -2 day) 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_VENDERID, 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)
// todo
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 = 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 {
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 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 Normal file
View File

@@ -0,0 +1,14 @@
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"`
}

15
legacy/legacy.go Normal file
View File

@@ -0,0 +1,15 @@
package legacy
import (
"git.rosy.net.cn/baseapi/utils/routinepool"
"github.com/astaxie/beego"
)
var (
RoutinePool *routinepool.Pool
)
func init() {
routinePoolSize := beego.AppConfig.DefaultInt("routinePoolSize", 0)
RoutinePool = routinepool.New(routinePoolSize, routinePoolSize)
}

8
legacy/models/config.go Normal file
View File

@@ -0,0 +1,8 @@
package models
type Config struct {
Id int
Thirdparty string `orm:"size(20);unique"`
Token string `orm:"size(300)"`
Date string `orm:"size(30)"`
}

26
legacy/models/models.go Normal file
View File

@@ -0,0 +1,26 @@
package models
import (
"time"
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"
)
type BlackClient struct {
ID int `orm:"column(id)"`
Mobile string `orm:"size(16);unique"`
Name string `orm:"size(8)"`
Note string `orm:"size(256)"`
CreatedAt time.Time `orm:"auto_now_add;type(datetime);null"`
UpdatedAt time.Time `orm:"auto_now;type(datetime);null"`
}
func RegisterModels() {
// register model
orm.RegisterModel(new(jdmodels.Jdorder))
orm.RegisterModel(new(elmmodels.ELMOrder))
orm.RegisterModel(new(Config))
orm.RegisterModel(new(BlackClient))
}

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

@@ -0,0 +1,26 @@
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 Normal file
View File

@@ -0,0 +1,13 @@
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)"`
}

119
legacy/tasks/configrefresh.go Normal file
View File

@@ -0,0 +1,119 @@
package tasks
import (
"time"
"git.rosy.net.cn/jx-callback/globals/api"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/globals"
"git.rosy.net.cn/jx-callback/legacy/freshfood"
"git.rosy.net.cn/jx-callback/legacy/models"
"github.com/astaxie/beego/orm"
)
const (
weixinTokenExpires = 7200 * time.Second
elmTokenExpires = 20 * 24 * 3600 * time.Second
maxRefreshGap = 5 * 60 * time.Second
)
type ElmTokenForCompatible struct {
Error string `json:"error"`
ErrorDescription string `json:"error_description"`
AccessToken string `json:"accessToken"`
TokenType string `json:"tokenType"`
Expires int `json:"expires"`
RefreshToken string `json:"refreshToken"`
Success bool `json:"success"`
}
func RefreshConfig(configKey string, expiresTime time.Duration, configGetter func() string, configSetter func(value string)) {
go func() {
sleepGap := expiresTime / 10
needRefreshGap := expiresTime * 8 / 10
if sleepGap > maxRefreshGap {
sleepGap = maxRefreshGap
}
for {
curConfig := &models.Config{
Thirdparty: configKey,
}
db := orm.NewOrm()
// 0: don't refresh, 1 update, 2 insert
handleType := 0
if err := db.Read(curConfig, "Thirdparty"); err != nil {
if err != orm.ErrNoRows {
globals.SugarLogger.Errorf("db error:%v, curConfig:%v", err, curConfig)
} else {
curConfig.Token = configGetter()
handleType = 2
}
} else {
latestTimeStr := utils.Time2Str(time.Now().Add(-needRefreshGap))
if curConfig.Date <= latestTimeStr {
curConfig.Token = configGetter()
handleType = 1
}
}
if handleType != 0 {
globals.SugarLogger.Debugf("refresh %s, value:%s", configKey, curConfig.Token)
curConfig.Date = utils.GetCurTimeStr()
var num int64
var err error
if handleType == 1 {
num, err = db.Update(curConfig, "Token", "Date")
} else {
num, err = db.Insert(curConfig)
}
if err != nil || num == 0 {
globals.SugarLogger.Errorf("db error:%v, num:%d, curConfig:%v", err, num, curConfig)
} else {
configSetter(curConfig.Token)
}
}
time.Sleep(sleepGap)
}
}()
}
func RefreshWeixinToken() {
RefreshConfig("wechat", weixinTokenExpires, func() string {
if tokenInfo, err := api.WeixinAPI.RefreshToken(); err == nil {
return tokenInfo.AccessToken
}
return ""
}, func(value string) {
api.WeixinAPI.SetToken(value)
freshfood.FreshFoodAPI.RefreshWeixinToken()
})
}
func RefreshElmToken() {
RefreshConfig("eleme", elmTokenExpires, func() string {
if tokenInfo, err := api.ElmAPI.RefreshTokenIndividual(); err == nil {
tokenInfo2 := &ElmTokenForCompatible{
Error: "",
ErrorDescription: "",
AccessToken: tokenInfo.AccessToken,
TokenType: tokenInfo.TokenType,
Expires: tokenInfo.ExpiresIn,
RefreshToken: "",
Success: true,
}
return string(utils.MustMarshal(tokenInfo2))
}
return ""
}, func(value string) {
var tokenInfo ElmTokenForCompatible
err := utils.UnmarshalUseNumber([]byte(value), &tokenInfo)
if err == nil {
api.ElmAPI.SetToken(tokenInfo.AccessToken)
freshfood.FreshFoodAPI.RefreshElmToken()
}
})
}