gobackend-qingma/endpoint.go

package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"strings"

	"github.com/go-kit/kit/endpoint"
	"golang.org/x/net/context"
	"xiaoniaokuaiyan.com/xiaoniao/cerror"
	"xiaoniaokuaiyan.com/xiaoniao/dal"
	"xiaoniaokuaiyan.com/xiaoniao/entity"
	"xiaoniaokuaiyan.com/xiaoniao/search"
	"xiaoniaokuaiyan.com/xiaoniao/server"
)

type LoginParam struct {
	Mobile    string `json:"mobile"`
	Password  string `json:"password"`
	Type      string `json:"type"`
	Vcode     string `json:"vcode"`
	Openid    string `json:"openid"`
	UnionId   string `json:"unionId"`
	OpenIdMp  string `json:"openid_mp"`
	UserZFBId string `json:"user_zfb_id"`
	OpenIdTrd string `json:"openid_trd"` //20220531 第三方openid （太平）
}

type LoginV2Param struct {
	Mobile     string `json:"mobile"`
	Password   string `json:"password"`
	Type       string `json:"type"`
	Vcode      string `json:"smscode"`
	FromOpenid string `json:"fromopenid"`   //对应原来的openid
	ToOpenid   string `json:"toopenid"`     //谁邀请的
	HeadUrl    string `json:"fromheadimg"`  //头像地址
	NickName   string `json:"fromnickname"` //昵称
}
type ProductParam struct {
	Id string `json:"id"`
}
type OrderParam struct {
	UserId   string         `json:"userid"`
	Products []ProductParam `json:"products"`
}

func makeSMSSendEndpoint(svc server.SMSService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*SMSParam)
		data, err := svc.SendSMS(param.Mobile, param.Type, nil)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10021
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

// 国际短信
func makeSMSSendWorldEndpoint(svc server.SMSService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*SMSParam)
		data, err := svc.SendWorldSMS(param.Mobile, param.Type, nil)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10023
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

////营销短信 20220705熠保发送验证码用
//func makeSMSSendYXEndpoint(svc server.SMSService) endpoint.Endpoint {
//	return func(ctx context.Context, request interface{}) (interface{}, error) {
//		req := request.(server.Request)
//		param := req.Payload.(*SMSParam)
//		data, err := svc.SendYXSMS(param.Mobile, param.Type, nil)
//		var res = &server.Response{
//			Errno:   0,
//			Errmsg:  "normal",
//			Payload: data,
//		}
//		if err != nil {
//			res.Errno = 10024
//			res.Errmsg = err.Error()
//		}
//		return res, nil
//	}
//}

func makeValidateCodeEndpoint(svc server.SMSService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*VcodeParam)
		data, err := svc.ValidateCode(param.Mobile, param.Code, param.CodeType)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10022
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

// user login api endpoint
func makeLoginEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		//loginParam := req.Payload.(map[string]interface{})
		//user, err := svc.Login(loginParam["mobile"].(string), loginParam["password"].(string))
		loginParam := req.Payload.(*LoginParam)
		params := map[string]string{
			"mobile":      loginParam.Mobile,
			"password":    loginParam.Password,
			"vcode":       loginParam.Vcode,
			"type":        loginParam.Type,
			"openid":      loginParam.Openid,
			"wx_type":     req.Extra["wx_type"].(string),
			"unionId":     loginParam.UnionId,
			"openid_mp":   loginParam.OpenIdMp,
			"user_zfb_id": loginParam.UserZFBId,
			"openid_trd":  loginParam.OpenIdTrd,
		}
		user, err := svc.Login(params)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: user,
		}
		if err != nil {
			res.Errno = 1000
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

// qz 扩展推广登录 20200813
func makeLoginV2Endpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		loginV2Param := req.Payload.(*LoginV2Param)
		params := map[string]string{
			"mobile":       loginV2Param.Mobile,
			"password":     loginV2Param.Password,
			"vcode":        loginV2Param.Vcode,
			"type":         loginV2Param.Type,
			"openid":       loginV2Param.FromOpenid,
			"toopenid":     loginV2Param.ToOpenid,
			"fromheadimg":  loginV2Param.HeadUrl,
			"fromnickname": loginV2Param.NickName,
			"wx_type":      req.Extra["wx_type"].(string),
		}
		user, err := svc.LoginV2(params)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: user,
		}
		if err != nil {
			res.Errno = 1000
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

// qz 20210304 登录送优惠券
func makeLoginCouponsEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		//loginParam := req.Payload.(map[string]interface{})
		//user, err := svc.Login(loginParam["mobile"].(string), loginParam["password"].(string))
		loginParam := req.Payload.(*LoginParam)
		params := map[string]string{
			"mobile":    loginParam.Mobile,
			"password":  loginParam.Password,
			"vcode":     loginParam.Vcode,
			"type":      loginParam.Type,
			"openid":    loginParam.Openid,
			"wx_type":   req.Extra["wx_type"].(string),
			"unionId":   loginParam.UnionId,
			"openid_mp": loginParam.OpenIdMp,
		}
		_, err := svc.LoginCoupons(params)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: true,
		}
		if err != nil {
			res.Errno = 1000
			res.Errmsg = err.Error()
			res.Payload = false
		}
		return res, nil
	}
}

// qz 获取推广关系 20200813
func makeGetHomeInviteEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		loginV2Param := req.Payload.(*LoginV2Param)
		params := map[string]string{
			"mobile":   loginV2Param.Mobile,
			"toopenid": loginV2Param.ToOpenid,
			"wx_type":  req.Extra["wx_type"].(string),
		}
		data, err := svc.GetHomeInvite(params)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "",
			Payload: data,
		}
		if err != nil {
			res.Errno = 1000
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

// user regist api endpoint
func makeRegistEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		registParam := req.Payload.(*RegistParam)
		user, err := svc.Regist(registParam.Mobile, registParam.Password, registParam.Vcode)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: user,
		}
		if err != nil {
			res.Errno = 1001
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

func makeResetPwdEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*ResetPwdParam)
		data, err := svc.ResetPwd(param.Mobile, param.Password, param.NewPassword)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10011
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

func makeForgetPwdEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*RegistParam)
		data, err := svc.ForgetPwd(param.Mobile, param.Vcode, param.Password)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10012
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

func makeSetOpenidEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*SetOpenidParam)
		data, err := svc.SetOpenid(param.Mobile, param.Openid, req.Extra["wx_type"].(string))
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10013
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

func makeGetQueueNoticeEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*entity.QueueNotice)
		data, err := svc.GetQueueNotice(param.CustomMobile)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10014
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}
func makeUpdateQueueNoticeEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*entity.QueueNotice)
		data, err := svc.UpdateQueueNotice(param)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10015
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

func makeGetRelationshipEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		data, err := svc.GetRelationship()
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10016
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

func makeUpdateUinfoEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*entity.User)
		data, err := svc.UpdateUserinfo(param)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10017
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

func makeGetUserWxEndpoint(svc server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		param := req.Payload.(*string)
		data, err := svc.GetUserWxInfo(*param)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "normal",
			Payload: data,
		}
		if err != nil {
			res.Errno = 10018
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

//application client request access token to visit api

func makeAuthEndpoint(svc server.AuthService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		reqStr := request.(string)
		token, err := svc.GetAccessToken(reqStr)
		var res = &server.Response{
			Errno:   0,
			Errmsg:  "-",
			Payload: token,
		}
		if err != nil {
			res.Errno = 103
			res.Errmsg = err.Error()
		}
		return res, nil
	}
}

// unified file upload api endpoint
func makeFileUploadEndpoint(svc server.FileService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "-",
		}
		if reader, ok := request.(io.Reader); !ok {
			res.Errno = 1002
			res.Errmsg = "miss upload file"
		} else {
			furl, err := svc.Upload(reader)
			if err != nil {
				res.Errno = 1003
				res.Errmsg = err.Error()
			} else {
				res.Payload = furl
			}
		}
		return res, nil
	}
}

func makeSearchEndpoint(srv server.SearchService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "-",
		}
		if kv, ok := req.Payload.(map[string]interface{}); !ok {
			res.Errno = 1004
			res.Errmsg = "bad request"
		} else {
			var isHl = true
			if isHighlight, ok := kv["isHighlight"]; ok {
				if int(isHighlight.(float64)) == 0 {
					isHl = false
				}
			}
			var (
				operType string
				data     interface{}
				err      error
				sortBy   string
				cateId   string
			)
			if oper, ok := kv["operType"]; ok {
				operType, _ = oper.(string)
			}

			switch operType {
			case "GET_TOP_KEYWORD":
				cityId := uint(kv["cityId"].(float64))
				size := int(kv["size"].(float64))
				data, err = srv.GetTopKeyword(int(cityId), size)
			case "GET_USER_KEYWORD":
				size := int(kv["size"].(float64))
				userId := int(kv["user_id"].(float64))
				data, err = srv.GetUserKeyword(userId, size)
			case "GET_TIP":
				text := kv["text"].(string)
				cityId := uint(kv["cityId"].(float64))
				data, err = srv.GetTip(text, int(cityId), req.IsZFB())
			default:
				text := kv["text"].(string)
				pi := int(kv["pageIndex"].(float64))
				size := int(kv["size"].(float64))
				cityId := uint(kv["cityId"].(float64))
				userId := int(kv["user_id"].(float64))
				if v, ok := kv["sortBy"]; ok {
					sortBy, _ = v.(string)
				}
				qParam := &search.QueryParam{
					Text:        text,
					PageIndex:   pi,
					Size:        size,
					CityId:      cityId,
					IsHighlight: isHl,
					SortBy:      sortBy,
				}
				if req.IsZFB() {
					qParam.IsZFB = true
				}
				if v, ok := kv["cateId"]; ok {
					if cateId, ok = v.(string); ok && cateId != "0" {
						qParam.CateIds = append(qParam.CateIds, cateId)
					}
				}
				if v, ok := kv["is_sale"]; ok {
					if isSale, ok := v.(bool); ok {
						qParam.IsSale = isSale
					}
				}
				data, err = srv.Query(qParam, userId)
			}
			if err != nil {
				res.Errno = 1005
				res.Errmsg = err.Error()
			}
			res.Payload = data
		}
		return res, nil
	}
}
func makeCartListEndpoint(srv server.CartService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		cp := req.Payload.(*entity.Cart)
		if cp.CustomId == 0 {
			res.Errno = 1006
			res.Errmsg = "bad request"
		} else {
			// 20230629 增加支付宝特殊处理
			if req.IsZFB() {
				data, err := srv.ZFB_CartList(cp.CustomId)
				if err != nil {
					res.Errno = 10070
					res.Errmsg = err.Error()
				}
				res.Payload = data
				return res, nil
			}
			data, err := srv.CartList(cp.CustomId)
			if err != nil {
				res.Errno = 10070
				res.Errmsg = err.Error()
			}
			res.Payload = data
		}
		return res, nil
	}

}

