Exportar um caso de uso de classificação de documentos

Exporte um caso de uso de classificação de documento para uso em outra instância ServiceNow®, adicionando-o a um conjunto de atualizações.

Antes de Iniciar

• Certifique-se de que ambas as instâncias tenham a mesma versão da família e a mesma versão de Inteligência para documentos instalada ao exportar e importar casos de uso.
• Função necessária: sn_docintel.manager

Por Que e Quando Desempenhar Esta Tarefa

Siga estas etapas para exportar um caso de uso de classificação de documento para um conjunto de atualizações junto com seus campos, grupos de campos, integrações, fluxos e todos os modelos de aprendizado de máquina (ML) relacionados. O conjunto de atualizações pode ser exportado para uso em outra instância.

Os conjuntos de atualizações são criados automaticamente e definidos como "Concluídos" como um processo em segundo plano. Este processo leva vários minutos. Os conjuntos de atualizações resultantes não devem ser definidos manualmente como "Concluídos" ou exportados antes que o trabalho em segundo plano seja concluído.

Para obter mais informações, consulte System update sets.

Procedimento

1. Navegar até Tudo > Definição do Sistema > Scripts – Plano de fundo.
2. Copie o script fornecido abaixo e cole-o na caixa Executar 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. Abra a instância em uma nova guia do navegador e navegue até Tudo > Inteligência para documentos > Classificação do Documento > Casos de Uso.
4. Abra o caso de uso que você deseja exportar.
5. Copie o sys_id do URL.

   Por exemplo, copie fda6a8b36b700210f465ee188e44afe8%26 do seguinte URL:

   https://instancename.service-now.com/nav_to.do?uri=sys_di_task_definition.do?sys_id=fda6a8b36b700210f465ee188e44afe8%26sysparm_view=edit_sys_di_task_definition_doc_classifier

   Dica:

   Para obter o URL, selecione o ícone Ações adicionais ( ) e selecione Copiar URL.
6. Na guia Scripts - Plano de fundo, cole o sys_id na primeira linha da variável TASK_DEFINITION_TO_EXPORT_SYS_ID.

   Por exemplo, a linha do script deve ser semelhante à seguinte linha:

   var TASK_DEFINITION_TO_EXPORT_SYS_ID = "9f426b878749e110ba3540809bbb35a6";

7. Selecione Executar script para executar o script em segundo plano no escopo global.

   Este script pode levar vários minutos para ser executado.

8. Navegar até Conjuntos de atualizações do sistema > Conjuntos de atualizações locais.

   Você pode ver vários conjuntos de atualizações com nomes que começam com o nome do caso de uso.

9. Selecione cada conjunto de atualizações em que o nome contenha "conjunto de atualizações global" e "tarefa de conjunto de atualizações global xy" e selecione Exportar lote de conjunto de atualizações para XML nos links relacionados para baixar os arquivos XML.
   Nota:

   No nome "tarefa do conjunto de atualizações global xy", xy se refere a um intervalo de tarefas que fazem parte do conjunto de atualizações. Por exemplo, se você tiver 100 tarefas de documento, encontrará dois conjuntos de atualizações em lote, um com "tarefa de conjunto de atualizações global 1-50" no nome e outro com "tarefa de conjunto de atualizações global 51-100".

Resultado

O caso de uso é exportado para o seu computador como arquivos XML.

O que Fazer Depois

Depois de exportar um caso de uso, importe-o para uso em sua instância ServiceNow®. Para obter mais informações, consulte Importar um caso de uso de classificação de documento.

Tarefas relacionadas

• Importar um caso de uso de classificação de documento
• Excluir um caso de uso de classificação de documento