Exporte um caso de uso de classificação de documento

Exporte um caso de uso de classificação de documento para uso em outro ServiceNow®adicionando-a a um conjunto de atualizações.

Antes de Iniciar

• Certifique-se de que ambas as instâncias tenham a mesma versão de família e a mesma versão de Inteligência para documentosinstalado 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ído" 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ído" ou exportados antes da conclusão do trabalho em segundo plano.

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 em Executar script caixa.

   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 da URL.

   Por exemplo, copiar fda6a8b36b700210f465ee188e44afe8%26 A partir 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 Ações adicionais ícone ( ) e selecione URL de cópia .
6. Em Scripts - Plano de fundo cole o sys_id na primeira linha do TASK_DEFINITION_TO_EXPORT_SYS_ID variável.

   Por exemplo, a linha do script deve se parecer com a seguinte linha:

   VAR TASK_DEFINITION_TO_EXPORT_SYS_ID: "9F426B878749E110BA3540809BBB35A6";

7. Selecione Script de execução 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 contém "conjunto de atualizações global" e "tarefa de conjunto de atualizações global x-y" e selecione Lote de conjunto de atualizações de exportação para XML Nos links relacionados para baixar os arquivos XML.
   Nota:

   No nome "Tarefa do conjunto de atualizações global x-y", x-y refere-se 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 globais 1-50" no nome e o outro com "tarefa de conjunto de atualizações globais 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 no ServiceNow®instância. Para obter mais informações, consulte Importe um caso de uso de classificação de documento.

Tarefas relacionadas

• Importe um caso de uso de classificação de documento
• Exclua um caso de uso de classificação de documento