É possível enviar uma matriz de objetos FormData em um httpClient.post?

Você está no caminho certo, mas enviar vários objetos FormData em um array diretamente do frontend para o backend não vai funcionar porque o objeto FormData deve ser enviado como uma entidade única. Em vez disso, você deve enviar os documentos como partes individuais em um único objeto FormData usando uma solicitação de formulário multiparte.

Etapa 1: Frontend - Modifique o objeto FormData para manipular vários arquivos Para enviar vários arquivos, você pode anexar os dados de cada documento ao mesmo objeto FormData com chaves exclusivas para cada documento. Isso permitirá que você envie vários documentos em uma solicitação HTTP.

Código de frontend atualizado:

public postSaveDocuments(entityType: DocumentEntityType, id: number, body: DocumentInputDto[]): Observable<Upload<UploadWithLockResultsDto>> {

    const url = `${DocumentationService.baseUrl}/${getUrlSegment(entityType)}/${id}/documents`;

    // Create a single FormData object for all documents
    const formData = new FormData();

    // Loop through the document DTOs and append each one
    body.forEach((documentInputDto, index) => {
      formData.append(`documents[${index}].documentId`, this.documentId.toString());
      formData.append(`documents[${index}].title`, this.title);
      formData.append(`documents[${index}].content`, this.content, this.content.name);
    });

    return this.httpClient.post(url, formData, {
      ...DocumentationService.options,
      reportProgress: true,
      observe: 'events',
      responseType: 'json'
    }).pipe(upload<UploadWithLockResultsDto>());
}

Etapa 2: Backend - Manipule os dados do formulário multipartes No backend, você precisa manipular os vários arquivos e seus metadados associados. Você pode fazer isso aceitando os dados como uma matriz MultipartFile ou um DTO personalizado, dependendo de como você prefere estruturar a solicitação. Como você está enviando metadados e arquivos, pode usar uma combinação de anotações @RequestParam e @ModelAttribute para vincular os dados do formulário e o conteúdo do arquivo.

Código de backend atualizado:

@PostMapping("/{documentEntityType}/{entityId}/documents")
public ResponseEntity<UploadWithLockResultsDto> saveDocuments(
    @PathVariable("documentEntityType") DocumentEntityType documentEntityType,
    @PathVariable("entityId") Integer entityId,
    @RequestParam("documents") List<MultipartFile> documents,
    @RequestParam Map<String, String> documentMetadata) throws AuthException, IOException {

    // Parse metadata and files
    List<DocumentInputDto> documentInputDtos = new ArrayList<>();
    for (int i = 0; i < documents.size(); i++) {
        MultipartFile file = documents.get(i);
        String documentId = documentMetadata.get("documents[" + i + "].documentId");
        String title = documentMetadata.get("documents[" + i + "].title");

        DocumentInputDto documentInputDto = new DocumentInputDto();
        documentInputDto.setDocumentId(Long.parseLong(documentId));
        documentInputDto.setTitle(title);
        documentInputDto.setContent(file); // Assuming the DocumentInputDto has a 'content' field for the file

        documentInputDtos.add(documentInputDto);
    }

    // Save the documents to the database
    var uploadWithLockResultsDto = documentService.updateDocuments(documentInputDtos, authentication.getName(), authentication.getPrincipal());
    return handleUploadWithLockResults(uploadWithLockResultsDto);
}

Etapa 3: atualize seu DocumentInputDto

public class DocumentInputDto {
    private Long documentId;
    private String title;
    private MultipartFile content; // The file being uploaded
    
    // Getters and setters...`enter code here`
}

O problema que você está enfrentando com o array documents retornando como nulo é provavelmente por causa de como o Spring manipula dados de formulário e uploads de arquivos multipart. O problema pode ser que você esteja enviando arquivos e dados de formulário (como metadados) sob o mesmo nome (documents[]) em sua solicitação, mas o Spring pode não estar mapeando corretamente as partes MultipartFile para os documentos List.

Vamos analisar alguns ajustes que você pode fazer para garantir que o Spring mapeie corretamente os dados do arquivo e os metadados para os campos apropriados.

Etapa 1: Atualize o código do frontend Você já está enviando os arquivos com metadados em um único objeto FormData. A questão principal é garantir a estrutura correta da solicitação para que o backend possa identificar corretamente os arquivos e os metadados. Os arquivos precisam ser enviados com campos de nome separados para cada documento, e os metadados devem seguir a mesma convenção de nomenclatura.

