package services import ( "context" "crypto/md5" "crypto/rand" "encoding/hex" "fmt" "io" "mime/multipart" "os" "path" "path/filepath" "strings" "time" "server/models" "github.com/qiniu/go-sdk/v7/auth/qbox" "github.com/qiniu/go-sdk/v7/storage" ) const ( SourceBackend = "backend" SourcePlatform = "platform" ) const ( ScopeTenant = "tenant" ScopeUser = "user" ) const ( StorageTypeLocal = "local" StorageTypeQiniu = "qiniu" ) type UploadContext struct { Source string Tid uint64 Tuid uint64 } func (c UploadContext) Scope() string { if c.Source == SourcePlatform { return ScopeTenant } if c.Tuid > 0 { return ScopeUser } return ScopeTenant } func BuildObjectKey(ctx UploadContext, ext string) string { datePath := time.Now().Format("2006/01/02") name := fmt.Sprintf("%d_%s%s", time.Now().UnixNano(), randomHex(6), normalizeExt(ext)) if ctx.Source == SourcePlatform { return path.Join(SourcePlatform, datePath, name) } if ctx.Tuid > 0 { return path.Join(SourceBackend, fmt.Sprint(ctx.Tid), fmt.Sprint(ctx.Tuid), datePath, name) } return path.Join(SourceBackend, fmt.Sprint(ctx.Tid), datePath, name) } func normalizeExt(ext string) string { ext = strings.TrimSpace(ext) if ext == "" { return "" } if !strings.HasPrefix(ext, ".") { ext = "." + ext } return strings.ToLower(ext) } func randomHex(n int) string { b := make([]byte, (n+1)/2) if _, err := rand.Read(b); err != nil { return fmt.Sprint(time.Now().UnixNano() % 1000000) } return hex.EncodeToString(b)[:n] } type StagedFile struct { TempPath string MD5 string Size int64 MimeType string Ext string } type UploadResult struct { URL string Key string Size int64 MD5 string MimeType string } type StorageService interface { Stage(file multipart.File, header *multipart.FileHeader) (*StagedFile, error) Commit(staged *StagedFile, ctx UploadContext) (*UploadResult, error) Discard(staged *StagedFile) error GetPublicURL(key string) string Delete(key string) error Move(oldKey, newKey string) error Type() string } type LocalStorage struct { BaseDir string BaseURL string } func NewLocalStorage() *LocalStorage { return &LocalStorage{ BaseDir: "uploads", BaseURL: "/", } } func (s *LocalStorage) Type() string { return StorageTypeLocal } func (s *LocalStorage) tempDir() string { return filepath.Join(s.BaseDir, ".tmp") } func (s *LocalStorage) Stage(file multipart.File, header *multipart.FileHeader) (*StagedFile, error) { dir := s.tempDir() if err := os.MkdirAll(dir, 0755); err != nil { return nil, fmt.Errorf("创建临时目录失败: %w", err) } tmp, err := os.CreateTemp(dir, "stage_*") if err != nil { return nil, fmt.Errorf("创建临时文件失败: %w", err) } defer tmp.Close() hash := md5.New() size, err := io.Copy(io.MultiWriter(tmp, hash), file) if err != nil { tmpPath := tmp.Name() _ = os.Remove(tmpPath) return nil, fmt.Errorf("读取上传文件失败: %w", err) } return &StagedFile{ TempPath: tmp.Name(), MD5: hex.EncodeToString(hash.Sum(nil)), Size: size, MimeType: mimeTypeOf(header), Ext: normalizeExt(filepath.Ext(header.Filename)), }, nil } func (s *LocalStorage) Commit(staged *StagedFile, ctx UploadContext) (*UploadResult, error) { if staged == nil { return nil, fmt.Errorf("待提交文件为空") } key := BuildObjectKey(ctx, staged.Ext) destPath := filepath.Join(s.BaseDir, filepath.FromSlash(key)) if err := os.MkdirAll(filepath.Dir(destPath), 0755); err != nil { return nil, fmt.Errorf("创建目录失败: %w", err) } if err := os.Rename(staged.TempPath, destPath); err != nil { if copyErr := copyFile(staged.TempPath, destPath); copyErr != nil { return nil, fmt.Errorf("保存文件失败: %w", copyErr) } _ = os.Remove(staged.TempPath) } return &UploadResult{ URL: s.GetPublicURL(key), Key: key, Size: staged.Size, MD5: staged.MD5, MimeType: staged.MimeType, }, nil } func (s *LocalStorage) Discard(staged *StagedFile) error { if staged == nil || staged.TempPath == "" { return nil } return os.Remove(staged.TempPath) } func (s *LocalStorage) GetPublicURL(key string) string { full := filepath.ToSlash(filepath.Join(s.BaseDir, filepath.FromSlash(key))) return s.BaseURL + strings.ReplaceAll(full, "\\", "/") } func (s *LocalStorage) Delete(key string) error { filePath := filepath.Join(s.BaseDir, filepath.FromSlash(key)) return os.Remove(filePath) } func (s *LocalStorage) Move(oldKey, newKey string) error { oldPath := filepath.Join(s.BaseDir, filepath.FromSlash(oldKey)) newPath := filepath.Join(s.BaseDir, filepath.FromSlash(newKey)) if err := os.MkdirAll(filepath.Dir(newPath), 0755); err != nil { return fmt.Errorf("创建目标目录失败: %w", err) } if err := os.Rename(oldPath, newPath); err != nil { if copyErr := copyFile(oldPath, newPath); copyErr != nil { return fmt.Errorf("移动文件失败: %w", copyErr) } _ = os.Remove(oldPath) } return nil } type QiniuStorage struct { AccessKey string SecretKey string Bucket string Domain string Region string } func NewQiniuStorage(cfg *models.StorageConfig) *QiniuStorage { return &QiniuStorage{ AccessKey: cfg.QiniuAccessKey, SecretKey: cfg.QiniuSecretKey, Bucket: cfg.QiniuBucket, Domain: cfg.QiniuDomain, Region: cfg.QiniuRegion, } } func (s *QiniuStorage) Type() string { return StorageTypeQiniu } func (s *QiniuStorage) getZone() *storage.Region { switch s.Region { case "z0": return &storage.ZoneHuadong case "z1": return &storage.ZoneHuabei case "z2": return &storage.ZoneHuanan case "na0": return &storage.ZoneBeimei case "as0": return &storage.ZoneXinjiapo case "cn-east-2": return &storage.ZoneHuadongZheJiang2 default: return &storage.ZoneHuadong } } func (s *QiniuStorage) Stage(file multipart.File, header *multipart.FileHeader) (*StagedFile, error) { tmp, err := os.CreateTemp("", "yz_upload_*") if err != nil { return nil, fmt.Errorf("创建临时文件失败: %w", err) } defer tmp.Close() hash := md5.New() size, err := io.Copy(io.MultiWriter(tmp, hash), file) if err != nil { _ = os.Remove(tmp.Name()) return nil, fmt.Errorf("读取上传文件失败: %w", err) } return &StagedFile{ TempPath: tmp.Name(), MD5: hex.EncodeToString(hash.Sum(nil)), Size: size, MimeType: mimeTypeOf(header), Ext: normalizeExt(filepath.Ext(header.Filename)), }, nil } func (s *QiniuStorage) Commit(staged *StagedFile, ctx UploadContext) (*UploadResult, error) { if staged == nil { return nil, fmt.Errorf("待提交文件为空") } key := BuildObjectKey(ctx, staged.Ext) f, err := os.Open(staged.TempPath) if err != nil { return nil, fmt.Errorf("打开临时文件失败: %w", err) } defer f.Close() mac := qbox.NewMac(s.AccessKey, s.SecretKey) putPolicy := storage.PutPolicy{Scope: s.Bucket} upToken := putPolicy.UploadToken(mac) cfg := storage.Config{ Region: s.getZone(), UseHTTPS: true, UseCdnDomains: false, } formUploader := storage.NewFormUploader(&cfg) ret := storage.PutRet{} if err := formUploader.Put(context.Background(), &ret, upToken, key, f, staged.Size, &storage.PutExtra{}); err != nil { return nil, fmt.Errorf("上传到七牛云失败: %w", err) } return &UploadResult{ URL: s.GetPublicURL(key), Key: key, Size: staged.Size, MD5: staged.MD5, MimeType: staged.MimeType, }, nil } func (s *QiniuStorage) Discard(staged *StagedFile) error { if staged == nil || staged.TempPath == "" { return nil } return os.Remove(staged.TempPath) } func (s *QiniuStorage) GetPublicURL(key string) string { domain := strings.TrimRight(s.Domain, "/") return fmt.Sprintf("%s/%s", domain, key) } func (s *QiniuStorage) Delete(key string) error { return s.runBucketManager(func(bm *storage.BucketManager) error { return bm.Delete(s.Bucket, key) }, "删除七牛云文件失败") } func (s *QiniuStorage) Move(oldKey, newKey string) error { return s.runBucketManager(func(bm *storage.BucketManager) error { return bm.Move(s.Bucket, oldKey, s.Bucket, newKey, false) }, "移动七牛云文件失败") } func (s *QiniuStorage) runBucketManager(fn func(*storage.BucketManager) error, errMsg string) error { mac := qbox.NewMac(s.AccessKey, s.SecretKey) cfg := storage.Config{Region: s.getZone(), UseHTTPS: true} bm := storage.NewBucketManager(mac, &cfg) if err := fn(bm); err != nil { return fmt.Errorf("%s: %w", errMsg, err) } return nil } func GetStorageService() (StorageService, error) { cfg, err := models.GetStorageConfig() if err != nil { return NewLocalStorage(), nil } switch cfg.StorageType { case "qiniu": if cfg.QiniuAccessKey == "" || cfg.QiniuSecretKey == "" || cfg.QiniuBucket == "" || cfg.QiniuDomain == "" { return nil, fmt.Errorf("七牛云配置不完整") } return NewQiniuStorage(cfg), nil case "local": return NewLocalStorage(), nil default: return NewLocalStorage(), nil } } func mimeTypeOf(header *multipart.FileHeader) string { if header == nil { return "" } return header.Header.Get("Content-Type") } func copyFile(src, dst string) error { in, err := os.Open(src) if err != nil { return err } defer in.Close() out, err := os.Create(dst) if err != nil { return err } defer out.Close() if _, err := io.Copy(out, in); err != nil { return err } return out.Sync() }