@RestController
@RequestMapping("/api")
public class ScanUploadController {

    @PostMapping("/upload")
    public ResponseEntity<Map<String, Object>> uploadScanImages(
            @RequestParam("image") MultipartFile imageFile,
            @RequestParam("imageCount") Integer imageCount,
            @RequestParam("id") String id,
            @RequestParam(value = "desc", required = false) String desc) {

        Map<String, Object> response = new HashMap<>();

        try {
            // 验证文件
            if (imageFile.isEmpty()) {
                response.put("network", false);
                response.put("msg", "上传文件为空");
                return ResponseEntity.badRequest().body(response);
            }

            // 生成文件名
            String fileName = id + "_" + System.currentTimeMillis() + ".pdf";
            String uploadDir = "/uploads/scan/";
            Path uploadPath = Paths.get(uploadDir);

            // 创建目录
            if (!Files.exists(uploadPath)) {
                Files.createDirectories(uploadPath);
            }

            // 保存文件
            Path filePath = uploadPath.resolve(fileName);
            Files.copy(imageFile.getInputStream(), filePath,
                      StandardCopyOption.REPLACE_EXISTING);

            // 记录到数据库
            ScanDocument document = new ScanDocument();
            document.setBusinessId(id);
            document.setDescription(desc);
            document.setImageCount(imageCount);
            document.setFilePath(filePath.toString());
            document.setFileName(fileName);
            document.setFileSize(imageFile.getSize());
            document.setUploadTime(new Date());

            scanDocumentService.save(document);

            // 返回成功响应
            response.put("network", true);
            response.put("msg", "上传成功");
            response.put("fileId", document.getId());
            response.put("fileName", fileName);

            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("文件上传失败", e);
            response.put("network", false);
            response.put("msg", "上传失败: " + e.getMessage());
            return ResponseEntity.status(500).body(response);
        }
    }
}

[ApiController]
[Route("api/[controller]")]
public class ScanUploadController : ControllerBase
{
    private readonly ILogger<ScanUploadController> _logger;
    private readonly IScanDocumentService _scanDocumentService;

    public ScanUploadController(ILogger<ScanUploadController> logger,
                               IScanDocumentService scanDocumentService)
    {
        _logger = logger;
        _scanDocumentService = scanDocumentService;
    }

    [HttpPost("upload")]
    public async Task<IActionResult> UploadScanImages(
        [FromForm] IFormFile image,
        [FromForm] int imageCount,
        [FromForm] string id,
        [FromForm] string desc = null)
    {
        try
        {
            // 验证文件
            if (image == null || image.Length == 0)
            {
                return BadRequest(new { network = false, msg = "上传文件为空" });
            }

            // 生成文件名
            var fileName = $"{id}_{DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()}.pdf";
            var uploadDir = Path.Combine(Directory.GetCurrentDirectory(), "uploads", "scan");

            // 创建目录
            if (!Directory.Exists(uploadDir))
            {
                Directory.CreateDirectory(uploadDir);
            }

            // 保存文件
            var filePath = Path.Combine(uploadDir, fileName);
            using (var stream = new FileStream(filePath, FileMode.Create))
            {
                await image.CopyToAsync(stream);
            }

            // 保存到数据库
            var document = new ScanDocument
            {
                BusinessId = id,
                Description = desc,
                ImageCount = imageCount,
                FilePath = filePath,
                FileName = fileName,
                FileSize = image.Length,
                UploadTime = DateTime.UtcNow
            };

            await _scanDocumentService.SaveAsync(document);

            // 返回成功响应
            return Ok(new
            {
                network = true,
                msg = "上传成功",
                fileId = document.Id,
                fileName = fileName
            });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "文件上传失败");
            return StatusCode(500, new { network = false, msg = $"上传失败: {ex.Message}" });
        }
    }
}

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "path/filepath"
    "strconv"
    "time"

    "github.com/gin-gonic/gin"
)

type ScanDocument struct {
    ID          uint      `json:"id" gorm:"primaryKey"`
    BusinessID  string    `json:"business_id"`
    Description string    `json:"description"`
    ImageCount  int       `json:"image_count"`
    FilePath    string    `json:"file_path"`
    FileName    string    `json:"file_name"`
    FileSize    int64     `json:"file_size"`
    UploadTime  time.Time `json:"upload_time"`
}

func uploadScanImages(c *gin.Context) {
    // 获取表单参数
    imageFile, header, err := c.Request.FormFile("image")
    if err != nil {
        c.JSON(http.StatusBadRequest, gin.H{
            "network": false,
            "msg":     "获取上传文件失败: " + err.Error(),
        })
        return
    }
    defer imageFile.Close()

    imageCount, _ := strconv.Atoi(c.PostForm("imageCount"))
    id := c.PostForm("id")
    desc := c.PostForm("desc")

    // 验证文件
    if header.Size == 0 {
        c.JSON(http.StatusBadRequest, gin.H{
            "network": false,
            "msg":     "上传文件为空",
        })
        return
    }

    // 生成文件名
    fileName := fmt.Sprintf("%s_%d.pdf", id, time.Now().UnixMilli())
    uploadDir := "./uploads/scan"

    // 创建目录
    if err := os.MkdirAll(uploadDir, 0755); err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "network": false,
            "msg":     "创建目录失败: " + err.Error(),
        })
        return
    }

    // 保存文件
    filePath := filepath.Join(uploadDir, fileName)
    dst, err := os.Create(filePath)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "network": false,
            "msg":     "创建文件失败: " + err.Error(),
        })
        return
    }
    defer dst.Close()

    if _, err := io.Copy(dst, imageFile); err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{
            "network": false,
            "msg":     "保存文件失败: " + err.Error(),
        })
        return
    }

    // 保存到数据库
    document := ScanDocument{
        BusinessID:  id,
        Description: desc,
        ImageCount:  imageCount,
        FilePath:    filePath,
        FileName:    fileName,
        FileSize:    header.Size,
        UploadTime:  time.Now(),
    }

    // 这里应该调用数据库服务保存记录
    // db.Create(&document)

    // 返回成功响应
    c.JSON(http.StatusOK, gin.H{
        "network":  true,
        "msg":      "上传成功",
        "fileId":   document.ID,
        "fileName": fileName,
    })
}