Aqui está o código de frontend atualizado para anexar vários documentos corretamente:

public postSaveDocuments(entityType: DocumentEntityType, id: number, body: DocumentInputDto[]): Observable<Upload<UploadWithLockResultsDto>> {
    const url = `${DocumentationService.baseUrl}/${getUrlSegment(entityType)}/${id}/documents`;

    // Create a single FormData object to handle multiple files and their metadata
    const formData = new FormData();

    // Loop through the document DTOs and append each one to the formData object
    body.forEach((documentInputDto, index) => {
        // Append metadata fields
        formData.append(`documents[${index}].documentId`, documentInputDto.documentId.toString());
        formData.append(`documents[${index}].title`, documentInputDto.title);

        // Append the file for this document
        formData.append(`documents[${index}].content`, documentInputDto.content, documentInputDto.content.name);
    });

    // Send the FormData as a POST request
    return this.httpClient.post(url, formData, {
        ...DocumentationService.options,
        reportProgress: true,
        observe: 'events',
        responseType: 'json'
    }).pipe(upload<UploadWithLockResultsDto>());
}

Etapa 2: Atualizar o código de backend O Spring usa o @RequestParam para vincular dados de formulário e uploads de arquivo. A chave para resolver esse problema é garantir que os metadados e os arquivos estejam vinculados corretamente aos parâmetros de backend. Veja como você pode ajustar o backend para manipular corretamente os uploads de arquivo e metadados:

MultipartFile Array: @RequestParam do Spring mapeará vários arquivos enviados com o mesmo nome para uma List. Mapeamento de Metadados: Para mapear os metadados do documento (como documentId e title), você pode usar um map ou um DTO personalizado. Aqui está o método de backend atualizado:

 @PostMapping("/{documentEntityType}/{entityId}/documents")
    public ResponseEntity<UploadWithLockResultsDto> saveDocuments(
        @PathVariable("documentEntityType") DocumentEntityType documentEntityType,
        @PathVariable("entityId") Integer entityId,
        @RequestParam("documents") List<MultipartFile> documents,  // Receive the files
        @RequestParam Map<String, String> documentMetadata) throws AuthException, IOException {
    
        // Ensure the documents and metadata are mapped correctly
        List<DocumentInputDto> documentInputDtos = new ArrayList<>();
        
        for (int i = 0; i < documents.size(); i++) {
            MultipartFile file = documents.get(i);
    
            // Retrieve metadata for each document
            String documentId = documentMetadata.get("documents[" + i + "].documentId");
            String title = documentMetadata.get("documents[" + i + "].title");
    
            // Create DocumentInputDto from metadata and file
            DocumentInputDto documentInputDto = new DocumentInputDto();
            documentInputDto.setDocumentId(Long.parseLong(documentId));
            documentInputDto.setTitle(title);
            documentInputDto.setContent(file); // Assuming 'content' is a MultipartFile field in your DTO
    
            documentInputDtos.add(documentInputDto);
        }
    
        // Save the documents to the database (service call)
        var uploadWithLockResultsDto = documentService.updateDocuments(documentInputDtos, authentication.getName(), authentication.getPrincipal());
        return handleUploadWithLockResults(uploadWithLockResultsDto);
    }

Etapa 3: Garanta que DocumentInputDto esteja correto Certifique-se de que sua classe DocumentInputDto tenha um campo para o MultipartFile e que você esteja usando getters e setters corretamente. Aqui está uma versão simples da classe DocumentInputDto:

public class DocumentInputDto {
    private Long documentId;
    private String title;
    private MultipartFile content; // The file being uploaded

    // Getters and setters
    public Long getDocumentId() {
        return documentId;
    }

    public void setDocumentId(Long documentId) {
        this.documentId = documentId;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public MultipartFile getContent() {
        return content;
    }

    public void setContent(MultipartFile content) {
        this.content = content;
    }
}

Etapa 4: Lidar com a configuração multipartes (se necessário) Certifique-se de que seu aplicativo Spring Boot esteja configurado para lidar com uploads de arquivos multipartes. Isso normalmente é feito no arquivo application.properties ou application.yml. Veja como você pode configurá-lo:

# application.properties
spring.servlet.multipart.enabled=true
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB