init: 1.0.0

internal/logic/auth/checkUserLogic.go

@@ -0,0 +1,37 @@
+package auth
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"gorm.io/gorm"
+)
+
+type CheckUserLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewCheckUserLogic Check user is exist
+func NewCheckUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CheckUserLogic {
+	return &CheckUserLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CheckUserLogic) CheckUser(req *types.CheckUserRequest) (resp *types.CheckUserResponse, err error) {
+	authMethod, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "email", req.Email)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find user by email error: %v", err.Error())
+	}
+	return &types.CheckUserResponse{
+		Exist: authMethod.UserId != 0,
+	}, nil
+}

internal/logic/auth/checkUserTelephoneLogic.go

@@ -0,0 +1,44 @@
+package auth
+
+import (
+	"context"
+
+	"github.com/perfect-panel/ppanel-server/pkg/phone"
+	"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 CheckUserTelephoneLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Check user telephone is exist
+func NewCheckUserTelephoneLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CheckUserTelephoneLogic {
+	return &CheckUserTelephoneLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *CheckUserTelephoneLogic) CheckUserTelephone(req *types.TelephoneCheckUserRequest) (resp *types.TelephoneCheckUserResponse, err error) {
+	phoneNumber, err := phone.FormatToE164(req.TelephoneAreaCode, req.Telephone)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "Invalid phone number")
+	}
+	authMethods, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "mobile", phoneNumber)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find user by email error: %v", err.Error())
+	}
+
+	return &types.TelephoneCheckUserResponse{
+		Exist: authMethods.UserId != 0,
+	}, nil
+}

internal/logic/auth/oauth/appleLoginCallbackLogic.go

