Frontend : Interface utilisateur pour la sélection et l'envoi de fichiers

La partie frontend comprend un formulaire HTML avec un champ de type fichier pour permettre aux utilisateusr de sélectionner des documents à télécharger. L'attribut accept définit les types MIME autorisés, tels que les documents Word, PDF, ou fichiers texte. L'attribut multiple permet de sélectionner plusieurs fichiers simultanément.

<input id="documentInput" class="file-selector" type="file" multiple accept="application/msword, application/pdf, text/plain, application/vnd.openxmlformats-officedocument.wordprocessingml.document, application/vnd.ms-excel">

Le code JavaScript gère l'envoi asynchrone des fichiers au serveeur via une requête AJAX. On utilise l'objet FormData pour encapsuler les données, y compris le fichier et des métadonnées comme un token de sécurité. La validation côté cliant vérifie qu'un fichier a été sélectionné avant l'envoi.

function handleFileUpload() {
    const selectedFile = document.getElementById('documentInput').files[0];
    if (!selectedFile) {
        alert('Veuillez sélectionner un fichier.');
        return;
    }
    const payload = new FormData();
    payload.append('document', selectedFile);
    payload.append('authToken', document.getElementById('securityToken').value);
    payload.append('documentCategory', 'rapport');

    fetch('/api/v1/documents/envoyer', {
        method: 'POST',
        body: payload,
        headers: {
            'Authorization': 'Bearer ' + getAuthToken()
        }
    })
    .then(response => response.json())
    .then(data => {
        if (data.status === 'success') {
            console.log('Fichier envoyé avec succès.');
            document.getElementById('documentInput').value = '';
            refreshDocumentList();
        } else {
            console.error('Échec de l\'envoi :', data.message);
        }
    })
    .catch(error => {
        console.error('Erreur réseau :', error);
    });
}

Backend : Traitement et stockage des fichiers avec Spring Boot

Le code backend utilise Spring Boot pour gérer la requête HTTP POST. Il valide la taille et le type MIME du fichier, puis le stocke dans un répertoire spécifique sur le serveur. La logique inclut la vérification de l'existence d'un fichier nommé de manière similaire dans la base de données pour mettre à jour ou créer une nouvelle entrée.

@PostMapping("/envoyer")
public ResponseEntity<Object> processDocumentUpload(HttpServletRequest request,
        @RequestParam("document") MultipartFile document) {
    if (document == null || document.isEmpty()) {
        return ResponseEntity.badRequest().body(Map.of("status", "error", "message", "Aucun fichier fourni."));
    }

    try {
        long fileLength = document.getSize();
        if (fileLength > 1024 * 1024) {
            return ResponseEntity.badRequest().body(Map.of("status", "error", "message", "La taille du fichier dépasse 1 Mo."));
        }

        String mimeType = document.getContentType();
        List<String> allowedTypes = Arrays.asList(
            "application/msword",
            "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
            "application/pdf",
            "text/plain",
            "application/vnd.ms-works",
            "application/vnd.ms-excel"
        );
        if (!allowedTypes.contains(mimeType)) {
            return ResponseEntity.badRequest().body(Map.of("status", "error", "message", "Type de fichier non autorisé."));
        }

        String originalName = document.getOriginalFilename();
        String storagePath = "/chemin/vers/stockage/";
        File storageDirectory = new File(storagePath);
        if (!storageDirectory.exists()) {
            storageDirectory.mkdirs();
        }

        String fileExtension = "";
        int dotIndex = originalName.lastIndexOf('.');
        if (dotIndex > 0) {
            fileExtension = originalName.substring(dotIndex);
        }

        Map<String, Object> existingRecord = documentService.findByName(originalName);
        if (existingRecord != null && !existingRecord.isEmpty()) {
            String recordId = (String) existingRecord.get("id");
            String oldFileName = (String) existingRecord.get("file_name");
            File oldFile = new File(storagePath + oldFileName);
            if (oldFile.exists()) {
                oldFile.delete();
            }
            document.transferTo(new File(storageDirectory, oldFileName));
            Map<String, Object> updateData = new HashMap<>();
            updateData.put("id", recordId);
            updateData.put("file_size", fileLength);
            documentService.updateRecord(updateData);
        } else {
            String newFileName = UUID.randomUUID().toString() + fileExtension;
            document.transferTo(new File(storageDirectory, newFileName));
            String relativePath = "/stockage/" + newFileName;
            String documentId = generateUniqueId();
            String fileId = generateFileId();
            Map<String, Object> newRecord = new HashMap<>();
            newRecord.put("id", documentId);
            newRecord.put("file_id", fileId);
            newRecord.put("creation_date", new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
            newRecord.put("file_name", newFileName);
            newRecord.put("original_name", originalName);
            newRecord.put("file_path", relativePath);
            newRecord.put("file_size", fileLength);
            documentService.addRecord(newRecord);
        }

        return ResponseEntity.ok(Map.of("status", "success", "message", "Fichier traité avec succès."));
    } catch (IOException e) {
        e.printStackTrace();
        return ResponseEntity.internalServerError().body(Map.of("status", "error", "message", "Erreur lors du traitement du fichier."));
    }
}