新增配置管理功能及多存储支持

- 添加管理员端 API，用于获取和更新完整配置。
- 添加公共端 API，用于获取非敏感配置信息。
- 增加本地存储（LocalStorage）、S3（S3Storage）、和 WebDAV（WebDAVStorage）存储类型的实现。
- 支持热更新存储配置和保存配置文件至磁盘。
- 更新 Swagger 文档以包含新接口定义。

internal/api/admin/config.go

@@ -0,0 +1,70 @@
+package admin
+
+import (
+	"FileRelay/internal/bootstrap"
+	"FileRelay/internal/config"
+	"FileRelay/internal/model"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ConfigHandler struct{}
+
+func NewConfigHandler() *ConfigHandler {
+	return &ConfigHandler{}
+}
+
+// GetConfig 获取当前完整配置
+// @Summary 获取完整配置
+// @Description 获取系统的完整配置文件内容（仅管理员）
+// @Tags         Admin
+// @Security AdminAuth
+// @Produce json
+// @Success 200 {object} config.Config
+// @Router /admin/config [get]
+func (h *ConfigHandler) GetConfig(c *gin.Context) {
+	c.JSON(http.StatusOK, config.GlobalConfig)
+}
+
+// UpdateConfig 更新配置
+// @Summary 更新配置
+// @Description 更新系统的配置文件内容（仅管理员）
+// @Tags         Admin
+// @Security AdminAuth
+// @Accept json
+// @Produce json
+// @Param config body config.Config true "新配置内容"
+// @Success 200 {object} model.Response
+// @Failure 400 {object} model.Response
+// @Failure 500 {object} model.Response
+// @Router /admin/config [put]
+func (h *ConfigHandler) UpdateConfig(c *gin.Context) {
+	var newConfig config.Config
+	if err := c.ShouldBindJSON(&newConfig); err != nil {
+		c.JSON(http.StatusBadRequest, model.ErrorResponse(model.CodeBadRequest, err.Error()))
+		return
+	}
+
+	// 简单的校验，防止数据库路径被改空等关键错误
+	if newConfig.Database.Path == "" {
+		newConfig.Database.Path = config.GlobalConfig.Database.Path
+	}
+
+	// 更新内存配置
+	config.UpdateGlobalConfig(&newConfig)
+
+	// 重新初始化存储（热更新业务逻辑）
+	if err := bootstrap.ReloadStorage(); err != nil {
+		c.JSON(http.StatusInternalServerError, model.ErrorResponse(model.CodeInternalError, "Failed to reload storage: "+err.Error()))
+		return
+	}
+
+	// 保存到文件
+	if err := config.SaveConfig(); err != nil {
+		c.JSON(http.StatusInternalServerError, model.ErrorResponse(model.CodeInternalError, "Failed to save config: "+err.Error()))
+		return
+	}
+
+	c.JSON(http.StatusOK, model.SuccessResponse("Config updated successfully and hot-reloaded"))
+}

internal/api/public/config.go

@@ -0,0 +1,41 @@
+package public
+
+import (
+	"FileRelay/internal/config"
+	"FileRelay/internal/model"
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+)
+
+type ConfigHandler struct{}
+
+func NewConfigHandler() *ConfigHandler {
+	return &ConfigHandler{}
+}
+
+// PublicConfig 公开配置结构
+type PublicConfig struct {
+	Site     config.SiteConfig   `json:"site"`
+	Upload   config.UploadConfig `json:"upload"`
+	APIToken struct {
+		Enabled bool `json:"enabled"`
+	} `json:"api_token"`
+}
+
+// GetPublicConfig 获取非敏感配置
+// @Summary 获取公共配置
+// @Description 获取前端展示所需的非敏感配置数据
+// @Tags         Public
+// @Produce      json
+// @Success 200 {object} model.Response{data=PublicConfig}
+// @Router /api/config [get]
+func (h *ConfigHandler) GetPublicConfig(c *gin.Context) {
+	pub := PublicConfig{
+		Site:   config.GlobalConfig.Site,
+		Upload: config.GlobalConfig.Upload,
+	}
+	pub.APIToken.Enabled = config.GlobalConfig.APIToken.Enabled
+
+	c.JSON(http.StatusOK, model.SuccessResponse(pub))
+}

internal/bootstrap/init.go

@@ -43,13 +43,15 @@ func InitDB() {
 	fmt.Println("Database initialized and migrated.")
 
 	// 初始化存储
-	initStorage()
+	if err := ReloadStorage(); err != nil {
+		log.Fatalf("Failed to initialize storage: %v", err)
+	}
 
 	// 初始化管理员 (如果不存在)
 	initAdmin()
 }
 
-func initStorage() {
+func ReloadStorage() error {
 	storageType := config.GlobalConfig.Storage.Type
 	switch storageType {
 	case "local":
@@ -61,13 +63,14 @@ func initStorage() {
 		cfg := config.GlobalConfig.Storage.S3
 		s3Storage, err := storage.NewS3Storage(context.Background(), cfg.Endpoint, cfg.Region, cfg.AccessKey, cfg.SecretKey, cfg.Bucket, cfg.UseSSL)
 		if err != nil {
-			log.Fatalf("Failed to initialize S3 storage: %v", err)
+			return err
 		}
 		storage.GlobalStorage = s3Storage
 	default:
-		log.Fatalf("Unsupported storage type: %s", storageType)
+		return fmt.Errorf("unsupported storage type: %s", storageType)
 	}
 	fmt.Printf("Storage initialized with type: %s\n", storageType)
+	return nil
 }
 
 func initAdmin() {

internal/config/config.go

@@ -2,6 +2,7 @@ package config
 
 import (
 	"os"
+	"sync"
 
 	"gopkg.in/yaml.v3"
 )
@@ -64,9 +65,16 @@ type DatabaseConfig struct {
 	Path string `yaml:"path"`
 }
 
-var GlobalConfig *Config
+var (
+	GlobalConfig *Config
+	ConfigPath   string
+	configLock   sync.RWMutex
+)
 
 func LoadConfig(path string) error {
+	configLock.Lock()
+	defer configLock.Unlock()
+
 	data, err := os.ReadFile(path)
 	if err != nil {
 		return err
@@ -78,5 +86,24 @@ func LoadConfig(path string) error {
 	}
 
 	GlobalConfig = &cfg
+	ConfigPath = path
 	return nil
 }
+
+func SaveConfig() error {
+	configLock.RLock()
+	defer configLock.RUnlock()
+
+	data, err := yaml.Marshal(GlobalConfig)
+	if err != nil {
+		return err
+	}
+
+	return os.WriteFile(ConfigPath, data, 0644)
+}
+
+func UpdateGlobalConfig(cfg *Config) {
+	configLock.Lock()
+	defer configLock.Unlock()
+	GlobalConfig = cfg
+}

internal/storage/local.go

@@ -0,0 +1,47 @@
+package storage
+
+import (
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+)
+
+type LocalStorage struct {
+	RootPath string
+}
+
+func NewLocalStorage(rootPath string) *LocalStorage {
+	// 确保根目录存在
+	if _, err := os.Stat(rootPath); os.IsNotExist(err) {
+		os.MkdirAll(rootPath, 0755)
+	}
+	return &LocalStorage{RootPath: rootPath}
+}
+
+func (s *LocalStorage) Save(ctx context.Context, path string, reader io.Reader) error {
+	fullPath := filepath.Join(s.RootPath, path)
+	dir := filepath.Dir(fullPath)
+	if _, err := os.Stat(dir); os.IsNotExist(err) {
+		os.MkdirAll(dir, 0755)
+	}
+
+	file, err := os.Create(fullPath)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	_, err = io.Copy(file, reader)
+	return err
+}
+
+func (s *LocalStorage) Open(ctx context.Context, path string) (io.ReadCloser, error) {
+	fullPath := filepath.Join(s.RootPath, path)
+	return os.Open(fullPath)
+}
+
+func (s *LocalStorage) Delete(ctx context.Context, path string) error {
+	fullPath := filepath.Join(s.RootPath, path)
+	return os.Remove(fullPath)
+}

internal/storage/s3.go

@@ -0,0 +1,72 @@
+package storage
+
+import (
+	"context"
+	"io"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/credentials"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+)
+
+type S3Storage struct {
+	client *s3.Client
+	bucket string
+}
+
+func NewS3Storage(ctx context.Context, endpoint, region, accessKey, secretKey, bucket string, useSSL bool) (*S3Storage, error) {
+	customResolver := aws.EndpointResolverWithOptionsFunc(func(service, region string, options ...interface{}) (aws.Endpoint, error) {
+		if endpoint != "" {
+			return aws.Endpoint{
+				URL:               endpoint,
+				SigningRegion:     region,
+				HostnameImmutable: true,
+			}, nil
+		}
+		return aws.Endpoint{}, &aws.EndpointNotFoundError{}
+	})
+
+	cfg, err := config.LoadDefaultConfig(ctx,
+		config.WithRegion(region),
+		config.WithCredentialsProvider(credentials.NewStaticCredentialsProvider(accessKey, secretKey, "")),
+		config.WithEndpointResolverWithOptions(customResolver),
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	client := s3.NewFromConfig(cfg)
+	return &S3Storage{
+		client: client,
+		bucket: bucket,
+	}, nil
+}
+
+func (s *S3Storage) Save(ctx context.Context, path string, reader io.Reader) error {
+	_, err := s.client.PutObject(ctx, &s3.PutObjectInput{
+		Bucket: aws.String(s.bucket),
+		Key:    aws.String(path),
+		Body:   reader,
+	})
+	return err
+}
+
+func (s *S3Storage) Open(ctx context.Context, path string) (io.ReadCloser, error) {
+	output, err := s.client.GetObject(ctx, &s3.GetObjectInput{
+		Bucket: aws.String(s.bucket),
+		Key:    aws.String(path),
+	})
+	if err != nil {
+		return nil, err
+	}
+	return output.Body, nil
+}
+
+func (s *S3Storage) Delete(ctx context.Context, path string) error {
+	_, err := s.client.DeleteObject(ctx, &s3.DeleteObjectInput{
+		Bucket: aws.String(s.bucket),
+		Key:    aws.String(path),
+	})
+	return err
+}

internal/storage/storage.go

@@ -0,0 +1,14 @@
+package storage
+
+import (
+	"context"
+	"io"
+)
+
+type Storage interface {
+	Save(ctx context.Context, path string, reader io.Reader) error
+	Open(ctx context.Context, path string) (io.ReadCloser, error)
+	Delete(ctx context.Context, path string) error
+}
+
+var GlobalStorage Storage

internal/storage/webdav.go

@@ -0,0 +1,54 @@
+package storage
+
+import (
+	"context"
+	"io"
+	"path/filepath"
+	"strings"
+
+	"github.com/studio-b12/gowebdav"
+)
+
+type WebDAVStorage struct {
+	client *gowebdav.Client
+	root   string
+}
+
+func NewWebDAVStorage(url, username, password, root string) *WebDAVStorage {
+	client := gowebdav.NewClient(url, username, password)
+	return &WebDAVStorage{
+		client: client,
+		root:   root,
+	}
+}
+
+func (s *WebDAVStorage) getFullPath(path string) string {
+	return filepath.ToSlash(filepath.Join(s.root, path))
+}
+
+func (s *WebDAVStorage) Save(ctx context.Context, path string, reader io.Reader) error {
+	fullPath := s.getFullPath(path)
+
+	// Ensure directory exists
+	dir := filepath.Dir(fullPath)
+	if dir != "." && dir != "/" {
+		parts := strings.Split(strings.Trim(dir, "/"), "/")
+		current := ""
+		for _, part := range parts {
+			current += "/" + part
+			_ = s.client.Mkdir(current, 0755)
+		}
+	}
+
+	return s.client.WriteStream(fullPath, reader, 0644)
+}
+
+func (s *WebDAVStorage) Open(ctx context.Context, path string) (io.ReadCloser, error) {
+	fullPath := s.getFullPath(path)
+	return s.client.ReadStream(fullPath)
+}
+
+func (s *WebDAVStorage) Delete(ctx context.Context, path string) error {
+	fullPath := s.getFullPath(path)
+	return s.client.Remove(fullPath)
+}