back/internal/api/mobile/users/register.go

package users

import (
	"recook/internal/back"
	"recook/internal/cache"
	. "recook/internal/dbc"
	"recook/internal/model/user"
	service "recook/internal/service/app"
	"recook/tools"

	"github.com/gin-gonic/gin"
	"github.com/go-redis/redis"
	"github.com/jinzhu/gorm"
)

type weChatRegister struct {
	Mobile    string `json:"mobile" validate:"required"`
	WxUnionId string `json:"wxUnionId" validate:"required"`
	SMS       string `json:"sms"`
}

type mobileRegister struct {
	Mobile       string `json:"mobile" validate:"required,len=11"`
	InvitationNo string `json:"invitationNo"`
	SMS          string `json:"sms"`
}

type weChatInvitation struct {
	WxUnionId    string `json:"wxUnionId" validate:"required"`
	InvitationNo string `json:"invitationNo"`
}

// WeChatRegister 微信注册 step2: 只传递过来手机号码， 如果手机号码之前注册过，关联上并且直接登陆， 没有注册过，则提示他输入邀请码
func WeChatRegister(c *gin.Context) {
	var p weChatRegister
	err := tools.ParseParams(&p, c)
	if err != nil {
		back.Fail(c, "参数错误"+err.Error())
		return
	}

	//  redis中设置5分钟更新一次验证码
	pwd, _ := Rds.Get(cache.SuperKey).Result()
	if pwd != p.SMS {
		// 这里是正常用户的业务逻辑
		v := cache.GetUserSMSCode(p.Mobile)
		if v != p.SMS {
			back.Fail(c, "验证码错误")
			return
		}
	}

	var userInfo user.Information
	// 用微信的唯一id账号查找用户
	var u = service.NewUserWithRedis()
	userInfo, err = u.GetUserInRedis(p.WxUnionId)
	if err != nil {
		if err == redis.Nil {
			DB.Where("wx_union_id=?", p.WxUnionId).Last(userInfo)
			if userInfo.ID <= 0 {
				back.Err(c, "没有该用户")
				return
			}
		} else {
			back.Err(c, "json错误："+err.Error())
			return
		}
	}

	// 需要绑定过手机号和邀请码
	if len(userInfo.Mobile) > 0 && len(userInfo.InvitationNo) > 0 {
		back.Fail(c, "已绑定过手机号")
		return
	}

	var oldUserInfo user.Information
	DB.First(&oldUserInfo, "mobile = ?", p.Mobile)

	if oldUserInfo.ID > 0 {
		if len(oldUserInfo.WxUnionId) == 0 { // 这个手机号码如果使用过了，但是没有绑定微信，直接将微信的数据绑定到那个账号下面
			tx := DB.Begin()
			{
				if err := tx.Model(&oldUserInfo).Updates(user.Information{
					Nickname:     userInfo.Nickname,
					HeadImgUrl:   userInfo.HeadImgUrl,
					WxUnionId:    userInfo.WxUnionId,
					WxAppOpenId:  userInfo.WxAppOpenId,
					WxMiniOpenId: userInfo.WxMiniOpenId,
				}).Error; err != nil {
					tx.Rollback()
					back.Err(c, err.Error())
					return
				}
				// 删除 微信信息
				err = u.DelUserInRedis(userInfo.WxUnionId)
				if err != nil {
					tx.Rollback()
					back.Err(c, "内部错误601"+err.Error())
					return
				}
			}
			tx.Commit()

			var login user.Login
			DB.First(&login, "user_id = ?", oldUserInfo.ID)
			back.Suc(c, "登录成功", &rtnPack{
				BasicAuth{
					ID:    login.ID,
					Token: login.Token,
				},
				(&DetailInfo{}).ReflectedBy(&oldUserInfo, false),
				1,
			})
		} else {
			back.Fail(c, "该手机号码已使用，请使用其他号码")
			return
		}
	} else {
		// 设置用户手机号码， 记录在redis中
		userInfo.Mobile = p.Mobile
		ok, err := u.SetUserInRedis(userInfo.WxUnionId, userInfo, 0)
		// 重新放入redis
		if ok != "OK" || err != nil {
			back.Fail(c, "对不起，内部错误")
			return
		}

		// 需要输入邀请码 客户端需要在下一页提示
		back.Suc(c, "请填写邀请码", gin.H{
			"status": 0,
			"info": gin.H{
				"wxUnionId": p.WxUnionId,
			},
		})
	}
}

