package main

import (
	"encoding/json"
	"io"
	"net/http"
	"reflect"
	"time"

	"github.com/go-kit/kit/endpoint"
	"github.com/go-kit/kit/log"
	httptransport "github.com/go-kit/kit/transport/http"
	"xiaoniaokuaiyan.com/xiaoniao/cerror"
	"xiaoniaokuaiyan.com/xiaoniao/entity"
	"xiaoniaokuaiyan.com/xiaoniao/search"
	"xiaoniaokuaiyan.com/xiaoniao/server"
)

type loggingMiddleware struct {
	server.UserService
	server.AuthService
	server.SearchService
	server.FileService
	server.OrderService
	server.SMSService
	server.CartService
	server.CouponService
	server.ProductivityService
	server.WeixinService
	server.CityService
	server.UserLinkerService
	server.ProductService
	server.DeliverUserService
	server.SystemService
	server.ActivityService
	server.GroupBloodService
	server.PayService
	server.JDLService
	log.Logger
}

//type ServiceMethod func(interface{}) (interface{}, error)

func (m loggingMiddleware) Login(params map[string]string) (v interface{}, err error) {
	defer func(begin time.Time) {
		vbytes, _ := json.Marshal(v)
		m.Logger.Log(
			"method", "UserService.Login",
			"mobile", params["mobile"],
			"password", params["password"],
			"v", string(vbytes),
			"took", time.Since(begin),
		)
	}(time.Now())
	v, err = m.UserService.Login(params)
	return
}

func (m loggingMiddleware) LoginV2(params map[string]string) (v interface{}, err error) {
	defer func(begin time.Time) {
		vbytes, _ := json.Marshal(v)
		m.Logger.Log(
			"method", "UserService.LoginV2",
			"mobile", params["mobile"],
			"password", params["password"],
			"v", string(vbytes),
			"took", time.Since(begin),
		)
	}(time.Now())
	v, err = m.UserService.LoginV2(params)
	return
}

func (m loggingMiddleware) GetHomeInvite(params map[string]string) (v interface{}, err error) {
	defer func(begin time.Time) {
		vbytes, _ := json.Marshal(v)
		m.Logger.Log(
			"method", "UserService.GetHomeInvite",
			"mobile", params["mobile"],
			"password", params["password"],
			"v", string(vbytes),
			"took", time.Since(begin),
		)
	}(time.Now())
	v, err = m.UserService.GetHomeInvite(params)
	return
}

func (m loggingMiddleware) Regist(mobile, password, vcode string) (v interface{}, err error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "UserService.Regist",
			"mobile", mobile,
			"took", time.Since(begin),
		)
	}(time.Now())
	v, err = m.UserService.Regist(mobile, password, vcode)
	return
}

func (m loggingMiddleware) ResetPwd(userName, password, newPassword string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "UserService.ResetPwd",
			"mobile", userName,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.UserService.ResetPwd(userName, password, newPassword)
}

func (m loggingMiddleware) ForgetPwd(userName, vcode, newPassword string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "UserService.ForgetPwd",
			"mobile", userName,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.UserService.ForgetPwd(userName, vcode, newPassword)
}

func (m loggingMiddleware) SetOpenid(mobile, openid string, wxType string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "UserService.SetOpenid",
			"mobile", mobile,
			"Openid", openid,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.UserService.SetOpenid(mobile, openid, wxType)
}

func (m loggingMiddleware) GetQueueNotice(mobile string) (interface{}, error) {
	return m.UserService.GetQueueNotice(mobile)
}

func (m loggingMiddleware) UpdateQueueNotice(notice *entity.QueueNotice) (interface{}, error) {
	return m.UserService.UpdateQueueNotice(notice)
}

func (m loggingMiddleware) SendSMS(mobile string, smsType int, params map[string]string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "SMSService.SendSMS",
			"mobile", mobile,
			"type", smsType,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.SMSService.SendSMS(mobile, smsType, params)
}
func (m loggingMiddleware) ValidateCode(mobile, code string, codeType int) (interface{}, error) {
	return m.SMSService.ValidateCode(mobile, code, codeType)
}

