diff --git a/business/jd/controller/order.go b/business/jd/controller/order.go
index cb94a91a2..b249af80c 100644
--- a/business/jd/controller/order.go
+++ b/business/jd/controller/order.go
@@ -63,68 +63,68 @@ func orderMsgHandlerRoutine() {
 	}
 }
 
-func addOrderMsg(orderMsg *jdapi.CallbackOrderMsg) {
-	globals.SugarLogger.Debugf("addOrderMsg:%v", orderMsg)
-	orderMsgChan <- *orderMsg
+func addOrderMsg(msg *jdapi.CallbackOrderMsg) {
+	globals.SugarLogger.Debugf("addOrderMsg:%v", msg)
+	orderMsgChan <- *msg
 }
 
-func handleOrderMsg(orderMsg *jdapi.CallbackOrderMsg) {
-	globals.SugarLogger.Debugf("handleOrderMsg:%v", orderMsg)
-	switch orderMsg.StatusID {
+func handleOrderMsg(msg *jdapi.CallbackOrderMsg) {
+	globals.SugarLogger.Debugf("handleOrderMsg:%v", msg)
+	switch msg.StatusID {
 	case jdapi.OrderStatusNew:
-		newOrder(orderMsg)
+		newOrder(msg)
 	case jdapi.OrderStatusAdjust:
-		adjustOrder(orderMsg)
+		adjustOrder(msg)
 	default:
-		normalOrderStatus(orderMsg)
+		normalOrderStatus(msg)
 	}
 }
 
 // --------------
-func (c *OrderController) OrderStatus(order *jdapi.CallbackOrderMsg) *jdapi.CallbackResponse {
-	if order.StatusID != jdapi.OrderStatusNew && order.StatusID != jdapi.OrderStatusAdjust {
-		err := normalOrderStatus(order)
+func (c *OrderController) OrderStatus(msg *jdapi.CallbackOrderMsg) *jdapi.CallbackResponse {
+	if msg.StatusID != jdapi.OrderStatusNew && msg.StatusID != jdapi.OrderStatusAdjust {
+		err := normalOrderStatus(msg)
 		if err != nil {
 			return jdapi.Err2CallbackResponse(err, "")
 		}
 	} else {
 		db := orm.NewOrm()
-		jdorderid := utils.Str2Int64(order.BillID)
-		status := int(utils.Str2Int64(order.StatusID))
+		jdorderid := utils.Str2Int64(msg.BillID)
+		status := int(utils.Str2Int64(msg.StatusID))
 		rec := &models.Jdorder{
 			Code:            MsgNotHandledCode,
 			JdOrderID:       jdorderid,
 			OrderStatus:     status,
-			OrderStatusTime: order.Timestamp,
+			OrderStatusTime: msg.Timestamp,
 		}
 
 		if created, _, err := db.ReadOrCreate(rec, "JdOrderID"); err == nil {
-			order.ID = rec.ID
+			msg.ID = rec.ID
 			if created {
-				if order.StatusID != jdapi.OrderStatusNew && order.StatusID != jdapi.OrderStatusAdjust {
-					globals.SugarLogger.Warnf("order:%v get before create", order)
-					oldStatusID := order.StatusID
-					order.StatusID = jdapi.OrderStatusNew
-					addOrderMsg(order)
-					order.StatusID = oldStatusID
+				if msg.StatusID != jdapi.OrderStatusNew && msg.StatusID != jdapi.OrderStatusAdjust {
+					globals.SugarLogger.Warnf("order:%v get before create", msg)
+					oldStatusID := msg.StatusID
+					msg.StatusID = jdapi.OrderStatusNew
+					addOrderMsg(msg)
+					msg.StatusID = oldStatusID
 				}
-				addOrderMsg(order)
+				addOrderMsg(msg)
 			} else {
 				if rec.OrderStatus != status {
-					if order.StatusID == jdapi.OrderStatusNew {
-						globals.SugarLogger.Warnf("order:%v get after some other message:%d", order, rec.OrderStatus)
+					if msg.StatusID == jdapi.OrderStatusNew {
+						globals.SugarLogger.Warnf("order:%v get after some other message:%d", msg, rec.OrderStatus)
 					} else {
 						rec.OrderStatus = status
-						rec.OrderStatusTime = order.Timestamp
+						rec.OrderStatusTime = msg.Timestamp
 						rec.Code = MsgNotHandledCode
 						utils.CallFuncLogError(func() error {
 							_, err := db.Update(rec, "OrderStatus", "OrderStatusTime", "Code")
 							return err
 						}, globals2.ErrStrAccessDB)
-						addOrderMsg(order)
+						addOrderMsg(msg)
 					}
 				} else {
-					globals.SugarLogger.Warnf("duplicated jd order msg %v", order)
+					globals.SugarLogger.Warnf("duplicated jd order msg %v", msg)
 				}
 			}
 		} else {
@@ -143,16 +143,16 @@ func (c *OrderController) OrderDeliveryStatus(jdOrderDeliveryStatusMsg *jdapi.Ca
 }
 
 //-----------
-func acceptOrder(order *jdapi.CallbackOrderMsg) {
-	globals2.Jdapi.OrderAcceptOperate(order.BillID, true)
+func acceptOrder(msg *jdapi.CallbackOrderMsg) {
+	globals2.Jdapi.OrderAcceptOperate(msg.BillID, true)
 }
 
-func newOrder(order *jdapi.CallbackOrderMsg) error {
-	result, err := globals2.Jdapi.LegacyQuerySingleOrder(order.BillID)
-	acceptOrder(order)
+func newOrder(msg *jdapi.CallbackOrderMsg) error {
+	result, err := globals2.Jdapi.LegacyQuerySingleOrder(msg.BillID)
+	acceptOrder(msg)
 	if err == nil {
 		rec := &models.Jdorder{
-			ID: order.ID,
+			ID: msg.ID,
 		}
 
 		rec.Code, _ = result["code"].(string)
@@ -168,7 +168,7 @@ func newOrder(order *jdapi.CallbackOrderMsg) error {
 		if ok && len(resultList) == 1 {
 			resultList0 := resultList[0].(map[string]interface{})
 			orderStatus, _ := resultList0["orderStatus"].(json.Number).Int64()
-			rec.JdOrderID = utils.Str2Int64(order.BillID)
+			rec.JdOrderID = utils.Str2Int64(msg.BillID)
 			rec.OrderStatus = int(orderStatus)
 			rec.OrderStatusTime = resultList0["orderStatusTime"].(string)
 
@@ -181,17 +181,17 @@ func newOrder(order *jdapi.CallbackOrderMsg) error {
 				return err
 			}, globals2.ErrStrAccessDB)
 			err = utils.CallFuncLogError(func() error {
-				return globals2.FreshFoodAPI.NewJDOrder(rec, order.StatusID == jdapi.OrderStatusNew)
+				return globals2.FreshFoodAPI.NewJDOrder(rec, msg.StatusID == jdapi.OrderStatusNew)
 			}, globals2.ErrStrAccessDB)
 		} else {
-			globals.SugarLogger.Errorf("can not get jdorder info:%v", order.BillID)
+			globals.SugarLogger.Errorf("can not get jdorder info:%v", msg.BillID)
 		}
 	}
 	return err
 }
 
-func adjustOrder(order *jdapi.CallbackOrderMsg) error {
-	return newOrder(order)
+func adjustOrder(msg *jdapi.CallbackOrderMsg) error {
+	return newOrder(msg)
 }
 
 func normalOrderStatus(msg *jdapi.CallbackOrderMsg) (err error) {