Merge branch 'old' into main

internal/logic/admin/application/previewSubscribeTemplateLogic.go

@@ -29,10 +29,12 @@ func NewPreviewSubscribeTemplateLogic(ctx context.Context, svcCtx *svc.ServiceCo
 }
 
 func (l *PreviewSubscribeTemplateLogic) PreviewSubscribeTemplate(req *types.PreviewSubscribeTemplateRequest) (resp *types.PreviewSubscribeTemplateResponse, err error) {
+	enable := true
 	_, servers, err := l.svcCtx.NodeModel.FilterNodeList(l.ctx, &node.FilterNodeParams{
 		Page:    1,
 		Size:    1000,
 		Preload: true,
+		Enabled: &enable,
 	})
 	if err != nil {
 		l.Errorf("[PreviewSubscribeTemplateLogic] FindAllServer error: %v", err.Error())

internal/logic/admin/authMethod/updateAuthMethodConfigLogic.go

@@ -92,6 +92,9 @@ func (l *UpdateAuthMethodConfigLogic) UpdateGlobal(method string) {
 	if method == "mobile" {
 		initialize.Mobile(l.svcCtx)
 	}
+	if method == "device" {
+		initialize.Device(l.svcCtx)
+	}
 }
 
 func validatePlatformConfig(platform string, cfg map[string]interface{}) (interface{}, error) {

internal/logic/admin/payment/getPaymentMethodListLogic.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"encoding/json"
 
+	"github.com/perfect-panel/server/internal/report"
 	paymentPlatform "github.com/perfect-panel/server/pkg/payment"
 
 	"github.com/perfect-panel/server/internal/model/payment"
@@ -43,15 +44,31 @@ func (l *GetPaymentMethodListLogic) GetPaymentMethodList(req *types.GetPaymentMe
 		Total: total,
 		List:  make([]types.PaymentMethodDetail, len(list)),
 	}
+
+	// gateway mod
+
+	isGatewayMod := report.IsGatewayMode()
+
 	for i, v := range list {
 		config := make(map[string]interface{})
 		_ = json.Unmarshal([]byte(v.Config), &config)
 		notifyUrl := ""
+
 		if paymentPlatform.ParsePlatform(v.Platform) != paymentPlatform.Balance {
+			notifyUrl = v.Domain
 			if v.Domain != "" {
-				notifyUrl = v.Domain + "/v1/notify/" + v.Platform + "/" + v.Token
+				// if is gateway mod, use gateway domain
+				if isGatewayMod {
+					notifyUrl += "/api/"
+				}
+				notifyUrl += "/v1/notify/" + v.Platform + "/" + v.Token
 			} else {
-				notifyUrl = "https://" + l.svcCtx.Config.Host + "/v1/notify/" + v.Platform + "/" + v.Token
+				notifyUrl += "https://" + l.svcCtx.Config.Host
+				if isGatewayMod {
+					notifyUrl += "/api/v1/notify/" + v.Platform + "/" + v.Token
+				} else {
+					notifyUrl += "/v1/notify/" + v.Platform + "/" + v.Token
+				}
 			}
 		}
 		resp.List[i] = types.PaymentMethodDetail{

internal/logic/admin/subscribe/resetAllSubscribeTokenLogic.go

@@ -0,0 +1,61 @@
+package subscribe
+
+import (
+	"context"
+	"strconv"
+	"time"
+
+	"github.com/perfect-panel/server/internal/model/user"
+	"github.com/perfect-panel/server/pkg/uuidx"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+)
+
+type ResetAllSubscribeTokenLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Reset all subscribe tokens
+func NewResetAllSubscribeTokenLogic(ctx context.Context, svcCtx *svc.ServiceContext) *ResetAllSubscribeTokenLogic {
+	return &ResetAllSubscribeTokenLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *ResetAllSubscribeTokenLogic) ResetAllSubscribeToken() (resp *types.ResetAllSubscribeTokenResponse, err error) {
+	var list []*user.Subscribe
+	tx := l.svcCtx.DB.WithContext(l.ctx).Begin()
+	// select all active and Finished subscriptions
+	if err = tx.Model(&user.Subscribe{}).Where("`status` IN ?", []int64{1, 2}).Find(&list).Error; err != nil {
+		logger.Errorf("[ResetAllSubscribeToken] Failed to fetch subscribe list: %v", err.Error())
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Failed to fetch subscribe list: %v", err.Error())
+	}
+
+	for _, sub := range list {
+		sub.Token = uuidx.SubscribeToken(strconv.FormatInt(time.Now().UnixMilli(), 10) + strconv.FormatInt(sub.Id, 10))
+		sub.UUID = uuidx.NewUUID().String()
+		if err = tx.Model(&user.Subscribe{}).Where("id = ?", sub.Id).Save(sub).Error; err != nil {
+			tx.Rollback()
+			logger.Errorf("[ResetAllSubscribeToken] Failed to update subscribe token for ID %d: %v", sub.Id, err.Error())
+			return &types.ResetAllSubscribeTokenResponse{
+				Success: false,
+			}, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Failed to update subscribe token for ID %d: %v", sub.Id, err.Error())
+		}
+	}
+	if err = tx.Commit().Error; err != nil {
+		logger.Errorf("[ResetAllSubscribeToken] Failed to commit transaction: %v", err.Error())
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Failed to commit transaction: %v", err.Error())
+	}
+
+	return &types.ResetAllSubscribeTokenResponse{
+		Success: true,
+	}, nil
+}

internal/logic/admin/system/getModuleConfigLogic.go

@@ -0,0 +1,41 @@
+package system
+
+import (
+	"context"
+	"os"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/constant"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type GetModuleConfigLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// Get Module Config
+func NewGetModuleConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetModuleConfigLogic {
+	return &GetModuleConfigLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *GetModuleConfigLogic) GetModuleConfig() (resp *types.ModuleConfig, err error) {
+	value, exists := os.LookupEnv("SECRET_KEY")
+	if !exists {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), " SECRET_KEY not set in environment variables")
+	}
+
+	return &types.ModuleConfig{
+		Secret:         value,
+		ServiceName:    constant.ServiceName,
+		ServiceVersion: constant.Version,
+	}, nil
+}

internal/logic/admin/tool/queryIPLocationLogic.go

@@ -0,0 +1,57 @@
+package tool
+
+import (
+	"context"
+	"net"
+
+	"github.com/perfect-panel/server/internal/svc"
+	"github.com/perfect-panel/server/internal/types"
+	"github.com/perfect-panel/server/pkg/logger"
+	"github.com/perfect-panel/server/pkg/xerr"
+	"github.com/pkg/errors"
+)
+
+type QueryIPLocationLogic struct {
+	logger.Logger
+	ctx    context.Context
+	svcCtx *svc.ServiceContext
+}
+
+// NewQueryIPLocationLogic Query IP Location
+func NewQueryIPLocationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *QueryIPLocationLogic {
+	return &QueryIPLocationLogic{
+		Logger: logger.WithContext(ctx),
+		ctx:    ctx,
+		svcCtx: svcCtx,
+	}
+}
+
+func (l *QueryIPLocationLogic) QueryIPLocation(req *types.QueryIPLocationRequest) (resp *types.QueryIPLocationResponse, err error) {
+	if l.svcCtx.GeoIP == nil {
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), " GeoIP database not configured")
+	}
+
+	ip := net.ParseIP(req.IP)
+	record, err := l.svcCtx.GeoIP.DB.City(ip)
+	if err != nil {
+		l.Errorf("Failed to query IP location: %v", err)
+		return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Failed to query IP location")
+	}
+
+	var country, region, city string
+	if record.Country.Names != nil {
+		country = record.Country.Names["en"]
+	}
+	if len(record.Subdivisions) > 0 && record.Subdivisions[0].Names != nil {
+		region = record.Subdivisions[0].Names["en"]
+	}
+	if record.City.Names != nil {
+		city = record.City.Names["en"]
+	}
+
+	return &types.QueryIPLocationResponse{
+		Country: country,
+		Region:  region,
+		City:    city,
+	}, nil
+}

internal/logic/admin/user/createUserLogic.go

@@ -40,6 +40,7 @@ func (l *CreateUserLogic) CreateUser(req *types.CreateUserRequest) error {
 	pwd := tool.EncodePassWord(req.Password)
 	newUser := &user.User{
 		Password:           pwd,
+		Algo:               "default",
 		ReferralPercentage: req.ReferralPercentage,
 		OnlyFirstPurchase:  &req.OnlyFirstPurchase,
 		ReferCode:          req.ReferCode,

internal/logic/admin/user/updateUserBasicInfoLogic.go

@@ -129,6 +129,7 @@ func (l *UpdateUserBasicInfoLogic) UpdateUserBasicInfo(req *types.UpdateUserBasi
 			return errors.Wrapf(xerr.NewErrCodeMsg(503, "Demo mode does not allow modification of the admin user password"), "UpdateUserBasicInfo failed: cannot update admin user password in demo mode")
 		}
 		userInfo.Password = tool.EncodePassWord(req.Password)
+		userInfo.Algo = "default"
 	}
 
 	err = l.svcCtx.UserModel.Update(l.ctx, userInfo)