// WeChatInvitation 微信注册 step3
func WeChatInvitation(c *gin.Context) {
	// 传入的参数设置
	var p weChatInvitation
	// 参数检查，
	err := tools.ParseParams(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}

	// 从微信端注册时用户邀请码默认为id时6的用户，邀请码为NXR0L3
	// p.InvitationNo = "NXR0L3"

	// 正确, 入库
	var u = service.NewUserWithRedis()
	userInfo, err := u.GetUserInRedis(p.WxUnionId)
	userInfo.InvitationNo = p.InvitationNo
	if err != nil {
		if err == redis.Nil {
			back.Fail(c, "用户不存在")
			return
		}
		back.Fail(c, "内部错误rds")
		return
	}

	registerUser := service.NewRegisterUser()

	tmp := userInfo
	var login user.Login
	if err = registerUser.UserAdd(c, &login, &userInfo, userInfo.Mobile); err != nil {
		back.Fail(c, "add error:"+err.Error())
		return
	}

	userInfo.Nickname = tmp.Nickname
	userInfo.HeadImgUrl = tmp.HeadImgUrl
	userInfo.WxUnionId = tmp.WxUnionId
	userInfo.WxAppOpenId = tmp.WxAppOpenId
	userInfo.WxMiniOpenId = tmp.WxMiniOpenId
	DB.Save(userInfo)

	// 删除redis中的值
	go u.DelUserInRedis(p.WxUnionId)

	cache.SetUserLoginCache(&login)

	back.Suc(c, "登录成功", &rtnPack{
		BasicAuth{
			ID:    login.ID,
			Token: login.Token,
		},
		(&DetailInfo{}).ReflectedBy(&userInfo, false),
		1,
	})
}

/*
微信注册 step3
*/
func WeChatInvitationWxapp(c *gin.Context) {
	// 传入的参数设置
	var p weChatInvitation
	// 参数检查，
	err := tools.ParseParams(&p, c)
	if err != nil {
		back.Fail(c, err.Error())
		return
	}

	// 从微信端注册时用户邀请码默认为id时6的用户，邀请码为NXR0L3
	//p.InvitationNo = "NXR0L3"

	// 正确, 入库
	var u = service.NewUserWithRedis()
	userInfo, err := u.GetUserInRedis(p.WxUnionId)
	if err != nil {
		if err == redis.Nil {
			back.Fail(c, "用户不存在")
			return
		}
		back.Fail(c, "内部错误rds")
		return
	}

	registerUser := service.NewRegisterUser()
	//
	//inviter, roleID, partner, err := registerUser.RegisterRole(p.InvitationNo, userInfo.Mobile)
	//if err != nil {
	//	back.Fail(c, err.Error())
	//	return
	//}
	userInfo.InvitationNo = p.InvitationNo

	tmp := userInfo
	var login user.Login
	if err = registerUser.UserAdd(c, &login, &userInfo, userInfo.Mobile); err != nil {
		back.Fail(c, "add error:"+err.Error())
		return
	}
	userInfo.Nickname = tmp.Nickname
	userInfo.HeadImgUrl = tmp.HeadImgUrl
	userInfo.WxUnionId = tmp.WxUnionId
	userInfo.WxAppOpenId = tmp.WxAppOpenId
	userInfo.WxMiniOpenId = tmp.WxMiniOpenId
	DB.Save(userInfo)

	// 删除redis中的值
	go u.DelUserInRedis(p.WxUnionId)

	cache.SetUserLoginCache(&login)

	back.Suc(c, "登录成功", &rtnPack{
		BasicAuth{
			ID:    login.ID,
			Token: login.Token,
		},
		(&DetailInfo{}).ReflectedBy(&userInfo, false),
		1,
	})
}

/*
手机注册
*/
func MobileRegister(c *gin.Context) {
	var p mobileRegister
	if err := tools.ParseParams(&p, c); err != nil {
		back.Fail(c, err.Error())
		return
	}

	// 从手机注册时用户邀请码默认为id时6的用户，邀请码为NXR0L3
	// p.InvitationNo = "NXR0L3"

	// 根据 不同的码 去调用不同的 下级规则
	// 获取用户角色等级
	registerUser := service.NewRegisterUser()
	//inviter, roleID, partner, err := registerUser.RegisterRole(p.InvitationNo, p.Mobile)
	//if err != nil {
	//	back.Fail(c, "错误："+err.Error())
	//	return
	//}

	var login user.Login
	var info user.Information
	info.InvitationNo = p.InvitationNo

	// 开始添加用户
	if err := registerUser.UserAdd(c, &login, &info, p.Mobile); err != nil {
		back.Fail(c, "add error:"+err.Error())
		return
	}

	// 设置用户已登陆的信息
	cache.SetUserLoginCache(&login)

	back.Suc(c, "登录成功", &rtnPack{
		BasicAuth{
			ID:    login.ID,
			Token: login.Token,
		},
		(&DetailInfo{}).ReflectedBy(&info, false),
		1,
	})
}

