LokiStack/backend/services/storage.go

package services

import (
	"fmt"
	"time"

	"lokideploy/models"
	"lokideploy/pkg/crypto"
	"lokideploy/repository"
	"lokideploy/utils"
)

type StorageService struct{}

func NewStorageService() *StorageService {
	return &StorageService{}
}

func (s *StorageService) Create(name, storageType, endpoint, bucket, region, accessKey, secretKey, pathPrefix string, insecure, isDefault bool) (*models.StorageConfig, error) {
	encAccessKey, err := crypto.EncryptField(accessKey)
	if err != nil {
		return nil, fmt.Errorf("AccessKey 加密失败: %w", err)
	}
	encSecretKey, err := crypto.EncryptField(secretKey)
	if err != nil {
		return nil, fmt.Errorf("SecretKey 加密失败: %w", err)
	}

	storage := models.StorageConfig{
		ID:          repository.GetDB().NextID("storages"),
		Name:        name,
		StorageType: storageType,
		Endpoint:    endpoint,
		Bucket:      bucket,
		Region:      region,
		AccessKey:   encAccessKey,
		SecretKey:   encSecretKey,
		PathPrefix:  pathPrefix,
		Insecure:    insecure,
		IsDefault:   isDefault,
		CreatedAt:   time.Now(),
		UpdatedAt:   time.Now(),
	}

	db := repository.GetDB()
	if isDefault {
		db.Lock()
		for i := range db.Storages {
			db.Storages[i].IsDefault = false
		}
		db.Unlock()
	}
	db.Lock()
	db.Storages = append(db.Storages, storage)
	db.Unlock()
	db.RequestSave()

	return &storage, nil
}

func (s *StorageService) Get(id uint) (*models.StorageConfig, error) {
	db := repository.GetDB()
	db.RLock()
	defer db.RUnlock()
	for i := range db.Storages {
		if db.Storages[i].ID == id {
			st := db.Storages[i]
			return &st, nil
		}
	}
	return nil, utils.ErrNotFound
}

func (s *StorageService) List(page, pageSize int) ([]models.StorageConfig, int64, error) {
	db := repository.GetDB()
	db.RLock()
	defer db.RUnlock()

	total := int64(len(db.Storages))
	start := (page - 1) * pageSize
	if start < 0 || start >= len(db.Storages) {
		return []models.StorageConfig{}, total, nil
	}
	end := start + pageSize
	if end > len(db.Storages) {
		end = len(db.Storages)
	}
	result := make([]models.StorageConfig, end-start)
	copy(result, db.Storages[start:end])
	return result, total, nil
}

func (s *StorageService) Update(id uint, updates map[string]interface{}) error {
	db := repository.GetDB()
	db.Lock()
	defer db.Unlock()
	for i := range db.Storages {
		if db.Storages[i].ID == id {
			if v, ok := updates["name"].(string); ok {
				db.Storages[i].Name = v
			}
			if v, ok := updates["endpoint"].(string); ok {
				db.Storages[i].Endpoint = v
			}
			if v, ok := updates["bucket"].(string); ok {
				db.Storages[i].Bucket = v
			}
			if v, ok := updates["region"].(string); ok {
				db.Storages[i].Region = v
			}
			if v, ok := updates["isDefault"].(bool); ok {
				if v {
					for j := range db.Storages {
						db.Storages[j].IsDefault = false
					}
				}
				db.Storages[i].IsDefault = v
			}
			db.Storages[i].UpdatedAt = time.Now()
			db.RequestSave()
			return nil
		}
	}
	return utils.ErrNotFound
}

func (s *StorageService) Delete(id uint) error {
	db := repository.GetDB()
	db.Lock()
	defer db.Unlock()
	for i, st := range db.Storages {
		if st.ID == id {
			db.Storages = append(db.Storages[:i], db.Storages[i+1:]...)
			db.RequestSave()
			return nil
		}
	}
	return utils.ErrNotFound
}

func (s *StorageService) GetDefault() (*models.StorageConfig, error) {
	db := repository.GetDB()
	db.RLock()
	defer db.RUnlock()
	for i := range db.Storages {
		if db.Storages[i].IsDefault {
			st := db.Storages[i]
			return &st, nil
		}
	}
	return nil, utils.ErrNotFound
}