smart-enterprise-management-gateway/controller/v1/user.go

// Copyright 2019 github.com. All rights reserved.
// Use of this source code is governed by github.com.

package v1

import (
	"github.com/dgrijalva/jwt-go"
	"github.com/jaryhe/gopkgs/logger"
	"github.com/jaryhe/gopkgs/tasker/httptasker"
	"github.com/jaryhe/gopkgs/util"
	"google.golang.org/grpc/status"
	"net/http"
	"smart-enterprise-management-gateway/consts"
	"smart-enterprise-management-gateway/errors"
	param_v1 "smart-enterprise-management-gateway/param/v1"
	"smart-enterprise-management-gateway/pb"
	"smart-enterprise-management-gateway/pb/v1"
	"strconv"
	"time"
	"fmt"

	"github.com/gin-gonic/gin"
	"go.uber.org/zap"
	"smart-enterprise-management-gateway/utils"
	"github.com/jaryhe/gopkgs/jwtwrapper"
	"smart-enterprise-management-gateway/parser"
)

// 注册
// @Summary 注册
// @Description 注册
// @Tags user
// @Accept  json
// @Produce  json
// @Param body body v1.RegisterBody true "登录信息"
// @Success 200 {object} v1.RegisterResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/register [post]
func (c *Controller) Register(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.RegisterRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.RegisterBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		vcode,_ := strconv.Atoi(req.Verify)
		resp := param_v1.RegisterResponse{}
		rpcReq := &v1.RegisterRequest{
		}
		utils.StructCopy(rpcReq, &req.RegisterBody, "")
		rpcReq.Vcode = uint32(vcode)
		rpcRsp, err := pb.Enterprise.Register(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "Register"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return err
		}
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask,  handleServiceTask)
}


// 公示
// @Summary 公示
// @Description 公示
// @Tags publicity
// @Accept  json
// @Produce  json
// @Param provider query string false "供应商名称"
// @Param device_code query int false "设备类型"
// @Success 200 {object} v1.PublicityResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/publicity [get]
func (c *Controller) Publicity(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.PublicityRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.PublicityQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {

		// 响应数据
		resp := param_v1.PublicityResponse{}
		rpcReq := &v1.PublicityRequest{
			DeviceCode:int32(req.DeviceCode),
			Provider:req.Provider,
		}

		rpcRsp, err := pb.Enterprise.Publicity(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Supplier.Publicity"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return err
		}
		resp.Data.List = make([]param_v1.PublicityItem, len(rpcRsp.List))
		for i, v := range rpcRsp.List {
			resp.Data.List[i].Name = v.Name
			resp.Data.List[i].SocialCode = v.SocialCode
		}
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}


// 根据社会码获取注册状态
// @Summary 根据社会码获取注册状态
// @Description 根据社会码获取注册状态
// @Tags user
// @Accept  json
// @Produce  json
// @Param social_code query string true " "
// @Success 200 {object} v1.CompanyApproveStatusResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/status [get]
func (c *Controller) CompanyApproveStatus(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.CompanyApproveStatusRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.CompanyApproveStatusQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := param_v1.CompanyApproveStatusResponse{}
		rpcReq := &v1.CompanyApproveStatusRequest{
			SocialCode:req.SocialCode,
		}

		rpcRsp, err := pb.Enterprise.CompanyApproveStatus(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "CompanyApproveStatus"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return err
		}
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 登录
// @Summary 登录
// @Description 登录
// @Tags user
// @Accept  json
// @Produce  json
// @Param body body v1.LoginBody true "登录信息"
// @Success 200 {object} v1.LoginResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/login [post]
func (c *Controller) Login(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.LoginRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.LoginBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		if !utils.CaptchaVerify(ctx, req.Verify, req.Captcha) {
			return errors.VerifyError
		}
		// 响应数据
		resp := param_v1.LoginResponse{}
		rpcReq := &v1.LoginRequest{
			User:req.User,
			Password:req.Password,
		}

		rpcRsp, err := pb.Enterprise.Login(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Enterprise.Login"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		subJect := map[string]interface{}{
			"user_name":req.User,
		}
		str,_ := json.MarshalToString(subJect)
		// 生成token
		token, err := jwtwrapper.GenToken(fmt.Sprintf("%d", rpcRsp.Uid), parser.Conf.Jwt.Issuer, str,
			time.Duration(parser.Conf.Jwt.Seconds)*time.Second)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.GenJwtToken"),
				zap.String("args", fmt.Sprintf("%d", rpcRsp.Uid)),
				zap.String("error", err.Error()))
			return errors.SystemError
		}

		refreshToken, err := jwtwrapper.GenToken(fmt.Sprintf("%d", rpcRsp.Uid), parser.Conf.Jwt.Issuer, str,
			time.Duration(7*24*60*60)*time.Second)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.GenJwtToken"),
				zap.String("args", fmt.Sprintf("%d", rpcRsp.Uid)),
				zap.String("error", err.Error()))
			return errors.SystemError
		}
		resp.Data.Uid = rpcRsp.Uid
		resp.Data.Token = token
		resp.Data.RefreshToken = refreshToken
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// token
// @Summary 刷新token
// @Description 刷新token
// @Tags user
// @Accept  json
// @Produce  json
// @Param token header string true "token"
// @Success 200 {object} v1.TokenResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/token_refresh [put]
func (c *Controller) TokenRefresh(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.TokenRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		tokenObj, err := jwtwrapper.ParseToken(req.Token)
		if tokenObj == nil {
			return errors.TokenFailedError
		}
		if err != nil {
			switch err.(*jwt.ValidationError).Errors {
			case jwt.ValidationErrorExpired:
				return errors.TokenFailedError
			default:
				return errors.TokenFailedError
			}
		}

		uid := tokenObj.Id
		// 生成token
		token, err := jwtwrapper.GenToken(fmt.Sprintf("%s", uid), parser.Conf.Jwt.Issuer, tokenObj.Subject,
			time.Duration(parser.Conf.Jwt.Seconds)*time.Second)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.GenJwtToken"),
				zap.String("args", fmt.Sprintf("%d", uid)),
				zap.String("error", err.Error()))
			return errors.SystemError
		}
		resp := param_v1.TokenResponse{}
		resp.Data = token
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}