func makeCartAddEndpoint(srv server.CartService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		cp := req.Payload.(*entity.Cart)
		if cp.CustomId == 0 || cp.ProductId == 0 {
			res.Errno = 1006
			res.Errmsg = "bad request"
		} else {
			data, err := srv.CartAdd(cp.CustomId, cp.ProductId, cp.Quantity, cp.IsAdd)
			if err != nil {
				res.Errno = 10007
				res.Errmsg = err.Error()
			}
			res.Payload = data
		}
		return res, nil
	}

}

func makeCartRemoveEndpoint(srv server.CartService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		cp := req.Payload.(*CartParam)
		if cp.CustomId == 0 || len(cp.ProductIds) == 0 {
			res.Errno = 10009
			res.Errmsg = "bad request"
		} else {
			data, err := srv.CartRemove(cp.CustomId, cp.ProductIds)
			if err != nil {
				res.Errno = 10008
				res.Errmsg = err.Error()
			}
			res.Payload = data
		}
		return res, nil
	}

}

func makeAddOrderEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		oitem := req.Payload.(*entity.Order)
		if req.UserId > 0 && req.UserId != oitem.CustomId && oitem.Source != "web-jiujing" {
			res.Errno = -100
			res.Errmsg = "数据异常"
			return res, nil
		}
		var (
			city   string
			cityId float64
		)
		if cv, ok := req.Extra["city"]; !ok {
			res.Errno = 10073
			res.Errmsg = "城市名不能为空"
			return res, nil
		} else {
			city = cv.(string)
		}
		if civ, ok := req.Extra["cityId"]; !ok {
			res.Errno = 10071
			res.Errmsg = "缺少城市编号"
		} else {
			cityId = civ.(float64)
		}
		var (
			data interface{}
			err  error
		)
		//20210527 vip 健康好礼活动 兑换码下单
		if fcode, ok := req.Extra["fcode"]; ok {

			data, err = srv.AddOrderFCode(oitem, int(cityId), city, fcode.(string))

		} else if oitem.Source == "web-jiaxiang" || oitem.Source == "jd-jicai" {
			data, err = srv.AddOrderInner(oitem, int(cityId), city)
		}  else {
			//data, err = srv.AddOrderV2(oitem, int(cityId), city)
			if req.IsZFB() {
				oitem.IsZFB = true
			}
			data, err = srv.AddOrder(oitem, int(cityId), city)
		}
		if err != nil {
			res.Errno = 10072
			res.Errmsg = err.Error()
		} else {
			//家政分享下单 qz add 20200814
			if oitem.ToOpenID != "" || oitem.OpenId == oitem.ToOpenID {
				order := data.(*entity.Order)
				srv.InsertAgent(order.Id, oitem.OpenId, oitem.ToOpenID, oitem.CustomMobile)
			}
		}
		res.Payload = data
		return res, nil
	}
}


func makePayEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		oitem := req.Payload.(*entity.Order)
		extra := make(map[string]string)
		for k, v := range req.Extra {
			extra[k] = fmt.Sprintf("%v", v)
		}
		//data, err := srv.PayV2(oitem, extra)
		data, err := srv.Pay(oitem, extra)
		if err != nil {
			res.Errno = 1008
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeOrderUpdateEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		oitem := req.Payload.(*entity.Order)
		if req.UserId != oitem.CustomId {
			res.Errno = -100
			res.Errmsg = "数据异常"
			return res, nil
		}
		var (
			upType string
		)
		if ut, ok := req.Extra["upType"]; !ok {
			res.Errno = 1015
			res.Errmsg = "更新类型"
			return res, nil
		} else {
			upType = ut.(string)
		}
		data, err := srv.OrderUpdate(oitem, upType)
		if err != nil {
			res.Errno = 10151
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeListOrderEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*ListOrderParam)
		//to do validate whether  customid equals current session user id or not
		if param.CustomId == 0 {
			res.Errno = 1009
			res.Errmsg = "param customid required"
			return nil, res
		}

		data, err := srv.ListOrder(param.CustomId, param.PageIndex, param.PageSize, param.Status, param.Mobile, req.IsZFB(), req.IsHistory())
		if err != nil {
			res.Errno = 10091
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

// 20211210 通过customfileid 获取订单
func makeListFileOrderEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*ListOrderParam)
		if param.CustomId == 0 {
			res.Errno = 1009
			res.Errmsg = "param customFileid required"
			return nil, res
		}
		if req.Mobile == param.Mobile { //号码相通，他可以查询所有自己在其他人账户下的报告
			param.CustomId = 0
		}
		data, err := srv.ListFileOrder(param.CustomId, param.PageIndex, param.PageSize, param.Status, param.Mobile, req.IsZFB(), req.IsHistory())
		if err != nil {
			res.Errno = 10091
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeOrderDetailEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*DetailOrderParam)
		var (
			data interface{}
			err  error
		)
		if param.Type == "BY_CODE" {
			data, err = srv.GetOrderInfoByCode(param.OrderId)
		} else if param.Type == "BY_NURSE" {
			data, err = srv.GetOrderInfoByNurse(param.OrderId, param.CustomId)
		} else {
			data, err = srv.OrderDetail(param.OrderId)
		}
		if err != nil {
			res.Errno = 10101
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeOrderReportEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*DetailOrderParam)

		data, err := srv.OrderReport(param.OrderId, param.Type)
		if err != nil {
			res.Errno = 10108
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}
func makeCancelOrderEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*DetailOrderParam)

		data, err := srv.CancelOrder(param.OrderId)
		if err != nil {
			res.Errno = 10102
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}
func makeDelOrderEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*DetailOrderParam)

		data, err := srv.DelOrder(param.OrderId)
		if err != nil {
			res.Errno = 10103
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeFailedOrderEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*DetailOrderParam)

		data, err := srv.FailedOrder(param.OrderId)
		if err != nil {
			res.Errno = 10103
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeRefundEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*map[string]string)

		//data, err := srv.RefundV2(*param)
		data, err := srv.Refund(*param)
		if err != nil {
			res.Errno = 10107
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeOrderSurveyEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.OrderSurvey)

		data, err := srv.CommitSurvey(param, req.UserId)
		if err != nil {
			res.Errno = 10108
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}

}

func makeSaveCallbackInfoEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.OrderCallbackInfo)
		/*if param.CustomId != req.UserId {
			res.Errno = 10109
			res.Errmsg = "0::forbidden"
			return res, nil
		}*/

		data, err := srv.SaveCallbackInfo(*param)
		if err != nil {
			res.Errno = 10109
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeOrderPayQueryEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*string)

		extra := make(map[string]string)
		for k, v := range req.Extra {
			extra[k] = fmt.Sprintf("%v", v)
		}
		data, err := srv.PayQuery(*param, extra)
		if err != nil {
			res.Errno = 10110
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

// 20240221 获取有效订单数量
func makeOrderVaildCountEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*ListOrderParam)

		data, err := srv.OrderVaildCount(param.CustomId, param.Status, param.Mobile)
		if err != nil {
			res.Errno = 10111
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeGetCallbackInfoEndpoint(srv server.OrderService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*string)

		data, err := srv.GetCallbackInfo(*param)
		if err != nil {
			res.Errno = 10110
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeCouponListEndpoint(srv server.CouponService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*CouponListParam)

		data, err := srv.ListCoupon(param.Mobile, param.Status, param.PageIndex, param.PageSize)
		if err != nil {
			res.Errno = 10010
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeCouponGetEndpoint(srv server.CouponService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*int)

		data, err := srv.GetCoupon(*param)
		if err != nil {
			res.Errno = 10012
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeCouponGetByOrderIdEndpoint(srv server.CouponService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*string)

		data, err := srv.GetCouponByOrderId(*param)
		if err != nil {
			res.Errno = 10019
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeExchangeEndpoint(srv server.CouponService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*ExchangeParam)

		data, err := srv.Exchange(param.CodeStr, param.CustomId, param.Mobile)
		if err != nil {
			if cerr, ok := err.(cerror.CError); ok {
				res.Errno = cerr.GetErrno()
				res.Errmsg = cerr.Error()
			} else {
				res.Errno = 10011
				res.Errmsg = err.Error()
			}
		}
		res.Payload = data
		return res, nil
	}
}

func makeCouponAddEndpoint(srv server.CouponService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.DiscountTicket)

		data, err := srv.AddCoupon(param)
		if err != nil {
			if cerr, ok := err.(cerror.CError); ok {
				res.Errno = cerr.GetErrno()
				res.Errmsg = cerr.Error()
			} else {
				res.Errno = 10013
				res.Errmsg = err.Error()
			}
		}
		res.Payload = data
		return res, nil
	}
}

func makeQueryFcodeEndpoint(srv server.CouponService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*string)

		data, err := srv.QueryFcode(*param)
		if err != nil {
			if cerr, ok := err.(cerror.CError); ok {
				res.Errno = cerr.GetErrno()
				res.Errmsg = cerr.Error()
			} else {
				res.Errno = 10014
				res.Errmsg = err.Error()
			}
		}
		res.Payload = data
		return res, nil
	}
}

// 20230215 用户可领取优惠券列表
func makeCouponActListEndpoint(srv server.CouponService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.DiscountActParams)

		data, err := srv.CouponActList(param.Mobile, param.Pid)
		if err != nil {

			res.Errno = 10020
			res.Errmsg = err.Error()

		}
		res.Payload = data
		return res, nil
	}
}

// 20230215 用户领取优惠券
func makeCouponActReceiveEndpoint(srv server.CouponService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.DiscountReceiveParams)

		data, err := srv.CouponReceive(param.Id, param.Mobile)
		if err != nil {

			res.Errno = 10025
			res.Errmsg = err.Error()

		}
		res.Payload = data
		return res, nil
	}
}

