- use auto router for callback msg.

- first normal demo api FinishedPickup added.

business/model/model.go

@@ -22,3 +22,8 @@ type ModelIDCUO struct {
 	UpdatedAt    time.Time
 	LastOperator string `gorm:"type:varchar(32)"` // 最后操作员
 }
+
+type CallResult struct {
+	Code   int    `json:"code"`
+	Result string `json:"result"`
+}

conf/app.conf

@@ -14,8 +14,6 @@ dadaAppSecret = "2c717ad914767d6e2beb3f743db9e477"
 
 autonaviKey = "4427170f870af2110becb8852d36ab08"
 
-callLegacyMsgHandler = false
-callNewMsgHandler = true
 generateLegacyJxOrder = false
 enableStore = true
 

controllers/dada_order.go

@@ -1,49 +1,32 @@
 package controllers
 
 import (
+	"net/http"
+
 	"git.rosy.net.cn/baseapi/utils"
 	"git.rosy.net.cn/jx-callback/business/partner/delivery/dada"
-	"git.rosy.net.cn/jx-callback/globals"
 	"git.rosy.net.cn/jx-callback/globals/api"
-	"git.rosy.net.cn/jx-callback/legacy/dada/controller"
 	"github.com/astaxie/beego"
 )
 
 // Operations about ELMOrder
