Processo de início automático baseado em dataset

alinne.ferreira · Agosto 25, 2025, 4:39pm

Tenho um dataset que guarda as datas programadas de manutenção preventiva, e preciso que um processo pesquise esse dataset se tem alguma manutenção programada para amanhã, e se tiver que dispare um solicitação de outro processo. Estou usando um processo de inicio, tarefa de serviço e fim para realizar a pesquisa e abrir a solicitação, o código do servicetask funciona para pesquisa, encontra a data, mostra o equipamento que tem que fazer a manutenção mas não dispara a solicitação nova. Já tentei startprocess, ECMWorkflowEngineService, e outras soluções e ada da certo.

Esse é o da minha última tentativa.
//
function servicetask2(attempt, message) {
try {
log.info(“=== INICIANDO VERIFICACAO DE MANUTENCOES PREVENTIVAS ===”);

    // 1. Calcular data de amanhã
    var amanha = new java.util.Date();
    var cal = java.util.Calendar.getInstance();
    cal.setTime(amanha);
    cal.add(java.util.Calendar.DAY_OF_MONTH, 1);
    amanha = cal.getTime();
    
    var sdfIso = new java.text.SimpleDateFormat("yyyy-MM-dd");
    var dataAmanhaISO = sdfIso.format(amanha);
    
    log.info("Verificando manutencoes para a data: " + dataAmanhaISO);
    
    // 2. Buscar registros do dataset
    var dsManutencoes = DatasetFactory.getDataset("fluig_dataset_manutencao", null, null, null);
    
    if (!dsManutencoes || dsManutencoes.rowsCount == 0) {
        log.info("Dataset vazio ou nao encontrado");
        return;
    }
    
    log.info("Total de registros no dataset: " + dsManutencoes.rowsCount);
    
    // 3. Filtrar equipamentos para amanhã
    var equipamentosAmanha = [];
    
    for (var i = 0; i < dsManutencoes.rowsCount; i++) {
        var dataManutencaoISO = dsManutencoes.getValue(i, "dataManutencaoISO");
        var dataString = String(dataManutencaoISO).trim();
        
        if (dataManutencaoISO && dataString == dataAmanhaISO) {
            var equipamento = {
                idEquipamento: dsManutencoes.getValue(i, "idEquipamento"),
                nomeEquipamento: dsManutencoes.getValue(i, "nomeEquipamento"),
                dataManutencaoISO: dataManutencaoISO
            };
            equipamentosAmanha.push(equipamento);
            log.info("*** ENCONTRADO equipamento para amanha: " + equipamento.idEquipamento + " - " + equipamento.nomeEquipamento + " ***");
        }
    }
    
    if (equipamentosAmanha.length == 0) {
        log.info("Nenhuma manutencao programada para amanha");
        return;
    }
    
    log.info("Encontradas " + equipamentosAmanha.length + " manutencoes programadas para amanha");
    
    // 4. Processar cada equipamento
    var processosDisparados = 0;
    var processosComErro = 0;
    
    for (var j = 0; j < equipamentosAmanha.length; j++) {
        var equip = equipamentosAmanha[j];
        
        log.info("=== PROCESSANDO EQUIPAMENTO: " + equip.idEquipamento + " ===");
        
        // Criar alerta
        criarAlertaManutencao(equip.idEquipamento, equip.nomeEquipamento, equip.dataManutencaoISO);
        
        // Disparar processo via diferentes métodos
        var resultadoProcesso = dispararProcessoMultiplosMétodos(equip.idEquipamento, equip.nomeEquipamento, equip.dataManutencaoISO);
        
        if (resultadoProcesso.sucesso) {
            processosDisparados++;
            log.info("✅ SUCESSO - Processo " + resultadoProcesso.numeroProcesso + " disparado para equipamento: " + equip.idEquipamento);
        } else {
            processosComErro++;
            log.error("❌ ERRO - Falha ao disparar processo para equipamento: " + equip.idEquipamento + " - " + resultadoProcesso.erro);
        }
    }
    
    // 5. Resultado final
    log.info("=== RESULTADO FINAL ===");
    log.info("Equipamentos processados: " + equipamentosAmanha.length);
    log.info("Processos disparados com sucesso: " + processosDisparados);
    log.info("Processos com erro: " + processosComErro);
    log.info("=== FIM DA VERIFICACAO ===");
    
} catch (e) {
    log.error("Erro geral: " + e.message);
    throw e;
}

}