func (m loggingMiddleware) GetAccessToken(tokenStr string) (v interface{}, err error) {
	defer func(begin time.Time) {
		vbuf, _ := json.Marshal(v)
		m.Logger.Log(
			"method", "AuthService.GetAccessToken",
			"tokenStr", tokenStr,
			"v", string(vbuf),
			"took", time.Since(begin),
		)
	}(time.Now())
	v, err = m.AuthService.GetAccessToken(tokenStr)
	return
}

func (m loggingMiddleware) Query(param *search.QueryParam, uid int) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "SearchService.Query",
			"text", param.Text,
			"user_id", uid,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.SearchService.Query(param, uid)
}
func (m loggingMiddleware) Upload(rd io.Reader) (interface{}, error) {
	return m.FileService.Upload(rd)
}

// 订单相关接口开始
func (m loggingMiddleware) AddOrder(orderItem *entity.Order, cityId int, city string) (result interface{}, err error) {
	defer func(begin time.Time) {
		errStr := ""
		if err != nil {
			errStr = err.Error()
		}
		m.Logger.Log(
			"method", "OrderService.AddOrder",
			"orderid", orderItem.Id,
			"took", time.Since(begin),
			"error", errStr,
		)
	}(time.Now())
	result, err = m.OrderService.AddOrder(orderItem, cityId, city)
	return
}

func (m loggingMiddleware) Pay(orderItem *entity.Order, extra map[string]string) (data interface{}, err error) {
	defer func(begin time.Time) {
		var errStr string
		if err != nil {
			errStr = err.Error()
		}
		m.Logger.Log(
			"method", "OrderService.Pay",
			"orderid", orderItem.Id,
			"took", time.Since(begin),
			"error", errStr,
		)
	}(time.Now())
	data, err = m.OrderService.Pay(orderItem, extra)
	return
}
func (m loggingMiddleware) UpdateOrder(orderItem *entity.Order, upType string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "OrderService.UpdateOrder",
			"orderid", orderItem.Id,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.OrderService.OrderUpdate(orderItem, upType)
}

func (m loggingMiddleware) CancelOrder(oid string) (bool, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "OrderService.CancelOrder",
			"orderid", oid,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.OrderService.CancelOrder(oid)
}
func (m loggingMiddleware) DelOrder(oid string) (bool, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "OrderService.DelOrder",
			"orderid", oid,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.OrderService.DelOrder(oid)
}

func (m loggingMiddleware) FailedOrder(oid string) (bool, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "OrderService.FailedOrder",
			"orderid", oid,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.OrderService.FailedOrder(oid)
}
func (m loggingMiddleware) ListOrder(customId, pageIndex, pageSize, status int, mobile string, isZFB, isHis bool) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "OrderService.ListOrder",
			"customid", customId,
			"status", status,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.OrderService.ListOrder(customId, pageIndex, pageSize, status, mobile, isZFB, isHis)
}

func (m loggingMiddleware) OrderDetail(orderId string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "OrderService.OrderDetail",
			"orderid", orderId,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.OrderService.OrderDetail(orderId)
}

func (m loggingMiddleware) OrderReport(orderId string, otype string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "OrderService.OrderReport",
			"orderid", orderId,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.OrderService.OrderReport(orderId, otype)
}

func (m loggingMiddleware) Refund(params map[string]string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "OrderService.Refund",
			"params", params,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.OrderService.Refund(params)
}

//订单相关接口结束

// 购物车相关接口开始
func (m loggingMiddleware) CartList(customId int) (interface{}, error) {
	return m.CartService.CartList(customId)
}
func (m loggingMiddleware) CartAdd(customId int, productId int, quantity int, isAdd bool) (interface{}, error) {

	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "CartService.CartAdd",
			"customid", customId,
			"productId", productId,
			"quantity", quantity,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.CartService.CartAdd(customId, productId, quantity, isAdd)
}
func (m loggingMiddleware) CartRemove(customId int, productIds []int) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "CartService.CartRemove",
			"customid", customId,
			"productId", productIds,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.CartService.CartRemove(customId, productIds)
}