-type DadaOrderController struct {
+type DadaDeliveryController struct {
 	beego.Controller
 }
 
-func (c *DadaOrderController) URLMapping() {
+func (c *DadaDeliveryController) Msg() {
-	c.Mapping("OrderStatusChanged", c.OrderStatusChanged)
+	if c.Ctx.Input.Method() == http.MethodPost {
-}
+		obj, callbackResponse := api.DadaAPI.GetOrderCallbackMsg(c.Ctx.Input.RequestBody)
-
+		if callbackResponse == nil {
-// @Title all msg
+			callbackResponse = dada.OnWaybillMsg(obj)
-// @Description create object
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /msg [post]
-func (c *DadaOrderController) OrderStatusChanged() {
-	obj, callbackResponse := api.DadaAPI.GetOrderCallbackMsg(c.Ctx.Input.RequestBody)
-	if callbackResponse == nil {
-		if globals.CallLegacyMsgHandler {
-			cc := &controller.OrderController{}
-			callbackResponse = cc.OrderStatusChanged(obj)
 		}
-		if globals.CallNewMsgHandler {
+		if callbackResponse != nil && callbackResponse.Code != 200 {
-			if globals.CallLegacyMsgHandler {
+			c.CustomAbort(callbackResponse.Code, string(utils.MustMarshal(callbackResponse)))
-				utils.CallFuncAsync(func() {
+		} else {
-					dada.OnWaybillMsg(obj)
+			c.Data["json"] = callbackResponse
-				})
+			c.ServeJSON()
-			} else {
-				callbackResponse = dada.OnWaybillMsg(obj)
-			}
 		}
-	}
-	if callbackResponse != nil && callbackResponse.Code != 200 {
-		c.CustomAbort(callbackResponse.Code, string(utils.MustMarshal(callbackResponse)))
 	} else {
-		c.Data["json"] = callbackResponse
+		c.Abort("404")
-		c.ServeJSON()
 	}
 }

controllers/elm_order.go

@@ -1,56 +1,32 @@
 package controllers
 
 import (
+	"net/http"
+
 	"git.rosy.net.cn/baseapi/platformapi/elmapi"
-	"git.rosy.net.cn/baseapi/utils"
 	"git.rosy.net.cn/jx-callback/business/partner/purchase/elm"
-	"git.rosy.net.cn/jx-callback/globals"
 	"git.rosy.net.cn/jx-callback/globals/api"
-	"git.rosy.net.cn/jx-callback/legacy/elm/controller"
 	"github.com/astaxie/beego"
 )
 
 // Operations about ELMOrder
-type ELMOrderController struct {
+type ElemeController struct {
 	beego.Controller
 }
 
-func (c *ELMOrderController) URLMapping() {
+// https://open.shop.ele.me/openapi/documents/httppushmethod
-	c.Mapping("MsgPost", c.MsgPost)
+func (c *ElemeController) Msg() {
-	c.Mapping("MsgGet", c.MsgGet)
+	if c.Ctx.Input.Method() == http.MethodPost {
-}
+		obj, callbackResponse := api.ElmAPI.GetCallbackMsg(c.Ctx.Input.RequestBody)
-
+		if callbackResponse == nil {
-// @Title all msg
+			callbackResponse = elm.OnCallbackMsg(obj)
-// @Description create object
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /msg [post]
-func (c *ELMOrderController) MsgPost() {
-	obj, callbackResponse := api.ElmAPI.GetCallbackMsg(c.Ctx.Input.RequestBody)
-	if callbackResponse == nil {
-		if globals.CallLegacyMsgHandler {
-			cc := &controller.OrderController{}
-			callbackResponse = cc.OrderMessage(obj)
-		}
-		if globals.CallNewMsgHandler {
-			if globals.CallLegacyMsgHandler {
-				utils.CallFuncAsync(func() {
-					elm.OnCallbackMsg(obj)
-				})
-			} else {
-				callbackResponse = elm.OnCallbackMsg(obj)
-			}
 		}
+		c.Data["json"] = callbackResponse
+		c.ServeJSON()
+	} else if c.Ctx.Input.Method() == http.MethodGet { // 应用需要支持推送地址的GET访问，当GET请求访问时，请直接返回{“message”:“ok”}，用于推送地址的可用性测试。
+		c.Data["json"] = elmapi.SuccessResponse
+		c.ServeJSON()
+	} else {
+		c.Abort("404")
 	}
-	c.Data["json"] = callbackResponse
-	c.ServeJSON()
-}
-
-// @Title all msg test
-// @Description create object
-// @Success 200 {string} models.Object.Id
-// @router /msg [get]
-func (c *ELMOrderController) MsgGet() {
-	c.Data["json"] = elmapi.SuccessResponse
-	c.ServeJSON()
 }

controllers/jd_order.go

@@ -1,183 +1,88 @@
 package controllers
 
 import (
+	"net/http"
+
 	"git.rosy.net.cn/baseapi/platformapi/jdapi"
-	"git.rosy.net.cn/baseapi/utils"
 	"git.rosy.net.cn/jx-callback/business/partner/purchase/jd"
-	"git.rosy.net.cn/jx-callback/globals"
 	"git.rosy.net.cn/jx-callback/globals/api"
-	"git.rosy.net.cn/jx-callback/legacy/jd/controller"
 	"github.com/astaxie/beego"
 )
 
 // Operations about JDOrder
-type JDOrderController struct {
+type DjswController struct {
 	beego.Controller
 }
 
-func (c *JDOrderController) URLMapping() {
+func (c *DjswController) orderStatus(isCancelOrder bool) {
-	c.Mapping("NewOrder", c.NewOrder)
+	if c.Ctx.Input.Method() == http.MethodPost {
-	c.Mapping("OrderAdjust", c.OrderAdjust)
+		var obj *jdapi.CallbackOrderMsg
-	c.Mapping("OrderWaitOutStore", c.OrderWaitOutStore)
+		var callbackResponse *jdapi.CallbackResponse
-	c.Mapping("PickFinishOrder", c.PickFinishOrder)
-	c.Mapping("DeliveryOrder", c.DeliveryOrder)
-	c.Mapping("LockOrder", c.LockOrder)
-	c.Mapping("UserCancelOrder", c.UserCancelOrder)
-	c.Mapping("ApplyCancelOrder", c.ApplyCancelOrder)
-	c.Mapping("PushDeliveryStatus", c.PushDeliveryStatus)
-}
 
-func (c *JDOrderController) orderStatus(isCancelOrder bool) {
+		if isCancelOrder {
-	var obj *jdapi.CallbackOrderMsg
+			obj, callbackResponse = api.JdAPI.GetOrderApplyCancelCallbackMsg(c.Ctx.Input.RequestBody)
-	var callbackResponse *jdapi.CallbackResponse
+		} else {
-
+			obj, callbackResponse = api.JdAPI.GetOrderCallbackMsg(c.Ctx.Input.RequestBody)
-	if isCancelOrder {
+		}
-		obj, callbackResponse = api.JdAPI.GetOrderApplyCancelCallbackMsg(c.Ctx.Input.RequestBody)
+		if callbackResponse == nil {
+			callbackResponse = jd.OnOrderMsg(obj)
+		}
+		c.Data["json"] = callbackResponse
+		c.ServeJSON()
 	} else {
-		obj, callbackResponse = api.JdAPI.GetOrderCallbackMsg(c.Ctx.Input.RequestBody)
+		c.Abort("404")
 	}
-	if callbackResponse == nil {
-		if globals.CallLegacyMsgHandler {
-			cc := controller.OrderController{}
-			callbackResponse = cc.OrderStatus(obj)
-		}
-		if globals.CallNewMsgHandler {
-			if globals.CallLegacyMsgHandler {
-				utils.CallFuncAsync(func() {
-					jd.OnOrderMsg(obj)
-				})
-			} else {
-				callbackResponse = jd.OnOrderMsg(obj)
-			}
-		}
-	}
-	c.Data["json"] = callbackResponse
-	c.ServeJSON()
 }
 
-// @Title newOrder
+func (c *DjswController) NewOrder() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /newOrder [post]
-func (c *JDOrderController) NewOrder() {
 	c.orderStatus(false)
 }
 
-// @Title AdjustOrder
+func (c *DjswController) OrderAdjust() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /orderAdjust [post]
-func (c *JDOrderController) OrderAdjust() {
 	c.orderStatus(false)
 }
 
-// @Title orderWaitOutStore
+func (c *DjswController) OrderWaitOutStore() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /orderWaitOutStore [post]
-func (c *JDOrderController) OrderWaitOutStore() {
 	c.orderStatus(false)
 }
 
-// @Title pickFinishOrder
+func (c *DjswController) PickFinishOrder() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /pickFinishOrder [post]
-func (c *JDOrderController) PickFinishOrder() {
 	c.orderStatus(false)
 }
 
-// @Title deliveryOrder
+func (c *DjswController) DeliveryOrder() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /deliveryOrder [post]
-func (c *JDOrderController) DeliveryOrder() {
 	c.orderStatus(false)
 }
 
-// @Title finishOrder
+func (c *DjswController) FinishOrder() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /finishOrder [post]
-func (c *JDOrderController) FinishOrder() {
 	c.orderStatus(false)
 }
 
-// @Title lockOrder
+func (c *DjswController) LockOrder() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /lockOrder [post]
-func (c *JDOrderController) LockOrder() {
 	c.orderStatus(false)
 }
 
-// @Title userCancelOrder
+func (c *DjswController) UserCancelOrder() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /userCancelOrder [post]
-func (c *JDOrderController) UserCancelOrder() {
 	c.orderStatus(false)
 }
 
-// @Title applyCancelOrder
+func (c *DjswController) ApplyCancelOrder() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /applyCancelOrder [post]
-func (c *JDOrderController) ApplyCancelOrder() {
 	c.orderStatus(true)
 }
 
-// @Title pushDeliveryStatus
+func (c *DjswController) PushDeliveryStatus() {
-// @Description create object
+	if c.Ctx.Input.Method() == http.MethodPost {
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
+		obj, callbackResponse := api.JdAPI.GetOrderDeliveryCallbackMsg(c.Ctx.Input.RequestBody)
-// @Success 200 {string} models.Object.Id
+		if callbackResponse == nil {
-// @Failure 403 body is empty
+			callbackResponse = jd.OnWaybillMsg(obj)
-// @router /pushDeliveryStatus [post]
-func (c *JDOrderController) PushDeliveryStatus() {
-	obj, callbackResponse := api.JdAPI.GetOrderDeliveryCallbackMsg(c.Ctx.Input.RequestBody)
-	if callbackResponse == nil {
-		if globals.CallLegacyMsgHandler {
-			cc := controller.OrderController{}
-			callbackResponse = cc.OrderDeliveryStatus(obj)
-		}
-		if globals.CallNewMsgHandler {
-			if globals.CallLegacyMsgHandler {
-				utils.CallFuncAsync(func() {
-					jd.OnWaybillMsg(obj)
-				})
-			} else {
-				callbackResponse = jd.OnWaybillMsg(obj)
-			}
 		}
+		c.Data["json"] = callbackResponse
+		c.ServeJSON()
+	} else {
+		c.Abort("404")
 	}
-	c.Data["json"] = callbackResponse
-	c.ServeJSON()
 }
 
-// @Title pushDeliveryStatus
+func (c *DjswController) OrderCommentPush() {
-// @Description create object
-// @Param	jd_param_json	formData	string	true	"应用级别输入参数"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router /orderCommentPush [post]
-func (c *JDOrderController) OrderComment() {
 	c.orderStatus(false)
 }

controllers/jx_order.go

@@ -0,0 +1,28 @@
+package controllers
+
+import (
+	"git.rosy.net.cn/jx-callback/business/model"
+	"github.com/astaxie/beego"
+)
+
+type OrderController struct {
+	beego.Controller
+}
+
+func (c *OrderController) URLMapping() {
+	c.Mapping("FinishedPickup", c.FinishedPickup)
+}
+
+// @Title 完成拣货
+// @Description 完成拣货，如果是购物平台负责配送，则自动召唤相应配送
+// @Param	orderid		path	string	true	"订单ID"
+// @Success 200 {object} business.model.CallResult
+// @Failure 200 {object} business.model.CallResult
+// @router /finishedpickup/:orderid [post]
+func (c *OrderController) FinishedPickup() {
+	c.Data["json"] = &model.CallResult{
+		Code:   0,
+		Result: c.Ctx.Input.Param(":orderid"),
+	}
+	c.ServeJSON()
+}

controllers/mtps_order.go

@@ -1,72 +1,40 @@
 package controllers
 
 import (
-	"git.rosy.net.cn/baseapi/utils"
+	"net/http"
+
 	"git.rosy.net.cn/jx-callback/business/partner/delivery/mtps"
-	"git.rosy.net.cn/jx-callback/globals"
 	"git.rosy.net.cn/jx-callback/globals/api"
-	"git.rosy.net.cn/jx-callback/legacy/mtps/controller"
 	"github.com/astaxie/beego"
 )
 
 // Operations about ELMOrder
-type MTPSOrderController struct {
+type MtpsController struct {
 	beego.Controller
 }
 
-func (c *MTPSOrderController) URLMapping() {
+func (c *MtpsController) Status() {
-	c.Mapping("Status", c.Status)
+	if c.Ctx.Input.Method() == http.MethodPost {
-	c.Mapping("Except", c.Except)
+		obj, callbackResponse := api.MtpsAPI.GetOrderCallbackMsg(c.Ctx.Request)
+		if callbackResponse == nil {
+			callbackResponse = mtps.OnWaybillMsg(obj)
+		}
+		c.Data["json"] = callbackResponse
+		c.ServeJSON()
+	} else {
+		c.Abort("404")
+	}
 }
 
-// @Title all msg
+func (c *MtpsController) Except() {
-// @Description create object
+	if c.Ctx.Input.Method() == http.MethodPost {
-// @Success 200 {string} models.Object.Id
+		obj, callbackResponse := api.MtpsAPI.GetOrderExceptionCallbackMsg(c.Ctx.Request)
-// @Failure 403 body is empty
+		if callbackResponse == nil {
-// @router /status [post]
+			callbackResponse = mtps.OnWaybillExcept(obj)
-func (c *MTPSOrderController) Status() {
-	obj, callbackResponse := api.MtpsAPI.GetOrderCallbackMsg(c.Ctx.Request)
-	if callbackResponse == nil {
-		if globals.CallLegacyMsgHandler {
-			cc := &controller.OrderController{}
-			callbackResponse = cc.OrderStatusChanged(obj)
-		}
-		if globals.CallNewMsgHandler {
-			if globals.CallLegacyMsgHandler {
-				utils.CallFuncAsync(func() {
-					mtps.OnWaybillMsg(obj)
-				})
-			} else {
-				callbackResponse = mtps.OnWaybillMsg(obj)
-			}
 		}
+		c.Data["json"] = callbackResponse
+		c.ServeJSON()
+	} else {
+		c.Abort("404")
 	}
-	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 := api.MtpsAPI.GetOrderExceptionCallbackMsg(c.Ctx.Request)
-	if callbackResponse == nil {
-		if globals.CallLegacyMsgHandler {
-			cc := &controller.OrderController{}
-			callbackResponse = cc.OrderException(obj)
-		}
-		if globals.CallNewMsgHandler {
-			if globals.CallLegacyMsgHandler {
-				utils.CallFuncAsync(func() {
-					mtps.OnWaybillExcept(obj)
-				})
-			} else {
-				callbackResponse = mtps.OnWaybillExcept(obj)
-			}
-		}
-	}
-	c.Data["json"] = callbackResponse
-	c.ServeJSON()
 }

controllers/object.go

@@ -1,92 +0,0 @@
-package controllers
-
-import (
-	"encoding/json"
-
-	"git.rosy.net.cn/jx-callback/models"
-
-	"github.com/astaxie/beego"
-)
-
-// Operations about object
-type ObjectController struct {
-	beego.Controller
-}
-
-// @Title Create
-// @Description create object
-// @Param	body		body 	models.Object	true		"The object content"
-// @Success 200 {string} models.Object.Id
-// @Failure 403 body is empty
-// @router / [post]
-func (o *ObjectController) Post() {
-	var ob models.Object
-	json.Unmarshal(o.Ctx.Input.RequestBody, &ob)
-	objectid := models.AddOne(ob)
-	o.Data["json"] = map[string]string{"ObjectId": objectid}
-	o.ServeJSON()
-}
-
-// @Title Get
-// @Description find object by objectid
-// @Param	objectId		path 	string	true		"the objectid you want to get"
-// @Success 200 {object} models.Object
-// @Failure 403 :objectId is empty
-// @router /:objectId [get]
-func (o *ObjectController) Get() {
-	objectId := o.Ctx.Input.Param(":objectId")
-	if objectId != "" {
-		ob, err := models.GetOne(objectId)
-		if err != nil {
-			o.Data["json"] = err.Error()
-		} else {
-			o.Data["json"] = ob
-		}
-	}
-	o.ServeJSON()
-}
-
-// @Title GetAll
-// @Description get all objects
-// @Success 200 {object} models.Object
-// @Failure 403 :objectId is empty
-// @router / [get]
-func (o *ObjectController) GetAll() {
-	obs := models.GetAll()
-	o.Data["json"] = obs
-	o.ServeJSON()
-}
-
-// @Title Update
-// @Description update the object
-// @Param	objectId		path 	string	true		"The objectid you want to update"
-// @Param	body		body 	models.Object	true		"The body"
-// @Success 200 {object} models.Object
-// @Failure 403 :objectId is empty
-// @router /:objectId [put]
-func (o *ObjectController) Put() {
-	objectId := o.Ctx.Input.Param(":objectId")
-	var ob models.Object
-	json.Unmarshal(o.Ctx.Input.RequestBody, &ob)
-
-	err := models.Update(objectId, ob.Score)
-	if err != nil {
-		o.Data["json"] = err.Error()
-	} else {
-		o.Data["json"] = "update success!"
-	}
-	o.ServeJSON()
-}
-
-// @Title Delete
-// @Description delete the object
-// @Param	objectId		path 	string	true		"The objectId you want to delete"
-// @Success 200 {string} delete success!
-// @Failure 403 objectId is empty
-// @router /:objectId [delete]
-func (o *ObjectController) Delete() {
-	objectId := o.Ctx.Input.Param(":objectId")
-	models.Delete(objectId)
-	o.Data["json"] = "delete success!"
-	o.ServeJSON()
-}

controllers/user.go

@@ -1,119 +0,0 @@
-package controllers
-
-import (
-	"encoding/json"
-
-	"git.rosy.net.cn/jx-callback/models"
-
-	"github.com/astaxie/beego"
-)
-
-// Operations about Users
-type UserController struct {
-	beego.Controller
-}
-
-// @Title CreateUser
-// @Description create users
-// @Param	body		body 	models.User	true		"body for user content"
-// @Success 200 {int} models.User.Id
-// @Failure 403 body is empty
-// @router / [post]
-func (u *UserController) Post() {
-	var user models.User
-	json.Unmarshal(u.Ctx.Input.RequestBody, &user)
-	uid := models.AddUser(user)
-	u.Data["json"] = map[string]string{"uid": uid}
-	u.ServeJSON()
-}
-
-// @Title GetAll
-// @Description get all Users
-// @Success 200 {object} models.User
-// @router / [get]
-func (u *UserController) GetAll() {
-	users := models.GetAllUsers()
-	u.Data["json"] = users
-	u.ServeJSON()
-}
-
-// @Title Get
-// @Description get user by uid
-// @Param	uid		path 	string	true		"The key for staticblock"
-// @Success 200 {object} models.User
-// @Failure 403 :uid is empty
-// @router /:uid [get]
-func (u *UserController) Get() {
-	uid := u.GetString(":uid")
-	if uid != "" {
-		user, err := models.GetUser(uid)
-		if err != nil {
-			u.Data["json"] = err.Error()
-		} else {
-			u.Data["json"] = user
-		}
-	}
-	u.ServeJSON()
-}
-
-// @Title Update
-// @Description update the user
-// @Param	uid		path 	string	true		"The uid you want to update"
-// @Param	body		body 	models.User	true		"body for user content"
-// @Success 200 {object} models.User
-// @Failure 403 :uid is not int
-// @router /:uid [put]
-func (u *UserController) Put() {
-	uid := u.GetString(":uid")
-	if uid != "" {
-		var user models.User
-		json.Unmarshal(u.Ctx.Input.RequestBody, &user)
-		uu, err := models.UpdateUser(uid, &user)
-		if err != nil {
-			u.Data["json"] = err.Error()
-		} else {
-			u.Data["json"] = uu
-		}
-	}
-	u.ServeJSON()
-}
-
-// @Title Delete
-// @Description delete the user
-// @Param	uid		path 	string	true		"The uid you want to delete"
-// @Success 200 {string} delete success!
-// @Failure 403 uid is empty
-// @router /:uid [delete]
-func (u *UserController) Delete() {
-	uid := u.GetString(":uid")
-	models.DeleteUser(uid)
-	u.Data["json"] = "delete success!"
-	u.ServeJSON()
-}
-
-// @Title Login
-// @Description Logs user into the system
-// @Param	username		query 	string	true		"The username for login"
-// @Param	password		query 	string	true		"The password for login"
-// @Success 200 {string} login success
-// @Failure 403 user not exist
-// @router /login [get]
-func (u *UserController) Login() {
-	username := u.GetString("username")
-	password := u.GetString("password")
-	if models.Login(username, password) {
-		u.Data["json"] = "login success"
-	} else {
-		u.Data["json"] = "user not exist"
-	}
-	u.ServeJSON()
-}
-
-// @Title logout
-// @Description Logs out current logged in user session
-// @Success 200 {string} logout success
-// @router /logout [get]
-func (u *UserController) Logout() {
-	u.Data["json"] = "logout success"
-	u.ServeJSON()
-}

globals/beegodb/beegodb.go

@@ -3,8 +3,6 @@ package beegodb
 import (
 	"git.rosy.net.cn/jx-callback/business/legacymodel"
 	"git.rosy.net.cn/jx-callback/business/model"
-	"git.rosy.net.cn/jx-callback/globals"
-	"git.rosy.net.cn/jx-callback/legacy/models"
 	"github.com/astaxie/beego"
 	"github.com/astaxie/beego/orm"
 )
@@ -12,25 +10,20 @@ import (
 func Init() {
 	// set default database
 	orm.RegisterDataBase("default", "mysql", beego.AppConfig.String("dbConnectStr"), 30)
-	if globals.CallLegacyMsgHandler {
-		models.RegisterModels()
-	}
 	orm.RegisterModel(new(legacymodel.Config))
 	orm.RegisterModel(new(legacymodel.BlackClient))
-	if globals.CallNewMsgHandler {
-		orm.RegisterModel(new(model.GoodsOrder))
-		orm.RegisterModel(new(model.OrderSku))
-		orm.RegisterModel(new(model.Waybill))
-		orm.RegisterModel(new(model.OrderStatus))
 
-		orm.RegisterModel(new(legacymodel.Jxstorefeature))
+	orm.RegisterModel(new(model.GoodsOrder))
+	orm.RegisterModel(new(model.OrderSku))
+	orm.RegisterModel(new(model.Waybill))
+	orm.RegisterModel(new(model.OrderStatus))
+
+	orm.RegisterModel(new(legacymodel.Jxstorefeature))
+
+	orm.RegisterModel(new(legacymodel.TempLog))
+	orm.RegisterModel(new(legacymodel.Jxorder2))
+	orm.RegisterModel(new(legacymodel.Jxordersku2))
 
-		orm.RegisterModel(new(legacymodel.TempLog))
-		orm.RegisterModel(new(legacymodel.Jxorder2))
-		orm.RegisterModel(new(legacymodel.Jxordersku2))
-		// orm.RegisterModel(new(legacymodel.Elemeorder2))
-		// orm.RegisterModel(new(legacymodel.Jdorder2))
-	}
 	// create table
 	orm.RunSyncdb("default", false, true)
 }

globals/globals.go

@@ -13,8 +13,6 @@ const (
 )
 
 var (
-	CallLegacyMsgHandler  bool
-	CallNewMsgHandler     bool
 	GenerateLegacyJxOrder bool
 	ReallyCallPlatformAPI bool
 
@@ -40,20 +38,11 @@ func init() {
 }
 
 func Init() {
-	CallLegacyMsgHandler = beego.AppConfig.DefaultBool("callLegacyMsgHandler", true)
+	ReallyCallPlatformAPI = true
-	CallNewMsgHandler = beego.AppConfig.DefaultBool("callNewMsgHandler", false)
 	GenerateLegacyJxOrder = beego.AppConfig.DefaultBool("generateLegacyJxOrder", false)
-	ReallyCallPlatformAPI = !CallLegacyMsgHandler
 
-	if ReallyCallPlatformAPI {
+	JxorderTableName = "jxorder"
-		JxorderTableName = "jxorder"
+	JxorderskuTableName = "jxordersku"
-		JxorderskuTableName = "jxordersku"
+	ElemeorderTableName = "elemeorder"
-		ElemeorderTableName = "elemeorder"
+	JdorderTableName = "jdorder"
-		JdorderTableName = "jdorder"
-	} else {
-		JxorderTableName = "jxorder2"
-		JxorderskuTableName = "jxordersku2"
-		ElemeorderTableName = "elemeorder2"
-		JdorderTableName = "jdorder2"
-	}
 }

main.go

@@ -11,7 +11,6 @@ import (
 	"git.rosy.net.cn/jx-callback/globals"
 	"git.rosy.net.cn/jx-callback/globals/api"
 	"git.rosy.net.cn/jx-callback/globals/beegodb"
-	"git.rosy.net.cn/jx-callback/legacy/jd/controller"
 	"git.rosy.net.cn/jx-callback/legacy/tasks"
 	_ "git.rosy.net.cn/jx-callback/routers"
 	"github.com/astaxie/beego"
@@ -85,9 +84,6 @@ func main() {
 				globals.SugarLogger.Errorf("RefreshElmToken failed with error:%s", err)
 				return
 			}
-			if globals.CallLegacyMsgHandler {
-				controller.InitOrder()
-			}
 			orderman.LoadPendingOrders()
 		}
 		if beego.AppConfig.DefaultBool("enableStore", false) {

models/object.go

@@ -1,53 +0,0 @@
-package models
-
-import (
-	"errors"
-	"strconv"
-	"time"
-)
-
-var (
-	Objects map[string]*Object
-)
-
-type Object struct {
-	ObjectId   string
-	Score      int64
-	PlayerName string
-}
-
-func init() {
-	Objects = make(map[string]*Object)
-	Objects["hjkhsbnmn123"] = &Object{"hjkhsbnmn123", 100, "astaxie"}
-	Objects["mjjkxsxsaa23"] = &Object{"mjjkxsxsaa23", 101, "someone"}
-}
-
-func AddOne(object Object) (ObjectId string) {
-	object.ObjectId = "astaxie" + strconv.FormatInt(time.Now().UnixNano(), 10)
-	Objects[object.ObjectId] = &object
-	return object.ObjectId
-}
-
-func GetOne(ObjectId string) (object *Object, err error) {
-	if v, ok := Objects[ObjectId]; ok {
-		return v, nil
-	}
-	return nil, errors.New("ObjectId Not Exist")
-}
-
-func GetAll() map[string]*Object {
-	return Objects
-}
-
-func Update(ObjectId string, Score int64) (err error) {
-	if v, ok := Objects[ObjectId]; ok {
-		v.Score = Score
-		return nil
-	}
-	return errors.New("ObjectId Not Exist")
-}
-
-func Delete(ObjectId string) {
-	delete(Objects, ObjectId)
-}
-

models/user.go

@@ -1,86 +0,0 @@
-package models
-
-import (
-	"errors"
-	"strconv"
-	"time"
-)
-
-var (
-	UserList map[string]*User
-)
-
-func init() {
-	UserList = make(map[string]*User)
-	u := User{"user_11111", "astaxie", "11111", Profile{"male", 20, "Singapore", "astaxie@gmail.com"}}
-	UserList["user_11111"] = &u
-}
-
-type User struct {
-	Id       string
-	Username string
-	Password string
-	Profile  Profile
-}
-
-type Profile struct {
-	Gender  string
-	Age     int
-	Address string
-	Email   string
-}
-
-func AddUser(u User) string {
-	u.Id = "user_" + strconv.FormatInt(time.Now().UnixNano(), 10)
-	UserList[u.Id] = &u
-	return u.Id
-}
-
-func GetUser(uid string) (u *User, err error) {
-	if u, ok := UserList[uid]; ok {
-		return u, nil
-	}
-	return nil, errors.New("User not exists")
-}
-
-func GetAllUsers() map[string]*User {
-	return UserList
-}
-
-func UpdateUser(uid string, uu *User) (a *User, err error) {
-	if u, ok := UserList[uid]; ok {
-		if uu.Username != "" {
-			u.Username = uu.Username
-		}
-		if uu.Password != "" {
-			u.Password = uu.Password
-		}
-		if uu.Profile.Age != 0 {
-			u.Profile.Age = uu.Profile.Age
-		}
-		if uu.Profile.Address != "" {
-			u.Profile.Address = uu.Profile.Address
-		}
-		if uu.Profile.Gender != "" {
-			u.Profile.Gender = uu.Profile.Gender
-		}
-		if uu.Profile.Email != "" {
-			u.Profile.Email = uu.Profile.Email
-		}
-		return u, nil
-	}
-	return nil, errors.New("User Not Exist")
-}
-
-func Login(username, password string) bool {
-	for _, u := range UserList {
-		if u.Username == username && u.Password == password {
-			return true
-		}
-	}
-	return false
-}
-
-func DeleteUser(uid string) {
-	delete(UserList, uid)
-}

routers/commentsRouter_controllers.go

@@ -7,228 +7,12 @@ import (
 
 func init() {
 
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:DadaOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:DadaOrderController"],
+	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:OrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:OrderController"],
 		beego.ControllerComments{
-			Method: "OrderStatusChanged",
+			Method: "FinishedPickup",
-			Router: `/msg`,
+			Router: `/finishedpickup/:orderid`,
 			AllowHTTPMethods: []string{"post"},
 			MethodParams: param.Make(),
 			Params: nil})
 
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ELMOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ELMOrderController"],
-		beego.ControllerComments{
-			Method: "MsgPost",
-			Router: `/msg`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ELMOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ELMOrderController"],
-		beego.ControllerComments{
-			Method: "MsgGet",
-			Router: `/msg`,
-			AllowHTTPMethods: []string{"get"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "ApplyCancelOrder",
-			Router: `/applyCancelOrder`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "DeliveryOrder",
-			Router: `/deliveryOrder`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "FinishOrder",
-			Router: `/finishOrder`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "LockOrder",
-			Router: `/lockOrder`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "NewOrder",
-			Router: `/newOrder`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "OrderAdjust",
-			Router: `/orderAdjust`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "OrderComment",
-			Router: `/orderCommentPush`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "OrderWaitOutStore",
-			Router: `/orderWaitOutStore`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "PickFinishOrder",
-			Router: `/pickFinishOrder`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "PushDeliveryStatus",
-			Router: `/pushDeliveryStatus`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:JDOrderController"],
-		beego.ControllerComments{
-			Method: "UserCancelOrder",
-			Router: `/userCancelOrder`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:MTPSOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:MTPSOrderController"],
-		beego.ControllerComments{
-			Method: "Except",
-			Router: `/except`,
-			AllowHTTPMethods: []string{"Post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:MTPSOrderController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:MTPSOrderController"],
-		beego.ControllerComments{
-			Method: "Status",
-			Router: `/status`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"],
-		beego.ControllerComments{
-			Method: "Post",
-			Router: `/`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"],
-		beego.ControllerComments{
-			Method: "GetAll",
-			Router: `/`,
-			AllowHTTPMethods: []string{"get"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"],
-		beego.ControllerComments{
-			Method: "Get",
-			Router: `/:objectId`,
-			AllowHTTPMethods: []string{"get"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"],
-		beego.ControllerComments{
-			Method: "Put",
-			Router: `/:objectId`,
-			AllowHTTPMethods: []string{"put"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:ObjectController"],
-		beego.ControllerComments{
-			Method: "Delete",
-			Router: `/:objectId`,
-			AllowHTTPMethods: []string{"delete"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"],
-		beego.ControllerComments{
-			Method: "Post",
-			Router: `/`,
-			AllowHTTPMethods: []string{"post"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"],
-		beego.ControllerComments{
-			Method: "GetAll",
-			Router: `/`,
-			AllowHTTPMethods: []string{"get"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"],
-		beego.ControllerComments{
-			Method: "Get",
-			Router: `/:uid`,
-			AllowHTTPMethods: []string{"get"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"],
-		beego.ControllerComments{
-			Method: "Put",
-			Router: `/:uid`,
-			AllowHTTPMethods: []string{"put"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"],
-		beego.ControllerComments{
-			Method: "Delete",
-			Router: `/:uid`,
-			AllowHTTPMethods: []string{"delete"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"],
-		beego.ControllerComments{
-			Method: "Login",
-			Router: `/login`,
-			AllowHTTPMethods: []string{"get"},
-			MethodParams: param.Make(),
-			Params: nil})
-
-	beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"] = append(beego.GlobalControllerRouter["git.rosy.net.cn/jx-callback/controllers:UserController"],
-		beego.ControllerComments{
-			Method: "Logout",
-			Router: `/logout`,
-			AllowHTTPMethods: []string{"get"},
-			MethodParams: param.Make(),
-			Params: nil})
-
 }

routers/router.go

@@ -15,31 +15,21 @@ import (
 )
 
 func init() {
-	nsJd := beego.NewNamespace("/djsw",
+	ns := beego.NewNamespace("/v2",
-		beego.NSInclude(
+		beego.NSNamespace("/order",
-			&controllers.JDOrderController{},
+			beego.NSInclude(
+				&controllers.OrderController{},
+			),
 		),
 	)
-	nsElm := beego.NewNamespace("/eleme",
+	beego.AddNamespace(ns)
-		beego.NSInclude(
+
-			&controllers.ELMOrderController{},
+	beego.AutoRouter(&controllers.DjswController{})
-		),
+	beego.AutoRouter(&controllers.MtpsController{})
-	)
+	beego.AutoRouter(&controllers.ElemeController{})
-	nsMtps := beego.NewNamespace("/mtps",
+	beego.AutoRouter(&controllers.DadaDeliveryController{})
-		beego.NSInclude(
+
-			&controllers.MTPSOrderController{},
+	beego.Any("/", func(ctx *beecontext.Context) {
-		),
-	)
-	nsDada := beego.NewNamespace("/dadadelivery",
-		beego.NSInclude(
-			&controllers.DadaOrderController{},
-		),
-	)
-	beego.AddNamespace(nsJd, nsElm, nsMtps, nsDada)
-	beego.Get("/", func(ctx *beecontext.Context) {
-		ctx.WriteString("pong\n")
-	})
-	beego.Head("/", func(ctx *beecontext.Context) {
 		ctx.WriteString("pong\n")
 	})
 }