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

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/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
-}