// 获取短信验证码
// @Summary 获取短信验证码
// @Description 获取短信验证码
// @Tags publicity
// @Accept  json
// @Produce  json
// @Param phone query string true "phone"
// @Param verify query bool false "verify"
// @Success 200 {object} v1.VcodeResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/vcode [get]
func (c *Controller) Vcode(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.VcodeRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.VcodeQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {


		if req.Verify {
			mreq := &v1.UserInfoRequest{Phone:req.Phone}
			_, err := pb.Enterprise.UserInfo(ctx, mreq)
			if err != nil {
				return err
			}
		}
		// 响应数据
		resp := param_v1.VcodeResponse{}
		rpcReq := &v1.GetVcodeRequest{
			PhoneNumber:req.Phone,
		}

		rpcRsp, err := pb.Thirdparty.GetVcode(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Thirdparty.GetVcode"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return err
		}
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

/*
// 找回密码校验手机和图片验证码
// @Summary 找回密码校验手机和图片验证码
// @Description 找回密码校验手机和图片验证码
// @Tags user
// @Accept  json
// @Produce  json
// @Param body body v1.FindPasswdVerifyBody true "登录信息"
// @Success 200 {object} v1.LoginResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/find_passwd_verify [post]
func (c *Controller) FindPasswdVerify(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.FindPasswdVerifyRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.FindPasswdVerifyBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		if !utils.CaptchaVerify(ctx, req.Verify, req.Captcha) {
			return errors.ParamsError
		}
		// 响应数据
		resp := param_v1.FindPasswdVerifyResponse{}
		rpcReq := &v1.CheckVcodeRequest{
			PhoneNumber:req.Phone,
			Vcode:req.Vcode,
		}

		_, err := pb.Thirdparty.CheckVcode(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Thirdparty.CheckVcode"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}
*/

// 找回密码设置密码
// @Summary 找回密码设置密码
// @Description 找回密码设置密码
// @Tags user
// @Accept  json
// @Produce  json
// @Param body body v1.SetPasswdBody true "登录信息"
// @Success 200 {object} v1.SetPasswdResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/set_passwd [put]
func (c *Controller) SetPasswd(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.SetPasswdRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.SetPasswdBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleVcodeTask := func() error {
		// 响应数据
		rpcReq := &v1.CheckVcodeRequest{
			PhoneNumber:req.Phone,
			Vcode:req.Vcode,
		}

		_, err := pb.Thirdparty.CheckVcode(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Thirdparty.CheckVcode"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		return nil
	}
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.SetPasswdResponse{}
		rpcReq := &v1.SetPasswdRequest {
			Passwd:req.Passwd,
			Phone:req.Phone,
		}

		_, err := pb.Enterprise.SetPasswd(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Supplier.SetPasswd"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleVcodeTask, handleServiceTask)
}

// 修改密码
// @Summary 修改密码
// @Description 修改密码
// @Tags user
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.ChangePasswdBody true " "
// @Success 200 {object} v1.ChangePasswdResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/change_passwd [put]
func (c *Controller) ChangePasswd(ctx *gin.Context) {
	// 解析参数
	var loginUid int64
	var userName string
	req := &param_v1.ChangePasswdRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.ChangePasswdBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		loginUid, _, _ := utils.GetJwtIdFromCtx(ctx)
		resp := param_v1.ChangePasswdResponse{}
		rpcReq := &v1.ChangePasswdRequest {
			Old:req.Old,
			New:req.New,
			Uid:loginUid,
		}

		_, err := pb.Enterprise.ChangePasswd(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Supplier.ChangePasswd"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务

	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask)
	req.New = "****"
	req.Old = "****"
	s, _ := json.MarshalToString(req)
	utils.LogWrite("修改密码", loginUid, userName,  s, err, 0)
}


// 操作日志列表
// @Summary 操作日志列表
// @Description 操作日志列表
// @Tags log
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query string true " "
// @Param start query int64 false " "
// @Param end query int64 false " "
// @Success 200 {object} v1.LogListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/log/list [get]
func (c *Controller) LogList(ctx *gin.Context) {
	// 解析参数
	//var loginUid int64
	//var userName string
	req := &param_v1.LogListRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.LogListQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		//loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		if req.Page < 1 {
			req.Page = 1
		}
		resp := param_v1.LogListResponse{}
		rpcReq := &v1.LogListRequest {
			Type:consts.LogTypeCompany,
			Page:req.Page,
			Start:req.Start,
			End:req.End,
		}

		reply, err := pb.OperationLog.LogList(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.OperationLog.LogList"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		resp.Data = *reply
		if resp.Data.List == nil {
			resp.Data.List = make([]*v1.LogInfo, 0)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务

	httptasker.Exec(ctx, parseParamTask, handleServiceTask)

}

// 获取图片验证码id
// @Summary 获取图片验证码id
// @Description 获取图片验证码id
// @Tags user
// @Accept  json
// @Produce  json
// @Success 200 {object} v1.CaptchaIdResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/captcha_id [get]
func (c *Controller) CaptchaId(ctx *gin.Context) {
	// 解析参数
	parseParamTask := func() error {
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := param_v1.CaptchaIdResponse{}
		id := utils.Captcha(ctx, 4)
		resp.Data.CaptureId = id
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 获取图片验证码图片
// @Summary 获取图片验证码图片
// @Description 获取图片验证码图片
// @Tags user
// @Accept  json
// @Produce  json
// @Param captcha_id path string true " "
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/captcha_png/{captcha_id} [get]
func (c *Controller) CaptchaPng(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.CaptchaPngRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, &req.CaptchaPngPath, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		utils.Serve(ctx.Writer, ctx.Request, req.CaptchaId, ".png", "zh", false, utils.CaptchaWidth, utils.CaptchaHight, "")
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 获取地图
// @Summary 获取地图
// @Description 获取地图
// @Tags 前台
// @Accept  json
// @Produce  json
// @Success 200 {object} v1.MapResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/map [get]
func (c *Controller) Map(ctx *gin.Context) {

	// 业务处理
	handleServiceTask := func() error {
		/*
			if !utils.CaptchaVerify(ctx, req.Verify, req.Captcha) {
				//return errors.ParamsError
			}*/
		// 响应数据
		resp := param_v1.MapResponse{}
		resp.Data.Url = parser.Conf.MapUrl

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, handleServiceTask)
}

//
// @Summary 发送验证邮件
// @Description 发送验证邮件
// @Tags user
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.MailPrepareBody true " "
// @Success 200 {object} v1.MailPrepareResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/verify_mail [put]
func (c *Controller) MailPrepare(ctx *gin.Context) {
	// 解析参数
	var loginUid int64
	var userName string
	req := &param_v1.MailPrepareRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.MailPrepareBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		if !utils.VerifyEmailFormat(req.Email) {
			return status.Error(10003, "邮箱格式错误")
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		loginUid, _, _ := utils.GetJwtIdFromCtx(ctx)
		rpcReq := &v1.EmailPrepareRequest {
			Id:loginUid,
			Password:req.Password,
			Email:req.Email,
		}

		_, err := pb.Enterprise.EmailPrepare(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Enterprise.MailPrepare"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		//ctx.JSON(http.StatusOK, resp)
		return nil
	}

	sendMailTask := func() error {
		subject := map[string]interface{}{
			"email":    req.Email,
			"project_id": 0,
			"user_name":userName,
		}
		str, _ := json.MarshalToString(subject)

		// 生成token
		token, err := jwtwrapper.GenToken(fmt.Sprintf("%d", loginUid), parser.Conf.Jwt.Issuer, str,
			time.Duration(180)*time.Second)

		resp := param_v1.MailPrepareResponse{}
		rpcReq := &v1.SendEmailRequest {
			Email:req.Email,
			Content:fmt.Sprintf("浏览器中打开以下链接验证邮箱:\n%s?token=%s", parser.Conf.EnterpriseMailCheckUrl, token),
		}

		_, err = pb.Thirdparty.SendEmail(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Thirdparty.SendEmail"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask, sendMailTask)
	s, _ := json.MarshalToString(req)
	utils.LogWrite("发送验证邮件", loginUid, userName, s, err, 0)
}

//
// @Summary 修改邮箱
// @Description 修改邮箱
// @Tags user
// @Accept  json
// @Produce  json
// @Param token query string true " "
// @Success 200 {object} v1.MailUpdateResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/mail [get]
func (c *Controller) MailUpdate(ctx *gin.Context) {
	// 解析参数
	var loginUid int64
	var userName string
	//var projectId int64
	var email string
	req := &param_v1.MailUpdateRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, &req.MailUpdateQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, _, userName, email,  err = utils.EmailTokenVeriy(req.Token)
		if err != nil {
			return  err
		}
		return nil
	}

	// 业务处理
	var pid int64
	handleServiceTask := func() error {
		resp := param_v1.MailUpdateResponse{

		}
		rpcReq := &v1.EmailUpdateRequest {
			Id:loginUid,
			Email:email,
		}

		_, err := pb.Enterprise.EmailUpdate(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Enterprise.EmailUpdate"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		resp.Message = "邮箱设置成功"
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask)
	utils.LogWrite("修改邮箱", loginUid, userName, email, err, pid)
}

//
// @Summary 修改电话号码
// @Description 修改电话号码
// @Tags user
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.PhoneUpdateBody true " "
// @Success 200 {object} v1.PhoneUpdateResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/phone [put]
func (c *Controller) PhoneUpdate(ctx *gin.Context) {
	// 解析参数
	var loginUid int64
	var userName string
	req := &param_v1.PhoneUpdateRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, &req.PhoneUpdateBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	var pid int64
	vcodeCheckTask := func() error {
		rpcReq := &v1.CheckVcodeRequest {
			Vcode:req.Vcode,
			PhoneNumber:req.Phone,
		}

		_, err := pb.Thirdparty.CheckVcode(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Thirdparty.CheckVcode"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		return nil
	}

	// 业务处理
	handleServiceTask := func() error {


		resp := &param_v1.PhoneUpdateResponse{}
		rpcReq := &v1.PhoneUpdateRequest {
			Id:loginUid,
			Phone:req.Phone,
		}

		_, err := pb.Enterprise.PhoneUpdate(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Enterprise.PhoneUpdate"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, vcodeCheckTask, handleServiceTask)
	s, _ := json.MarshalToString(req)
	utils.LogWrite("修改电话号码", loginUid, userName, s, err, pid)
}

//
// @Summary 获取电话和邮箱
// @Description 获取电话和邮箱
// @Tags 用户
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Success 200 {object} v1.UserInfoResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/info [get]
func (c *Controller) UserInfo(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.UserInfoRequest{}
	var loginUid int64
	//var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, _, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := param_v1.UserInfoResponse{}
		rpcReq := &v1.UserInfoRequest{
			Id:loginUid,
		}

		rpcRsp, err := pb.Enterprise.UserInfo(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Enterprise.UserInfo"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 获取临时token
// @Summary 获取临时token
// @Description 获取临时token
// @Tags user
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param project_id query string true "项目id"
// @Success 200 {object} v1.TmpTokenResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/tmp_token [get]
func (c *Controller) TmpToken(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.TmpTokenRequest{}
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.TmpTokenQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		resp := param_v1.TmpTokenResponse{}
		subject := map[string]interface{}{
			"tmp_token":true,
			"project_id":req.ProjectId,
		}
		subjectStr, _ := json.MarshalToString(subject)
		// 生成token
		token, err := jwtwrapper.GenToken(fmt.Sprintf("%d", req.ProjectId), parser.Conf.Jwt.Issuer, subjectStr,
			time.Duration(120)*time.Second)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.TmpToken"),
				zap.String("args", fmt.Sprintf("%d", req.ProjectId)),
				zap.String("error", err.Error()))
			return errors.SystemError
		}

		resp.Data.Token = token
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

//
// @Summary 企业基本信息
// @Description 企业基本信息
// @Tags 用户
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Success 200 {object} v1.CompanyInfoResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/user/company_info [get]
func (c *Controller) CompanyInfo(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.CompanyInfoRequest{}
	var loginUid int64
	//var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, nil, nil, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, _, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据
		resp := param_v1.CompanyInfoResponse{}
		rpcReq := &v1.CompanyInfoRequest{
			Id:loginUid,
		}

		rpcRsp, err := pb.Enterprise.CompanyInfo(ctx, rpcReq)

		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "pb.Enterprise.CompanyInfo"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		resp.Data = *rpcRsp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}