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

- mtps added.

Browse Source 
- refactor.
This commit is contained in:
gazebo
2018-06-18 12:03:53 +08:00
parent a0a97c6fc2
commit 03c7efbe1e
14 changed files with 302 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
business/business.go
View File

@@ -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)
}

40
business/elm/controller/controller.go
View File

@@ -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)
}

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

@@ -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
}

91
business/freshfood/freshfood.go
View File

@@ -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)
}

19
business/jd/controller/controller.go
View File

@@ -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()
}

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

@@ -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)
return &jdapi.JDOrderMsgResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
globals.SugarLogger.Warnf("error in OrderStatus, error:%v", err)
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)
sugarLogger.Debug(rec)
globals.SugarLogger.Warnf("duplicated jd orderid:%s", order.BillId)
globals.SugarLogger.Debug(rec)
}
} else {
sugarLogger.Errorf("error when calling ReadOrCreate:%v", err)
return &jdapi.JDOrderMsgResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
globals.SugarLogger.Errorf("error when calling ReadOrCreate:%v", err)
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)
return &jdapi.JDOrderMsgResponse{jdapi.JDerrorCodeAccessFailed, err.Error(), ""}
globals.SugarLogger.Errorf("Error when calling JDOrderDeliveryStatus, error:%v", err)
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

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

@@ -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))
}

13
business/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)"`
}

17
controllers/elm_order.go
View File

@@ -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
jdParamJSON := c.Ctx.Input.RequestBody
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 {
obj, callbackResponse := globals.ElmAPI.GetMsgFromData(c.Ctx.Input.RequestBody)
if callbackResponse == nil {
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()
}

45
controllers/jd_order.go
View File

@@ -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
c.handleJDCallback(&ob, false, func() interface{} {
obj, callbackResponse := globals.Jdapi.GetOrderMsg(c.Ctx.Request)
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
c.handleJDCallback(&ob, true, func() interface{} {
obj, callbackResponse := globals.Jdapi.GetOrderDeliveryMsg(c.Ctx.Request)
if callbackResponse == nil {
cc := controller.OrderController{}
return cc.OrderDeliveryStatus(&ob)
})
callbackResponse = cc.OrderDeliveryStatus(obj)
}
c.Data["json"] = callbackResponse
c.ServeJSON()
}

47
controllers/mtps_order.go Normal file
View File

@@ -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()
}

69
globals/globals.go
View File

@@ -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
// freshFoodServerURL = "http://portal.jingxicaishi.com"
SugarLogger *zap.SugaredLogger
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)
}

3
main.go
View File

@@ -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"

7
routers/router.go
View File

@@ -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)
}