hepa-calc-api/api/controller/Login.go

package controller

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"hepa-calc-api/api/dao"
	"hepa-calc-api/api/dto"
	"hepa-calc-api/api/model"
	"hepa-calc-api/api/requests"
	"hepa-calc-api/api/responses"
	"hepa-calc-api/api/service"
	"hepa-calc-api/config"
	"hepa-calc-api/global"
	"hepa-calc-api/utils"
	"time"
)

type Login struct{}

// Login 登录
func (r *Login) Login(c *gin.Context) {
	loginRequest := requests.LoginRequest{}
	req := loginRequest.Login
	if err := c.ShouldBind(&req); err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 参数验证
	if err := global.Validate.Struct(req); err != nil {
		responses.FailWithMessage(utils.Translate(err), c)
		return
	}

	// 公众号登录
	if req.Source == 2 {
		if req.Mobile == "" || req.OpenId == "" {
			responses.FailWithMessage("登陆失败", c)
			return
		}
	}

	// 检测参数
	if req.Mobile != "" {
		// 检测验证码
		if config.C.Env != "dev" {
			if req.Source == 2 {
				if req.Code == "" {
					responses.FailWithMessage("请输入手机号验证码", c)
					return
				}

				code, _ := global.Redis.Get(c, "login_code_count_"+req.Mobile).Result()
				if code == "" {
					responses.FailWithMessage("验证码失效", c)
					return
				}

				if req.Code != code {
					responses.FailWithMessage("验证码错误", c)
					return
				}
			}
		}
	}

	// 开始事务
	tx := global.Db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
			utils.LogJsonErr("操作失败", r)
			responses.FailWithMessage("操作失败", c)
			return
		}
	}()

	var userInfo *model.UserInfo
	var err error

	// 检测用户信息
	userDao := dao.UserDao{}
	maps := make(map[string]interface{})
	maps["mobile"] = req.Mobile
	user, _ := userDao.GetUser(maps)
	// 新用户处理方式
	if user == nil {
		// 登录ip
		publicService := service.PublicService{}
		loginIp := publicService.GetUserIP(c.Request)

		// 处理用户头像
		userService := service.UserService{}
		avatarOssPath, err := userService.HandleUserImage(req.HeadImgUrl)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}

		// 新增用户
		user = &model.User{
			UserName:         "",
			AppIden:          req.Uuid,
			Mobile:           req.Mobile,
			RegisterSource:   req.Source,
			OpenId:           req.OpenId,
			UnionId:          req.UnionId,
			Age:              nil,
			Sex:              nil,
			Avatar:           avatarOssPath,
			IsMember:         0,
			MemberExpireDate: nil,
			LoginIp:          loginIp,
		}
		loginAt := model.LocalTime(time.Now())
		user.LoginAt = &loginAt

		user, err = userDao.AddUser(tx, user)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}

		// 新增用户详情
		userInfo = &model.UserInfo{
			UserId:          user.UserId,
			Height:          "",
			Weight:          "",
			NationId:        nil,
			IsFamilyHistory: nil,
			IsPregnant:      nil,
			ExpectedDate:    nil,
			ProvinceId:      "",
			Province:        "",
			CityId:          "",
			City:            "",
			CountyId:        "",
			County:          "",
		}
		userInfoDao := dao.UserInfoDao{}
		userInfo, err = userInfoDao.AddUserInfo(tx, userInfo)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}
	} else {
		// 获取用户详情数据
		userInfoDao := dao.UserInfoDao{}
		userInfo, err = userInfoDao.GetUserInfoByUserId(user.UserId)
		if err != nil {
			tx.Rollback()
			responses.FailWithMessage(err.Error(), c)
			return
		}

		// 处理用户openid
		if req.OpenId != "" {
			userData := make(map[string]interface{})
			if req.OpenId != user.OpenId {
				userData["open_id"] = req.OpenId
			}

			err := userDao.EditUserById(tx, user.UserId, userData)
			if err != nil {
				tx.Rollback()
				responses.FailWithMessage(err.Error(), c)
				return
			}
		}
	}

	// 处理app用户数据
	userService := service.UserService{}
	err = userService.GetAppUserInfo(tx, user, userInfo)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 处理app用户病例数据
	err = userService.GetAppUserCase(tx, user)
	if err != nil {
		tx.Rollback()
		responses.FailWithMessage(err.Error(), c)
		return
	}

	tx.Commit()

	// 获取用户信息
	user, err = userDao.GetUserById(user.UserId)
	if err != nil {
		responses.FailWithMessage(err.Error(), c)
		return
	}

	// 下发token
	token := &utils.Token{
		UserId: fmt.Sprintf("%d", user.UserId),
	}

	// 生成jwt
	jwt, err := token.NewJWT()
	if err != nil || jwt == "" {
		responses.FailWithMessage("登陆失败", c)
		return
	}

	// 处理返回值
	g := dto.LoginMobileDto(user)

	// 加载token
	g.LoadToken(jwt)

	responses.OkWithData(g, c)
}