351 lines
8.8 KiB
Go
351 lines
8.8 KiB
Go
package controller
|
|
|
|
import (
|
|
"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"
|
|
"strconv"
|
|
|
|
"mh-server/model"
|
|
"time"
|
|
)
|
|
|
|
func AuthLogin(c *gin.Context) {
|
|
req := struct {
|
|
Code string `json:"code" binding:"required"`
|
|
}{}
|
|
|
|
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)
|
|
|
|
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
|
|
}
|
|
|
|
//var lastUser model.User
|
|
//if err := model.NewUserQuerySet(model.DB).OrderDescByID().One(&lastUser); err != nil && err != model.RecordNotFound {
|
|
// logger.Error(err)
|
|
// RespJson(c, status.InternalServerError, nil)
|
|
// return
|
|
//}
|
|
|
|
now := time.Now()
|
|
// 不存在则创建 新用户
|
|
if sqlErr == model.RecordNotFound {
|
|
user = model.User{
|
|
WxOpenID: resp.OpenID,
|
|
WxUnionID: resp.UnionID,
|
|
LastLoginAt: now,
|
|
MemberLevel: 1,
|
|
//Notify: common.Yes,
|
|
}
|
|
fmt.Println("新用户:", user.WxOpenID)
|
|
|
|
user.Uid = createUid()
|
|
if err := user.Create(model.DB); 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
|
|
}
|
|
|
|
RespJson(c, status.OK, map[string]interface{}{
|
|
"access_token": newAccessToken,
|
|
"access_expire": config.AppConfig.JwtUserAccessExpire,
|
|
"uid": user.Uid,
|
|
"access_created_at": now,
|
|
})
|
|
return
|
|
}
|
|
|
|
fmt.Println(" user:", user.Uid)
|
|
// 旧用户
|
|
newAccessToken, err := auth.CreateAccessToken(user.Uid)
|
|
if err != nil {
|
|
logger.Error(err)
|
|
RespJson(c, status.InternalServerError, nil)
|
|
}
|
|
|
|
//isNew := false
|
|
//// 用户没有授权 下次进入不会提示
|
|
//if user.WxOpenID == "" {
|
|
// isNew = true
|
|
//}
|
|
inviteCode := strconv.FormatUint(uint64(user.ID), 32)
|
|
|
|
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,
|
|
"uid": user.Uid,
|
|
"access_created_at": now,
|
|
//"is_new": isNew,
|
|
"invite_from_code": inviteCode,
|
|
})
|
|
fmt.Println("sqlErr:", sqlErr)
|
|
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
|
|
}
|
|
|
|
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)
|
|
//}
|