jx-callback/swagger/param_parser.go.txt

// this file was automatically generated by modified bee tool (https://github.com/GazeboXu/bee)
// bee generate docs
// please don't modify it manually!!!
package controllers

import (
	"encoding/json"
	"fmt"
	"strings"
	"time"
	"net/http"
	"git.rosy.net.cn/jx-callback/business/jxstore/event"
	"git.rosy.net.cn/jx-callback/business/jxstore/cms"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxutils/jsonerr"
	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/globals"
)

const (
	strRequiredParamIsEmpty = "参数[%s]为空或数值不合法！"
)

type tOrderPayParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OrderID		string
	PayType		int
	VendorPayType		string
	OrderType		string
	AppId		string
	IsChoose		int
}

// func (c *OrderController) Pay() {
// 	c.callPay(func(params *tOrderPayParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callPay(handler func(params *tOrderPayParams) (interface{}, string, error)) {
	var err error
	params := &tOrderPayParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OrderID = utils.TrimBlankChar(c.GetString("orderID"))
	if params.PayType, err = c.GetInt("payType", 0); err != nil {
		errParams = append(errParams, "payType")
	}
	params.VendorPayType = utils.TrimBlankChar(c.GetString("vendorPayType"))
	params.OrderType = utils.TrimBlankChar(c.GetString("orderType"))
	params.AppId = utils.TrimBlankChar(c.GetString("appId"))
	if params.IsChoose, err = c.GetInt("isChoose", 0); err != nil {
		errParams = append(errParams, "isChoose")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("orderID") == "" {
		errParams = append(errParams, "orderID")
	}
	params.MapData["orderID"] = params.OrderID
	if c.GetString("payType") == "" {
		errParams = append(errParams, "payType")
	}
	params.MapData["payType"] = params.PayType
	if c.GetString("vendorPayType") == "" {
		errParams = append(errParams, "vendorPayType")
	}
	params.MapData["vendorPayType"] = params.VendorPayType
	if c.GetString("orderType") == "" {
		errParams = append(errParams, "orderType")
	}
	params.MapData["orderType"] = params.OrderType
	if c.GetString("appId") == "" {
		errParams = append(errParams, "appId")
	}
	params.MapData["appId"] = params.AppId
	if c.GetString("isChoose") == "" {
		errParams = append(errParams, "isChoose")
	}
	params.MapData["isChoose"] = params.IsChoose
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.Pay, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.Pay, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.Pay error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventUploadImgParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *EventController) UploadImg() {
// 	c.callUploadImg(func(params *tEventUploadImgParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callUploadImg(handler func(params *tEventUploadImgParams) (interface{}, string, error)) {
	var err error
	params := &tEventUploadImgParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.UploadImg, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.UploadImg, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.UploadImg error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionShareUnionLinkParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobID		int
	ShareType		int
	ResourceType		int
	LinkType		int
	GoodsID		string
}

// func (c *UnionController) ShareUnionLink() {
// 	c.callShareUnionLink(func(params *tUnionShareUnionLinkParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callShareUnionLink(handler func(params *tUnionShareUnionLinkParams) (interface{}, string, error)) {
	var err error
	params := &tUnionShareUnionLinkParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.JobID, err = c.GetInt("jobID", 0); err != nil {
		errParams = append(errParams, "jobID")
	}
	if params.ShareType, err = c.GetInt("shareType", 0); err != nil {
		errParams = append(errParams, "shareType")
	}
	if params.ResourceType, err = c.GetInt("resourceType", 0); err != nil {
		errParams = append(errParams, "resourceType")
	}
	if params.LinkType, err = c.GetInt("linkType", 0); err != nil {
		errParams = append(errParams, "linkType")
	}
	params.GoodsID = utils.TrimBlankChar(c.GetString("goodsID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobID") == "" {
		errParams = append(errParams, "jobID")
	}
	params.MapData["jobID"] = params.JobID
	if c.GetString("shareType") == "" {
		errParams = append(errParams, "shareType")
	}
	params.MapData["shareType"] = params.ShareType
	if utils.TrimBlankChar(c.GetString("resourceType")) != "" {
		params.MapData["resourceType"] = params.ResourceType
	}
	if c.GetString("linkType") == "" {
		errParams = append(errParams, "linkType")
	}
	params.MapData["linkType"] = params.LinkType
	if utils.TrimBlankChar(c.GetString("goodsID")) != "" {
		params.MapData["goodsID"] = params.GoodsID
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.ShareUnionLink, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.ShareUnionLink, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.ShareUnionLink error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tWithdrawalGetWithdrawalRecordParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Status		int
	PageSize		int
	PageNum		int
}

// func (c *WithdrawalRecordController) GetWithdrawalRecord() {
// 	c.callGetWithdrawalRecord(func(params *tWithdrawalGetWithdrawalRecordParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *WithdrawalRecordController) callGetWithdrawalRecord(handler func(params *tWithdrawalGetWithdrawalRecordParams) (interface{}, string, error)) {
	var err error
	params := &tWithdrawalGetWithdrawalRecordParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Status, err = c.GetInt("status", 0); err != nil {
		errParams = append(errParams, "status")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.PageNum, err = c.GetInt("pageNum", 0); err != nil {
		errParams = append(errParams, "pageNum")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("status") == "" {
		errParams = append(errParams, "status")
	}
	params.MapData["status"] = params.Status
	if c.GetString("pageSize") == "" {
		errParams = append(errParams, "pageSize")
	}
	params.MapData["pageSize"] = params.PageSize
	if c.GetString("pageNum") == "" {
		errParams = append(errParams, "pageNum")
	}
	params.MapData["pageNum"] = params.PageNum
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API WithdrawalRecordController.GetWithdrawalRecord, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API WithdrawalRecordController.GetWithdrawalRecord, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API WithdrawalRecordController.GetWithdrawalRecord error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2DingDingOAuth2Params struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Code		string
	Block		string
	State		string
}

// func (c *Auth2Controller) DingDingOAuth2() {
// 	c.callDingDingOAuth2(func(params *tAuth2DingDingOAuth2Params) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callDingDingOAuth2(handler func(params *tAuth2DingDingOAuth2Params) (interface{}, string, error)) {
	var err error
	params := &tAuth2DingDingOAuth2Params{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Code = utils.TrimBlankChar(c.GetString("code"))
	params.Block = utils.TrimBlankChar(c.GetString("block"))
	params.State = utils.TrimBlankChar(c.GetString("state"))
	if c.GetString("code") == "" {
		errParams = append(errParams, "code")
	}
	params.MapData["code"] = params.Code
	if utils.TrimBlankChar(c.GetString("block")) != "" {
		params.MapData["block"] = params.Block
	}
	if utils.TrimBlankChar(c.GetString("state")) != "" {
		params.MapData["state"] = params.State
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.DingDingOAuth2, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.DingDingOAuth2, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.DingDingOAuth2 error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderPayByBalanceParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OrderID		string
	PayType		int
	VendorPayType		string
	OrderType		string
	AppId		string
	IsChoose		int
}

// func (c *OrderController) PayByBalance() {
// 	c.callPayByBalance(func(params *tOrderPayByBalanceParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callPayByBalance(handler func(params *tOrderPayByBalanceParams) (interface{}, string, error)) {
	var err error
	params := &tOrderPayByBalanceParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OrderID = utils.TrimBlankChar(c.GetString("orderID"))
	if params.PayType, err = c.GetInt("payType", 0); err != nil {
		errParams = append(errParams, "payType")
	}
	params.VendorPayType = utils.TrimBlankChar(c.GetString("vendorPayType"))
	params.OrderType = utils.TrimBlankChar(c.GetString("orderType"))
	params.AppId = utils.TrimBlankChar(c.GetString("appId"))
	if params.IsChoose, err = c.GetInt("isChoose", 0); err != nil {
		errParams = append(errParams, "isChoose")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("orderID") == "" {
		errParams = append(errParams, "orderID")
	}
	params.MapData["orderID"] = params.OrderID
	if c.GetString("payType") == "" {
		errParams = append(errParams, "payType")
	}
	params.MapData["payType"] = params.PayType
	if c.GetString("vendorPayType") == "" {
		errParams = append(errParams, "vendorPayType")
	}
	params.MapData["vendorPayType"] = params.VendorPayType
	if c.GetString("orderType") == "" {
		errParams = append(errParams, "orderType")
	}
	params.MapData["orderType"] = params.OrderType
	if c.GetString("appId") == "" {
		errParams = append(errParams, "appId")
	}
	params.MapData["appId"] = params.AppId
	if c.GetString("isChoose") == "" {
		errParams = append(errParams, "isChoose")
	}
	params.MapData["isChoose"] = params.IsChoose
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.PayByBalance, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.PayByBalance, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.PayByBalance error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobUpdateJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
}

// func (c *JobController) UpdateJob() {
// 	c.callUpdateJob(func(params *tJobUpdateJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callUpdateJob(handler func(params *tJobUpdateJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobUpdateJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.UpdateJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.UpdateJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.UpdateJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetJobOrdersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
	JobUserID		string
	JobOrderID		int
	CategoryID		string
	Statuss		string
	FromTime		string
	ToTime		string
	Offset		int
	PageSize		int
}

// func (c *JobController) GetJobOrders() {
// 	c.callGetJobOrders(func(params *tJobGetJobOrdersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetJobOrders(handler func(params *tJobGetJobOrdersParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetJobOrdersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	params.JobUserID = utils.TrimBlankChar(c.GetString("jobUserID"))
	if params.JobOrderID, err = c.GetInt("jobOrderID", 0); err != nil {
		errParams = append(errParams, "jobOrderID")
	}
	params.CategoryID = utils.TrimBlankChar(c.GetString("categoryID"))
	params.Statuss = utils.TrimBlankChar(c.GetString("statuss"))
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("userID")) != "" {
		params.MapData["userID"] = params.UserID
	}
	if utils.TrimBlankChar(c.GetString("jobUserID")) != "" {
		params.MapData["jobUserID"] = params.JobUserID
	}
	if utils.TrimBlankChar(c.GetString("jobOrderID")) != "" {
		params.MapData["jobOrderID"] = params.JobOrderID
	}
	if utils.TrimBlankChar(c.GetString("categoryID")) != "" {
		params.MapData["categoryID"] = params.CategoryID
	}
	if utils.TrimBlankChar(c.GetString("statuss")) != "" {
		params.MapData["statuss"] = params.Statuss
	}
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetJobOrders, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetJobOrders, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetJobOrders error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionGetVendorMatterCategoryParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorID		int
}

// func (c *UnionController) GetVendorMatterCategory() {
// 	c.callGetVendorMatterCategory(func(params *tUnionGetVendorMatterCategoryParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callGetVendorMatterCategory(handler func(params *tUnionGetVendorMatterCategoryParams) (interface{}, string, error)) {
	var err error
	params := &tUnionGetVendorMatterCategoryParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.VendorID, err = c.GetInt("vendorID", 0); err != nil {
		errParams = append(errParams, "vendorID")
	}
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if c.GetString("vendorID") == "" {
		errParams = append(errParams, "vendorID")
	}
	params.MapData["vendorID"] = params.VendorID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.GetVendorMatterCategory, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.GetVendorMatterCategory, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.GetVendorMatterCategory error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tWithdrawalDeleteWithdrawalRecordParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Id		int
}

// func (c *WithdrawalRecordController) DeleteWithdrawalRecord() {
// 	c.callDeleteWithdrawalRecord(func(params *tWithdrawalDeleteWithdrawalRecordParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *WithdrawalRecordController) callDeleteWithdrawalRecord(handler func(params *tWithdrawalDeleteWithdrawalRecordParams) (interface{}, string, error)) {
	var err error
	params := &tWithdrawalDeleteWithdrawalRecordParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Id, err = c.GetInt("id", 0); err != nil {
		errParams = append(errParams, "id")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("id") == "" {
		errParams = append(errParams, "id")
	}
	params.MapData["id"] = params.Id
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API WithdrawalRecordController.DeleteWithdrawalRecord, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API WithdrawalRecordController.DeleteWithdrawalRecord, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API WithdrawalRecordController.DeleteWithdrawalRecord error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2AddMyDeliveryAddressParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	ConsigneeName		string
	ConsigneeMobile		string
	Address		string
	DetailAddress		string
	Lng		float64
	Lat		float64
	Tag		string
	Remark		string
	IsDefault		int
	Type		int
	AutoAddress		string
}

