优化结构

internal/data/integration_config.go

@@ -2,292 +2,30 @@ package data
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
-	"fmt"
-	"strings"
 
 	"kra/internal/config"
 	dataintegration "kra/internal/data/integration"
-
-	"gorm.io/gorm"
 )
 
-const (
-	integrationKindStorage = "storage"
-	integrationKindEmail   = "email"
-)
-
-var storageProviderNames = []string{
-	"local",
-	"qiniu",
-	"aliyun-oss",
-	"huawei-obs",
-	"tencent-cos",
-	"aws-s3",
-	"cloudflare-r2",
-	"minio",
-}
-
-func normalizeStorageType(value string) string {
-	value = strings.ToLower(strings.TrimSpace(value))
-	if value == "" {
-		return "local"
-	}
-	return value
-}
-
-func storageProviderValue(storage *config.Storage, provider string) any {
-	if storage == nil {
-		storage = &config.Storage{}
-	}
-	switch provider {
-	case "qiniu":
-		if storage.Qiniu == nil {
-			storage.Qiniu = &config.Qiniu{}
-		}
-		return storage.Qiniu
-	case "aliyun-oss":
-		return ensureObjectStore(&storage.AliyunOSS)
-	case "huawei-obs":
-		return ensureObjectStore(&storage.HuaweiOBS)
-	case "tencent-cos":
-		return ensureObjectStore(&storage.TencentCOS)
-	case "aws-s3":
-		return ensureObjectStore(&storage.AWSS3)
-	case "cloudflare-r2":
-		return ensureObjectStore(&storage.CloudflareR2)
-	case "minio":
-		return ensureObjectStore(&storage.Minio)
-	default:
-		return nil
-	}
-}
-
-func ensureObjectStore(value **config.ObjectStore) *config.ObjectStore {
-	if *value == nil {
-		*value = &config.ObjectStore{}
-	}
-	return *value
-}
-
-func marshalStorageProvider(storage *config.Storage, provider string) (string, error) {
-	value := storageProviderValue(storage, provider)
-	if value == nil {
-		return "{}", nil
-	}
-	raw, err := json.Marshal(value)
-	if err != nil {
-		return "", err
-	}
-	return string(raw), nil
-}
-
-func unmarshalStorageProvider(storage *config.Storage, provider, value string) error {
-	if provider == "local" || strings.TrimSpace(value) == "" {
-		return nil
-	}
-	target := storageProviderValue(storage, provider)
-	if target == nil {
-		return nil
-	}
-	if !json.Valid([]byte(value)) {
-		return fmt.Errorf("invalid %s integration configuration", provider)
-	}
-	if err := json.Unmarshal([]byte(value), target); err != nil {
-		return fmt.Errorf("decode %s integration configuration: %w", provider, err)
-	}
-	return nil
-}
-
-func saveStorageIntegrationConfig(db *gorm.DB, storage *config.Storage) error {
-	if storage == nil {
-		storage = &config.Storage{}
-	}
-	active := normalizeStorageType(storage.Type)
-	known := false
-	for _, provider := range storageProviderNames {
-		if provider == active {
-			known = true
-			break
-		}
-	}
-	if !known {
-		return fmt.Errorf("unsupported storage type %q", active)
-	}
-
-	return db.Session(&gorm.Session{NewDB: true}).Transaction(func(tx *gorm.DB) error {
-		for _, provider := range storageProviderNames {
-			value, err := marshalStorageProvider(storage, provider)
-			if err != nil {
-				return fmt.Errorf("encode %s integration configuration: %w", provider, err)
-			}
-			var current dataintegration.ConfigPO
-			err = tx.Where("kind = ? AND provider = ?", integrationKindStorage, provider).First(&current).Error
-			switch {
-			case errors.Is(err, gorm.ErrRecordNotFound):
-				current = dataintegration.ConfigPO{Kind: integrationKindStorage, Provider: provider}
-				current.Enabled, current.Config = provider == active, value
-				if err = tx.Create(&current).Error; err != nil {
-					return err
-				}
-			case err != nil:
-				return err
-			default:
-				if err = tx.Model(&current).Updates(map[string]any{"enabled": provider == active, "config": value}).Error; err != nil {
-					return err
-				}
-			}
-		}
-		return nil
-	})
-}
-
-func loadStorageIntegrationConfig(db *gorm.DB) (*config.Storage, bool, error) {
-	var rows []dataintegration.ConfigPO
-	err := db.Session(&gorm.Session{NewDB: true}).
-		Where("kind = ?", integrationKindStorage).
-		Order("id ASC").
-		Find(&rows).Error
-	if err != nil {
-		return nil, false, err
-	}
-	if len(rows) == 0 {
-		return nil, false, nil
-	}
-
-	storage := &config.Storage{Type: "local"}
-	for _, row := range rows {
-		if err = unmarshalStorageProvider(storage, row.Provider, row.Config); err != nil {
-			return nil, false, err
-		}
-		if row.Enabled {
-			storage.Type = row.Provider
-		}
-	}
-	return storage, true, nil
-}
-
-// resolveStorageIntegrationConfig upgrades a legacy YAML configuration only
-// when the database has no storage rows yet. From then on the database is the
-// sole source of truth.
-func resolveStorageIntegrationConfig(db *gorm.DB, legacy *config.Storage) (*config.Storage, error) {
-	clean := db.Session(&gorm.Session{NewDB: true})
-	if !clean.Migrator().HasTable(&dataintegration.ConfigPO{}) {
-		if legacy == nil {
-			return &config.Storage{Type: "local"}, nil
-		}
-		return config.CloneStorage(legacy), nil
-	}
-	storage, found, err := loadStorageIntegrationConfig(clean)
-	if err != nil {
-		return nil, err
-	}
-	if found {
-		return storage, nil
-	}
-	if legacy == nil {
-		legacy = &config.Storage{Type: "local"}
-	}
-	if err = saveStorageIntegrationConfig(clean, legacy); err != nil {
-		return nil, err
-	}
-	storage, _, err = loadStorageIntegrationConfig(clean)
-	return storage, err
-}
-
 func (d *Data) persistStorageIntegrationConfig(ctx context.Context, storage *config.Storage) error {
 	if !d.databaseReady.Load() {
 		return errors.New("database is not initialized")
 	}
-	db := d.gormDB.WithContext(ctx)
-	if !db.Migrator().HasTable(&dataintegration.ConfigPO{}) {
+	db := d.gormDB.load().WithContext(ctx)
+	if !dataintegration.HasConfigTable(db) {
 		return errors.New("integration configuration table does not exist")
 	}
-	return saveStorageIntegrationConfig(db, storage)
-}
-
-func defaultEmailIntegrationConfig() *config.Email {
-	return &config.Email{Port: 465, IsSSL: true}
-}
-
-func saveEmailIntegrationConfig(db *gorm.DB, email *config.Email) error {
-	if email == nil {
-		email = defaultEmailIntegrationConfig()
-	}
-	raw, err := json.Marshal(email)
-	if err != nil {
-		return fmt.Errorf("encode smtp integration configuration: %w", err)
-	}
-	enabled := email.Host != "" && email.From != "" && email.Secret != "" && email.Port > 0
-	clean := db.Session(&gorm.Session{NewDB: true})
-	var current dataintegration.ConfigPO
-	err = clean.Where("kind = ? AND provider = ?", integrationKindEmail, "smtp").First(&current).Error
-	switch {
-	case errors.Is(err, gorm.ErrRecordNotFound):
-		return clean.Create(&dataintegration.ConfigPO{
-			Kind: integrationKindEmail, Provider: "smtp", Enabled: enabled, Config: string(raw),
-		}).Error
-	case err != nil:
-		return err
-	default:
-		return clean.Model(&current).Updates(map[string]any{"enabled": enabled, "config": string(raw)}).Error
-	}
-}
-
-func loadEmailIntegrationConfig(db *gorm.DB) (*config.Email, bool, error) {
-	var row dataintegration.ConfigPO
-	err := db.Session(&gorm.Session{NewDB: true}).
-		Where("kind = ? AND provider = ?", integrationKindEmail, "smtp").
-		First(&row).Error
-	if errors.Is(err, gorm.ErrRecordNotFound) {
-		return nil, false, nil
-	}
-	if err != nil {
-		return nil, false, err
-	}
-	if !json.Valid([]byte(row.Config)) {
-		return nil, false, errors.New("invalid smtp integration configuration")
-	}
-	email := defaultEmailIntegrationConfig()
-	if err = json.Unmarshal([]byte(row.Config), email); err != nil {
-		return nil, false, fmt.Errorf("decode smtp integration configuration: %w", err)
-	}
-	return email, true, nil
-}
-
-func resolveEmailIntegrationConfig(db *gorm.DB, legacy *config.Email) (*config.Email, error) {
-	clean := db.Session(&gorm.Session{NewDB: true})
-	if !clean.Migrator().HasTable(&dataintegration.ConfigPO{}) {
-		if legacy == nil {
-			return defaultEmailIntegrationConfig(), nil
-		}
-		return config.CloneEmail(legacy), nil
-	}
-	email, found, err := loadEmailIntegrationConfig(clean)
-	if err != nil {
-		return nil, err
-	}
-	if found {
-		return email, nil
-	}
-	if legacy == nil {
-		legacy = defaultEmailIntegrationConfig()
-	}
-	if err = saveEmailIntegrationConfig(clean, legacy); err != nil {
-		return nil, err
-	}
-	email, _, err = loadEmailIntegrationConfig(clean)
-	return email, err
+	return dataintegration.SaveStorageConfig(db, storage)
 }
 
 func (d *Data) persistEmailIntegrationConfig(ctx context.Context, email *config.Email) error {
 	if !d.databaseReady.Load() {
 		return errors.New("database is not initialized")
 	}
-	db := d.gormDB.WithContext(ctx)
-	if !db.Migrator().HasTable(&dataintegration.ConfigPO{}) {
+	db := d.gormDB.load().WithContext(ctx)
+	if !dataintegration.HasConfigTable(db) {
 		return errors.New("integration configuration table does not exist")
 	}
-	return saveEmailIntegrationConfig(db, email)
+	return dataintegration.SaveEmailConfig(db, email)
 }