// 产能查询
func makeiPtListEndpoint(srv server.ProductivityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*PtListParam)

		data, err := srv.PtList(param.CityId, param.FromDay, param.PtType, param.KongFuType)
		if err != nil {
			res.Errno = 1010
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeWXAccessTokenEndpoint(srv server.WeixinService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)

		data, err := srv.GetWXAccessToken(req.Extra["wx_type"].(string))
		if err != nil {
			res.Errno = 10110
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeWXApiTicketEndpoint(srv server.WeixinService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		data, err := srv.GetJSAPITicket(req.Extra["wx_type"].(string))
		if err != nil {
			res.Errno = 10120
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}

func makeWXJsSdkSignEndpoint(srv server.WeixinService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		signUrl := req.Payload.(*string)
		data, err := srv.JsSdkSign(*signUrl, req.Extra["wx_type"].(string))
		if err != nil {
			res.Errno = 10122
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}

func makeSendTplEndpoint(srv server.WeixinService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)

		data, err := srv.SendTpl(req.Payload.(string), req.Extra["wx_type"].(string))
		if err != nil {
			res.Errno = 10121
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeWxScanPayEndpoint(srv server.WeixinService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)

		data, err := srv.ScanPay(*req.Payload.(*map[string]string))
		if err != nil {
			res.Errno = 10122
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeGetPayReasonEndpoint(srv server.WeixinService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		data, err := srv.GetPayReason()
		if err != nil {
			res.Errno = 10123
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeCityAllEndpoint(srv server.CityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}

		req := request.(server.Request)
		shortName := req.Payload.(string)
		if shortName != "" {
			data, err := srv.GetCityByShortName(shortName)
			if err != nil {
				res.Errno = 10133
				res.Errmsg = err.Error()
			}
			res.Payload = data
		} else {
			data, err := srv.GetCityAllList()
			if err != nil {
				res.Errno = 10133
				res.Errmsg = err.Error()
			}
			res.Payload = data
		}

		return res, nil
	}

}

func makeCityOpenCountyEndpoint(srv server.CityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}

		//req := request.(server.Request)
		//shortName := req.Payload.(string)
		//if shortName != "" {
		data, err := srv.GetCityOpenCounty()
		if err != nil {
			res.Errno = 10134
			res.Errmsg = err.Error()
		}
		res.Payload = data
		//}

		return res, nil
	}

}

func makeCityOpenListEndpoint(srv server.CityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}

		data, err := srv.GetOpenCityList()
		if err != nil {
			res.Errno = 10130
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}

func makeGetCityByIdEndpoint(srv server.CityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		cityIds := req.Payload.(*[]int)

		data, err := srv.GetCityListById(*cityIds)
		if err != nil {
			res.Errno = 10131
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}

func makeGetCountyByCityIdEndpoint(srv server.CityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		cityId := req.Payload.(*int)

		data, err := srv.GetCountyByCityId(*cityId)
		if err != nil {
			res.Errno = 10132
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}

// 订单联系人相关
func makeLinkerGetEndpoint(srv server.UserLinkerService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.UserLinker)

		data, err := srv.LinkerGet(param.Id, param.CustomId)
		if err != nil {
			res.Errno = 10144
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeLinkerAddEndpoint(srv server.UserLinkerService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.UserLinker)

		data, err := srv.LinkerAdd(param)
		if err != nil {
			res.Errno = 10140
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeLinkerUpdateEndpoint(srv server.UserLinkerService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.UserLinker)

		data, err := srv.LinkerUpdate(param)
		if err != nil {
			res.Errno = 10141
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeLinkerListEndpoint(srv server.UserLinkerService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.UserLinker)

		data, err := srv.LinkerList(param.CustomId)
		if err != nil {
			res.Errno = 10143
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeLinkerDefaultEndpoint(srv server.UserLinkerService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.UserLinker)

		data, err := srv.LinkerDefault(param.CustomId)
		if err != nil {
			res.Errno = 10146
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeLinkerDelEndpoint(srv server.UserLinkerService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*entity.UserLinker)

		data, err := srv.LinkerDel(param)
		if err != nil {
			res.Errno = 10142
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}

func makeLinkerRelEndpoint(srv server.UserLinkerService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}

		data, err := srv.Relationships()
		if err != nil {
			res.Errno = 10147
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}

}
func makeProductGetEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*[]int)

		// 20230629 增加支付宝特殊处理
		if req.IsZFB() {
			data, err := srv.ZFB_ProductGet(*param)
			if err != nil {
				res.Errno = 10150
				res.Errmsg = err.Error()
			}
			res.Payload = data
			return res, nil
		}

		data, err := srv.ProductGet(*param)
		if err != nil {
			res.Errno = 10150
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeProductGetCoordinates(srv server.ProductService) endpoint.Endpoint {
	//20211013 获取产品坐标
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*ProductCoordinatesParam)

		data, err := srv.ProductGetCoordinates(param.Pid, "", param.CityId)
		if err != nil {
			res.Errno = 10159
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeProductCheckCoordinates(srv server.ProductService) endpoint.Endpoint {
	//20211013 检测坐标是否在上门范围内
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*ProductCoordinatesParam)

		data, err := srv.ProductGetCoordinates(param.Pid, param.Coordinates, param.CityId)
		if err != nil {
			res.Errno = 10160
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeProductGetByCatIdEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		param := req.Payload.(*GetProductByCateParam)
		pager := dal.Pager{
			PageSize:  param.PageSize,
			PageIndex: param.PageIndex,
		}
		sp := dal.SortParam{
			SortBy:  param.SortBy,
			SortDir: param.SortDir,
		}
		// 20230629 增加支付宝特殊处理
		if req.IsZFB() {
			data, err := srv.ZFB_ProductGetByCateId(param.CateIds, pager, param.CityId, sp)
			if err != nil {
				res.Errno = 10151
				res.Errmsg = err.Error()
			}
			res.Payload = data
			return res, nil
		}
		data, err := srv.ProductGetByCateId(param.CateIds, pager, param.CityId, sp)
		if err != nil {
			res.Errno = 10151
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeGetProductCateEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		req := request.(server.Request)
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		posType := req.Payload.(*int)
		data, err := srv.GetProductCate(*posType)
		if err != nil {
			res.Errno = 10152
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeGetRecommendProductEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*GetProductByCateParam)
		pager := dal.Pager{
			PageSize:  param.PageSize,
			PageIndex: param.PageIndex,
		}
		sp := dal.SortParam{
			SortBy:  param.SortBy,
			SortDir: param.SortDir,
		}
		// 20230629 增加支付宝特殊处理
		if req.IsZFB() {
			data, err := srv.GetRecommendProduct(pager, param.CityId, sp)
			if err != nil {
				res.Errno = 10153
				res.Errmsg = err.Error()
			}
			res.Payload = data
			return res, nil
		}
		data, err := srv.GetRecommendProduct(pager, param.CityId, sp)
		if err != nil {
			res.Errno = 10153
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetTagsEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*TagParam)
		data, err := srv.GetTags(param.ParentId, param.CityId)
		if err != nil {
			res.Errno = 10154
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeGetProductByTagsEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*GetProductParam)
		// 20230629 增加支付宝特殊处理
		if req.IsZFB() {
			data, err := srv.ZFB_GetByTags(param.Tags, param.PageIndex, param.PageSize, param.CityId)
			if err != nil {
				res.Errno = 10155
				res.Errmsg = err.Error()
			}
			res.Payload = data
			return res, nil
		}
		data, err := srv.GetByTags(param.Tags, param.PageIndex, param.PageSize, param.CityId)
		if err != nil {
			res.Errno = 10155
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeAddProductByDpidsEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*[]int)
		data, err := srv.AddByDpids(*param)
		if err != nil {
			res.Errno = 10156
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeSaveConsumerGeneSignEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.ConsumerGeneSign)
		data, err := srv.SaveConsumerGeneSign(param)
		if err != nil {
			res.Errno = 10156
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeGetProductAddingCateEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*int)
		data, err := srv.GetProductAddingCate(*param)
		if err != nil {
			res.Errno = 10157
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeGetProductTopEndpoint(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*TopProductParam)
		// 20230629 增加支付宝特殊处理
		if req.IsZFB() {
			data, err := srv.ZFB_GetTop(param.Size, param.CityId)
			if err != nil {
				res.Errno = 10158
				res.Errmsg = err.Error()
			}
			res.Payload = data
			return res, nil
		}
		data, err := srv.GetTop(param.Size, param.CityId)
		if err != nil {
			res.Errno = 10158
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeProductGuess(srv server.ProductService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*ProductGuessParam)
		data, err := srv.GetByGuess(param.Mobile)
		if err != nil {
			res.Errno = 10161
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetOrderListEndpoint(srv server.DeliverUserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*GetOrderListParam)
		data, err := srv.GetOrderList(param.Openid, param.Status, param.PageIndex, param.PageSize)
		if err != nil {
			res.Errno = 10201
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

// 20220225 护士签到订单列表调用 之前用的makeGetOrderListEndpoint
func makeGetOrderListV2Endpoint(srv server.DeliverUserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*GetOrderListParam)
		data, err := srv.GetOrderListV2(param.Openid, param.PageIndex, param.PageSize)
		if err != nil {
			res.Errno = 10206
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetOrderSignEndpoint(srv server.DeliverUserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		orderId := req.Payload.(*string)
		data, err := srv.GetOrderSign(*orderId)
		if err != nil {
			res.Errno = 10202
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeSaveOrderSignEndpoint(srv server.DeliverUserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		signItem := req.Payload.(*entity.OrderSign)
		var err error
		result := true
		//qz 检测项录入 20200826
		//如果 status =600 将remark 转换成 DetectInfoParam
		//20221229 增加601 其他检测
		if signItem.Status == "600" || signItem.Status == "601" {
			dataList := []entity.DetectInfoParam{}
			err = json.Unmarshal([]byte(signItem.Remark), &dataList)
			if err == nil && len(dataList) > 0 {
				result, err = srv.DetectInfoAdd(dataList)
			}
		} else if signItem.Status == "100" {
			//todo 发送验证码
			//todo 保存验证码
			err = srv.SendVCode(signItem.OrderId)
		} else if signItem.Status == "201" {
			//todo 校验校验码
			//todo 如果校验失败返回错误
			err = srv.VerifyCode(signItem.OrderId, signItem.Remark)
		}

		if err != nil || !result {
			res.Errno = 10203
			res.Errmsg = err.Error()
			res.Payload = result
			return res, nil
		}

		data, err := srv.SaveOrderSign(signItem)

		if err != nil {
			res.Errno = 10203
			res.Errmsg = err.Error()
		}
		res.Payload = data

		return res, nil
	}
}

func makeRegistDUEndpoint(srv server.DeliverUserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		duItem := req.Payload.(*entity.DeliverUser)
		data, err := srv.RegistDU(duItem)
		if err != nil {
			res.Errno = 10204
			res.Errmsg = err.Error()
			if strings.Contains(err.Error(), "require subscribe rid") {
				res.Errno = 10240
				res.Errmsg = err.Error()
			}
		}
		res.Payload = data
		return res, nil
	}
}

func makeNurseExamEndpoint(srv server.DeliverUserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*NourseExamParam)
		var (
			data interface{}
			err  error
		)
		switch param.Oper {
		case "UPDATE_DU":
			data, err = srv.UpdateDU(param.DUser)
		case "GET_EXAM":
			data, err = srv.GetExamList()
		case "CHECK_EXAM":
			data, err = srv.CheckExam(param.DUser, param.Questions)
		case "GET_STUDY_LIST":
			data, err = srv.GetStudyList(param.Type)
		case "GET_STUDY_LOG":
			data, err = srv.GetStudyLog(param.DUser.Openid, param.Type)
		case "ADD_STUDY_LOG":
			data, err = srv.AddStduyLog(param.StudyLog)
		case "GET_DELIVER":
			data, err = srv.Get(param.DUser.Openid)
		case "GET_DISPATCH_ORDERS":
			data, err = srv.GetDispatchOrders(param.City)
		case "SCRAMBLE_ORDER":
			data, err = srv.ScrambleOrder(param.DeliverUserId, param.OrderId)
		case "ADD_WORKDAYS":
			data, err = srv.AddWorkdays(param.DeliverUserId, param.Workdays)
		case "GET_WORKDAYS":
			data, err = srv.GetNurseWorkdays(param.DeliverUserId)
		case "GET_BILLS":
			data, err = srv.GetBills(param.DeliverUserId, param.PageIndex, param.PageSize)
		case "GET_ACCOUNT_INFO":
			data, err = srv.GetAccountInfo(param.DeliverUserId)
		case "CANCEL_WORKDAYS":
			data, err = srv.CancelWorkdays(param.DeliverUserId, param.Workdays)
		case "GET_MSG":
			data, err = srv.NurseMsg(param.DeliverUserId, param.PageIndex, param.PageSize, param.City)
		case "WITHDRAW":
			data, err = srv.NurseWithdraw(param.DeliverUserId, param.Money)
		case "ADD_CHAT_MSG":
			data, err = srv.AddChatMsg(param.ChatMsg)
		case "GET_CHAT_MSG":
			data, err = srv.GetChatMsg(param.DeliverUserId, param.PageIndex)
		case "UPDATE_NURSE_MSG":
			data, err = srv.UpdateNurseMsg(param.DeliverUserId)
		case "GET_SCORE_INFO":
			data, err = srv.NurseScore(param.DeliverUserId)
		case "NURSE_SIGNIN":
			data, err = srv.NurseSignIn(param.DeliverUserId)
		case "GET_SCORE_BILL":
			data, err = srv.GetScoreBill(param.DeliverUserId, param.PageIndex, param.PageSize, param.Type)
		case "SCORE_WITHDRAW":
			data, err = srv.NurseScoreWithdraw(param.DeliverUserId, param.Money)
		case "GET_IF_STATUS":
			data, err = srv.GetIFStatus(param.Openid, param.Type, param.PageIndex, param.PageSize)
		case "GET_DAILY_QUESTION":
			data, err = srv.DailyQuestion()
		case "CHECK_QUESTION":
			data, err = srv.CheckQuestion(param.DeliverUserId, &param.Questions[0])
		case "SET_SKIP":
			data, err = srv.GetIsSkip(param.DeliverUserId, param.IsSkip)
		case "PRODUCT_EXAM":
			data, err = srv.GetProductExam(param.ProductId)
		case "CHECK_PRODUCT_EXAM":
			data, err = srv.CheckProductExam(param.DeliverUserId, param.ProductId, param.Answers)
		case "DELIVER_PRODUCT_LIST":
			data, err = srv.GetDeliverProductList(param.PageIndex, param.PageSize)
		case "GET_WIKI":
			data, err = srv.GetWikiByProductId(param.ProductId)
		case "CHECK_DELIVER_PASS":
			data, err = srv.CheckDeliverPass(param.ProductId, param.DeliverUserId)
		case "GET_PRODUCT_DISCOUNT":
			data, err = srv.GetProductDiscount(param.ProductId, param.DeliverUserId)

		default:
			err = errors.New("参数错误(oper)")
		}
		if err != nil {
			res.Errno = 10205
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetFirstPagePicListEndpoint(srv server.SystemService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		data, err := srv.GetFirstPagePicList()
		if err != nil {
			res.Errno = 10301
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeGetWorkdaysEndpoint(srv server.SystemService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		n := req.Payload.(*int)
		data, err := srv.GetWorkdays(*n)
		if err != nil {
			res.Errno = 10302
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeGetQuestionEndpoint(srv server.SystemService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		n := req.Payload.(*int)
		data, err := srv.GetQuestion(*n)
		if err != nil {
			res.Errno = 10303
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}
func makeGetDictListEndpoint(srv server.SystemService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		dictparam := req.Payload.(*DictParam)
		data, err := srv.GetDictList(dictparam.Class, dictparam.Ordernum)
		if err != nil {
			res.Errno = 10304
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}
func makeGetDictListsEndpoint(srv server.SystemService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		dictparams := req.Payload.(*[]DictParam)
		result := map[string]interface{}{}
		for _, v := range *dictparams {
			data, err := srv.GetDictList(v.Class, v.Ordernum)
			if err != nil {
				res.Errno = 10305
				res.Errmsg = err.Error()
				break
			}
			result[v.Class] = data
		}
		res.Payload = result
		return res, nil

	}
}

// activity service handler
func makeAddReporterEndpoint(srv server.ActivityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.ActReporter)
		data, err := srv.AddReporter(param)
		if err != nil {
			res.Errno = 10501
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeAddActInfoEndpoint(srv server.ActivityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.ActInfo)
		data, err := srv.AddActInfo(param)
		if err != nil {
			res.Errno = 10502
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeGetActInfoEndpoint(srv server.ActivityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.ActInfo)

		data, err := srv.GetActInfo(param.Mobile.String, param.Source)
		if err != nil {
			res.Errno = 10504
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeUpdateActinfoEndpoint(srv server.ActivityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.ActInfo)
		data, err := srv.UpdateActInfo(param)
		if err != nil {
			res.Errno = 10504
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

// qz activity 提现
func makeWithdrawActinfoEndpoint(srv server.ActivityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.ActInfo)
		data, err := srv.WithdrawActInfo(param)
		if err != nil {
			res.Errno = 10504
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

// group blood service handler
func makeGetGroupBloodInfoEndpoint(srv server.GroupBloodService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*GroupBloodParam)
		data, err := srv.GetGroupBloodInfo(param.CustomId)
		if err != nil {
			res.Errno = 10601
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}
func makeGroupBloodEnqueueEndpoint(srv server.GroupBloodService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*GroupBloodParam)
		data, err := srv.Enqueue(param.SubjectId, param.CustomId)
		if err != nil {
			res.Errno = 10602
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}
func makeGroupBloodNextEndpoint(srv server.GroupBloodService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*GroupBloodParam)
		data, err := srv.Next(param.SubjectId, param.OperType)
		if err != nil {
			res.Errno = 10603
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}
func makeGroupBloodSubjectQueueEndpoint(srv server.GroupBloodService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*GroupBloodParam)
		data, err := srv.GetQueueInfo(param.SubjectId, param.Status)
		if err != nil {
			res.Errno = 10604
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeGroupBloodGetOrderinfoEndpoint(srv server.GroupBloodService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*string)
		data, err := srv.GetOrderInfo(*param)
		if err != nil {
			res.Errno = 10605
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeGroupBloodGetProgressinfoEndpoint(srv server.GroupBloodService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*string)
		data, err := srv.GetCheckProgress(*param)
		if err != nil {
			res.Errno = 10606
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

func makeGroupBloodConfirmCheckEndpoint(srv server.GroupBloodService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.GPParam)
		data, err := srv.ConfirmChecked(param)
		if err != nil {
			res.Errno = 10607
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

// pay serivce hanlder
func makeGetPrepayInfoEndpoint(srv server.PayService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*map[string]string)
		data, err := srv.GetPrepayInfo(*param)
		if err != nil {
			res.Errno = 10701
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil

	}
}

// qz 保存custom 基本信息
func makeSaveInfoEndpoint(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.User)
		data, err := srv.SaveInfo(param)
		if err != nil {
			res.Errno = 10702
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

// qz 保存custom hobby
func makeSaveHobbyEndpoint(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.User)
		data, err := srv.SaveHobby(param)
		if err != nil {
			res.Errno = 10703
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

// qz 获取hobby
func makeGetHobbyEndpoint(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}

		data, err := srv.GetHobby()
		if err != nil {
			res.Errno = 10704
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}




// 新版本
func makeGetCustomFilelist(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*int)
		data, err := srv.GetCustomFileList(*param)
		if err != nil {
			res.Errno = 10707
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetCustomFile(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*int)
		data, err := srv.GetCustomFile(*param)
		if err != nil {
			res.Errno = 10705
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeUpdateCustomFileLabel(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.CustomInfoLabelsDto)
		err := srv.UpdateCustomFileLabel(param)
		if err != nil {
			res.Errno = 10706
			res.Errmsg = err.Error()
		}
		//res.Payload =
		return res, nil
	}
}

func makeAddCustomFile(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.CustomFile)
		data, err := srv.AddCustomFile(param)
		if err != nil {
			res.Errno = 10709
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeModifyCustomFile(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.CustomFile)
		data, err := srv.ModifyCustomFile(param)
		if err != nil {
			res.Errno = 10710
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeDelCustomFile(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*int)
		err := srv.DelCustomFile(*param)
		if err != nil {
			res.Errno = 10710
			res.Errmsg = err.Error()
		}
		//res.Payload = data
		return res, nil
	}
}

func makeAddCustomAttachment(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.CustomAttachment)
		data, err := srv.AddCustomAttachment(param)
		if err != nil {
			res.Errno = 10711
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetCustomAttachmentCount(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.CustomFileParam)
		param.CustomMobile = req.Mobile
		data, err := srv.GetCustomAttachmentCount(param)
		if err != nil {
			res.Errno = 10712
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetCustomAttachmentList(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.CustomFileParam)
		//data, err := srv.GetCustomAttachmentList(*param,"")
		param.CustomMobile = req.Mobile
		data, err := srv.GetComprehensive(param)
		if err != nil {
			res.Errno = 10713
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetCustomRiskList(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*int)
		data, err := srv.GetCustomRiskList(*param)
		if err != nil {
			res.Errno = 10714
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetYiDianList(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*int)
		data, err := srv.GetGetYiDianList(*param)
		if err != nil {
			res.Errno = 10715
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

func makeGetDoctorRecommendList(srv server.UserService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*int)
		data, err := srv.GetDoctorRecommendList(*param)
		if err != nil {
			res.Errno = 10716
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

// 20220505开票
func makeAddInvoice(srv server.ActivityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.ActInfo)
		data, err := srv.AddInvoice(param)
		if err != nil {
			res.Errno = 10505
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

// 20220505获取开票
func makeGetInvoice(srv server.ActivityService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.ActInfo)
		data, err := srv.GetInvoice(param.ExCode.String)
		if err != nil {
			res.Errno = 10506
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}

// 20220623 京东物流
func makeJDLAdd(srv server.JDLService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.JDLParams)
		fmt.Println(param)
		//data, err := srv.PuckUpOrder(param)
		data, err := srv.PuckUpOrderV2(param)
		if err != nil {
			res.Errno = 11001
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeJDLCalendar(srv server.JDLService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.JDLParams)
		fmt.Println(param)
		data, err := srv.Calendar(param)
		if err != nil {
			res.Errno = 11002
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeJDLCancel(srv server.JDLService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.JDLCheck)
		fmt.Println(param)
		//data, err := srv.Cancel(param.PickUpCode, param.CustomerCode)
		data, err := srv.CancelV2(param.PickUpCode, param.CustomerCode)
		if err != nil {
			res.Errno = 11003
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}
func makeJDLTrace(srv server.JDLService) endpoint.Endpoint {
	return func(ctx context.Context, request interface{}) (interface{}, error) {
		var res = &server.Response{
			Errno:  0,
			Errmsg: "",
		}
		req := request.(server.Request)
		param := req.Payload.(*entity.JDLCheck)
		fmt.Println(param)
		data, err := srv.GetTraceInfo(param.PickUpCode, param.CustomerCode)
		if err != nil {
			res.Errno = 11004
			res.Errmsg = err.Error()
		}
		res.Payload = data
		return res, nil
	}
}