// func (c *User2Controller) AddMyDeliveryAddress() {
// 	c.callAddMyDeliveryAddress(func(params *tUser2AddMyDeliveryAddressParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callAddMyDeliveryAddress(handler func(params *tUser2AddMyDeliveryAddressParams) (interface{}, string, error)) {
	var err error
	params := &tUser2AddMyDeliveryAddressParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.ConsigneeName = utils.TrimBlankChar(c.GetString("consigneeName"))
	params.ConsigneeMobile = utils.TrimBlankChar(c.GetString("consigneeMobile"))
	params.Address = utils.TrimBlankChar(c.GetString("address"))
	params.DetailAddress = utils.TrimBlankChar(c.GetString("detailAddress"))
	if params.Lng, err = c.GetFloat("lng", 0); err != nil {
		errParams = append(errParams, "lng")
	}
	if params.Lat, err = c.GetFloat("lat", 0); err != nil {
		errParams = append(errParams, "lat")
	}
	params.Tag = utils.TrimBlankChar(c.GetString("tag"))
	params.Remark = utils.TrimBlankChar(c.GetString("remark"))
	if params.IsDefault, err = c.GetInt("isDefault", 0); err != nil {
		errParams = append(errParams, "isDefault")
	}
	if params.Type, err = c.GetInt("type", 0); err != nil {
		errParams = append(errParams, "type")
	}
	params.AutoAddress = utils.TrimBlankChar(c.GetString("autoAddress"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("consigneeName") == "" {
		errParams = append(errParams, "consigneeName")
	}
	params.MapData["consigneeName"] = params.ConsigneeName
	if c.GetString("consigneeMobile") == "" {
		errParams = append(errParams, "consigneeMobile")
	}
	params.MapData["consigneeMobile"] = params.ConsigneeMobile
	if utils.TrimBlankChar(c.GetString("address")) != "" {
		params.MapData["address"] = params.Address
	}
	if utils.TrimBlankChar(c.GetString("detailAddress")) != "" {
		params.MapData["detailAddress"] = params.DetailAddress
	}
	if utils.TrimBlankChar(c.GetString("lng")) != "" {
		params.MapData["lng"] = params.Lng
	}
	if utils.TrimBlankChar(c.GetString("lat")) != "" {
		params.MapData["lat"] = params.Lat
	}
	if utils.TrimBlankChar(c.GetString("tag")) != "" {
		params.MapData["tag"] = params.Tag
	}
	if utils.TrimBlankChar(c.GetString("remark")) != "" {
		params.MapData["remark"] = params.Remark
	}
	if utils.TrimBlankChar(c.GetString("isDefault")) != "" {
		params.MapData["isDefault"] = params.IsDefault
	}
	if utils.TrimBlankChar(c.GetString("type")) != "" {
		params.MapData["type"] = params.Type
	}
	if utils.TrimBlankChar(c.GetString("autoAddress")) != "" {
		params.MapData["autoAddress"] = params.AutoAddress
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.AddMyDeliveryAddress, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.AddMyDeliveryAddress, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.AddMyDeliveryAddress error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2GetBindAuthInfoParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *User2Controller) GetBindAuthInfo() {
// 	c.callGetBindAuthInfo(func(params *tUser2GetBindAuthInfoParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callGetBindAuthInfo(handler func(params *tUser2GetBindAuthInfoParams) (interface{}, string, error)) {
	var err error
	params := &tUser2GetBindAuthInfoParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.GetBindAuthInfo, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.GetBindAuthInfo, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.GetBindAuthInfo error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventUpdateUserMessageGroupReadParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
}

// func (c *EventController) UpdateUserMessageGroupRead() {
// 	c.callUpdateUserMessageGroupRead(func(params *tEventUpdateUserMessageGroupReadParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callUpdateUserMessageGroupRead(handler func(params *tEventUpdateUserMessageGroupReadParams) (interface{}, string, error)) {
	var err error
	params := &tEventUpdateUserMessageGroupReadParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.UpdateUserMessageGroupRead, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.UpdateUserMessageGroupRead, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.UpdateUserMessageGroupRead error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventCreateMessageGroupParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
	UserID2		string
	Name		string
	DividePercentage		int
	QuitPrice		int
}

// func (c *EventController) CreateMessageGroup() {
// 	c.callCreateMessageGroup(func(params *tEventCreateMessageGroupParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callCreateMessageGroup(handler func(params *tEventCreateMessageGroupParams) (interface{}, string, error)) {
	var err error
	params := &tEventCreateMessageGroupParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	params.UserID2 = utils.TrimBlankChar(c.GetString("userID2"))
	params.Name = utils.TrimBlankChar(c.GetString("name"))
	if params.DividePercentage, err = c.GetInt("dividePercentage", 0); err != nil {
		errParams = append(errParams, "dividePercentage")
	}
	if params.QuitPrice, err = c.GetInt("quitPrice", 0); err != nil {
		errParams = append(errParams, "quitPrice")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if utils.TrimBlankChar(c.GetString("userID2")) != "" {
		params.MapData["userID2"] = params.UserID2
	}
	if utils.TrimBlankChar(c.GetString("name")) != "" {
		params.MapData["name"] = params.Name
	}
	if utils.TrimBlankChar(c.GetString("dividePercentage")) != "" {
		params.MapData["dividePercentage"] = params.DividePercentage
	}
	if utils.TrimBlankChar(c.GetString("quitPrice")) != "" {
		params.MapData["quitPrice"] = params.QuitPrice
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.CreateMessageGroup, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.CreateMessageGroup, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.CreateMessageGroup error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2GetUserByMiniInfoParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Data		string
	Iv		string
	JsCode		string
	AuthType		string
	AppID		string
}

// func (c *User2Controller) GetUserByMiniInfo() {
// 	c.callGetUserByMiniInfo(func(params *tUser2GetUserByMiniInfoParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callGetUserByMiniInfo(handler func(params *tUser2GetUserByMiniInfoParams) (interface{}, string, error)) {
	var err error
	params := &tUser2GetUserByMiniInfoParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Data = utils.TrimBlankChar(c.GetString("data"))
	params.Iv = utils.TrimBlankChar(c.GetString("iv"))
	params.JsCode = utils.TrimBlankChar(c.GetString("jsCode"))
	params.AuthType = utils.TrimBlankChar(c.GetString("authType"))
	params.AppID = utils.TrimBlankChar(c.GetString("appID"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if c.GetString("data") == "" {
		errParams = append(errParams, "data")
	}
	params.MapData["data"] = params.Data
	if c.GetString("iv") == "" {
		errParams = append(errParams, "iv")
	}
	params.MapData["iv"] = params.Iv
	if utils.TrimBlankChar(c.GetString("jsCode")) != "" {
		params.MapData["jsCode"] = params.JsCode
	}
	if utils.TrimBlankChar(c.GetString("authType")) != "" {
		params.MapData["authType"] = params.AuthType
	}
	if utils.TrimBlankChar(c.GetString("appID")) != "" {
		params.MapData["appID"] = params.AppID
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.GetUserByMiniInfo, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.GetUserByMiniInfo, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.GetUserByMiniInfo error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderFinishedCashOrdersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OrderIDs		string
}

// func (c *OrderController) FinishedCashOrders() {
// 	c.callFinishedCashOrders(func(params *tOrderFinishedCashOrdersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callFinishedCashOrders(handler func(params *tOrderFinishedCashOrdersParams) (interface{}, string, error)) {
	var err error
	params := &tOrderFinishedCashOrdersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OrderIDs = utils.TrimBlankChar(c.GetString("orderIDs"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("orderIDs") == "" {
		errParams = append(errParams, "orderIDs")
	}
	params.MapData["orderIDs"] = params.OrderIDs
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.FinishedCashOrders, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.FinishedCashOrders, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.FinishedCashOrders error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderGetMyUnionOrdersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Statuss		string
	VendorID		int
	Offset		int
	PageSize		int
}

// func (c *OrderController) GetMyUnionOrders() {
// 	c.callGetMyUnionOrders(func(params *tOrderGetMyUnionOrdersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callGetMyUnionOrders(handler func(params *tOrderGetMyUnionOrdersParams) (interface{}, string, error)) {
	var err error
	params := &tOrderGetMyUnionOrdersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Statuss = utils.TrimBlankChar(c.GetString("statuss"))
	if params.VendorID, err = c.GetInt("vendorID", 0); err != nil {
		errParams = append(errParams, "vendorID")
	}
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("statuss")) != "" {
		params.MapData["statuss"] = params.Statuss
	}
	if utils.TrimBlankChar(c.GetString("vendorID")) != "" {
		params.MapData["vendorID"] = params.VendorID
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.GetMyUnionOrders, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.GetMyUnionOrders, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.GetMyUnionOrders error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobRefreshJobStatusParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *JobController) RefreshJobStatus() {
// 	c.callRefreshJobStatus(func(params *tJobRefreshJobStatusParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callRefreshJobStatus(handler func(params *tJobRefreshJobStatusParams) (interface{}, string, error)) {
	var err error
	params := &tJobRefreshJobStatusParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.RefreshJobStatus, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.RefreshJobStatus, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.RefreshJobStatus error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetStationListParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	StationName		string
	CityCode		int
	Lat		float64
	Lng		float64
	OilCode		string
	SortType		int
	Offset		int
	PageSize		int
}

// func (c *JobController) GetStationList() {
// 	c.callGetStationList(func(params *tJobGetStationListParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetStationList(handler func(params *tJobGetStationListParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetStationListParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.StationName = utils.TrimBlankChar(c.GetString("stationName"))
	if params.CityCode, err = c.GetInt("cityCode", 0); err != nil {
		errParams = append(errParams, "cityCode")
	}
	if params.Lat, err = c.GetFloat("lat", 0); err != nil {
		errParams = append(errParams, "lat")
	}
	if params.Lng, err = c.GetFloat("lng", 0); err != nil {
		errParams = append(errParams, "lng")
	}
	params.OilCode = utils.TrimBlankChar(c.GetString("oilCode"))
	if params.SortType, err = c.GetInt("sortType", 0); err != nil {
		errParams = append(errParams, "sortType")
	}
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("stationName")) != "" {
		params.MapData["stationName"] = params.StationName
	}
	if utils.TrimBlankChar(c.GetString("cityCode")) != "" {
		params.MapData["cityCode"] = params.CityCode
	}
	if utils.TrimBlankChar(c.GetString("lat")) != "" {
		params.MapData["lat"] = params.Lat
	}
	if utils.TrimBlankChar(c.GetString("lng")) != "" {
		params.MapData["lng"] = params.Lng
	}
	if utils.TrimBlankChar(c.GetString("oilCode")) != "" {
		params.MapData["oilCode"] = params.OilCode
	}
	if utils.TrimBlankChar(c.GetString("sortType")) != "" {
		params.MapData["sortType"] = params.SortType
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetStationList, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetStationList, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetStationList error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tExpressCreateWayOrderParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	PromiseTimeType		int
	DeliveryType		int
	Goods		string
	GuaranteeValueAmount		float64
	Weight		int
	Length		int
	Width		int
	Height		int
	OrderSendTime		string
	PackageNum		int
	ReceiveAddress		string
	ReceiveName		string
	ReceivePhone		string
	Remark		string
	SenderAddress		string
	SenderName		string
	SenderPhone		string
	ThirdPlatform		int
	Type		int
	ReceiveAddressId		int
	SenderAddressId		int
	ChannelType		int
	Images		string
	ChannelFee		float64
	Bulk		int
	ServiceCharge		float64
	GuarantFee		float64
	OriginalFee		float64
	Increment		float64
}

// func (c *QBiDaExpressController) CreateWayOrder() {
// 	c.callCreateWayOrder(func(params *tExpressCreateWayOrderParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *QBiDaExpressController) callCreateWayOrder(handler func(params *tExpressCreateWayOrderParams) (interface{}, string, error)) {
	var err error
	params := &tExpressCreateWayOrderParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.PromiseTimeType, err = c.GetInt("promiseTimeType", 0); err != nil {
		errParams = append(errParams, "promiseTimeType")
	}
	if params.DeliveryType, err = c.GetInt("deliveryType", 0); err != nil {
		errParams = append(errParams, "deliveryType")
	}
	params.Goods = utils.TrimBlankChar(c.GetString("goods"))
	if params.GuaranteeValueAmount, err = c.GetFloat("guaranteeValueAmount", 0); err != nil {
		errParams = append(errParams, "guaranteeValueAmount")
	}
	if params.Weight, err = c.GetInt("weight", 0); err != nil {
		errParams = append(errParams, "weight")
	}
	if params.Length, err = c.GetInt("length", 0); err != nil {
		errParams = append(errParams, "length")
	}
	if params.Width, err = c.GetInt("width", 0); err != nil {
		errParams = append(errParams, "width")
	}
	if params.Height, err = c.GetInt("height", 0); err != nil {
		errParams = append(errParams, "height")
	}
	params.OrderSendTime = utils.TrimBlankChar(c.GetString("orderSendTime"))
	if params.PackageNum, err = c.GetInt("packageNum", 0); err != nil {
		errParams = append(errParams, "packageNum")
	}
	params.ReceiveAddress = utils.TrimBlankChar(c.GetString("receiveAddress"))
	params.ReceiveName = utils.TrimBlankChar(c.GetString("receiveName"))
	params.ReceivePhone = utils.TrimBlankChar(c.GetString("receivePhone"))
	params.Remark = utils.TrimBlankChar(c.GetString("remark"))
	params.SenderAddress = utils.TrimBlankChar(c.GetString("senderAddress"))
	params.SenderName = utils.TrimBlankChar(c.GetString("senderName"))
	params.SenderPhone = utils.TrimBlankChar(c.GetString("senderPhone"))
	if params.ThirdPlatform, err = c.GetInt("thirdPlatform", 0); err != nil {
		errParams = append(errParams, "thirdPlatform")
	}
	if params.Type, err = c.GetInt("type", 0); err != nil {
		errParams = append(errParams, "type")
	}
	if params.ReceiveAddressId, err = c.GetInt("receiveAddressId", 0); err != nil {
		errParams = append(errParams, "receiveAddressId")
	}
	if params.SenderAddressId, err = c.GetInt("senderAddressId", 0); err != nil {
		errParams = append(errParams, "senderAddressId")
	}
	if params.ChannelType, err = c.GetInt("channelType", 0); err != nil {
		errParams = append(errParams, "channelType")
	}
	params.Images = utils.TrimBlankChar(c.GetString("images"))
	if params.ChannelFee, err = c.GetFloat("channelFee", 0); err != nil {
		errParams = append(errParams, "channelFee")
	}
	if params.Bulk, err = c.GetInt("bulk", 0); err != nil {
		errParams = append(errParams, "bulk")
	}
	if params.ServiceCharge, err = c.GetFloat("serviceCharge", 0); err != nil {
		errParams = append(errParams, "serviceCharge")
	}
	if params.GuarantFee, err = c.GetFloat("guarantFee", 0); err != nil {
		errParams = append(errParams, "guarantFee")
	}
	if params.OriginalFee, err = c.GetFloat("originalFee", 0); err != nil {
		errParams = append(errParams, "originalFee")
	}
	if params.Increment, err = c.GetFloat("increment", 0); err != nil {
		errParams = append(errParams, "increment")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("promiseTimeType")) != "" {
		params.MapData["promiseTimeType"] = params.PromiseTimeType
	}
	if utils.TrimBlankChar(c.GetString("deliveryType")) != "" {
		params.MapData["deliveryType"] = params.DeliveryType
	}
	if c.GetString("goods") == "" {
		errParams = append(errParams, "goods")
	}
	params.MapData["goods"] = params.Goods
	if utils.TrimBlankChar(c.GetString("guaranteeValueAmount")) != "" {
		params.MapData["guaranteeValueAmount"] = params.GuaranteeValueAmount
	}
	if c.GetString("weight") == "" {
		errParams = append(errParams, "weight")
	}
	params.MapData["weight"] = params.Weight
	if utils.TrimBlankChar(c.GetString("length")) != "" {
		params.MapData["length"] = params.Length
	}
	if utils.TrimBlankChar(c.GetString("width")) != "" {
		params.MapData["width"] = params.Width
	}
	if utils.TrimBlankChar(c.GetString("height")) != "" {
		params.MapData["height"] = params.Height
	}
	if utils.TrimBlankChar(c.GetString("orderSendTime")) != "" {
		params.MapData["orderSendTime"] = params.OrderSendTime
	}
	if c.GetString("packageNum") == "" {
		errParams = append(errParams, "packageNum")
	}
	params.MapData["packageNum"] = params.PackageNum
	if c.GetString("receiveAddress") == "" {
		errParams = append(errParams, "receiveAddress")
	}
	params.MapData["receiveAddress"] = params.ReceiveAddress
	if c.GetString("receiveName") == "" {
		errParams = append(errParams, "receiveName")
	}
	params.MapData["receiveName"] = params.ReceiveName
	if c.GetString("receivePhone") == "" {
		errParams = append(errParams, "receivePhone")
	}
	params.MapData["receivePhone"] = params.ReceivePhone
	if utils.TrimBlankChar(c.GetString("remark")) != "" {
		params.MapData["remark"] = params.Remark
	}
	if c.GetString("senderAddress") == "" {
		errParams = append(errParams, "senderAddress")
	}
	params.MapData["senderAddress"] = params.SenderAddress
	if c.GetString("senderName") == "" {
		errParams = append(errParams, "senderName")
	}
	params.MapData["senderName"] = params.SenderName
	if c.GetString("senderPhone") == "" {
		errParams = append(errParams, "senderPhone")
	}
	params.MapData["senderPhone"] = params.SenderPhone
	if utils.TrimBlankChar(c.GetString("thirdPlatform")) != "" {
		params.MapData["thirdPlatform"] = params.ThirdPlatform
	}
	if c.GetString("type") == "" {
		errParams = append(errParams, "type")
	}
	params.MapData["type"] = params.Type
	if c.GetString("receiveAddressId") == "" {
		errParams = append(errParams, "receiveAddressId")
	}
	params.MapData["receiveAddressId"] = params.ReceiveAddressId
	if c.GetString("senderAddressId") == "" {
		errParams = append(errParams, "senderAddressId")
	}
	params.MapData["senderAddressId"] = params.SenderAddressId
	if c.GetString("channelType") == "" {
		errParams = append(errParams, "channelType")
	}
	params.MapData["channelType"] = params.ChannelType
	if utils.TrimBlankChar(c.GetString("images")) != "" {
		params.MapData["images"] = params.Images
	}
	if c.GetString("channelFee") == "" {
		errParams = append(errParams, "channelFee")
	}
	params.MapData["channelFee"] = params.ChannelFee
	if utils.TrimBlankChar(c.GetString("bulk")) != "" {
		params.MapData["bulk"] = params.Bulk
	}
	if utils.TrimBlankChar(c.GetString("serviceCharge")) != "" {
		params.MapData["serviceCharge"] = params.ServiceCharge
	}
	if utils.TrimBlankChar(c.GetString("guarantFee")) != "" {
		params.MapData["guarantFee"] = params.GuarantFee
	}
	if utils.TrimBlankChar(c.GetString("originalFee")) != "" {
		params.MapData["originalFee"] = params.OriginalFee
	}
	if utils.TrimBlankChar(c.GetString("increment")) != "" {
		params.MapData["increment"] = params.Increment
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API QBiDaExpressController.CreateWayOrder, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API QBiDaExpressController.CreateWayOrder, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API QBiDaExpressController.CreateWayOrder error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionGetUnionActListParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorID		int
	ActType		int
}

// func (c *UnionController) GetUnionActList() {
// 	c.callGetUnionActList(func(params *tUnionGetUnionActListParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callGetUnionActList(handler func(params *tUnionGetUnionActListParams) (interface{}, string, error)) {
	var err error
	params := &tUnionGetUnionActListParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.VendorID, err = c.GetInt("vendorID", 0); err != nil {
		errParams = append(errParams, "vendorID")
	}
	if params.ActType, err = c.GetInt("actType", 0); err != nil {
		errParams = append(errParams, "actType")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("vendorID") == "" {
		errParams = append(errParams, "vendorID")
	}
	params.MapData["vendorID"] = params.VendorID
	if c.GetString("actType") == "" {
		errParams = append(errParams, "actType")
	}
	params.MapData["actType"] = params.ActType
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.GetUnionActList, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.GetUnionActList, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.GetUnionActList error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2WeixinMPOAuth2Params struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Code		string
	Block		string
	State		string
}

// func (c *Auth2Controller) WeixinMPOAuth2() {
// 	c.callWeixinMPOAuth2(func(params *tAuth2WeixinMPOAuth2Params) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callWeixinMPOAuth2(handler func(params *tAuth2WeixinMPOAuth2Params) (interface{}, string, error)) {
	var err error
	params := &tAuth2WeixinMPOAuth2Params{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Code = utils.TrimBlankChar(c.GetString("code"))
	params.Block = utils.TrimBlankChar(c.GetString("block"))
	params.State = utils.TrimBlankChar(c.GetString("state"))
	if c.GetString("code") == "" {
		errParams = append(errParams, "code")
	}
	params.MapData["code"] = params.Code
	if c.GetString("block") == "" {
		errParams = append(errParams, "block")
	}
	params.MapData["block"] = params.Block
	if utils.TrimBlankChar(c.GetString("state")) != "" {
		params.MapData["state"] = params.State
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.WeixinMPOAuth2, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.WeixinMPOAuth2, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.WeixinMPOAuth2 error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderGetOrdersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OrderID		string
	UserID		string
	OrderType		int
	CityCodes		string
	FromTime		string
	ToTime		string
	Keyword		string
	Offset		int
	PageSize		int
}

// func (c *OrderController) GetOrders() {
// 	c.callGetOrders(func(params *tOrderGetOrdersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callGetOrders(handler func(params *tOrderGetOrdersParams) (interface{}, string, error)) {
	var err error
	params := &tOrderGetOrdersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OrderID = utils.TrimBlankChar(c.GetString("orderID"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.OrderType, err = c.GetInt("orderType", 0); err != nil {
		errParams = append(errParams, "orderType")
	}
	params.CityCodes = utils.TrimBlankChar(c.GetString("cityCodes"))
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	params.Keyword = utils.TrimBlankChar(c.GetString("keyword"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("orderID")) != "" {
		params.MapData["orderID"] = params.OrderID
	}
	if utils.TrimBlankChar(c.GetString("userID")) != "" {
		params.MapData["userID"] = params.UserID
	}
	if utils.TrimBlankChar(c.GetString("orderType")) != "" {
		params.MapData["orderType"] = params.OrderType
	}
	if utils.TrimBlankChar(c.GetString("cityCodes")) != "" {
		params.MapData["cityCodes"] = params.CityCodes
	}
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("keyword")) != "" {
		params.MapData["keyword"] = params.Keyword
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.GetOrders, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.GetOrders, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.GetOrders error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobCheckJdDeliveryWeightParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *JobController) CheckJdDeliveryWeight() {
// 	c.callCheckJdDeliveryWeight(func(params *tJobCheckJdDeliveryWeightParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callCheckJdDeliveryWeight(handler func(params *tJobCheckJdDeliveryWeightParams) (interface{}, string, error)) {
	var err error
	params := &tJobCheckJdDeliveryWeightParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.CheckJdDeliveryWeight, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.CheckJdDeliveryWeight, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.CheckJdDeliveryWeight error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventUpdateMessageGroupParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	GroupID		int
	Payload		string
}

// func (c *EventController) UpdateMessageGroup() {
// 	c.callUpdateMessageGroup(func(params *tEventUpdateMessageGroupParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callUpdateMessageGroup(handler func(params *tEventUpdateMessageGroupParams) (interface{}, string, error)) {
	var err error
	params := &tEventUpdateMessageGroupParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.GroupID, err = c.GetInt("groupID", 0); err != nil {
		errParams = append(errParams, "groupID")
	}
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("groupID") == "" {
		errParams = append(errParams, "groupID")
	}
	params.MapData["groupID"] = params.GroupID
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.UpdateMessageGroup, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.UpdateMessageGroup, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.UpdateMessageGroup error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsNewConfigParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Type		string
	Key		string
	Value		string
}

// func (c *CmsController) NewConfig() {
// 	c.callNewConfig(func(params *tCmsNewConfigParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callNewConfig(handler func(params *tCmsNewConfigParams) (interface{}, string, error)) {
	var err error
	params := &tCmsNewConfigParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Type = utils.TrimBlankChar(c.GetString("type"))
	params.Key = utils.TrimBlankChar(c.GetString("key"))
	params.Value = utils.TrimBlankChar(c.GetString("value"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("type") == "" {
		errParams = append(errParams, "type")
	}
	params.MapData["type"] = params.Type
	if c.GetString("key") == "" {
		errParams = append(errParams, "key")
	}
	params.MapData["key"] = params.Key
	if c.GetString("value") == "" {
		errParams = append(errParams, "value")
	}
	params.MapData["value"] = params.Value
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.NewConfig, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.NewConfig, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.NewConfig error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionGetUnionOrdersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorIDs		string
	Statuss		string
	BeginTime		string
	EndTime		string
	Keyword		string
	Offset		int
	PageSize		int
}

// func (c *UnionController) GetUnionOrders() {
// 	c.callGetUnionOrders(func(params *tUnionGetUnionOrdersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callGetUnionOrders(handler func(params *tUnionGetUnionOrdersParams) (interface{}, string, error)) {
	var err error
	params := &tUnionGetUnionOrdersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.VendorIDs = utils.TrimBlankChar(c.GetString("vendorIDs"))
	params.Statuss = utils.TrimBlankChar(c.GetString("statuss"))
	params.BeginTime = utils.TrimBlankChar(c.GetString("beginTime"))
	params.EndTime = utils.TrimBlankChar(c.GetString("endTime"))
	params.Keyword = utils.TrimBlankChar(c.GetString("keyword"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("vendorIDs")) != "" {
		params.MapData["vendorIDs"] = params.VendorIDs
	}
	if utils.TrimBlankChar(c.GetString("statuss")) != "" {
		params.MapData["statuss"] = params.Statuss
	}
	if utils.TrimBlankChar(c.GetString("beginTime")) != "" {
		params.MapData["beginTime"] = params.BeginTime
	}
	if utils.TrimBlankChar(c.GetString("endTime")) != "" {
		params.MapData["endTime"] = params.EndTime
	}
	if utils.TrimBlankChar(c.GetString("keyword")) != "" {
		params.MapData["keyword"] = params.Keyword
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.GetUnionOrders, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.GetUnionOrders, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.GetUnionOrders error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderCreateOrderParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Type		int
	OrderType		int
	Way		string
	Price		int
	Lng		float64
	Lat		float64
	Mobile		string
	FlowCode		string
}

// func (c *OrderController) CreateOrder() {
// 	c.callCreateOrder(func(params *tOrderCreateOrderParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callCreateOrder(handler func(params *tOrderCreateOrderParams) (interface{}, string, error)) {
	var err error
	params := &tOrderCreateOrderParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Type, err = c.GetInt("type", 0); err != nil {
		errParams = append(errParams, "type")
	}
	if params.OrderType, err = c.GetInt("orderType", 0); err != nil {
		errParams = append(errParams, "orderType")
	}
	params.Way = utils.TrimBlankChar(c.GetString("way"))
	if params.Price, err = c.GetInt("price", 0); err != nil {
		errParams = append(errParams, "price")
	}
	if params.Lng, err = c.GetFloat("lng", 0); err != nil {
		errParams = append(errParams, "lng")
	}
	if params.Lat, err = c.GetFloat("lat", 0); err != nil {
		errParams = append(errParams, "lat")
	}
	params.Mobile = utils.TrimBlankChar(c.GetString("mobile"))
	params.FlowCode = utils.TrimBlankChar(c.GetString("flowCode"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("type") == "" {
		errParams = append(errParams, "type")
	}
	params.MapData["type"] = params.Type
	if c.GetString("orderType") == "" {
		errParams = append(errParams, "orderType")
	}
	params.MapData["orderType"] = params.OrderType
	if c.GetString("way") == "" {
		errParams = append(errParams, "way")
	}
	params.MapData["way"] = params.Way
	if c.GetString("price") == "" {
		errParams = append(errParams, "price")
	}
	params.MapData["price"] = params.Price
	if c.GetString("lng") == "" {
		errParams = append(errParams, "lng")
	}
	params.MapData["lng"] = params.Lng
	if c.GetString("lat") == "" {
		errParams = append(errParams, "lat")
	}
	params.MapData["lat"] = params.Lat
	if utils.TrimBlankChar(c.GetString("mobile")) != "" {
		params.MapData["mobile"] = params.Mobile
	}
	if utils.TrimBlankChar(c.GetString("flowCode")) != "" {
		params.MapData["flowCode"] = params.FlowCode
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.CreateOrder, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.CreateOrder, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.CreateOrder error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobPublishJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
}

// func (c *JobController) PublishJob() {
// 	c.callPublishJob(func(params *tJobPublishJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callPublishJob(handler func(params *tJobPublishJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobPublishJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.PublishJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.PublishJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.PublishJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetMtMembersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *JobController) GetMtMembers() {
// 	c.callGetMtMembers(func(params *tJobGetMtMembersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetMtMembers(handler func(params *tJobGetMtMembersParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetMtMembersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetMtMembers, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetMtMembers, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetMtMembers error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventGetImMessageRecordParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	GroupID		int
	FromTime		string
	ToTime		string
	Offset		int
	PageSize		int
}

// func (c *EventController) GetImMessageRecord() {
// 	c.callGetImMessageRecord(func(params *tEventGetImMessageRecordParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callGetImMessageRecord(handler func(params *tEventGetImMessageRecordParams) (interface{}, string, error)) {
	var err error
	params := &tEventGetImMessageRecordParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.GroupID, err = c.GetInt("groupID", 0); err != nil {
		errParams = append(errParams, "groupID")
	}
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("groupID") == "" {
		errParams = append(errParams, "groupID")
	}
	params.MapData["groupID"] = params.GroupID
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.GetImMessageRecord, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.GetImMessageRecord, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.GetImMessageRecord error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tTaskUnmanageTasksParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	TaskIDs		string
}

// func (c *TaskController) UnmanageTasks() {
// 	c.callUnmanageTasks(func(params *tTaskUnmanageTasksParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *TaskController) callUnmanageTasks(handler func(params *tTaskUnmanageTasksParams) (interface{}, string, error)) {
	var err error
	params := &tTaskUnmanageTasksParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.TaskIDs = utils.TrimBlankChar(c.GetString("taskIDs"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("taskIDs")) != "" {
		params.MapData["taskIDs"] = params.TaskIDs
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API TaskController.UnmanageTasks, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API TaskController.UnmanageTasks, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API TaskController.UnmanageTasks error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tTaskCancelTaskParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	TaskID		string
}

// func (c *TaskController) CancelTask() {
// 	c.callCancelTask(func(params *tTaskCancelTaskParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *TaskController) callCancelTask(handler func(params *tTaskCancelTaskParams) (interface{}, string, error)) {
	var err error
	params := &tTaskCancelTaskParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.TaskID = utils.TrimBlankChar(c.GetString("taskID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("taskID") == "" {
		errParams = append(errParams, "taskID")
	}
	params.MapData["taskID"] = params.TaskID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API TaskController.CancelTask, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API TaskController.CancelTask, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API TaskController.CancelTask error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsInitStationParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *CmsController) InitStation() {
// 	c.callInitStation(func(params *tCmsInitStationParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callInitStation(handler func(params *tCmsInitStationParams) (interface{}, string, error)) {
	var err error
	params := &tCmsInitStationParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.InitStation, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.InitStation, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.InitStation error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventAddMessageGroupParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	GroupID		int
	UserID		string
}

// func (c *EventController) AddMessageGroup() {
// 	c.callAddMessageGroup(func(params *tEventAddMessageGroupParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callAddMessageGroup(handler func(params *tEventAddMessageGroupParams) (interface{}, string, error)) {
	var err error
	params := &tEventAddMessageGroupParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.GroupID, err = c.GetInt("groupID", 0); err != nil {
		errParams = append(errParams, "groupID")
	}
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("groupID") == "" {
		errParams = append(errParams, "groupID")
	}
	params.MapData["groupID"] = params.GroupID
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.AddMessageGroup, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.AddMessageGroup, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.AddMessageGroup error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsGetServiceInfoParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *CmsController) GetServiceInfo() {
// 	c.callGetServiceInfo(func(params *tCmsGetServiceInfoParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callGetServiceInfo(handler func(params *tCmsGetServiceInfoParams) (interface{}, string, error)) {
	var err error
	params := &tCmsGetServiceInfoParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.GetServiceInfo, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.GetServiceInfo, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.GetServiceInfo error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2LoadMyCartParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	StoreIDs		string
}

// func (c *User2Controller) LoadMyCart() {
// 	c.callLoadMyCart(func(params *tUser2LoadMyCartParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callLoadMyCart(handler func(params *tUser2LoadMyCartParams) (interface{}, string, error)) {
	var err error
	params := &tUser2LoadMyCartParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.StoreIDs = utils.TrimBlankChar(c.GetString("storeIDs"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("storeIDs") == "" {
		errParams = append(errParams, "storeIDs")
	}
	params.MapData["storeIDs"] = params.StoreIDs
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.LoadMyCart, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.LoadMyCart, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.LoadMyCart error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderGetManageStatisticsJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	CityCodes		string
	FromTime		string
	ToTime		string
	JobIDs		string
	Offset		int
	PageSize		int
}

// func (c *OrderController) GetManageStatisticsJob() {
// 	c.callGetManageStatisticsJob(func(params *tOrderGetManageStatisticsJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callGetManageStatisticsJob(handler func(params *tOrderGetManageStatisticsJobParams) (interface{}, string, error)) {
	var err error
	params := &tOrderGetManageStatisticsJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.CityCodes = utils.TrimBlankChar(c.GetString("cityCodes"))
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	params.JobIDs = utils.TrimBlankChar(c.GetString("jobIDs"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("cityCodes")) != "" {
		params.MapData["cityCodes"] = params.CityCodes
	}
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("jobIDs")) != "" {
		params.MapData["jobIDs"] = params.JobIDs
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.GetManageStatisticsJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.GetManageStatisticsJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.GetManageStatisticsJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetJobCategoriesParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Name		string
}

// func (c *JobController) GetJobCategories() {
// 	c.callGetJobCategories(func(params *tJobGetJobCategoriesParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetJobCategories(handler func(params *tJobGetJobCategoriesParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetJobCategoriesParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Name = utils.TrimBlankChar(c.GetString("name"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("name")) != "" {
		params.MapData["name"] = params.Name
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetJobCategories, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetJobCategories, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetJobCategories error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetJdDeliveryParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Status		int
	FromTime		string
	ToTime		string
	Offset		int
	PageSize		int
}

// func (c *JobController) GetJdDelivery() {
// 	c.callGetJdDelivery(func(params *tJobGetJdDeliveryParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetJdDelivery(handler func(params *tJobGetJdDeliveryParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetJdDeliveryParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Status, err = c.GetInt("status", 0); err != nil {
		errParams = append(errParams, "status")
	}
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("status")) != "" {
		params.MapData["status"] = params.Status
	}
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetJdDelivery, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetJdDelivery, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetJdDelivery error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2LogoutParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *Auth2Controller) Logout() {
// 	c.callLogout(func(params *tAuth2LogoutParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callLogout(handler func(params *tAuth2LogoutParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2LogoutParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.Logout, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.Logout, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.Logout error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderCashParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OrderID		string
	PayType		int
	VendorPayType		string
}

// func (c *OrderController) Cash() {
// 	c.callCash(func(params *tOrderCashParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callCash(handler func(params *tOrderCashParams) (interface{}, string, error)) {
	var err error
	params := &tOrderCashParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OrderID = utils.TrimBlankChar(c.GetString("orderID"))
	if params.PayType, err = c.GetInt("payType", 0); err != nil {
		errParams = append(errParams, "payType")
	}
	params.VendorPayType = utils.TrimBlankChar(c.GetString("vendorPayType"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("orderID") == "" {
		errParams = append(errParams, "orderID")
	}
	params.MapData["orderID"] = params.OrderID
	if c.GetString("payType") == "" {
		errParams = append(errParams, "payType")
	}
	params.MapData["payType"] = params.PayType
	if c.GetString("vendorPayType") == "" {
		errParams = append(errParams, "vendorPayType")
	}
	params.MapData["vendorPayType"] = params.VendorPayType
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.Cash, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.Cash, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.Cash error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobImprotMtMembersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
}

// func (c *JobController) ImprotMtMembers() {
// 	c.callImprotMtMembers(func(params *tJobImprotMtMembersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callImprotMtMembers(handler func(params *tJobImprotMtMembersParams) (interface{}, string, error)) {
	var err error
	params := &tJobImprotMtMembersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.ImprotMtMembers, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.ImprotMtMembers, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.ImprotMtMembers error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventTransferMessageGroupMasterParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	GroupID		int
	UserID		string
}

// func (c *EventController) TransferMessageGroupMaster() {
// 	c.callTransferMessageGroupMaster(func(params *tEventTransferMessageGroupMasterParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callTransferMessageGroupMaster(handler func(params *tEventTransferMessageGroupMasterParams) (interface{}, string, error)) {
	var err error
	params := &tEventTransferMessageGroupMasterParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.GroupID, err = c.GetInt("groupID", 0); err != nil {
		errParams = append(errParams, "groupID")
	}
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("groupID") == "" {
		errParams = append(errParams, "groupID")
	}
	params.MapData["groupID"] = params.GroupID
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.TransferMessageGroupMaster, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.TransferMessageGroupMaster, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.TransferMessageGroupMaster error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2RegisterUserParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
	MobileVerifyCode		string
	AuthToken		string
}

// func (c *User2Controller) RegisterUser() {
// 	c.callRegisterUser(func(params *tUser2RegisterUserParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callRegisterUser(handler func(params *tUser2RegisterUserParams) (interface{}, string, error)) {
	var err error
	params := &tUser2RegisterUserParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	params.MobileVerifyCode = utils.TrimBlankChar(c.GetString("mobileVerifyCode"))
	params.AuthToken = utils.TrimBlankChar(c.GetString("authToken"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if utils.TrimBlankChar(c.GetString("mobileVerifyCode")) != "" {
		params.MapData["mobileVerifyCode"] = params.MobileVerifyCode
	}
	if utils.TrimBlankChar(c.GetString("authToken")) != "" {
		params.MapData["authToken"] = params.AuthToken
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.RegisterUser, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.RegisterUser, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.RegisterUser error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOpenapiCallOpenAPIParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	App_id		string
	Timestamp		int
	Sign		string
	Method		string
}

// func (c *ApiController) CallOpenAPI() {
// 	c.callCallOpenAPI(func(params *tOpenapiCallOpenAPIParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *ApiController) callCallOpenAPI(handler func(params *tOpenapiCallOpenAPIParams) (interface{}, string, error)) {
	var err error
	params := &tOpenapiCallOpenAPIParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.App_id = utils.TrimBlankChar(c.GetString("app_id"))
	if params.Timestamp, err = c.GetInt("timestamp", 0); err != nil {
		errParams = append(errParams, "timestamp")
	}
	params.Sign = utils.TrimBlankChar(c.GetString("sign"))
	params.Method = utils.TrimBlankChar(c.GetString("method"))
	if utils.TrimBlankChar(c.GetString("app_id")) != "" {
		params.MapData["app_id"] = params.App_id
	}
	if utils.TrimBlankChar(c.GetString("timestamp")) != "" {
		params.MapData["timestamp"] = params.Timestamp
	}
	if utils.TrimBlankChar(c.GetString("sign")) != "" {
		params.MapData["sign"] = params.Sign
	}
	if utils.TrimBlankChar(c.GetString("method")) != "" {
		params.MapData["method"] = params.Method
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API ApiController.CallOpenAPI, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API ApiController.CallOpenAPI, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API ApiController.CallOpenAPI error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tWithdrawalExamineWithdrawalOrderParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Phone		string
	OrderId		string
	ExamineStatus		int
	Remark		string
	UserId		string
}

// func (c *WithdrawalRecordController) ExamineWithdrawalOrder() {
// 	c.callExamineWithdrawalOrder(func(params *tWithdrawalExamineWithdrawalOrderParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *WithdrawalRecordController) callExamineWithdrawalOrder(handler func(params *tWithdrawalExamineWithdrawalOrderParams) (interface{}, string, error)) {
	var err error
	params := &tWithdrawalExamineWithdrawalOrderParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Phone = utils.TrimBlankChar(c.GetString("phone"))
	params.OrderId = utils.TrimBlankChar(c.GetString("orderId"))
	if params.ExamineStatus, err = c.GetInt("examineStatus", 0); err != nil {
		errParams = append(errParams, "examineStatus")
	}
	params.Remark = utils.TrimBlankChar(c.GetString("remark"))
	params.UserId = utils.TrimBlankChar(c.GetString("userId"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("phone") == "" {
		errParams = append(errParams, "phone")
	}
	params.MapData["phone"] = params.Phone
	if c.GetString("orderId") == "" {
		errParams = append(errParams, "orderId")
	}
	params.MapData["orderId"] = params.OrderId
	if c.GetString("examineStatus") == "" {
		errParams = append(errParams, "examineStatus")
	}
	params.MapData["examineStatus"] = params.ExamineStatus
	if utils.TrimBlankChar(c.GetString("remark")) != "" {
		params.MapData["remark"] = params.Remark
	}
	if utils.TrimBlankChar(c.GetString("userId")) != "" {
		params.MapData["userId"] = params.UserId
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API WithdrawalRecordController.ExamineWithdrawalOrder, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API WithdrawalRecordController.ExamineWithdrawalOrder, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API WithdrawalRecordController.ExamineWithdrawalOrder error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tTaskGetTasksParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	TaskID		string
	FromStatus		int
	ToStatus		int
	LastHours		int
	CreatedBy		string
}

// func (c *TaskController) GetTasks() {
// 	c.callGetTasks(func(params *tTaskGetTasksParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *TaskController) callGetTasks(handler func(params *tTaskGetTasksParams) (interface{}, string, error)) {
	var err error
	params := &tTaskGetTasksParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.TaskID = utils.TrimBlankChar(c.GetString("taskID"))
	if params.FromStatus, err = c.GetInt("fromStatus", 0); err != nil {
		errParams = append(errParams, "fromStatus")
	}
	if params.ToStatus, err = c.GetInt("toStatus", 0); err != nil {
		errParams = append(errParams, "toStatus")
	}
	if params.LastHours, err = c.GetInt("lastHours", 0); err != nil {
		errParams = append(errParams, "lastHours")
	}
	params.CreatedBy = utils.TrimBlankChar(c.GetString("createdBy"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("taskID")) != "" {
		params.MapData["taskID"] = params.TaskID
	}
	if utils.TrimBlankChar(c.GetString("fromStatus")) != "" {
		params.MapData["fromStatus"] = params.FromStatus
	}
	if utils.TrimBlankChar(c.GetString("toStatus")) != "" {
		params.MapData["toStatus"] = params.ToStatus
	}
	if utils.TrimBlankChar(c.GetString("lastHours")) != "" {
		params.MapData["lastHours"] = params.LastHours
	}
	if utils.TrimBlankChar(c.GetString("createdBy")) != "" {
		params.MapData["createdBy"] = params.CreatedBy
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API TaskController.GetTasks, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API TaskController.GetTasks, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API TaskController.GetTasks error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2GetUsersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Keyword		string
	UserID		string
	Pop		int
	CityCodes		string
	Mobile		string
	FromTime		string
	ToTime		string
	TimeType		int
	ConsumeTypes		string
	Offset		int
	PageSize		int
}

// func (c *User2Controller) GetUsers() {
// 	c.callGetUsers(func(params *tUser2GetUsersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callGetUsers(handler func(params *tUser2GetUsersParams) (interface{}, string, error)) {
	var err error
	params := &tUser2GetUsersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Keyword = utils.TrimBlankChar(c.GetString("keyword"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.Pop, err = c.GetInt("pop", 0); err != nil {
		errParams = append(errParams, "pop")
	}
	params.CityCodes = utils.TrimBlankChar(c.GetString("cityCodes"))
	params.Mobile = utils.TrimBlankChar(c.GetString("mobile"))
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	if params.TimeType, err = c.GetInt("timeType", 0); err != nil {
		errParams = append(errParams, "timeType")
	}
	params.ConsumeTypes = utils.TrimBlankChar(c.GetString("consumeTypes"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("keyword")) != "" {
		params.MapData["keyword"] = params.Keyword
	}
	if utils.TrimBlankChar(c.GetString("userID")) != "" {
		params.MapData["userID"] = params.UserID
	}
	if utils.TrimBlankChar(c.GetString("pop")) != "" {
		params.MapData["pop"] = params.Pop
	}
	if utils.TrimBlankChar(c.GetString("cityCodes")) != "" {
		params.MapData["cityCodes"] = params.CityCodes
	}
	if utils.TrimBlankChar(c.GetString("mobile")) != "" {
		params.MapData["mobile"] = params.Mobile
	}
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("timeType")) != "" {
		params.MapData["timeType"] = params.TimeType
	}
	if utils.TrimBlankChar(c.GetString("consumeTypes")) != "" {
		params.MapData["consumeTypes"] = params.ConsumeTypes
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.GetUsers, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.GetUsers, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.GetUsers error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobAuditJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobOrderID		int
	Status		int
	Comment		string
	VendorWaybillID		string
}

// func (c *JobController) AuditJob() {
// 	c.callAuditJob(func(params *tJobAuditJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callAuditJob(handler func(params *tJobAuditJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobAuditJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.JobOrderID, err = c.GetInt("jobOrderID", 0); err != nil {
		errParams = append(errParams, "jobOrderID")
	}
	if params.Status, err = c.GetInt("status", 0); err != nil {
		errParams = append(errParams, "status")
	}
	params.Comment = utils.TrimBlankChar(c.GetString("comment"))
	params.VendorWaybillID = utils.TrimBlankChar(c.GetString("vendorWaybillID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobOrderID") == "" {
		errParams = append(errParams, "jobOrderID")
	}
	params.MapData["jobOrderID"] = params.JobOrderID
	if c.GetString("status") == "" {
		errParams = append(errParams, "status")
	}
	params.MapData["status"] = params.Status
	if utils.TrimBlankChar(c.GetString("comment")) != "" {
		params.MapData["comment"] = params.Comment
	}
	if utils.TrimBlankChar(c.GetString("vendorWaybillID")) != "" {
		params.MapData["vendorWaybillID"] = params.VendorWaybillID
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.AuditJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.AuditJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.AuditJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsUpdateConfigParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Type		string
	Key		string
	Value		string
}

// func (c *CmsController) UpdateConfig() {
// 	c.callUpdateConfig(func(params *tCmsUpdateConfigParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callUpdateConfig(handler func(params *tCmsUpdateConfigParams) (interface{}, string, error)) {
	var err error
	params := &tCmsUpdateConfigParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Type = utils.TrimBlankChar(c.GetString("type"))
	params.Key = utils.TrimBlankChar(c.GetString("key"))
	params.Value = utils.TrimBlankChar(c.GetString("value"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("type") == "" {
		errParams = append(errParams, "type")
	}
	params.MapData["type"] = params.Type
	if c.GetString("key") == "" {
		errParams = append(errParams, "key")
	}
	params.MapData["key"] = params.Key
	if c.GetString("value") == "" {
		errParams = append(errParams, "value")
	}
	params.MapData["value"] = params.Value
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.UpdateConfig, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.UpdateConfig, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.UpdateConfig error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2DeleteMyDeliveryAddressParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Id		int
}

// func (c *User2Controller) DeleteMyDeliveryAddress() {
// 	c.callDeleteMyDeliveryAddress(func(params *tUser2DeleteMyDeliveryAddressParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callDeleteMyDeliveryAddress(handler func(params *tUser2DeleteMyDeliveryAddressParams) (interface{}, string, error)) {
	var err error
	params := &tUser2DeleteMyDeliveryAddressParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Id, err = c.GetInt("id", 0); err != nil {
		errParams = append(errParams, "id")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("id") == "" {
		errParams = append(errParams, "id")
	}
	params.MapData["id"] = params.Id
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.DeleteMyDeliveryAddress, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.DeleteMyDeliveryAddress, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.DeleteMyDeliveryAddress error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tExpressQueryExpressPriceParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	PromiseTimeType		int
	DeliveryType		int
	GoodsValue		float64
	ReceiveAddress		string
	SendAddress		string
	Type		int
	Weight		int
	Length		int
	Width		int
	Height		int
	SendPhone		string
	ChannelType		int
}

// func (c *QBiDaExpressController) QueryExpressPrice() {
// 	c.callQueryExpressPrice(func(params *tExpressQueryExpressPriceParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *QBiDaExpressController) callQueryExpressPrice(handler func(params *tExpressQueryExpressPriceParams) (interface{}, string, error)) {
	var err error
	params := &tExpressQueryExpressPriceParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.PromiseTimeType, err = c.GetInt("promiseTimeType", 0); err != nil {
		errParams = append(errParams, "promiseTimeType")
	}
	if params.DeliveryType, err = c.GetInt("deliveryType", 0); err != nil {
		errParams = append(errParams, "deliveryType")
	}
	if params.GoodsValue, err = c.GetFloat("goodsValue", 0); err != nil {
		errParams = append(errParams, "goodsValue")
	}
	params.ReceiveAddress = utils.TrimBlankChar(c.GetString("receiveAddress"))
	params.SendAddress = utils.TrimBlankChar(c.GetString("sendAddress"))
	if params.Type, err = c.GetInt("type", 0); err != nil {
		errParams = append(errParams, "type")
	}
	if params.Weight, err = c.GetInt("weight", 0); err != nil {
		errParams = append(errParams, "weight")
	}
	if params.Length, err = c.GetInt("length", 0); err != nil {
		errParams = append(errParams, "length")
	}
	if params.Width, err = c.GetInt("width", 0); err != nil {
		errParams = append(errParams, "width")
	}
	if params.Height, err = c.GetInt("height", 0); err != nil {
		errParams = append(errParams, "height")
	}
	params.SendPhone = utils.TrimBlankChar(c.GetString("sendPhone"))
	if params.ChannelType, err = c.GetInt("channelType", 0); err != nil {
		errParams = append(errParams, "channelType")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("promiseTimeType")) != "" {
		params.MapData["promiseTimeType"] = params.PromiseTimeType
	}
	if utils.TrimBlankChar(c.GetString("deliveryType")) != "" {
		params.MapData["deliveryType"] = params.DeliveryType
	}
	if utils.TrimBlankChar(c.GetString("goodsValue")) != "" {
		params.MapData["goodsValue"] = params.GoodsValue
	}
	if c.GetString("receiveAddress") == "" {
		errParams = append(errParams, "receiveAddress")
	}
	params.MapData["receiveAddress"] = params.ReceiveAddress
	if c.GetString("sendAddress") == "" {
		errParams = append(errParams, "sendAddress")
	}
	params.MapData["sendAddress"] = params.SendAddress
	if utils.TrimBlankChar(c.GetString("type")) != "" {
		params.MapData["type"] = params.Type
	}
	if c.GetString("weight") == "" {
		errParams = append(errParams, "weight")
	}
	params.MapData["weight"] = params.Weight
	if utils.TrimBlankChar(c.GetString("length")) != "" {
		params.MapData["length"] = params.Length
	}
	if utils.TrimBlankChar(c.GetString("width")) != "" {
		params.MapData["width"] = params.Width
	}
	if utils.TrimBlankChar(c.GetString("height")) != "" {
		params.MapData["height"] = params.Height
	}
	if c.GetString("sendPhone") == "" {
		errParams = append(errParams, "sendPhone")
	}
	params.MapData["sendPhone"] = params.SendPhone
	if c.GetString("channelType") == "" {
		errParams = append(errParams, "channelType")
	}
	params.MapData["channelType"] = params.ChannelType
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API QBiDaExpressController.QueryExpressPrice, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API QBiDaExpressController.QueryExpressPrice, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API QBiDaExpressController.QueryExpressPrice error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tRechargeGetRechargeOrderDetailParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OrderId		string
	Mobile		string
}

// func (c *RechargeManagerController) GetRechargeOrderDetail() {
// 	c.callGetRechargeOrderDetail(func(params *tRechargeGetRechargeOrderDetailParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *RechargeManagerController) callGetRechargeOrderDetail(handler func(params *tRechargeGetRechargeOrderDetailParams) (interface{}, string, error)) {
	var err error
	params := &tRechargeGetRechargeOrderDetailParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OrderId = utils.TrimBlankChar(c.GetString("orderId"))
	params.Mobile = utils.TrimBlankChar(c.GetString("mobile"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("orderId") == "" {
		errParams = append(errParams, "orderId")
	}
	params.MapData["orderId"] = params.OrderId
	if c.GetString("mobile") == "" {
		errParams = append(errParams, "mobile")
	}
	params.MapData["mobile"] = params.Mobile
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API RechargeManagerController.GetRechargeOrderDetail, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API RechargeManagerController.GetRechargeOrderDetail, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API RechargeManagerController.GetRechargeOrderDetail error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2DeleteUserCityManagerParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
	CityCode		int
}

// func (c *User2Controller) DeleteUserCityManager() {
// 	c.callDeleteUserCityManager(func(params *tUser2DeleteUserCityManagerParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callDeleteUserCityManager(handler func(params *tUser2DeleteUserCityManagerParams) (interface{}, string, error)) {
	var err error
	params := &tUser2DeleteUserCityManagerParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.CityCode, err = c.GetInt("cityCode", 0); err != nil {
		errParams = append(errParams, "cityCode")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if c.GetString("cityCode") == "" {
		errParams = append(errParams, "cityCode")
	}
	params.MapData["cityCode"] = params.CityCode
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.DeleteUserCityManager, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.DeleteUserCityManager, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.DeleteUserCityManager error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderSettleUnionOrdersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorIDs		string
}

// func (c *OrderController) SettleUnionOrders() {
// 	c.callSettleUnionOrders(func(params *tOrderSettleUnionOrdersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callSettleUnionOrders(handler func(params *tOrderSettleUnionOrdersParams) (interface{}, string, error)) {
	var err error
	params := &tOrderSettleUnionOrdersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.VendorIDs = utils.TrimBlankChar(c.GetString("vendorIDs"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("vendorIDs")) != "" {
		params.MapData["vendorIDs"] = params.VendorIDs
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.SettleUnionOrders, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.SettleUnionOrders, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.SettleUnionOrders error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tRechargeQueryAccountBillParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *RechargeManagerController) QueryAccountBill() {
// 	c.callQueryAccountBill(func(params *tRechargeQueryAccountBillParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *RechargeManagerController) callQueryAccountBill(handler func(params *tRechargeQueryAccountBillParams) (interface{}, string, error)) {
	var err error
	params := &tRechargeQueryAccountBillParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API RechargeManagerController.QueryAccountBill, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API RechargeManagerController.QueryAccountBill, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API RechargeManagerController.QueryAccountBill error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventSendSysMessageParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
}

// func (c *EventController) SendSysMessage() {
// 	c.callSendSysMessage(func(params *tEventSendSysMessageParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callSendSysMessage(handler func(params *tEventSendSysMessageParams) (interface{}, string, error)) {
	var err error
	params := &tEventSendSysMessageParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.SendSysMessage, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.SendSysMessage, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.SendSysMessage error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionGetVendorMatterDetailParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorID		int
	GoodsID		string
}

// func (c *UnionController) GetVendorMatterDetail() {
// 	c.callGetVendorMatterDetail(func(params *tUnionGetVendorMatterDetailParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callGetVendorMatterDetail(handler func(params *tUnionGetVendorMatterDetailParams) (interface{}, string, error)) {
	var err error
	params := &tUnionGetVendorMatterDetailParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.VendorID, err = c.GetInt("vendorID", 0); err != nil {
		errParams = append(errParams, "vendorID")
	}
	params.GoodsID = utils.TrimBlankChar(c.GetString("goodsID"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if c.GetString("vendorID") == "" {
		errParams = append(errParams, "vendorID")
	}
	params.MapData["vendorID"] = params.VendorID
	if c.GetString("goodsID") == "" {
		errParams = append(errParams, "goodsID")
	}
	params.MapData["goodsID"] = params.GoodsID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.GetVendorMatterDetail, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.GetVendorMatterDetail, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.GetVendorMatterDetail error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2LoginParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	AuthType		string
	AuthSecret		string
	AuthID		string
	AuthIDType		string
}

// func (c *Auth2Controller) Login() {
// 	c.callLogin(func(params *tAuth2LoginParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callLogin(handler func(params *tAuth2LoginParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2LoginParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.AuthType = utils.TrimBlankChar(c.GetString("authType"))
	params.AuthSecret = utils.TrimBlankChar(c.GetString("authSecret"))
	params.AuthID = utils.TrimBlankChar(c.GetString("authID"))
	params.AuthIDType = utils.TrimBlankChar(c.GetString("authIDType"))
	if c.GetString("authType") == "" {
		errParams = append(errParams, "authType")
	}
	params.MapData["authType"] = params.AuthType
	if c.GetString("authSecret") == "" {
		errParams = append(errParams, "authSecret")
	}
	params.MapData["authSecret"] = params.AuthSecret
	if utils.TrimBlankChar(c.GetString("authID")) != "" {
		params.MapData["authID"] = params.AuthID
	}
	if utils.TrimBlankChar(c.GetString("authIDType")) != "" {
		params.MapData["authIDType"] = params.AuthIDType
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.Login, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.Login, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.Login error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobRefreshJdDeliveryParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *JobController) RefreshJdDelivery() {
// 	c.callRefreshJdDelivery(func(params *tJobRefreshJdDeliveryParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callRefreshJdDelivery(handler func(params *tJobRefreshJdDeliveryParams) (interface{}, string, error)) {
	var err error
	params := &tJobRefreshJdDeliveryParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.RefreshJdDelivery, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.RefreshJdDelivery, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.RefreshJdDelivery error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobTempJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *JobController) TempJob() {
// 	c.callTempJob(func(params *tJobTempJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callTempJob(handler func(params *tJobTempJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobTempJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.TempJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.TempJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.TempJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobSubmitJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
}

// func (c *JobController) SubmitJob() {
// 	c.callSubmitJob(func(params *tJobSubmitJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callSubmitJob(handler func(params *tJobSubmitJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobSubmitJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.SubmitJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.SubmitJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.SubmitJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobAddressDistinguishParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Address		string
}

// func (c *JobController) AddressDistinguish() {
// 	c.callAddressDistinguish(func(params *tJobAddressDistinguishParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callAddressDistinguish(handler func(params *tJobAddressDistinguishParams) (interface{}, string, error)) {
	var err error
	params := &tJobAddressDistinguishParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Address = utils.TrimBlankChar(c.GetString("address"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("address")) != "" {
		params.MapData["address"] = params.Address
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.AddressDistinguish, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.AddressDistinguish, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.AddressDistinguish error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobCancelAcceptJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobID		int
	JobOrderID		int
}

// func (c *JobController) CancelAcceptJob() {
// 	c.callCancelAcceptJob(func(params *tJobCancelAcceptJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callCancelAcceptJob(handler func(params *tJobCancelAcceptJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobCancelAcceptJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.JobID, err = c.GetInt("jobID", 0); err != nil {
		errParams = append(errParams, "jobID")
	}
	if params.JobOrderID, err = c.GetInt("jobOrderID", 0); err != nil {
		errParams = append(errParams, "jobOrderID")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobID") == "" {
		errParams = append(errParams, "jobID")
	}
	params.MapData["jobID"] = params.JobID
	if c.GetString("jobOrderID") == "" {
		errParams = append(errParams, "jobOrderID")
	}
	params.MapData["jobOrderID"] = params.JobOrderID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.CancelAcceptJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.CancelAcceptJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.CancelAcceptJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tExpressCancelWayVendorOrderParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Genre		int
	OrderNo		string
	Type		int
}

// func (c *QBiDaExpressController) CancelWayVendorOrder() {
// 	c.callCancelWayVendorOrder(func(params *tExpressCancelWayVendorOrderParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *QBiDaExpressController) callCancelWayVendorOrder(handler func(params *tExpressCancelWayVendorOrderParams) (interface{}, string, error)) {
	var err error
	params := &tExpressCancelWayVendorOrderParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Genre, err = c.GetInt("genre", 0); err != nil {
		errParams = append(errParams, "genre")
	}
	params.OrderNo = utils.TrimBlankChar(c.GetString("orderNo"))
	if params.Type, err = c.GetInt("type", 0); err != nil {
		errParams = append(errParams, "type")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("genre") == "" {
		errParams = append(errParams, "genre")
	}
	params.MapData["genre"] = params.Genre
	if c.GetString("orderNo") == "" {
		errParams = append(errParams, "orderNo")
	}
	params.MapData["orderNo"] = params.OrderNo
	if c.GetString("type") == "" {
		errParams = append(errParams, "type")
	}
	params.MapData["type"] = params.Type
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API QBiDaExpressController.CancelWayVendorOrder, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API QBiDaExpressController.CancelWayVendorOrder, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API QBiDaExpressController.CancelWayVendorOrder error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tWithdrawalAddWithdrawalRecordParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	WithdrawalMoney		int
	AlipayAccount		string
	AlipayName		string
	Lng		float64
	Lat		float64
	CityCode		int
	DistrictCode		int
}

// func (c *WithdrawalRecordController) AddWithdrawalRecord() {
// 	c.callAddWithdrawalRecord(func(params *tWithdrawalAddWithdrawalRecordParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *WithdrawalRecordController) callAddWithdrawalRecord(handler func(params *tWithdrawalAddWithdrawalRecordParams) (interface{}, string, error)) {
	var err error
	params := &tWithdrawalAddWithdrawalRecordParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.WithdrawalMoney, err = c.GetInt("withdrawalMoney", 0); err != nil {
		errParams = append(errParams, "withdrawalMoney")
	}
	params.AlipayAccount = utils.TrimBlankChar(c.GetString("alipayAccount"))
	params.AlipayName = utils.TrimBlankChar(c.GetString("alipayName"))
	if params.Lng, err = c.GetFloat("lng", 0); err != nil {
		errParams = append(errParams, "lng")
	}
	if params.Lat, err = c.GetFloat("lat", 0); err != nil {
		errParams = append(errParams, "lat")
	}
	if params.CityCode, err = c.GetInt("cityCode", 0); err != nil {
		errParams = append(errParams, "cityCode")
	}
	if params.DistrictCode, err = c.GetInt("districtCode", 0); err != nil {
		errParams = append(errParams, "districtCode")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("withdrawalMoney") == "" {
		errParams = append(errParams, "withdrawalMoney")
	}
	params.MapData["withdrawalMoney"] = params.WithdrawalMoney
	if c.GetString("alipayAccount") == "" {
		errParams = append(errParams, "alipayAccount")
	}
	params.MapData["alipayAccount"] = params.AlipayAccount
	if c.GetString("alipayName") == "" {
		errParams = append(errParams, "alipayName")
	}
	params.MapData["alipayName"] = params.AlipayName
	if c.GetString("lng") == "" {
		errParams = append(errParams, "lng")
	}
	params.MapData["lng"] = params.Lng
	if c.GetString("lat") == "" {
		errParams = append(errParams, "lat")
	}
	params.MapData["lat"] = params.Lat
	if c.GetString("cityCode") == "" {
		errParams = append(errParams, "cityCode")
	}
	params.MapData["cityCode"] = params.CityCode
	if c.GetString("districtCode") == "" {
		errParams = append(errParams, "districtCode")
	}
	params.MapData["districtCode"] = params.DistrictCode
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API WithdrawalRecordController.AddWithdrawalRecord, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API WithdrawalRecordController.AddWithdrawalRecord, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API WithdrawalRecordController.AddWithdrawalRecord error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2ChangePasswordParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OldPwd		string
	NewPwd		string
}

// func (c *Auth2Controller) ChangePassword() {
// 	c.callChangePassword(func(params *tAuth2ChangePasswordParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callChangePassword(handler func(params *tAuth2ChangePasswordParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2ChangePasswordParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OldPwd = utils.TrimBlankChar(c.GetString("oldPwd"))
	params.NewPwd = utils.TrimBlankChar(c.GetString("newPwd"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("oldPwd")) != "" {
		params.MapData["oldPwd"] = params.OldPwd
	}
	if c.GetString("newPwd") == "" {
		errParams = append(errParams, "newPwd")
	}
	params.MapData["newPwd"] = params.NewPwd
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.ChangePassword, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.ChangePassword, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.ChangePassword error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2GetUserCityManagerParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
	CityCode		int
}

// func (c *User2Controller) GetUserCityManager() {
// 	c.callGetUserCityManager(func(params *tUser2GetUserCityManagerParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callGetUserCityManager(handler func(params *tUser2GetUserCityManagerParams) (interface{}, string, error)) {
	var err error
	params := &tUser2GetUserCityManagerParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.CityCode, err = c.GetInt("cityCode", 0); err != nil {
		errParams = append(errParams, "cityCode")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("userID")) != "" {
		params.MapData["userID"] = params.UserID
	}
	if utils.TrimBlankChar(c.GetString("cityCode")) != "" {
		params.MapData["cityCode"] = params.CityCode
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.GetUserCityManager, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.GetUserCityManager, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.GetUserCityManager error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2SaveMyCartParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	StoreID		int
	Payload		string
}

// func (c *User2Controller) SaveMyCart() {
// 	c.callSaveMyCart(func(params *tUser2SaveMyCartParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callSaveMyCart(handler func(params *tUser2SaveMyCartParams) (interface{}, string, error)) {
	var err error
	params := &tUser2SaveMyCartParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.StoreID, err = c.GetInt("storeID", 0); err != nil {
		errParams = append(errParams, "storeID")
	}
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("storeID") == "" {
		errParams = append(errParams, "storeID")
	}
	params.MapData["storeID"] = params.StoreID
	if utils.TrimBlankChar(c.GetString("payload")) != "" {
		params.MapData["payload"] = params.Payload
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.SaveMyCart, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.SaveMyCart, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.SaveMyCart error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetCoordinateFromAddressParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Address		string
	CityCode		int
}

// func (c *JobController) GetCoordinateFromAddress() {
// 	c.callGetCoordinateFromAddress(func(params *tJobGetCoordinateFromAddressParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetCoordinateFromAddress(handler func(params *tJobGetCoordinateFromAddressParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetCoordinateFromAddressParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Address = utils.TrimBlankChar(c.GetString("address"))
	if params.CityCode, err = c.GetInt("cityCode", 0); err != nil {
		errParams = append(errParams, "cityCode")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("address") == "" {
		errParams = append(errParams, "address")
	}
	params.MapData["address"] = params.Address
	if c.GetString("cityCode") == "" {
		errParams = append(errParams, "cityCode")
	}
	params.MapData["cityCode"] = params.CityCode
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetCoordinateFromAddress, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetCoordinateFromAddress, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetCoordinateFromAddress error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionGetVendorMattersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorID		int
	VendorCatID		string
	Keyword		string
	Offset		int
	PageSize		int
	ListID		string
	SortType		int
}

// func (c *UnionController) GetVendorMatters() {
// 	c.callGetVendorMatters(func(params *tUnionGetVendorMattersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callGetVendorMatters(handler func(params *tUnionGetVendorMattersParams) (interface{}, string, error)) {
	var err error
	params := &tUnionGetVendorMattersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.VendorID, err = c.GetInt("vendorID", 0); err != nil {
		errParams = append(errParams, "vendorID")
	}
	params.VendorCatID = utils.TrimBlankChar(c.GetString("vendorCatID"))
	params.Keyword = utils.TrimBlankChar(c.GetString("keyword"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	params.ListID = utils.TrimBlankChar(c.GetString("listID"))
	if params.SortType, err = c.GetInt("sortType", 0); err != nil {
		errParams = append(errParams, "sortType")
	}
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if c.GetString("vendorID") == "" {
		errParams = append(errParams, "vendorID")
	}
	params.MapData["vendorID"] = params.VendorID
	if utils.TrimBlankChar(c.GetString("vendorCatID")) != "" {
		params.MapData["vendorCatID"] = params.VendorCatID
	}
	if utils.TrimBlankChar(c.GetString("keyword")) != "" {
		params.MapData["keyword"] = params.Keyword
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if utils.TrimBlankChar(c.GetString("listID")) != "" {
		params.MapData["listID"] = params.ListID
	}
	if utils.TrimBlankChar(c.GetString("sortType")) != "" {
		params.MapData["sortType"] = params.SortType
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.GetVendorMatters, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.GetVendorMatters, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.GetVendorMatters error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2AddAuthBindWithMobileParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	AuthToken		string
	Mobile		string
}

// func (c *Auth2Controller) AddAuthBindWithMobile() {
// 	c.callAddAuthBindWithMobile(func(params *tAuth2AddAuthBindWithMobileParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callAddAuthBindWithMobile(handler func(params *tAuth2AddAuthBindWithMobileParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2AddAuthBindWithMobileParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.AuthToken = utils.TrimBlankChar(c.GetString("authToken"))
	params.Mobile = utils.TrimBlankChar(c.GetString("mobile"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("authToken") == "" {
		errParams = append(errParams, "authToken")
	}
	params.MapData["authToken"] = params.AuthToken
	if c.GetString("mobile") == "" {
		errParams = append(errParams, "mobile")
	}
	params.MapData["mobile"] = params.Mobile
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.AddAuthBindWithMobile, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.AddAuthBindWithMobile, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.AddAuthBindWithMobile error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2DeletedTokenInfoWithoutParamParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *Auth2Controller) DeletedTokenInfoWithoutParam() {
// 	c.callDeletedTokenInfoWithoutParam(func(params *tAuth2DeletedTokenInfoWithoutParamParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callDeletedTokenInfoWithoutParam(handler func(params *tAuth2DeletedTokenInfoWithoutParamParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2DeletedTokenInfoWithoutParamParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.DeletedTokenInfoWithoutParam, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.DeletedTokenInfoWithoutParam, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.DeletedTokenInfoWithoutParam error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobCancelPublishJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobID		int
}

// func (c *JobController) CancelPublishJob() {
// 	c.callCancelPublishJob(func(params *tJobCancelPublishJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callCancelPublishJob(handler func(params *tJobCancelPublishJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobCancelPublishJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.JobID, err = c.GetInt("jobID", 0); err != nil {
		errParams = append(errParams, "jobID")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobID") == "" {
		errParams = append(errParams, "jobID")
	}
	params.MapData["jobID"] = params.JobID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.CancelPublishJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.CancelPublishJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.CancelPublishJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventUploadAudioParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *EventController) UploadAudio() {
// 	c.callUploadAudio(func(params *tEventUploadAudioParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callUploadAudio(handler func(params *tEventUploadAudioParams) (interface{}, string, error)) {
	var err error
	params := &tEventUploadAudioParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.UploadAudio, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.UploadAudio, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.UploadAudio error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tExpressQueryUserOrderListParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	ExpressType		int
	OrderStatus		int
	OrderNo		string
	PageNum		int
	PageSize		int
}

// func (c *QBiDaExpressController) QueryUserOrderList() {
// 	c.callQueryUserOrderList(func(params *tExpressQueryUserOrderListParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *QBiDaExpressController) callQueryUserOrderList(handler func(params *tExpressQueryUserOrderListParams) (interface{}, string, error)) {
	var err error
	params := &tExpressQueryUserOrderListParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.ExpressType, err = c.GetInt("expressType", 0); err != nil {
		errParams = append(errParams, "expressType")
	}
	if params.OrderStatus, err = c.GetInt("orderStatus", 0); err != nil {
		errParams = append(errParams, "orderStatus")
	}
	params.OrderNo = utils.TrimBlankChar(c.GetString("orderNo"))
	if params.PageNum, err = c.GetInt("pageNum", 0); err != nil {
		errParams = append(errParams, "pageNum")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("expressType")) != "" {
		params.MapData["expressType"] = params.ExpressType
	}
	if utils.TrimBlankChar(c.GetString("orderStatus")) != "" {
		params.MapData["orderStatus"] = params.OrderStatus
	}
	if utils.TrimBlankChar(c.GetString("orderNo")) != "" {
		params.MapData["orderNo"] = params.OrderNo
	}
	if c.GetString("pageNum") == "" {
		errParams = append(errParams, "pageNum")
	}
	params.MapData["pageNum"] = params.PageNum
	if c.GetString("pageSize") == "" {
		errParams = append(errParams, "pageSize")
	}
	params.MapData["pageSize"] = params.PageSize
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API QBiDaExpressController.QueryUserOrderList, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API QBiDaExpressController.QueryUserOrderList, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API QBiDaExpressController.QueryUserOrderList error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2CreateCaptchaParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Width		int
	Height		int
	CaptchaLen		int
}

// func (c *Auth2Controller) CreateCaptcha() {
// 	c.callCreateCaptcha(func(params *tAuth2CreateCaptchaParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callCreateCaptcha(handler func(params *tAuth2CreateCaptchaParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2CreateCaptchaParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	if params.Width, err = c.GetInt("width", 0); err != nil {
		errParams = append(errParams, "width")
	}
	if params.Height, err = c.GetInt("height", 0); err != nil {
		errParams = append(errParams, "height")
	}
	if params.CaptchaLen, err = c.GetInt("captchaLen", 0); err != nil {
		errParams = append(errParams, "captchaLen")
	}
	if c.GetString("width") == "" {
		errParams = append(errParams, "width")
	}
	params.MapData["width"] = params.Width
	if c.GetString("height") == "" {
		errParams = append(errParams, "height")
	}
	params.MapData["height"] = params.Height
	if utils.TrimBlankChar(c.GetString("captchaLen")) != "" {
		params.MapData["captchaLen"] = params.CaptchaLen
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.CreateCaptcha, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.CreateCaptcha, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.CreateCaptcha error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2GetUserParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
}

// func (c *User2Controller) GetUser() {
// 	c.callGetUser(func(params *tUser2GetUserParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callGetUser(handler func(params *tUser2GetUserParams) (interface{}, string, error)) {
	var err error
	params := &tUser2GetUserParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.GetUser, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.GetUser, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.GetUser error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2UpdateMyDeliveryAddressParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Id		int
	ConsigneeName		string
	ConsigneeMobile		string
	Address		string
	DetailAddress		string
	Lng		float64
	Lat		float64
	Tag		string
	Remark		string
	IsDefault		int
}

// func (c *User2Controller) UpdateMyDeliveryAddress() {
// 	c.callUpdateMyDeliveryAddress(func(params *tUser2UpdateMyDeliveryAddressParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callUpdateMyDeliveryAddress(handler func(params *tUser2UpdateMyDeliveryAddressParams) (interface{}, string, error)) {
	var err error
	params := &tUser2UpdateMyDeliveryAddressParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Id, err = c.GetInt("id", 0); err != nil {
		errParams = append(errParams, "id")
	}
	params.ConsigneeName = utils.TrimBlankChar(c.GetString("consigneeName"))
	params.ConsigneeMobile = utils.TrimBlankChar(c.GetString("consigneeMobile"))
	params.Address = utils.TrimBlankChar(c.GetString("address"))
	params.DetailAddress = utils.TrimBlankChar(c.GetString("detailAddress"))
	if params.Lng, err = c.GetFloat("lng", 0); err != nil {
		errParams = append(errParams, "lng")
	}
	if params.Lat, err = c.GetFloat("lat", 0); err != nil {
		errParams = append(errParams, "lat")
	}
	params.Tag = utils.TrimBlankChar(c.GetString("tag"))
	params.Remark = utils.TrimBlankChar(c.GetString("remark"))
	if params.IsDefault, err = c.GetInt("isDefault", 0); err != nil {
		errParams = append(errParams, "isDefault")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("id") == "" {
		errParams = append(errParams, "id")
	}
	params.MapData["id"] = params.Id
	if utils.TrimBlankChar(c.GetString("consigneeName")) != "" {
		params.MapData["consigneeName"] = params.ConsigneeName
	}
	if utils.TrimBlankChar(c.GetString("consigneeMobile")) != "" {
		params.MapData["consigneeMobile"] = params.ConsigneeMobile
	}
	if utils.TrimBlankChar(c.GetString("address")) != "" {
		params.MapData["address"] = params.Address
	}
	if utils.TrimBlankChar(c.GetString("detailAddress")) != "" {
		params.MapData["detailAddress"] = params.DetailAddress
	}
	if utils.TrimBlankChar(c.GetString("lng")) != "" {
		params.MapData["lng"] = params.Lng
	}
	if utils.TrimBlankChar(c.GetString("lat")) != "" {
		params.MapData["lat"] = params.Lat
	}
	if utils.TrimBlankChar(c.GetString("tag")) != "" {
		params.MapData["tag"] = params.Tag
	}
	if utils.TrimBlankChar(c.GetString("remark")) != "" {
		params.MapData["remark"] = params.Remark
	}
	if utils.TrimBlankChar(c.GetString("isDefault")) != "" {
		params.MapData["isDefault"] = params.IsDefault
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.UpdateMyDeliveryAddress, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.UpdateMyDeliveryAddress, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.UpdateMyDeliveryAddress error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2InvestMemberParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	MemberID		int
}

// func (c *User2Controller) InvestMember() {
// 	c.callInvestMember(func(params *tUser2InvestMemberParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callInvestMember(handler func(params *tUser2InvestMemberParams) (interface{}, string, error)) {
	var err error
	params := &tUser2InvestMemberParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.MemberID, err = c.GetInt("memberID", 0); err != nil {
		errParams = append(errParams, "memberID")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("memberID") == "" {
		errParams = append(errParams, "memberID")
	}
	params.MapData["memberID"] = params.MemberID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.InvestMember, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.InvestMember, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.InvestMember error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2AcceptAddGroupParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Flag		int
}

// func (c *User2Controller) AcceptAddGroup() {
// 	c.callAcceptAddGroup(func(params *tUser2AcceptAddGroupParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callAcceptAddGroup(handler func(params *tUser2AcceptAddGroupParams) (interface{}, string, error)) {
	var err error
	params := &tUser2AcceptAddGroupParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Flag, err = c.GetInt("flag", 0); err != nil {
		errParams = append(errParams, "flag")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("flag") == "" {
		errParams = append(errParams, "flag")
	}
	params.MapData["flag"] = params.Flag
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.AcceptAddGroup, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.AcceptAddGroup, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.AcceptAddGroup error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsGetPlacesParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Keyword		string
	ParentCode		int
	Level		int
	IncludeDisabled		bool
}

// func (c *CmsController) GetPlaces() {
// 	c.callGetPlaces(func(params *tCmsGetPlacesParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callGetPlaces(handler func(params *tCmsGetPlacesParams) (interface{}, string, error)) {
	var err error
	params := &tCmsGetPlacesParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Keyword = utils.TrimBlankChar(c.GetString("keyword"))
	if params.ParentCode, err = c.GetInt("parentCode", 0); err != nil {
		errParams = append(errParams, "parentCode")
	}
	if params.Level, err = c.GetInt("level", 0); err != nil {
		errParams = append(errParams, "level")
	}
	if params.IncludeDisabled, err = c.GetBool("includeDisabled", false); err != nil {
		errParams = append(errParams, "includeDisabled")
	}
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if utils.TrimBlankChar(c.GetString("keyword")) != "" {
		params.MapData["keyword"] = params.Keyword
	}
	if utils.TrimBlankChar(c.GetString("parentCode")) != "" {
		params.MapData["parentCode"] = params.ParentCode
	}
	if utils.TrimBlankChar(c.GetString("level")) != "" {
		params.MapData["level"] = params.Level
	}
	if utils.TrimBlankChar(c.GetString("includeDisabled")) != "" {
		params.MapData["includeDisabled"] = params.IncludeDisabled
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.GetPlaces, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.GetPlaces, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.GetPlaces error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsDeleteConfigParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Type		string
	Key		string
}

// func (c *CmsController) DeleteConfig() {
// 	c.callDeleteConfig(func(params *tCmsDeleteConfigParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callDeleteConfig(handler func(params *tCmsDeleteConfigParams) (interface{}, string, error)) {
	var err error
	params := &tCmsDeleteConfigParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Type = utils.TrimBlankChar(c.GetString("type"))
	params.Key = utils.TrimBlankChar(c.GetString("key"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("type") == "" {
		errParams = append(errParams, "type")
	}
	params.MapData["type"] = params.Type
	if c.GetString("key") == "" {
		errParams = append(errParams, "key")
	}
	params.MapData["key"] = params.Key
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.DeleteConfig, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.DeleteConfig, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.DeleteConfig error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionGetVendorMatterRcmmdParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorID		int
	GoodsID		string
	RcmmdType		int
	Offset		int
	PageSize		int
}

// func (c *UnionController) GetVendorMatterRcmmd() {
// 	c.callGetVendorMatterRcmmd(func(params *tUnionGetVendorMatterRcmmdParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callGetVendorMatterRcmmd(handler func(params *tUnionGetVendorMatterRcmmdParams) (interface{}, string, error)) {
	var err error
	params := &tUnionGetVendorMatterRcmmdParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.VendorID, err = c.GetInt("vendorID", 0); err != nil {
		errParams = append(errParams, "vendorID")
	}
	params.GoodsID = utils.TrimBlankChar(c.GetString("goodsID"))
	if params.RcmmdType, err = c.GetInt("rcmmdType", 0); err != nil {
		errParams = append(errParams, "rcmmdType")
	}
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if c.GetString("vendorID") == "" {
		errParams = append(errParams, "vendorID")
	}
	params.MapData["vendorID"] = params.VendorID
	if c.GetString("goodsID") == "" {
		errParams = append(errParams, "goodsID")
	}
	params.MapData["goodsID"] = params.GoodsID
	if c.GetString("rcmmdType") == "" {
		errParams = append(errParams, "rcmmdType")
	}
	params.MapData["rcmmdType"] = params.RcmmdType
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.GetVendorMatterRcmmd, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.GetVendorMatterRcmmd, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.GetVendorMatterRcmmd error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tExpressGetOrderDetailParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	ExpressType		int
	OrderNo		string
}

// func (c *QBiDaExpressController) GetOrderDetail() {
// 	c.callGetOrderDetail(func(params *tExpressGetOrderDetailParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *QBiDaExpressController) callGetOrderDetail(handler func(params *tExpressGetOrderDetailParams) (interface{}, string, error)) {
	var err error
	params := &tExpressGetOrderDetailParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.ExpressType, err = c.GetInt("expressType", 0); err != nil {
		errParams = append(errParams, "expressType")
	}
	params.OrderNo = utils.TrimBlankChar(c.GetString("orderNo"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("expressType") == "" {
		errParams = append(errParams, "expressType")
	}
	params.MapData["expressType"] = params.ExpressType
	if c.GetString("orderNo") == "" {
		errParams = append(errParams, "orderNo")
	}
	params.MapData["orderNo"] = params.OrderNo
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API QBiDaExpressController.GetOrderDetail, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API QBiDaExpressController.GetOrderDetail, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API QBiDaExpressController.GetOrderDetail error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tRechargeGetUserRechargeParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Page		int
	PageSize		int
	Mobile		string
	OrderId		string
}

// func (c *RechargeManagerController) GetUserRecharge() {
// 	c.callGetUserRecharge(func(params *tRechargeGetUserRechargeParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *RechargeManagerController) callGetUserRecharge(handler func(params *tRechargeGetUserRechargeParams) (interface{}, string, error)) {
	var err error
	params := &tRechargeGetUserRechargeParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Page, err = c.GetInt("page", 0); err != nil {
		errParams = append(errParams, "page")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	params.Mobile = utils.TrimBlankChar(c.GetString("mobile"))
	params.OrderId = utils.TrimBlankChar(c.GetString("orderId"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("page") == "" {
		errParams = append(errParams, "page")
	}
	params.MapData["page"] = params.Page
	if c.GetString("pageSize") == "" {
		errParams = append(errParams, "pageSize")
	}
	params.MapData["pageSize"] = params.PageSize
	if utils.TrimBlankChar(c.GetString("mobile")) != "" {
		params.MapData["mobile"] = params.Mobile
	}
	if utils.TrimBlankChar(c.GetString("orderId")) != "" {
		params.MapData["orderId"] = params.OrderId
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API RechargeManagerController.GetUserRecharge, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API RechargeManagerController.GetUserRecharge, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API RechargeManagerController.GetUserRecharge error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2RemoveAuthBindParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	AuthType		string
	AuthTypeID		string
}

// func (c *Auth2Controller) RemoveAuthBind() {
// 	c.callRemoveAuthBind(func(params *tAuth2RemoveAuthBindParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callRemoveAuthBind(handler func(params *tAuth2RemoveAuthBindParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2RemoveAuthBindParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.AuthType = utils.TrimBlankChar(c.GetString("authType"))
	params.AuthTypeID = utils.TrimBlankChar(c.GetString("authTypeID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("authType") == "" {
		errParams = append(errParams, "authType")
	}
	params.MapData["authType"] = params.AuthType
	if utils.TrimBlankChar(c.GetString("authTypeID")) != "" {
		params.MapData["authTypeID"] = params.AuthTypeID
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.RemoveAuthBind, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.RemoveAuthBind, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.RemoveAuthBind error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2SendVerifyCodeParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	CaptchaID		string
	CaptchaValue		string
	AuthToken		string
	AuthID		string
}

// func (c *Auth2Controller) SendVerifyCode() {
// 	c.callSendVerifyCode(func(params *tAuth2SendVerifyCodeParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callSendVerifyCode(handler func(params *tAuth2SendVerifyCodeParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2SendVerifyCodeParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.CaptchaID = utils.TrimBlankChar(c.GetString("captchaID"))
	params.CaptchaValue = utils.TrimBlankChar(c.GetString("captchaValue"))
	params.AuthToken = utils.TrimBlankChar(c.GetString("authToken"))
	params.AuthID = utils.TrimBlankChar(c.GetString("authID"))
	if utils.TrimBlankChar(c.GetString("captchaID")) != "" {
		params.MapData["captchaID"] = params.CaptchaID
	}
	if utils.TrimBlankChar(c.GetString("captchaValue")) != "" {
		params.MapData["captchaValue"] = params.CaptchaValue
	}
	if utils.TrimBlankChar(c.GetString("authToken")) != "" {
		params.MapData["authToken"] = params.AuthToken
	}
	if c.GetString("authID") == "" {
		errParams = append(errParams, "authID")
	}
	params.MapData["authID"] = params.AuthID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.SendVerifyCode, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.SendVerifyCode, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.SendVerifyCode error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2QueryMyDeliveryAddressParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Type		int
}

// func (c *User2Controller) QueryMyDeliveryAddress() {
// 	c.callQueryMyDeliveryAddress(func(params *tUser2QueryMyDeliveryAddressParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callQueryMyDeliveryAddress(handler func(params *tUser2QueryMyDeliveryAddressParams) (interface{}, string, error)) {
	var err error
	params := &tUser2QueryMyDeliveryAddressParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Type, err = c.GetInt("type", 0); err != nil {
		errParams = append(errParams, "type")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("type")) != "" {
		params.MapData["type"] = params.Type
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.QueryMyDeliveryAddress, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.QueryMyDeliveryAddress, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.QueryMyDeliveryAddress error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tExpressDeleteOrderParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	LocalOrderId		string
}

// func (c *QBiDaExpressController) DeleteOrder() {
// 	c.callDeleteOrder(func(params *tExpressDeleteOrderParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *QBiDaExpressController) callDeleteOrder(handler func(params *tExpressDeleteOrderParams) (interface{}, string, error)) {
	var err error
	params := &tExpressDeleteOrderParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.LocalOrderId = utils.TrimBlankChar(c.GetString("localOrderId"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("localOrderId") == "" {
		errParams = append(errParams, "localOrderId")
	}
	params.MapData["localOrderId"] = params.LocalOrderId
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API QBiDaExpressController.DeleteOrder, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API QBiDaExpressController.DeleteOrder, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API QBiDaExpressController.DeleteOrder error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderGetManageStatisticsImgParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	CityCodes		string
	FromTime		string
	ToTime		string
	JobIDs		string
}

// func (c *OrderController) GetManageStatisticsImg() {
// 	c.callGetManageStatisticsImg(func(params *tOrderGetManageStatisticsImgParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callGetManageStatisticsImg(handler func(params *tOrderGetManageStatisticsImgParams) (interface{}, string, error)) {
	var err error
	params := &tOrderGetManageStatisticsImgParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.CityCodes = utils.TrimBlankChar(c.GetString("cityCodes"))
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	params.JobIDs = utils.TrimBlankChar(c.GetString("jobIDs"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("cityCodes")) != "" {
		params.MapData["cityCodes"] = params.CityCodes
	}
	if c.GetString("fromTime") == "" {
		errParams = append(errParams, "fromTime")
	}
	params.MapData["fromTime"] = params.FromTime
	if c.GetString("toTime") == "" {
		errParams = append(errParams, "toTime")
	}
	params.MapData["toTime"] = params.ToTime
	if utils.TrimBlankChar(c.GetString("jobIDs")) != "" {
		params.MapData["jobIDs"] = params.JobIDs
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.GetManageStatisticsImg, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.GetManageStatisticsImg, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.GetManageStatisticsImg error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobConfirmDropShippingJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobOrderID		int
}

// func (c *JobController) ConfirmDropShippingJob() {
// 	c.callConfirmDropShippingJob(func(params *tJobConfirmDropShippingJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callConfirmDropShippingJob(handler func(params *tJobConfirmDropShippingJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobConfirmDropShippingJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.JobOrderID, err = c.GetInt("jobOrderID", 0); err != nil {
		errParams = append(errParams, "jobOrderID")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobOrderID") == "" {
		errParams = append(errParams, "jobOrderID")
	}
	params.MapData["jobOrderID"] = params.JobOrderID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.ConfirmDropShippingJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.ConfirmDropShippingJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.ConfirmDropShippingJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobSendJdDeliveryParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
	PickUpStartTime		string
	PickUpEndTime		string
}

// func (c *JobController) SendJdDelivery() {
// 	c.callSendJdDelivery(func(params *tJobSendJdDeliveryParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callSendJdDelivery(handler func(params *tJobSendJdDeliveryParams) (interface{}, string, error)) {
	var err error
	params := &tJobSendJdDeliveryParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	params.PickUpStartTime = utils.TrimBlankChar(c.GetString("pickUpStartTime"))
	params.PickUpEndTime = utils.TrimBlankChar(c.GetString("pickUpEndTime"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if utils.TrimBlankChar(c.GetString("pickUpStartTime")) != "" {
		params.MapData["pickUpStartTime"] = params.PickUpStartTime
	}
	if utils.TrimBlankChar(c.GetString("pickUpEndTime")) != "" {
		params.MapData["pickUpEndTime"] = params.PickUpEndTime
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.SendJdDelivery, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.SendJdDelivery, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.SendJdDelivery error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tBillGetUserBillDetailParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
	FromTime		string
	ToTime		string
	Offset		int
	PageSize		int
}

// func (c *BillController) GetUserBillDetail() {
// 	c.callGetUserBillDetail(func(params *tBillGetUserBillDetailParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *BillController) callGetUserBillDetail(handler func(params *tBillGetUserBillDetailParams) (interface{}, string, error)) {
	var err error
	params := &tBillGetUserBillDetailParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API BillController.GetUserBillDetail, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API BillController.GetUserBillDetail, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API BillController.GetUserBillDetail error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tExpressGetOrderListParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	ExpressType		int
	OrderNo		string
	OrderStatus		int
	PageNum		int
	PageSize		int
	StartTime		string
	EndTime		string
}

// func (c *QBiDaExpressController) GetOrderList() {
// 	c.callGetOrderList(func(params *tExpressGetOrderListParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *QBiDaExpressController) callGetOrderList(handler func(params *tExpressGetOrderListParams) (interface{}, string, error)) {
	var err error
	params := &tExpressGetOrderListParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.ExpressType, err = c.GetInt("expressType", 0); err != nil {
		errParams = append(errParams, "expressType")
	}
	params.OrderNo = utils.TrimBlankChar(c.GetString("orderNo"))
	if params.OrderStatus, err = c.GetInt("orderStatus", 0); err != nil {
		errParams = append(errParams, "orderStatus")
	}
	if params.PageNum, err = c.GetInt("pageNum", 0); err != nil {
		errParams = append(errParams, "pageNum")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	params.StartTime = utils.TrimBlankChar(c.GetString("startTime"))
	params.EndTime = utils.TrimBlankChar(c.GetString("endTime"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("expressType")) != "" {
		params.MapData["expressType"] = params.ExpressType
	}
	if utils.TrimBlankChar(c.GetString("orderNo")) != "" {
		params.MapData["orderNo"] = params.OrderNo
	}
	if utils.TrimBlankChar(c.GetString("orderStatus")) != "" {
		params.MapData["orderStatus"] = params.OrderStatus
	}
	if c.GetString("pageNum") == "" {
		errParams = append(errParams, "pageNum")
	}
	params.MapData["pageNum"] = params.PageNum
	if c.GetString("pageSize") == "" {
		errParams = append(errParams, "pageSize")
	}
	params.MapData["pageSize"] = params.PageSize
	if c.GetString("startTime") == "" {
		errParams = append(errParams, "startTime")
	}
	params.MapData["startTime"] = params.StartTime
	if c.GetString("endTime") == "" {
		errParams = append(errParams, "endTime")
	}
	params.MapData["endTime"] = params.EndTime
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API QBiDaExpressController.GetOrderList, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API QBiDaExpressController.GetOrderList, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API QBiDaExpressController.GetOrderList error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2GetTokenInfoParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *Auth2Controller) GetTokenInfo() {
// 	c.callGetTokenInfo(func(params *tAuth2GetTokenInfoParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callGetTokenInfo(handler func(params *tAuth2GetTokenInfoParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2GetTokenInfoParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.GetTokenInfo, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.GetTokenInfo, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.GetTokenInfo error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2UpdateUserByMiniInfoParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Data		string
	Iv		string
	JsCode		string
}

// func (c *User2Controller) UpdateUserByMiniInfo() {
// 	c.callUpdateUserByMiniInfo(func(params *tUser2UpdateUserByMiniInfoParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callUpdateUserByMiniInfo(handler func(params *tUser2UpdateUserByMiniInfoParams) (interface{}, string, error)) {
	var err error
	params := &tUser2UpdateUserByMiniInfoParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Data = utils.TrimBlankChar(c.GetString("data"))
	params.Iv = utils.TrimBlankChar(c.GetString("iv"))
	params.JsCode = utils.TrimBlankChar(c.GetString("jsCode"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("data") == "" {
		errParams = append(errParams, "data")
	}
	params.MapData["data"] = params.Data
	if c.GetString("iv") == "" {
		errParams = append(errParams, "iv")
	}
	params.MapData["iv"] = params.Iv
	if utils.TrimBlankChar(c.GetString("jsCode")) != "" {
		params.MapData["jsCode"] = params.JsCode
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.UpdateUserByMiniInfo, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.UpdateUserByMiniInfo, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.UpdateUserByMiniInfo error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2UpdateUserParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Payload		string
}

// func (c *User2Controller) UpdateUser() {
// 	c.callUpdateUser(func(params *tUser2UpdateUserParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callUpdateUser(handler func(params *tUser2UpdateUserParams) (interface{}, string, error)) {
	var err error
	params := &tUser2UpdateUserParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Payload = utils.TrimBlankChar(c.GetString("payload"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("payload") == "" {
		errParams = append(errParams, "payload")
	}
	params.MapData["payload"] = params.Payload
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.UpdateUser, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.UpdateUser, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.UpdateUser error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetAllDeliveryDetailParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorWaybillID		string
	ComType		string
}

// func (c *JobController) GetAllDeliveryDetail() {
// 	c.callGetAllDeliveryDetail(func(params *tJobGetAllDeliveryDetailParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetAllDeliveryDetail(handler func(params *tJobGetAllDeliveryDetailParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetAllDeliveryDetailParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.VendorWaybillID = utils.TrimBlankChar(c.GetString("vendorWaybillID"))
	params.ComType = utils.TrimBlankChar(c.GetString("comType"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("vendorWaybillID")) != "" {
		params.MapData["vendorWaybillID"] = params.VendorWaybillID
	}
	if utils.TrimBlankChar(c.GetString("comType")) != "" {
		params.MapData["comType"] = params.ComType
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetAllDeliveryDetail, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetAllDeliveryDetail, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetAllDeliveryDetail error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventGetMessageGroupsParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	GroupID		int
	IsMember		bool
}

// func (c *EventController) GetMessageGroups() {
// 	c.callGetMessageGroups(func(params *tEventGetMessageGroupsParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callGetMessageGroups(handler func(params *tEventGetMessageGroupsParams) (interface{}, string, error)) {
	var err error
	params := &tEventGetMessageGroupsParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.GroupID, err = c.GetInt("groupID", 0); err != nil {
		errParams = append(errParams, "groupID")
	}
	if params.IsMember, err = c.GetBool("isMember", false); err != nil {
		errParams = append(errParams, "isMember")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("groupID") == "" {
		errParams = append(errParams, "groupID")
	}
	params.MapData["groupID"] = params.GroupID
	if c.GetString("isMember") == "" {
		errParams = append(errParams, "isMember")
	}
	params.MapData["isMember"] = params.IsMember
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.GetMessageGroups, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.GetMessageGroups, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.GetMessageGroups error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionGetUnionJobOrderInfoParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobOrderID		int
}

// func (c *UnionController) GetUnionJobOrderInfo() {
// 	c.callGetUnionJobOrderInfo(func(params *tUnionGetUnionJobOrderInfoParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callGetUnionJobOrderInfo(handler func(params *tUnionGetUnionJobOrderInfoParams) (interface{}, string, error)) {
	var err error
	params := &tUnionGetUnionJobOrderInfoParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.JobOrderID, err = c.GetInt("jobOrderID", 0); err != nil {
		errParams = append(errParams, "jobOrderID")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobOrderID") == "" {
		errParams = append(errParams, "jobOrderID")
	}
	params.MapData["jobOrderID"] = params.JobOrderID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.GetUnionJobOrderInfo, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.GetUnionJobOrderInfo, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.GetUnionJobOrderInfo error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUnionGetPddBindInfoParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *UnionController) GetPddBindInfo() {
// 	c.callGetPddBindInfo(func(params *tUnionGetPddBindInfoParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UnionController) callGetPddBindInfo(handler func(params *tUnionGetPddBindInfoParams) (interface{}, string, error)) {
	var err error
	params := &tUnionGetPddBindInfoParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UnionController.GetPddBindInfo, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UnionController.GetPddBindInfo, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UnionController.GetPddBindInfo error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2AddUserCityManagerParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
	CityCode		int
}

// func (c *User2Controller) AddUserCityManager() {
// 	c.callAddUserCityManager(func(params *tUser2AddUserCityManagerParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callAddUserCityManager(handler func(params *tUser2AddUserCityManagerParams) (interface{}, string, error)) {
	var err error
	params := &tUser2AddUserCityManagerParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.CityCode, err = c.GetInt("cityCode", 0); err != nil {
		errParams = append(errParams, "cityCode")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if c.GetString("cityCode") == "" {
		errParams = append(errParams, "cityCode")
	}
	params.MapData["cityCode"] = params.CityCode
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.AddUserCityManager, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.AddUserCityManager, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.AddUserCityManager error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobAcceptJobParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobID		int
	DropShippingDeliveryID		int
	DropShippingCount		int
}

// func (c *JobController) AcceptJob() {
// 	c.callAcceptJob(func(params *tJobAcceptJobParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callAcceptJob(handler func(params *tJobAcceptJobParams) (interface{}, string, error)) {
	var err error
	params := &tJobAcceptJobParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.JobID, err = c.GetInt("jobID", 0); err != nil {
		errParams = append(errParams, "jobID")
	}
	if params.DropShippingDeliveryID, err = c.GetInt("dropShippingDeliveryID", 0); err != nil {
		errParams = append(errParams, "dropShippingDeliveryID")
	}
	if params.DropShippingCount, err = c.GetInt("dropShippingCount", 0); err != nil {
		errParams = append(errParams, "dropShippingCount")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobID") == "" {
		errParams = append(errParams, "jobID")
	}
	params.MapData["jobID"] = params.JobID
	if utils.TrimBlankChar(c.GetString("dropShippingDeliveryID")) != "" {
		params.MapData["dropShippingDeliveryID"] = params.DropShippingDeliveryID
	}
	if utils.TrimBlankChar(c.GetString("dropShippingCount")) != "" {
		params.MapData["dropShippingCount"] = params.DropShippingCount
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.AcceptJob, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.AcceptJob, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.AcceptJob error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobUserRefundEjyParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorOrderID		string
	Reason		string
}

// func (c *JobController) UserRefundEjy() {
// 	c.callUserRefundEjy(func(params *tJobUserRefundEjyParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callUserRefundEjy(handler func(params *tJobUserRefundEjyParams) (interface{}, string, error)) {
	var err error
	params := &tJobUserRefundEjyParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.VendorOrderID = utils.TrimBlankChar(c.GetString("vendorOrderID"))
	params.Reason = utils.TrimBlankChar(c.GetString("reason"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("vendorOrderID") == "" {
		errParams = append(errParams, "vendorOrderID")
	}
	params.MapData["vendorOrderID"] = params.VendorOrderID
	if c.GetString("reason") == "" {
		errParams = append(errParams, "reason")
	}
	params.MapData["reason"] = params.Reason
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.UserRefundEjy, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.UserRefundEjy, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.UserRefundEjy error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobTempJobTestParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Data		string
}

// func (c *JobController) TempJobTest() {
// 	c.callTempJobTest(func(params *tJobTempJobTestParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callTempJobTest(handler func(params *tJobTempJobTestParams) (interface{}, string, error)) {
	var err error
	params := &tJobTempJobTestParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Data = utils.TrimBlankChar(c.GetString("data"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if utils.TrimBlankChar(c.GetString("data")) != "" {
		params.MapData["data"] = params.Data
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.TempJobTest, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.TempJobTest, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.TempJobTest error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetJobDetailParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobID		int
	Lng		float64
	Lat		float64
}

// func (c *JobController) GetJobDetail() {
// 	c.callGetJobDetail(func(params *tJobGetJobDetailParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetJobDetail(handler func(params *tJobGetJobDetailParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetJobDetailParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.JobID, err = c.GetInt("jobID", 0); err != nil {
		errParams = append(errParams, "jobID")
	}
	if params.Lng, err = c.GetFloat("lng", 0); err != nil {
		errParams = append(errParams, "lng")
	}
	if params.Lat, err = c.GetFloat("lat", 0); err != nil {
		errParams = append(errParams, "lat")
	}
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if utils.TrimBlankChar(c.GetString("jobID")) != "" {
		params.MapData["jobID"] = params.JobID
	}
	if utils.TrimBlankChar(c.GetString("lng")) != "" {
		params.MapData["lng"] = params.Lng
	}
	if utils.TrimBlankChar(c.GetString("lat")) != "" {
		params.MapData["lat"] = params.Lat
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetJobDetail, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetJobDetail, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetJobDetail error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventGetUserStatisticsParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *EventController) GetUserStatistics() {
// 	c.callGetUserStatistics(func(params *tEventGetUserStatisticsParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callGetUserStatistics(handler func(params *tEventGetUserStatisticsParams) (interface{}, string, error)) {
	var err error
	params := &tEventGetUserStatisticsParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.GetUserStatistics, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.GetUserStatistics, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.GetUserStatistics error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventDeleteMessageGroupParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	GroupID		int
	UserID		string
	Flag		bool
}

// func (c *EventController) DeleteMessageGroup() {
// 	c.callDeleteMessageGroup(func(params *tEventDeleteMessageGroupParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callDeleteMessageGroup(handler func(params *tEventDeleteMessageGroupParams) (interface{}, string, error)) {
	var err error
	params := &tEventDeleteMessageGroupParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.GroupID, err = c.GetInt("groupID", 0); err != nil {
		errParams = append(errParams, "groupID")
	}
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.Flag, err = c.GetBool("flag", false); err != nil {
		errParams = append(errParams, "flag")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("groupID") == "" {
		errParams = append(errParams, "groupID")
	}
	params.MapData["groupID"] = params.GroupID
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if utils.TrimBlankChar(c.GetString("flag")) != "" {
		params.MapData["flag"] = params.Flag
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.DeleteMessageGroup, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.DeleteMessageGroup, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.DeleteMessageGroup error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsQueryConfigsParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Type		string
	Key		string
	Keyword		string
}

// func (c *CmsController) QueryConfigs() {
// 	c.callQueryConfigs(func(params *tCmsQueryConfigsParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callQueryConfigs(handler func(params *tCmsQueryConfigsParams) (interface{}, string, error)) {
	var err error
	params := &tCmsQueryConfigsParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Type = utils.TrimBlankChar(c.GetString("type"))
	params.Key = utils.TrimBlankChar(c.GetString("key"))
	params.Keyword = utils.TrimBlankChar(c.GetString("keyword"))
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if utils.TrimBlankChar(c.GetString("type")) != "" {
		params.MapData["type"] = params.Type
	}
	if utils.TrimBlankChar(c.GetString("key")) != "" {
		params.MapData["key"] = params.Key
	}
	if utils.TrimBlankChar(c.GetString("keyword")) != "" {
		params.MapData["keyword"] = params.Keyword
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.QueryConfigs, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.QueryConfigs, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.QueryConfigs error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsInitPlaceParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *CmsController) InitPlace() {
// 	c.callInitPlace(func(params *tCmsInitPlaceParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callInitPlace(handler func(params *tCmsInitPlaceParams) (interface{}, string, error)) {
	var err error
	params := &tCmsInitPlaceParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.InitPlace, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.InitPlace, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.InitPlace error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tExpressTryAgainOrderByOldOrderParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OldNo		string
}

// func (c *QBiDaExpressController) TryAgainOrderByOldOrder() {
// 	c.callTryAgainOrderByOldOrder(func(params *tExpressTryAgainOrderByOldOrderParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *QBiDaExpressController) callTryAgainOrderByOldOrder(handler func(params *tExpressTryAgainOrderByOldOrderParams) (interface{}, string, error)) {
	var err error
	params := &tExpressTryAgainOrderByOldOrderParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OldNo = utils.TrimBlankChar(c.GetString("oldNo"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("oldNo") == "" {
		errParams = append(errParams, "oldNo")
	}
	params.MapData["oldNo"] = params.OldNo
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API QBiDaExpressController.TryAgainOrderByOldOrder, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API QBiDaExpressController.TryAgainOrderByOldOrder, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API QBiDaExpressController.TryAgainOrderByOldOrder error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2GetUserSerachKeywordParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *User2Controller) GetUserSerachKeyword() {
// 	c.callGetUserSerachKeyword(func(params *tUser2GetUserSerachKeywordParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callGetUserSerachKeyword(handler func(params *tUser2GetUserSerachKeywordParams) (interface{}, string, error)) {
	var err error
	params := &tUser2GetUserSerachKeywordParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.GetUserSerachKeyword, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.GetUserSerachKeyword, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.GetUserSerachKeyword error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobReloadJobSpanParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobIDs		string
	Span		int
}

// func (c *JobController) ReloadJobSpan() {
// 	c.callReloadJobSpan(func(params *tJobReloadJobSpanParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callReloadJobSpan(handler func(params *tJobReloadJobSpanParams) (interface{}, string, error)) {
	var err error
	params := &tJobReloadJobSpanParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.JobIDs = utils.TrimBlankChar(c.GetString("jobIDs"))
	if params.Span, err = c.GetInt("span", 0); err != nil {
		errParams = append(errParams, "span")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobIDs") == "" {
		errParams = append(errParams, "jobIDs")
	}
	params.MapData["jobIDs"] = params.JobIDs
	if c.GetString("span") == "" {
		errParams = append(errParams, "span")
	}
	params.MapData["span"] = params.Span
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.ReloadJobSpan, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.ReloadJobSpan, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.ReloadJobSpan error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobCreateJobSpanParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	JobIDs		string
	EndAt		string
	Span		int
}

// func (c *JobController) CreateJobSpan() {
// 	c.callCreateJobSpan(func(params *tJobCreateJobSpanParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callCreateJobSpan(handler func(params *tJobCreateJobSpanParams) (interface{}, string, error)) {
	var err error
	params := &tJobCreateJobSpanParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.JobIDs = utils.TrimBlankChar(c.GetString("jobIDs"))
	params.EndAt = utils.TrimBlankChar(c.GetString("endAt"))
	if params.Span, err = c.GetInt("span", 0); err != nil {
		errParams = append(errParams, "span")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("jobIDs") == "" {
		errParams = append(errParams, "jobIDs")
	}
	params.MapData["jobIDs"] = params.JobIDs
	if c.GetString("endAt") == "" {
		errParams = append(errParams, "endAt")
	}
	params.MapData["endAt"] = params.EndAt
	if c.GetString("span") == "" {
		errParams = append(errParams, "span")
	}
	params.MapData["span"] = params.Span
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.CreateJobSpan, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.CreateJobSpan, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.CreateJobSpan error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetJobsParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserIDs		string
	CategoryIDs		string
	Statuss		string
	VendorIDs		string
	CityCodes		string
	IncludeStep		bool
	FromTime		string
	ToTime		string
	Lng		float64
	Lat		float64
	Span		int
	Keyword		string
	SortType		int
	Offset		int
	PageSize		int
}

// func (c *JobController) GetJobs() {
// 	c.callGetJobs(func(params *tJobGetJobsParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetJobs(handler func(params *tJobGetJobsParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetJobsParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserIDs = utils.TrimBlankChar(c.GetString("userIDs"))
	params.CategoryIDs = utils.TrimBlankChar(c.GetString("categoryIDs"))
	params.Statuss = utils.TrimBlankChar(c.GetString("statuss"))
	params.VendorIDs = utils.TrimBlankChar(c.GetString("vendorIDs"))
	params.CityCodes = utils.TrimBlankChar(c.GetString("cityCodes"))
	if params.IncludeStep, err = c.GetBool("includeStep", false); err != nil {
		errParams = append(errParams, "includeStep")
	}
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	if params.Lng, err = c.GetFloat("lng", 0); err != nil {
		errParams = append(errParams, "lng")
	}
	if params.Lat, err = c.GetFloat("lat", 0); err != nil {
		errParams = append(errParams, "lat")
	}
	if params.Span, err = c.GetInt("span", 0); err != nil {
		errParams = append(errParams, "span")
	}
	params.Keyword = utils.TrimBlankChar(c.GetString("keyword"))
	if params.SortType, err = c.GetInt("sortType", 0); err != nil {
		errParams = append(errParams, "sortType")
	}
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if utils.TrimBlankChar(c.Ctx.Input.Header("token")) != "" {
		params.MapData["token"] = params.Token
	}
	if utils.TrimBlankChar(c.GetString("userIDs")) != "" {
		params.MapData["userIDs"] = params.UserIDs
	}
	if utils.TrimBlankChar(c.GetString("categoryIDs")) != "" {
		params.MapData["categoryIDs"] = params.CategoryIDs
	}
	if utils.TrimBlankChar(c.GetString("statuss")) != "" {
		params.MapData["statuss"] = params.Statuss
	}
	if utils.TrimBlankChar(c.GetString("vendorIDs")) != "" {
		params.MapData["vendorIDs"] = params.VendorIDs
	}
	if utils.TrimBlankChar(c.GetString("cityCodes")) != "" {
		params.MapData["cityCodes"] = params.CityCodes
	}
	if utils.TrimBlankChar(c.GetString("includeStep")) != "" {
		params.MapData["includeStep"] = params.IncludeStep
	}
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("lng")) != "" {
		params.MapData["lng"] = params.Lng
	}
	if utils.TrimBlankChar(c.GetString("lat")) != "" {
		params.MapData["lat"] = params.Lat
	}
	if utils.TrimBlankChar(c.GetString("span")) != "" {
		params.MapData["span"] = params.Span
	}
	if utils.TrimBlankChar(c.GetString("keyword")) != "" {
		params.MapData["keyword"] = params.Keyword
	}
	if utils.TrimBlankChar(c.GetString("sortType")) != "" {
		params.MapData["sortType"] = params.SortType
	}
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if utils.TrimBlankChar(c.GetString("pageSize")) != "" {
		params.MapData["pageSize"] = params.PageSize
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetJobs, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetJobs, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetJobs error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetEjyOrdersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Offset		int
}

// func (c *JobController) GetEjyOrders() {
// 	c.callGetEjyOrders(func(params *tJobGetEjyOrdersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetEjyOrders(handler func(params *tJobGetEjyOrdersParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetEjyOrdersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Offset, err = c.GetInt("offset", 0); err != nil {
		errParams = append(errParams, "offset")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("offset")) != "" {
		params.MapData["offset"] = params.Offset
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetEjyOrders, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetEjyOrders, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetEjyOrders error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsUpdatePlaceParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Code		int
}

// func (c *CmsController) UpdatePlace() {
// 	c.callUpdatePlace(func(params *tCmsUpdatePlaceParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callUpdatePlace(handler func(params *tCmsUpdatePlaceParams) (interface{}, string, error)) {
	var err error
	params := &tCmsUpdatePlaceParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Code, err = c.GetInt("code", 0); err != nil {
		errParams = append(errParams, "code")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("code") == "" {
		errParams = append(errParams, "code")
	}
	params.MapData["code"] = params.Code
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.UpdatePlace, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.UpdatePlace, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.UpdatePlace error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tRechargeSystemQueryRechargeListParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	OrderId		string
	Mobile		string
	RechargeStatus		int
	Page		int
	PageSize		int
	StartTime		string
	EndTime		string
	UserName		string
}

// func (c *RechargeManagerController) SystemQueryRechargeList() {
// 	c.callSystemQueryRechargeList(func(params *tRechargeSystemQueryRechargeListParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *RechargeManagerController) callSystemQueryRechargeList(handler func(params *tRechargeSystemQueryRechargeListParams) (interface{}, string, error)) {
	var err error
	params := &tRechargeSystemQueryRechargeListParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.OrderId = utils.TrimBlankChar(c.GetString("orderId"))
	params.Mobile = utils.TrimBlankChar(c.GetString("mobile"))
	if params.RechargeStatus, err = c.GetInt("rechargeStatus", 0); err != nil {
		errParams = append(errParams, "rechargeStatus")
	}
	if params.Page, err = c.GetInt("page", 0); err != nil {
		errParams = append(errParams, "page")
	}
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	params.StartTime = utils.TrimBlankChar(c.GetString("startTime"))
	params.EndTime = utils.TrimBlankChar(c.GetString("endTime"))
	params.UserName = utils.TrimBlankChar(c.GetString("userName"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("orderId")) != "" {
		params.MapData["orderId"] = params.OrderId
	}
	if utils.TrimBlankChar(c.GetString("mobile")) != "" {
		params.MapData["mobile"] = params.Mobile
	}
	if utils.TrimBlankChar(c.GetString("rechargeStatus")) != "" {
		params.MapData["rechargeStatus"] = params.RechargeStatus
	}
	if c.GetString("page") == "" {
		errParams = append(errParams, "page")
	}
	params.MapData["page"] = params.Page
	if c.GetString("pageSize") == "" {
		errParams = append(errParams, "pageSize")
	}
	params.MapData["pageSize"] = params.PageSize
	if c.GetString("startTime") == "" {
		errParams = append(errParams, "startTime")
	}
	params.MapData["startTime"] = params.StartTime
	if c.GetString("endTime") == "" {
		errParams = append(errParams, "endTime")
	}
	params.MapData["endTime"] = params.EndTime
	if utils.TrimBlankChar(c.GetString("userName")) != "" {
		params.MapData["userName"] = params.UserName
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API RechargeManagerController.SystemQueryRechargeList, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API RechargeManagerController.SystemQueryRechargeList, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API RechargeManagerController.SystemQueryRechargeList error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tUser2GetSelfInfoParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
}

// func (c *User2Controller) GetSelfInfo() {
// 	c.callGetSelfInfo(func(params *tUser2GetSelfInfoParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *User2Controller) callGetSelfInfo(handler func(params *tUser2GetSelfInfoParams) (interface{}, string, error)) {
	var err error
	params := &tUser2GetSelfInfoParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API User2Controller.GetSelfInfo, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API User2Controller.GetSelfInfo, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API User2Controller.GetSelfInfo error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobGetDeliveryDetailParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorWaybillID		string
}

// func (c *JobController) GetDeliveryDetail() {
// 	c.callGetDeliveryDetail(func(params *tJobGetDeliveryDetailParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callGetDeliveryDetail(handler func(params *tJobGetDeliveryDetailParams) (interface{}, string, error)) {
	var err error
	params := &tJobGetDeliveryDetailParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.VendorWaybillID = utils.TrimBlankChar(c.GetString("vendorWaybillID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("vendorWaybillID")) != "" {
		params.MapData["vendorWaybillID"] = params.VendorWaybillID
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.GetDeliveryDetail, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.GetDeliveryDetail, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.GetDeliveryDetail error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2AddAuthBindParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	AuthToken		string
}

// func (c *Auth2Controller) AddAuthBind() {
// 	c.callAddAuthBind(func(params *tAuth2AddAuthBindParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callAddAuthBind(handler func(params *tAuth2AddAuthBindParams) (interface{}, string, error)) {
	var err error
	params := &tAuth2AddAuthBindParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.AuthToken = utils.TrimBlankChar(c.GetString("authToken"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("authToken") == "" {
		errParams = append(errParams, "authToken")
	}
	params.MapData["authToken"] = params.AuthToken
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.AddAuthBind, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.AddAuthBind, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.AddAuthBind error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tBalanceUpdateUserBalanceParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Phone		string
	UserID		string
	Money		int
}

// func (c *UserBalanceController) UpdateUserBalance() {
// 	c.callUpdateUserBalance(func(params *tBalanceUpdateUserBalanceParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *UserBalanceController) callUpdateUserBalance(handler func(params *tBalanceUpdateUserBalanceParams) (interface{}, string, error)) {
	var err error
	params := &tBalanceUpdateUserBalanceParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Phone = utils.TrimBlankChar(c.GetString("phone"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.Money, err = c.GetInt("money", 0); err != nil {
		errParams = append(errParams, "money")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("phone") == "" {
		errParams = append(errParams, "phone")
	}
	params.MapData["phone"] = params.Phone
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if utils.TrimBlankChar(c.GetString("money")) != "" {
		params.MapData["money"] = params.Money
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API UserBalanceController.UpdateUserBalance, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API UserBalanceController.UpdateUserBalance, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API UserBalanceController.UpdateUserBalance error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tWithdrawalGetWithdrawalListParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	PageSize		int
	PageNum		int
	UserName		string
	UserId		string
	OrderId		string
	StartTime		string
	EndTime		string
	Phone		string
	OrderStatus		int
}

// func (c *WithdrawalRecordController) GetWithdrawalList() {
// 	c.callGetWithdrawalList(func(params *tWithdrawalGetWithdrawalListParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *WithdrawalRecordController) callGetWithdrawalList(handler func(params *tWithdrawalGetWithdrawalListParams) (interface{}, string, error)) {
	var err error
	params := &tWithdrawalGetWithdrawalListParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.PageSize, err = c.GetInt("pageSize", 0); err != nil {
		errParams = append(errParams, "pageSize")
	}
	if params.PageNum, err = c.GetInt("pageNum", 0); err != nil {
		errParams = append(errParams, "pageNum")
	}
	params.UserName = utils.TrimBlankChar(c.GetString("userName"))
	params.UserId = utils.TrimBlankChar(c.GetString("userId"))
	params.OrderId = utils.TrimBlankChar(c.GetString("orderId"))
	params.StartTime = utils.TrimBlankChar(c.GetString("startTime"))
	params.EndTime = utils.TrimBlankChar(c.GetString("endTime"))
	params.Phone = utils.TrimBlankChar(c.GetString("phone"))
	if params.OrderStatus, err = c.GetInt("orderStatus", 0); err != nil {
		errParams = append(errParams, "orderStatus")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("pageSize") == "" {
		errParams = append(errParams, "pageSize")
	}
	params.MapData["pageSize"] = params.PageSize
	if c.GetString("pageNum") == "" {
		errParams = append(errParams, "pageNum")
	}
	params.MapData["pageNum"] = params.PageNum
	if utils.TrimBlankChar(c.GetString("userName")) != "" {
		params.MapData["userName"] = params.UserName
	}
	if utils.TrimBlankChar(c.GetString("userId")) != "" {
		params.MapData["userId"] = params.UserId
	}
	if utils.TrimBlankChar(c.GetString("orderId")) != "" {
		params.MapData["orderId"] = params.OrderId
	}
	if utils.TrimBlankChar(c.GetString("startTime")) != "" {
		params.MapData["startTime"] = params.StartTime
	}
	if utils.TrimBlankChar(c.GetString("endTime")) != "" {
		params.MapData["endTime"] = params.EndTime
	}
	if utils.TrimBlankChar(c.GetString("phone")) != "" {
		params.MapData["phone"] = params.Phone
	}
	if utils.TrimBlankChar(c.GetString("orderStatus")) != "" {
		params.MapData["orderStatus"] = params.OrderStatus
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API WithdrawalRecordController.GetWithdrawalList, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API WithdrawalRecordController.GetWithdrawalList, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API WithdrawalRecordController.GetWithdrawalList error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tCmsGetQiniuUploadTokenParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Suffix		string
	HashCode		string
}

// func (c *CmsController) GetQiniuUploadToken() {
// 	c.callGetQiniuUploadToken(func(params *tCmsGetQiniuUploadTokenParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *CmsController) callGetQiniuUploadToken(handler func(params *tCmsGetQiniuUploadTokenParams) (interface{}, string, error)) {
	var err error
	params := &tCmsGetQiniuUploadTokenParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.Suffix = utils.TrimBlankChar(c.GetString("suffix"))
	params.HashCode = utils.TrimBlankChar(c.GetString("hashCode"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("suffix") == "" {
		errParams = append(errParams, "suffix")
	}
	params.MapData["suffix"] = params.Suffix
	if utils.TrimBlankChar(c.GetString("hashCode")) != "" {
		params.MapData["hashCode"] = params.HashCode
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API CmsController.GetQiniuUploadToken, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API CmsController.GetQiniuUploadToken, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API CmsController.GetQiniuUploadToken error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventTestWebsocketParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
}

// func (c *EventController) TestWebsocket() {
// 	c.callTestWebsocket(func(params *tEventTestWebsocketParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callTestWebsocket(handler func(params *tEventTestWebsocketParams) (interface{}, string, error)) {
	var err error
	params := &tEventTestWebsocketParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.TestWebsocket, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.TestWebsocket, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.TestWebsocket error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tEventGetMessageGroupByUserParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
}

// func (c *EventController) GetMessageGroupByUser() {
// 	c.callGetMessageGroupByUser(func(params *tEventGetMessageGroupByUserParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *EventController) callGetMessageGroupByUser(handler func(params *tEventGetMessageGroupByUserParams) (interface{}, string, error)) {
	var err error
	params := &tEventGetMessageGroupByUserParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("userID") == "" {
		errParams = append(errParams, "userID")
	}
	params.MapData["userID"] = params.UserID
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API EventController.GetMessageGroupByUser, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API EventController.GetMessageGroupByUser, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API EventController.GetMessageGroupByUser error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tAuth2WeixinOAuth2Params struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Code		string
	Block		string
	State		string
}

// func (c *Auth2Controller) WeixinOAuth2() {
// 	c.callWeixinOAuth2(func(params *tAuth2WeixinOAuth2Params) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *Auth2Controller) callWeixinOAuth2(handler func(params *tAuth2WeixinOAuth2Params) (interface{}, string, error)) {
	var err error
	params := &tAuth2WeixinOAuth2Params{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Code = utils.TrimBlankChar(c.GetString("code"))
	params.Block = utils.TrimBlankChar(c.GetString("block"))
	params.State = utils.TrimBlankChar(c.GetString("state"))
	if c.GetString("code") == "" {
		errParams = append(errParams, "code")
	}
	params.MapData["code"] = params.Code
	if c.GetString("block") == "" {
		errParams = append(errParams, "block")
	}
	params.MapData["block"] = params.Block
	if utils.TrimBlankChar(c.GetString("state")) != "" {
		params.MapData["state"] = params.State
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx = jxcontext.NewWithUserName(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API Auth2Controller.WeixinOAuth2, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API Auth2Controller.WeixinOAuth2, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API Auth2Controller.WeixinOAuth2 error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tOrderGetPayStatisticsParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	UserID		string
	Pop		int
	CityCodes		string
	Mobile		string
	FromTime		string
	ToTime		string
	OrderTypes		string
}

// func (c *OrderController) GetPayStatistics() {
// 	c.callGetPayStatistics(func(params *tOrderGetPayStatisticsParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *OrderController) callGetPayStatistics(handler func(params *tOrderGetPayStatisticsParams) (interface{}, string, error)) {
	var err error
	params := &tOrderGetPayStatisticsParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.UserID = utils.TrimBlankChar(c.GetString("userID"))
	if params.Pop, err = c.GetInt("pop", 0); err != nil {
		errParams = append(errParams, "pop")
	}
	params.CityCodes = utils.TrimBlankChar(c.GetString("cityCodes"))
	params.Mobile = utils.TrimBlankChar(c.GetString("mobile"))
	params.FromTime = utils.TrimBlankChar(c.GetString("fromTime"))
	params.ToTime = utils.TrimBlankChar(c.GetString("toTime"))
	params.OrderTypes = utils.TrimBlankChar(c.GetString("orderTypes"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if utils.TrimBlankChar(c.GetString("userID")) != "" {
		params.MapData["userID"] = params.UserID
	}
	if utils.TrimBlankChar(c.GetString("pop")) != "" {
		params.MapData["pop"] = params.Pop
	}
	if utils.TrimBlankChar(c.GetString("cityCodes")) != "" {
		params.MapData["cityCodes"] = params.CityCodes
	}
	if utils.TrimBlankChar(c.GetString("mobile")) != "" {
		params.MapData["mobile"] = params.Mobile
	}
	if utils.TrimBlankChar(c.GetString("fromTime")) != "" {
		params.MapData["fromTime"] = params.FromTime
	}
	if utils.TrimBlankChar(c.GetString("toTime")) != "" {
		params.MapData["toTime"] = params.ToTime
	}
	if utils.TrimBlankChar(c.GetString("orderTypes")) != "" {
		params.MapData["orderTypes"] = params.OrderTypes
	}
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API OrderController.GetPayStatistics, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API OrderController.GetPayStatistics, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API OrderController.GetPayStatistics error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobRechargeMtMembersParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	Phone		int
}

// func (c *JobController) RechargeMtMembers() {
// 	c.callRechargeMtMembers(func(params *tJobRechargeMtMembersParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callRechargeMtMembers(handler func(params *tJobRechargeMtMembersParams) (interface{}, string, error)) {
	var err error
	params := &tJobRechargeMtMembersParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	if params.Phone, err = c.GetInt("phone", 0); err != nil {
		errParams = append(errParams, "phone")
	}
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("phone") == "" {
		errParams = append(errParams, "phone")
	}
	params.MapData["phone"] = params.Phone
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.RechargeMtMembers, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.RechargeMtMembers, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.RechargeMtMembers error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}

type tJobCancelJdDeliveryParams struct {
	MapData	map[string]interface{}
	Ctx		*jxcontext.Context
	Token		string
	VendorWaybillID		string
	Reason		string
}

// func (c *JobController) CancelJdDelivery() {
// 	c.callCancelJdDelivery(func(params *tJobCancelJdDeliveryParams) (retVal interface{}, errCode string, err error) {
// 		return retVal, "", err
// 	})
// }
func (c *JobController) callCancelJdDelivery(handler func(params *tJobCancelJdDeliveryParams) (interface{}, string, error)) {
	var err error
	params := &tJobCancelJdDeliveryParams{
		MapData : make(map[string]interface{}),
	}
	errParams := []string{}
	token	:= c.Ctx.Input.Header("token")
	errCode := model.ErrCodeGeneralFailed

	params.Token = utils.TrimBlankChar(c.Ctx.Input.Header("token"))
	params.VendorWaybillID = utils.TrimBlankChar(c.GetString("vendorWaybillID"))
	params.Reason = utils.TrimBlankChar(c.GetString("reason"))
	if params.Token == "" {
		errCode = model.ErrCodeTokenIsInvalid
		err = model.ErrTokenIsInvalid
	}
	params.MapData["token"] = params.Token
	if c.GetString("vendorWaybillID") == "" {
		errParams = append(errParams, "vendorWaybillID")
	}
	params.MapData["vendorWaybillID"] = params.VendorWaybillID
	if c.GetString("reason") == "" {
		errParams = append(errParams, "reason")
	}
	params.MapData["reason"] = params.Reason
	if len(errParams) > 0 && err == nil {
		err = fmt.Errorf(strRequiredParamIsEmpty, strings.Join(errParams, ","))
	}

	if err == nil {
		var (
			errCode2	string
			err2		error
			result interface{}
		)
		params.Ctx, errCode2, err2 = jxcontext.New(nil, token, c.Ctx.ResponseWriter, c.Ctx.Request)
		if err = err2; err == nil {
			globals.SugarLogger.Debugf("Begin API JobController.CancelJdDelivery, username:%s, accessUUID:%s, data:%s\n", params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), utils.Format4Output(params.MapData, true))
			beginTime := time.Now()
			result, errCode2, err2 = handler(params)
			resultStr := ""
			if err = err2; err == nil {
				if globals.OutputDebugMsgLevel > 0 {
					resultStr = utils.Format4Output(result, true)
				}
				if len(resultStr) > 2000000 {
					resultStr = fmt.Sprintf("result len is:%d", len(resultStr))
				}
				if errCode2 != model.ErrorCodeIgnore {
					resultMarshal, _ := json.Marshal(result)
					c.Data["json"] = &CallResult{
						Code: model.ErrCodeSuccess,
						Data: string(resultMarshal),
					}
				} else {
					errCode = errCode2
				}
			}else {
				if errSync, ok := err2.(*cms.SyncError); ok {
					if _,ok := errSync.Original.(*cms.SpecSyncError);ok{
						errCode2 = model.ErrCodeJsonSyncErr
						errCode = errCode2
					}
				}
			}
			if globals.IsAddEvent {
				if params.Ctx != nil {
					if params.Ctx.GetRequest().Method != http.MethodGet{
						var (
							errMsg string
							errCodeEvent string
						)
						if err2 != nil {
							errMsg = err2.Error()
							errCodeEvent = errCode
						}else {
							errMsg = ""
							errCodeEvent = model.ErrCodeSuccess
						}
						event.AddOperateEvent(params.Ctx, params.Ctx.GetTrackInfo(), string(utils.MustMarshal(params.MapData)), errCodeEvent, errMsg, int(time.Now().Sub(beginTime) / time.Millisecond), "")
					}
				}
			}
			globals.SugarLogger.Debugf("End API JobController.CancelJdDelivery, username:%s, accessUUID:%s, elapsed time:%d, data:%s, err:%v, errCode:%s, result:%s\n",
				params.Ctx.GetUserName(), params.Ctx.GetTrackInfo(), int(time.Now().Sub(beginTime) / time.Millisecond),
				utils.Format4Output(params.MapData, true), err, errCode2, resultStr)
		}
		if err != nil && errCode2 != model.ErrCodeSuccess && errCode2 != "" {
			errCode = errCode2
		}
		if err != nil {
			globals.SugarLogger.Debugf("API JobController.CancelJdDelivery error:%v, data:%s", err, utils.Format4Output(params.MapData, true))
		}
	}
	if errCode != model.ErrorCodeIgnore {
		if err != nil {
			if errCode == model.ErrCodeGeneralFailed && jsonerr.IsJsonErr(err) {
				errCode = err.(*jsonerr.Error).ErrCode()
			}
			c.Data["json"] = &CallResult{
				Code: errCode,
				Desc: err.Error(),
			}
		}
		c.ServeJSON()
	}
}