- mtps added.

- refactor.

business/business.go

@@ -1,21 +0,0 @@
-package controller
-
-import (
-	elmmodels "git.rosy.net.cn/jx-callback/business/elm/models"
-	"git.rosy.net.cn/jx-callback/business/jd/models"
-	"github.com/astaxie/beego/orm"
-	_ "github.com/go-sql-driver/mysql" // import your used driver
-)
-
-// 确定这个init是最先执行的
-func init() {
-	// set default database
-	orm.RegisterDataBase("default", "mysql", "root:WebServer@1@tcp(127.0.0.1:3306)/jx-callback?charset=utf8&loc=Local", 30)
-
-	// register model
-	orm.RegisterModel(new(models.Jdorder))
-	orm.RegisterModel(new(elmmodels.ELMOrder))
-
-	// create table
-	orm.RunSyncdb("default", false, true)
-}

business/elm/controller/controller.go

@@ -1,40 +0,0 @@
-package controller
-
-import (
-	"git.rosy.net.cn/baseapi/platform/elmapi"
-	"git.rosy.net.cn/baseapi/utils"
-	"git.rosy.net.cn/jx-callback/globals"
-	"github.com/astaxie/beego/orm"
-	"go.uber.org/zap"
-)
-
-const (
-	elmToken  = "" //"bab2a27f99562f394b411dbb9a6214da"
-	elmAppKey = "KLRDcOZGrk"
-	elmSecret = "1fc221f8265506531da36fb613d5f5ad673f2e9a"
-)
-
-var (
-	gElmAPI     *elmapi.ELMAPI
-	sugarLogger *zap.SugaredLogger
-)
-
-func init() {
-	sugarLogger = globals.SugarLogger
-	token := elmToken
-	if token == "" {
-		db := orm.NewOrm()
-		var tokenInfo []orm.Params
-		num, err := db.Raw("SELECT * FROM thirdpartytoken WHERE thirdparty='eleme'").Values(&tokenInfo)
-		if err != nil || num != 1 {
-			panic(err.Error())
-		}
-
-		var tokenInfo2 map[string]interface{}
-		if err := utils.UnmarshalUseNumber([]byte(tokenInfo[0]["token"].(string)), &tokenInfo2); err != nil {
-			panic(err.Error())
-		}
-		token = tokenInfo2["accessToken"].(string)
-	}
-	gElmAPI = elmapi.NewELMAPI(token, elmAppKey, elmSecret, sugarLogger, true)
-}

business/elm/controller/order.go

@@ -22,7 +22,7 @@ func (o *OrderController) OrderMessage(msg *elmapi.ELMCallbackMsg) *elmapi.ELMCa
 	var innerMsg map[string]interface{}
 	err := utils.UnmarshalUseNumber([]byte(msg.Message), &innerMsg)
 	if err != nil {
-		sugarLogger.Warnf("OrderMessage unmarshal %v error:%v", msg, err)
+		globals.SugarLogger.Warnf("OrderMessage unmarshal %v error:%v", msg, err)
 		return errResponseDataError
 	}
 	if msg.Type == elmapi.OrderValid {
@@ -30,7 +30,7 @@ func (o *OrderController) OrderMessage(msg *elmapi.ELMCallbackMsg) *elmapi.ELMCa
 	} else if msg.Type >= elmapi.MerchantValid && msg.Type <= elmapi.OrderFinished {
 		return o.OrderStatusChanged(msg, innerMsg["orderId"].(string))
 	}
