666 lines
21 KiB
Go
666 lines
21 KiB
Go
package services
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"encoding/csv"
|
||
"fmt"
|
||
"io"
|
||
stdhttp "net/http"
|
||
"net/url"
|
||
"os"
|
||
"path"
|
||
"path/filepath"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/aliyun/aliyun-oss-go-sdk/oss"
|
||
"github.com/aws/aws-sdk-go-v2/aws"
|
||
"github.com/aws/aws-sdk-go-v2/credentials"
|
||
"github.com/aws/aws-sdk-go-v2/service/s3"
|
||
"github.com/aws/aws-sdk-go-v2/service/s3/types"
|
||
"github.com/goravel/framework/contracts/http"
|
||
"github.com/goravel/framework/facades"
|
||
"github.com/minio/minio-go/v7"
|
||
miniocreds "github.com/minio/minio-go/v7/pkg/credentials"
|
||
"github.com/tencentyun/cos-go-sdk-v5"
|
||
|
||
apperrors "goravel/app/errors"
|
||
"goravel/app/http/helpers"
|
||
"goravel/app/models"
|
||
"goravel/app/utils"
|
||
"goravel/app/utils/errorlog"
|
||
)
|
||
|
||
type ExportService interface {
|
||
// ExportToCSV 导出数据到CSV文件
|
||
// headers: CSV表头
|
||
// data: 数据行，每行是一个字符串切片
|
||
// filename: 文件名（不含扩展名）
|
||
// skipAutoCreate: 是否跳过自动创建导出记录（用于异步任务）
|
||
// 返回: 文件路径和错误
|
||
ExportToCSV(headers []string, data [][]string, filename string, skipAutoCreate ...bool) (string, error)
|
||
|
||
// ExportToCSVStream 流式导出到 CSV（只支持 local/public 磁盘，避免百万级导出把内存打爆）
|
||
// headers: CSV 表头
|
||
// filename: 文件名（不含扩展名）
|
||
// write: 回调里持续调用 writer.Write(row) 写入数据；回调返回 error 会终止导出
|
||
// skipAutoCreate: 是否跳过自动创建导出记录（用于异步任务）
|
||
ExportToCSVStream(headers []string, filename string, write func(writer *csv.Writer) error, skipAutoCreate ...bool) (string, error)
|
||
|
||
// ExportToCSVStreamAt 流式导出到指定 filePath（包含目录+文件名，如 exports/orders_1_20260107.csv）
|
||
// 用于“导出中”就先写入 exports 表的 Path/Filename 等字段，完成后只更新 size/status。
|
||
ExportToCSVStreamAt(headers []string, filePath string, write func(writer *csv.Writer) error, skipAutoCreate ...bool) (string, error)
|
||
|
||
// ExportToCSVStreamAtWithProgress 流式导出到指定 filePath，并通过回调返回已写入字节数（可用于实时更新 exports.size）
|
||
ExportToCSVStreamAtWithProgress(headers []string, filePath string, write func(writer *csv.Writer) error, onProgress func(writtenBytes int64), skipAutoCreate ...bool) (string, error)
|
||
|
||
// ExportToFile 导出数据到文件（根据配置的格式）
|
||
// headers: 表头
|
||
// data: 数据行
|
||
// filename: 文件名（不含扩展名）
|
||
// 返回: 文件路径和错误
|
||
ExportToFile(headers []string, data [][]string, filename string) (string, error)
|
||
|
||
// GetExportURL 获取导出文件的访问URL
|
||
// filePath: 文件路径
|
||
// 返回: 访问URL
|
||
GetExportURL(filePath string) string
|
||
}
|
||
|
||
type ExportServiceImpl struct {
|
||
ctx http.Context
|
||
disk string
|
||
path string
|
||
format string
|
||
}
|
||
|
||
func NewExportService(ctx http.Context) ExportService {
|
||
// 从数据库读取文件存储配置，如果不存在则使用默认值
|
||
// 优先使用 file_disk，如果没有则使用 storage_disk（向后兼容），再尝试 export_disk，最后使用默认值 local
|
||
disk := utils.GetConfigValue("storage", "file_disk", "")
|
||
if disk == "" {
|
||
disk = utils.GetConfigValue("storage", "storage_disk", "")
|
||
}
|
||
if disk == "" {
|
||
// 向后兼容 export_disk
|
||
disk = utils.GetConfigValue("storage", "export_disk", "")
|
||
}
|
||
// 如果都不存在，使用默认值 local
|
||
if disk == "" {
|
||
disk = "local"
|
||
}
|
||
|
||
// 记录使用的存储驱动（用于调试）
|
||
// facades.Log().Debugf("ExportService: using storage disk: %s", disk)
|
||
|
||
// 文件路径默认使用 exports，不再从配置读取
|
||
path := "exports"
|
||
// 文件格式默认使用 csv，不再从配置读取
|
||
format := "csv"
|
||
|
||
return &ExportServiceImpl{
|
||
ctx: ctx,
|
||
disk: disk,
|
||
path: path,
|
||
format: format,
|
||
}
|
||
}
|
||
|
||
// ExportToCSVStream 流式导出 CSV（仅 local/public）
|
||
func (s *ExportServiceImpl) ExportToCSVStream(headers []string, filename string, write func(writer *csv.Writer) error, skipAutoCreate ...bool) (string, error) {
|
||
timestamp := time.Now().Format("20060102_150405")
|
||
filename = fmt.Sprintf("%s_%s.csv", filename, timestamp)
|
||
// 注意：存储路径统一使用 "/"，避免 Windows 下 filepath.Join 生成 "\" 导致云存储对象 key 异常
|
||
filePath := path.Join(s.path, filename)
|
||
|
||
return s.ExportToCSVStreamAt(headers, filePath, write, skipAutoCreate...)
|
||
}
|
||
|
||
func (s *ExportServiceImpl) ExportToCSVStreamAt(headers []string, filePath string, write func(writer *csv.Writer) error, skipAutoCreate ...bool) (string, error) {
|
||
return s.ExportToCSVStreamAtWithProgress(headers, filePath, write, nil, skipAutoCreate...)
|
||
}
|
||
|
||
type progressWriter struct {
|
||
w io.Writer
|
||
written int64
|
||
lastTick time.Time
|
||
interval time.Duration
|
||
cb func(int64)
|
||
}
|
||
|
||
func (p *progressWriter) Write(b []byte) (int, error) {
|
||
n, err := p.w.Write(b)
|
||
if n > 0 {
|
||
p.written += int64(n)
|
||
if p.cb != nil && (p.interval <= 0 || time.Since(p.lastTick) >= p.interval) {
|
||
p.lastTick = time.Now()
|
||
p.cb(p.written)
|
||
}
|
||
}
|
||
return n, err
|
||
}
|
||
|
||
func (s *ExportServiceImpl) ExportToCSVStreamAtWithProgress(headers []string, filePath string, write func(writer *csv.Writer) error, onProgress func(writtenBytes int64), skipAutoCreate ...bool) (string, error) {
|
||
// 规范化
|
||
filePath = path.Clean(strings.ReplaceAll(filePath, "\\", "/"))
|
||
displayName := path.Base(filePath)
|
||
|
||
// local/public：直接写到磁盘 root 下（最省资源）
|
||
if s.disk == "local" || s.disk == "public" {
|
||
// 获取磁盘 root，直接写到 root 下，避免先缓存在内存再 Put
|
||
root := facades.Config().GetString(fmt.Sprintf("filesystems.disks.%s.root", s.disk), "")
|
||
if root == "" {
|
||
return "", fmt.Errorf("filesystems.disks.%s.root is empty, can't stream write", s.disk)
|
||
}
|
||
|
||
absPath := filepath.Join(root, filepath.FromSlash(filePath))
|
||
if err := os.MkdirAll(filepath.Dir(absPath), 0o755); err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "创建导出目录失败", map[string]any{
|
||
"abs_path": absPath,
|
||
"error": err.Error(),
|
||
}, "创建导出目录失败: %w", err)
|
||
}
|
||
return "", fmt.Errorf("创建导出目录失败: %w", err)
|
||
}
|
||
|
||
f, err := os.Create(absPath)
|
||
if err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "创建导出文件失败", map[string]any{
|
||
"abs_path": absPath,
|
||
"error": err.Error(),
|
||
}, "创建导出文件失败: %w", err)
|
||
}
|
||
return "", fmt.Errorf("创建导出文件失败: %w", err)
|
||
}
|
||
defer func() {
|
||
_ = f.Close()
|
||
}()
|
||
|
||
pw := &progressWriter{
|
||
w: f,
|
||
lastTick: time.Now(),
|
||
interval: 2 * time.Second,
|
||
cb: onProgress,
|
||
}
|
||
writer := csv.NewWriter(pw)
|
||
|
||
// 写入表头
|
||
if len(headers) > 0 {
|
||
if err := writer.Write(headers); err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "写入CSV表头失败", map[string]any{
|
||
"filename": displayName,
|
||
"error": err.Error(),
|
||
}, "写入CSV表头失败: %w", err)
|
||
}
|
||
return "", apperrors.ErrWriteCSVHeaderFailed.WithError(err)
|
||
}
|
||
}
|
||
|
||
// 由调用方流式写入数据
|
||
if err := write(writer); err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "写入CSV数据失败", map[string]any{
|
||
"filename": displayName,
|
||
"error": err.Error(),
|
||
}, "写入CSV数据失败: %w", err)
|
||
}
|
||
return "", apperrors.ErrWriteCSVDataFailed.WithError(err)
|
||
}
|
||
|
||
writer.Flush()
|
||
if onProgress != nil {
|
||
onProgress(pw.written)
|
||
}
|
||
if err := writer.Error(); err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "CSV写入失败", map[string]any{
|
||
"filename": displayName,
|
||
"error": err.Error(),
|
||
}, "CSV写入失败: %w", err)
|
||
}
|
||
return "", apperrors.ErrCSVWriteFailed.WithError(err)
|
||
}
|
||
|
||
// 记录导出日志到数据库（尽量避免影响主流程，错误仅记日志）
|
||
shouldSkip := len(skipAutoCreate) > 0 && skipAutoCreate[0]
|
||
if !shouldSkip {
|
||
// 复用 ExportToCSV 的异步记录逻辑：这里先简单沿用（不阻塞主流程）
|
||
go s.recordExportLog(filePath, absPath)
|
||
}
|
||
|
||
return filePath, nil
|
||
}
|
||
|
||
// 云存储（s3/oss/cos/minio）：先流式写到本地临时文件，再“流式/文件上传”到云盘，然后删除临时文件
|
||
tmpFile, err := os.CreateTemp(os.TempDir(), "export-*.csv")
|
||
if err != nil {
|
||
return "", fmt.Errorf("创建临时导出文件失败: %w", err)
|
||
}
|
||
tmpPath := tmpFile.Name()
|
||
defer func() {
|
||
_ = tmpFile.Close()
|
||
}()
|
||
|
||
pw := &progressWriter{
|
||
w: tmpFile,
|
||
lastTick: time.Now(),
|
||
interval: 2 * time.Second,
|
||
cb: onProgress,
|
||
}
|
||
writer := csv.NewWriter(pw)
|
||
if len(headers) > 0 {
|
||
if err := writer.Write(headers); err != nil {
|
||
_ = os.Remove(tmpPath)
|
||
return "", apperrors.ErrWriteCSVHeaderFailed.WithError(err)
|
||
}
|
||
}
|
||
if err := write(writer); err != nil {
|
||
writer.Flush()
|
||
if onProgress != nil {
|
||
onProgress(pw.written)
|
||
}
|
||
_ = os.Remove(tmpPath)
|
||
return "", apperrors.ErrWriteCSVDataFailed.WithError(err)
|
||
}
|
||
writer.Flush()
|
||
if onProgress != nil {
|
||
onProgress(pw.written)
|
||
}
|
||
if err := writer.Error(); err != nil {
|
||
_ = os.Remove(tmpPath)
|
||
return "", apperrors.ErrCSVWriteFailed.WithError(err)
|
||
}
|
||
if err := tmpFile.Close(); err != nil {
|
||
_ = os.Remove(tmpPath)
|
||
return "", fmt.Errorf("关闭临时导出文件失败: %w", err)
|
||
}
|
||
|
||
if err := s.uploadLocalFileToCloudDisk(tmpPath, filePath); err != nil {
|
||
// 上传失败：保留临时文件便于排查（同时记录日志）
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "上传云存储失败", map[string]any{
|
||
"disk": s.disk,
|
||
"tmp_path": tmpPath,
|
||
"dest_path": filePath,
|
||
"error": err.Error(),
|
||
}, "上传云存储失败: %v", err)
|
||
} else {
|
||
facades.Log().Errorf("export upload failed: disk=%s tmp=%s dest=%s err=%v", s.disk, tmpPath, filePath, err)
|
||
}
|
||
return "", err
|
||
}
|
||
|
||
_ = os.Remove(tmpPath)
|
||
|
||
shouldSkip := len(skipAutoCreate) > 0 && skipAutoCreate[0]
|
||
if !shouldSkip {
|
||
go s.recordExportLog(filePath, tmpPath)
|
||
}
|
||
|
||
return filePath, nil
|
||
}
|
||
|
||
// ExportToCSV 导出数据到CSV文件
|
||
// skipAutoCreate: 是否跳过自动创建导出记录（用于异步任务，避免重复创建）
|
||
func (s *ExportServiceImpl) ExportToCSV(headers []string, data [][]string, filename string, skipAutoCreate ...bool) (string, error) {
|
||
timestamp := time.Now().Format("20060102_150405")
|
||
filename = fmt.Sprintf("%s_%s.csv", filename, timestamp)
|
||
filePath := path.Join(s.path, filename)
|
||
|
||
// 创建CSV内容缓冲区
|
||
var buf bytes.Buffer
|
||
writer := csv.NewWriter(&buf)
|
||
|
||
// 写入表头
|
||
if len(headers) > 0 {
|
||
if err := writer.Write(headers); err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "写入CSV表头失败", map[string]any{
|
||
"filename": filename,
|
||
"error": err.Error(),
|
||
}, "写入CSV表头失败: %w", err)
|
||
}
|
||
return "", apperrors.ErrWriteCSVHeaderFailed.WithError(err)
|
||
}
|
||
}
|
||
|
||
// 写入数据
|
||
for _, row := range data {
|
||
if err := writer.Write(row); err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "写入CSV数据失败", map[string]any{
|
||
"filename": filename,
|
||
"error": err.Error(),
|
||
}, "写入CSV数据失败: %w", err)
|
||
}
|
||
return "", apperrors.ErrWriteCSVDataFailed.WithError(err)
|
||
}
|
||
}
|
||
|
||
writer.Flush()
|
||
if err := writer.Error(); err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "CSV写入失败", map[string]any{
|
||
"filename": filename,
|
||
"error": err.Error(),
|
||
}, "CSV写入失败: %w", err)
|
||
}
|
||
return "", apperrors.ErrCSVWriteFailed.WithError(err)
|
||
}
|
||
|
||
// 获取存储驱动
|
||
storage := facades.Storage().Disk(s.disk)
|
||
|
||
// 写入文件
|
||
if err := storage.Put(filePath, buf.String()); err != nil {
|
||
if s.ctx != nil {
|
||
errorlog.RecordHTTP(s.ctx, "export", "保存文件失败", map[string]any{
|
||
"filename": filename,
|
||
"file_path": filePath,
|
||
"error": err.Error(),
|
||
}, "保存文件失败: %w", err)
|
||
}
|
||
return "", apperrors.ErrSaveFileFailed.WithError(err)
|
||
}
|
||
|
||
// 获取文件大小（如果存储驱动支持 Size 方法）
|
||
var size int64
|
||
if fileInfo, err := storage.Size(filePath); err == nil {
|
||
size = fileInfo
|
||
}
|
||
|
||
// 记录导出日志到数据库（尽量避免影响主流程，错误仅记日志）
|
||
// 如果 skipAutoCreate 为 true，则跳过自动创建（用于异步任务）
|
||
shouldSkip := len(skipAutoCreate) > 0 && skipAutoCreate[0]
|
||
if !shouldSkip {
|
||
go func() {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
facades.Log().Errorf("ExportService: panic while recording export log: %v", r)
|
||
}
|
||
}()
|
||
|
||
adminID := uint(0)
|
||
if s.ctx != nil {
|
||
if id, err := helpers.GetAdminIDFromContext(s.ctx); err == nil {
|
||
adminID = id
|
||
}
|
||
}
|
||
|
||
ext := ""
|
||
if dot := strings.LastIndex(filename, "."); dot != -1 {
|
||
ext = filename[dot+1:]
|
||
} else if dot := strings.LastIndex(filePath, "."); dot != -1 {
|
||
ext = filePath[dot+1:]
|
||
}
|
||
|
||
// 尝试从 context 中获取导出类型
|
||
exportType := ""
|
||
if s.ctx != nil {
|
||
if typeValue := s.ctx.Value("export_type"); typeValue != nil {
|
||
if typeStr, ok := typeValue.(string); ok {
|
||
exportType = typeStr
|
||
}
|
||
}
|
||
}
|
||
|
||
exportRecord := models.Export{
|
||
AdminID: adminID,
|
||
Type: exportType,
|
||
Disk: s.disk,
|
||
Path: filePath,
|
||
Filename: filepath.Base(filePath),
|
||
Extension: ext,
|
||
Size: size,
|
||
Status: 1,
|
||
}
|
||
|
||
if err := facades.Orm().Query().Create(&exportRecord); err != nil {
|
||
facades.Log().Errorf("ExportService: failed to record export log: %v", err)
|
||
}
|
||
}()
|
||
}
|
||
|
||
return filePath, nil
|
||
}
|
||
|
||
func (s *ExportServiceImpl) recordExportLog(filePath string, absOrTmpPathForSize string) {
|
||
defer func() {
|
||
if r := recover(); r != nil {
|
||
facades.Log().Errorf("ExportService: panic while recording export log: %v", r)
|
||
}
|
||
}()
|
||
|
||
size := int64(0)
|
||
if fi, err := os.Stat(absOrTmpPathForSize); err == nil {
|
||
size = fi.Size()
|
||
}
|
||
|
||
adminID := uint(0)
|
||
if s.ctx != nil {
|
||
if id, err := helpers.GetAdminIDFromContext(s.ctx); err == nil {
|
||
adminID = id
|
||
}
|
||
}
|
||
|
||
ext := "csv"
|
||
exportType := ""
|
||
if s.ctx != nil {
|
||
if typeValue := s.ctx.Value("export_type"); typeValue != nil {
|
||
if typeStr, ok := typeValue.(string); ok {
|
||
exportType = typeStr
|
||
}
|
||
}
|
||
}
|
||
|
||
exportRecord := models.Export{
|
||
AdminID: adminID,
|
||
Type: exportType,
|
||
Disk: s.disk,
|
||
Path: filePath,
|
||
Filename: path.Base(filePath),
|
||
Extension: ext,
|
||
Size: size,
|
||
Status: 1,
|
||
}
|
||
|
||
if err := facades.Orm().Query().Create(&exportRecord); err != nil {
|
||
facades.Log().Errorf("ExportService: failed to record export log: %v", err)
|
||
}
|
||
}
|
||
|
||
func (s *ExportServiceImpl) uploadLocalFileToCloudDisk(localFilePath string, destPath string) error {
|
||
destPath = strings.TrimPrefix(destPath, "/")
|
||
switch s.disk {
|
||
case "s3":
|
||
return s.uploadToS3(localFilePath, destPath)
|
||
case "minio":
|
||
return s.uploadToMinio(localFilePath, destPath)
|
||
case "oss":
|
||
return s.uploadToOss(localFilePath, destPath)
|
||
case "cos":
|
||
return s.uploadToCos(localFilePath, destPath)
|
||
default:
|
||
return fmt.Errorf("unsupported cloud disk for stream export: %s", s.disk)
|
||
}
|
||
}
|
||
|
||
func (s *ExportServiceImpl) uploadToS3(localFilePath, key string) error {
|
||
cfg := facades.Config()
|
||
accessKeyId := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.key", s.disk))
|
||
accessKeySecret := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.secret", s.disk))
|
||
region := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.region", s.disk))
|
||
bucket := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.bucket", s.disk))
|
||
token := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.token", s.disk))
|
||
endpoint := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.endpoint", s.disk))
|
||
usePathStyle := cfg.GetBool(fmt.Sprintf("filesystems.disks.%s.use_path_style", s.disk), true)
|
||
objectCannedACL := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.object_canned_acl", s.disk))
|
||
if accessKeyId == "" || accessKeySecret == "" || region == "" || bucket == "" {
|
||
return fmt.Errorf("please set %s configuration first", s.disk)
|
||
}
|
||
|
||
options := s3.Options{
|
||
Region: region,
|
||
Credentials: aws.NewCredentialsCache(
|
||
credentials.NewStaticCredentialsProvider(accessKeyId, accessKeySecret, token)),
|
||
UsePathStyle: usePathStyle,
|
||
}
|
||
if endpoint != "" {
|
||
options.BaseEndpoint = aws.String(endpoint)
|
||
}
|
||
client := s3.New(options)
|
||
|
||
f, err := os.Open(localFilePath)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
defer func() { _ = f.Close() }()
|
||
fi, err := f.Stat()
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
input := &s3.PutObjectInput{
|
||
Bucket: aws.String(bucket),
|
||
Key: aws.String(key),
|
||
Body: f,
|
||
ContentLength: aws.Int64(fi.Size()),
|
||
ContentType: aws.String("text/csv; charset=utf-8"),
|
||
}
|
||
if objectCannedACL != "" {
|
||
input.ACL = types.ObjectCannedACL(objectCannedACL)
|
||
}
|
||
|
||
_, err = client.PutObject(context.Background(), input)
|
||
return err
|
||
}
|
||
|
||
func (s *ExportServiceImpl) uploadToMinio(localFilePath, key string) error {
|
||
cfg := facades.Config()
|
||
accessKeyId := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.key", s.disk))
|
||
accessKeySecret := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.secret", s.disk))
|
||
region := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.region", s.disk))
|
||
bucket := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.bucket", s.disk))
|
||
endpoint := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.endpoint", s.disk))
|
||
ssl := cfg.GetBool(fmt.Sprintf("filesystems.disks.%s.ssl", s.disk), false)
|
||
if accessKeyId == "" || accessKeySecret == "" || bucket == "" || endpoint == "" {
|
||
return fmt.Errorf("please set %s configuration first", s.disk)
|
||
}
|
||
endpoint = strings.TrimPrefix(endpoint, "http://")
|
||
endpoint = strings.TrimPrefix(endpoint, "https://")
|
||
|
||
client, err := minio.New(endpoint, &minio.Options{
|
||
Creds: miniocreds.NewStaticV4(accessKeyId, accessKeySecret, ""),
|
||
Secure: ssl,
|
||
Region: region,
|
||
})
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
_, err = client.FPutObject(context.Background(), bucket, key, localFilePath, minio.PutObjectOptions{
|
||
ContentType: "text/csv; charset=utf-8",
|
||
})
|
||
return err
|
||
}
|
||
|
||
func (s *ExportServiceImpl) uploadToOss(localFilePath, key string) error {
|
||
cfg := facades.Config()
|
||
accessKeyId := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.key", s.disk))
|
||
accessKeySecret := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.secret", s.disk))
|
||
bucket := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.bucket", s.disk))
|
||
endpoint := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.endpoint", s.disk))
|
||
if accessKeyId == "" || accessKeySecret == "" || bucket == "" || endpoint == "" {
|
||
return fmt.Errorf("please set %s configuration first", s.disk)
|
||
}
|
||
client, err := oss.New(endpoint, accessKeyId, accessKeySecret)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
bucketInstance, err := client.Bucket(bucket)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return bucketInstance.PutObjectFromFile(key, localFilePath)
|
||
}
|
||
|
||
func (s *ExportServiceImpl) uploadToCos(localFilePath, key string) error {
|
||
cfg := facades.Config()
|
||
accessKeyId := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.key", s.disk))
|
||
accessKeySecret := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.secret", s.disk))
|
||
cosUrl := cfg.GetString(fmt.Sprintf("filesystems.disks.%s.url", s.disk))
|
||
if accessKeyId == "" || accessKeySecret == "" || cosUrl == "" {
|
||
return fmt.Errorf("please set %s configuration first", s.disk)
|
||
}
|
||
u, err := url.Parse(cosUrl)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
b := &cos.BaseURL{BucketURL: u}
|
||
client := cos.NewClient(b, &stdhttp.Client{
|
||
Transport: &cos.AuthorizationTransport{
|
||
SecretID: accessKeyId,
|
||
SecretKey: accessKeySecret,
|
||
},
|
||
})
|
||
_, _, err = client.Object.Upload(context.Background(), key, localFilePath, nil)
|
||
return err
|
||
}
|
||
|
||
// ExportToFile 导出数据到文件（根据配置的格式）
|
||
func (s *ExportServiceImpl) ExportToFile(headers []string, data [][]string, filename string) (string, error) {
|
||
switch s.format {
|
||
case "csv":
|
||
return s.ExportToCSV(headers, data, filename)
|
||
case "xlsx":
|
||
return "", apperrors.ErrExcelNotImplemented
|
||
default:
|
||
return s.ExportToCSV(headers, data, filename)
|
||
}
|
||
}
|
||
|
||
func (s *ExportServiceImpl) GetExportURL(filePath string) string {
|
||
// 根据不同的存储类型从配置读取 URL
|
||
var configURL string
|
||
switch s.disk {
|
||
case "s3":
|
||
configURL = utils.GetConfigValue("storage", "s3_url", "")
|
||
case "oss":
|
||
configURL = utils.GetConfigValue("storage", "oss_url", "")
|
||
case "cos":
|
||
configURL = utils.GetConfigValue("storage", "cos_url", "")
|
||
case "qiniu":
|
||
configURL = utils.GetConfigValue("storage", "qiniu_domain", "")
|
||
case "minio":
|
||
configURL = utils.GetConfigValue("storage", "minio_url", "")
|
||
}
|
||
|
||
if configURL != "" {
|
||
// 确保 URL 以 / 结尾，然后拼接文件路径
|
||
if !strings.HasSuffix(configURL, "/") {
|
||
configURL += "/"
|
||
}
|
||
return configURL + filePath
|
||
}
|
||
|
||
// 对于 local 和 public 存储，使用下载接口而不是直接文件路径
|
||
// 这样可以避免被前端路由拦截
|
||
if s.disk == "local" || s.disk == "public" {
|
||
// 返回下载接口 URL，需要从 context 中获取导出记录 ID
|
||
// 但这里没有 ID，所以需要修改调用方式
|
||
// 暂时返回一个占位符，实际 URL 在 ExportController.Index 中生成
|
||
return ""
|
||
}
|
||
|
||
storage := facades.Storage().Disk(s.disk)
|
||
if url, err := storage.TemporaryUrl(filePath, time.Now().Add(24*time.Hour)); err == nil {
|
||
return url
|
||
}
|
||
|
||
return "/storage/" + filePath
|
||
}
|