---
sourceDocument: Xanadu Activer AI
sourceDocumentLink: https://servicenow-prod.fluidtopics.net/r/fr-FR/xanadu/intelligent-experiences

 Release :

    - xanadu

ft:locale :

    - fr-FR

ft:publication_title :

    - Xanadu Activer AI

ft:clusterId :

    - platai

bundleId :

    - platai

workflow :

    - Platform


---

# Exporter un cas d'utilisation de classification de documents

# Exporter un cas d'utilisation de classification de documents {#ariaid-title1}

* Rversion finale: Xanadu
* 
* Mis à jour 4 sept. 2024
* 
* ![](https://www.servicenow.com/docs/portal-asset/ico-clock) 4 minutes de lecture

Exportez un cas d'utilisation de classification de documents pour l'utiliser dans une autre ServiceNow® instance en l'ajoutant à un ensemble de mises à jour.

## Avant de commencer

* Assurez-vous que les deux instances disposent de la même version de famille et de la même version installée lors de l'exportation et de l'importation des Intelligence documentaire cas d'utilisation.
* Rôle requis : sn_docintel.manager
{#export-document-classification-use-case__ul_odd_ny5_pcc}

## Pourquoi et quand exécuter cette tâche

Suivez ces étapes pour exporter un cas d'utilisation de classification de documents vers un ensemble de mises à jour avec ses champs, groupes de champs, intégrations, flux et tous les modèles d'apprentissage machine (ML) connexes. L'ensemble de mises à jour peut ensuite être exporté pour être utilisé dans une autre instance.

Pour plus d'informations, consultez [System update sets](https://www.servicenow.com/docs/access?context=system-update-sets&version=xanadu&pubname=xanadu-application-development&ft:locale=en-US).

## Procédure

1. Accédez à la ToutDéfinition du systèmeScripts -- Arrière-plan.
2. Copiez le script fourni ci-dessous et collez-le dans la zone Exécuter le script .  

       var TASK_DEFINITION_TO_EXPORT_SYS_ID = "";
       var TASK_BATCH_SIZE = 50;

       var scopeToUpdateSet = {};
       var taskDefinitionName = "";

       function getTaskSuffix(taskBatchNum) {
          if (taskBatchNum != null) {
             return (
                " task " +
                ((taskBatchNum - 1) * TASK_BATCH_SIZE + 1) +
                "-" +
                taskBatchNum * TASK_BATCH_SIZE
             );
          } else {
             return "";
          }
       }

       function createUpdateSet(taskBatchNum) {
          var taskSuffix = getTaskSuffix(taskBatchNum);
          var globalNameSuffix = " global update set" + taskSuffix;
          var docintelNameSuffix = " docintel update set" + taskSuffix;
          var globalKey = "global" + taskSuffix;
          var docintelKey = "19b40605edae411005e8007f82757635" + taskSuffix;

          // Create a new global update set
          var globalUpdateSetGR = new GlideRecord("sys_update_set");
          globalUpdateSetGR.initialize();
          globalUpdateSetGR.name = taskDefinitionName + globalNameSuffix;
          globalUpdateSetGR.application = "global";
          var globalUpdateSetID = globalUpdateSetGR.insert();
          scopeToUpdateSet[globalKey] = globalUpdateSetID;
          // Create a new DocIntel scope update set
          var updateSetGR = new GlideRecord("sys_update_set");
          updateSetGR.initialize();
          updateSetGR.name = taskDefinitionName + docintelNameSuffix;
          updateSetGR.application = "19b40605edae411005e8007f82757635";
          updateSetGR.parent = globalUpdateSetGR.sys_id;
          var updateSetID = updateSetGR.insert();
          scopeToUpdateSet[docintelKey] = updateSetID;
       }

       function saveToUpdateSet(glideRecord, taskCount) {
          var gum;
          var scope = String(glideRecord.sys_scope || "global");
          if (scope !== "global" && scope !== "19b40605edae411005e8007f82757635") {
             gs.info("unknown scope: " + scope + "|" + glideRecord.getDisplayValue());
             return;
          }
          
          var taskBatchNum = taskCount ? Math.ceil(taskCount / TASK_BATCH_SIZE) : null;
          var updateSetSysId = scopeToUpdateSet[scope + getTaskSuffix(taskBatchNum)];
          if (!updateSetSysId) {
             createUpdateSet(taskBatchNum);
             updateSetSysId = scopeToUpdateSet[scope + getTaskSuffix(taskBatchNum)];
          }
        
          try {
             gum = new GlideUpdateManager2(updateSetSysId);
          } catch (e) {
             var gus = new GlideUpdateSet();
             gus.set(updateSetSysId);
             gum = new GlideUpdateManager2();
          }
          gum.saveRecord(glideRecord);
       }

       function exportTaskDefinition(taskDefinitionId) {
        var currentUpdateSetSysId = gs.getPreference("sys_update_set");
        // Get task definition
        var taskDefinitionGR = new GlideRecord("di_task_definition");
        if (!taskDefinitionGR.get(taskDefinitionId)) {
        gs.info("task definition not found.");
        return;
        }
        
       taskDefinitionName = taskDefinitionGR.getValue("display_name");
        createUpdateSet(null);
        
        //Push records into the current update set
        // Task Definition
        saveToUpdateSet(taskDefinitionGR);
        saveToUpdateSet(taskDefinitionGR.ml_definition_ocr.getRefRecord());
        saveToUpdateSet(taskDefinitionGR.ml_definition_training.getRefRecord());
        saveToUpdateSet(taskDefinitionGR.ml_definition_prediction.getRefRecord());
        saveToUpdateSet(
        taskDefinitionGR.ml_definition_pdf_preprocessing.getRefRecord()
        );

        // KeyGroups
        var keyGroupGR = new GlideRecord("di_key_group");
        keyGroupGR.addQuery("task_definition", taskDefinitionId);
        keyGroupGR.query();
        while (keyGroupGR.next()) {
        saveToUpdateSet(keyGroupGR);
        }

        // Keys
        var keyGR = new GlideRecord("di_key");
        keyGR.addQuery("task_definition", taskDefinitionId);
        keyGR.query();
        while (keyGR.next()) {
        saveToUpdateSet(keyGR);
        }

        // ML Solutions
        var mlSolutionGR = new GlideRecord("ml_solution");
        mlSolutionGR.addQuery("solution_name", "CONTAINS", taskDefinitionId);
        mlSolutionGR.addQuery("active", true);
        mlSolutionGR.query();
        while (mlSolutionGR.next()) {
        saveToUpdateSet(mlSolutionGR);
        // ML Model Artifacts
        var mlModelArtifactGR = new GlideRecord("ml_model_artifact");
        mlModelArtifactGR.addQuery("solution", mlSolutionGR.sys_id);
        mlModelArtifactGR.query();
        while (mlModelArtifactGR.next()) {
        saveToUpdateSet(mlModelArtifactGR);
        }
        // ML progress tracker
        saveToUpdateSet(mlSolutionGR.progress_tracker.getRefRecord());
        }

        // Tasks
        var taskCount = 0;

        var taskGR = new GlideRecord("di_task");
        taskGR.addQuery("task_definition", taskDefinitionId);
        taskGR.query();
        while (taskGR.next()) {
        taskCount += 1;
        saveToUpdateSet(taskGR, taskCount);
        // PDFs
        var pdfGR = new GlideRecord("di_pdf");
        pdfGR.addQuery("task", taskGR.sys_id);
        pdfGR.query();
        while (pdfGR.next()) {
        saveToUpdateSet(pdfGR, taskCount);
        }
        // Images
        var imageGR = new GlideRecord("di_image");
        imageGR.addQuery("task", taskGR.sys_id);
        imageGR.query();
        while (imageGR.next()) {
        saveToUpdateSet(imageGR, taskCount);
        // Candidate Scores
        var candidateScoreGR = new GlideRecord("di_candidate_score");
        candidateScoreGR.addQuery("image", imageGR.sys_id);
        candidateScoreGR.query();
        while (candidateScoreGR.next()) {
        saveToUpdateSet(candidateScoreGR, taskCount);
        }
        }
        // Extracted Values
        var extractedValueGR = new GlideRecord("di_extracted_value");
        extractedValueGR.addQuery("task", taskGR.sys_id);
        extractedValueGR.query();
        while (extractedValueGR.next()) {
        saveToUpdateSet(extractedValueGR, taskCount);
        }
        // Prediction Inputs
        var predictionInputGR = new GlideRecord("di_prediction_input");
        predictionInputGR.addQuery("task", taskGR.sys_id);
        predictionInputGR.query();
        while (predictionInputGR.next()) {
        saveToUpdateSet(predictionInputGR, taskCount);
       }

        // Training Inputs
        var trainingInputGR = new GlideRecord("di_training_input");
        trainingInputGR.addQuery("task", taskGR.sys_id);
        trainingInputGR.query();
        while (trainingInputGR.next()) {
        saveToUpdateSet(trainingInputGR, taskCount);
        }
        }

        // Reset current update set
        new GlideUpdateSet().set(currentUpdateSetSysId);

        // Mark as completed
        for (var updateSetKey in scopeToUpdateSet) {
        var globalUpdateSetGR = new GlideRecord("sys_update_set");
        globalUpdateSetGR.get(scopeToUpdateSet[updateSetKey]);
        globalUpdateSetGR.setValue("state", "complete");
        globalUpdateSetGR.update();
        }
       }

       exportTaskDefinition(TASK_DEFINITION_TO_EXPORT_SYS_ID);

3. Ouvrir l'instance dans un nouvel onglet de navigateur et naviguer jusqu'à ToutIntelligence documentaireClassification de documentsCas d'utilisation.
4. Ouvrez le cas d'utilisation que vous souhaitez exporter.
5. Copiez le sys_id à partir de l'URL.  
   Par exemple, copiez `9f426b878749e110ba3540809bbb35a6` à partir de l'URL suivante :

   https://instancename.service-now.com/now/docintel-admin/usecase/9f426b878749e110ba3540809bbb35a6
6. Dans l'onglet Scripts - Arrière-plan , collez le sys_id de la première ligne de la variable `TASK_DEFINITION_TO_EXPORT_SYS_ID` .  
   Par exemple, la ligne du script doit ressembler à la ligne suivante :

   `var TASK_DEFINITION_TO_EXPORT_SYS_ID = << 9f426b878749e110ba3540809bbb35a6 >> ;`
7. Sélectionnez Exécuter le script pour exécuter le script en arrière-plan dans le champ d'application global.  
   L'exécution de ce script peut prendre plusieurs minutes.
8. Accédez à la Ensembles de mises à jour systèmeEnsembles de mises à jour locaux.  
   Vous pouvez voir plusieurs ensembles de mises à jour dont le nom commence par le nom du cas d'utilisation.
9. Sélectionnez chaque ensemble de mises à jour dont le nom contient \<\< ensemble de mises à jour global \>\> et \<\< tâche d'ensemble de mises à jour global x-y \>\>, puis sélectionnez Exporter le lot d'ensembles de mises à jour au format XML dans les liens connexes pour télécharger les fichiers XML.  
   Remarque :  
   Dans le nom \<\< tâche d'ensemble de mises à jour globale x-y \>\>, x-y fait référence à une gamme de tâches qui font partie de l'ensemble de mises à jour. Par exemple, si vous avez 100 tâches de documents, vous trouverez deux ensembles de mises à jour par lots, l'un dont le nom contient \<\< Tâche d'ensemble de mises à jour global 1-50 \>\> et l'autre \<\< Tâche d'ensemble de mises à jour global 51-100 \>\>.

## Résultats

Le cas d'utilisation est exporté vers votre ordinateur sous forme de fichiers XML.

## Que faire ensuite

Après avoir exporté un cas d'utilisation, importez-le pour l'utiliser dans votre ServiceNow® instance. Pour plus d'informations, consultez [Importer un cas d'utilisation de classification de documents](https://servicenow-prod.fluidtopics.net/QULtiWiQZnZIPyhBRUiGew "Importez un cas d’utilisation de classification de documents à utiliser dans votre ServiceNow instance.").
**Tâches associées**   

* [Importer un cas d'utilisation de classification de documents](https://servicenow-prod.fluidtopics.net/QULtiWiQZnZIPyhBRUiGew "Importez un cas d’utilisation de classification de documents à utiliser dans votre ServiceNow instance.")
* [Supprimer un cas d'utilisation de classification de documents](https://servicenow-prod.fluidtopics.net/yaJSWc_6kC0iGce4wMlEOQ "Supprimez un cas d’utilisation lorsqu’il n’est plus nécessaire pour vos documents.")