-	return elmapi.ELMResponseOK
+	return elmapi.SuccessResponse
 }
 
 func (o *OrderController) NewOrder(msg *elmapi.ELMCallbackMsg, orderId string) *elmapi.ELMCallbackResponse {
@@ -42,24 +42,24 @@ func (o *OrderController) NewOrder(msg *elmapi.ELMCallbackMsg, orderId string) *
 
 	created, _, err := db.ReadOrCreate(rec, "OrderId")
 	if err != nil {
-		sugarLogger.Warnf("error when calling ReadOrCreate, error:%v", err)
+		globals.SugarLogger.Warnf("error when calling ReadOrCreate, error:%v", err)
 		return errResponseDBError
 	}
 	if created || rec.Type != msg.Type {
-		result, err := gElmAPI.GetOrder(orderId)
+		result, err := globals.ElmAPI.GetOrder(orderId)
 		if err != nil {
-			sugarLogger.Warnf("call GetOrder error:%v", err)
+			globals.SugarLogger.Warnf("call GetOrder error:%v", err)
 			return errResponseCallELMAPIError
 		}
 		err = globals.FreshFoodAPI.NewELMOrder(result)
 		if err != nil {
-			sugarLogger.Warnf("internal error:%v", err)
+			globals.SugarLogger.Warnf("internal error:%v", err)
 			return errResponseInternal
 		}
 	} else {
-		sugarLogger.Infof("duplicate elm msg received:%v", msg)
+		globals.SugarLogger.Infof("duplicate elm msg received:%v", msg)
 	}
-	return elmapi.ELMResponseOK
+	return elmapi.SuccessResponse
 }
 
 func (o *OrderController) OrderStatusChanged(msg *elmapi.ELMCallbackMsg, orderId string) *elmapi.ELMCallbackResponse {
@@ -70,17 +70,17 @@ func (o *OrderController) OrderStatusChanged(msg *elmapi.ELMCallbackMsg, orderId
 
 	err := db.Read(rec, "OrderId")
 	if err != nil {
-		sugarLogger.Warnf("error when calling ReadOrCreate, error:%v", err)
+		globals.SugarLogger.Warnf("error when calling ReadOrCreate, error:%v", err)
 		return errResponseDBError
 	}
 	if rec.Type != msg.Type {
 		err = globals.FreshFoodAPI.ELMOrderStatus(orderId, msg.Type, utils.GetCurTimestamp())
 		if err != nil {
-			sugarLogger.Warnf("internal error:%v", err)
+			globals.SugarLogger.Warnf("internal error:%v", err)
 			return errResponseInternal
 		}
 	} else {
-		sugarLogger.Infof("duplicate elm msg received:%v", msg)
+		globals.SugarLogger.Infof("duplicate elm msg received:%v", msg)
 	}
-	return elmapi.ELMResponseOK
+	return elmapi.SuccessResponse
 }

business/freshfood/freshfood.go

@@ -6,11 +6,25 @@ import (
 	"time"
 
 	"git.rosy.net.cn/baseapi/platform/jdapi"
+	"git.rosy.net.cn/baseapi/platform/mtpsapi"
 	"git.rosy.net.cn/baseapi/utils"
 	"git.rosy.net.cn/jx-callback/business/jd/models"
 	"go.uber.org/zap"
 )
 
+const (
+	URL_FRESHFOOD_ORDER_CREATE_JDDJ = "order"
+	URL_FRESHFOOD_ORDER_STATUS      = "order/status"
+	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"
 
@@ -31,6 +45,26 @@ const (
 	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 (
 	JD_VENDERID  = 0
 	ELM_VENDERID = 2
@@ -50,7 +84,7 @@ func NewFreshFoodAPI(baseURL string, sugarredLogger *zap.SugaredLogger) *FreshFo
 	return &FreshFoodAPI{baseURL, sugarredLogger, &http.Client{Timeout: time.Second * 5}}
 }
 
-func (f *FreshFoodAPI) AccessFreshFodd(apiStr string, params url.Values) error {
+func (f *FreshFoodAPI) AccessFreshFood(apiStr string, params url.Values) error {
 	var err error
 	fullURL := f.baseURL + "/" + apiStr
 	for i := 0; i < retryCount; i++ {
@@ -68,7 +102,11 @@ func (f *FreshFoodAPI) AccessFreshFodd(apiStr string, params url.Values) error {
 func (f *FreshFoodAPI) NewJDOrder(jdorder *models.Jdorder) error {
 	params := make(url.Values)
 	params.Set(URL_FRESHFOOD_PARA_JDORDER, string(utils.MustMarshal(jdorder)))
-	return f.AccessFreshFodd("order", params)
+
+	if jdorder.OrderStatus == utils.Str2Int(jdapi.JdOrderStatusNew) {
+		return f.AccessFreshFood(URL_FRESHFOOD_ORDER_CREATE_JDDJ, params)
+	}
+	return f.AccessFreshFood(URL_FRESHFOOD_ORDER_MODIFY, params)
 }
 
 // todo venderId
@@ -80,7 +118,7 @@ func (f *FreshFoodAPI) JDOrderStatus(jdorder *models.Jdorder) error {
 	params.Set(URL_FRESHFOOD_PARA_ORDERSTATUSTIME, jdorder.OrderStatusTime)
 	params.Set(URL_FRESHFOOD_PARA_CITYNAME, jdorder.CityName)
 
-	return f.AccessFreshFodd("order/status", params)
+	return f.AccessFreshFood(URL_FRESHFOOD_ORDER_STATUS, params)
 }
 
 func (f *FreshFoodAPI) JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.JDDeliveryStatusMsg) error {
@@ -100,16 +138,15 @@ func (f *FreshFoodAPI) JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.JDD
 
 	params.Set(URL_FRESHFOOD_PARA_CITYNAME, cityName)
 
-	return f.AccessFreshFodd("delivery/status", params)
+	return f.AccessFreshFood(URL_FRESHFOOD_DELIVERY_STATUS, params)
 }
 
 // elm api
 func (f *FreshFoodAPI) NewELMOrder(order map[string]interface{}) error {
-	str := string(utils.MustMarshal(order))
 	params := make(url.Values)
-	params.Set(URL_FRESHFOOD_PARA_ELEMEORDER, str)
+	params.Set(URL_FRESHFOOD_PARA_ELEMEORDER, string(utils.MustMarshal(order)))
 
-	return f.AccessFreshFodd("order/eleme", params)
+	return f.AccessFreshFood(URL_FRESHFOOD_ORDER_CREATE_ELEME, params)
 }
 
 func (f *FreshFoodAPI) ELMOrderStatus(orderId string, status int, timestamp int64) error {
@@ -119,5 +156,43 @@ func (f *FreshFoodAPI) ELMOrderStatus(orderId string, status int, timestamp int6
 	params.Set(URL_FRESHFOOD_PARA_ORDERSTATUS, utils.Int2Str(status))
 	params.Set(URL_FRESHFOOD_PARA_ORDERSTATUSTIME, utils.Timestamp2Str(timestamp))
 
-	return f.AccessFreshFodd("order/status", params)
+	return f.AccessFreshFood(URL_FRESHFOOD_PARA_ORDERSTATUS, params)
+}
+
+// mtps api
+func (f *FreshFoodAPI) MtpsOrderStatusChanged(order *mtpsapi.MtpsCallbackOrderMsg) 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 *FreshFoodAPI) MtpsOrderException(order *mtpsapi.MtpsCallbackOrderExceptionMsg) 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)
 }

business/jd/controller/controller.go

@@ -1,19 +0,0 @@
-package controller
-
-import (
-	"git.rosy.net.cn/baseapi/platform/jdapi"
-	"git.rosy.net.cn/jx-callback/globals"
-	"go.uber.org/zap"
-)
-
-var (
-	gJdapi            *jdapi.JDAPI
-	sugarLogger       *zap.SugaredLogger
-	jdSuccessResponse = &jdapi.JDOrderMsgResponse{Code: "0", Msg: "success", Data: ""}
-)
-
-func init() {
-	sugarLogger = globals.SugarLogger
-	gJdapi = jdapi.NewJDAPI("91633f2a-c5f5-4982-a925-a220d19095c3", "1dba76d40cac446ca500c0391a0b6c9d", "a88d031a1e7b462cb1579f12e97fe7f4", sugarLogger)
-	initOrder()
-}

business/jd/controller/order.go

@@ -23,7 +23,7 @@ var (
 type OrderController struct {
 }
 
-func initOrder() {
+func InitOrder() {
 	errChecker = new(corm.MysqlErrorChecker)
 
 	orderMsgChan = make(chan *jdapi.JDOrderMsg, 128)
@@ -39,7 +39,7 @@ func handlePendingOrderMsg() {
 	db := orm.NewOrm()
 	_, err := db.Raw("SELECT * FROM jdorder WHERE code = ?", MsgNotHandledCode).QueryRows(&ordersInfo)
 	if err != nil {
-		sugarLogger.Errorf("can not get jdorder from db, error:%v", err)
+		globals.SugarLogger.Errorf("can not get jdorder from db, error:%v", err)
 	} else {
 		for _, jdOrderInfo := range ordersInfo {
 			orderMsg := &jdapi.JDOrderMsg{
@@ -57,18 +57,18 @@ func handlePendingOrderMsg() {
 func orderMsgHandlerRoutinue() {
 	for {
 		msg := <-orderMsgChan
-		sugarLogger.Debugf("OrderMsgHandlerRoutinue:%v", msg)
+		globals.SugarLogger.Debugf("OrderMsgHandlerRoutinue:%v", msg)
 		go handleOrderMsg(msg)
 	}
 }
 
 func addOrderMsg(orderMsg *jdapi.JDOrderMsg) {
-	sugarLogger.Debugf("addOrderMsg:%v", orderMsg)
+	globals.SugarLogger.Debugf("addOrderMsg:%v", orderMsg)
 	orderMsgChan <- orderMsg
 }
 
 func handleOrderMsg(orderMsg *jdapi.JDOrderMsg) {
-	sugarLogger.Debugf("handleOrderMsg:%v", orderMsg)
+	globals.SugarLogger.Debugf("handleOrderMsg:%v", orderMsg)
 	switch orderMsg.StatusId {
 	case jdapi.JdOrderStatusNew:
 		newOrder(orderMsg)
@@ -80,12 +80,12 @@ func handleOrderMsg(orderMsg *jdapi.JDOrderMsg) {
 }
 
 // --------------
-func (c *OrderController) OrderStatus(order *jdapi.JDOrderMsg) *jdapi.JDOrderMsgResponse {
+func (c *OrderController) OrderStatus(order *jdapi.JDOrderMsg) *jdapi.JDCallbackResponse {
 	if order.StatusId != jdapi.JdOrderStatusNew && order.StatusId != jdapi.JdOrderStatusAdjust {
 		err := normalOrderStatus(order)
 		if err != nil {
-			sugarLogger.Warnf("error in OrderStatus, error:%v", err)
+			globals.SugarLogger.Warnf("error in OrderStatus, error:%v", err)
-			return &jdapi.JDOrderMsgResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
+			return &jdapi.JDCallbackResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
 		}
 	} else {
 		db := orm.NewOrm()
@@ -104,7 +104,7 @@ func (c *OrderController) OrderStatus(order *jdapi.JDOrderMsg) *jdapi.JDOrderMsg
 				isStatusSame := order.StatusId == jdapi.JdOrderStatusNew
 				if !isStatusSame {
 					order.StatusId = jdapi.JdOrderStatusNew
-					sugarLogger.Warnf("order:%s get %s before create", order.BillId, order.StatusId)
+					globals.SugarLogger.Warnf("order:%s get %s before create", order.BillId, order.StatusId)
 				}
 				addOrderMsg(order)
 
@@ -120,40 +120,40 @@ func (c *OrderController) OrderStatus(order *jdapi.JDOrderMsg) *jdapi.JDOrderMsg
 
 				addOrderMsg(order)
 			} else {
-				sugarLogger.Warnf("duplicated jd orderid:%s", order.BillId)
+				globals.SugarLogger.Warnf("duplicated jd orderid:%s", order.BillId)
-				sugarLogger.Debug(rec)
+				globals.SugarLogger.Debug(rec)
 			}
 		} else {
-			sugarLogger.Errorf("error when calling ReadOrCreate:%v", err)
+			globals.SugarLogger.Errorf("error when calling ReadOrCreate:%v", err)
-			return &jdapi.JDOrderMsgResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
+			return &jdapi.JDCallbackResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
 		}
 	}
-	return jdSuccessResponse
+	return jdapi.SuccessResponse
 }
 
-func (c *OrderController) OrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.JDDeliveryStatusMsg) *jdapi.JDOrderMsgResponse {
+func (c *OrderController) OrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.JDDeliveryStatusMsg) *jdapi.JDCallbackResponse {
 	err := globals.FreshFoodAPI.JDOrderDeliveryStatus(jdOrderDeliveryStatusMsg)
 
 	if err != nil {
-		sugarLogger.Errorf("Error when calling JDOrderDeliveryStatus, error:%v", err)
+		globals.SugarLogger.Errorf("Error when calling JDOrderDeliveryStatus, error:%v", err)
-		return &jdapi.JDOrderMsgResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
+		return &jdapi.JDCallbackResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
 	}
 
-	return jdSuccessResponse
+	return jdapi.SuccessResponse
 }
 
 //-----------
 func acceptOrder(order *jdapi.JDOrderMsg) {
-	gJdapi.OrderAcceptOperate(order.BillId, true)
+	globals.Jdapi.OrderAcceptOperate(order.BillId, true)
 }
 
 func newOrder(order *jdapi.JDOrderMsg) error {
-	sugarLogger.Debug("NewOrder2")
+	globals.SugarLogger.Debug("NewOrder2")
 
-	result, err := gJdapi.LegacyQuerySingleOrder(order.BillId)
+	result, err := globals.Jdapi.LegacyQuerySingleOrder(order.BillId)
 	acceptOrder(order)
 	if err != nil {
-		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 {
 		rec := &models.Jdorder{
 			Id: order.Id,
@@ -187,13 +187,13 @@ func newOrder(order *jdapi.JDOrderMsg) error {
 				db := orm.NewOrm()
 				_, err = db.Update(rec, "Data", "Code", "Msg", "Success", "CityName", "OrderStatus", "OrderStatusTime")
 				if err != nil {
-					sugarLogger.Errorf("update order error:%v", err)
+					globals.SugarLogger.Errorf("update order error:%v", err)
 				}
 			} else {
-				sugarLogger.Errorf("Error when calling NewJDOrder error:%v", err)
+				globals.SugarLogger.Errorf("Error when calling NewJDOrder error:%v", err)
 			}
 		} else {
-			sugarLogger.Warnf("can not get jdorder info:%v", order.BillId)
+			globals.SugarLogger.Warnf("can not get jdorder info:%v", order.BillId)
 		}
 	}
 	return err
@@ -211,12 +211,12 @@ func normalOrderStatus(order *jdapi.JDOrderMsg) error {
 
 	err := db.Read(rec, "JdOrderId")
 	if err != nil {
-		sugarLogger.Warnf("error when accessing db:%v", err)
+		globals.SugarLogger.Warnf("error when accessing db:%v", err)
 		return err
 	}
 
 	if rec.OrderStatus == utils.Str2Int(order.StatusId) {
-		sugarLogger.Infof("Duplicate message order:%v", order)
+		globals.SugarLogger.Infof("Duplicate message order:%v", order)
 		return nil
 	}
 
@@ -224,14 +224,14 @@ func normalOrderStatus(order *jdapi.JDOrderMsg) error {
 	rec.OrderStatusTime = order.Timestamp
 	err = globals.FreshFoodAPI.JDOrderStatus(rec)
 	if err != nil {
-		sugarLogger.Warnf("access freshfood failed, error:%v", err)
+		globals.SugarLogger.Warnf("access freshfood failed, error:%v", err)
 		return err
 	}
 
 	rec.Code = "0"
 	_, err = db.Update(rec, "OrderStatus", "OrderStatusTime", "Code")
 	if err != nil {
-		sugarLogger.Warnf("error when accessing db:%v", err)
+		globals.SugarLogger.Warnf("error when accessing db:%v", err)
 	}
 
 	return err

business/mtps/controller/order.go

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

business/mtps/models/order.go

@@ -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)"`
+}

controllers/elm_order.go

@@ -1,8 +1,6 @@
 package controllers
 
 import (
-	"encoding/json"
-
 	"git.rosy.net.cn/baseapi/platform/elmapi"
 	"git.rosy.net.cn/jx-callback/business/elm/controller"
 	"git.rosy.net.cn/jx-callback/globals"
@@ -25,17 +23,12 @@ func (c *ELMOrderController) URLMapping() {
 // @Failure 403 body is empty
 // @router /msg [post]
 func (c *ELMOrderController) MsgPost() {
-	var obj elmapi.ELMCallbackMsg
+	obj, callbackResponse := globals.ElmAPI.GetMsgFromData(c.Ctx.Input.RequestBody)
-	jdParamJSON := c.Ctx.Input.RequestBody
+	if callbackResponse == nil {
-
-	err := json.Unmarshal([]byte(jdParamJSON), &obj)
-	if err != nil {
-		globals.SugarLogger.Warnf("error when Unmarshal data:%v, error:%v", jdParamJSON, err)
-		c.Data["json"] = elmapi.ELMCallbackResponse{Message: "failed"}
-	} else {
 		cc := &controller.OrderController{}
-		c.Data["json"] = cc.OrderMessage(&obj)
+		c.Data["json"] = cc.OrderMessage(obj)
 	}
+	c.Data["json"] = callbackResponse
 	c.ServeJSON()
 }
 
@@ -44,6 +37,6 @@ func (c *ELMOrderController) MsgPost() {
 // @Success 200 {string} models.Object.Id
 // @router /msg [get]
 func (c *ELMOrderController) MsgGet() {
-	c.Data["json"] = elmapi.ELMResponseOK
+	c.Data["json"] = elmapi.SuccessResponse
 	c.ServeJSON()
 }

controllers/jd_order.go

@@ -1,17 +1,11 @@
 package controllers
 
 import (
-	"encoding/json"
-	"net/url"
-
-	"git.rosy.net.cn/baseapi/platform/jdapi"
 	"git.rosy.net.cn/jx-callback/business/jd/controller"
 	"git.rosy.net.cn/jx-callback/globals"
 	"github.com/astaxie/beego"
 )
 
-const JD_PARAM_JSON = "jd_param_json"
-
 // Operations about JDOrder
 type JDOrderController struct {
 	beego.Controller
@@ -29,31 +23,14 @@ func (c *JDOrderController) URLMapping() {
 	c.Mapping("PushDeliveryStatus", c.PushDeliveryStatus)
 }
 
-func (c *JDOrderController) handleJDCallback(obj interface{}, needUnescape bool, hanlder func() interface{}) {
-	jdParamJSON := c.GetString(JD_PARAM_JSON)
-	if needUnescape {
-		jdParamJSON2, err := url.QueryUnescape(jdParamJSON)
-		if err != nil {
-			globals.SugarLogger.Warnf("can not escape data:%v, error:%v", jdParamJSON, err)
-		}
-		jdParamJSON = jdParamJSON2
-	}
-	err := json.Unmarshal([]byte(jdParamJSON), obj)
-	if err != nil {
-		globals.SugarLogger.Warnf("error when Unmarshal data:%v, error:%v", jdParamJSON, err)
-		c.Data["json"] = jdapi.JDOrderMsgResponse{jdapi.JDerrorCodeMissingMandatoryParam, "jd_param_json format is wrong", jdParamJSON}
-	} else {
-		c.Data["json"] = hanlder()
-	}
-	c.ServeJSON()
-}
-
 func (c *JDOrderController) orderStatus() {
-	var ob jdapi.JDOrderMsg
+	obj, callbackResponse := globals.Jdapi.GetOrderMsg(c.Ctx.Request)
-	c.handleJDCallback(&ob, false, func() interface{} {
+	if callbackResponse == nil {
 		cc := controller.OrderController{}
-		return cc.OrderStatus(&ob)
+		callbackResponse = cc.OrderStatus(obj)
-	})
+	}
+	c.Data["json"] = callbackResponse
+	c.ServeJSON()
 }
 
 // @Title newOrder
@@ -153,9 +130,11 @@ func (c *JDOrderController) ApplyCancelOrder() {
 // @Failure 403 body is empty
 // @router /pushDeliveryStatus [post]
 func (c *JDOrderController) PushDeliveryStatus() {
-	var ob jdapi.JDDeliveryStatusMsg
+	obj, callbackResponse := globals.Jdapi.GetOrderDeliveryMsg(c.Ctx.Request)
-	c.handleJDCallback(&ob, true, func() interface{} {
+	if callbackResponse == nil {
 		cc := controller.OrderController{}
-		return cc.OrderDeliveryStatus(&ob)
+		callbackResponse = cc.OrderDeliveryStatus(obj)
-	})
+	}
+	c.Data["json"] = callbackResponse
+	c.ServeJSON()
 }

controllers/mtps_order.go

@@ -0,0 +1,47 @@
+package controllers
+
+import (
+	"git.rosy.net.cn/jx-callback/business/mtps/controller"
+	"git.rosy.net.cn/jx-callback/globals"
+	"github.com/astaxie/beego"
+)
+
+// Operations about ELMOrder
+type MTPSOrderController struct {
+	beego.Controller
+}
+
+func (c *MTPSOrderController) URLMapping() {
+	c.Mapping("Status", c.Status)
+	c.Mapping("Except", c.Except)
+}
+
+// @Title all msg
+// @Description create object
+// @Success 200 {string} models.Object.Id
+// @Failure 403 body is empty
+// @router /status [post]
+func (c *MTPSOrderController) Status() {
+	obj, callbackResponse := globals.MtpsAPI.GetOrderCallbackMsg(c.Ctx.Request)
+	if callbackResponse == nil {
+		cc := &controller.OrderController{}
+		c.Data["json"] = cc.OrderStatusChanged(obj)
+	}
+	c.Data["json"] = callbackResponse
+	c.ServeJSON()
+}
+
+// @Title all msg test
+// @Description create object
+// @Success 200 {string} models.Object.Id
+// @Failure 403 body is empty
+// @router /except [Post]
+func (c *MTPSOrderController) Except() {
+	obj, callbackResponse := globals.MtpsAPI.GetOrderExceptionCallbackMsg(c.Ctx.Request)
+	if callbackResponse == nil {
+		cc := &controller.OrderController{}
+		c.Data["json"] = cc.OrderException(obj)
+	}
+	c.Data["json"] = callbackResponse
+	c.ServeJSON()
+}

globals/globals.go

@@ -1,22 +1,87 @@
 package globals
 
 import (
+	"git.rosy.net.cn/baseapi/platform/elmapi"
+	"git.rosy.net.cn/baseapi/platform/jdapi"
+	"git.rosy.net.cn/baseapi/platform/mtpsapi"
+	"git.rosy.net.cn/baseapi/utils"
+	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/jd/models"
+	"github.com/astaxie/beego/orm"
+	_ "github.com/go-sql-driver/mysql" // import your used driver
 	"go.uber.org/zap"
 )
 
 const (
 	freshFoodServerURL = "http://test.jxc4.com"
+	// freshFoodServerURL = "http://portal.jingxicaishi.com"
+)
+
+const (
+	jdToken  = "91633f2a-c5f5-4982-a925-a220d19095c3"
+	jdAppKey = "1dba76d40cac446ca500c0391a0b6c9d"
+	jdSecret = "a88d031a1e7b462cb1579f12e97fe7f4"
+)
+
+const (
+	elmToken  = "" //"bab2a27f99562f394b411dbb9a6214da"
+	elmAppKey = "KLRDcOZGrk"
+	elmSecret = "1fc221f8265506531da36fb613d5f5ad673f2e9a"
+)
+
+const (
+	mtpsAppKey = "25e816550bc9484480642f19a95f13fd"
+	mtpsSecret = "r4$HqrKx9~=7?2Jfo,$Z~a7%~k!Au&pEdI2)oPJvSbH2ao@2N0[8wSIvtuumh_J^"
 )
 
 var (
-	SugarLogger *zap.SugaredLogger
+	SugarLogger  *zap.SugaredLogger
-	// freshFoodServerURL = "http://portal.jingxicaishi.com"
 	FreshFoodAPI *freshfood.FreshFoodAPI
+
+	Jdapi   *jdapi.JDAPI
+	ElmAPI  *elmapi.ELMAPI
+	MtpsAPI *mtpsapi.MTPSAPI
 )
 
 func init() {
 	logger, _ := zap.NewDevelopment()
 	SugarLogger = logger.Sugar()
+	initDB()
 	FreshFoodAPI = freshfood.NewFreshFoodAPI(freshFoodServerURL, SugarLogger)
+
+	Jdapi = jdapi.NewJDAPI(jdToken, jdAppKey, jdSecret, SugarLogger)
+	initElm()
+	MtpsAPI = mtpsapi.NewMTPSAPI(mtpsAppKey, mtpsSecret, SugarLogger)
+}
+
+func initElm() {
+	token := elmToken
+	if token == "" {
+		db := orm.NewOrm()
+		var tokenInfo []orm.Params
+		num, err := db.Raw("SELECT * FROM thirdpartytoken WHERE thirdparty='eleme'").Values(&tokenInfo)
+		if err != nil || num != 1 {
+			panic(err.Error())
+		}
+
+		var tokenInfo2 map[string]interface{}
+		if err := utils.UnmarshalUseNumber([]byte(tokenInfo[0]["token"].(string)), &tokenInfo2); err != nil {
+			panic(err.Error())
+		}
+		token = tokenInfo2["accessToken"].(string)
+	}
+	ElmAPI = elmapi.NewELMAPI(token, elmAppKey, elmSecret, SugarLogger, true)
+}
+
+func initDB() {
+	// set default database
+	orm.RegisterDataBase("default", "mysql", "root:WebServer@1@tcp(127.0.0.1:3306)/jx-callback?charset=utf8&loc=Local", 30)
+
+	// register model
+	orm.RegisterModel(new(models.Jdorder))
+	orm.RegisterModel(new(elmmodels.ELMOrder))
+
+	// create table
+	orm.RunSyncdb("default", false, true)
 }

main.go

@@ -1,12 +1,13 @@
 package main
 
 import (
-	_ "git.rosy.net.cn/jx-callback/business"
+	"git.rosy.net.cn/jx-callback/business/jd/controller"
 	_ "git.rosy.net.cn/jx-callback/routers"
 	"github.com/astaxie/beego"
 )
 
 func main() {
+	controller.InitOrder()
 	if beego.BConfig.RunMode == "dev" {
 		beego.BConfig.WebConfig.DirectoryIndex = true
 		beego.BConfig.WebConfig.StaticDir["/swagger"] = "swagger"

routers/router.go

@@ -24,5 +24,10 @@ func init() {
 			&controllers.ELMOrderController{},
 		),
 	)
-	beego.AddNamespace(ns, ns2)
+	ns3 := beego.NewNamespace("/mtps",
+		beego.NSInclude(
+			&controllers.MTPSOrderController{},
+		),
+	)
+	beego.AddNamespace(ns, ns2, ns3)
 }