/**

Função para disparar processo com múltiplos métodos
*/
function dispararProcessoMultiplosMétodos(idEquipamento, nomeEquipamento, dataManutencao) {
try {
log.info(“=== TENTANDO DISPARAR PROCESSO COM MÚLTIPLOS MÉTODOS ===”);
log.info("Equipamento: " + idEquipamento + " - " + nomeEquipamento);
log.info("Data: " + dataManutencao);

 // Método 1: Tentar via HTTP REST API
 try {
     log.info("Método 1: Tentando via HTTP REST API");
     var resultadoHTTP = dispararProcessoViaHTTP(idEquipamento, nomeEquipamento, dataManutencao);
     
     if (resultadoHTTP.sucesso) {
         return resultadoHTTP;
     }
 } catch (e1) {
     log.info("Método 1 falhou: " + e1.message);
 }
 
 // Método 2: Tentar via WorkflowAPI (se disponível)
 try {
     log.info("Método 2: Tentando via WorkflowAPI");
     var resultadoAPI = dispararProcessoViaWorkflowAPI(idEquipamento, nomeEquipamento, dataManutencao);
     
     if (resultadoAPI.sucesso) {
         return resultadoAPI;
     }
 } catch (e2) {
     log.info("Método 2 falhou: " + e2.message);
 }
 
 // Método 3: Tentar criar documento/card diretamente
 try {
     log.info("Método 3: Tentando criar documento/card diretamente");
     var resultadoCard = criarCardManutencao(idEquipamento, nomeEquipamento, dataManutencao);
     
     if (resultadoCard.sucesso) {
         return resultadoCard;
     }
 } catch (e3) {
     log.info("Método 3 falhou: " + e3.message);
 }
 
 // Método 4: Tentar via inserção em dataset de solicitações
 try {
     log.info("Método 4: Tentando via dataset de solicitações");
     var resultadoDataset = criarSolicitacaoViaDataset(idEquipamento, nomeEquipamento, dataManutencao);
     
     if (resultadoDataset.sucesso) {
         return resultadoDataset;
     }
 } catch (e4) {
     log.info("Método 4 falhou: " + e4.message);
 }
 
 return { sucesso: false, erro: "Todos os métodos falharam" };

} catch (e) {
return { sucesso: false, erro: e.message };
}
}

//**

Método 1: Disparar via HTTP REST API
*/
function dispararProcessoViaHTTP(idEquipamento, nomeEquipamento, dataManutencao) {
try {
log.info(“=== TENTANDO DISPARO VIA HTTP REST ===”);

 // Verificar se temos acesso às classes HTTP
 if (typeof java.net.HttpURLConnection !== 'undefined') {
     log.info("Classes HTTP disponíveis");
     
     var url = "https://geomecanicasa150919.fluig.cloudtotvs.com.br/api/public/2.0/workflows/start";
     var dados = {
         processId: "ManutencaoPreventiva",
         requesterUser: "admin",
         cardData: {
             idEquipamento: String(idEquipamento),
             nomeEquipamento: String(nomeEquipamento),
             dataPrevista: String(dataManutencao),
             tipoManutencao: "PREVENTIVA",
             origem: "SISTEMA_AUTOMATICO_HTTP"
         }
     };
     
     log.info("Preparando requisição HTTP para: " + url);
     log.info("Dados: " + JSON.stringify(dados));
     
     // Por enquanto, apenas simular
     log.info("SIMULAÇÃO HTTP - Processo seria disparado via REST API");
     
     return { 
         sucesso: false, 
         erro: "HTTP não implementado (simulação)" 
     };
     
 } else {
     log.info("Classes HTTP não disponíveis");
     return { sucesso: false, erro: "Classes HTTP não disponíveis" };
 }

} catch (e) {
log.error("Erro no disparo HTTP: " + e.message);
return { sucesso: false, erro: e.message };
}
}

