Client/server
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

init: 1.0.0

Browse Source
This commit is contained in:
Chang lue Tsen
2025-04-25 12:08:29 +09:00
commit 8addcc584b
1031 changed files with 76472 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/logic/app/auth/checkLogic.go
+41
View File
@@ -0,0 +1,41 @@
package auth
import (
"context"
"github.com/pkg/errors"
"gorm.io/gorm"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
)
type CheckLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Check Account
func NewCheckLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CheckLogic {
return &CheckLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *CheckLogic) Check(req *types.AppAuthCheckRequest) (resp *types.AppAuthCheckResponse, err error) {
resp = &types.AppAuthCheckResponse{}
_, err = findUserByMethod(l.ctx, l.svcCtx, req.Method, req.Identifier, req.Account, req.AreaCode)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
resp.Status = false
return resp, nil
}
return resp, err
}
resp.Status = true
return
}
internal/logic/app/auth/findUserByMethod.go
+59
View File
@@ -0,0 +1,59 @@
package auth
import (
"context"
"github.com/perfect-panel/ppanel-server/pkg/authmethod"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/pkg/phone"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"gorm.io/gorm"
)
func findUserByMethod(ctx context.Context, svcCtx *svc.ServiceContext, method, identifier, account, areaCode string) (userInfo *user.User, err error) {
var authMethods *user.AuthMethods
switch method {
case authmethod.Email:
authMethods, err = svcCtx.UserModel.FindUserAuthMethodByOpenID(ctx, authmethod.Email, account)
case authmethod.Mobile:
phoneNumber, err := phone.FormatToE164(areaCode, account)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "Invalid phone number")
}
authMethods, err = svcCtx.UserModel.FindUserAuthMethodByOpenID(ctx, authmethod.Mobile, phoneNumber)
if err != nil {
return nil, err
}
case authmethod.Device:
userDevice, err := svcCtx.UserModel.FindOneDeviceByIdentifier(ctx, identifier)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, err
}
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user device imei error")
}
return svcCtx.UserModel.FindOne(ctx, userDevice.UserId)
default:
return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "unknown method")
}
if err != nil {
return nil, err
}
return svcCtx.UserModel.FindOne(ctx, authMethods.UserId)
}
func existError(method string) error {
switch method {
case authmethod.Email:
return errors.Wrapf(xerr.NewErrCode(xerr.EmailExist), "")
case authmethod.Mobile:
return errors.Wrapf(xerr.NewErrCode(xerr.TelephoneExist), "")
case authmethod.Device:
return errors.Wrapf(xerr.NewErrCode(xerr.DeviceExist), "")
default:
return errors.New("unknown method")
}
}
internal/logic/app/auth/getAppConfigLogic.go
+119
View File
@@ -0,0 +1,119 @@
package auth
import (
"context"
"encoding/json"
"fmt"
"strings"
"github.com/perfect-panel/ppanel-server/internal/model/application"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"gorm.io/gorm"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
)
type GetAppConfigLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// GetAppConfig
func NewGetAppConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetAppConfigLogic {
return &GetAppConfigLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetAppConfigLogic) GetAppConfig(req *types.AppConfigRequest) (resp *types.AppConfigResponse, err error) {
resp = &types.AppConfigResponse{}
systems, err := l.svcCtx.SystemModel.GetSiteConfig(l.ctx)
if err != nil {
l.Errorw("[QueryApplicationConfig] GetSiteConfig error: ", logger.Field("error", err.Error()))
}
for _, sysVal := range systems {
if sysVal.Key == "CustomData" {
jsonStr := strings.ReplaceAll(sysVal.Value, "\\", "")
customData := make(map[string]interface{})
if err = json.Unmarshal([]byte(jsonStr), &customData); err != nil {
break
}
website := customData["website"]
if website != nil {
resp.OfficialWebsite = fmt.Sprintf("%v", website)
}
contacts := customData["contacts"]
if contacts != nil {
contactsJson, err := json.Marshal(contacts)
if err == nil {
contactsMap := make(map[string]string)
err = json.Unmarshal(contactsJson, &contactsMap)
if err == nil {
resp.OfficialEmail = fmt.Sprintf("%v", contactsMap["email"])
resp.OfficialTelegram = fmt.Sprintf("%v", contactsMap["telegram"])
resp.OfficialTelephone = fmt.Sprintf("%v", contactsMap["telephone"])
}
}
}
break
}
}
var applications []*application.Application
err = l.svcCtx.ApplicationModel.Transaction(l.ctx, func(tx *gorm.DB) (err error) {
return tx.Model(applications).Preload("ApplicationVersions").Find(&applications).Error
})
if err != nil {
l.Errorw("[QueryApplicationConfig] get application error: ", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get application error: %v", err.Error())
}
if len(applications) == 0 {
return resp, nil
}
isOk := false
for _, app := range applications {
if isOk {
break
}
resp.Application.Name = app.Name
resp.Application.Description = app.Description
applicationVersions := app.ApplicationVersions
if len(applicationVersions) != 0 {
for _, applicationVersion := range applicationVersions {
if applicationVersion.Platform == req.UserAgent {
resp.Application.Id = applicationVersion.ApplicationId
resp.Application.Url = applicationVersion.Url
resp.Application.Version = applicationVersion.Version
resp.Application.VersionDescription = applicationVersion.Description
resp.Application.IsDefault = applicationVersion.IsDefault
isOk = true
break
}
}
}
}
configs, err := l.svcCtx.ApplicationModel.FindOneConfig(l.ctx, 1)
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
l.Logger.Error("[GetAppInfo] FindOneAppConfig error: ", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetAppInfo FindOneAppConfig error: %v", err.Error())
}
resp.EncryptionKey = configs.EncryptionKey
resp.EncryptionMethod = configs.EncryptionMethod
resp.Domains = strings.Split(configs.Domains, ";")
resp.StartupPicture = configs.StartupPicture
resp.StartupPictureSkipTime = configs.StartupPictureSkipTime
resp.InvitationLink = configs.InvitationLink
resp.KrWebsiteId = configs.KrWebsiteId
return
}
internal/logic/app/auth/loginLogic.go
+194
View File
@@ -0,0 +1,194 @@
package auth
import (
"encoding/json"
"fmt"
"time"
"github.com/perfect-panel/ppanel-server/pkg/authmethod"
"github.com/gin-gonic/gin"
"github.com/perfect-panel/ppanel-server/pkg/constant"
"github.com/perfect-panel/ppanel-server/pkg/phone"
"github.com/perfect-panel/ppanel-server/internal/config"
"github.com/perfect-panel/ppanel-server/internal/logic/common"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/jwt"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/uuidx"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"gorm.io/gorm"
)
type LoginLogic struct {
logger.Logger
ctx *gin.Context
svcCtx *svc.ServiceContext
}
// Login
func NewLoginLogic(ctx *gin.Context, svcCtx *svc.ServiceContext) *LoginLogic {
return &LoginLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *LoginLogic) Login(req *types.AppAuthRequest) (resp *types.AppAuthRespone, err error) {
loginStatus := false
var userInfo *user.User
// Record login status
defer func(svcCtx *svc.ServiceContext) {
if userInfo != nil && userInfo.Id != 0 {
if err := svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
UserId: userInfo.Id,
LoginIP: l.ctx.ClientIP(),
UserAgent: l.ctx.Request.UserAgent(),
Success: &loginStatus,
}); err != nil {
l.Errorw("InsertLoginLog Error", logger.Field("error", err.Error()))
}
}
}(l.svcCtx)
resp = &types.AppAuthRespone{}
//query user
userInfo, err = findUserByMethod(l.ctx, l.svcCtx, req.Method, req.Identifier, req.Account, req.AreaCode)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserPasswordError), "user password")
}
return resp, err
}
switch req.Method {
case authmethod.Email:
if !l.svcCtx.Config.Email.Enable {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.EmailNotEnabled), "Email function is not enabled yet")
}
if req.Code != "" {
cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeCacheKey, constant.Security.String(), req.Account)
value, err := l.svcCtx.Redis.Get(l.ctx, cacheKey).Result()
if err != nil {
l.Errorw("Redis Error", logger.Field("error", err.Error()), logger.Field("cacheKey", cacheKey))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
var payload common.CacheKeyPayload
err = json.Unmarshal([]byte(value), &payload)
if err != nil {
l.Errorw("Unmarshal Error", logger.Field("error", err.Error()), logger.Field("value", value))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
if payload.Code != req.Code {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
l.svcCtx.Redis.Del(l.ctx, cacheKey)
} else {
// Verify password
if !tool.VerifyPassWord(req.Password, userInfo.Password) {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserPasswordError), "user password")
}
}
case authmethod.Mobile:
if !l.svcCtx.Config.Mobile.Enable {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SmsNotEnabled), "sms login is not enabled")
}
phoneNumber, err := phone.FormatToE164(req.AreaCode, req.Account)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "Invalid phone number")
}
if req.Code != "" {
cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeTelephoneCacheKey, constant.Security, phoneNumber)
value, err := l.svcCtx.Redis.Get(l.ctx, cacheKey).Result()
if err != nil {
l.Errorw("Redis Error", logger.Field("error", err.Error()), logger.Field("cacheKey", cacheKey))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
if value == "" {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
var payload common.CacheKeyPayload
if err := json.Unmarshal([]byte(value), &payload); err != nil {
l.Errorw("[SendSmsCode]: Unmarshal Error", logger.Field("error", err.Error()), logger.Field("value", value))
}
if payload.Code != req.Code {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
l.svcCtx.Redis.Del(l.ctx, cacheKey)
} else {
// Verify password
if !tool.VerifyPassWord(req.Password, userInfo.Password) {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserPasswordError), "user password")
}
}
case authmethod.Device:
default:
return nil, existError(req.Method)
}
device, err := l.svcCtx.UserModel.FindOneDeviceByIdentifier(l.ctx, req.Identifier)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
if req.Method == authmethod.Device {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "device not exist")
}
//Add User Device
userInfo.UserDevices = append(userInfo.UserDevices, user.Device{
UserAgent: req.UserAgent,
Identifier: req.Identifier,
Ip: l.ctx.ClientIP(),
})
err = l.svcCtx.UserModel.Update(l.ctx, userInfo)
if err != nil {
l.Errorw("[UpdateUserBindDevice] Fail", logger.Field("error", err.Error()))
}
}
} else {
//Change the user who owns the device
if device.UserId != userInfo.Id {
device.UserId = userInfo.Id
}
device.Ip = l.ctx.ClientIP()
err = l.svcCtx.UserModel.UpdateDevice(l.ctx, device)
if err != nil {
l.Errorw("[UpdateUserBindDevice] Fail", logger.Field("error", err.Error()))
}
}
// Generate session id
sessionId := uuidx.NewUUID().String()
// Generate token
token, err := jwt.NewJwtToken(
l.svcCtx.Config.JwtAuth.AccessSecret,
time.Now().Unix(),
l.svcCtx.Config.JwtAuth.AccessExpire,
jwt.WithOption("UserId", userInfo.Id),
jwt.WithOption("SessionId", sessionId),
)
if err != nil {
l.Logger.Error("[UserLogin] token generate error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "token generate error: %v", err.Error())
}
sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
if err = l.svcCtx.Redis.Set(l.ctx, sessionIdCacheKey, userInfo.Id, time.Duration(l.svcCtx.Config.JwtAuth.AccessExpire)*time.Second).Err(); err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "set session id error: %v", err.Error())
}
resp.Token = token
return
}
internal/logic/app/auth/registerLogic.go
+249
View File
@@ -0,0 +1,249 @@
package auth
import (
"encoding/json"
"fmt"
"time"
"github.com/perfect-panel/ppanel-server/pkg/authmethod"
"github.com/gin-gonic/gin"
"github.com/perfect-panel/ppanel-server/internal/config"
"github.com/perfect-panel/ppanel-server/internal/logic/common"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/constant"
"github.com/perfect-panel/ppanel-server/pkg/jwt"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/phone"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/uuidx"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"gorm.io/gorm"
)
type CacheKeyPayload struct {
Code string `json:"code"`
LastAt int64 `json:"lastAt"`
}
type RegisterLogic struct {
logger.Logger
ctx *gin.Context
svcCtx *svc.ServiceContext
}
// Register
func NewRegisterLogic(ctx *gin.Context, svcCtx *svc.ServiceContext) *RegisterLogic {
return &RegisterLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *RegisterLogic) Register(req *types.AppAuthRequest) (resp *types.AppAuthRespone, err error) {
resp = &types.AppAuthRespone{}
var referer *user.User
c := l.svcCtx.Config.Register
// Check if the registration is stopped
if c.StopRegister {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.StopRegister), "stop register")
}
if req.Invite == "" {
if l.svcCtx.Config.Invite.ForcedInvite {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.InviteCodeError), "invite code is required")
}
} else {
// Check if the invite code is valid
referer, err = l.svcCtx.UserModel.FindOneByReferCode(l.ctx, req.Invite)
if err != nil {
l.Errorw("FindOneByReferCode Error", logger.Field("error", err))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.InviteCodeError), "invite code is invalid")
}
}
if req.Password == "" {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.PasswordIsEmpty), "Password required")
}
userInfo, err := findUserByMethod(l.ctx, l.svcCtx, req.Method, req.Identifier, req.Account, req.AreaCode)
if err == nil && userInfo != nil {
return nil, existError(req.Method)
}
if !errors.Is(err, gorm.ErrRecordNotFound) {
return nil, err
}
// Generate password
pwd := tool.EncodePassWord(req.Password)
userInfo = &user.User{
Password: pwd,
}
if referer != nil {
userInfo.RefererId = referer.Id
}
switch req.Method {
case authmethod.Email:
if !l.svcCtx.Config.Email.Enable {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.EmailNotEnabled), "Email function is not enabled yet")
}
if l.svcCtx.Config.Email.EnableVerify {
cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeCacheKey, constant.Register.String(), req.Account)
value, err := l.svcCtx.Redis.Get(l.ctx, cacheKey).Result()
if err != nil {
l.Errorw("Redis Error", logger.Field("error", err.Error()), logger.Field("cacheKey", cacheKey))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
var payload common.CacheKeyPayload
err = json.Unmarshal([]byte(value), &payload)
if err != nil {
l.Errorw("Unmarshal Error", logger.Field("error", err.Error()), logger.Field("value", value))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
if payload.Code != req.Code {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
}
userInfo.AuthMethods = []user.AuthMethods{{
AuthType: authmethod.Email,
AuthIdentifier: req.Account,
}}
case authmethod.Mobile:
if req.AreaCode == "" {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneAreaCodeIsEmpty), "area code required")
}
if !l.svcCtx.Config.Mobile.Enable {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SmsNotEnabled), "sms login is not enabled")
}
phoneNumber, err := phone.FormatToE164(req.AreaCode, req.Account)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "Invalid phone number")
}
cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeTelephoneCacheKey, constant.Register, phoneNumber)
value, err := l.svcCtx.Redis.Get(l.ctx, cacheKey).Result()
if err != nil {
l.Errorw("Redis Error", logger.Field("error", err.Error()), logger.Field("cacheKey", cacheKey))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
var payload CacheKeyPayload
_ = json.Unmarshal([]byte(value), &payload)
if payload.Code != req.Code {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
userInfo.AuthMethods = []user.AuthMethods{{
AuthType: authmethod.Mobile,
AuthIdentifier: phoneNumber,
Verified: true,
}}
case authmethod.Device:
oneDevice, err := l.svcCtx.UserModel.FindOneDeviceByIdentifier(l.ctx, req.Identifier)
if err == nil && oneDevice != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DeviceExist), "device exist")
}
default:
return nil, existError(req.Method)
}
device, err := l.svcCtx.UserModel.FindOneDeviceByIdentifier(l.ctx, req.Identifier)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
//Add User Device
userInfo.UserDevices = append(userInfo.UserDevices, user.Device{
Ip: l.ctx.ClientIP(),
Identifier: req.Identifier,
UserAgent: req.UserAgent,
})
} else {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
}
} else {
//Delete Other User Device
err = l.svcCtx.UserModel.DeleteDevice(l.ctx, device.Id)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "delete old user device failed: %v", err.Error())
} else {
//User Add Device
userInfo.UserDevices = append(userInfo.UserDevices, user.Device{
Ip: l.ctx.ClientIP(),
Identifier: req.Identifier,
UserAgent: req.UserAgent,
})
}
}
err = l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
// Save user information
if err := db.Create(userInfo).Error; err != nil {
return err
}
// Generate ReferCode
userInfo.ReferCode = uuidx.UserInviteCode(userInfo.Id)
// Update ReferCode
if err := db.Model(&user.User{}).Where("id = ?", userInfo.Id).Update("refer_code", userInfo.ReferCode).Error; err != nil {
return err
}
if l.svcCtx.Config.Register.EnableTrial {
// Active trial
if err = l.activeTrial(userInfo.Id); err != nil {
return err
}
}
return nil
})
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert user info failed: %v", err.Error())
}
// Generate session id
sessionId := uuidx.NewUUID().String()
// Generate token
token, err := jwt.NewJwtToken(
l.svcCtx.Config.JwtAuth.AccessSecret,
time.Now().Unix(),
l.svcCtx.Config.JwtAuth.AccessExpire,
jwt.WithOption("UserId", userInfo.Id),
jwt.WithOption("SessionId", sessionId),
)
if err != nil {
l.Logger.Error("[UserLogin] token generate error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "token generate error: %v", err.Error())
}
sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
if err := l.svcCtx.Redis.Set(l.ctx, sessionIdCacheKey, userInfo.Id, time.Duration(l.svcCtx.Config.JwtAuth.AccessExpire)*time.Second).Err(); err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "set session id error: %v", err.Error())
}
resp.Token = token
return
}
func (l *RegisterLogic) activeTrial(uid int64) error {
sub, err := l.svcCtx.SubscribeModel.FindOne(l.ctx, l.svcCtx.Config.Register.TrialSubscribe)
if err != nil {
return err
}
userSub := &user.Subscribe{
Id: 0,
UserId: uid,
OrderId: 0,
SubscribeId: sub.Id,
StartTime: time.Now(),
ExpireTime: tool.AddTime(l.svcCtx.Config.Register.TrialTimeUnit, l.svcCtx.Config.Register.TrialTime, time.Now()),
Traffic: sub.Traffic,
Download: 0,
Upload: 0,
Token: uuidx.SubscribeToken(fmt.Sprintf("Trial-%v", uid)),
UUID: uuidx.NewUUID().String(),
Status: 1,
}
return l.svcCtx.UserModel.InsertSubscribe(l.ctx, userSub)
}
internal/logic/app/auth/resetPasswordLogic.go
+161
View File
@@ -0,0 +1,161 @@
package auth
import (
"encoding/json"
"fmt"
"time"
"github.com/perfect-panel/ppanel-server/pkg/authmethod"
"github.com/gin-gonic/gin"
"github.com/perfect-panel/ppanel-server/pkg/constant"
"github.com/perfect-panel/ppanel-server/pkg/phone"
"github.com/perfect-panel/ppanel-server/internal/config"
"github.com/perfect-panel/ppanel-server/internal/logic/common"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/jwt"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/uuidx"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"gorm.io/gorm"
)
type ResetPasswordLogic struct {
logger.Logger
ctx *gin.Context
svcCtx *svc.ServiceContext
}
// Reset Password
func NewResetPasswordLogic(ctx *gin.Context, svcCtx *svc.ServiceContext) *ResetPasswordLogic {
return &ResetPasswordLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *ResetPasswordLogic) ResetPassword(req *types.AppAuthRequest) (resp *types.AppAuthRespone, err error) {
resp = &types.AppAuthRespone{}
userInfo, err := findUserByMethod(l.ctx, l.svcCtx, req.Method, req.Identifier, req.Account, req.AreaCode)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "query user info failed")
}
l.Errorw("FindOneByEmail Error", logger.Field("error", err))
return nil, err
}
switch req.Method {
case authmethod.Mobile:
if !l.svcCtx.Config.Mobile.Enable {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.SmsNotEnabled), "sms login is not enabled")
}
phoneNumber, err := phone.FormatToE164(req.AreaCode, req.Account)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "Invalid phone number")
}
cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeTelephoneCacheKey, constant.Security, phoneNumber)
value, err := l.svcCtx.Redis.Get(l.ctx, cacheKey).Result()
if err != nil {
l.Errorw("Redis Error", logger.Field("error", err.Error()), logger.Field("cacheKey", cacheKey))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
var payload common.CacheKeyPayload
err = json.Unmarshal([]byte(value), &payload)
if err != nil {
l.Errorw("Unmarshal Error", logger.Field("error", err.Error()), logger.Field("value", value))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
if payload.Code != req.Code {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
case authmethod.Email:
if !l.svcCtx.Config.Email.Enable {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.EmailNotEnabled), "Email function is not enabled yet")
}
cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeCacheKey, constant.Security.String(), req.Account)
value, err := l.svcCtx.Redis.Get(l.ctx, cacheKey).Result()
if err != nil {
l.Errorw("Redis Error", logger.Field("error", err.Error()), logger.Field("cacheKey", cacheKey))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
var payload CacheKeyPayload
err = json.Unmarshal([]byte(value), &payload)
if err != nil {
l.Errorw("Unmarshal Error", logger.Field("error", err.Error()), logger.Field("value", value))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
if payload.Code != req.Code {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
}
default:
return nil, errors.New("unknown method")
}
userInfo.Password = tool.EncodePassWord(req.Password)
err = l.svcCtx.UserModel.Update(l.ctx, userInfo)
if err != nil {
l.Errorw("UpdateUser Error", logger.Field("error", err))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update user info failed: %v", err.Error())
}
device, err := l.svcCtx.UserModel.FindOneDeviceByIdentifier(l.ctx, req.Identifier)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
//Add User Device
userInfo.UserDevices = append(userInfo.UserDevices, user.Device{
Ip: l.ctx.ClientIP(),
Identifier: req.Identifier,
UserAgent: req.UserAgent,
})
} else {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
}
} else {
if device.UserId != userInfo.Id {
//Change the user who owns the device
if device.UserId != userInfo.Id {
device.UserId = userInfo.Id
}
device.Ip = l.ctx.ClientIP()
err = l.svcCtx.UserModel.UpdateDevice(l.ctx, device)
if err != nil {
l.Errorw("[UpdateUserBindDevice] Fail", logger.Field("error", err.Error()))
}
}
}
// Generate session id
sessionId := uuidx.NewUUID().String()
// Generate token
token, err := jwt.NewJwtToken(
l.svcCtx.Config.JwtAuth.AccessSecret,
time.Now().Unix(),
l.svcCtx.Config.JwtAuth.AccessExpire,
jwt.WithOption("UserId", userInfo.Id),
jwt.WithOption("SessionId", sessionId),
)
if err != nil {
l.Logger.Error("[UserLogin] token generate error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "token generate error: %v", err.Error())
}
sessionIdCacheKey := fmt.Sprintf("%v:%v", config.SessionIdKey, sessionId)
if err := l.svcCtx.Redis.Set(l.ctx, sessionIdCacheKey, userInfo.Id, time.Duration(l.svcCtx.Config.JwtAuth.AccessExpire)*time.Second).Err(); err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "set session id error: %v", err.Error())
}
resp.Token = token
return
}