@@ -0,0 +1,40 @@
+package oauth
+
+import (
+	"context"
+	"fmt"
+	"net/http"
+	"net/url"
+
+	"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 AppleLoginCallbackLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Apple Login Callback
+func NewAppleLoginCallbackLogic(ctx context.Context, svcCtx *svc.ServiceContext) *AppleLoginCallbackLogic {
+	return &AppleLoginCallbackLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *AppleLoginCallbackLogic) AppleLoginCallback(req *types.AppleLoginCallbackRequest, r *http.Request, w http.ResponseWriter) error {
+	// validate the state code
+	result, err := l.svcCtx.Redis.Get(l.ctx, fmt.Sprintf("apple:%s", req.State)).Result()
+	if err != nil {
+		l.Errorw("get apple state code from redis failed", logger.Field("error", err.Error()), logger.Field("code", req.State))
+		http.Redirect(w, r, l.svcCtx.Config.Site.Host, http.StatusTemporaryRedirect)
+		return nil
+	}
+	http.Redirect(w, r, fmt.Sprintf("%s?method=apple&code=%s&state=%s", result, req.Code, req.State), http.StatusFound)
+	l.Infow("redirect to apple login page", logger.Field("url", fmt.Sprintf("%s?method=apple&code=%s&state=%s", result, url.QueryEscape(req.Code), req.State)))
+	return nil
+}

internal/logic/auth/oauth/oAuthLoginGetTokenLogic.go

@@ -0,0 +1,344 @@
+package oauth
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/auth"
+	"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/oauth/apple"
+	"github.com/perfect-panel/ppanel-server/pkg/oauth/google"
+	"github.com/perfect-panel/ppanel-server/pkg/oauth/telegram"
+	"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 googleRequest struct {
+	Code  string `json:"code"`
+	State string `json:"state"`
+}
+type OAuthLoginGetTokenLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewOAuthLoginGetTokenLogic OAuth login get token
+func NewOAuthLoginGetTokenLogic(ctx context.Context, svcCtx *svc.ServiceContext) *OAuthLoginGetTokenLogic {
+	return &OAuthLoginGetTokenLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *OAuthLoginGetTokenLogic) OAuthLoginGetToken(req *types.OAuthLoginGetTokenRequest, ip, userAgent string) (resp *types.LoginResponse, 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:   ip,
+				UserAgent: userAgent,
+				Success:   &loginStatus,
+			}); err != nil {
+				l.Errorw("error insert login log: %v", logger.Field("error", err.Error()))
+			}
+		}
+	}(l.svcCtx)
+	switch req.Method {
+	case "google":
+		userInfo, err = l.google(req)
+	case "apple":
+		userInfo, err = l.apple(req)
+	case "telegram":
+		userInfo, err = l.telegram(req)
+	default:
+		l.Errorw("oauth login method not support: %v", logger.Field("method", req.Method))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "oauth login method not support: %v", req.Method)
+	}
+	if err != nil {
+		return nil, err
+	}
+	// 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())
+	}
+	loginStatus = true
+	return &types.LoginResponse{
+		Token: token,
+	}, nil
+}
+
+func (l *OAuthLoginGetTokenLogic) google(req *types.OAuthLoginGetTokenRequest) (*user.User, error) {
+	var request googleRequest
+	err := tool.CloneMapToStruct(req.Callback.(map[string]interface{}), &request)
+	if err != nil {
+		l.Errorw("error CloneMapToStruct: %v", logger.Field("error", err.Error()))
+		return nil, err
+	}
+	// validate the state code
+	redirect, err := l.svcCtx.Redis.Get(l.ctx, fmt.Sprintf("google:%s", request.State)).Result()
+	if err != nil {
+		l.Errorw("error get google state code: %v", logger.Field("error", err.Error()))
+		return nil, err
+	}
+	// get google config
+	authMethod, err := l.svcCtx.AuthModel.FindOneByMethod(l.ctx, "google")
+	if err != nil {
+		l.Errorw("error find google auth method: %v", logger.Field("error", err.Error()))
+		return nil, err
+	}
+	var cfg auth.GoogleAuthConfig
+	err = cfg.Unmarshal(authMethod.Config)
+	if err != nil {
+		l.Errorw("error unmarshal google config: %v", logger.Field("config", authMethod.Config), logger.Field("error", err.Error()))
+		return nil, err
+	}
+	client := google.New(&google.Config{
+		ClientID:     cfg.ClientId,
+		ClientSecret: cfg.ClientSecret,
+		RedirectURL:  redirect,
+	})
+	token, err := client.Exchange(l.ctx, request.Code)
+	if err != nil {
+		l.Errorw("error exchange google token: %v", logger.Field("error", err.Error()))
+		return nil, err
+	}
+	googleUserInfo, err := client.GetUserInfo(token.AccessToken)
+	if err != nil {
+		l.Errorw("error get google user info: %v", logger.Field("error", err.Error()))
+		return nil, err
+	}
+	// query user info
+	userAuthMethod, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "google", googleUserInfo.OpenID)
+	if err != nil {
+		if errors.As(err, &gorm.ErrRecordNotFound) {
+			return l.register(googleUserInfo.Email, googleUserInfo.Picture, "google", googleUserInfo.OpenID)
+		}
+		return nil, err
+	}
+	return l.svcCtx.UserModel.FindOne(l.ctx, userAuthMethod.UserId)
+}
+
+func (l *OAuthLoginGetTokenLogic) apple(req *types.OAuthLoginGetTokenRequest) (*user.User, error) {
+	// validate the state code
+	_, err := l.svcCtx.Redis.Get(l.ctx, fmt.Sprintf("apple:%s", req.Callback.(map[string]interface{})["state"])).Result()
+	if err != nil {
+		l.Errorw("[AppleLoginCallback] Get State code error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "get apple state code failed: %v", err.Error())
+	}
+	appleAuth, err := l.svcCtx.AuthModel.FindOneByMethod(l.ctx, "apple")
+	if err != nil {
+		l.Errorw("[AppleLoginCallback] FindOneByMethod error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find apple auth method failed: %v", err.Error())
+	}
+	var appleCfg auth.AppleAuthConfig
+	err = appleCfg.Unmarshal(appleAuth.Config)
+	if err != nil {
+		l.Errorw("[AppleLoginCallback] Unmarshal error", logger.Field("error", err.Error()), logger.Field("config", appleAuth.Config))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "unmarshal apple config failed: %v", err.Error())
+	}
+
+	client, err := apple.New(apple.Config{
+		ClientID:     appleCfg.ClientId,
+		TeamID:       appleCfg.TeamID,
+		KeyID:        appleCfg.KeyID,
+		ClientSecret: appleCfg.ClientSecret,
+		RedirectURI:  appleCfg.RedirectURL,
+	})
+	if err != nil {
+		l.Errorw("[AppleLoginCallback] New apple client error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "new apple client failed: %v", err.Error())
+	}
+	// verify web token
+	resp, err := client.VerifyWebToken(l.ctx, req.Callback.(map[string]interface{})["code"].(string))
+	if err != nil {
+		l.Errorw("[AppleLoginCallback] VerifyWebToken error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "verify web token failed: %v", err.Error())
+	}
+	if resp.Error != "" {
+		l.Errorw("[AppleLoginCallback] VerifyWebToken error", logger.Field("error", resp.Error))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "verify web token failed: %v", resp.Error)
+	}
+	// query apple user unique id
+	appleUnique, err := apple.GetUniqueID(resp.IDToken)
+	if err != nil {
+		l.Errorw("[AppleLoginCallback] GetUniqueID error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "get apple unique id failed: %v", err.Error())
+	}
+	// get apple user info
+	appleUserInfo, err := apple.GetClaims(resp.AccessToken)
+	if err != nil {
+		l.Errorw("[AppleLoginCallback] GetClaims error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "get apple user info failed: %v", err.Error())
+	}
+	// query user by apple unique id
+	userAuthMethod, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "apple", appleUnique)
+	if err != nil {
+		// if user not exist, handle register
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return l.register((*appleUserInfo)["email"].(string), "", "apple", appleUnique)
+		}
+		l.Errorw("[AppleLoginCallback] FindUserAuthMethodByOpenID error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find user auth method by openid failed: %v", err.Error())
+	}
+	// query user info
+	userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, userAuthMethod.UserId)
+
+	if err != nil {
+		l.Errorw(
+			"[AppleLoginCallback] FindOne error",
+			logger.Field("error", err.Error()),
+		)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find user info failed: %v", err.Error())
+	}
+
+	return userInfo, nil
+}
+
+func (l *OAuthLoginGetTokenLogic) telegram(req *types.OAuthLoginGetTokenRequest) (*user.User, error) {
+	appleAuth, err := l.svcCtx.AuthModel.FindOneByMethod(l.ctx, "telegram")
+	if err != nil {
+		l.Errorw("[OAuthLoginGetToken] FindOneByMethod error", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find telegram auth method failed: %v", err.Error())
+	}
+	var telegramCfg auth.TelegramAuthConfig
+	err = json.Unmarshal([]byte(appleAuth.Config), &telegramCfg)
+	if err != nil {
+		l.Errorw("[OAuthLoginGetToken] Unmarshal error", logger.Field("error", err.Error()), logger.Field("config", appleAuth.Config))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "unmarshal telegram config failed: %v", err.Error())
+	}
+	encodeText := req.Callback.(map[string]interface{})["tgAuthResult"].(string)
+	// base64 decode
+	callbackData, err := telegram.ParseAndValidateBase64([]byte(encodeText), telegramCfg.BotToken)
+	if err != nil {
+		l.Errorw("[TelegramLoginCallback] ParseAndValidateBase64 error", logger.Field("error", err.Error()))
+		return nil, err
+	}
+	// 验证数据有效期
+	if time.Now().Unix()-*callbackData.AuthDate > 86400 {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "auth date expired")
+	}
+	// query user auth info
+	userAuthMethod, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "telegram", fmt.Sprintf("%v", *callbackData.Id))
+	if err != nil {
+		if errors.As(err, &gorm.ErrRecordNotFound) {
+			return l.register(fmt.Sprintf("%v@%s", *callbackData.Id, "qq.com"), *callbackData.PhotoUrl, "telegram", fmt.Sprintf("%v", callbackData.Id))
+		}
+	}
+	// query user info
+	userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, userAuthMethod.UserId)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find user info failed: %v", err.Error())
+	}
+	return userInfo, nil
+}
+
+func (l *OAuthLoginGetTokenLogic) register(email, avatar, method, openid string) (*user.User, error) {
+	if l.svcCtx.Config.Invite.ForcedInvite {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.InviteCodeError), "invite code is required")
+	}
+	var userInfo *user.User
+	err := l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
+		err := db.Model(&user.User{}).Where("email = ?", email).First(&userInfo).Error
+		if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+			return err
+		}
+		if userInfo.Id != 0 {
+			return errors.Wrapf(xerr.NewErrCode(xerr.UserExist), "user email exist: %v", email)
+		}
+		userInfo = &user.User{
+			Avatar: avatar,
+		}
+		if err := db.Create(userInfo).Error; err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create user info failed: %v", err.Error())
+		}
+		// Generate ReferCode
+		userInfo.ReferCode = uuidx.UserInviteCode(userInfo.Id)
+		// Update ReferCode
+		err = db.Where("id = ?", userInfo.Id).Update("refer_code", userInfo.ReferCode).Error
+		if err != nil {
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update refer code failed: %v", err.Error())
+		}
+		authMethod := &user.AuthMethods{
+			UserId:         userInfo.Id,
+			AuthType:       method,
+			AuthIdentifier: openid,
+			Verified:       true,
+		}
+		if err = db.Create(authMethod).Error; err != nil {
+			l.Errorw("error create auth method: %v", logger.Field("error", err.Error()))
+			return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create auth method failed: %v", err.Error())
+		}
+		if email != "" {
+			authMethod = &user.AuthMethods{
+				UserId:         userInfo.Id,
+				AuthType:       "email",
+				AuthIdentifier: email,
+				Verified:       true,
+			}
+			if err := db.Create(authMethod).Error; err != nil {
+				l.Errorw("error create auth method: %v", logger.Field("error", err.Error()))
+				return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create auth method failed: %v", err.Error())
+			}
+		}
+		if l.svcCtx.Config.Register.EnableTrial {
+			// Active trial
+			if err = l.activeTrial(userInfo.Id); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	return userInfo, err
+}
+
+func (l *OAuthLoginGetTokenLogic) 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/auth/oauth/oAuthLoginLogic.go