//购物车相关接口结束

func (m loggingMiddleware) ListCoupon(mobile string, status, pageIndex, pageSize int) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "CouponService.ListCoupon",
			"mobile", mobile,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.CouponService.ListCoupon(mobile, status, pageIndex, pageSize)
}
func (m loggingMiddleware) Exchange(codeStr string, customId int, mobile string) (interface{}, cerror.CError) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "CouponService.Exchange",
			"mobile", mobile,
			"codeStr", codeStr,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.CouponService.Exchange(codeStr, customId, mobile)
}
func (m loggingMiddleware) GetCoupon(id int) (interface{}, error) {
	return m.CouponService.GetCoupon(id)
}

// 产能相关接口
func (m loggingMiddleware) PtList(cityId int, fromDay string, ptType int, kongFuType int) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "ProductivityService.PtList",
			"fromDay", fromDay,
			"pttype", ptType,
			"kongFuType", kongFuType,
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.ProductivityService.PtList(cityId, fromDay, ptType, kongFuType)
}

// 微信相关接口
func (m loggingMiddleware) GetWXAccessToken(accountType string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "WeixinService.GetAccessToken",
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.WeixinService.GetWXAccessToken(accountType)
}
func (m loggingMiddleware) GetJSAPITicket(accountType string) (interface{}, error) {
	defer func(begin time.Time) {
		m.Logger.Log(
			"method", "WeixinService.GetJSAPITicket",
			"took", time.Since(begin),
		)
	}(time.Now())
	return m.WeixinService.GetJSAPITicket(accountType)
}

func (m loggingMiddleware) SendTpl(msg string, accountType string) (result interface{}, err error) {
	defer func(begin time.Time) {
		errStr := ""
		if err != nil {
			errStr = err.Error()
		}
		m.Logger.Log(
			"method", "WeixinService.SendTpl",
			"took", time.Since(begin),
			"msg", msg,
			"error", errStr,
		)
	}(time.Now())
	result, err = m.WeixinService.SendTpl(msg, accountType)
	return
}
func (m loggingMiddleware) GetOpenCityList() (interface{}, error) {
	return m.CityService.GetOpenCityList()
}

func (m loggingMiddleware) GetCityAllList() (interface{}, error) {
	return m.CityService.GetCityAllList()
}

// 订单联系人相关接口
func (m loggingMiddleware) LinkerGet(id, cid int) (interface{}, error) {
	return m.UserLinkerService.LinkerGet(id, cid)
}
func (m loggingMiddleware) LinkerAdd(linker *entity.UserLinker) (interface{}, error) {
	return m.UserLinkerService.LinkerAdd(linker)
}
func (m loggingMiddleware) LinkerUpdate(linker *entity.UserLinker) (interface{}, error) {
	return m.UserLinkerService.LinkerUpdate(linker)
}
func (m loggingMiddleware) LinkerList(cid int) (interface{}, error) {
	return m.UserLinkerService.LinkerList(cid)
}
func (m loggingMiddleware) LinkerDefault(cid int) (interface{}, error) {
	return m.UserLinkerService.LinkerDefault(cid)
}
func (m loggingMiddleware) LinkerDel(linker *entity.UserLinker) (interface{}, error) {
	return m.UserLinkerService.LinkerDel(linker)
}

func (m loggingMiddleware) ProductGet(pids []int) (interface{}, error) {
	return m.ProductService.ProductGet(pids)
}

func (m loggingMiddleware) GetTags(level, cityId int) (interface{}, error) {
	return m.ProductService.GetTags(level, cityId)
}
func (m loggingMiddleware) GetByTags(tags []string, pageIndex, pageSize uint, cityId int) (interface{}, error) {
	return m.ProductService.GetByTags(tags, pageIndex, pageSize, cityId)
}