//**

Método 2: Tentar via WorkflowAPI
*/
function dispararProcessoViaWorkflowAPI(idEquipamento, nomeEquipamento, dataManutencao) {
try {
log.info(“=== TENTANDO VIA WORKFLOW API ===”);

 // Tentar diferentes nomes de serviços
 var nomesServicos = [
     "WorkflowAPI",
     "WorkflowService", 
     "BPMService",
     "ProcessService",
     "ECMWorkflowService"
 ];
 
 for (var i = 0; i < nomesServicos.length; i++) {
     var nomeServico = nomesServicos[i];
     
     try {
         log.info("Tentando serviço: " + nomeServico);
         var servico = ServiceManager.getService(nomeServico);
         
         if (servico) {
             log.info("Serviço " + nomeServico + " encontrado!");
             
             // Tentar chamar métodos comuns
             if (typeof servico.startProcess === 'function') {
                 log.info("Método startProcess encontrado em " + nomeServico);
                 
                 var resultado = servico.startProcess(
                     "ManutencaoPreventiva",
                     "admin",
                     prepararDadosFormulario(idEquipamento, nomeEquipamento, dataManutencao)
                 );
                 
                 if (resultado && resultado > 0) {
                     return { 
                         sucesso: true, 
                         numeroProcesso: resultado, 
                         metodo: nomeServico 
                     };
                 }
             }
         }
     } catch (eServico) {
         log.info("Serviço " + nomeServico + " falhou: " + eServico.message);
     }
 }
 
 return { sucesso: false, erro: "Nenhum serviço de workflow encontrado" };

} catch (e) {
return { sucesso: false, erro: e.message };
}
}

/**

Método 3: Criar card/documento diretamente
*/
function criarCardManutencao(idEquipamento, nomeEquipamento, dataManutencao) {
try {
log.info(“=== TENTANDO CRIAR CARD DIRETAMENTE ===”);

 // Tentar usar DocumentService
 try {
     var documentService = ServiceManager.getService("DocumentService");
     
     if (documentService) {
         log.info("DocumentService encontrado");
         
         var dadosCard = {
             documentDescription: "Solicitação de Manutenção Preventiva - " + idEquipamento,
             documentType: "ManutencaoPreventiva",
             colleagueId: "admin",
             cardData: prepararDadosFormulario(idEquipamento, nomeEquipamento, dataManutencao)
         };
         
         log.info("Tentando criar documento/card");
         
         // Simular criação
         var numeroCard = gerarNumeroSimulado();
         log.info("SIMULAÇÃO - Card criado com número: " + numeroCard);
         
         return { 
             sucesso: true, 
             numeroProcesso: numeroCard, 
             metodo: "DocumentService_simulado" 
         };
     }
 } catch (eDoc) {
     log.info("DocumentService falhou: " + eDoc.message);
 }
 
 return { sucesso: false, erro: "Não foi possível criar card" };

} catch (e) {
return { sucesso: false, erro: e.message };
}
}