@@ -0,0 +1,134 @@
+package oauth
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/auth"
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/oauth/google"
+	"github.com/perfect-panel/ppanel-server/pkg/oauth/telegram"
+	"github.com/perfect-panel/ppanel-server/pkg/random"
+	"github.com/perfect-panel/ppanel-server/pkg/xerr"
+	"github.com/pkg/errors"
+	"golang.org/x/oauth2"
+)
+
+type OAuthLoginLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// OAuth login
+func NewOAuthLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *OAuthLoginLogic {
+	return &OAuthLoginLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *OAuthLoginLogic) OAuthLogin(req *types.OAthLoginRequest) (resp *types.OAuthLoginResponse, err error) {
+	var uri string
+	switch req.Method {
+	case "google":
+		uri, err = l.google(req)
+	case "apple":
+		uri, err = l.apple(req)
+	case "telegram":
+		uri, err = l.telegram(req)
+	case "github":
+		uri, err = l.github()
+	case "facebook":
+		uri, err = l.facebook()
+
+	}
+	if err != nil {
+		l.Errorw("OAuthLogin ", logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "OAuthLogin: %v", err.Error())
+	}
+	return &types.OAuthLoginResponse{
+		Redirect: uri,
+	}, nil
+}
+
+func (l *OAuthLoginLogic) google(req *types.OAthLoginRequest) (string, error) {
+	authMethod, err := l.svcCtx.AuthModel.FindOneByMethod(l.ctx, "google")
+	if err != nil {
+		return "", err
+	}
+	var cfg auth.GoogleAuthConfig
+	err = json.Unmarshal([]byte(authMethod.Config), &cfg)
+	if err != nil {
+		l.Errorw("error unmarshal google config: %v", logger.Field("config", authMethod.Config), logger.Field("error", err.Error()))
+		return "", err
+	}
+	client := google.New(&google.Config{
+		ClientID:     cfg.ClientId,
+		ClientSecret: cfg.ClientSecret,
+		RedirectURL:  req.Redirect,
+	})
+	// generate the state code
+	code := random.KeyNew(8, 1)
+	// save the state code
+	err = l.svcCtx.Redis.Set(l.ctx, fmt.Sprintf("google:%s", code), req.Redirect, 5*60*time.Second).Err()
+	if err != nil {
+		return "", err
+	}
+	uri := client.AuthCodeURL(code, oauth2.AccessTypeOffline)
+	return uri, nil
+}
+
+func (l *OAuthLoginLogic) facebook() (string, error) {
+	return "", nil
+}
+func (l *OAuthLoginLogic) apple(req *types.OAthLoginRequest) (string, error) {
+	authMethod, err := l.svcCtx.AuthModel.FindOneByMethod(l.ctx, "apple")
+	if err != nil {
+		return "", err
+	}
+	var cfg auth.AppleAuthConfig
+	err = json.Unmarshal([]byte(authMethod.Config), &cfg)
+	if err != nil {
+		l.Errorw("error unmarshal apple config: %v", logger.Field("config", authMethod.Config), logger.Field("error", err.Error()))
+		return "", err
+	}
+	uri := "https://appleid.apple.com/auth/authorize?client_id=%s&redirect_uri=%s&response_type=code&state=%s&scope=name email&response_mode=form_post"
+	// generate the state code
+	code := random.KeyNew(8, 1)
+	// save the state code
+	err = l.svcCtx.Redis.Set(l.ctx, fmt.Sprintf("apple:%s", code), req.Redirect, 5*60*time.Second).Err()
+	if err != nil {
+		l.Errorw("error save state code to redis: %v", logger.Field("code", code), logger.Field("error", err.Error()))
+	}
+	return fmt.Sprintf(uri, cfg.ClientId, fmt.Sprintf("%s/v1/auth/oauth/callback/apple", cfg.RedirectURL), code), nil
+}
+func (l *OAuthLoginLogic) github() (string, error) {
+	return "", nil
+}
+func (l *OAuthLoginLogic) telegram(req *types.OAthLoginRequest) (string, error) {
+	authMethod, err := l.svcCtx.AuthModel.FindOneByMethod(l.ctx, "telegram")
+	if err != nil {
+		return "", err
+	}
+	var cfg auth.TelegramAuthConfig
+	err = json.Unmarshal([]byte(authMethod.Config), &cfg)
+	if err != nil {
+		l.Errorw("error unmarshal apple config: %v", logger.Field("config", authMethod.Config), logger.Field("error", err.Error()))
+		return "", err
+	}
+	// generate the state code
+	code := random.KeyNew(8, 1)
+	// save the state code
+	err = l.svcCtx.Redis.Set(l.ctx, fmt.Sprintf("apple:%s", code), req.Redirect, 5*60*time.Second).Err()
+	if err != nil {
+		l.Errorw("error save state code to redis", logger.Field("code", code), logger.Field("error", err.Error()))
+		return "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "error save state code to redis")
+	}
+	return telegram.GenerateTelegramOAuthURL(cfg.BotToken, code, req.Redirect), nil
+}