func MobileRegisterWxapp(c *gin.Context) {
	var p mobileRegister
	if err := tools.ParseParams(&p, c); err != nil {
		back.Fail(c, err.Error())
		return
	}

	//  redis中设置5分钟更新一次验证码
	pwd, _ := Rds.Get(cache.SuperKey).Result()
	if pwd != p.SMS {
		// 这里是正常用户的业务逻辑
		v := cache.GetUserSMSCode(p.Mobile)
		if v != p.SMS {
			back.Fail(c, "验证码错误")
			return
		}
	}

	// 从手机注册时用户邀请码默认为id时6的用户，邀请码为NXR0L3
	//p.InvitationNo = "NXR0L3"

	// 根据 不同的码 去调用不同的 下级规则
	//// 获取用户角色等级
	registerUser := service.NewRegisterUser()
	//inviter, roleID, partner, err := registerUser.RegisterRole(p.InvitationNo, p.Mobile)
	//if err != nil {
	//	back.Fail(c, "错误："+err.Error())
	//	return
	//}

	var login user.Login
	var info user.Information
	var uuid user.Information
	DB.Table(info.TableName()).Where("invitation_no=?", p.InvitationNo).First(&uuid)

	// 开始添加用户
	if err := registerUser.UserAdd(c, &login, &info, p.Mobile); err != nil {
		back.Fail(c, "add error:"+err.Error())
		return
	}

	// 设置用户已登陆的信息
	cache.SetUserLoginCache(&login)

	back.Suc(c, "登录成功", &rtnPack{
		BasicAuth{
			ID:    login.ID,
			Token: login.Token,
		},
		(&DetailInfo{}).ReflectedBy(&info, false),
		1,
	})
}

func IsRegistered(c *gin.Context) {
	type mobileH5IsRegistered struct {
		Mobile string `json:"mobile" validate:"required,len=11"`
	}
	var p mobileH5IsRegistered
	if err := tools.ParseParams(&p, c); err != nil {
		back.Fail(c, "请填写正确的资料"+err.Error())
		return
	}
	var userInfo user.Information
	err := DB.Where("mobile = ?", p.Mobile).Find(&userInfo).Error
	if err != gorm.ErrRecordNotFound && err != nil {
		back.Fail(c, err.Error())
		return
	}
	if err == gorm.ErrRecordNotFound {
		back.Suc(c, "手机号未注册", gin.H{
			"is_registered": false,
		})
		return
	}
	back.Suc(c, "手机号已经注册", gin.H{
		"is_registered": true,
	})
	return
}

type mobileH5Register struct {
	Mobile         string `json:"mobile" validate:"required,len=11"`
	InvitationNo   string `json:"invitationNo" validate:"required,max=8,min=6"`
	SMS            string `json:"sms" validate:"required,len=4"`
	SuperiorUserId uint   `json:"superiorUserId"`
}

/*
	H5注册 手机注册
*/
func MobileRegisterH5(c *gin.Context) {
	var p mobileH5Register
	if err := tools.ParseParams(&p, c); err != nil {
		back.Fail(c, "请填写正确的资料"+err.Error())
		return
	}

	//if !(p.Mobile == "15669291989" || p.Mobile == "18906611076" || p.Mobile == "15988645436") {
	//	v := cache.GetUserSMSCode(p.Mobile)
	//	if v != p.SMS {
	//		http.Fail(c, "手机验证码错误")
	//		return
	//	}
	//}
	//  redis中设置5分钟更新一次验证码
	pwd, _ := Rds.Get(cache.SuperKey).Result()
	if pwd != p.SMS {
		// 这里是正常用户的业务逻辑
		v := cache.GetUserSMSCode(p.Mobile)
		if v != p.SMS {
			back.Fail(c, "验证码错误")
			return
		}
	}

	var userInfo user.Information
	err := DB.Where("mobile = ?", p.Mobile).Find(&userInfo).Error
	if err != gorm.ErrRecordNotFound {
		back.Fail(c, "请勿重复注册")
		return
	}

	// 获取用户角色等级
	registerUser := service.NewRegisterUser()
	//inviter, roleID, partner, err := registerUser.RegisterRole(p.InvitationNo, p.Mobile)
	//if err != nil {
	//	back.Fail(c, err.Error())
	//	return
	//}

	var login user.Login
	var info user.Information

	info.InvitationNo = p.InvitationNo

	// 开始添加用户
	if err = registerUser.UserAdd(c, &login, &info, p.Mobile); err != nil {
		back.Fail(c, "add error:"+err.Error())
		return
	}

	back.Suc(c, "注册成功", nil)
	return
}