func (m loggingMiddleware) makeHandler(payloadType reflect.Type, endpointFunc interface{}, decodeFunc httptransport.DecodeRequestFunc, shouldLogin ...bool) http.Handler {
	vf := reflect.ValueOf(endpointFunc)
	vp := reflect.ValueOf(m)
	y := vf.Call([]reflect.Value{vp})[0]
	if decodeFunc == nil {
		decodeFunc = server.MakeDecodeRequest(payloadType, shouldLogin...)
	}
	return httptransport.NewServer(
		y.Interface().(endpoint.Endpoint),
		decodeFunc,
		server.EncodeResponse,
		httptransport.ServerErrorLogger(log.With(m.Logger, "transport", "HTTP/JSON")),
	)
}

// 20220719 不打印日志，部分信息并没有太大意义。免得日志文件增长过快，
func (m loggingMiddleware) makeHandlerNoLog(payloadType reflect.Type, endpointFunc interface{}, decodeFunc httptransport.DecodeRequestFunc, shouldLogin ...bool) http.Handler {
	vf := reflect.ValueOf(endpointFunc)
	vp := reflect.ValueOf(m)
	y := vf.Call([]reflect.Value{vp})[0]
	if decodeFunc == nil {
		decodeFunc = server.MakeDecodeRequest(payloadType, shouldLogin...)
	}
	return httptransport.NewServer(
		y.Interface().(endpoint.Endpoint),
		decodeFunc,
		server.EncodeResponseNoLog,
		httptransport.ServerErrorLogger(log.With(m.Logger, "transport", "HTTP/JSON")),
	)
}