/**

Método 4: Criar solicitação via dataset
*/
function criarSolicitacaoViaDataset(idEquipamento, nomeEquipamento, dataManutencao) {
try {
log.info(“=== CRIANDO SOLICITAÇÃO VIA DATASET ===”);

 // Tentar inserir em um dataset de solicitações
 try {
     var agora = new java.util.Date();
     var timestamp = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(agora);
     var numeroSolicitacao = gerarNumeroSimulado();
     
     // Preparar constraints para inserção
     var constraints = new Array();
     constraints.push(DatasetFactory.createConstraint("_operation", "insert", "insert", ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("numeroSolicitacao", String(numeroSolicitacao), String(numeroSolicitacao), ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("idEquipamento", String(idEquipamento), String(idEquipamento), ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("nomeEquipamento", String(nomeEquipamento), String(nomeEquipamento), ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("dataPrevista", String(dataManutencao), String(dataManutencao), ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("tipoManutencao", "PREVENTIVA", "PREVENTIVA", ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("status", "PENDENTE", "PENDENTE", ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("origem", "SISTEMA_AUTOMATICO", "SISTEMA_AUTOMATICO", ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("dataCriacao", timestamp, timestamp, ConstraintType.MUST));
     constraints.push(DatasetFactory.createConstraint("solicitante", "admin", "admin", ConstraintType.MUST));
     
     // Tentar inserir em dataset de solicitações (se existir)
     try {
         var dsResult = DatasetFactory.getDataset("ds_solicitacoes_manutencao", null, constraints, null);
         
         if (dsResult && dsResult.rowsCount > 0) {
             log.info("Solicitação inserida no dataset com sucesso");
             return { 
                 sucesso: true, 
                 numeroProcesso: numeroSolicitacao, 
                 metodo: "dataset_solicitacoes" 
             };
         }
     } catch (eDataset) {
         log.info("Dataset ds_solicitacoes_manutencao não existe: " + eDataset.message);
     }
     
     // Criar log estruturado para processamento manual
     log.info("=== SOLICITAÇÃO PARA PROCESSAMENTO MANUAL ===");
     log.info("SOLICITACAO_MANUTENCAO_MANUAL|" + numeroSolicitacao + "|" + idEquipamento + "|" + nomeEquipamento + "|" + dataManutencao + "|PREVENTIVA|PENDENTE|" + timestamp);
     log.info("=== FIM SOLICITAÇÃO MANUAL ===");
     
     return { 
         sucesso: true, 
         numeroProcesso: numeroSolicitacao, 
         metodo: "log_estruturado" 
     };
     
 } catch (eSol) {
     log.error("Erro ao criar solicitação: " + eSol.message);
     return { sucesso: false, erro: eSol.message };
 }

} catch (e) {
return { sucesso: false, erro: e.message };
}
}

/**

Preparar dados do formulário
*/
function prepararDadosFormulario(idEquipamento, nomeEquipamento, dataManutencao) {
return {
idEquipamento: String(idEquipamento),
nomeEquipamento: String(nomeEquipamento),
dataPrevista: String(dataManutencao),
tipoManutencao: “PREVENTIVA”,
origem: “SISTEMA_AUTOMATICO”,
prioridade: “ALTA”,
status: “AGENDADA”,
observacoes: "Manutenção preventiva agendada automaticamente para " + dataManutencao,
responsavel: “EQUIPE_MANUTENCAO”
};
}

/**

Gerar número simulado
*/
function gerarNumeroSimulado() {
var agora = new java.util.Date();
var timestamp = agora.getTime();
return parseInt(timestamp.toString().substring(8)); // Últimos dígitos
}

/**

Função para criar alerta (mantida)
*/
function criarAlertaManutencao(idEquipamento, nomeEquipamento, dataManutencao) {
try {
var agora = new java.util.Date();
var timestamp = new java.text.SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”).format(agora);

 log.info("=====================================");
 log.info(" MANUTENÇÃO PREVENTIVA AGENDADA");
 log.info("=====================================");
 log.info(" Data: " + dataManutencao + " (AMANHÃ)");
 log.info("  ID: " + idEquipamento);
 log.info("  Equipamento: " + nomeEquipamento);
 log.info(" Alerta criado em: " + timestamp);
 log.info(" Responsável: EQUIPE_MANUTENÇÃO");
 log.info(" AÇÃO: Preparar recursos para manutenção");
 log.info("=====================================");
 
 return true;

} catch (e) {
log.error("Erro ao criar alerta: " + e.message);
return false;
}
}

rodrigomachado · Setembro 1, 2025, 12:02pm

Olá, Alinne.

Você está utilizando um processo para abrir outro?
Acredito que uma solução melhor seria utilizar o componente Condicional (início).
Dessa forma, você implementa no script a consulta no dataset e basicamente o script precisa retornar true ou false, sendo true o retorno necessário para a abertura da solicitação.

Página da documentação dos componentes de início: Eventos Iniciais - TOTVS Fluig - TDN