846 lines
23 KiB
Go
846 lines
23 KiB
Go
package controller
|
||
|
||
import (
|
||
"fmt"
|
||
"github.com/codinl/go-logger"
|
||
"github.com/gin-gonic/gin"
|
||
"github.com/medivhzhan/weapp"
|
||
"golang.org/x/sync/errgroup"
|
||
"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 models.ErpOrderCreateReq true "用户登陆模型"
|
||
// @Success 200 {object} app.Response
|
||
// @Router /api/v1/auth/login [post]
|
||
func AuthLogin(c *gin.Context) {
|
||
req := struct {
|
||
Code string `json:"code" binding:"required"`
|
||
InviteUid uint32 `json:"invite_uid"`
|
||
}{}
|
||
|
||
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)
|
||
|
||
var user = model.User{}
|
||
sqlErr := model.NewUserQuerySet(model.DB).WxOpenIDEq(resp.OpenID).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 req.InviteUid != 0 && req.InviteUid != user.Uid { // 入参有邀请人id且非本人
|
||
inviteUser := model.GetUserByUid(req.InviteUid)
|
||
user.StoreId = inviteUser.StoreId
|
||
if user.StoreId == 0 { // 用户所属门店id为空则更新
|
||
_, err = model.NewUserQuerySet(model.DB).UidEq(user.Uid).GetUpdater().SetStoreId(inviteUser.StoreId).
|
||
UpdateNum()
|
||
if err != nil {
|
||
logger.Error("update err:", err)
|
||
}
|
||
}
|
||
|
||
if inviteUser.UserType == 2 && user.Uid != 0 { // 店员邀请
|
||
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,
|
||
Action: 2, // 激活邀请
|
||
SpendType: 1, // 未开通
|
||
MemberLevel: 0, // 0，未开通会员
|
||
First: 1, // 首次
|
||
Scan: 1, // 扫码次数
|
||
ActionTime: nowTime, // 激活时间
|
||
}
|
||
err = model.DB.Create(firstInviteRecord).Error
|
||
if err != nil {
|
||
logger.Error("create user invite record err:", err)
|
||
}
|
||
}
|
||
// 已经邀请过，则更新扫码记录
|
||
inviteRecord := &model.UserInviteRecord{
|
||
ToUid: user.Uid,
|
||
FromUid: req.InviteUid,
|
||
Action: 1, // 未激活
|
||
SpendType: 1, // 未开通
|
||
MemberLevel: 0,
|
||
First: 0,
|
||
Scan: 1,
|
||
ActionTime: nowTime,
|
||
}
|
||
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(user.Uid).FromUidEq(req.InviteUid).ActionEq(1).
|
||
SpendTypeEq(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 { // 邀请表没记录
|
||
memberLevel := user.MemberLevel
|
||
if memberLevel == 0 {
|
||
memberLevel = model.MemberTypeConsumer // 普通用户
|
||
}
|
||
invite := &model.UserInvite{
|
||
FromUid: req.InviteUid,
|
||
UserType: inviteUser.UserType, // 邀请人用户类型
|
||
StoreId: inviteUser.StoreId, // 邀请人门店ID
|
||
MemberOpenTime: time.Time{}, // 开通会员时间
|
||
MemberType: memberLevel, // 被邀请用户类型
|
||
MemberStatus: 1, // 被邀请用户会员类型
|
||
ToUid: user.Uid,
|
||
Action: 1, // 未激活
|
||
SpendType: 1, // 未开通
|
||
UserInviteRecordId: inviteRecord.ID, // 邀请记录id
|
||
FirstInvite: 0, // TODO 首次邀请id
|
||
Scan: 1, // 扫码次数
|
||
}
|
||
fmt.Println("创建邀请:", invite)
|
||
//count, err := model.NewUserInviteQuerySet(model.DB).FromUidEq(req.InviteUid).ToUidEq(user.Uid).Count()
|
||
//if err != nil {
|
||
// logger.Error(err)
|
||
// RespJson(c, status.InternalServerError, nil)
|
||
// return
|
||
//}
|
||
//if count == 0 {
|
||
//}
|
||
if err := invite.Create(model.DB); err != nil {
|
||
logger.Error(err)
|
||
RespJson(c, status.InternalServerError, nil)
|
||
return
|
||
}
|
||
}
|
||
|
||
if inviteErr == nil { // 邀请表有记录则更新邀请记录ID
|
||
//err = model.NewUserInviteQuerySet(model.DB).IDEq(inviteNew.ID).GetUpdater().
|
||
// SetFromUid(req.InviteUid).SetStoreId(inviteUser.StoreId).SetUserInviteRecordId(inviteRecord.ID).Update()
|
||
err = model.NewUserInviteQuerySet(model.DB).IDEq(inviteNew.ID).GetUpdater().SetCreatedAt(nowTime).
|
||
SetUserInviteRecordId(inviteRecord.ID).Update()
|
||
if err != nil {
|
||
logger.Error("from uid update user invite err:", err, req.InviteUid)
|
||
}
|
||
}
|
||
|
||
}
|
||
}
|
||
if sqlErr == model.RecordNotFound {
|
||
user = model.User{
|
||
WxOpenID: resp.OpenID,
|
||
WxUnionID: resp.UnionID,
|
||
LastLoginAt: nowTime,
|
||
MemberLevel: 1,
|
||
//Notify: common.Yes,
|
||
}
|
||
user.Uid = createUid() // 新建uid
|
||
|
||
var eg errgroup.Group
|
||
if req.InviteUid != 0 { // 如果入参有邀请人id，则新增2条邀请记录？
|
||
inviteRecordFirst := &model.UserInviteRecord{
|
||
ToUid: user.Uid,
|
||
FromUid: req.InviteUid,
|
||
Action: 2, // 激活邀请
|
||
SpendType: 1,
|
||
MemberLevel: 0,
|
||
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,
|
||
Action: 1,
|
||
SpendType: 1,
|
||
MemberLevel: 0,
|
||
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 = inviteUser.StoreId
|
||
user.UserType = model.UserTypeConsumer
|
||
user.CooperativeBusinessId = inviteUser.CooperativeBusinessId
|
||
user.CooperativeName = inviteUser.CooperativeName
|
||
|
||
invite := &model.UserInvite{
|
||
FromUid: req.InviteUid,
|
||
UserType: inviteUser.UserType,
|
||
StoreId: inviteUser.StoreId,
|
||
MemberType: model.MemberTypeConsumer,
|
||
ToUid: user.Uid,
|
||
MemberStatus: 1,
|
||
Action: 1,
|
||
SpendType: 1,
|
||
UserInviteRecordId: inviteRecord.ID,
|
||
Scan: 1,
|
||
}
|
||
eg.Go(func() error {
|
||
if err := invite.Create(model.DB); err != nil {
|
||
logger.Error(err)
|
||
RespJson(c, status.InternalServerError, nil)
|
||
return err
|
||
}
|
||
return nil
|
||
})
|
||
}
|
||
|
||
fmt.Println("新用户:", user.WxOpenID)
|
||
eg.Go(func() error {
|
||
if err := user.Create(model.DB); err != nil {
|
||
logger.Error(err)
|
||
RespJson(c, status.InternalServerError, nil)
|
||
return err
|
||
}
|
||
return nil
|
||
})
|
||
err := eg.Wait()
|
||
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
|
||
}
|
||
|
||
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": user.Uid,
|
||
"access_created_at": nowTime,
|
||
})
|
||
return
|
||
}
|
||
|
||
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)
|
||
}
|
||
|
||
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": user.Uid,
|
||
"access_created_at": nowTime,
|
||
//"is_new": isNew,
|
||
//"invite_from_code": inviteCode,
|
||
})
|
||
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)
|
||
}
|
||
|
||
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 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
|
||
ret := m
|
||
RespOK(c, ret)
|
||
return
|
||
}
|
||
|
||
// 找一个可以用的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
|
||
}
|
||
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
_ = model.NewUserQuerySet(model.DB).UidEq(uc.Uid).GetUpdater().SetTel(phone.PhoneNumber).Update()
|
||
|
||
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)
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
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
|
||
}
|
||
|
||
//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
|
||
}
|
||
|
||
//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
|
||
}
|
||
}
|
||
|
||
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)
|
||
}
|