internal/logic/auth/resetPasswordLogic.go

@@ -0,0 +1,118 @@
+package auth
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/model/user"
+	"github.com/perfect-panel/ppanel-server/pkg/jwt"
+	"github.com/perfect-panel/ppanel-server/pkg/uuidx"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/pkg/constant"
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+	"github.com/perfect-panel/ppanel-server/pkg/tool"
+	"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"
+)
+
+type ResetPasswordLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewResetPasswordLogic Reset password
+func NewResetPasswordLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ResetPasswordLogic {
+	return &ResetPasswordLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ResetPasswordLogic) ResetPassword(req *types.ResetPasswordRequest) (resp *types.LoginResponse, err error) {
+	var userInfo *user.User
+	loginStatus := false
+
+	defer func() {
+		if userInfo.Id != 0 && loginStatus {
+			if err := l.svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
+				UserId:    userInfo.Id,
+				LoginIP:   req.IP,
+				UserAgent: req.UserAgent,
+				Success:   &loginStatus,
+			}); err != nil {
+				l.Logger.Error("[ResetPassword] insert login log error", logger.Field("error", err.Error()))
+			}
+		}
+	}()
+
+	cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeCacheKey, constant.Security, req.Email)
+	// Check the verification code
+	if value, err := l.svcCtx.Redis.Get(l.ctx, cacheKey).Result(); err != nil {
+		l.Errorw("Verification code error", logger.Field("cacheKey", cacheKey), logger.Field("error", err.Error()))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "Verification code error")
+	} else {
+		var payload CacheKeyPayload
+		if err := json.Unmarshal([]byte(value), &payload); err != nil {
+			l.Errorw("Unmarshal errors", logger.Field("cacheKey", cacheKey), logger.Field("error", err.Error()), logger.Field("value", value))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "Verification code error")
+		}
+		if payload.Code != req.Code {
+			l.Errorw("Verification code error", logger.Field("cacheKey", cacheKey), logger.Field("error", "Verification code error"), logger.Field("reqCode", req.Code), logger.Field("payloadCode", payload.Code))
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "Verification code error")
+		}
+	}
+
+	// Check user
+	authMethod, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "email", req.Email)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "user email not exist: %v", req.Email)
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find user by email error: %v", err.Error())
+	}
+
+	userInfo, err = l.svcCtx.UserModel.FindOne(l.ctx, authMethod.UserId)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "user email not exist: %v", req.Email)
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
+	}
+
+	// Update password
+	userInfo.Password = tool.EncodePassWord(req.Password)
+	if err := l.svcCtx.UserModel.Update(l.ctx, userInfo); err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update 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())
+	}
+	loginStatus = true
+	return &types.LoginResponse{
+		Token: token,
+	}, nil
+}

