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

- refactor as baseapi.

Browse Source
This commit is contained in:
gazebo
2018-06-22 22:38:30 +08:00
parent 50790b3686
commit 65593521b9
7 changed files with 82 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
business/dada/controller/order.go
View File

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

20
business/elm/controller/order.go
View File

@@ -1,7 +1,7 @@
package controller package controller
import ( import (
"git.rosy.net.cn/baseapi/platform/elmapi" "git.rosy.net.cn/baseapi/platformapi/elmapi"
"git.rosy.net.cn/baseapi/utils" "git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/elm/models" "git.rosy.net.cn/jx-callback/business/elm/models"
"git.rosy.net.cn/jx-callback/globals" "git.rosy.net.cn/jx-callback/globals"
@@ -10,31 +10,31 @@ import (
) )
var ( var (
errResponseInternal = &elmapi.ELMCallbackResponse{Message: "internal error"} errResponseInternal = &elmapi.CallbackResponse{Message: "internal error"}
errResponseDataError = &elmapi.ELMCallbackResponse{Message: "elm data error"} errResponseDataError = &elmapi.CallbackResponse{Message: "elm data error"}
errResponseDBError = &elmapi.ELMCallbackResponse{Message: "DB error"} errResponseDBError = &elmapi.CallbackResponse{Message: "DB error"}
errResponseCallELMAPIError = &elmapi.ELMCallbackResponse{Message: "call ELM API error"} errResponseCallELMAPIError = &elmapi.CallbackResponse{Message: "call ELM API error"}
) )
type OrderController struct { type OrderController struct {
} }
func (o *OrderController) OrderMessage(msg *elmapi.ELMCallbackMsg) *elmapi.ELMCallbackResponse { func (o *OrderController) OrderMessage(msg *elmapi.CallbackMsg) *elmapi.CallbackResponse {
var innerMsg map[string]interface{} var innerMsg map[string]interface{}
err := utils.UnmarshalUseNumber([]byte(msg.Message), &innerMsg) err := utils.UnmarshalUseNumber([]byte(msg.Message), &innerMsg)
if err != nil { if err != nil {
globals.SugarLogger.Warnf("OrderMessage unmarshal %v error:%v", msg, err) globals.SugarLogger.Warnf("OrderMessage unmarshal %v error:%v", msg, err)
return errResponseDataError return errResponseDataError
} }
if msg.Type == elmapi.OrderValid { if msg.Type == elmapi.MsgTypeOrderValid {
return o.NewOrder(msg, innerMsg["id"].(string)) return o.NewOrder(msg, innerMsg["id"].(string))
} else if msg.Type >= elmapi.MerchantValid && msg.Type <= elmapi.OrderFinished { } else if msg.Type >= elmapi.MsgTypeMerchantValid && msg.Type <= elmapi.MsgTypeOrderFinished {
return o.OrderStatusChanged(msg, innerMsg["orderId"].(string)) return o.OrderStatusChanged(msg, innerMsg["orderId"].(string))
} }
return elmapi.SuccessResponse return elmapi.SuccessResponse
} }
func (o *OrderController) NewOrder(msg *elmapi.ELMCallbackMsg, orderId string) *elmapi.ELMCallbackResponse { func (o *OrderController) NewOrder(msg *elmapi.CallbackMsg, orderId string) *elmapi.CallbackResponse {
db := orm.NewOrm() db := orm.NewOrm()
rec := &models.ELMOrder{ rec := &models.ELMOrder{
OrderId: orderId, OrderId: orderId,
@@ -63,7 +63,7 @@ func (o *OrderController) NewOrder(msg *elmapi.ELMCallbackMsg, orderId string) *
return elmapi.SuccessResponse return elmapi.SuccessResponse
} }
func (o *OrderController) OrderStatusChanged(msg *elmapi.ELMCallbackMsg, orderId string) *elmapi.ELMCallbackResponse { func (o *OrderController) OrderStatusChanged(msg *elmapi.CallbackMsg, orderId string) *elmapi.CallbackResponse {
db := orm.NewOrm() db := orm.NewOrm()
rec := &models.ELMOrder{ rec := &models.ELMOrder{
OrderId: orderId, OrderId: orderId,

26
business/freshfood/freshfood.go
View File

@@ -5,10 +5,10 @@ import (
"net/url" "net/url"
"time" "time"
"git.rosy.net.cn/baseapi/platform/dadaapi" "git.rosy.net.cn/baseapi/platformapi/dadaapi"
"git.rosy.net.cn/baseapi/platform/jdapi" "git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/platform/mtpsapi" "git.rosy.net.cn/baseapi/platformapi/mtpsapi"
"git.rosy.net.cn/baseapi/utils" "git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jd/models" "git.rosy.net.cn/jx-callback/business/jd/models"
"git.rosy.net.cn/jx-callback/globals" "git.rosy.net.cn/jx-callback/globals"
@@ -119,7 +119,7 @@ func (f *FreshFoodAPI) NewJDOrder(jdorder *models.Jdorder) error {
params := make(url.Values) params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_JDORDER, string(utils.MustMarshal(jdorder))) params.Set(URL_FRESHFOOD_PARA_JDORDER, string(utils.MustMarshal(jdorder)))
if jdorder.OrderStatus == utils.Str2Int(jdapi.JdOrderStatusNew) { if jdorder.OrderStatus == utils.Str2Int(jdapi.OrderStatusNew) {
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_CREATE_JDDJ, params) return f.AccessFreshFood(URL_FRESHFOOD_ORDER_CREATE_JDDJ, params)
} }
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_MODIFY, params) return f.AccessFreshFood(URL_FRESHFOOD_ORDER_MODIFY, params)
@@ -137,12 +137,12 @@ func (f *FreshFoodAPI) JDOrderStatus(jdorder *models.Jdorder) error {
return f.AccessFreshFood(URL_FRESHFOOD_ORDER_STATUS, params) return f.AccessFreshFood(URL_FRESHFOOD_ORDER_STATUS, params)
} }
func (f *FreshFoodAPI) JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.JDDeliveryStatusMsg) error { func (f *FreshFoodAPI) JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.CallbackDeliveryStatusMsg) error {
params := make(url.Values) params := make(url.Values)
cityName := "all" cityName := "all"
params.Set(URL_FRESHFOOD_PARA_VENDERID, utils.Int2Str(JD_VENDERID)) params.Set(URL_FRESHFOOD_PARA_VENDERID, utils.Int2Str(JD_VENDERID))
params.Set(URL_FRESHFOOD_PARA_ORDERID, jdOrderDeliveryStatusMsg.OrderId) params.Set(URL_FRESHFOOD_PARA_ORDERID, jdOrderDeliveryStatusMsg.OrderID)
params.Set(URL_FRESHFOOD_PARA_DELIVERYSTATUS, utils.Int2Str(jdOrderDeliveryStatusMsg.DeliveryStatus)) params.Set(URL_FRESHFOOD_PARA_DELIVERYSTATUS, utils.Int2Str(jdOrderDeliveryStatusMsg.DeliveryStatus))
params.Set(URL_FRESHFOOD_PARA_DLIVERYSTATUSTIME, jdOrderDeliveryStatusMsg.DeliveryStatusTime) params.Set(URL_FRESHFOOD_PARA_DLIVERYSTATUSTIME, jdOrderDeliveryStatusMsg.DeliveryStatusTime)
params.Set(URL_FRESHFOOD_PARA_DELIVERYCARRIERNO, jdOrderDeliveryStatusMsg.DeliveryCarrierNo) params.Set(URL_FRESHFOOD_PARA_DELIVERYCARRIERNO, jdOrderDeliveryStatusMsg.DeliveryCarrierNo)
@@ -175,7 +175,7 @@ func (f *FreshFoodAPI) ELMOrderStatus(orderId string, status int, timestamp int6
} }
// mtps api // mtps api
func (f *FreshFoodAPI) MtpsOrderStatusChanged(order *mtpsapi.MtpsCallbackOrderMsg) error { func (f *FreshFoodAPI) MtpsOrderStatusChanged(order *mtpsapi.CallbackOrderMsg) error {
params := make(url.Values) params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_DELIVERYID, utils.Int64ToStr(order.DeliveryId)) params.Set(URL_FRESHFOOD_PARA_DELIVERYID, utils.Int64ToStr(order.DeliveryId))
params.Set(URL_FRESHFOOD_PARA_MTPEISONID, order.MtPeisongId) params.Set(URL_FRESHFOOD_PARA_MTPEISONID, order.MtPeisongId)
@@ -192,12 +192,12 @@ func (f *FreshFoodAPI) MtpsOrderStatusChanged(order *mtpsapi.MtpsCallbackOrderMs
return f.AccessFreshFood(URL_FRESHFOOD_MTPS_DELIVERYSTATUS, params) return f.AccessFreshFood(URL_FRESHFOOD_MTPS_DELIVERYSTATUS, params)
} }
func (f *FreshFoodAPI) MtpsOrderException(order *mtpsapi.MtpsCallbackOrderExceptionMsg) error { func (f *FreshFoodAPI) MtpsOrderException(order *mtpsapi.CallbackOrderExceptionMsg) error {
params := make(url.Values) params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_DELIVERYID, utils.Int64ToStr(order.DeliveryId)) params.Set(URL_FRESHFOOD_PARA_DELIVERYID, utils.Int64ToStr(order.DeliveryId))
params.Set(URL_FRESHFOOD_PARA_MTPEISONID, order.MtPeisongId) params.Set(URL_FRESHFOOD_PARA_MTPEISONID, order.MtPeisongId)
params.Set(URL_FRESHFOOD_PARA_ORDERID, order.OrderId) params.Set(URL_FRESHFOOD_PARA_ORDERID, order.OrderId)
params.Set(URL_FRESHFOOD_PARA_EXCEPTIONID, utils.Int64ToStr(order.ExceptionId)) 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_EXCEPTIONCODE, utils.Int2Str(order.ExceptionCode))
params.Set(URL_FRESHFOOD_PARA_EXCEPTIONDESC, order.ExceptionDescr) params.Set(URL_FRESHFOOD_PARA_EXCEPTIONDESC, order.ExceptionDescr)
params.Set(URL_FRESHFOOD_PARA_EXCEPTIONTIME, utils.Int64ToStr(order.ExceptionTime)) params.Set(URL_FRESHFOOD_PARA_EXCEPTIONTIME, utils.Int64ToStr(order.ExceptionTime))
@@ -212,15 +212,15 @@ func (f *FreshFoodAPI) MtpsOrderException(order *mtpsapi.MtpsCallbackOrderExcept
// dada // dada
func (f *FreshFoodAPI) DadaOrderStatusChanged(msg *dadaapi.DadaCallbackMsg) error { func (f *FreshFoodAPI) DadaOrderStatusChanged(msg *dadaapi.CallbackMsg) error {
params := make(url.Values) params := make(url.Values)
params.Set(URL_FRESHFOOD_PARA_CLIENTID, msg.ClientId) params.Set(URL_FRESHFOOD_PARA_CLIENTID, msg.ClientID)
params.Set(URL_FRESHFOOD_PARA_ORDERID, msg.OrderId) params.Set(URL_FRESHFOOD_PARA_ORDERID, msg.OrderID)
params.Set(URL_FRESHFOOD_PARA_ORDERSTATUS, utils.Int2Str(msg.OrderStatus)) params.Set(URL_FRESHFOOD_PARA_ORDERSTATUS, utils.Int2Str(msg.OrderStatus))
params.Set(URL_FRESHFOOD_PARA_CANCELREASON, msg.CancelReason) params.Set(URL_FRESHFOOD_PARA_CANCELREASON, msg.CancelReason)
params.Set(URL_FRESHFOOD_PARA_CANCELFROM, utils.Int2Str(msg.CancelFrom)) 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_UPDATETIME, utils.Int2Str(msg.UpdateTime))
params.Set(URL_FRESHFOOD_PARA_DMID, utils.Int2Str(msg.DmId)) params.Set(URL_FRESHFOOD_PARA_DMID, utils.Int2Str(msg.DmID))
params.Set(URL_FRESHFOOD_PARA_DMNAME, msg.DmName) params.Set(URL_FRESHFOOD_PARA_DMNAME, msg.DmName)
params.Set(URL_FRESHFOOD_PARA_DMMOBILE, msg.DmMobile) params.Set(URL_FRESHFOOD_PARA_DMMOBILE, msg.DmMobile)

76
business/jd/controller/order.go
View File

@@ -3,7 +3,7 @@ package controller
import ( import (
"encoding/json" "encoding/json"
"git.rosy.net.cn/baseapi/platform/jdapi" "git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/utils" "git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-callback/business/jd/models" "git.rosy.net.cn/jx-callback/business/jd/models"
"git.rosy.net.cn/jx-callback/compat/corm" "git.rosy.net.cn/jx-callback/compat/corm"
@@ -18,7 +18,7 @@ const (
var ( var (
errChecker corm.DBErrorChecker errChecker corm.DBErrorChecker
orderMsgChan chan jdapi.JDOrderMsg orderMsgChan chan jdapi.CallbackOrderMsg
) )
type OrderController struct { type OrderController struct {
@@ -27,7 +27,7 @@ type OrderController struct {
func InitOrder() { func InitOrder() {
errChecker = new(corm.MysqlErrorChecker) errChecker = new(corm.MysqlErrorChecker)
orderMsgChan = make(chan jdapi.JDOrderMsg, 128) orderMsgChan = make(chan jdapi.CallbackOrderMsg, 128)
go orderMsgHandlerRoutine() go orderMsgHandlerRoutine()
// todo 这样操作在有多个进程时，会有问题 // todo 这样操作在有多个进程时，会有问题
@@ -43,10 +43,10 @@ func handlePendingOrderMsg() {
globals.SugarLogger.Errorf("can not get jdorder from db, error:%v", err) globals.SugarLogger.Errorf("can not get jdorder from db, error:%v", err)
} else { } else {
for _, jdOrderInfo := range ordersInfo { for _, jdOrderInfo := range ordersInfo {
orderMsg := &jdapi.JDOrderMsg{ orderMsg := &jdapi.CallbackOrderMsg{
Id: jdOrderInfo.Id, ID: jdOrderInfo.Id,
BillId: utils.Int64ToStr(jdOrderInfo.JdOrderId), BillID: utils.Int64ToStr(jdOrderInfo.JdOrderId),
StatusId: utils.Int2Str(jdOrderInfo.OrderStatus), StatusID: utils.Int2Str(jdOrderInfo.OrderStatus),
Timestamp: jdOrderInfo.OrderStatusTime, Timestamp: jdOrderInfo.OrderStatusTime,
} }
@@ -63,17 +63,17 @@ func orderMsgHandlerRoutine() {
} }
} }
func addOrderMsg(orderMsg *jdapi.JDOrderMsg) { func addOrderMsg(orderMsg *jdapi.CallbackOrderMsg) {
globals.SugarLogger.Debugf("addOrderMsg:%v", orderMsg) globals.SugarLogger.Debugf("addOrderMsg:%v", orderMsg)
orderMsgChan <- *orderMsg orderMsgChan <- *orderMsg
} }
func handleOrderMsg(orderMsg *jdapi.JDOrderMsg) { func handleOrderMsg(orderMsg *jdapi.CallbackOrderMsg) {
globals.SugarLogger.Debugf("handleOrderMsg:%v", orderMsg) globals.SugarLogger.Debugf("handleOrderMsg:%v", orderMsg)
switch orderMsg.StatusId { switch orderMsg.StatusID {
case jdapi.JdOrderStatusNew: case jdapi.OrderStatusNew:
newOrder(orderMsg) newOrder(orderMsg)
case jdapi.JdOrderStatusAdjust: case jdapi.OrderStatusAdjust:
adjustOrder(orderMsg) adjustOrder(orderMsg)
default: default:
normalOrderStatus(orderMsg) normalOrderStatus(orderMsg)
@@ -81,16 +81,16 @@ func handleOrderMsg(orderMsg *jdapi.JDOrderMsg) {
} }
// -------------- // --------------
func (c *OrderController) OrderStatus(order *jdapi.JDOrderMsg) *jdapi.JDCallbackResponse { func (c *OrderController) OrderStatus(order *jdapi.CallbackOrderMsg) *jdapi.CallbackResponse {
if order.StatusId != jdapi.JdOrderStatusNew && order.StatusId != jdapi.JdOrderStatusAdjust { if order.StatusID != jdapi.OrderStatusNew && order.StatusID != jdapi.OrderStatusAdjust {
err := normalOrderStatus(order) err := normalOrderStatus(order)
if err != nil { if err != nil {
return &jdapi.JDCallbackResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""} return &jdapi.CallbackResponse{jdapi.ResponseCodeAccessFailed, err.Error(), ""}
} }
} else { } else {
db := orm.NewOrm() db := orm.NewOrm()
jdorderid := utils.Str2Int64(order.BillId) jdorderid := utils.Str2Int64(order.BillID)
status := utils.Str2Int(order.StatusId) status := utils.Str2Int(order.StatusID)
rec := &models.Jdorder{ rec := &models.Jdorder{
Code: MsgNotHandledCode, Code: MsgNotHandledCode,
JdOrderId: jdorderid, JdOrderId: jdorderid,
@@ -99,19 +99,19 @@ func (c *OrderController) OrderStatus(order *jdapi.JDOrderMsg) *jdapi.JDCallback
} }
if created, _, err := db.ReadOrCreate(rec, "Jdorderid"); err == nil { if created, _, err := db.ReadOrCreate(rec, "Jdorderid"); err == nil {
order.Id = rec.Id order.ID = rec.Id
if created { if created {
if order.StatusId != jdapi.JdOrderStatusNew && order.StatusId != jdapi.JdOrderStatusAdjust { if order.StatusID != jdapi.OrderStatusNew && order.StatusID != jdapi.OrderStatusAdjust {
globals.SugarLogger.Warnf("order:%v get before create", order) globals.SugarLogger.Warnf("order:%v get before create", order)
oldStatusId := order.StatusId oldStatusId := order.StatusID
order.StatusId = jdapi.JdOrderStatusNew order.StatusID = jdapi.OrderStatusNew
addOrderMsg(order) addOrderMsg(order)
order.StatusId = oldStatusId order.StatusID = oldStatusId
} }
addOrderMsg(order) addOrderMsg(order)
} else { } else {
if rec.OrderStatus != status { if rec.OrderStatus != status {
if order.StatusId == jdapi.JdOrderStatusNew { if order.StatusID == jdapi.OrderStatusNew {
globals.SugarLogger.Warnf("order:%v get after some other message:%d", order, rec.OrderStatus) globals.SugarLogger.Warnf("order:%v get after some other message:%d", order, rec.OrderStatus)
} else { } else {
rec.OrderStatus = status rec.OrderStatus = status
@@ -129,36 +129,36 @@ func (c *OrderController) OrderStatus(order *jdapi.JDOrderMsg) *jdapi.JDCallback
} }
} else { } else {
globals.SugarLogger.Errorf("error when calling ReadOrCreate:%v", err) globals.SugarLogger.Errorf("error when calling ReadOrCreate:%v", err)
return &jdapi.JDCallbackResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""} return &jdapi.CallbackResponse{jdapi.ResponseCodeAccessFailed, err.Error(), ""}
} }
} }
return jdapi.SuccessResponse return jdapi.SuccessResponse
} }
func (c *OrderController) OrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.JDDeliveryStatusMsg) *jdapi.JDCallbackResponse { func (c *OrderController) OrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.CallbackDeliveryStatusMsg) *jdapi.CallbackResponse {
err := globals2.FreshFoodAPI.JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg) err := globals2.FreshFoodAPI.JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg)
if err != nil { if err != nil {
globals.SugarLogger.Errorf("Error when calling JDOrderDeliveryStatus, error:%v", err) globals.SugarLogger.Errorf("Error when calling JDOrderDeliveryStatus, error:%v", err)
return &jdapi.JDCallbackResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""} return &jdapi.CallbackResponse{jdapi.ResponseCodeAccessFailed, err.Error(), ""}
} }
return jdapi.SuccessResponse return jdapi.SuccessResponse
} }
//----------- //-----------
func acceptOrder(order *jdapi.JDOrderMsg) { func acceptOrder(order *jdapi.CallbackOrderMsg) {
globals2.Jdapi.OrderAcceptOperate(order.BillId, true) globals2.Jdapi.OrderAcceptOperate(order.BillID, true)
} }
func newOrder(order *jdapi.JDOrderMsg) error { func newOrder(order *jdapi.CallbackOrderMsg) error {
result, err := globals2.Jdapi.LegacyQuerySingleOrder(order.BillId) result, err := globals2.Jdapi.LegacyQuerySingleOrder(order.BillID)
acceptOrder(order) acceptOrder(order)
if err != nil { if err != nil {
globals.SugarLogger.Errorf("error when query jd order:%s, error:%v", order.BillId, err) globals.SugarLogger.Errorf("error when query jd order:%s, error:%v", order.BillID, err)
} else { } else {
rec := &models.Jdorder{ rec := &models.Jdorder{
Id: order.Id, Id: order.ID,
} }
rec.Code, _ = result["code"].(string) rec.Code, _ = result["code"].(string)
@@ -195,20 +195,20 @@ func newOrder(order *jdapi.JDOrderMsg) error {
globals.SugarLogger.Errorf("Error when calling NewJDOrder error:%v", err) globals.SugarLogger.Errorf("Error when calling NewJDOrder error:%v", err)
} }
} else { } else {
globals.SugarLogger.Warnf("can not get jdorder info:%v", order.BillId) globals.SugarLogger.Warnf("can not get jdorder info:%v", order.BillID)
} }
} }
return err return err
} }
func adjustOrder(order *jdapi.JDOrderMsg) error { func adjustOrder(order *jdapi.CallbackOrderMsg) error {
return newOrder(order) return newOrder(order)
} }
func normalOrderStatus(order *jdapi.JDOrderMsg) error { func normalOrderStatus(order *jdapi.CallbackOrderMsg) error {
db := orm.NewOrm() db := orm.NewOrm()
rec := &models.Jdorder{ rec := &models.Jdorder{
JdOrderId: utils.Str2Int64(order.BillId), JdOrderId: utils.Str2Int64(order.BillID),
} }
err := db.Read(rec, "JdOrderId") err := db.Read(rec, "JdOrderId")
@@ -217,12 +217,12 @@ func normalOrderStatus(order *jdapi.JDOrderMsg) error {
return err return err
} }
if rec.OrderStatus == utils.Str2Int(order.StatusId) { if rec.OrderStatus == utils.Str2Int(order.StatusID) {
globals.SugarLogger.Infof("Duplicate message order:%v", order) globals.SugarLogger.Infof("Duplicate message order:%v", order)
return nil return nil
} }
rec.OrderStatus = utils.Str2Int(order.StatusId) rec.OrderStatus = utils.Str2Int(order.StatusID)
rec.OrderStatusTime = order.Timestamp rec.OrderStatusTime = order.Timestamp
err = globals2.FreshFoodAPI.JDOrderStatus(rec) err = globals2.FreshFoodAPI.JDOrderStatus(rec)
if err != nil { if err != nil {

10
business/mtps/controller/order.go
View File

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

2
controllers/elm_order.go
View File

@@ -1,7 +1,7 @@
package controllers package controllers
import ( import (
"git.rosy.net.cn/baseapi/platform/elmapi" "git.rosy.net.cn/baseapi/platformapi/elmapi"
"git.rosy.net.cn/jx-callback/business/elm/controller" "git.rosy.net.cn/jx-callback/business/elm/controller"
"git.rosy.net.cn/jx-callback/globals/globals2" "git.rosy.net.cn/jx-callback/globals/globals2"
"github.com/astaxie/beego" "github.com/astaxie/beego"

24
globals/globals2/globals2.go
View File

@@ -1,10 +1,10 @@
package globals2 package globals2
import ( import (
"git.rosy.net.cn/baseapi/platform/dadaapi" "git.rosy.net.cn/baseapi/platformapi/dadaapi"
"git.rosy.net.cn/baseapi/platform/elmapi" "git.rosy.net.cn/baseapi/platformapi/elmapi"
"git.rosy.net.cn/baseapi/platform/jdapi" "git.rosy.net.cn/baseapi/platformapi/jdapi"
"git.rosy.net.cn/baseapi/platform/mtpsapi" "git.rosy.net.cn/baseapi/platformapi/mtpsapi"
"git.rosy.net.cn/baseapi/utils" "git.rosy.net.cn/baseapi/utils"
elmmodels "git.rosy.net.cn/jx-callback/business/elm/models" elmmodels "git.rosy.net.cn/jx-callback/business/elm/models"
"git.rosy.net.cn/jx-callback/business/freshfood" "git.rosy.net.cn/jx-callback/business/freshfood"
@@ -69,19 +69,19 @@ const (
var ( var (
FreshFoodAPI *freshfood.FreshFoodAPI FreshFoodAPI *freshfood.FreshFoodAPI
Jdapi *jdapi.JDAPI Jdapi *jdapi.API
ElmAPI *elmapi.ELMAPI ElmAPI *elmapi.API
MtpsAPI *mtpsapi.MTPSAPI MtpsAPI *mtpsapi.API
DadaAPI *dadaapi.DadaAPI DadaAPI *dadaapi.API
) )
func init() { func init() {
initDB() initDB()
FreshFoodAPI = freshfood.NewFreshFoodAPI(freshFoodServerURL) FreshFoodAPI = freshfood.NewFreshFoodAPI(freshFoodServerURL)
Jdapi = jdapi.NewJDAPI(jdToken, jdAppKey, jdSecret) Jdapi = jdapi.New(jdToken, jdAppKey, jdSecret)
initElm() initElm()
MtpsAPI = mtpsapi.NewMTPSAPI(mtpsAppKey, mtpsSecret) MtpsAPI = mtpsapi.New(mtpsAppKey, mtpsSecret)
DadaAPI = dadaapi.NewDadaAPI(dadaAppKey, dadaAppSecret, dadaSourceId, dadaCallbackURL, dadaIsProd) DadaAPI = dadaapi.New(dadaAppKey, dadaAppSecret, dadaSourceId, dadaCallbackURL, dadaIsProd)
} }
func initElm() { func initElm() {
@@ -100,7 +100,7 @@ func initElm() {
} }
token = tokenInfo2["accessToken"].(string) token = tokenInfo2["accessToken"].(string)
} }
ElmAPI = elmapi.NewELMAPI(token, elmAppKey, elmSecret, elmIsProd) ElmAPI = elmapi.New(token, elmAppKey, elmSecret, elmIsProd)
} }
func initDB() { func initDB() {