func (m loggingMiddleware) GetMeta() map[string]http.Handler {
	return map[string]http.Handler{
		"/user/login":               m.makeHandler(reflect.TypeOf(LoginParam{}), makeLoginEndpoint, nil),
		"/user/loginV2":             m.makeHandler(reflect.TypeOf(LoginV2Param{}), makeLoginV2Endpoint, nil),
		"/user/logincoupon":         m.makeHandler(reflect.TypeOf(LoginParam{}), makeLoginCouponsEndpoint, nil),
		"/user/homeinvite":          m.makeHandler(reflect.TypeOf(LoginV2Param{}), makeGetHomeInviteEndpoint, nil),
		"/user/saveinfo":            m.makeHandler(reflect.TypeOf(entity.User{}), makeSaveInfoEndpoint, nil, true),
		"/user/savehobby":           m.makeHandler(reflect.TypeOf(entity.User{}), makeSaveHobbyEndpoint, nil, true),
		"/user/gethobby":            m.makeHandler(nil, makeGetHobbyEndpoint, nil, false),
		"/user/regist":              m.makeHandler(reflect.TypeOf(RegistParam{}), makeRegistEndpoint, nil),
		"/user/resetpwd":            m.makeHandler(reflect.TypeOf(ResetPwdParam{}), makeResetPwdEndpoint, nil, true),
		"/user/forgetpwd":           m.makeHandler(reflect.TypeOf(RegistParam{}), makeForgetPwdEndpoint, nil),
		"/user/setopenid":           m.makeHandler(reflect.TypeOf(SetOpenidParam{}), makeSetOpenidEndpoint, nil, true),
		"/user/notice/get":          m.makeHandler(reflect.TypeOf(entity.QueueNotice{}), makeGetQueueNoticeEndpoint, nil, true),
		"/user/notice/update":       m.makeHandler(reflect.TypeOf(entity.QueueNotice{}), makeUpdateQueueNoticeEndpoint, nil, true),
		"/user/relationship":        m.makeHandler(nil, makeGetRelationshipEndpoint, nil, false),
		"/user/update":              m.makeHandler(reflect.TypeOf(entity.User{}), makeUpdateUinfoEndpoint, nil, true),
		"/user/wxinfo":              m.makeHandler(reflect.TypeOf(""), makeGetUserWxEndpoint, nil, false),
		"/auth/token":               m.makeHandler(nil, makeAuthEndpoint, server.DecodeAuthRequest),
		"/search":                   m.makeHandler(nil, makeSearchEndpoint, nil, false),
		"/file/upload":              m.makeHandler(nil, makeFileUploadEndpoint, server.DecodeFileRequest),
		"/order/add":                m.makeHandler(reflect.TypeOf(entity.Order{}), makeAddOrderEndpoint, nil, true),
		"/order/pay":                m.makeHandler(reflect.TypeOf(entity.Order{}), makePayEndpoint, nil, true),

		"/order/inner/add":          m.makeHandler(reflect.TypeOf(entity.Order{}), makeAddOrderEndpoint, nil, false),
		"/order/inner/pay":          m.makeHandler(reflect.TypeOf(entity.Order{}), makePayEndpoint, nil, false),
		"/order/list":               m.makeHandler(reflect.TypeOf(ListOrderParam{}), makeListOrderEndpoint, nil, true),
		"/order/detail":             m.makeHandler(reflect.TypeOf(DetailOrderParam{}), makeOrderDetailEndpoint, nil, true),
		"/order/detail/code":        m.makeHandler(reflect.TypeOf(DetailOrderParam{}), makeOrderDetailEndpoint, nil, false),
		"/order/cancel":             m.makeHandler(reflect.TypeOf(DetailOrderParam{}), makeCancelOrderEndpoint, nil, true),
		"/order/del":                m.makeHandler(reflect.TypeOf(DetailOrderParam{}), makeDelOrderEndpoint, nil, true),
		"/order/failed":             m.makeHandler(reflect.TypeOf(DetailOrderParam{}), makeFailedOrderEndpoint, nil, true),
		"/order/report":             m.makeHandler(reflect.TypeOf(DetailOrderParam{}), makeOrderReportEndpoint, nil),
		"/order/update":             m.makeHandler(reflect.TypeOf(entity.Order{}), makeOrderUpdateEndpoint, nil, true),
		"/order/refund":             m.makeHandler(reflect.TypeOf(map[string]string{}), makeRefundEndpoint, nil),
		"/order/survey":             m.makeHandler(reflect.TypeOf(entity.OrderSurvey{}), makeOrderSurveyEndpoint, nil),
		"/order/savecbinfo":         m.makeHandler(reflect.TypeOf(entity.OrderCallbackInfo{}), makeSaveCallbackInfoEndpoint, nil),
		"/order/getcbinfo":          m.makeHandler(reflect.TypeOf(""), makeGetCallbackInfoEndpoint, nil),
		"/order/payquery":           m.makeHandler(reflect.TypeOf(""), makeOrderPayQueryEndpoint, nil, true),
		"/order/vaildcount":         m.makeHandler(reflect.TypeOf(ListOrderParam{}), makeOrderVaildCountEndpoint, nil),
		"/sms/send":                 m.makeHandler(reflect.TypeOf(SMSParam{}), makeSMSSendEndpoint, nil),
		"/sms/sendworld":            m.makeHandler(reflect.TypeOf(SMSParam{}), makeSMSSendWorldEndpoint, nil),
		"/sms/validatecode":         m.makeHandler(reflect.TypeOf(VcodeParam{}), makeValidateCodeEndpoint, nil),
		"/cart/list":                m.makeHandler(reflect.TypeOf(entity.Cart{}), makeCartListEndpoint, nil, true),
		"/cart/add":                 m.makeHandler(reflect.TypeOf(entity.Cart{}), makeCartAddEndpoint, nil, true),
		"/cart/remove":              m.makeHandler(reflect.TypeOf(CartParam{}), makeCartRemoveEndpoint, nil, true),
		"/coupon/list":              m.makeHandler(reflect.TypeOf(CouponListParam{}), makeCouponListEndpoint, nil, true),
		"/coupon/getbyorderid":      m.makeHandler(reflect.TypeOf(""), makeCouponGetByOrderIdEndpoint, nil, true),
		"/coupon/exchange":          m.makeHandler(reflect.TypeOf(ExchangeParam{}), makeExchangeEndpoint, nil, true),
		"/coupon/detail":            m.makeHandler(reflect.TypeOf(int(1)), makeCouponGetEndpoint, nil, true),
		"/coupon/add":               m.makeHandler(reflect.TypeOf(entity.DiscountTicket{}), makeCouponAddEndpoint, nil, true),
		"/coupon/queryfcode":        m.makeHandler(reflect.TypeOf(""), makeQueryFcodeEndpoint, nil),
		"/coupon/actlist":           m.makeHandler(reflect.TypeOf(entity.DiscountActParams{}), makeCouponActListEndpoint, nil),
		"/coupon/receive":           m.makeHandler(reflect.TypeOf(entity.DiscountReceiveParams{}), makeCouponActReceiveEndpoint, nil),
		"/wx/token":                 m.makeHandler(nil, makeWXAccessTokenEndpoint, nil),
		"/wx/jsapi_ticket":          m.makeHandler(nil, makeWXApiTicketEndpoint, nil),
		"/wx/sendtpl":               m.makeHandler(nil, makeSendTplEndpoint, nil),
		"/wx/jssdksign":             m.makeHandler(reflect.TypeOf(""), makeWXJsSdkSignEndpoint, nil),
		"/wx/scanpay":               m.makeHandler(reflect.TypeOf(map[string]string{}), makeWxScanPayEndpoint, nil),
		"/wx/payreason":             m.makeHandler(nil, makeGetPayReasonEndpoint, nil),
		"/city/openlist":            m.makeHandler(nil, makeCityOpenListEndpoint, nil),
		"/city/all":                 m.makeHandlerNoLog(nil, makeCityAllEndpoint, nil),
		"/city/opencounty":          m.makeHandler(nil, makeCityOpenCountyEndpoint, nil),
		"/city/infobyid":            m.makeHandler(reflect.TypeOf([]int{}), makeGetCityByIdEndpoint, nil),
		"/city/county":              m.makeHandler(reflect.TypeOf(int(1)), makeGetCountyByCityIdEndpoint, nil),
		"/userlinker/get":           m.makeHandler(reflect.TypeOf(entity.UserLinker{}), makeLinkerGetEndpoint, nil, true),
		"/userlinker/add":           m.makeHandler(reflect.TypeOf(entity.UserLinker{}), makeLinkerAddEndpoint, nil, true),
		"/userlinker/save":          m.makeHandler(reflect.TypeOf(entity.UserLinker{}), makeLinkerUpdateEndpoint, nil, true),
		"/userlinker/list":          m.makeHandler(reflect.TypeOf(entity.UserLinker{}), makeLinkerListEndpoint, nil, true),
		"/userlinker/default":       m.makeHandler(reflect.TypeOf(entity.UserLinker{}), makeLinkerDefaultEndpoint, nil, true),
		"/userlinker/del":           m.makeHandler(reflect.TypeOf(entity.UserLinker{}), makeLinkerDelEndpoint, nil, true),
		"/userlinker/relationships": m.makeHandler(nil, makeLinkerRelEndpoint, nil, true),
		"/productivity/list":        m.makeHandler(reflect.TypeOf(PtListParam{}), makeiPtListEndpoint, nil),
		"/product/get":              m.makeHandler(reflect.TypeOf([]int{}), makeProductGetEndpoint, nil),
		"/product/getcoordinates":   m.makeHandler(reflect.TypeOf(ProductCoordinatesParam{}), makeProductGetCoordinates, nil),
		"/product/checkcoordinates": m.makeHandler(reflect.TypeOf(ProductCoordinatesParam{}), makeProductCheckCoordinates, nil),
		"/product/getbycateid":      m.makeHandler(reflect.TypeOf(GetProductByCateParam{}), makeProductGetByCatIdEndpoint, nil),
		"/product/cate":             m.makeHandler(reflect.TypeOf(int(1)), makeGetProductCateEndpoint, nil),
		"/product/recommend":        m.makeHandler(reflect.TypeOf(GetProductByCateParam{}), makeGetRecommendProductEndpoint, nil),
		"/product/tag":              m.makeHandler(nil, makeGetTagsEndpoint, nil),
		"/product/getbytag":         m.makeHandler(reflect.TypeOf(GetProductParam{}), makeGetProductByTagsEndpoint, nil),
		"/product/savegenesign":     m.makeHandler(reflect.TypeOf(entity.ConsumerGeneSign{}), makeSaveConsumerGeneSignEndpoint, nil),
		"/product/addingcate":       m.makeHandler(reflect.TypeOf(0), makeGetProductAddingCateEndpoint, nil),
		"/product/addbydpids":       m.makeHandler(reflect.TypeOf([]int{}), makeAddProductByDpidsEndpoint, nil, true),
		"/product/top":              m.makeHandler(reflect.TypeOf(TopProductParam{}), makeGetProductTopEndpoint, nil),
		"/product/guess":            m.makeHandler(reflect.TypeOf(ProductGuessParam{}), makeProductGuess, nil),
		"/duser/orderlist":          m.makeHandler(reflect.TypeOf(GetOrderListParam{}), makeGetOrderListEndpoint, nil),
		"/duser/orderlist/v2":       m.makeHandler(reflect.TypeOf(GetOrderListParam{}), makeGetOrderListV2Endpoint, nil),
		"/duser/ordersign":          m.makeHandler(reflect.TypeOf(""), makeGetOrderSignEndpoint, nil),
		"/duser/saveordersign":      m.makeHandler(reflect.TypeOf(entity.OrderSign{}), makeSaveOrderSignEndpoint, nil),
		"/duser/regist":             m.makeHandler(reflect.TypeOf(entity.DeliverUser{}), makeRegistDUEndpoint, nil),
		"/duser/exam":               m.makeHandler(reflect.TypeOf(NourseExamParam{}), makeNurseExamEndpoint, nil),
		"/system/piclist":           m.makeHandler(nil, makeGetFirstPagePicListEndpoint, nil),
		"/system/workdays":          m.makeHandler(reflect.TypeOf(int(0)), makeGetWorkdaysEndpoint, nil),
		"/system/question":          m.makeHandler(reflect.TypeOf(int(0)), makeGetQuestionEndpoint, nil),
		//"/system/dictlist":          m.makeHandler(reflect.TypeOf(""), makeGetDictListEndpoint, nil),
		"/system/dictlist":       m.makeHandler(reflect.TypeOf(DictParam{}), makeGetDictListEndpoint, nil),

		"/act/addreporter":       m.makeHandler(reflect.TypeOf(entity.ActReporter{}), makeAddReporterEndpoint, nil),
		"/act/addinfo":           m.makeHandler(reflect.TypeOf(entity.ActInfo{}), makeAddActInfoEndpoint, nil),
		"/act/getinfo":           m.makeHandler(reflect.TypeOf(entity.ActInfo{}), makeGetActInfoEndpoint, nil),
		"/act/upinfo":            m.makeHandler(reflect.TypeOf(entity.ActInfo{}), makeUpdateActinfoEndpoint, nil),

		"/act/withdraw":          m.makeHandler(reflect.TypeOf(entity.ActInfo{}), makeWithdrawActinfoEndpoint, nil),
		"/act/addinvoice":        m.makeHandler(reflect.TypeOf(entity.ActInfo{}), makeAddInvoice, nil),
		"/act/getinvoice":        m.makeHandler(reflect.TypeOf(entity.ActInfo{}), makeGetInvoice, nil),
		"/jicai/gbinfo":          m.makeHandler(reflect.TypeOf(GroupBloodParam{}), makeGetGroupBloodInfoEndpoint, nil, true),
		"/jicai/enqueue":         m.makeHandler(reflect.TypeOf(GroupBloodParam{}), makeGroupBloodEnqueueEndpoint, nil, true),
		"/jicai/next":            m.makeHandler(reflect.TypeOf(GroupBloodParam{}), makeGroupBloodNextEndpoint, nil, false),
		"/jicai/subjectqueue":    m.makeHandler(reflect.TypeOf(GroupBloodParam{}), makeGroupBloodSubjectQueueEndpoint, nil, false),
		"/jicai/orderinfo":       m.makeHandler(reflect.TypeOf(""), makeGroupBloodGetOrderinfoEndpoint, nil),
		"/jicai/checkprogress":   m.makeHandler(reflect.TypeOf(""), makeGroupBloodGetProgressinfoEndpoint, nil),
		"/jicai/confirmchecked":  m.makeHandler(reflect.TypeOf(entity.GPParam{}), makeGroupBloodConfirmCheckEndpoint, nil),
		"/pay/prepay/get":        m.makeHandler(reflect.TypeOf(map[string]string{}), makeGetPrepayInfoEndpoint, nil, false),

		"/user/customfile/list":        m.makeHandler(reflect.TypeOf(int(1)), makeGetCustomFilelist, nil, true),
		"/user/customfile/get":         m.makeHandler(reflect.TypeOf(int(1)), makeGetCustomFile, nil, true),
		"/user/customfile/updatelabel": m.makeHandler(reflect.TypeOf(entity.CustomInfoLabelsDto{}), makeUpdateCustomFileLabel, nil, true),
		"/user/customfile/add":         m.makeHandler(reflect.TypeOf(entity.CustomFile{}), makeAddCustomFile, nil, true),
		"/user/customfile/modify":      m.makeHandler(reflect.TypeOf(entity.CustomFile{}), makeModifyCustomFile, nil, true),
		"/user/customfile/del":         m.makeHandler(reflect.TypeOf(int(1)), makeDelCustomFile, nil, true),
		"/user/customattachment/add":   m.makeHandler(reflect.TypeOf(entity.CustomAttachment{}), makeAddCustomAttachment, nil, true),
		"/user/customattachment/count": m.makeHandler(reflect.TypeOf(entity.CustomFileParam{}), makeGetCustomAttachmentCount, nil, true),
		"/user/customattachment/list":  m.makeHandler(reflect.TypeOf(entity.CustomFileParam{}), makeGetCustomAttachmentList, nil, true),
		"/user/customrisk/list":        m.makeHandler(reflect.TypeOf(int(1)), makeGetCustomRiskList, nil, true),
		"/user/yidian/list":            m.makeHandler(reflect.TypeOf(int(1)), makeGetYiDianList, nil, true),
		"/user/doctorrecommend/list":   m.makeHandler(reflect.TypeOf(int(1)), makeGetDoctorRecommendList, nil, true),
		"/order/list/customfileid":     m.makeHandler(reflect.TypeOf(ListOrderParam{}), makeListFileOrderEndpoint, nil, true),
		"/system/dictlist/list":        m.makeHandler(reflect.TypeOf([]DictParam{}), makeGetDictListsEndpoint, nil),

		//京东物流
		"/order/jdl/calendar": m.makeHandler(reflect.TypeOf(entity.JDLParams{}), makeJDLCalendar, nil),
		"/order/jdl/add":      m.makeHandler(reflect.TypeOf(entity.JDLParams{}), makeJDLAdd, nil),
		"/order/jdl/cancel":   m.makeHandler(reflect.TypeOf(entity.JDLCheck{}), makeJDLCancel, nil),
		"/order/jdl/trace":    m.makeHandler(reflect.TypeOf(entity.JDLCheck{}), makeJDLTrace, nil),

	}
}