func main() {
    r := gin.Default()
    r.POST("/api/upload", uploadScanImages)
    r.Run(":8080")
}

use actix_multipart::Multipart;
use actix_web::{web, App, HttpResponse, HttpServer, Result};
use futures::{StreamExt, TryStreamExt};
use serde::{Deserialize, Serialize};
use std::io::Write;
use tokio::fs;
use uuid::Uuid;

#[derive(Serialize, Deserialize)]
struct ScanDocument {
    id: Option<u32>,
    business_id: String,
    description: Option<String>,
    image_count: i32,
    file_path: String,
    file_name: String,
    file_size: u64,
    upload_time: chrono::DateTime<chrono::Utc>,
}

#[derive(Serialize)]
struct UploadResponse {
    network: bool,
    msg: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    file_id: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    file_name: Option<String>,
}

async fn upload_scan_images(mut payload: Multipart) -> Result<HttpResponse> {
    let mut image_data: Option<Vec<u8>> = None;
    let mut image_count: Option<i32> = None;
    let mut business_id: Option<String> = None;
    let mut description: Option<String> = None;

    // 解析multipart数据
    while let Ok(Some(mut field)) = payload.try_next().await {
        let content_disposition = field.content_disposition();

        if let Some(name) = content_disposition.get_name() {
            match name {
                "image" => {
                    let mut data = Vec::new();
                    while let Some(chunk) = field.next().await {
                        let chunk = chunk?;
                        data.extend_from_slice(&chunk);
                    }
                    image_data = Some(data);
                }
                "imageCount" => {
                    let mut data = Vec::new();
                    while let Some(chunk) = field.next().await {
                        let chunk = chunk?;
                        data.extend_from_slice(&chunk);
                    }
                    if let Ok(count_str) = String::from_utf8(data) {
                        image_count = count_str.parse().ok();
                    }
                }
                "id" => {
                    let mut data = Vec::new();
                    while let Some(chunk) = field.next().await {
                        let chunk = chunk?;
                        data.extend_from_slice(&chunk);
                    }
                    if let Ok(id_str) = String::from_utf8(data) {
                        business_id = Some(id_str);
                    }
                }
                "desc" => {
                    let mut data = Vec::new();
                    while let Some(chunk) = field.next().await {
                        let chunk = chunk?;
                        data.extend_from_slice(&chunk);
                    }
                    if let Ok(desc_str) = String::from_utf8(data) {
                        description = Some(desc_str);
                    }
                }
                _ => {}
            }
        }
    }

    // 验证必要参数
    let image_data = match image_data {
        Some(data) if !data.is_empty() => data,
        _ => {
            return Ok(HttpResponse::BadRequest().json(UploadResponse {
                network: false,
                msg: "上传文件为空".to_string(),
                file_id: None,
                file_name: None,
            }));
        }
    };

    let business_id = business_id.unwrap_or_else(|| Uuid::new_v4().to_string());
    let image_count = image_count.unwrap_or(1);

    // 生成文件名
    let timestamp = chrono::Utc::now().timestamp_millis();
    let file_name = format!("{}_{}.pdf", business_id, timestamp);
    let upload_dir = "./uploads/scan";

    // 创建目录
    if let Err(e) = fs::create_dir_all(upload_dir).await {
        return Ok(HttpResponse::InternalServerError().json(UploadResponse {
            network: false,
            msg: format!("创建目录失败: {}", e),
            file_id: None,
            file_name: None,
        }));
    }

    // 保存文件
    let file_path = format!("{}/{}", upload_dir, file_name);
    if let Err(e) = fs::write(&file_path, &image_data).await {
        return Ok(HttpResponse::InternalServerError().json(UploadResponse {
            network: false,
            msg: format!("保存文件失败: {}", e),
            file_id: None,
            file_name: None,
        }));
    }

    // 保存到数据库
    let document = ScanDocument {
        id: None,
        business_id: business_id.clone(),
        description,
        image_count,
        file_path: file_path.clone(),
        file_name: file_name.clone(),
        file_size: image_data.len() as u64,
        upload_time: chrono::Utc::now(),
    };

    // 这里应该调用数据库服务保存记录
    // let saved_document = db_service.save(document).await?;

    // 返回成功响应
    Ok(HttpResponse::Ok().json(UploadResponse {
        network: true,
        msg: "上传成功".to_string(),
        file_id: Some(1), // document.id
        file_name: Some(file_name),
    }))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/api/upload", web::post().to(upload_scan_images))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}