internal/logic/auth/telephoneLoginLogic.go

@@ -0,0 +1,135 @@
+package auth
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"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 TelephoneLoginLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// User Telephone login
+func NewTelephoneLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TelephoneLoginLogic {
+	return &TelephoneLoginLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TelephoneLoginLogic) TelephoneLogin(req *types.TelephoneLoginRequest, r *http.Request, ip string) (resp *types.LoginResponse, err error) {
+	phoneNumber, err := phone.FormatToE164(req.TelephoneAreaCode, req.Telephone)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "Invalid phone number")
+	}
+	if !l.svcCtx.Config.Mobile.Enable {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SmsNotEnabled), "sms login is not enabled")
+	}
+	loginStatus := false
+	var userInfo *user.User
+	// Record login status
+	defer func(svcCtx *svc.ServiceContext) {
+		if userInfo.Id != 0 {
+			if err := svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
+				UserId:    userInfo.Id,
+				LoginIP:   ip,
+				UserAgent: r.UserAgent(),
+				Success:   &loginStatus,
+			}); err != nil {
+				l.Logger.Error("[UserLogin] insert login log error", logger.Field("error", err.Error()))
+			}
+		}
+	}(l.svcCtx)
+
+	authMethodInfo, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "mobile", phoneNumber)
+	if err != nil {
+		if errors.As(err, gorm.ErrRecordNotFound) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "user telephone not exist: %v", req.Telephone)
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
+	}
+
+	userInfo, err = l.svcCtx.UserModel.FindOne(l.ctx, authMethodInfo.UserId)
+	if err != nil {
+		if errors.As(err, gorm.ErrRecordNotFound) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "user telephone not exist: %v", req.Telephone)
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
+	}
+
+	if req.Password == "" && req.TelephoneCode == "" {
+		return nil, xerr.NewErrCodeMsg(xerr.InvalidParams, "password and telephone code is empty")
+	}
+
+	if req.TelephoneCode == "" {
+		// Verify password
+		if !tool.VerifyPassWord(req.Password, userInfo.Password) {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserPasswordError), "user password")
+		}
+	} else {
+		cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeTelephoneCacheKey, constant.ParseVerifyType(uint8(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.TelephoneCode {
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
+		}
+		l.svcCtx.Redis.Del(l.ctx, cacheKey)
+	}
+
+	// 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())
+	}
+	loginStatus = true
+	return &types.LoginResponse{
+		Token: token,
+	}, nil
+}

