mh_server/controller/account.go

package controller

import (
	"encoding/json"
	"fmt"
	"github.com/codinl/go-logger"
	"github.com/gin-gonic/gin"
	"github.com/medivhzhan/weapp"
	"mh-server/config"
	"mh-server/lib/auth"
	"mh-server/lib/status"
	"mh-server/lib/utils"
	"mh-server/lib/utils/crypt"
	"mh-server/model"
	"time"
)

// AuthLogin 用户登陆
// @Summary 用户登陆
// @Tags 用户鉴权
// @Produce json
// @Accept json
// @Param request body model.AuthLoginReq true "用户登陆模型"
// @Success 200 {object} model.AuthLoginResp
// @Router /api/v1/auth/login [post]
func AuthLogin(c *gin.Context) {
	req := new(model.AuthLoginReq)

	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	fmt.Println("WxAppId", config.AppConfig.WxAppId)
	fmt.Println("WxAppSecret", config.AppConfig.WxAppSecret)
	model.AuthLoginMutex.Lock()
	defer model.AuthLoginMutex.Unlock()

	resp, err := weapp.Login(config.AppConfig.WxAppId, config.AppConfig.WxAppSecret, req.Code)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	if resp.SessionKey == "" {
		logger.Error("Get SessionKey Fail")
		RespJson(c, status.BadRequest, nil)
		return
	}
	fmt.Println("用户信息 resp:", resp)
	logger.Infof("OpenID=%+v", resp.OpenID)
	logger.Info("resp.UnionID=", resp.UnionID)

	// 解析手机号
	phone, err := weapp.DecryptPhoneNumber(resp.SessionKey, req.EncryptedData, req.Iv)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	//// 解析用户数据
	//userInfo, err := weapp.DecryptUserInfo(req.RawData, req.EncryptedData, req.Signature, req.Iv, resp.SessionKey)
	//if err != nil {
	//	logger.Error(err)
	//	RespJson(c, status.BadRequest, nil)
	//	return
	//}
	//fmt.Println("用户信息 userInfo:", userInfo)

	var user = model.User{}
	sqlErr := model.NewUserQuerySet(model.DB).TelEq(phone.PhoneNumber).OrderDescByLastLoginAt().One(&user)
	if sqlErr != nil && sqlErr != model.RecordNotFound {
		logger.Error("WxOpenIDEq:", sqlErr)
		RespJson(c, status.DBOperateError, nil)
		return
	}

	fmt.Println("InviteUid:", req.InviteUid)
	nowTime := time.Now()
	// 不存在则创建新用户
	if sqlErr == model.RecordNotFound {
		// 通过openid查询是否有历史遗留数据：有openid但是手机号为空
		_ = model.NewUserQuerySet(model.DB).WxOpenIDEq(resp.OpenID).One(&user)
		if user.WxOpenID == resp.OpenID && user.Tel == "" {
			_ = model.NewUserQuerySet(model.DB).UidEq(user.Uid).GetUpdater().SetTel(phone.PhoneNumber).Update()
		} else { // 通过openid也未查询到数据
			user = model.User{
				WxOpenID:              resp.OpenID,
				WxUnionID:             resp.UnionID,
				LastLoginAt:           nowTime,
				MemberLevel:           model.MemberLevelUser, // 普通会员
				Tel:                   phone.PhoneNumber,
				CooperativeBusinessId: 1,
			}
			user.Uid = createUid() // 新建uid
			err = user.Create(model.DB)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
			fmt.Println("新用户:", user.WxOpenID)
		}
		//// 判断是否有邀请人
		//if req.InviteUid != 0 {
		//	inviteUser := model.GetUserByUid(req.InviteUid)
		//	effectiveStoreInfo, err := model.GetUserEffectiveStore(req.InviteUid)
		//	if err != nil {
		//		RespJson(c, status.InviteUserFail, nil)
		//		return
		//	}
		//
		//	if inviteUser.UserType == model.UserTypeShopAssistant { // 如果入参有邀请人id，并且是店员，则新增2条邀请记录
		//		inviteRecordFirst := &model.UserInviteRecord{
		//			ToUid:       user.Uid,
		//			FromUid:     req.InviteUid,
		//			StoreId:     effectiveStoreInfo.StoreID,
		//			Action:      2,                     // 激活邀请
		//			SpendType:   1,                     // 未开通
		//			MemberLevel: model.MemberLevelUser, // 普通会员
		//			First:       1,                     // 首次邀请
		//			Scan:        1,
		//			ActionTime:  nowTime,
		//		}
		//		err = model.DB.Create(inviteRecordFirst).Error
		//		if err != nil {
		//			logger.Error("create user invite record err:", err)
		//		}
		//
		//		inviteRecord := &model.UserInviteRecord{
		//			ToUid:       user.Uid,
		//			FromUid:     req.InviteUid,
		//			StoreId:     effectiveStoreInfo.StoreID,
		//			Action:      1,                     // 1-未激活
		//			SpendType:   1,                     // 未开通
		//			MemberLevel: model.MemberLevelUser, // 普通会员
		//			First:       0,
		//			Scan:        1,
		//			ActionTime:  nowTime,
		//		}
		//		err = model.DB.Create(inviteRecord).Error
		//		if err != nil {
		//			logger.Error("create user invite record err:", err)
		//		}
		//
		//		inviteUser := model.GetUserByUid(req.InviteUid)
		//		user.StoreId = effectiveStoreInfo.StoreID
		//		user.UserType = model.UserTypeConsumer
		//		user.CooperativeBusinessId = inviteUser.CooperativeBusinessId
		//		user.CooperativeName = inviteUser.CooperativeName
		//
		//		invite := &model.UserInvite{
		//			FromUid:            req.InviteUid,
		//			UserType:           inviteUser.UserType,
		//			StoreId:            effectiveStoreInfo.StoreID,
		//			MemberType:         model.MemberLevelUser,
		//			ToUid:              user.Uid,
		//			MemberStatus:       1, // 1-未开通
		//			Action:             1, // 1-未激活
		//			SpendType:          1, // 未开通
		//			UserInviteRecordId: inviteRecord.ID,
		//			Scan:               1,
		//		}
		//		err = invite.Create(model.DB)
		//		if err != nil {
		//			logger.Error(err)
		//			RespJson(c, status.InternalServerError, nil)
		//			return
		//		}
		//	}
		//}
		//newAccessToken, err := auth.CreateAccessToken(user.Uid)
		//if err != nil {
		//	logger.Error(err)
		//	RespJson(c, status.InternalServerError, nil)
		//	return
		//}
		//
		//fmt.Println("JwtUserRefreshKey:", config.AppConfig.JwtUserRefreshKey)
		//fmt.Println("JwtUserRefreshExpire:", config.AppConfig.JwtUserRefreshExpire)
		//newRefreshToken, err := auth.CreateToken(user.Uid, config.AppConfig.JwtUserRefreshKey, config.AppConfig.JwtUserRefreshExpire)
		//if err != nil {
		//	logger.Error(err)
		//	RespJson(c, status.InternalServerError, nil)
		//	return
		//}
		//refreshToken := &model.UserRefreshToken{
		//	Uid:   user.Uid,
		//	Token: newRefreshToken,
		//}
		//err = refreshToken.Create(model.DB)
		//if err != nil {
		//	logger.Error(err)
		//	RespJson(c, status.InternalServerError, nil)
		//	return
		//}
		//
		//ret := model.AuthLoginResp{
		//	AccessToken:     newAccessToken,
		//	AccessExpire:    config.AppConfig.JwtUserAccessExpire,
		//	RefreshToken:    refreshToken.Token,
		//	RefreshExpire:   config.AppConfig.JwtUserRefreshExpire,
		//	Uid:             user.Uid,
		//	AccessCreatedAt: nowTime,
		//}
		//
		//RespJson(c, status.OK, ret)
		//return
	} else {
		if user.WxOpenID == "" { // 微信openid为空，只是线下购物时新建了用户，则更新补充数据
			user.WxOpenID = resp.OpenID
			user.WxUnionID = resp.UnionID
			user.LastLoginAt = nowTime
			user.MemberLevel = model.MemberLevelUser // 普通会员
			//user.WxName = userInfo.Nickname
			//user.WxAvatar = userInfo.Avatar
			user.CreatedAt = nowTime
			user.CooperativeBusinessId = 1
			err = model.UserUpdate(&user)
			if err != nil {
				logger.Error("WxOpenIDEq:", err)
				RespJson(c, status.DBOperateError, nil)
				return
			}
		}
	}

	if req.InviteUid != 0 && req.InviteUid != user.Uid && user.Uid != 0 { // 入参有邀请人id且非本人
		inviteUser := model.GetUserByUid(req.InviteUid)
		effectiveStoreInfo, err := model.GetUserEffectiveStore(req.InviteUid)
		if err != nil {
			RespJson(c, status.InviteUserFail, nil)
			return
		}

		if user.StoreId == 0 { // 用户所属门店id为空则更新
			_, err = model.NewUserQuerySet(model.DB).UidEq(user.Uid).GetUpdater().SetStoreId(effectiveStoreInfo.StoreID).
				UpdateNum()
			if err != nil {
				logger.Error("update err:", err)
			}
		}

		if inviteUser.UserType == model.UserTypeShopAssistant { // 店员邀请
			memberLevel := user.MemberLevel
			if memberLevel == 0 {
				memberLevel = model.MemberLevelUser // 普通会员
			}

			exist, err := model.QueryRecordExist(
				fmt.Sprintf("SELECT * FROM user_invite_record WHERE to_uid = %d AND from_uid = %d ",
					user.Uid, req.InviteUid))
			if err != nil {
				logger.Error("query err:", err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
			if !exist { // 未邀请过，则添加邀请记录：首次邀请记录
				firstInviteRecord := &model.UserInviteRecord{
					ToUid:       user.Uid,
					FromUid:     req.InviteUid,
					StoreId:     effectiveStoreInfo.StoreID,
					Action:      2,           // 没邀请过，则生成1条记录且后台可显示
					SpendType:   1,           // 未开通
					MemberLevel: memberLevel, // 会员等级
					First:       1,           // 首次
					Scan:        1,           // 扫码次数
					ActionTime:  nowTime,     // 激活时间
				}

				err = model.DB.Create(firstInviteRecord).Error
				if err != nil {
					logger.Error("create user invite record err:", err)
				}

				// 如果用户还未开通会员，此时首次扫某个店员的码，需要再多生成1条记录
				if user.MemberLevel == model.MemberLevelConsumer || user.MemberLevel == model.MemberLevelUser {
					// 已经邀请过，则更新扫码记录
					inviteRecord := &model.UserInviteRecord{
						ToUid:       user.Uid,
						FromUid:     req.InviteUid,
						StoreId:     effectiveStoreInfo.StoreID,
						Action:      1,           // 未激活
						SpendType:   1,           // 未开通
						MemberLevel: memberLevel, // 会员等级
						First:       0,
						Scan:        1,
						ActionTime:  nowTime,
					}
					err = model.DB.Create(inviteRecord).Error
					if err != nil {
						logger.Error("create user invite record err:", err)
					}
					firstInviteRecord.ID = inviteRecord.ID
				}

				// UserInvite 邀请主要
				var inviteNew model.UserInvite
				//inviteErr := model.NewUserInviteQuerySet(model.DB).ToUidEq(user.Uid).FromUidEq(req.InviteUid).ActionEq(1).
				//	SpendTypeEq(1).One(&inviteNew) // action:1-未激活 spend_type:1-未开通

				inviteErr := model.NewUserInviteQuerySet(model.DB).ToUidEq(user.Uid).FromUidEq(req.InviteUid).
					OrderDescByCreatedAt().Limit(1).One(&inviteNew)
				if inviteErr != nil && inviteErr != model.RecordNotFound {
					// 是否存在未开通
					logger.Error("user invite err:", err)
				}
				fmt.Println("inviteErr:", inviteErr)
				fmt.Printf("inviteNew:%#v \n", inviteNew)
				if inviteErr == model.RecordNotFound { // 邀请表没记录
					invite := &model.UserInvite{
						FromUid:            req.InviteUid,              // 邀请人用户id
						UserType:           inviteUser.UserType,        // 邀请人用户类型
						StoreId:            effectiveStoreInfo.StoreID, // 邀请人门店ID --- 邀请人如果有多家门店：优先取有效期短的门店，如果有效期相同则取门店id小的门店
						MemberOpenTime:     time.Time{},                // 开通会员时间
						MemberType:         memberLevel,                // 被邀请用户类型
						MemberStatus:       1,                          // 被邀请用户会员状态 1-未开通
						ToUid:              user.Uid,                   // 被邀请用户id
						Action:             1,                          // 开通会员
						SpendType:          1,                          // 未开通
						UserInviteRecordId: firstInviteRecord.ID,       // 邀请记录id
						FirstInvite:        1,                          // 首次邀请标志：1 首次邀请 0 非首次
						Scan:               1,                          // 扫码次数
					}
					fmt.Println("创建邀请:", invite)

					if user.MemberLevel == model.MemberLevelGold || user.MemberLevel == model.MemberLevelPeriod ||
						user.MemberLevel == model.MemberLevelPlatinum || user.MemberLevel == model.MemberLevelBlackGold {
						invite.RenewHide = 1
						invite.Action = 2 // 续费会员
					}

					if err := invite.Create(model.DB); err != nil {
						logger.Error(err)
						RespJson(c, status.InternalServerError, nil)
						return
					}
				}
				//// 已经邀请过，则更新扫码记录
				//inviteRecord := &model.UserInviteRecord{
				//	ToUid:       user.Uid,
				//	FromUid:     req.InviteUid,
				//	StoreId:     effectiveStoreInfo.StoreID,
				//	Action:      1,           // 未激活
				//	SpendType:   1,           // 未开通
				//	MemberLevel: memberLevel, // 会员等级
				//	First:       0,
				//	Scan:        1,
				//	ActionTime:  nowTime,
				//}
				//if user.MemberLevel == model.MemberLevelGold || user.MemberLevel == model.MemberLevelPeriod ||
				//	user.MemberLevel == model.MemberLevelPlatinum || user.MemberLevel == model.MemberLevelBlackGold {
				//	inviteRecord.Action = 2 // 激活后邀请
				//}
				//err = model.DB.Create(inviteRecord).Error
				//if err != nil {
				//	logger.Error("create user invite record err:", err)
				//}

			} else { // 邀请过，则更新邀请时间
				var inviteNew model.UserInvite
				inviteErr := model.NewUserInviteQuerySet(model.DB).ToUidEq(user.Uid).FromUidEq(req.InviteUid).
					OrderDescByCreatedAt().Limit(1).One(&inviteNew)
				if inviteErr == nil {
					err = model.NewUserInviteQuerySet(model.DB).IDEq(inviteNew.ID).GetUpdater().SetCreatedAt(nowTime).Update()
					if err != nil {
						logger.Error("NewUserInviteQuerySet err:", err, req.InviteUid)
					}
				}
			}
		}
	}

	fmt.Println(" user:", user.Uid)
	// 旧用户
	newAccessToken, err := auth.CreateAccessToken(user.Uid)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
	}

	newRefreshToken, err := auth.CreateToken(user.Uid, config.AppConfig.JwtUserRefreshKey, config.AppConfig.JwtUserRefreshExpire)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	refreshToken, err := model.UserRefreshTokenGetOrUpdate(user.Uid, newRefreshToken)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	err = model.NewUserQuerySet(model.DB).WxOpenIDEq(resp.OpenID).GetUpdater().SetLastLoginAt(time.Now()).Update()
	if err != nil && err != model.RecordNotFound {
		logger.Error(err)
	}

	ret := model.AuthLoginResp{
		AccessToken:     newAccessToken,
		AccessExpire:    config.AppConfig.JwtUserAccessExpire,
		RefreshToken:    refreshToken.Token,
		RefreshExpire:   config.AppConfig.JwtUserRefreshExpire,
		Uid:             user.Uid,
		AccessCreatedAt: nowTime,
	}

	RespJson(c, status.OK, ret)
	return

}

func UserInfoUpload(c *gin.Context) {
	req := struct {
		Uid           uint32 `json:"uid" binding:"required"`
		Code          string `json:"code" binding:"required"`
		EncryptedData string `json:"encrypted_data" binding:"required"`
		RawData       string `json:"raw_data" binding:"required"`
		Signature     string `json:"signature" binding:"required"`
		Iv            string `json:"iv" binding:"required"`
		//UserInfo      weapp.Userinfo `json:"user_info" binding:"required"`
	}{}

	if err := c.ShouldBindJSON(&req); err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

	resp, err := weapp.Login(config.AppConfig.WxAppId, config.AppConfig.WxAppSecret, req.Code)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	if resp.SessionKey == "" {
		logger.Error("Get SessionKey Fail")
		RespJson(c, status.BadRequest, nil)
		return
	}

	userInfo, err := weapp.DecryptUserInfo(req.RawData, req.EncryptedData, req.Signature, req.Iv, resp.SessionKey)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}
	logger.Infof("userInfo=%+v", userInfo)

	user := new(model.User)
	if err := model.NewUserQuerySet(model.DB).UidEq(req.Uid).One(user); err == nil {
		user.WxUnionID = userInfo.UnionID
		//user.WxName = req.UserInfo.Nickname
		//user.WxAvatar = req.UserInfo.Avatar
		//user.Gender = uint8(req.UserInfo.Gender)
		//user.City = req.UserInfo.City
		//user.Province = req.UserInfo.Province
		//user.Country = req.UserInfo.Country
		//user.MemberLevel = 1

		user.WxName = userInfo.Nickname
		user.WxAvatar = userInfo.Avatar
		user.Gender = uint8(userInfo.Gender)
		user.Province = userInfo.Province
		user.City = userInfo.City
		user.Country = userInfo.Country

		as := model.UserDBSchema
		if err := user.Update(model.DB, as.WxUnionID, as.WxName, as.WxAvatar, as.Gender, as.City, as.Province, as.Country, as.MemberLevel); err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}

	RespOK(c, nil)
}

