Develop (#76)

* refactor: rename queryannouncementhandler.go to queryAnnouncementLogic.go for clarity

* feat(panDomain): update subscription logic to use V2 handler for improved functionality

* refactor(subscribe): replace V2 handler with a unified Handler method for subscription logic

* feat(subscribe): implement user agent limit feature with configurable list

* fix(subscribe): improve error handling and logging for subscription requests

* feat(subscribe): add user agent limit configuration to system settings

* refactor(api): remove deprecated application-related endpoints and types

* refactor(swagger): remove deprecated app.json generation from swagger configuration

* refactor(swagger): remove deprecated app.json check from swagger configuration

* fix(subscribe): update delete method to use Where clause for improved query accuracy

* fix(subscribe): update Id field tag to use primaryKey and improve save method query

* fix(subscribe): update Id field tag to use primaryKey and improve model queries

* fix(subscribe): rename variable for clarity and add special handling for Stash user agent

* fix(email): convert RegisterStartTime and RegisterEndTime to time.Time for accurate query filtering

* refactor(log): consolidate logging models and update related logic for improved clarity and functionality

* fix(types): change Content field type in MessageLog to interface{} for improved flexibility

* fix(log): change MessageLog list to use value type for improved performance and memory efficiency

* fix(email): set EmailTypeVerify in task payload and update content type conversion for verification email

* fix(log): remove unused Id field from SystemLog during login log insertion

* fix(login): remove debug logs and error logging during user login process

* fix(log): add traffic reset logging for subscription resets

* fix(log): insert reset traffic log during subscription activation

* feat(log): add endpoints for retrieving and resetting subscribe traffic logs

* refactor(log): remove Reset Subscribe Traffic Log endpoint and related types

* feat(traffic): add traffic statistics logging and scheduling

* fix(subscribe): ensure active status and reset timestamps during traffic resets

* feat(api): enhance server and node management with new request/response structures

* refactor(api): rename OnlineUser to ServerOnlineUser for clarity

* feat(api): define OnlineUser type with SID and IP fields

* feat(server): implement server management handlers and database schema

* feat(api): add traffic log details filtering and enhance traffic log structures

* feat(api): migrate server and node data handling, update related structures and logic

* feat(server): implement server deletion logic with error handling

* feat(api): update log filtering to use ResetSubscribe type for subscription logs

* feat(api): standardize timestamp field across log structures

* feat(api): refactor cache key handling for server and user lists

* feat(api): enhance server status handling with protocol support and refactor related logic

* fix(traffic): adjust start date for traffic statistics and improve log deletion comment

* feat(api): implement daily traffic ranking for users and servers with error handling

* feat(api): update server total data response to use 'OnlineUsers' and implement daily traffic statistics logging

* feat(api): add log settings management with auto-clear and clear days configuration

* fix(log): correct category in log settings update query

* feat(routes): add handler for scheduled traffic statistics

* feat(model): add user counts struct and update queries for new and renewal users

* feat(api): add referral percentage and only first purchase fields to user model and requests

* feat(database): update user table to add referral percentage and only first purchase fields

* feat(api): add reset sort endpoints for server and node

* feat(api): add sort field to server model

* feat(api): implement sorting functionality for nodes and servers

* fix(database): add sort column to nodes table

* fix(model): enhance user statistics queries with new order and renewal order counts

* fix(log): update timestamp handling in login and registration logs

* fix(log): update sorting logic for server and user subscribe traffic logs

* fix(server): add server status handling based on last reported time

* fix(model): correct filter condition to use 'date' instead of 'data'

* fix(migration): add index for traffic log on timestamp, user_id, and subscribe_id

* fix(log): optimize user traffic rank data handling by using append instead of index assignment

* fix(filter): refactor node list creation to use append and remove duplicates from tags

* fix(node): add ServerId and Enabled fields to node update logic

* feat(tags): add endpoint to query all node tags

* fix(preview): add Preload parameter to FilterNodeList for improved data retrieval

* fix(log): date is empty

* feat(subscribe): add Language field to subscription models and update query logic

* feat(subscription): add Language parameter to GetSubscription request and update query logic

* fix(server): encode ServerKey in base64 and update last reported time for nodes

* feat: delete common GetSubscription

* feat(subscription): implement FilterList method for subscription queries and update related logic

* fix(subscribe): remove duplicate user agents in SubscribeHandler

* fix(push): initialize onlineUsers as a map in pushOnlineUsersLogic

* fix(reset): initialize subs as a map in clearCache method

* refactor(query): simplify node and tag filtering using InSet function

* feat(userlist): enhance GetServerUserListLogic with improved node and tag handling

* fix(userlist): correct node ID assignment and update query logic for tag filtering

* fix(userlist): correct node ID assignment in getServerUserListLogic

* refactor(query): streamline query construction for tag filtering

* fix(statistics): optimize server ranking data handling in QueryServerTotalDataLogic

* refactor(statistics): simplify server ranking data construction in QueryServerTotalDataLogic

* fix(statistics): correct server traffic data assignment in QueryServerTotalDataLogic

* fix(statistics): optimize yesterday's top 10 server traffic data assignment in QueryServerTotalDataLogic

* fix(middleware): remove duplicate elements from user agent list in PanDomainMiddleware

* feat(middleware): enhance user agent handling by querying client list in PanDomainMiddleware

* feat(client): subscribe_template

* feat(oauth): add user agent and IP logging to registration and login processes

* fix(balance): add timestamp to balance logs for payment, refund, and recharge transactions

* fix(log): correct comment for CommissionTypeRefund to improve clarity

* fix(log): replace magic number with constant for gift type in purchase checkout logic

* fix(log): rename OrderId to OrderNo for consistency in balance logging

* feat(log): add logging for balance, gift amount, and commission adjustments

* fix(user): correct placement of DeepCopy for user info update logic

* feat(log): add UserSubscribeId to FilterSubscribeLogRequest for enhanced filtering

* fix(purchase): streamline error handling and improve JSON marshaling for temporary orders

* fix(order): simplify commission handling and improve payload parsing logic

* fix(order): update commission calculation to actual payment amount minus gateway handling fee

* feat(payment): add support for CryptoSaaS payment platform and enhance configuration handling

* fix(balance): update QueryUserBalanceLog response structure to include balance log list

* fix(email): update task progress handling to use specific task ID for updates

* feat(quota): add quota task creation and querying endpoints with updated data structures

* fix(email): update task handling to use generic task model and improve error logging

* fix(order): improve error logging for database transaction and user cache updates

* feat(quota): enhance quota task management with new request structures and processing logic

* fix(quota): remove redundant quota task status endpoint from admin marketing routes

* fix(worker): update task completion status handling in worker logic

* fix(quota): update taskInfo to include current subscription count in quota logic

* doc(log): rename function for clarity and add cache cleanup comment

* fix(quota): update time handling in quota logic and correct subscriber ID query

* fix(quota): update time handling to use UnixMilli for start time in quota logic

* feat(protocol): add server protocol configuration query and enhance protocol options

* fix(quota): correct time range queries for start and expire times in quota logic

* fix(types): update plugin options to include 'none' in the plugin field

---------

Co-authored-by: Chang lue Tsen <tension@ppanel.dev>

internal/logic/admin/system/createApplicationLogic.go

@@ -1,125 +0,0 @@
-package system
-
-import (
-	"context"
-
-	"github.com/perfect-panel/server/internal/model/application"
-	"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 CreateApplicationLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-func NewCreateApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateApplicationLogic {
-	return &CreateApplicationLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *CreateApplicationLogic) CreateApplication(req *types.CreateApplicationRequest) error {
-	var ios []application.ApplicationVersion
-	if len(req.Platform.IOS) > 0 {
-		for _, ios_ := range req.Platform.IOS {
-			ios = append(ios, application.ApplicationVersion{
-				Url:         ios_.Url,
-				Version:     ios_.Version,
-				Platform:    "ios",
-				IsDefault:   ios_.IsDefault,
-				Description: ios_.Description,
-			})
-		}
-	}
-
-	var mac []application.ApplicationVersion
-	if len(req.Platform.MacOS) > 0 {
-		for _, mac_ := range req.Platform.MacOS {
-			mac = append(mac, application.ApplicationVersion{
-				Url:         mac_.Url,
-				Version:     mac_.Version,
-				Platform:    "macos",
-				IsDefault:   mac_.IsDefault,
-				Description: mac_.Description,
-			})
-		}
-	}
-
-	var linux []application.ApplicationVersion
-	if len(req.Platform.Linux) > 0 {
-		for _, linux_ := range req.Platform.Linux {
-			linux = append(linux, application.ApplicationVersion{
-				Url:         linux_.Url,
-				Version:     linux_.Version,
-				Platform:    "linux",
-				IsDefault:   linux_.IsDefault,
-				Description: linux_.Description,
-			})
-		}
-	}
-
-	var android []application.ApplicationVersion
-	if len(req.Platform.Android) > 0 {
-		for _, android_ := range req.Platform.Android {
-			android = append(android, application.ApplicationVersion{
-				Url:         android_.Url,
-				Version:     android_.Version,
-				Platform:    "android",
-				IsDefault:   android_.IsDefault,
-				Description: android_.Description,
-			})
-		}
-	}
-
-	var windows []application.ApplicationVersion
-	if len(req.Platform.Windows) > 0 {
-		for _, windows_ := range req.Platform.Windows {
-			windows = append(windows, application.ApplicationVersion{
-				Url:         windows_.Url,
-				Version:     windows_.Version,
-				Platform:    "windows",
-				IsDefault:   windows_.IsDefault,
-				Description: windows_.Description,
-			})
-		}
-	}
-
-	var harmony []application.ApplicationVersion
-	if len(req.Platform.Harmony) > 0 {
-		for _, harmony_ := range req.Platform.Harmony {
-			harmony = append(harmony, application.ApplicationVersion{
-				Url:         harmony_.Url,
-				Version:     harmony_.Version,
-				Platform:    "harmony",
-				IsDefault:   harmony_.IsDefault,
-				Description: harmony_.Description,
-			})
-		}
-	}
-	var applicationVersions []application.ApplicationVersion
-	applicationVersions = append(applicationVersions, ios...)
-	applicationVersions = append(applicationVersions, mac...)
-	applicationVersions = append(applicationVersions, linux...)
-	applicationVersions = append(applicationVersions, android...)
-	applicationVersions = append(applicationVersions, windows...)
-	applicationVersions = append(applicationVersions, harmony...)
-	app := application.Application{
-		Name:                req.Name,
-		Icon:                req.Icon,
-		SubscribeType:       req.SubscribeType,
-		ApplicationVersions: applicationVersions,
-	}
-	err := l.svcCtx.ApplicationModel.Insert(l.ctx, &app)
-	if err != nil {
-		l.Errorw("[CreateApplicationLogic] create application error: ", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create application error: %v", err)
-	}
-	return nil
-}

internal/logic/admin/system/createApplicationVersionLogic.go

@@ -1,44 +0,0 @@
-package system
-
-import (
-	"context"
-
-	"github.com/perfect-panel/server/internal/model/application"
-	"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 CreateApplicationVersionLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-// Create application version
-func NewCreateApplicationVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateApplicationVersionLogic {
-	return &CreateApplicationVersionLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *CreateApplicationVersionLogic) CreateApplicationVersion(req *types.CreateApplicationVersionRequest) error {
-	create := &application.ApplicationVersion{
-		Url:           req.Url,
-		Platform:      req.Platform,
-		Version:       req.Version,
-		Description:   req.Description,
-		IsDefault:     req.IsDefault,
-		ApplicationId: req.ApplicationId,
-	}
-	err := l.svcCtx.ApplicationModel.InsertVersion(l.ctx, create)
-	if err != nil {
-		l.Errorw("[CreateApplicationVersion] create application version error: ", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "create application version error: %v", err)
-	}
-	return nil
-}

internal/logic/admin/system/deleteApplicationLogic.go

@@ -1,35 +0,0 @@
-package system
-
-import (
-	"context"
-
-	"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 DeleteApplicationLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-func NewDeleteApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteApplicationLogic {
-	return &DeleteApplicationLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *DeleteApplicationLogic) DeleteApplication(req *types.DeleteApplicationRequest) error {
-	// delete application
-	err := l.svcCtx.ApplicationModel.Delete(l.ctx, req.Id)
-	if err != nil {
-		l.Errorw("[DeleteApplicationLogic] delete application error: ", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete application error: %v", err.Error())
-	}
-	return nil
-}

internal/logic/admin/system/deleteApplicationVersionLogic.go

@@ -1,36 +0,0 @@
-package system
-
-import (
-	"context"
-
-	"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 DeleteApplicationVersionLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-// Delete application
-func NewDeleteApplicationVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteApplicationVersionLogic {
-	return &DeleteApplicationVersionLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *DeleteApplicationVersionLogic) DeleteApplicationVersion(req *types.DeleteApplicationVersionRequest) error {
-	// delete application
-	err := l.svcCtx.ApplicationModel.DeleteVersion(l.ctx, req.Id)
-	if err != nil {
-		l.Errorw("[DeleteApplicationVersion] delete application version error: ", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete application version error: %v", err.Error())
-	}
-	return nil
-}

internal/logic/admin/system/getApplicationConfigLogic.go

@@ -1,49 +0,0 @@
-package system
-
-import (
-	"context"
-	"strings"
-
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
-	"gorm.io/gorm"
-
-	"github.com/perfect-panel/server/internal/svc"
-	"github.com/perfect-panel/server/internal/types"
-	"github.com/perfect-panel/server/pkg/logger"
-)
-
-type GetApplicationConfigLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-// get application config
-func NewGetApplicationConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetApplicationConfigLogic {
-	return &GetApplicationConfigLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *GetApplicationConfigLogic) GetApplicationConfig() (resp *types.ApplicationConfig, err error) {
-	resp = &types.ApplicationConfig{}
-	appConfig, err := l.svcCtx.ApplicationModel.FindOneConfig(l.ctx, 1)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			err = nil
-			return
-		}
-		l.Errorw("[GetApplicationConfig] Database Error", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get app config  error: %v", err.Error())
-	}
-	resp.AppId = appConfig.AppId
-	resp.EncryptionKey = appConfig.EncryptionKey
-	resp.EncryptionMethod = appConfig.EncryptionMethod
-	resp.Domains = strings.Split(appConfig.Domains, ";")
-	resp.StartupPicture = appConfig.StartupPicture
-	resp.StartupPictureSkipTime = appConfig.StartupPictureSkipTime
-	return
-}

internal/logic/admin/system/getApplicationLogic.go

@@ -1,113 +0,0 @@
-package system
-
-import (
-	"context"
-
-	"github.com/perfect-panel/server/internal/model/application"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
-	"gorm.io/gorm"
-
-	"github.com/perfect-panel/server/internal/svc"
-	"github.com/perfect-panel/server/internal/types"
-	"github.com/perfect-panel/server/pkg/logger"
-)
-
-type GetApplicationLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-// Get application
-func NewGetApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetApplicationLogic {
-	return &GetApplicationLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *GetApplicationLogic) GetApplication() (resp *types.ApplicationResponse, err error) {
-	resp = &types.ApplicationResponse{}
-	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("[GetApplicationLogic] 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
-	}
-
-	for _, app := range applications {
-		applicationResponse := types.ApplicationResponseInfo{
-			Id:            app.Id,
-			Name:          app.Name,
-			Icon:          app.Icon,
-			Description:   app.Description,
-			SubscribeType: app.SubscribeType,
-		}
-		applicationVersions := app.ApplicationVersions
-		if len(applicationVersions) != 0 {
-			for _, applicationVersion := range applicationVersions {
-				switch applicationVersion.Platform {
-				case "ios":
-					applicationResponse.Platform.IOS = append(applicationResponse.Platform.IOS, &types.ApplicationVersion{
-						Id:          applicationVersion.Id,
-						Url:         applicationVersion.Url,
-						Version:     applicationVersion.Version,
-						IsDefault:   applicationVersion.IsDefault,
-						Description: applicationVersion.Description,
-					})
-				case "macos":
-					applicationResponse.Platform.MacOS = append(applicationResponse.Platform.MacOS, &types.ApplicationVersion{
-						Id:          applicationVersion.Id,
-						Url:         applicationVersion.Url,
-						Version:     applicationVersion.Version,
-						IsDefault:   applicationVersion.IsDefault,
-						Description: applicationVersion.Description,
-					})
-				case "linux":
-					applicationResponse.Platform.Linux = append(applicationResponse.Platform.Linux, &types.ApplicationVersion{
-						Id:          applicationVersion.Id,
-						Url:         applicationVersion.Url,
-						Version:     applicationVersion.Version,
-						IsDefault:   applicationVersion.IsDefault,
-						Description: applicationVersion.Description,
-					})
-				case "android":
-					applicationResponse.Platform.Android = append(applicationResponse.Platform.Android, &types.ApplicationVersion{
-						Id:          applicationVersion.Id,
-						Url:         applicationVersion.Url,
-						Version:     applicationVersion.Version,
-						IsDefault:   applicationVersion.IsDefault,
-						Description: applicationVersion.Description,
-					})
-				case "windows":
-					applicationResponse.Platform.Windows = append(applicationResponse.Platform.Windows, &types.ApplicationVersion{
-						Id:          applicationVersion.Id,
-						Url:         applicationVersion.Url,
-						Version:     applicationVersion.Version,
-						IsDefault:   applicationVersion.IsDefault,
-						Description: applicationVersion.Description,
-					})
-				case "harmony":
-					applicationResponse.Platform.Harmony = append(applicationResponse.Platform.Harmony, &types.ApplicationVersion{
-						Id:          applicationVersion.Id,
-						Url:         applicationVersion.Url,
-						Version:     applicationVersion.Version,
-						IsDefault:   applicationVersion.IsDefault,
-						Description: applicationVersion.Description,
-					})
-				}
-			}
-		}
-		resp.Applications = append(resp.Applications, applicationResponse)
-	}
-
-	return
-}

internal/logic/admin/system/getSubscribeTypeLogic.go

@@ -1,42 +0,0 @@
-package system
-
-import (
-	"context"
-
-	"github.com/perfect-panel/server/internal/model/subscribeType"
-	"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 GetSubscribeTypeLogic struct {
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-	logger.Logger
-}
-
-func NewGetSubscribeTypeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetSubscribeTypeLogic {
-	return &GetSubscribeTypeLogic{
-		ctx:    ctx,
-		svcCtx: svcCtx,
-		Logger: logger.WithContext(ctx),
-	}
-}
-
-func (l *GetSubscribeTypeLogic) GetSubscribeType() (resp *types.SubscribeType, err error) {
-	var list []*subscribeType.SubscribeType
-	err = l.svcCtx.DB.Model(&subscribeType.SubscribeType{}).Find(&list).Error
-	if err != nil {
-		l.Errorw("[GetSubscribeType] get subscribe type failed", logger.Field("error", err.Error()))
-		return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get subscribe type failed: %v", err)
-	}
-	typeList := make([]string, 0)
-	for _, item := range list {
-		typeList = append(typeList, item.Name)
-	}
-	return &types.SubscribeType{
-		SubscribeTypes: typeList,
-	}, nil
-}

internal/logic/admin/system/updateApplicationConfigLogic.go

@@ -1,45 +0,0 @@
-package system
-
-import (
-	"context"
-	"strings"
-
-	"github.com/perfect-panel/server/internal/model/application"
-	"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 UpdateApplicationConfigLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-// update application config
-func NewUpdateApplicationConfigLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateApplicationConfigLogic {
-	return &UpdateApplicationConfigLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *UpdateApplicationConfigLogic) UpdateApplicationConfig(req *types.ApplicationConfig) error {
-	err := l.svcCtx.ApplicationModel.UpdateConfig(l.ctx, &application.ApplicationConfig{
-		Id:                     1,
-		AppId:                  req.AppId,
-		EncryptionKey:          req.EncryptionKey,
-		EncryptionMethod:       req.EncryptionMethod,
-		Domains:                strings.Join(req.Domains, ";"),
-		StartupPicture:         req.StartupPicture,
-		StartupPictureSkipTime: req.StartupPictureSkipTime,
-	})
-	if err != nil {
-		l.Errorw("[UpdateApplicationConfig] Database Error", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update app config error: %v", err.Error())
-	}
-	return nil
-}

internal/logic/admin/system/updateApplicationLogic.go

@@ -1,149 +0,0 @@
-package system
-
-import (
-	"context"
-
-	"github.com/perfect-panel/server/internal/model/application"
-	"github.com/perfect-panel/server/pkg/logger"
-	"github.com/perfect-panel/server/pkg/xerr"
-	"github.com/pkg/errors"
-	"gorm.io/gorm"
-
-	"github.com/perfect-panel/server/internal/svc"
-	"github.com/perfect-panel/server/internal/types"
-)
-
-type UpdateApplicationLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-func NewUpdateApplicationLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateApplicationLogic {
-	return &UpdateApplicationLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *UpdateApplicationLogic) UpdateApplication(req *types.UpdateApplicationRequest) error {
-
-	// find application
-	app, err := l.svcCtx.ApplicationModel.FindOne(l.ctx, req.Id)
-	if err != nil {
-		l.Errorw("[UpdateApplication] find application error", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find application error: %v", err.Error())
-	}
-	app.Name = req.Name
-	app.Icon = req.Icon
-	app.SubscribeType = req.SubscribeType
-	app.Description = req.Description
-
-	var ios []application.ApplicationVersion
-	if len(req.Platform.IOS) > 0 {
-		for _, ios_ := range req.Platform.IOS {
-			ios = append(ios, application.ApplicationVersion{
-				Url:           ios_.Url,
-				Version:       ios_.Version,
-				Platform:      "ios",
-				IsDefault:     ios_.IsDefault,
-				Description:   ios_.Description,
-				ApplicationId: app.Id,
-			})
-		}
-	}
-
-	var mac []application.ApplicationVersion
-	if len(req.Platform.MacOS) > 0 {
-		for _, mac_ := range req.Platform.MacOS {
-			mac = append(mac, application.ApplicationVersion{
-				Url:           mac_.Url,
-				Version:       mac_.Version,
-				Platform:      "macos",
-				IsDefault:     mac_.IsDefault,
-				Description:   mac_.Description,
-				ApplicationId: app.Id,
-			})
-		}
-	}
-
-	var linux []application.ApplicationVersion
-	if len(req.Platform.Linux) > 0 {
-		for _, linux_ := range req.Platform.Linux {
-			linux = append(linux, application.ApplicationVersion{
-				Url:           linux_.Url,
-				Version:       linux_.Version,
-				Platform:      "linux",
-				IsDefault:     linux_.IsDefault,
-				Description:   linux_.Description,
-				ApplicationId: app.Id,
-			})
-		}
-	}
-
-	var android []application.ApplicationVersion
-	if len(req.Platform.Android) > 0 {
-		for _, android_ := range req.Platform.Android {
-			android = append(android, application.ApplicationVersion{
-				Url:           android_.Url,
-				Version:       android_.Version,
-				Platform:      "android",
-				IsDefault:     android_.IsDefault,
-				Description:   android_.Description,
-				ApplicationId: app.Id,
-			})
-		}
-	}
-
-	var windows []application.ApplicationVersion
-	if len(req.Platform.Windows) > 0 {
-		for _, windows_ := range req.Platform.Windows {
-			windows = append(windows, application.ApplicationVersion{
-				Url:           windows_.Url,
-				Version:       windows_.Version,
-				Platform:      "windows",
-				IsDefault:     windows_.IsDefault,
-				Description:   windows_.Description,
-				ApplicationId: app.Id,
-			})
-		}
-	}
-
-	var harmony []application.ApplicationVersion
-	if len(req.Platform.Harmony) > 0 {
-		for _, harmony_ := range req.Platform.Harmony {
-			harmony = append(harmony, application.ApplicationVersion{
-				Url:           harmony_.Url,
-				Version:       harmony_.Version,
-				Platform:      "harmony",
-				IsDefault:     harmony_.IsDefault,
-				Description:   harmony_.Description,
-				ApplicationId: app.Id,
-			})
-		}
-	}
-	var applicationVersions []application.ApplicationVersion
-	applicationVersions = append(applicationVersions, ios...)
-	applicationVersions = append(applicationVersions, mac...)
-	applicationVersions = append(applicationVersions, linux...)
-	applicationVersions = append(applicationVersions, android...)
-	applicationVersions = append(applicationVersions, windows...)
-	applicationVersions = append(applicationVersions, harmony...)
-	app.ApplicationVersions = applicationVersions
-	err = l.svcCtx.ApplicationModel.Transaction(l.ctx, func(db *gorm.DB) error {
-
-		if err = db.Where("application_id = ?", app.Id).Delete(&application.ApplicationVersion{}).Error; err != nil {
-			return err
-		}
-		if err = db.Create(&applicationVersions).Error; err != nil {
-			return err
-		}
-		return db.Save(app).Error
-	})
-	if err != nil {
-		l.Errorw("[UpdateApplication] update application error", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update application error: %v", err.Error())
-	}
-	return nil
-}

internal/logic/admin/system/updateApplicationVersionLogic.go

@@ -1,45 +0,0 @@
-package system
-
-import (
-	"context"
-
-	"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 UpdateApplicationVersionLogic struct {
-	logger.Logger
-	ctx    context.Context
-	svcCtx *svc.ServiceContext
-}
-
-// Update application version
-func NewUpdateApplicationVersionLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateApplicationVersionLogic {
-	return &UpdateApplicationVersionLogic{
-		Logger: logger.WithContext(ctx),
-		ctx:    ctx,
-		svcCtx: svcCtx,
-	}
-}
-
-func (l *UpdateApplicationVersionLogic) UpdateApplicationVersion(req *types.UpdateApplicationVersionRequest) error {
-	// find application
-	app, err := l.svcCtx.ApplicationModel.FindOneVersion(l.ctx, req.Id)
-	if err != nil {
-		l.Errorw("[UpdateApplicationVersion] find application version error", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find application error: %v", err.Error())
-	}
-	app.Url = req.Url
-	app.Version = req.Version
-	app.Description = req.Description
-	app.IsDefault = req.IsDefault
-	err = l.svcCtx.ApplicationModel.UpdateVersion(l.ctx, app)
-	if err != nil {
-		l.Errorw("[UpdateApplicationVersion] update application version error", logger.Field("error", err.Error()))
-		return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update application version error: %v", err.Error())
-	}
-	return nil
-}