internal/logic/auth/telephoneResetPasswordLogic.go

@@ -0,0 +1,106 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"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 TelephoneResetPasswordLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Reset password
+func NewTelephoneResetPasswordLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TelephoneResetPasswordLogic {
+	return &TelephoneResetPasswordLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TelephoneResetPasswordLogic) TelephoneResetPassword(req *types.TelephoneResetPasswordRequest) (resp *types.LoginResponse, err error) {
+	code := req.Code
+
+	phoneNumber, err := phone.FormatToE164(req.TelephoneAreaCode, req.Telephone)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "Invalid phone number")
+	}
+
+	if l.svcCtx.Config.Mobile.Enable {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SmsNotEnabled), "sms login is not enabled")
+	}
+
+	// if the email verification is enabled, the verification code is required
+	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 != code {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.VerifyCodeError), "code error")
+	}
+
+	authMethods, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "mobile", phoneNumber)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		l.Errorw("FindOneByTelephone Error", logger.Field("error", err))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
+	}
+	if authMethods.UserId == 0 {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "user telephone exist: %v", phoneNumber)
+	}
+
+	// Check if the user exists
+	userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, authMethods.UserId)
+	if err != nil {
+		l.Errorw("FindOneByTelephone Error", logger.Field("error", err))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
+	}
+
+	// Generate password
+	pwd := tool.EncodePassWord(req.Password)
+	userInfo.Password = pwd
+	err = l.svcCtx.UserModel.Update(l.ctx, userInfo)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "update user password 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.Errorw("[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())
+	}
+	return &types.LoginResponse{
+		Token: token,
+	}, nil
+}

internal/logic/auth/telephoneUserRegisterLogic.go

@@ -0,0 +1,182 @@
+package auth
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/pkg/constant"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"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/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 TelephoneUserRegisterLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewTelephoneUserRegisterLogic User Telephone register
+func NewTelephoneUserRegisterLogic(ctx context.Context, svcCtx *svc.ServiceContext) *TelephoneUserRegisterLogic {
+	return &TelephoneUserRegisterLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *TelephoneUserRegisterLogic) TelephoneUserRegister(req *types.TelephoneRegisterRequest) (resp *types.LoginResponse, err error) {
+	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 !phone.Check(req.TelephoneAreaCode, req.Telephone) {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "telephone number error")
+	}
+
+	if !l.svcCtx.Config.Mobile.Enable {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.SmsNotEnabled), "sms login is not enabled")
+	}
+
+	phoneNumber, err := phone.FormatToE164(req.TelephoneAreaCode, req.Telephone)
+	if err != nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.TelephoneError), "Invalid phone number")
+	}
+
+	// if the email verification is enabled, the verification code is required
+	cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeTelephoneCacheKey, constant.ParseVerifyType(uint8(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
+	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)
+	// Check if the user exists
+	_, err = l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "mobile", phoneNumber)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		l.Errorw("FindOneByTelephone Error", logger.Field("error", err))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
+	}
+	if !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserExist), "telephone already exists")
+	}
+	var referer *user.User
+	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")
+		}
+	}
+
+	// Generate password
+	pwd := tool.EncodePassWord(req.Password)
+	userInfo := &user.User{
+		Password: pwd,
+		AuthMethods: []user.AuthMethods{
+			{
+				AuthType:       "mobile",
+				AuthIdentifier: phoneNumber,
+				Verified:       true,
+			},
+		},
+	}
+	if referer != nil {
+		userInfo.RefererId = referer.Id
+	}
+	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
+	})
+	// 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())
+	}
+	return &types.LoginResponse{
+		Token: token,
+	}, nil
+}
+
+func (l *TelephoneUserRegisterLogic) 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/auth/userLoginLogic.go

@@ -0,0 +1,89 @@
+package auth
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/perfect-panel/ppanel-server/pkg/logger"
+
+	"github.com/perfect-panel/ppanel-server/internal/config"
+	"github.com/perfect-panel/ppanel-server/internal/model/user"
+	"github.com/perfect-panel/ppanel-server/pkg/jwt"
+	"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"
+
+	"github.com/perfect-panel/ppanel-server/internal/svc"
+	"github.com/perfect-panel/ppanel-server/internal/types"
+)
+
+type UserLoginLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewUserLoginLogic User login
+func NewUserLoginLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserLoginLogic {
+	return &UserLoginLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UserLoginLogic) UserLogin(req *types.UserLoginRequest) (resp *types.LoginResponse, err error) {
+	loginStatus := false
+	var userInfo *user.User
+	// Record login status
+	defer func(svcCtx *svc.ServiceContext) {
+		if userInfo.Id != 0 {
+			if err := svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
+				UserId:    userInfo.Id,
+				LoginIP:   req.IP,
+				UserAgent: req.UserAgent,
+				Success:   &loginStatus,
+			}); err != nil {
+				l.Logger.Error("[UserLogin] insert login log error", logger.Field("error", err.Error()))
+			}
+		}
+	}(l.svcCtx)
+
+	userInfo, err = l.svcCtx.UserModel.FindOneByEmail(l.ctx, req.Email)
+	if err != nil {
+		if errors.As(err, &gorm.ErrRecordNotFound) {
+			logger.WithContext(l.ctx).Error(err)
+			return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "user email not exist: %v", req.Email)
+		}
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
+	}
+	// Verify password
+	if !tool.VerifyPassWord(req.Password, userInfo.Password) {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserPasswordError), "user password")
+	}
+	// 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())
+	}
+	loginStatus = true
+	return &types.LoginResponse{
+		Token: token,
+	}, nil
+}

internal/logic/auth/userRegisterLogic.go

@@ -0,0 +1,182 @@
+package auth
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"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/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 UserRegisterLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewUserRegisterLogic User register
+func NewUserRegisterLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UserRegisterLogic {
+	return &UserRegisterLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *UserRegisterLogic) UserRegister(req *types.UserRegisterRequest) (resp *types.LoginResponse, err error) {
+
+	c := l.svcCtx.Config.Register
+	email := l.svcCtx.Config.Email
+	var referer *user.User
+	// 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 the email verification is enabled, the verification code is required
+	if email.EnableVerify {
+		cacheKey := fmt.Sprintf("%s:%s:%s", config.AuthCodeCacheKey, constant.Register, req.Email)
+		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")
+		}
+	}
+	// Check if the user exists
+	_, err = l.svcCtx.UserModel.FindOneByEmail(l.ctx, req.Email)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		l.Errorw("FindOneByEmail Error", logger.Field("error", err))
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "query user info failed: %v", err.Error())
+	} else if err == nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.UserExist), "user email exist: %v", req.Email)
+	}
+	// Generate password
+	pwd := tool.EncodePassWord(req.Password)
+	userInfo := &user.User{
+		Password: pwd,
+	}
+	if referer != nil {
+		userInfo.RefererId = referer.Id
+	}
+	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
+		}
+		// create user auth info
+		authInfo := &user.AuthMethods{
+			UserId:         userInfo.Id,
+			AuthType:       "email",
+			AuthIdentifier: req.Email,
+			Verified:       email.EnableVerify,
+		}
+		if err = db.Create(authInfo).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
+	})
+	// 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())
+	}
+	// Set session id
+	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())
+	}
+	loginStatus := true
+	defer func() {
+		if token != "" && userInfo.Id != 0 {
+			if err := l.svcCtx.UserModel.InsertLoginLog(l.ctx, &user.LoginLog{
+				UserId:    userInfo.Id,
+				LoginIP:   req.IP,
+				UserAgent: req.UserAgent,
+				Success:   &loginStatus,
+			}); err != nil {
+				l.Logger.Error("[UserRegister] insert login log error", logger.Field("error", err.Error()))
+			}
+		}
+	}()
+	return &types.LoginResponse{
+		Token: token,
+	}, nil
+}
+
+func (l *UserRegisterLogic) 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{
+		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)
+}