// UserData 获取用户数据
// @Summary 获取用户数据
// @Tags 用户信息
// @Produce json
// @Accept json
// @Success 200 {object} model.User
// @Router /api/v1/user/data [post]
func UserData(c *gin.Context) {
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	m := new(model.User)
	if err := model.NewUserQuerySet(model.DB).UidEq(uc.Uid).One(m); err != nil && err != model.RecordNotFound {
		logger.Error(err)
		RespJson(c, status.Unauthorized, nil)
		return
	}

	var sysUser model.SysUser
	if err := model.NewSysUserQuerySet(model.DB).UidEq(uc.Uid).One(&sysUser); err != nil && err != model.RecordNotFound {
		logger.Error(err)
		RespJson(c, status.Unauthorized, nil)
		return
	}

	var userVm model.UserVm
	err := model.NewUserVmQuerySet(model.DB).UidEq(uc.Uid).One(&userVm)
	if err != nil && err != model.RecordNotFound {
		logger.Error("err")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if err == model.RecordNotFound {
		userVm = model.UserVm{
			Uid: uc.Uid,
			Vm:  0,
		}
		err = model.DB.Create(&userVm).Error
		if err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
	}
	m.UserVm = &userVm
	if sysUser.StoreData != "" {
		sysUser.StoreList = deserializeStoreData(sysUser.StoreData)
	}
	m.StoreList = sysUser.StoreList
	m.RoleId = uint32(sysUser.RoleId)
	ret := m
	RespOK(c, ret)
	return
}

// 反序列化 StoreData
func deserializeStoreData(storeData string) []model.StoreInfo {
	var StoreData []model.StoreInfo
	if err := json.Unmarshal([]byte(storeData), &StoreData); err != nil {
		// 可以根据实际情况处理反序列化失败的情况
		logger.Println("反序列化 StoreData 失败:", err)
	}
	return StoreData
}

// 找一个可以用的Uid
func createUid() uint32 {
	for {
		uid := utils.GenUid()
		if count, err := model.NewUserQuerySet(model.DB).UidEq(uid).Count(); err == nil && count > 0 {
			continue
		}
		return uid
	}
}

func TokenRefresh(c *gin.Context) {
	req := struct {
		RefreshToken string `json:"refresh_token" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}

	userJwt := auth.NewJWT(config.AppConfig.JwtUserRefreshKey)
	uc, err := userJwt.ParseToken(req.RefreshToken)
	if err != nil {
		logger.Error(err)
		RespJson(c, status.RefreshTokenInvalid, nil)
		return
	}

	// 从数据库获取用户的refresh_token
	m := new(model.UserRefreshToken)
	if err := model.NewUserRefreshTokenQuerySet(model.DB).UidEq(uc.Uid).One(m); err == nil {
		if req.RefreshToken == m.Token {
			newAccessToken, err := auth.CreateToken(uc.Uid, config.AppConfig.JwtUserAccessKey, config.AppConfig.JwtUserAccessExpire)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			newRefreshToken, err := auth.CreateToken(uc.Uid, config.AppConfig.JwtUserRefreshKey, config.AppConfig.JwtUserRefreshExpire)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			refreshToken, err := model.UserRefreshTokenGetOrUpdate(uc.Uid, newRefreshToken)
			if err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}

			now := time.Now()
			logger.Info("now.Unix=", now.Unix())
			RespJson(c, status.OK, map[string]interface{}{
				"access_token":       newAccessToken,
				"access_expire":      config.AppConfig.JwtUserAccessExpire,
				"refresh_token":      refreshToken.Token,
				"refresh_expire":     config.AppConfig.JwtUserRefreshExpire,
				"uid":                uc.Uid,
				"access_created_at":  now,
				"refresh_created_at": refreshToken.CreatedAt,
			})
			return
		} else {
			RespJson(c, status.BadRequest, nil)
			return
		}
	} else {
		logger.Error(err)
		RespJson(c, status.BadRequest, nil)
		return
	}

}

// UserTel 绑定/换绑用户手机号
func UserTel(c *gin.Context) {
	req := struct {
		Code          string `json:"code" `
		EncryptedData string `json:"encrypted_data" `
		Iv            string `json:"iv" `
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}

	uc := auth.GetCurrentUser(c)
	if uc == nil {
		RespJson(c, status.Unauthorized, nil)
		return
	}

	if req.Code != "" && req.EncryptedData != "" && req.Iv != "" {
		resp, err := weapp.Login(config.AppConfig.WxAppId, config.AppConfig.WxAppSecret, req.Code)
		if err != nil {
			RespJson(c, status.BadRequest, nil)
			return
		}

		// 解析手机号
		phone, err := weapp.DecryptPhoneNumber(resp.SessionKey, req.EncryptedData, req.Iv)
		if err != nil {
			logger.Error(err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		// 换绑手机号:通过新手机号查询是否有用户信息，如果有则返回错误信息"该手机号已经注册账号"；如果没有则更新当前用户手机号为新手机号
		var user = model.User{}
		sqlErr := model.NewUserQuerySet(model.DB).TelEq(phone.PhoneNumber).One(&user)
		if sqlErr != nil && sqlErr != model.RecordNotFound {
			logger.Error("query user by tel error:", sqlErr)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		if sqlErr == model.RecordNotFound { // 未查询到信息
			_ = model.NewUserQuerySet(model.DB).UidEq(uc.Uid).GetUpdater().SetTel(phone.PhoneNumber).Update()
		} else {
			if user.Uid != uc.Uid {
				fmt.Println("绑定手机号失败：" + phone.PhoneNumber + "该手机号已经注册账号")
				logger.Error("绑定手机号失败：" + phone.PhoneNumber + "该手机号已经注册账号")
				RespJson(c, status.ThePhoneHasBeenRegistered, nil)
				return
			}
		}

		RespJson(c, status.OK, map[string]interface{}{
			"tel": phone.PurePhoneNumber,
		})
		return
	} else {
		user := model.GetUserByUid(uc.Uid)
		if user.Tel != "" {
			RespJson(c, status.OK, map[string]interface{}{
				"tel": user.Tel,
			})
			return
		}
	}

	RespJson(c, status.OK, map[string]interface{}{
		"tel": "",
	})

	return
}

//func StepConfig(c *gin.Context) {
//	stepConfig := model.GetStepConfig()
//	RespJson(c, status.OK, stepConfig)
//}

func UserInviteAppletQRCode(c *gin.Context) {
	req := struct {
		Uid uint32 `json:"uid" binding:"required"`
	}{}
	if c.ShouldBindJSON(&req) != nil || req.Uid == 0 {
		RespJson(c, status.BadRequest, nil)
		return
	}
	user := model.GetUserByUid(req.Uid)
	if user.InviteCodeUrl == "" && user.Uid != 0 {
		//shareCode, err := crypt.GenShareCode(req.Uid)
		shareCode, err := crypt.GenDrawShareCode("", "", "", req.Uid)
		if err != nil {
			logger.Error("err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		user.InviteCodeUrl = shareCode
		user.AppletQRCodeUpdate()
	}

	RespOK(c, user)
}

func UserInviteList(c *gin.Context) {
	req := model.UserInviteListReq{}
	if c.ShouldBindJSON(&req) != nil || req.Uid == 0 {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}
	if req.Uid == 0 {
		req.Uid = uc.Uid
	}
	fmt.Println("req.MemberType:", req.MemberType)
	fmt.Printf("req.MemberType:%#v \n", req)
	fmt.Printf("req.MemberType:%+v \n", req)

	resp, err := req.InviteUserList()
	if err != nil {
		logger.Error("err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	RespOK(c, resp)
}

// NewUserInviteRecordList 会员推广记录
// @Summary 会员推广记录
// @Tags 会员推广, V1.2.0
// @Produce json
// @Accept json
// @Param request body model.NewUserInviteRecordReq true "会员推广记录模型"
// @Success 200 {object} model.UserInviteRecordListResp
// @Router /api/v1/user/new_invite_list [post]
func NewUserInviteRecordList(c *gin.Context) {
	req := new(model.NewUserInviteRecordReq)
	if c.ShouldBindJSON(req) != nil {
		logger.Errorf("para err")
		RespJson(c, status.BadRequest, nil)
		return
	}

	resp, err := req.NewList()
	if err != nil {
		logger.Errorf("err:", err)
		RespJson(c, status.InternalServerError, "查询失败")
		return
	}

	RespOK(c, resp)
}

func UserCodeToCoupon(c *gin.Context) {
	req := &struct {
		Code string `json:"code"`
	}{}
	if c.ShouldBindJSON(&req) != nil {
		RespJson(c, status.BadRequest, nil)
		return
	}
	uc := auth.GetCurrentUser(c)
	if uc == nil {
		logger.Error("uc is nil")
		RespJson(c, status.Unauthorized, nil)
		return
	}

	var inviteUid, inviteStoreId, userMemberLevel uint32
	if len(req.Code) == 6 {
		user := model.GetUserByUid(uc.Uid)
		if user == nil {
			logger.Error("user is nil")
			RespJson(c, status.Unauthorized, nil)
			return
		}

		if !user.IsMember() { // 判断用户是否为会员
			logger.Error("user is not member")
			RespJson(c, status.UserNotMember, nil)
			return
		}

		userMemberLevel = user.MemberLevel

		//if user.OpenMemberTime.IsZero() {
		//	logger.Error("user is not member")
		//	RespJson(c, status.UserNotMember, nil)
		//	return
		//}

		var shopperPromotionCode model.ShopperPromotionCode
		err := model.NewShopperPromotionCodeQuerySet(model.DB).CodeEq(req.Code).One(&shopperPromotionCode)
		if err != nil {
			logger.Error("shopper promotion code err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		inviteUid = shopperPromotionCode.Uid
		inviteStoreId = shopperPromotionCode.StoreId

		//model.UserCoupon{}

		exist, err := model.QueryRecordExist(fmt.Sprintf(
			"SELECT * FROM user_coupon WHERE uid=%d AND approach=1 AND activity_id=1 AND state=1 AND promotional_sales=%d ",
			uc.Uid, shopperPromotionCode.Uid))
		if err != nil {
			logger.Error("exist err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if exist {
			logger.Error("coupon received err:", err)
			RespJson(c, status.CouponReceived, nil)
			return
		}

		count, err := model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityIdEq(1).
			ApproachEq(1).StateEq(1).Count()
		if err != nil {
			logger.Error("count user coupon err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		if count >= 3 {
			logger.Error("coupon count gte 3")
			RespJson(c, status.CouponReceived, nil)
			return
		}
		var userCoupons []model.UserCoupon
		err = model.NewUserCouponQuerySet(model.DB).UidEq(uc.Uid).ActivityTypeEq(1).
			StateEq(1).All(&userCoupons)
		if err != nil {
			logger.Error("coupons err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		userCouponMap := make(map[uint32]int, 0)
		for i, _ := range userCoupons {
			userCouponMap[userCoupons[i].CouponId] = i
		}

		var coupons []model.Coupon
		err = model.NewCouponQuerySet(model.DB).ActivityIdEq(1).All(&coupons)
		if err != nil {
			logger.Error("coupons err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}

		for i, _ := range coupons {
			_, ok := userCouponMap[coupons[i].ID]
			if ok {
				continue
			}

			userCoupon := &model.UserCoupon{
				Uid:              uc.Uid,
				CouponId:         coupons[i].ID,
				CouponType:       coupons[i].CouponType,
				ActivityType:     coupons[i].ActivityType,
				ActivityId:       coupons[i].ActivityId,
				Value:            coupons[i].Value,
				State:            1,
				ActiveStart:      time.Now(),
				ActiveEnd:        time.Now().AddDate(0, 0, 30),
				UseTime:          time.Time{},
				MemberLevel:      coupons[i].MemberLevel,
				Approach:         1,
				PromotionalSales: shopperPromotionCode.Uid,
				RedeemCode:       shopperPromotionCode.Code,
			}

			err = model.DB.Create(userCoupon).Error
			if err != nil {
				logger.Error("user coupon err:", err)
				continue
			}
		}

		// 使用店员兑换码才产生邀请记录
		logger.Info("666")
		logger.Info("uc.Uid:", uc.Uid)
		logger.Info("inviteUid:", inviteUid)
		exist, err = model.QueryRecordExist(
			fmt.Sprintf("SELECT * FROM user_invite_record WHERE to_uid = %d AND from_uid = %d ",
				uc.Uid, inviteUid))
		if err != nil {
			logger.Error("query err:", err)
			RespJson(c, status.InternalServerError, nil)
			return
		}
		logger.Info("exist:", exist)
		if !exist { // 未邀请过，则添加邀请记录：首次邀请记录
			firstInviteRecord := &model.UserInviteRecord{
				ToUid:       uc.Uid,
				FromUid:     inviteUid,
				StoreId:     uint64(inviteStoreId),
				Action:      2,               // 激活邀请
				SpendType:   1,               // 未开通
				MemberLevel: userMemberLevel, // 会员等级
				First:       1,               // 首次
				Scan:        1,               // 扫码次数
				ActionTime:  time.Now(),      // 激活时间
			}

			err = model.DB.Create(firstInviteRecord).Error
			if err != nil {
				logger.Error("create user invite record err:", err)
			}
		}
		// 已经邀请过，则更新扫码记录
		inviteRecord := &model.UserInviteRecord{
			ToUid:       uc.Uid,
			FromUid:     inviteUid,
			StoreId:     uint64(inviteStoreId),
			Action:      1,               // 未激活
			SpendType:   1,               // 未开通
			MemberLevel: userMemberLevel, // 会员等级
			First:       0,
			Scan:        1,
			ActionTime:  time.Now(),
		}
		err = model.DB.Create(inviteRecord).Error
		if err != nil {
			logger.Error("create user invite record err:", err)
		}
		// UserInvite 邀请主要
		var inviteNew model.UserInvite
		inviteErr := model.NewUserInviteQuerySet(model.DB).ToUidEq(uc.Uid).FromUidEq(inviteUid).ActionEq(1).
			SpendTypeEq(1).One(&inviteNew) // action:1-未激活 spend_type:1-未开通
		if inviteErr != nil && inviteErr != model.RecordNotFound {
			// 是否存在未开通
			logger.Error("user invite err:", err)
		}
		logger.Info("inviteErr:", inviteErr)
		fmt.Println("inviteErr:", inviteErr)
		fmt.Printf("inviteNew:%#v \n", inviteNew)
		if inviteErr == model.RecordNotFound { // 邀请表没记录
			logger.Info("inviteErr == model.RecordNotFound")
			invite := &model.UserInvite{
				FromUid:            inviteUid,             // 邀请人用户id
				UserType:           2,                     // 邀请人用户类型
				StoreId:            uint64(inviteStoreId), // 邀请人门店ID --- 邀请人如果有多家门店：优先取有效期短的门店，如果有效期相同则取门店id小的门店
				MemberOpenTime:     time.Time{},           // 开通会员时间
				MemberType:         userMemberLevel,       // 被邀请用户类型
				MemberStatus:       1,                     // 被邀请用户会员状态 1-未开通
				ToUid:              uc.Uid,                // 被邀请用户id
				Action:             1,                     // 未激活
				SpendType:          1,                     // 未开通
				UserInviteRecordId: inviteRecord.ID,       // 邀请记录id
				FirstInvite:        1,                     // 首次邀请标志：1 首次邀请 0 非首次
				Scan:               1,                     // 扫码次数
			}
			fmt.Println("创建邀请:", invite)
			if err := invite.Create(model.DB); err != nil {
				logger.Error(err)
				RespJson(c, status.InternalServerError, nil)
				return
			}
		}

		if inviteErr == nil { // 邀请表有记录则更新邀请记录ID
			logger.Info("inviteErr == nil")
			err = model.NewUserInviteQuerySet(model.DB).IDEq(inviteNew.ID).GetUpdater().SetCreatedAt(time.Now()).
				SetUserInviteRecordId(inviteRecord.ID).Update()
			if err != nil {
				logger.Error("from uid update user invite err:", err, inviteStoreId)
			}
		}

		RespOK(c, nil)
		return
	}
	var redeemCode model.RedeemCode
	err := model.NewRedeemCodeQuerySet(model.DB).SerialCodeEq(req.Code).One(&redeemCode)
	if err != nil {
		logger.Error("redeem code err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if req.Code != "DC5709BC7375B9F5FA89D0" && redeemCode.Status != model.RedeemCodeStatusHold {
		logger.Error("redeem code status err")
		RespJson(c, status.InternalServerError, nil)
		return
	}

	var coupon model.Coupon
	err = model.NewCouponQuerySet(model.DB).IDEq(redeemCode.CouponId).One(&coupon)
	if err != nil {
		logger.Error("coupon err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	exist, err := model.QueryRecordExist(fmt.Sprintf(
		"SELECT * FROM user_coupon WHERE uid=%d AND activity_type=%d", uc.Uid, coupon.ActivityType))
	if err != nil {
		logger.Error("exist err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	if exist {
		logger.Error("user have coupon ")
		RespJson(c, status.UserFocusHasCoupon, nil)
		return
	}
	begin := model.DB.Begin()
	userCoupon := &model.UserCoupon{
		Uid:          uc.Uid,
		CouponId:     coupon.ID,
		CouponType:   coupon.CouponType,
		ActivityType: coupon.ActivityType,
		ActivityId:   coupon.ActivityId,
		Value:        coupon.Value,
		State:        1,
		ActiveStart:  time.Now(),
		UseTime:      time.Time{},
		MemberLevel:  0,
	}
	userCoupon.ActiveEnd = userCoupon.ActiveStart.AddDate(0, 0, 7)
	err = userCoupon.Create(begin)
	if err != nil {
		begin.Rollback()
		logger.Error("create user coupon")
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = model.NewRedeemCodeQuerySet(begin).IDEq(redeemCode.ID).GetUpdater().SetStatus("used").Update()
	if err != nil {
		begin.Rollback()
		logger.Error("update status err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}

	err = begin.Commit().Error
	if err != nil {
		begin.Rollback()
		logger.Error("commit err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	err = model.NewPublicRecordQuerySet(model.DB).RedeemCodeIdEq(redeemCode.ID).GetUpdater().
		SetRedeemCodeState(3).Update()
	if err != nil {
		logger.Error("update public record State err:", err)
		RespJson(c, status.InternalServerError, nil)
		return
	}
	//resp, err := req.InviteUserList()
	//if err != nil {
	//	logger.Error("err:", err)
	//	RespJson(c, status.InternalServerError, nil)
	//	return
	//}

	RespOK(c, nil)
}