Utilisation du type de sortie «Codeunit»

Le type de sortie Codeunit peut être utilisé pour traiter et envoyer des documents via une logique métier personnalisée. Au lieu d'utiliser des types de sortie standard comme E-mail, FTP ou Téléchargement, une codeunit est exécutée, qui peut transférer ou traiter ultérieurement les documents générés vers n'importe quelle destination.

Info

Le type de sortie Codeunit est particulièrement adapté aux intégrations où les documents doivent être transférés vers des systèmes externes ou des API (par exemple, DMS, stockage cloud, systèmes d'archivage).

Cas d'utilisation typiques

Avec cette fonctionnalité, vous pouvez par exemple :

• Télécharger des documents via des API externes (par ex. Dropbox, Google Drive ou vos propres dépôts)
• Transférer des documents vers des systèmes tiers (par ex. DMS, systèmes d'archivage)
• Implémenter une logique de traitement individuelle (par ex. cryptage, validation, transformation)
• Intégration dans les flux de travail de l'entreprise (par ex. démarrer automatiquement des processus d'approbation)

Configuration

Pour utiliser le type de sortie Codeunit, vous devez configurer un profil d'envoi correspondant et y déposer la codeunit souhaitée.

1. Ouvrez la page Profils d'envoi.
2. Créez un nouveau profil ou modifiez-en un existant.
3. Dans le champ Type de sortie, sélectionnez l'option Codeunit.
4. Exécutez l'action Options dans la barre de menus.
5. Dans le champ ID de la Codeunit, indiquez le numéro de la codeunit à exécuter (par ex. 50000 dans l'exemple ci-dessous).
6. Sous Pièces jointes du profil d'envoi, configurez les documents (rapports, fichiers, etc.) qui doivent être traités par la codeunit.

Lorsque ce profil d'envoi est utilisé pour envoyer des documents, la codeunit que vous avez spécifiée est exécutée à la place d'un envoi standard (comme l'e-mail).

Fonctionnement

Lorsqu'une entrée de file d'attente avec le type de sortie Codeunit est traitée, Document Dispatch effectue les étapes suivantes :

1. Toutes les pièces jointes configurées (rapports, fichiers, XML, etc.) sont générées.
2. La codeunit déposée dans le profil d'envoi est exécutée via CODEUNIT.Run().
3. La codeunit accède aux documents générés via les entrées de ligne de file d'attente.
4. La codeunit traite et envoie les documents conformément à la logique implémentée (par ex. téléversement API).

Exemple : Télécharger des documents via une API dans un référentiel

L'exemple suivant montre comment des documents peuvent être transférés vers un référentiel externe via une API REST.

Exemple d'implémentation

codeunit 50000 "Doc. Dispatch API Upload"
{
    TableNo = "SIM_EDS Record Attachment";
    Permissions = tabledata "SIM_EDS Queue Line" = RIM;

    trigger OnRun()
    begin
        UploadDocumentsToAPI();
    end;

    var
        GlobalCodeunitSIMEDSSI: Codeunit "SIM_EDS SI";

    /// <summary>
    /// Uploads all generated documents to an external repository via an API
    /// </summary>
    procedure UploadDocumentsToAPI()
    var
        LocalRecordSIMEDSQueueLine: Record "SIM_EDS Queue Line";
        LocalRecordSIMEDSQueueEntry: Record "SIM_EDS Queue Entry";
        LocalCodeunitBase64Convert: Codeunit "Base64 Convert";
        LocalHttpClient: HttpClient;
        LocalHttpContent: HttpContent;
        LocalHttpResponse: HttpResponseMessage;
        LocalHeaders: HttpHeaders;
        LocalInStream: InStream;
        LocalFileBase64Text: Text;
        LocalApiUrlText: Text;
        LocalQueueEntryNo: BigInteger;
        LocalSuccessBoolean: Boolean;
    begin
        // Get Queue Entry No. from Document Dispatch
        LocalQueueEntryNo := GlobalCodeunitSIMEDSSI.GetQueueEntryNo();
        if LocalQueueEntryNo = 0 then 
            Error('No Queue Entry found.');

        if not LocalRecordSIMEDSQueueEntry.Get(LocalQueueEntryNo) then
            Error('Queue Entry %1 not found.', LocalQueueEntryNo);

        // Iterate through all generated Queue Lines (= documents) for this Queue Entry
        LocalRecordSIMEDSQueueLine.SetRange("Queue Entry No.", LocalQueueEntryNo);
        LocalRecordSIMEDSQueueLine.SetRange("Attach Tag", true); // Only tagged attachments

        if LocalRecordSIMEDSQueueLine.FindSet() then
            repeat
                // Get document from Queue Line
                LocalRecordSIMEDSQueueLine.CalcFields("Document Blob");

                if LocalRecordSIMEDSQueueLine."Document Blob".HasValue then begin
                    // Convert document to Base64 for API transfer
                    Clear(LocalInStream);
                    LocalRecordSIMEDSQueueLine."Document Blob".CreateInStream(LocalInStream);
                    LocalFileBase64Text := LocalCodeunitBase64Convert.ToBase64(LocalInStream);

                    // Perform API upload
                    LocalApiUrlText := GetAPIUploadUrl(); // Your API URL
                    LocalSuccessBoolean := UploadFileToAPI(
                        LocalApiUrlText,
                        LocalRecordSIMEDSQueueLine."Document Name",
                        LocalFileBase64Text,
                        LocalRecordSIMEDSQueueEntry
                    );

                    if not LocalSuccessBoolean then
                        Error('Upload failed for document: %1', LocalRecordSIMEDSQueueLine."Document Name");
                end;
            until LocalRecordSIMEDSQueueLine.Next() = 0;

        Message('All documents uploaded successfully.');
    end;

    local procedure UploadFileToAPI(
        ParamApiUrl: Text;
        ParamFilename: Text;
        ParamFileBase64: Text;
        ParamQueueEntry: Record "SIM_EDS Queue Entry"
    ): Boolean
    var
        LocalHttpClient: HttpClient;
        LocalHttpContent: HttpContent;
        LocalHttpResponse: HttpResponseMessage;
        LocalHeaders: HttpHeaders;
        LocalJsonObject: JsonObject;
        LocalJsonText: Text;
        LocalRequestBody: Text;
    begin
        // Create JSON payload for API
        LocalJsonObject.Add('filename', ParamFilename);
        LocalJsonObject.Add('content', ParamFileBase64);
        LocalJsonObject.Add('source_document', Format(ParamQueueEntry."Source ID"));
        LocalJsonObject.Add('queue_entry_no', ParamQueueEntry."Entry No.");

        LocalJsonObject.WriteTo(LocalJsonText);

        // Configure HTTP Request
        LocalHttpContent.WriteFrom(LocalJsonText);
        LocalHttpContent.GetHeaders(LocalHeaders);
        LocalHeaders.Clear();
        LocalHeaders.Add('Content-Type', 'application/json');
        LocalHeaders.Add('Authorization', GetAPIAuthToken()); // Your auth logic

        // Perform API call
        if not LocalHttpClient.Post(ParamApiUrl, LocalHttpContent, LocalHttpResponse) then
            exit(false);

        // Check response
        exit(LocalHttpResponse.IsSuccessStatusCode());
    end;

    local procedure GetAPIUploadUrl(): Text
    var
        LocalSetup: Record "Your API Setup"; // Your setup table
    begin
        LocalSetup.Get();
        LocalSetup.TestField("API Base URL");
        exit(LocalSetup."API Base URL" + '/upload');
    end;

    local procedure GetAPIAuthToken(): Text
    var
        LocalSetup: Record "Your API Setup";
    begin
        LocalSetup.Get();
        LocalSetup.TestField("API Token");
        exit('Bearer ' + LocalSetup."API Token");
    end;
}

Avantages

Lorsque vous utilisez le type de sortie Codeunit, vous bénéficiez, entre autres, des avantages suivants :

• Contrôle total : vous déterminez où et comment les documents sont traités
• Flexibilité : toute API, tout protocole, toute logique métier est possible
• Intégration : intégration transparente dans le mécanisme de file d'attente de Document Dispatch
• Gestion des erreurs : utilisation des mécanismes de gestion des erreurs standard de Document Dispatch
• Traçabilité : les téléversements sont consignés dans l'historique de la file d'attente