Mudanças entre as edições de "Expressões"

De PJe
Ir para: navegação, pesquisa
(Transição de saída padrão)
 
(203 edições intermediárias de 7 usuários não apresentadas)
Linha 1: Linha 1:
 
Esta seção se destina a explicitar algumas expressões (EL) que devem ser usadas na construção de fluxos do PJe para atender determinadas situações.
 
Esta seção se destina a explicitar algumas expressões (EL) que devem ser usadas na construção de fluxos do PJe para atender determinadas situações.
 
  
 
== Definir variável no fluxo ==
 
== Definir variável no fluxo ==
Linha 7: Linha 6:
  
 
Configura para uso futuro no fluxo uma variável cujo nome seja <nome da variável> para conter o valor especificado pelo valor respectivo.
 
Configura para uso futuro no fluxo uma variável cujo nome seja <nome da variável> para conter o valor especificado pelo valor respectivo.
 +
 +
<font color=red>Exemplos:</font>
 +
 +
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('pje:aguardaEstouroPrazo', 'true')}
 +
 +
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('pje:aguardaFecharExpediente', 'true')}
 +
 +
<nowiki>#</nowiki>{taskInstanceUtil.setVariable('ocultarAssinatura', 'true')}
  
 
=== Definir minuta em elaboração ===
 
=== Definir minuta em elaboração ===
Linha 13: Linha 20:
  
 
Configura para uso futuro no fluxo a variável minutaEmElaboração como sendo o documento em manutenção.
 
Configura para uso futuro no fluxo a variável minutaEmElaboração como sendo o documento em manutenção.
 +
 +
=== Restringir tipos de documentos disponíveis ===
 +
 +
<nowiki>#{taskInstanceUtil.setVariable('tiposDisponiveisIds','60,69,65,71')}</nowiki>
 +
 +
 +
Restringe os tipos de documentos disponíveis para utilização no fluxo aos tipos passados como parâmetro, desde que estejam definidos na instalação e estejam ativos. Para que a restrição não mais ocorra no fluxo, deve-se [[Express%C3%B5es#Excluir_vari.C3.A1vel|apagar a variável]].
 +
 +
Deve ser utilizada, por exemplo, ao [[Preparar ato de comunicação|criar expedientes]], para limitar os tipos de documentos que poderão ser utilizados na construção do expediente.
 +
 +
== Excluir variável ==
 +
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('pje:aguardaEstouroPrazo')}
 +
 +
Exclui a variável criada anteriormente (evento)
 +
 +
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('pje:aguardaCiencia')}
 +
 +
Exclui a variável criada anteriormente (evento)
 +
 +
<nowiki>#</nowiki>{processInstance.getContextInstance().deleteVariable('minutaEmElaboracao')}
 +
 +
Exclui a variável criada anteriormente (evento)
 +
 +
=== Apagar agrupamentos ===
 +
 +
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('AgrupamentosLancadosTemporariamente')}
 +
 +
Apaga possíveis agrupamentos lançados temporiamente anteriormente
 +
 +
=== Apagar movimentos ===
 +
 +
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('MovimentosLancadosTemporariamente')}
 +
 +
Apaga possíveis movimentos lançados temporiamente anteriormente
  
 
== Configurar lançador de movimentações ==
 
== Configurar lançador de movimentações ==
Linha 25: Linha 66:
  
 
Configura os modelos de documento passíveis de serem utilizados pela tarefa cujo nome é <nome da tarefa>. No caso de serem mais de um modelo, os códigos devem ser separados por vírgula.
 
Configura os modelos de documento passíveis de serem utilizados pela tarefa cujo nome é <nome da tarefa>. No caso de serem mais de um modelo, os códigos devem ser separados por vírgula.
 +
 +
Exemplos:
 +
 +
=== Restringir modelos do PAC ===
 +
<nowiki>#</nowiki>{modeloDocumento.set('Processo_Fluxo_prepararExpediente',60,69,65,71)}
 +
 +
Configura os modelos de documento passíveis cujos códigos são 60, 69, 65 e 71 para serem utilizadas na tarefa do [[Preparar_ato_de_comunicação|PAC]] de [[Preparar_ato_de_comunicação#Preparar_comunica.C3.A7.C3.A3o|preparar expediente]].
 +
 +
=== Restringir modelos da minuta ===
 +
 +
<nowiki>#</nowiki>{modeloDocumento.set('minuta_ato_judicial',85,86,75,76)}
 +
 +
Configura os modelos de documento passíveis cujos códigos são 60, 69, 65 e 71 para serem utilizadas na tarefa do [[Preparar_ato_judicial|PAJ]] de [[Preparar_ato_judicial#Minutar ato|minutar]].
  
 
== Verificação de audiências marcadas ==
 
== Verificação de audiências marcadas ==
Linha 32: Linha 86:
 
Verifica se houve audiências marcadas e encaminha o fluxo para as tarefas "Verificar providência a adota" ou "Escolher providência inicial", conforme existência de audiência ou não, respectivamente.
 
Verifica se houve audiências marcadas e encaminha o fluxo para as tarefas "Verificar providência a adota" ou "Escolher providência inicial", conforme existência de audiência ou não, respectivamente.
  
== Verificação de preventos ==
+
<!--== Verificação de preventos ==
  
 
Essa EL retorna "verdadeiro" se houver processos preventos relacionados ao processo do fluxo e falso caso contrário.
 
Essa EL retorna "verdadeiro" se houver processos preventos relacionados ao processo do fluxo e falso caso contrário.
 +
-->
 +
 +
== Remover a exibição do botão GRAVAR na tarefa ==
 +
No evento de criar tarefa crie a variável 'mostrarBotaoGravarNoFluxo', com o valor 'false'.
 +
 +
<nowiki>#</nowiki>{taskInstanceUtil.setVariable('mostrarBotaoGravarNoFluxo','false')}
 +
  
 
== Transição de saída padrão ==
 
== Transição de saída padrão ==
 
<nowiki>#</nowiki>{taskInstanceUtil.setFrameDefaultTransition(' <nome da transição de saída padrão> ')}
 
<nowiki>#</nowiki>{taskInstanceUtil.setFrameDefaultTransition(' <nome da transição de saída padrão> ')}
  
Vinculação da transição de saída padrão da tarefa
+
Vinculação da transição de saída padrão da tarefa  
 +
 
 +
Adicione sempre no evento Criar Tarefa
 +
 
 +
Exemplos:
 +
 
 +
=== Transição de saída padrão ===
 +
<nowiki>#</nowiki>{taskInstanceUtil.setFrameDefaultTransition('Término')}
 +
 
 +
Na tarefa em que é utilizada, a transição de saída padrão passar a ser Término.
 +
 
 +
=== Transição de saída padrão da revisão ===
 +
<nowiki>#</nowiki>{taskInstanceUtil.setFrameDefaultTransition('Confirmar movimentação')}
 +
 
 +
Na tarefa de revisão da minuta ([[Preparar_ato_judicial#Confirmar_ato|Confirmar ato]]), a transição de saída padrão passar a ser Confirmar movimentação.
  
 
== Atos de comunicação em aberto ==
 
== Atos de comunicação em aberto ==
Linha 46: Linha 121:
 
Verifica existência de atos de comunicação em aberto
 
Verifica existência de atos de comunicação em aberto
  
== Existência do movimento com complemento ==
+
<nowiki>#</nowiki>{atoComunicacaoService.getAtosComunicacaoAbertos(processoJudicialService.findById(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo'))) == 0 ? 'Prazos vencidos' : 'Aguardando término dos prazos'}
 +
 
 +
Verifica se há atos de comunicação em aberto (nó de decisão)
 +
 
 +
<!--== Existência do movimento com complemento ==
  
 
<nowiki>#</nowiki>{processoTrfHome.existeMovimentoCompletoTipoDominio('51;50;36;e'}
 
<nowiki>#</nowiki>{processoTrfHome.existeMovimentoCompletoTipoDominio('51;50;36;e'}
  
Verifica se há movimento com complemento registrado no processo (código do movimento e complemento)
+
Verifica se há movimento com complemento registrado no processo (código do movimento e complemento)-->
  
== Existência do movimento ==
+
== Verificação de movimentos ==
 
<nowiki>#</nowiki>{processoTrfHome.existeMovimentoLancadoPorIdEvento(848)}
 
<nowiki>#</nowiki>{processoTrfHome.existeMovimentoLancadoPorIdEvento(848)}
  
 
Verifica se há movimento lançado com aquele identificador
 
Verifica se há movimento lançado com aquele identificador
 +
 +
<nowiki>#</nowiki>{verificaEventoAction.verificarEventos(19, 28)}
 +
 +
Verifica se existem aqueles movimentos no processo
  
 
== Existência de sentença líquida ==
 
== Existência de sentença líquida ==
Linha 62: Linha 145:
 
Verifica se há sentença líquida lançada no processo
 
Verifica se há sentença líquida lançada no processo
  
== Existência de posto avançado ==  
+
== Quantidade de postos avançados ==  
 
<nowiki>#</nowiki>{postoAvancadoAction.numeroDePostosDoOrgaoJulgador() > 0}
 
<nowiki>#</nowiki>{postoAvancadoAction.numeroDePostosDoOrgaoJulgador() > 0}
  
 
Verifica se o OJ  possui posto avançado
 
Verifica se o OJ  possui posto avançado
 +
 +
<nowiki>#</nowiki>{postoAvancadoAction.numeroDePostosDoOrgaoJulgador() == 1 ? 'Encaminhar posto avançado' : 'Escolher posto avançado' }
 +
 +
Verfica a quantidade de postos avançados do OJ (nó de decisão)
  
 
== Verificação de documento de magistrado assinado ==  
 
== Verificação de documento de magistrado assinado ==  
Linha 78: Linha 165:
 
Verifica se último documento do processo está assinado
 
Verifica se último documento do processo está assinado
  
== Verifica movimentos ==
+
== Verificação de audiências ==
<nowiki>#</nowiki>{verificaEventoAction.verificarEventos(19, 28)}
+
 
+
Verifica se existem aqueles movimentos no processo
+
 
+
== Verifica audiência ==
+
  
 
<nowiki>#</nowiki>{processoAudienciaHome.existeAudienciaPendenteProcesso()}
 
<nowiki>#</nowiki>{processoAudienciaHome.existeAudienciaPendenteProcesso()}
  
 
Verifica se há audiência pendente de ser realizada no processo
 
Verifica se há audiência pendente de ser realizada no processo
 +
 +
<nowiki>#</nowiki>{processoAudienciaHome.existeAudienciaPendenteProcesso() ? 'Operações da Audiência' : 'Designar Audiência'}
 +
 +
Verifica se há audiência pendente de ser realizada no processo (nó de decisão)
  
 
== Recupera o posto avançado ==
 
== Recupera o posto avançado ==
Linha 95: Linha 181:
  
 
== Existência de carta precatória ==
 
== Existência de carta precatória ==
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesPrecatorias().size() > 0 ? 'Encaminhar Carta' : 'JoinComunicação'}
+
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesPrecatorias().size() > 0 ? 'Encaminhar Carta' : 'JoinComunicacao'}
  
 
Verifica se há expedientes do tipo carta precatória (nó de decisão)
 
Verifica se há expedientes do tipo carta precatória (nó de decisão)
Linha 105: Linha 191:
  
 
== Expedientes para o diário ==
 
== Expedientes para o diário ==
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesDiario().size() > 0 ? 'Publicar DJE' : 'Joincomunicação'}
+
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesDiario().size() > 0 ? 'Publicar DJE' : 'JoinComunicacao'}
  
 
Verifica se há expedientes enviados para o diário (nó de decisão)
 
Verifica se há expedientes enviados para o diário (nó de decisão)
Linha 113: Linha 199:
  
 
Utilizado para verificar se há partes no processo do tipo órgão público
 
Utilizado para verificar se há partes no processo do tipo órgão público
 +
 +
== Expediente carta ==
 +
 +
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesPrecatorias().size() > 0 ? 'Encaminhar carta' : 'JoinComunicacao'}
 +
 +
Verifica se há expedientes do tipo Carta
  
 
== Expedientes para os correios ==
 
== Expedientes para os correios ==
Linha 118: Linha 210:
 
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesCorreios().size() > 0 ? 'Imprimir Correspondência' : 'JoinComunicacao'}
 
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesCorreios().size() > 0 ? 'Imprimir Correspondência' : 'JoinComunicacao'}
  
Verifica se há expedientes enviados para correio (nó de decisão)
+
Verifica se há expedientes do tipo Correios (nó de decisão)
  
 
== Expediente edital ==
 
== Expediente edital ==
  
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesEdital().size() > 0 ? 'Encaminhar Edital' : 'JoinComunicação'}
+
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesEdital().size() > 0 ? 'Encaminhar Edital' : 'JoinComunicacao'}
  
 
Verifica se há expedientes do tipo edital (nó de decisão)
 
Verifica se há expedientes do tipo edital (nó de decisão)
 +
<!--== ==
  
 
<nowiki>#</nowiki>{processoTrfHome.existeMovimentoCompletoTipoDominio('51;3;5;e')?'Minutar Despacho ou Decisão - Liq':(processoTrfHome.existeMovimentoCompletoTipoDominio('51;3;6;e')?'Minutar Despacho ou Decisão - Liq':'Minutar Sentença - Liq')}
 
<nowiki>#</nowiki>{processoTrfHome.existeMovimentoCompletoTipoDominio('51;3;5;e')?'Minutar Despacho ou Decisão - Liq':(processoTrfHome.existeMovimentoCompletoTipoDominio('51;3;6;e')?'Minutar Despacho ou Decisão - Liq':'Minutar Sentença - Liq')}
  
Verifica se há movimento com complemento registrado no processo (código do movimento e complemento (nó de decisão)
+
Verifica se há movimento com complemento registrado no processo (código do movimento e complemento (nó de decisão) -->
  
<nowiki>#</nowiki>{competenciaClasseAssuntoHome.processoContemClasseAssunto('40;1116;991;992;993;990;261:55292') ? 'Iniciar Execução' : 'Verificar Valor'}
+
== Expediente telefone ==
  
Verifica se há assunto cadastrado para processo (nó de decisão)
+
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesTelefone().size() > 0 ? 'Registrar ciência' : 'JoinComunicacao'}
  
<nowiki>#</nowiki>{atoComunicacaoService.getAtosComunicacaoAbertos(processoJudicialService.findById(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo'))) == 0 ? 'Prazos vencidos' : 'Aguardando término dos prazos'}
+
Verifica se há expedientes do tipo telefone (nó de decisão)
  
Verifica se há atos de comunicação em aberto (nó de decisão)
+
== Expediente pessoal ==
  
<nowiki>#</nowiki>{postoAvancadoAction.numeroDePostosDoOrgaoJulgador() == 1 ? 'Encaminhar posto avançado' : 'Escolher posto avançado' }
+
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesPessoal().size() > 0 ? 'Registrar ciência' : 'JoinComunicacao'}
  
Verfica a quantidade de postos avançados do OJ (nó de decisão)
+
Verifica se há expedientes do tipo pessoal (nó de decisão)
 +
 
 +
== Nó de decisão para expediente pessoal/por telefone ou para expediente DJE ==
  
 +
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesTelefone().size() > 0 or comunicacaoProcessualAction.getExpedientesPessoal().size() > 0 ? 'Registrar ciência' : 'Publicar DJE'}
 +
 +
Verifica se o expediente é pessoal ou por telefone para envio para registro de ciência. Caso contrário, assume que o expediente é para o diário e envia para publicação.
 +
 +
== Verificação de assunto do processo ==
 +
<nowiki>#</nowiki>{competenciaClasseAssuntoHome.processoContemClasseAssunto('40;1116;991;992;993;990;261:55292') ? 'Iniciar Execução' : 'Verificar Valor'}
 +
 +
<font color=red>Verifica se há assunto cadastrado para processo (nó de decisão)</font>
 +
 +
== Documentos não apreciados ==
 
<nowiki>#</nowiki>{documentoJudicialService.haDocumentoNaoApreciado(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ,62,23) ? 'Embargos de Declaração' : 'Aguardando prazo - recurso'}
 
<nowiki>#</nowiki>{documentoJudicialService.haDocumentoNaoApreciado(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ,62,23) ? 'Embargos de Declaração' : 'Aguardando prazo - recurso'}
  
Verifica se há expedientes não apreciados dos tipos especificados (nó de decisão)
+
<nowiki>#</nowiki>{documentoJudicialService.haDocumentoNaoApreciado(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ,62,47,5,42) ? 'Analisar manifestação' : 'Há órgão público?'}
  
<nowiki>#</nowiki>{processoAudienciaHome.existeAudienciaPendenteProcesso() ? 'Operações da Audiência' : 'Designar Audiência'}
+
Verifica se há documento não apreciado (nó de decisão)
 
+
Verifica se há audiência pendente de ser realizada no processo (nó de decisão)
+
  
 +
== Verifica urgência ou sigilo ==
 
<nowiki>#</nowiki>{processoTrfHome.isEmPedidoSegredoJustica() or processoTrfHome.isEmPedidoUrgencia ? 'Apreciar Urgentes' : 'Triagem Inicial'}
 
<nowiki>#</nowiki>{processoTrfHome.isEmPedidoSegredoJustica() or processoTrfHome.isEmPedidoUrgencia ? 'Apreciar Urgentes' : 'Triagem Inicial'}
  
 
Verifica se há pedido de urgência ou segredo de justiça (nó de decisão)
 
Verifica se há pedido de urgência ou segredo de justiça (nó de decisão)
  
 +
== Expediente para central ==
 
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesMandados().size() > 0 ? 'Tem uma Central?' : 'JoinComunicacao'}
 
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesMandados().size() > 0 ? 'Tem uma Central?' : 'JoinComunicacao'}
  
Verifica se há expedientes do tipo mandado ou ofício (nó de decisão)
+
<font color=red>Verifica se há expedientes do tipo mandado ou ofício (nó de decisão)</font>
  
 +
== Expediente após sentença ==
 
<nowiki>#</nowiki>{processoExpedienteManager.existeExpedienteAposUltimaSentenca(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo')) ? 'Aguardando ciência' : 'Aguardando prazo - ED'}
 
<nowiki>#</nowiki>{processoExpedienteManager.existeExpedienteAposUltimaSentenca(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo')) ? 'Aguardando ciência' : 'Aguardando prazo - ED'}
  
 
Verifica se há expedientes após última sentença do processo (nó de decisão)
 
Verifica se há expedientes após última sentença do processo (nó de decisão)
  
<nowiki>#</nowiki>{documentoJudicialService.haDocumentoNaoApreciado(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ,62,47,5,42) ? 'Analisar manifestação' : 'Há órgão público?'}
+
== Expedientes sem ciência ==
 
+
Verifica se há documento não apreciado (nó de decisão)
+
 
+
 
<nowiki>#</nowiki>{processoParteExpedienteManager.todosTomaramCiencia(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ) ? 'Aguardando prazo - ED' : 'Aguardando ciência'}
 
<nowiki>#</nowiki>{processoParteExpedienteManager.todosTomaramCiencia(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ) ? 'Aguardando prazo - ED' : 'Aguardando ciência'}
  
 
Verifica se todos os destinatários já tomaram ciência (nó de decisão)
 
Verifica se todos os destinatários já tomaram ciência (nó de decisão)
  
 +
== Verificação de faixa de valores ==
 
<nowiki>#</nowiki>{processoTrfHome.isViolacaoFaixaValores() ? 'Valor Incompatível' : 'Verificar Urgência'}
 
<nowiki>#</nowiki>{processoTrfHome.isViolacaoFaixaValores() ? 'Valor Incompatível' : 'Verificar Urgência'}
  
 
Verifica se há violação de faixa de valores no processo (nó de decisão)
 
Verifica se há violação de faixa de valores no processo (nó de decisão)
  
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesCorreios().size() > 0 ? 'Imprimir Correspondência' : 'JoinComunicação'}
+
== Verificação de expedientes eletrônicos ==
 
+
Verifica se há expedientes do tipo correios (nó de decisão)
+
 
+
 
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesEletronico().size() > 0 ? 'Encaminhar Via Sistema' : 'JoinComunicacao'}
 
<nowiki>#</nowiki>{comunicacaoProcessualAction.getExpedientesEletronico().size() > 0 ? 'Encaminhar Via Sistema' : 'JoinComunicacao'}
  
 
Verifica se há expedientes do tipo eletrônico (nó de decisão)
 
Verifica se há expedientes do tipo eletrônico (nó de decisão)
  
<nowiki>#</nowiki>{conectorMandados.haVariasCentraisMandado() ? 'Selecionar Central de Mandado' : 'Encaminhar Central Mandados'}
+
== Centrais de mandado ==
 +
<nowiki>#</nowiki>{conectorMandados.haVariasCentraisMandado() ? 'Selecionar central de mandados' : 'Encaminhar central de mandados'}
  
 
Verifica se há mais de uma central de mandado vinculado ao OJ (nó de decisão)
 
Verifica se há mais de uma central de mandado vinculado ao OJ (nó de decisão)
 +
 +
== Verificação de execução ou liquidação ==
  
 
<nowiki>#</nowiki>{(processoTrfHome.isProcessoExecucao() )?'Iniciar Execução':(processoTrfHome.isProcessoLiquidacao() ? 'Iniciar Liquidação' : 'Verificar Valor')}
 
<nowiki>#</nowiki>{(processoTrfHome.isProcessoExecucao() )?'Iniciar Execução':(processoTrfHome.isProcessoLiquidacao() ? 'Iniciar Liquidação' : 'Verificar Valor')}
  
 
Verifica se é processo de execução ou é processo de liquidação  (nó de decisão)
 
Verifica se é processo de execução ou é processo de liquidação  (nó de decisão)
 
<nowiki>#</nowiki>{taskInstanceUtil.setFrameDefaultTransition('Término')}
 
  
Setar a transição padrão para a tarefa (evento)
+
== Tipos de documentos na tarefa ==
  
<nowiki>#</nowiki>{modeloDocumento.set('Processo_Fluxo_prepararExpediente',14,56,69,8,92,93,161,216,217,218)}
+
<nowiki>#</nowiki>{tipoDocumento.set('textEditSecretariaJT',63,62)}
  
Setar modelos de documentos a serem utilizados para a tarefa (evento)
+
Setar tipos de documentos que podem ser utilizados na tarefa (evento)
  
<nowiki>#</nowiki>{tipoDocumento.set('minutaEmElaboracao',63,62)}
+
=== Restringir tipos de documento da revisão de minuta ===
  
Setar tipos de documentos que podem ser utilizados na tarefa  (evento)
+
<nowiki>#</nowiki>{tipoDocumento.set('Processo_Fluxo_revisarMinuta',62,63,64)}
 +
 
 +
Na tarefa [[Preparar ato judicial#Confirmar ato|"confirmar ato"]] (variável "Processo_Fluxo_revisarMinuta" do tipo "Frame") deve-se utilizar a EL para restrição dos tipos de documentos. Nesse exemplo, o primeiro parâmetro do método corresponde ao nome da variável definido no fluxo, os seguintes são os identificadores (ids) dos tipos de documentos que devem ser disponibilizados.
  
 +
== Registro automático de movimentos ==
 
<nowiki>#</nowiki>{preencherMovimento.deCodigo(51).comComplementoDeCodigo(3).doTipoDominio().preencherComElementoDeCodigo(36).lancarMovimento()}
 
<nowiki>#</nowiki>{preencherMovimento.deCodigo(51).comComplementoDeCodigo(3).doTipoDominio().preencherComElementoDeCodigo(36).lancarMovimento()}
  
Linha 214: Linha 319:
 
Registrar movimento automaticamente  (evento)
 
Registrar movimento automaticamente  (evento)
  
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('pje:aguardaEstouroPrazo', 'true')}
+
=== Movimentos com complemento do tipo identificador ===
 +
<nowiki>#</nowiki>{preencherMovimento.deCodigo(135).comProximoComplementoVazio().preencherComTexto(processoTrfHome.instance.numeroProcesso).lancarMovimento()}
  
Cria a variável setando o valor inicial (evento)
+
Registrar com movimento com código 135 com complemento utilizando o número do processo
  
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('pje:aguardaFecharExpediente', 'true')}
+
=== Movimentos com complemento do tipo livre ===
 +
<nowiki>#</nowiki>{preencherMovimento.deCodigo(10966).comComplementoDeCodigo(<CODIGO_DO_TIPO_DE_COMPLEMENTO_CRIADO>).doTipoLivre().
 +
preencherComTexto(processoHistoricoClasseHome.instance.classeJudicialAnterior).comComplementoDeCodigo(<CODIGO_DO_TIPO_DE_COMPLEMENTO_CRIADO>).
 +
doTipoLivre().preencherComTexto(processoHistoricoClasseHome.instance.classeJudicialAtual).lancarMovimento()}
  
Cria a variável setando o valor inicial (evento)
+
Registrar movimento do tipo 10966 com dois complementos do tipo livre, a classe judicial anterior do processo e a classe judicial atual. Para utilização dessa EL, deve ser criado um complemento de nome "tipo", do tipo livre. O código utilizado na criação deve ser inserido na EL em lugar do campo <CODIGO_DO_TIPO_DE_COMPLEMENTO_CRIADO>.
  
<nowiki>#</nowiki>{taskInstanceUtil.setVariable('ocultarAssinatura', 'true')}
 
  
Cria a variável setando o valor inicial (evento)
+
=== Movimento de mudança de classe ===
  
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('pje:aguardaEstouroPrazo')}
+
<nowiki>#</nowiki>{preencherMovimento.deCodigo(10966).comComplementoDeNome('classeAnterior').preencherComTexto(classeAntiga).comComplementoDeNome('classeAtual').preencherComTexto(classeNova).lancarMovimento()}
  
Exclui a variável criada anteriormente (evento)
+
<!--<nowiki>#</nowiki>{preencherMovimento.deCodigo(10966).comComplementoDeCodigo(30).doTipoDinamico().preencherComObjeto(processoTrfHome.getClasseJudicialAnterior()).
 +
comComplementoDeCodigo(31).doTipoDinamico().preencherComObjeto(processoTrfHome.getClasseProcesso()).lancarMovimento()}-->
  
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('pje:aguardaCiencia')}
+
Registrar movimento do tipo 10966, o sistema deve lançar a movimentação, que possui o formato: Classe Processual alterada de #{classeAnterior} para #{classeNova}.
  
Exclui a variável criada anteriormente (evento)
+
Para essa EL funcionar, devem ter sido configurados os seguintes valores no sistema:
  
<nowiki>#</nowiki>{processInstance.getContextInstance().deleteVariable('minutaEmElaboracao')}
+
== Exclusão de movimento ==
 
+
Exclui a variável criada anteriormente (evento)
+
  
 
<nowiki>#</nowiki>{lancadorMovimentosService.excluirUltimoMovimento('51')}
 
<nowiki>#</nowiki>{lancadorMovimentosService.excluirUltimoMovimento('51')}
Linha 242: Linha 349:
 
Excluir o último registro do movimento processual (evento)
 
Excluir o último registro do movimento processual (evento)
  
 +
== Exclusão de movimentos temporários ==
 
<nowiki>#</nowiki>{lancadorMovimentosService.apagarMovimentosTemporarios()}
 
<nowiki>#</nowiki>{lancadorMovimentosService.apagarMovimentosTemporarios()}
  
Exclui movimentos serializados (evento)
+
<font color = red>Exclui movimentos serializados (evento)</font>
  
 +
== Encaminhamento para posto avançado ==
 
<nowiki>#</nowiki>{postoAvancadoAction.encaminharParaPostoAvancado()}
 
<nowiki>#</nowiki>{postoAvancadoAction.encaminharParaPostoAvancado()}
  
Remete o processo para o Posto avançado cadastrado para o OJ (evento)
+
Remete o processo para o posto avançado cadastrado para o OJ (evento)
  
 +
== Retorno do posto avançado para o órgão julgador ==
 
<nowiki>#</nowiki>{postoAvancadoAction.retornarParaOrgaoJulgador()}
 
<nowiki>#</nowiki>{postoAvancadoAction.retornarParaOrgaoJulgador()}
  
 
Executa o método que efetiva o retorno do processo para o OJ principal do posto avançado
 
Executa o método que efetiva o retorno do processo para o OJ principal do posto avançado
  
 +
== Meios de comunicação possíveis ==
 
<nowiki>#</nowiki>{preparaAtoComunicacaoAction.setMeiosComunicacao('P,E,C,M,L')}
 
<nowiki>#</nowiki>{preparaAtoComunicacaoAction.setMeiosComunicacao('P,E,C,M,L')}
  
Linha 261: Linha 372:
  
 
Setar os meios de comunicação possíveis de uso no preparar ato de comunicação (evento)
 
Setar os meios de comunicação possíveis de uso no preparar ato de comunicação (evento)
 +
 +
<nowiki>#</nowiki>{preparaAtoComunicacaoAction.setMeiosComunicacao('P,E,C,L,M,T,S')}
 +
 +
Setar os meios de comunicação possíveis de uso no preparar ato de comunicação.
 +
 +
== Habilitar homologação da sentença ==
  
 
<nowiki>#</nowiki>{resultadoSentencaService.homologarResultadoSentenca()}
 
<nowiki>#</nowiki>{resultadoSentencaService.homologarResultadoSentenca()}
  
 
Habilitar o botão para homologação de sentenca (evento)
 
Habilitar o botão para homologação de sentenca (evento)
 +
 +
== Exclusão de resultado não homologado ==
  
 
<nowiki>#</nowiki>{resultadoSentencaService.excluirResultadoSentencaNaoHomologado()}
 
<nowiki>#</nowiki>{resultadoSentencaService.excluirResultadoSentencaNaoHomologado()}
Linha 270: Linha 389:
 
Exclui o registro de resultado de sentença (evento)
 
Exclui o registro de resultado de sentença (evento)
  
<nowiki>#</nowiki>{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('C', 'processoExpedienteAtual', '#{preencherMovimento.deCodigo(60).comComplementoDeCodigo(4).preencherComObjeto(processoExpedienteAtual.getProcessoDocumento().getTipoProcessoDocumento()).comComplementoDeCodigo(13).doTipoDominio().preencherComElementoDeCodigo(7030).lancarMovimento()}')}
+
== Registrar ciência ==
 +
 
 +
<nowiki>#</nowiki>{comunicacaoProcessualAction.registrarCienciaExpedientePessoal()}
 +
 
 +
Registra a ciência do expediente feito na própria secretaria (por telefone ou pessoalmente)
 +
 
 +
== Envio de expediente e registro de movimento ==
 +
Expressões utilizadas para envio de expedientes e concomitante registro de movimento associado ao envio, ou seja, movimento de código 60 - Expedição de documento.
 +
 
 +
=== Envio de expediente do tipo aviso de recebimento ===
 +
<nowiki>#</nowiki>{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('C', 'processoExpedienteAtual', '<nowiki>#</nowiki>{preencherMovimento.deCodigo(60).associarAoDocumento(processoExpedienteAtual.getProcessoDocumento()).
 +
comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>).doTipoDominio().
 +
preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_aviso_de_recebimento>).lancarMovimento()}
 +
')}
 +
 
 +
Envia o expediente Correios e registra o movimento processual de forma automatizada (evento)
 +
 
 +
=== Envio de expediente do tipo mandado ===
 +
<nowiki>#</nowiki>{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('M', 'processoExpedienteAtual', '<nowiki>#</nowiki>{preencherMovimento.deCodigo(60).associarAoDocumento(processoExpedienteAtual.getProcessoDocumento()).
 +
comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>).doTipoDominio().
 +
preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_mandado>).lancarMovimento()}
 +
')}
 +
 
 +
Envia o expediente do tipo mandado e registra o movimento processual de forma automatizada (evento)
 +
 
 +
=== Envio de expediente do tipo eletrônico ===
 +
 
 +
<nowiki>#</nowiki>{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('E', 'processoExpedienteAtual',
 +
'<nowiki>#</nowiki>{preencherMovimento.deCodigo(60).associarAoDocumento(processoExpedienteAtual.getProcessoDocumento()).
 +
comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>).                 doTipoDominio().preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_outros_documentos>).lancarMovimento()}')}
 +
 
 +
Envia o expediente eletrônico e registra o movimento processual de forma automatizada (evento)
 +
 
 +
== Envio de expediente ==
 +
<nowiki>#</nowiki>{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('P', 'processoExpedienteAtual', <nowiki>''</nowiki>)}
 +
 
 +
Envia o expediente utilizando o conector com o diário de justiça eletrônico, se existir.
 +
 
 +
== Preencher movimento de expedição de documento ==
 +
 
 +
<nowiki>#</nowiki>{preencherMovimento.deCodigo(60).comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>).doTipoDominio().
 +
preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_outros_documentos>).associarAoDocumentoDeId(processoHome.idProcessoDocumento).
 +
lancarMovimento()}
 +
 
 +
Preenche o movimento de "Expedição de outros documentos", utilizado em expedientes para o diário de justiça eletrônico, por telefone e pessoais.
 +
<!--
 +
#{preencherMovimento.deCodigo(60).comComplementoDeCodigo(4).doTipoDominio().preencherComElementoDeCodigo(93).associarAoDocumentoDeId(processoHome.idProcessoDocumento).lancarMovimento()}
 +
<font color=red>O trecho de associação do movimento ao documento não funciona. Pendência [http://www.cnj.jus.br/jira/browse/PJEII-14567 PJEII-14567]. Temporariamente, deve-se utilizar a expressão sem a associação, conforme abaixo:</font>
 +
 
 +
<nowiki>#</nowiki>{preencherMovimento.deCodigo(60).comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>).
 +
doTipoDominio().preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_outros_documentos>).lancarMovimento()}-->
 +
 
 +
 
 +
== Lista de documentos ==
 +
<!--http://www.cnj.jus.br/jira/browse/PJEII-6384-->
 +
 
 +
 
 +
Quando o processo é físico, o advogado autor apresenta DUAS cópias da petição inicial. Uma delas será encaminhada conjuntamente com a intimação inicial ao Reclamado.
 +
No processo eletrônico esse custo (milhares de processos x milhares de folhas) será da Justiça do Trabalho que tem de imprimir a inicial para encaminhar a notificação ao(s) reclamado(s).
 +
O TRT13, dentre outros, solucionou o problema colocando códigos de acesso aos documentos no corpo da notificação, de forma que o reclamado é instruído a acessar o documento e fazer o download. Manda-se apenas uma única folha. Inclusive o formato, preparado para dobrar em tres partes onde a 1a parte exposta contém o endereço do destinatário.
 +
Anexo envio exemplo.
 +
 
 +
Criar variável com lista de documentos (códigos de acesso) para compor Notificação Inicial e assim não ter que imprimir a petição inicial para envio via correio
 +
 
 +
<nowiki>#</nowiki>{processoTrfHome.tabelaHashDocumentos}
 +
 
 +
 
 +
== Verificar se o processo chegou via MNI ==
 +
 
 +
<nowiki>#</nowiki>{intercomunicacaoService.processoAutuadoViaMNI(processoTrfHome.instance)}
 +
 
 +
Retorna verdadeiro se o processo chegou via MNI.
 +
 
 +
=== Definir um procedimento manual que deve ser feito pela instância de primeiro grau quando a instância de segundo grau devolve um processo que não foi remetido via MNI ===
 +
 
 +
No fluxo, após a atividade que devolve o processo para o primeiro grau, incluir um nó de decisão com a expressão abaixo:
 +
 
 +
<nowiki>#</nowiki>{intercomunicacaoService.processoAutuadoViaMNI(processoTrfHome.instance)?'Recebimento do processo':'Fim'}
 +
 
 +
onde: 'Recebimento do processo' corresponde ao nome da tarefa que será executada pela instância de primeiro grau depois que a instância de segundo grau devolver o processo. Esta atividade só será executada se o processo devolvido não tiver chegado no segundo grau via MNI. 'Fim' corresponde ao nó de término.
 +
 
 +
Assim, se o processo foi remetido para o segundo grau sem usar MNI, quando o segundo grau devolver o processo para o primeiro grau, o primeiro grau terá que executar a atividade 'Recebimento do processo'. Mas quando o processo foi remetido para o segundo grau por meio do MNI, quando o segundo grau devolver o processo para o primeiro grau, nenhuma intervenção manual será necessária.
 +
 
 +
== Deslocamento de processo para a presidência ==
 +
 
 +
Para realizar o deslocamento de um processo para a presidência no PJe, é necessário, como pré-condição, que se obtenha, no banco de dados, os identificadores do colegiado a que a presidência está vinculada, do próprio órgão presidência e do órgão julgador cargo (cargo judicial concreto) da presidência.<br>
 +
Após, devem ser criados dois nós de sistema, um para a ida, e outro para a volta. No meio, devem ser colocadas as atividades da presidência.<br>
 +
Eis a descrição ideal dos nós de ida e de volta:
 +
 
 +
* 4 eventos na ida em nó de sistema. Os três primeiros, ao entrar no nó, para gravação do juízo de origem
 +
<<<<<<< Nó de ida >>>>>>>>>>>>
 +
 
 +
-> tramitacaoProcessualService.gravaVariavel("pje:fluxo:identificador:orgaoOrigem", processoTrfHome.instance.orgaoJulgador.idOrgaoJulgador)
 +
 
 +
-> tramitacaoProcessualService.gravaVariavel("pje:fluxo:identificador:colegiadoOrigem", 
 +
processoTrfHome.instance.orgaoJulgadorColegiado.idOrgaoJulgadorColegiado)
 +
 
 +
-> tramitacaoProcessualService.gravaVariavel("pje:fluxo:identificador:cargoOrigem",
 +
processoTrfHome.instance.orgaoJulgadorCargo.idOrgaoJulgadorCargo)
 +
 
 +
Ao sair do nó de sistema
 +
#{processoJudicialService.deslocarOrgaoJulgador(processoTrfHome.instance, 2 (id órgão presidência), 1 (id órgão julgador colegiado),
 +
18 (id do orgao julgador  cargo presidência)}
 +
 
 +
<<<<<<< Fim do nó de ida >>>>>>>>>>>>
 +
 
 +
* Volta
 +
 
 +
<<<<<<< Nó de volta >>>>>>>>>>>>
 +
 
 +
Ao entrar no nó:
 +
#{processoJudicialService.deslocarOrgaoJulgador(processoTrfHome.instance,
 +
tramitacaoProcessualService.recuperaVariavel("pje:fluxo:identificador:orgaoOrigem"), 
 +
tramitacaoProcessualService.recuperaVariavel("pje:fluxo:identificador:colegiadoOrigem"),
 +
tramitacaoProcessualService.recuperaVariavel("pje:fluxo:identificador:cargoOrigem")}
 +
 
 +
Ao sair do nó
 +
-> tramitacaoProcessualService.apagaVariavel("pje:fluxo:identificador:orgaoOrigem")
 +
 
 +
-> tramitacaoProcessualService.apagaVariavel("pje:fluxo:identificador:colegiadoOrigem")
 +
 
 +
-> tramitacaoProcessualService.apagaVariavel("pje:fluxo:identificador:cargoOrigem")
 +
 
 +
<<<<<<< Fim do nó de volta >>>>>>>>>>>>
 +
 
 +
== Acesso a sistemas externos por meio de tarefas de fluxo ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.gravaVariavelTarefa('pje:flx:paginaExterna', 'URL_DO_SISTEMA_EXTERNO')}
 +
 
 +
Frame que permite o acesso a sistemas externos por meio de tarefas de fluxo.
 +
Exemplos de sistemas que poderiam ser acessados: Bacenjud, Renajud, Banco Nacional de Bens Apreendidos e eventuais sistemas de controle de precatórios.
 +
 
 +
== Supressão de visualizadores em processos sigilosos ==
 +
 
 +
<nowiki>#</nowiki>{processoVisibilidadeSegredoManager.limpaRegistros(processo)}
 +
 
 +
Limpa a lista de visualizadores de um determinado processo.
 +
 
 +
== Enviar intimação para Ministério Público ==
 +
 
 +
<nowiki>#</nowiki>{atoComunicacaoService.intimarDestinatarioEletronicamente(tramitacaoProcessualService.recuperaProcesso().idProcessoTrf, <idPessoaMP>, '<tipoprazo>',<qtd_prazo>,<cod_modelo>,<cod_tipo>)}
 +
 
 +
Expressão a ser inserida no evento "Ao entrar no nó" de um nó de sistema para realizar a intimação automática do ministério público. Para isso, seguem os significados dos parâmetros:
 +
 
 +
* <idPessoaMP> - deve ser substituído pela id da pessoa ao qual está vinculado o Ministério Público
 +
* <tipoprazo> - deve ser substituído pelo Tipo de prazo correspondente, conforme opções disponíveis na regra de domínio [[Regras_de_domínio#RD96|RD96]]. Por exemplo, D.
 +
* <qtd_prazo> - é a quantidade a ser associado ao tipo de prazo. Por exemplo, se esse valor for 5 e o valor do parâmetro anterior for 'D', o prazo de resposta da intimação são cinco dias
 +
* <cod_modelo> - código do modelo de documento a ser utilizado pela intimação
 +
* <cod_tipo> - código do tipo de documento a ser utilizado pela intimação
 +
 
 +
 
 +
<nowiki>#</nowiki>{atoComunicacaoService.intimarDestinatarioEletronicamente(tramitacaoProcessualService.recuperaProcesso().idProcessoTrf, <idPessoaMP>, '<tipoprazo>',<qtd_prazo>,<cod_doc>)}
 +
 
 +
Expressão a ser inserida no evento "Ao entrar no nó" de um nó de tarefa para realizar a intimação automática do ministério público. Para isso, seguem os significados dos parâmetros:
 +
 
 +
* <idPessoaMP> - deve ser substituído pela id da pessoa ao qual está vinculado o Ministério Público
 +
* <tipoprazo> - deve ser substituído pelo Tipo de prazo correspondente, conforme opções disponíveis na regra de domínio [[Regras_de_domínio#RD96|RD96]]. Por exemplo, D.
 +
* <qtd_prazo> - é a quantidade a ser associado ao tipo de prazo. Por exemplo, se esse valor for 5 e o valor do parâmetro anterior for 'D', o prazo de resposta da intimação são cinco dias
 +
* <cod_doc> - código do documento a ser utilizado pela intimação
 +
 
 +
== Registrar inclusão em pauta ==
 +
 
 +
<nowiki>#</nowiki>{processoJudicialManager.aptidaoParaJulgamento(processoTrfHome.instance.idProcessoTrf, true)}
 +
 
 +
Expressão utilizada para que um processo esteja marcado como selecionado para pauta, via de regra utilizada em um nó de sistema
 +
 
 +
== Criar um nó de decisão baseado na classe judicial do processo ==
 +
 
 +
<nowiki>#</nowiki>{processoTrfHome.instance.classeJudicial.codClasseJudicial == 'códigoClasse'  ? 'transiçãoSeVerdadeiro' : 'transiçãoSeFalso'}
 +
 
 +
Expressão utilizada para criar um nó de decisão baseado na classe judicial do processo
 +
 
 +
 
 +
== Identificar os meios de comunicação sem ciência registrada ==
 +
 
 +
<nowiki>#</nowiki>{taskInstanceUtil.setVariable('pje:fluxo:registrociencia:meios','P,T')}
 +
 
 +
Expressão utilizada para identificar quais os meios de comunicação/expedição sem ciência registrada que poderão ter ciência manipulada na tarefa
 +
[[ Registro_manual_de_ci%C3%AAncia_de_expedientes | Registro manual de ciência de expedientes]].
 +
 
 +
A sequência de valores do parâmetro ''pje:fluxo:registrociencia:meios'' implica na sequência de meios de comunicação desejados de acordo com a lista de meios de comunicação permitidos para a tarefa em questão:
 +
* P("Diário Eletrônico");
 +
* L("Carta") - exemplos: carta rogatória, de ordem ou precatória;
 +
* D("Edital");
 +
* N("Comunicação");
 +
* S("Pessoalmente");
 +
* T("Telefone").
 +
 
 +
 
 +
== Transição de desistência ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.gravaVariavelTarefa('pje:fluxo:transicao:dispensaRequeridos','Nome da transição que dispensa os campos')}
 +
 
 +
Expressão utilizada na configuração de evento em nó de tarefa para caracterizar transição de desistência, ou seja, transição que não validará campos da tela.
 +
 
 +
== Registrar situação processual ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.acrescentarSituacao('codigo_da_situacao')}
 +
 
 +
Expressão a ser utilizada na configuração de evento para registrar uma determinada situação no processo. A situação deve ter sido previamente [[Manual_de_referência#Tipo_de_situa.C3.A7.C3.A3o_processual|configurada]].
 +
 
 +
As situações do processo são exibidas, de acordo com permissão adequada, no [[Funcionalidades#Ferramentas|detalhamento do processo]].
 +
 
 +
== Encerrar situação processual ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.removerSituacao('codigo_da_situacao')}
 +
 
 +
Expressão a ser utilizada na configuração de evento para remover uma determinada situação do processo já registrada anteriormente.
 +
 
 +
As situações do processo são exibidas, de acordo com permissão adequada, no [[Funcionalidades#Ferramentas|detalhamento do processo]].
 +
 
 +
 
 +
== Verificar situação processual ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.temSituacao('<nome da situação>')}
 +
 
 +
Expressão a ser utilizada para verificar se o processo tem determinada situação processual ainda não encerrada.
 +
 
 +
As situações do processo são exibidas, de acordo com permissão adequada, no [[Funcionalidades#Ferramentas|detalhamento do processo]].
 +
 
 +
== Recuperar id do órgão julgador do processo ==
 +
 
 +
<nowiki>#</nowiki>{processoTrfHome.instance.orgaoJulgador.idOrgaoJulgador}
 +
 
 +
Expressão a ser utilizada para recuperar o id do órgão julgador do processo. A expressão pode ser utilizada, por exemplo, na verificação de condição em uma transição. Se uma determinada transição só deve estar disponível para processos distribuídos para determinado órgão julgador, pode-se utilizar a o registro de condição na configuração da transição da seguinte forma:
 +
 
 +
<nowiki>#</nowiki>{processoTrfHome.instance.orgaoJulgador.idOrgaoJulgador == 3}
 +
 
 +
Da mesma forma, pode-se restringir a transição à processos que não sejam de determinado órgão julgado:
 +
 
 +
<nowiki>#</nowiki>{processoTrfHome.instance.orgaoJulgador.idOrgaoJulgador != 3}
 +
 
 +
 
 +
== Recuperar o nome da pessoa ==
 +
 
 +
<nowiki>#</nowiki>{processoParte.pessoa.inTipoPessoa eq 'J' ? pessoaJuridicaManager.findById(parteSelecionada.pessoa.idPessoa).nomeFantasia : parteSelecionada.getNomeParte()}
 +
 
 +
Expressão que retorna o nome da pessoa física ou o nome fantasia da pessoa jurídica parte do processo.
 +
 
 +
== Verificar papel do usuário ==
 +
 
 +
<nowiki>#</nowiki>{org.jboss.seam.security.identity.hasRole('<identificador do papel>')}
 +
 
 +
Expressão verifica se o usuário tem o papel passado como parâmetro. Por exemplo:
 +
 
 +
<nowiki>#</nowiki>{org.jboss.seam.security.identity.hasRole('cnj:chefesetor')}
 +
 
 +
== Recuperar classe judicial do processo ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.recuperaProcesso().classeJudicial.codClasseJudicial}
 +
 
 +
Expressão recupera a classe judicial do processo.  A expressão pode ser utilizada, por exemplo, na verificação de condição em uma transição. Se uma determinada transição só deve estar disponível para processos de determinada classe judicial, pode-se utilizar a o registro de condição na configuração da transição da seguinte forma:
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.recuperaProcesso().classeJudicial.codClasseJudicial == '11888'}
 +
 
 +
== Definir variável ==
 +
 
 +
Há dois tipos de variável que podem ser criadas, variáveis de fluxo e variáveis de tarefa.
 +
- Variáveis de fluxo são variáveis que quando criadas em alguma tarefa do fluxo, continuam disponíveis para uso em qualquer tarefa do fluxo até que sejam apagadas.
 +
- Variáveis de fluxo são variáveis cujo contexto de utilização é apenas para a tarefa na qual foram criadas, desta forma, mesmo que não tenham sido apagadas durante o andamento do fluxo, estas variáveis não estarão disponíveis de uma tarefa para outra.
 +
 
 +
=== Definição de variáveis de fluxo ===
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.gravaVariavel('<nome da variável', <valor>)}
 +
 
 +
=== Definição de variáveis de tarefa ===
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.gravaVariavelTarefa('<nome da variável>', '<valor>')}
 +
 
 +
Similarmente à definição já descrita no início dessa página ([[Expressões#Definir_vari.C3.A1vel_no_fluxo|aqui]]), define um valor para uma variável a fim de recuperá-lo posteriormente.
 +
 
 +
== Recuperar variável definida anteriormente ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.recuperaVariavel('<nome da variável')}
 +
 
 +
Similarmente à recuperação já descrita com o uso de getVariable, recupera o valor de uma variável definida anteriormente. Caso não tenha sido definida, o valor retornará vazio.
 +
 
 +
A expressão pode ser utilizada, por exemplo, na definição de um nó de decisão. Pode-se optar por uma transição caso não tenha sido definida uma variável ou não tenha sido definida com o valor "true" e por outra transição caso a situação seja diferente dessa. Segue o exemplo:
 +
 
 +
<nowiki>#</nowiki>{empty tramitacaoProcessualService.recuperaVariavel('cnj:fluxo:determinacaoPrevia') or not tramitacaoProcessualService.recuperaVariavel('cnj:fluxo:determinacaoPrevia') ? 'Decisão inicial' : 'Cumprir determinação'}
 +
 
 +
 
 +
Pode-se utilizar um campo do tipo "Aviso" para exibir o conteúdo de uma variável de fluxo, para isso deve-se dar um nome de variável qualquer (diferente do nome da variável que se quer exibir o conteúdo) e no campo "Label" a expresão: <nowiki>#{tramitacaoProcessualService.recuperaVariavel('<nome da variável')}</nowiki> e o campo Escrita deve estar marcado.
 +
 
 +
*se o valor da variável for um campo datetime deve-se utilizá-la separadamente de qualquer outro texto no campo do tipo aviso, desta forma o sistema exibirá na seguinte formatação: DD/MM/AAAA, pois se este tipo de variável estiver no meio de um texto o sistema não fará esta formatação, exibindo o texto da seguinte forma: NONONONONO AAAA-MM-DD 00:00:00.
 +
 
 +
== Apagar variável ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.apagaVariavel('cnj:fluxo:determinacaoPrevia')}
 +
 
 +
Similarmente à remoção já descrita anteriormente ([[Expressões#Excluir_vari.C3.A1vel|aqui]]), apaga a variável definida anteriormente.
 +
 
 +
== Verificar urgência ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.temUrgencia()}
 +
 
 +
Verifica se foi registrado pedido de liminar ou de antecipação de tutela para o processo ainda não apreciado.
 +
 
 +
 
 +
== Verificar movimento de determinado grupo ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.temMovimento('<nome do grupo>')}
 +
 
 +
Verifica se houve registro no processo de algum movimento do grupo fornecido como parâmetro.
 +
 
 +
 
 +
== Verificar movimento de determinado grupo até determinada data ==
 +
<font color=red>Em construção</font>
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.temMovimentoDoGrupo('<nome do grupo>', tramitacaoProcessualService.recuperaVariavel(<variaveldatadefinidaanteriormente>))}
 +
 
 +
Verifica se houve, até a data fornecida como parâmetro, registro no processo de algum movimento do grupo fornecido como parâmetro. Deve-se observar que a data passada como parâmetro pode vir na forma de uma variável do tipo "java.util.Date". Entre outras opções, para se obter uma data nesse formato, pode-se utilizar a seguinte função da biblioteca do PJe:
 +
 
 +
DateUtil.stringToDate(datatexto, formato)
 +
 
 +
Como exemplo, segue a chamada da EL utilizando a data formatada:
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.temMovimentoDoGrupo('Julgamento', DateUtil.stringToDate('2014-03-14', 'yyyy-MM-dd') )}
 +
 
 +
 
 +
Pode-se, por exemplo, utilizar a verificação em um nó de decisão conforme exemplo de expressão abaixo:
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.temMovimentoDoGrupo('Julgamento', tramitacaoProcessualService.recuperaVariavel('pje:julgado:data')) ? 'Comunicar de decisão terminativa' : 'Cumprir decisão em pedido urgente'}
 +
 
 +
== Recuperar ano do processo ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.recuperaProcesso().ano}
 +
 
 +
Recupera o campo ano de distribuição do processo. O ano está presente no número do processo conforme valor de xxxx da máscara abaixo:
 +
 
 +
nnnnnnn-nn.xxxx.n.nn.nnnn
 +
 
 +
== Recuperar número sequencial do processo ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.recuperaProcesso().numeroSequencia}
 +
 
 +
Recupera o campo sequencial do número do processo, ou seja, o valor de xxxxxxx da máscara abaixo:
 +
 
 +
xxxxxxx-nn.nnnn.n.nn.nnnn
 +
 
 +
 
 +
== Comparar assunto ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.temAssunto(codigoAssunto)}
 +
 
 +
Verifica se o processo judicial atual tem, entre seus assuntos ativos, aquele cujo código é o passado como parâmetro.
 +
 
 +
== Verificar assunto conforme agrupamento ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.temAssuntoDoGrupo(codigoAgrupamento)}
 +
 
 +
Verifica se o processo tem, entre seus assuntos, algum dos assuntos contidos no [[Manual_de_referência#Agrupamento_de_classes_ou_assuntos|agrupamento]] passado como parâmetro.
 +
 
 +
== Atribuir segredo de justiça ==
 +
 
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.recuperaProcesso().setSegredoJustica(true)}
 +
 
 +
Atribui [[Regras_de_negócio#RN443|segredo de justiça]] ao processo. Via de regra, será utilizada ao distribuir o processo caso seja verificado que o processo tem a ele associado determinados assuntos (verificação através de expressões [[Expressões#Comparar_assunto|temAssunto]] e [[Expressões#Verificar_assunto_conforme_agrupamento|temAssuntoDoGrupo]]).
 +
 
 +
== Verificar decisão pelo tipo de documento ==
 +
 
 +
<nowiki>#</nowiki>{processoDocumentoManager.findById(tramitacaoProcessualService.recuperaVariavel(“pje:atoProferido”)). tipoProcessoDocumento.idTipoProcessoDocumento == ID_TIPO_DOCUMENTO_DECISAO}
 +
 
 +
Verifica se há documento no processo que caracteriza uma decisão
 +
 
 +
== Criar fluxo paralelo ==
 +
 
 +
<nowiki>#</nowiki>{processoJudicialService.incluirNovoFluxo(tramitacaoProcessualService.recuperaProcesso(), '<código do fluxo>')}
 +
 
 +
Inicia no processo o fluxo identificado pelo código passado como parâmetro. Abaixo, veja como fica a EL que inicia o fluxo de digitalização identificado pelo código FLXDIGIT:
 +
 
 +
<nowiki>#</nowiki>{processoJudicialService.incluirNovoFluxo(tramitacaoProcessualService.recuperaProcesso(), 'FLXDIGIT')}
 +
 
 +
 
 +
== Verificar magistrados vinculados ==
 +
 
 +
<nowiki>#</nowiki>{vinculacaoMagistradoAction.magistradosVinculados.size() > 0}
 +
 
 +
Verifica se há pelo menos um magistrado vinculado ao processo. Essa expressão é útil em instalações onde determinados processos podem ser atribuídos a magistrados que compõem o órgão julgador, mas que não estão caracterizados como titular do órgão. Essa vinculação pode ser realizada por meio da aba Processos da configuração do órgão julgador ou por meio de tarefa no fluxo.
 +
 
 +
 
 +
== Liberar documentos da sessão ==
 +
 
 +
<nowiki>#</nowiki>{sessaoProcessoDocumentoManager.liberarDocumentosSessao(processoTrfHome.instance, <ORGAO-JULGADOR>, <SESSÃO-JULGAMENTO>)}
 +
 
 +
Expressão utilizada para liberar os documentos (voto, relatório, ementa) de um dado processo, associados a um órgão julgador, para uma determinada sessão de julgamento.
 +
 
 +
Para liberar todos os documentos do relator de um processo, independentemente da sessão, utilize a EL assim:
 +
<nowiki>#</nowiki>{sessaoProcessoDocumentoManager.liberarDocumentosSessao(processoTrfHome.instance, processoTrfHome.instance.orgaoJulgador, null)}
 +
 
 +
Para liberar todos os documentos não só do relator, mas inclusive dos demais vogais, independentemente da sessão, utilize a EL assim:
 +
<nowiki>#</nowiki>{sessaoProcessoDocumentoManager.liberarDocumentosSessao(processoTrfHome.instance, null, null)}
 +
 
 +
 
 +
== Verificação se o relatório está assinado ==
  
Remete o expediente e registra o movimento processual de forma automatizada (evento)
+
<nowiki>#</nowiki>{votacaoColegiadoAction.relatorioAssinado}
  
<nowiki>#</nowiki>{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('M', 'processoExpedienteAtual', '#{preencherMovimento.deCodigo(60).comComplementoDeCodigo(4).preencherComObjeto(processoExpedienteAtual.getProcessoDocumento().getTipoProcessoDocumento()).comComplementoDeCodigo(13).doTipoDominio().preencherComElementoDeCodigo(7030).lancarMovimento()}#{preencherMovimento.deCodigo(50079).comComplementoDeCodigo(5037).doTipoDominio().preencherComElementoDeCodigo(7238).comComplementoDeCodigo(7).doTipoDominio().preencherComElementoDeCodigo(7051).comComplementoDeCodigo(18).doTipoDominio().preencherComElementoDeCodigo(7084).lancarMovimento()}')}
+
Esta expressão verifica se o relatório do processo está assinado, utiliza-se esta expressão para verificar se o fluxo pode ser encaminhado para a inclusão de pauta, visto que o relatório estar assinado é condição essencial (no CNJ) para solicitar a inclusão de um processo em pauta.
  
Remete o expediente e registra o movimento processual de forma automatizada (evento)
 
  
<nowiki>#</nowiki>{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('E', 'processoExpedienteAtual', '#{preencherMovimento.deCodigo(60).comComplementoDeCodigo(4).preencherComObjeto(processoExpedienteAtual.getProcessoDocumento().getTipoProcessoDocumento()).comComplementoDeCodigo(13).doTipoDominio().preencherComElementoDeCodigo(7030).lancarMovimento()}')}
+
== Restringir tipos de documentos na reclassificação ==
  
Remete o expediente e registra o movimento processual de forma automatizada (evento)
+
<nowiki>#</nowiki>{tramitacaoProcessualService.gravaVariavelTarefa('pje:reclassificarDocumento:idsTipoDocumentoProibidoAlterar','12,62,63,64')}
  
 +
Esta expressão restringe os tipos de documentos que serão disponibilizados na tarefa de reclassificação de documentos. A expressão deve ser configurada em uma ação no evento "Criar tarefa" da tarefa de reclassificação. Na mesma tarefa, deve-se configurar a seguinte expressão em uma ação no evento "Ao sair do nó":
  
== Restringir código de tipo de documento para envio de remessa ao STF ==
+
<nowiki>#</nowiki>{tramitacaoProcessualService.apagaVariavelTarefa('pje:reclassificarDocumento:idsTipoDocumentoProibidoAlterar')}
  
<nowiki>#</nowiki>{taskInstanceUtil.setVariable('pje:fluxo:remessaSTF:tipoDocumento:codigo>',<código(s) do(s) tipos(s) de documento(s) permitido(s)>)}
+
== Especificar tipos de documentos na reclassificação ==
+
Configura os códigos dos tipos de documentos permitidos na preparação de remessa a ser enviada ao STF. A variável '''pje:fluxo:remessaSTF:tipoDocumento:codigo''' deve ser criada na tarefa responsável pela preparação dessa remessa. No caso de serem mais de um código, os códigos devem ser separados por vírgula. É importante destacar que, cada instância (1o grau, 2o grau) terá um conjunto de códigos permitidos na tarefa em questão. A [http://www.stf.jus.br/PORTAL/ATONORMATIVO/VERATONORMATIVO.ASP?DOCUMENTO=2198 Resolução 490/2012 do STF] regulamenta os códigos de tipos de documentos homologados pelo STF.
+
  
 +
<nowiki>#</nowiki>{tramitacaoProcessualService.gravaVariavelTarefa('pje:reclassificarDocumento:idsTipoDocumentoPermitidoAlterar','12,62,63,64')}
  
== Restringir código de tipo de documento para envio de remessa ao STJ ==
+
Esta expressão especifica os tipos de documentos que serão disponibilizados na tarefa de reclassificação de documentos. A expressão deve ser configurada em uma ação no evento "Criar tarefa" da tarefa de reclassificação. Na mesma tarefa, deve-se configurar a seguinte expressão em uma ação no evento "Ao sair do nó":
  
< esta configuração ainda será definida>
+
<nowiki>#</nowiki>{tramitacaoProcessualService.apagaVariavelTarefa('pje:reclassificarDocumento:idsTipoDocumentoPermitidoAlterar')}
  
  
== Definir remessa de manifestação processual para envio à instância superior ==
+
== Esconder botão gravar dos frames ==
  
<nowiki>#</nowiki>{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('remessaManifestacaoProcessual', processoHome.idProcessoDocumento)}
+
<nowiki>#</nowiki>{taskInstanceUtil.deleteVariableLocally('mostrarBotaoGravarNoFluxo')}
  
Configura para uso futuro no fluxo a variável remessaManifestacaoProcessual como sendo a remessa de manifestação processual.
+
Esta expressão especifica que não será exibido o botão "Gravar" na tela da tarefa configurada. Ela deve ser utilizada na criação de frames, em uma ação no evento "Criar tarefa".

Edição atual tal como às 11h19min de 24 de novembro de 2020

Esta seção se destina a explicitar algumas expressões (EL) que devem ser usadas na construção de fluxos do PJe para atender determinadas situações.

Conteúdo

[editar] Definir variável no fluxo

#{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('<nome da variável', <valor>)}

Configura para uso futuro no fluxo uma variável cujo nome seja <nome da variável> para conter o valor especificado pelo valor respectivo.

Exemplos:

#{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('pje:aguardaEstouroPrazo', 'true')}

#{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('pje:aguardaFecharExpediente', 'true')}

#{taskInstanceUtil.setVariable('ocultarAssinatura', 'true')}

[editar] Definir minuta em elaboração

#{org.jboss.seam.bpm.processInstance.contextInstance.setVariable('minutaEmElaboracao', processoHome.idProcessoDocumento)}

Configura para uso futuro no fluxo a variável minutaEmElaboração como sendo o documento em manutenção.

[editar] Restringir tipos de documentos disponíveis

#{taskInstanceUtil.setVariable('tiposDisponiveisIds','60,69,65,71')}


Restringe os tipos de documentos disponíveis para utilização no fluxo aos tipos passados como parâmetro, desde que estejam definidos na instalação e estejam ativos. Para que a restrição não mais ocorra no fluxo, deve-se apagar a variável.

Deve ser utilizada, por exemplo, ao criar expedientes, para limitar os tipos de documentos que poderão ser utilizados na construção do expediente.

[editar] Excluir variável

#{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('pje:aguardaEstouroPrazo')}

Exclui a variável criada anteriormente (evento)

#{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('pje:aguardaCiencia')}

Exclui a variável criada anteriormente (evento)

#{processInstance.getContextInstance().deleteVariable('minutaEmElaboracao')}

Exclui a variável criada anteriormente (evento)

[editar] Apagar agrupamentos

#{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('AgrupamentosLancadosTemporariamente')}

Apaga possíveis agrupamentos lançados temporiamente anteriormente

[editar] Apagar movimentos

#{org.jboss.seam.bpm.processInstance.contextInstance.deleteVariable('MovimentosLancadosTemporariamente')}

Apaga possíveis movimentos lançados temporiamente anteriormente

[editar] Configurar lançador de movimentações

#{lancadorMovimentosService.setCondicaoLancamentoMovimentosTemporarioNoFluxo('#{true}')}

Essa expressão configura o lançador de movimentações como associado à tarefa sendo configurada. Ao setar o parâmetro para "false", o usuário está dizendo que o lançamento da movimentação não precisará ser confirmado em tarefa futura. O contrário diz que uma tarefa futura confirmará o movimento.

[editar] Vincular modelo à tarefa

#{modeloDocumento.set('<nome de tarefa>',<código(s) do(s) modelo(s) a ser(em) vinculado(s)>)}

Configura os modelos de documento passíveis de serem utilizados pela tarefa cujo nome é <nome da tarefa>. No caso de serem mais de um modelo, os códigos devem ser separados por vírgula.

Exemplos:

[editar] Restringir modelos do PAC

#{modeloDocumento.set('Processo_Fluxo_prepararExpediente',60,69,65,71)}

Configura os modelos de documento passíveis cujos códigos são 60, 69, 65 e 71 para serem utilizadas na tarefa do PAC de preparar expediente.

[editar] Restringir modelos da minuta

#{modeloDocumento.set('minuta_ato_judicial',85,86,75,76)}

Configura os modelos de documento passíveis cujos códigos são 60, 69, 65 e 71 para serem utilizadas na tarefa do PAJ de minutar.

[editar] Verificação de audiências marcadas

#{processoTrfHome.instance.processoAudienciaList.size() > 0 ? 'Verificar providência a adotar' : 'Escolher providência inicial'}

Verifica se houve audiências marcadas e encaminha o fluxo para as tarefas "Verificar providência a adota" ou "Escolher providência inicial", conforme existência de audiência ou não, respectivamente.


[editar] Remover a exibição do botão GRAVAR na tarefa

No evento de criar tarefa crie a variável 'mostrarBotaoGravarNoFluxo', com o valor 'false'.

#{taskInstanceUtil.setVariable('mostrarBotaoGravarNoFluxo','false')}


[editar] Transição de saída padrão

#{taskInstanceUtil.setFrameDefaultTransition(' <nome da transição de saída padrão> ')}

Vinculação da transição de saída padrão da tarefa

Adicione sempre no evento Criar Tarefa

Exemplos:

[editar] Transição de saída padrão

#{taskInstanceUtil.setFrameDefaultTransition('Término')}

Na tarefa em que é utilizada, a transição de saída padrão passar a ser Término.

[editar] Transição de saída padrão da revisão

#{taskInstanceUtil.setFrameDefaultTransition('Confirmar movimentação')}

Na tarefa de revisão da minuta (Confirmar ato), a transição de saída padrão passar a ser Confirmar movimentação.

[editar] Atos de comunicação em aberto

#{atoComunicacaoService.getAtosComunicacaoAbertos(processoJudicialService.findById(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo'))) != 0}

Verifica existência de atos de comunicação em aberto

#{atoComunicacaoService.getAtosComunicacaoAbertos(processoJudicialService.findById(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo'))) == 0 ? 'Prazos vencidos' : 'Aguardando término dos prazos'}

Verifica se há atos de comunicação em aberto (nó de decisão)


[editar] Verificação de movimentos

#{processoTrfHome.existeMovimentoLancadoPorIdEvento(848)}

Verifica se há movimento lançado com aquele identificador

#{verificaEventoAction.verificarEventos(19, 28)}

Verifica se existem aqueles movimentos no processo

[editar] Existência de sentença líquida

#{resultadoSentencaService.isPossuiSentencaLiquida()}

Verifica se há sentença líquida lançada no processo

[editar] Quantidade de postos avançados

#{postoAvancadoAction.numeroDePostosDoOrgaoJulgador() > 0}

Verifica se o OJ possui posto avançado

#{postoAvancadoAction.numeroDePostosDoOrgaoJulgador() == 1 ? 'Encaminhar posto avançado' : 'Escolher posto avançado' }

Verfica a quantidade de postos avançados do OJ (nó de decisão)

[editar] Verificação de documento de magistrado assinado

#{!resultadoSentencaService.isUltimoSentencaDecisaoDespachoAssinado()}

Verifica se a última sentença, despacho ou decisão está assinada

[editar] Verificação de último documento do processo assinado

#{processoDocumentoHome.isUltimoDocumentoAssinado()}

Verifica se último documento do processo está assinado

[editar] Verificação de audiências

#{processoAudienciaHome.existeAudienciaPendenteProcesso()}

Verifica se há audiência pendente de ser realizada no processo

#{processoAudienciaHome.existeAudienciaPendenteProcesso() ? 'Operações da Audiência' : 'Designar Audiência'}

Verifica se há audiência pendente de ser realizada no processo (nó de decisão)

[editar] Recupera o posto avançado

#{processoTrfHome.instance.orgaoJulgador.postoAvancado}

Obtém o posto avançado do órgão julgador

[editar] Existência de carta precatória

#{comunicacaoProcessualAction.getExpedientesPrecatorias().size() > 0 ? 'Encaminhar Carta' : 'JoinComunicacao'}

Verifica se há expedientes do tipo carta precatória (nó de decisão)

[editar] Sentença

#{org.jboss.seam.bpm.processInstance.contextInstance.getVariable('tipoSentenca') == 'true' ? 'Partes cientes?' : 'Controle de prazos diversos'}

Verifica se a variável criada “tiposentenca” está setada para true (nó de decisão)

[editar] Expedientes para o diário

#{comunicacaoProcessualAction.getExpedientesDiario().size() > 0 ? 'Publicar DJE' : 'JoinComunicacao'}

Verifica se há expedientes enviados para o diário (nó de decisão)

[editar] Órgão público

#{processoJudicialService.findById(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo')).haParteOrgaoPublico() ? 'Reexame necessário' : 'Registrar trânsito em julgado'}

Utilizado para verificar se há partes no processo do tipo órgão público

[editar] Expediente carta

#{comunicacaoProcessualAction.getExpedientesPrecatorias().size() > 0 ? 'Encaminhar carta' : 'JoinComunicacao'}

Verifica se há expedientes do tipo Carta

[editar] Expedientes para os correios

#{comunicacaoProcessualAction.getExpedientesCorreios().size() > 0 ? 'Imprimir Correspondência' : 'JoinComunicacao'}

Verifica se há expedientes do tipo Correios (nó de decisão)

[editar] Expediente edital

#{comunicacaoProcessualAction.getExpedientesEdital().size() > 0 ? 'Encaminhar Edital' : 'JoinComunicacao'}

Verifica se há expedientes do tipo edital (nó de decisão)

[editar] Expediente telefone

#{comunicacaoProcessualAction.getExpedientesTelefone().size() > 0 ? 'Registrar ciência' : 'JoinComunicacao'}

Verifica se há expedientes do tipo telefone (nó de decisão)

[editar] Expediente pessoal

#{comunicacaoProcessualAction.getExpedientesPessoal().size() > 0 ? 'Registrar ciência' : 'JoinComunicacao'}

Verifica se há expedientes do tipo pessoal (nó de decisão)

[editar] Nó de decisão para expediente pessoal/por telefone ou para expediente DJE

#{comunicacaoProcessualAction.getExpedientesTelefone().size() > 0 or comunicacaoProcessualAction.getExpedientesPessoal().size() > 0 ? 'Registrar ciência' : 'Publicar DJE'}

Verifica se o expediente é pessoal ou por telefone para envio para registro de ciência. Caso contrário, assume que o expediente é para o diário e envia para publicação.

[editar] Verificação de assunto do processo

#{competenciaClasseAssuntoHome.processoContemClasseAssunto('40;1116;991;992;993;990;261:55292') ? 'Iniciar Execução' : 'Verificar Valor'}

Verifica se há assunto cadastrado para processo (nó de decisão)

[editar] Documentos não apreciados

#{documentoJudicialService.haDocumentoNaoApreciado(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ,62,23) ? 'Embargos de Declaração' : 'Aguardando prazo - recurso'}

#{documentoJudicialService.haDocumentoNaoApreciado(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ,62,47,5,42) ? 'Analisar manifestação' : 'Há órgão público?'}

Verifica se há documento não apreciado (nó de decisão)

[editar] Verifica urgência ou sigilo

#{processoTrfHome.isEmPedidoSegredoJustica() or processoTrfHome.isEmPedidoUrgencia ? 'Apreciar Urgentes' : 'Triagem Inicial'}

Verifica se há pedido de urgência ou segredo de justiça (nó de decisão)

[editar] Expediente para central

#{comunicacaoProcessualAction.getExpedientesMandados().size() > 0 ? 'Tem uma Central?' : 'JoinComunicacao'}

Verifica se há expedientes do tipo mandado ou ofício (nó de decisão)

[editar] Expediente após sentença

#{processoExpedienteManager.existeExpedienteAposUltimaSentenca(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo')) ? 'Aguardando ciência' : 'Aguardando prazo - ED'}

Verifica se há expedientes após última sentença do processo (nó de decisão)

[editar] Expedientes sem ciência

#{processoParteExpedienteManager.todosTomaramCiencia(org.jboss.seam.bpm.processInstance.contextInstance.getVariable('processo') ) ? 'Aguardando prazo - ED' : 'Aguardando ciência'}

Verifica se todos os destinatários já tomaram ciência (nó de decisão)

[editar] Verificação de faixa de valores

#{processoTrfHome.isViolacaoFaixaValores() ? 'Valor Incompatível' : 'Verificar Urgência'}

Verifica se há violação de faixa de valores no processo (nó de decisão)

[editar] Verificação de expedientes eletrônicos

#{comunicacaoProcessualAction.getExpedientesEletronico().size() > 0 ? 'Encaminhar Via Sistema' : 'JoinComunicacao'}

Verifica se há expedientes do tipo eletrônico (nó de decisão)

[editar] Centrais de mandado

#{conectorMandados.haVariasCentraisMandado() ? 'Selecionar central de mandados' : 'Encaminhar central de mandados'}

Verifica se há mais de uma central de mandado vinculado ao OJ (nó de decisão)

[editar] Verificação de execução ou liquidação

#{(processoTrfHome.isProcessoExecucao() )?'Iniciar Execução':(processoTrfHome.isProcessoLiquidacao() ? 'Iniciar Liquidação' : 'Verificar Valor')}

Verifica se é processo de execução ou é processo de liquidação (nó de decisão)

[editar] Tipos de documentos na tarefa

#{tipoDocumento.set('textEditSecretariaJT',63,62)}

Setar tipos de documentos que podem ser utilizados na tarefa (evento)

[editar] Restringir tipos de documento da revisão de minuta

#{tipoDocumento.set('Processo_Fluxo_revisarMinuta',62,63,64)}

Na tarefa "confirmar ato" (variável "Processo_Fluxo_revisarMinuta" do tipo "Frame") deve-se utilizar a EL para restrição dos tipos de documentos. Nesse exemplo, o primeiro parâmetro do método corresponde ao nome da variável definido no fluxo, os seguintes são os identificadores (ids) dos tipos de documentos que devem ser disponibilizados.

[editar] Registro automático de movimentos

#{preencherMovimento.deCodigo(51).comComplementoDeCodigo(3).doTipoDominio().preencherComElementoDeCodigo(36).lancarMovimento()}

Registrar movimento automaticamente (evento)

#{preencherMovimento.deCodigo(123).comComplementoDeCodigo(7).doTipoDominio().preencherComElementoDeCodigo(7051).comComplementoDeCodigo(18).doTipoDominio().preencherComElementoDeCodigo(38).lancarMovimento()}

Registrar movimento automaticamente (evento)

#{preencherMovimento.deCodigo(848).lancarMovimento()}

Registrar movimento automaticamente (evento)

[editar] Movimentos com complemento do tipo identificador

#{preencherMovimento.deCodigo(135).comProximoComplementoVazio().preencherComTexto(processoTrfHome.instance.numeroProcesso).lancarMovimento()}

Registrar com movimento com código 135 com complemento utilizando o número do processo

[editar] Movimentos com complemento do tipo livre

#{preencherMovimento.deCodigo(10966).comComplementoDeCodigo(<CODIGO_DO_TIPO_DE_COMPLEMENTO_CRIADO>).doTipoLivre(). preencherComTexto(processoHistoricoClasseHome.instance.classeJudicialAnterior).comComplementoDeCodigo(<CODIGO_DO_TIPO_DE_COMPLEMENTO_CRIADO>). doTipoLivre().preencherComTexto(processoHistoricoClasseHome.instance.classeJudicialAtual).lancarMovimento()}

Registrar movimento do tipo 10966 com dois complementos do tipo livre, a classe judicial anterior do processo e a classe judicial atual. Para utilização dessa EL, deve ser criado um complemento de nome "tipo", do tipo livre. O código utilizado na criação deve ser inserido na EL em lugar do campo <CODIGO_DO_TIPO_DE_COMPLEMENTO_CRIADO>.


[editar] Movimento de mudança de classe

#{preencherMovimento.deCodigo(10966).comComplementoDeNome('classeAnterior').preencherComTexto(classeAntiga).comComplementoDeNome('classeAtual').preencherComTexto(classeNova).lancarMovimento()}


Registrar movimento do tipo 10966, o sistema deve lançar a movimentação, que possui o formato: Classe Processual alterada de #{classeAnterior} para #{classeNova}.

Para essa EL funcionar, devem ter sido configurados os seguintes valores no sistema:

[editar] Exclusão de movimento

#{lancadorMovimentosService.excluirUltimoMovimento('51')}

Excluir o último registro do movimento processual (evento)

[editar] Exclusão de movimentos temporários

#{lancadorMovimentosService.apagarMovimentosTemporarios()}

Exclui movimentos serializados (evento)

[editar] Encaminhamento para posto avançado

#{postoAvancadoAction.encaminharParaPostoAvancado()}

Remete o processo para o posto avançado cadastrado para o OJ (evento)

[editar] Retorno do posto avançado para o órgão julgador

#{postoAvancadoAction.retornarParaOrgaoJulgador()}

Executa o método que efetiva o retorno do processo para o OJ principal do posto avançado

[editar] Meios de comunicação possíveis

#{preparaAtoComunicacaoAction.setMeiosComunicacao('P,E,C,M,L')}

Setar os meios de comunicação possíveis de uso no preparar ato de comunicação (evento)

#{preparaAtoComunicacaoAction.setMeiosComunicacao('P,D,E,C,M,L')}

Setar os meios de comunicação possíveis de uso no preparar ato de comunicação (evento)

#{preparaAtoComunicacaoAction.setMeiosComunicacao('P,E,C,L,M,T,S')}

Setar os meios de comunicação possíveis de uso no preparar ato de comunicação.

[editar] Habilitar homologação da sentença

#{resultadoSentencaService.homologarResultadoSentenca()}

Habilitar o botão para homologação de sentenca (evento)

[editar] Exclusão de resultado não homologado

#{resultadoSentencaService.excluirResultadoSentencaNaoHomologado()}

Exclui o registro de resultado de sentença (evento)

[editar] Registrar ciência

#{comunicacaoProcessualAction.registrarCienciaExpedientePessoal()}

Registra a ciência do expediente feito na própria secretaria (por telefone ou pessoalmente)

[editar] Envio de expediente e registro de movimento

Expressões utilizadas para envio de expedientes e concomitante registro de movimento associado ao envio, ou seja, movimento de código 60 - Expedição de documento.

[editar] Envio de expediente do tipo aviso de recebimento

#{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('C', 'processoExpedienteAtual', '#{preencherMovimento.deCodigo(60).associarAoDocumento(processoExpedienteAtual.getProcessoDocumento()). comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>).doTipoDominio(). preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_aviso_de_recebimento>).lancarMovimento()} ')}

Envia o expediente Correios e registra o movimento processual de forma automatizada (evento)

[editar] Envio de expediente do tipo mandado

#{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('M', 'processoExpedienteAtual', '#{preencherMovimento.deCodigo(60).associarAoDocumento(processoExpedienteAtual.getProcessoDocumento()). comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>).doTipoDominio(). preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_mandado>).lancarMovimento()} ')}

Envia o expediente do tipo mandado e registra o movimento processual de forma automatizada (evento)

[editar] Envio de expediente do tipo eletrônico

#{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('E', 'processoExpedienteAtual', '#{preencherMovimento.deCodigo(60).associarAoDocumento(processoExpedienteAtual.getProcessoDocumento()). comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>). doTipoDominio().preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_outros_documentos>).lancarMovimento()}')}

Envia o expediente eletrônico e registra o movimento processual de forma automatizada (evento)

[editar] Envio de expediente

#{comunicacaoProcessualAction.enviarExpedientesLancarMovimentos('P', 'processoExpedienteAtual', '')}

Envia o expediente utilizando o conector com o diário de justiça eletrônico, se existir.

[editar] Preencher movimento de expedição de documento

#{preencherMovimento.deCodigo(60).comComplementoDeCodigo(<CÓDIGO_DO_TIPO_DE_COMPLEMENTO_DO_TIPO_DOMÍNIO_PARA_tipo_de_documento>).doTipoDominio(). preencherComElementoDeCodigo(<CÓDIGO_DO_ELEMENTO_DE_DOMÍNIO_PARA_outros_documentos>).associarAoDocumentoDeId(processoHome.idProcessoDocumento). lancarMovimento()}

Preenche o movimento de "Expedição de outros documentos", utilizado em expedientes para o diário de justiça eletrônico, por telefone e pessoais.


[editar] Lista de documentos

Quando o processo é físico, o advogado autor apresenta DUAS cópias da petição inicial. Uma delas será encaminhada conjuntamente com a intimação inicial ao Reclamado. No processo eletrônico esse custo (milhares de processos x milhares de folhas) será da Justiça do Trabalho que tem de imprimir a inicial para encaminhar a notificação ao(s) reclamado(s). O TRT13, dentre outros, solucionou o problema colocando códigos de acesso aos documentos no corpo da notificação, de forma que o reclamado é instruído a acessar o documento e fazer o download. Manda-se apenas uma única folha. Inclusive o formato, preparado para dobrar em tres partes onde a 1a parte exposta contém o endereço do destinatário. Anexo envio exemplo.

Criar variável com lista de documentos (códigos de acesso) para compor Notificação Inicial e assim não ter que imprimir a petição inicial para envio via correio

#{processoTrfHome.tabelaHashDocumentos}


[editar] Verificar se o processo chegou via MNI

#{intercomunicacaoService.processoAutuadoViaMNI(processoTrfHome.instance)}

Retorna verdadeiro se o processo chegou via MNI.

[editar] Definir um procedimento manual que deve ser feito pela instância de primeiro grau quando a instância de segundo grau devolve um processo que não foi remetido via MNI

No fluxo, após a atividade que devolve o processo para o primeiro grau, incluir um nó de decisão com a expressão abaixo:

#{intercomunicacaoService.processoAutuadoViaMNI(processoTrfHome.instance)?'Recebimento do processo':'Fim'}

onde: 'Recebimento do processo' corresponde ao nome da tarefa que será executada pela instância de primeiro grau depois que a instância de segundo grau devolver o processo. Esta atividade só será executada se o processo devolvido não tiver chegado no segundo grau via MNI. 'Fim' corresponde ao nó de término.

Assim, se o processo foi remetido para o segundo grau sem usar MNI, quando o segundo grau devolver o processo para o primeiro grau, o primeiro grau terá que executar a atividade 'Recebimento do processo'. Mas quando o processo foi remetido para o segundo grau por meio do MNI, quando o segundo grau devolver o processo para o primeiro grau, nenhuma intervenção manual será necessária.

[editar] Deslocamento de processo para a presidência

Para realizar o deslocamento de um processo para a presidência no PJe, é necessário, como pré-condição, que se obtenha, no banco de dados, os identificadores do colegiado a que a presidência está vinculada, do próprio órgão presidência e do órgão julgador cargo (cargo judicial concreto) da presidência.
Após, devem ser criados dois nós de sistema, um para a ida, e outro para a volta. No meio, devem ser colocadas as atividades da presidência.
Eis a descrição ideal dos nós de ida e de volta:

  • 4 eventos na ida em nó de sistema. Os três primeiros, ao entrar no nó, para gravação do juízo de origem
<<<<<<< Nó de ida >>>>>>>>>>>>
-> tramitacaoProcessualService.gravaVariavel("pje:fluxo:identificador:orgaoOrigem", processoTrfHome.instance.orgaoJulgador.idOrgaoJulgador)
-> tramitacaoProcessualService.gravaVariavel("pje:fluxo:identificador:colegiadoOrigem",  
processoTrfHome.instance.orgaoJulgadorColegiado.idOrgaoJulgadorColegiado)
-> tramitacaoProcessualService.gravaVariavel("pje:fluxo:identificador:cargoOrigem",
processoTrfHome.instance.orgaoJulgadorCargo.idOrgaoJulgadorCargo)
Ao sair do nó de sistema
#{processoJudicialService.deslocarOrgaoJulgador(processoTrfHome.instance, 2 (id órgão presidência), 1 (id órgão julgador colegiado), 
18 (id do orgao julgador  cargo presidência)}
<<<<<<< Fim do nó de ida >>>>>>>>>>>>
  • Volta
<<<<<<< Nó de volta >>>>>>>>>>>>
Ao entrar no nó:
#{processoJudicialService.deslocarOrgaoJulgador(processoTrfHome.instance, 
tramitacaoProcessualService.recuperaVariavel("pje:fluxo:identificador:orgaoOrigem"),  
tramitacaoProcessualService.recuperaVariavel("pje:fluxo:identificador:colegiadoOrigem"), 
tramitacaoProcessualService.recuperaVariavel("pje:fluxo:identificador:cargoOrigem")}
Ao sair do nó
-> tramitacaoProcessualService.apagaVariavel("pje:fluxo:identificador:orgaoOrigem")
-> tramitacaoProcessualService.apagaVariavel("pje:fluxo:identificador:colegiadoOrigem")
-> tramitacaoProcessualService.apagaVariavel("pje:fluxo:identificador:cargoOrigem")
<<<<<<< Fim do nó de volta >>>>>>>>>>>>

[editar] Acesso a sistemas externos por meio de tarefas de fluxo

#{tramitacaoProcessualService.gravaVariavelTarefa('pje:flx:paginaExterna', 'URL_DO_SISTEMA_EXTERNO')}

Frame que permite o acesso a sistemas externos por meio de tarefas de fluxo. Exemplos de sistemas que poderiam ser acessados: Bacenjud, Renajud, Banco Nacional de Bens Apreendidos e eventuais sistemas de controle de precatórios.

[editar] Supressão de visualizadores em processos sigilosos

#{processoVisibilidadeSegredoManager.limpaRegistros(processo)}

Limpa a lista de visualizadores de um determinado processo.

[editar] Enviar intimação para Ministério Público

#{atoComunicacaoService.intimarDestinatarioEletronicamente(tramitacaoProcessualService.recuperaProcesso().idProcessoTrf, <idPessoaMP>, '<tipoprazo>',<qtd_prazo>,<cod_modelo>,<cod_tipo>)}

Expressão a ser inserida no evento "Ao entrar no nó" de um nó de sistema para realizar a intimação automática do ministério público. Para isso, seguem os significados dos parâmetros:

  • <idPessoaMP> - deve ser substituído pela id da pessoa ao qual está vinculado o Ministério Público
  • <tipoprazo> - deve ser substituído pelo Tipo de prazo correspondente, conforme opções disponíveis na regra de domínio RD96. Por exemplo, D.
  • <qtd_prazo> - é a quantidade a ser associado ao tipo de prazo. Por exemplo, se esse valor for 5 e o valor do parâmetro anterior for 'D', o prazo de resposta da intimação são cinco dias
  • <cod_modelo> - código do modelo de documento a ser utilizado pela intimação
  • <cod_tipo> - código do tipo de documento a ser utilizado pela intimação


#{atoComunicacaoService.intimarDestinatarioEletronicamente(tramitacaoProcessualService.recuperaProcesso().idProcessoTrf, <idPessoaMP>, '<tipoprazo>',<qtd_prazo>,<cod_doc>)}

Expressão a ser inserida no evento "Ao entrar no nó" de um nó de tarefa para realizar a intimação automática do ministério público. Para isso, seguem os significados dos parâmetros:

  • <idPessoaMP> - deve ser substituído pela id da pessoa ao qual está vinculado o Ministério Público
  • <tipoprazo> - deve ser substituído pelo Tipo de prazo correspondente, conforme opções disponíveis na regra de domínio RD96. Por exemplo, D.
  • <qtd_prazo> - é a quantidade a ser associado ao tipo de prazo. Por exemplo, se esse valor for 5 e o valor do parâmetro anterior for 'D', o prazo de resposta da intimação são cinco dias
  • <cod_doc> - código do documento a ser utilizado pela intimação

[editar] Registrar inclusão em pauta

#{processoJudicialManager.aptidaoParaJulgamento(processoTrfHome.instance.idProcessoTrf, true)}

Expressão utilizada para que um processo esteja marcado como selecionado para pauta, via de regra utilizada em um nó de sistema

[editar] Criar um nó de decisão baseado na classe judicial do processo

#{processoTrfHome.instance.classeJudicial.codClasseJudicial == 'códigoClasse'  ? 'transiçãoSeVerdadeiro' : 'transiçãoSeFalso'}

Expressão utilizada para criar um nó de decisão baseado na classe judicial do processo


[editar] Identificar os meios de comunicação sem ciência registrada

#{taskInstanceUtil.setVariable('pje:fluxo:registrociencia:meios','P,T')}

Expressão utilizada para identificar quais os meios de comunicação/expedição sem ciência registrada que poderão ter ciência manipulada na tarefa Registro manual de ciência de expedientes.

A sequência de valores do parâmetro pje:fluxo:registrociencia:meios implica na sequência de meios de comunicação desejados de acordo com a lista de meios de comunicação permitidos para a tarefa em questão:

  • P("Diário Eletrônico");
  • L("Carta") - exemplos: carta rogatória, de ordem ou precatória;
  • D("Edital");
  • N("Comunicação");
  • S("Pessoalmente");
  • T("Telefone").


[editar] Transição de desistência

#{tramitacaoProcessualService.gravaVariavelTarefa('pje:fluxo:transicao:dispensaRequeridos','Nome da transição que dispensa os campos')}

Expressão utilizada na configuração de evento em nó de tarefa para caracterizar transição de desistência, ou seja, transição que não validará campos da tela.

[editar] Registrar situação processual

#{tramitacaoProcessualService.acrescentarSituacao('codigo_da_situacao')}

Expressão a ser utilizada na configuração de evento para registrar uma determinada situação no processo. A situação deve ter sido previamente configurada.

As situações do processo são exibidas, de acordo com permissão adequada, no detalhamento do processo.

[editar] Encerrar situação processual

#{tramitacaoProcessualService.removerSituacao('codigo_da_situacao')}

Expressão a ser utilizada na configuração de evento para remover uma determinada situação do processo já registrada anteriormente.

As situações do processo são exibidas, de acordo com permissão adequada, no detalhamento do processo.


[editar] Verificar situação processual

#{tramitacaoProcessualService.temSituacao('<nome da situação>')}

Expressão a ser utilizada para verificar se o processo tem determinada situação processual ainda não encerrada.

As situações do processo são exibidas, de acordo com permissão adequada, no detalhamento do processo.

[editar] Recuperar id do órgão julgador do processo

#{processoTrfHome.instance.orgaoJulgador.idOrgaoJulgador}

Expressão a ser utilizada para recuperar o id do órgão julgador do processo. A expressão pode ser utilizada, por exemplo, na verificação de condição em uma transição. Se uma determinada transição só deve estar disponível para processos distribuídos para determinado órgão julgador, pode-se utilizar a o registro de condição na configuração da transição da seguinte forma:

#{processoTrfHome.instance.orgaoJulgador.idOrgaoJulgador == 3}

Da mesma forma, pode-se restringir a transição à processos que não sejam de determinado órgão julgado:

#{processoTrfHome.instance.orgaoJulgador.idOrgaoJulgador != 3}


[editar] Recuperar o nome da pessoa

#{processoParte.pessoa.inTipoPessoa eq 'J' ? pessoaJuridicaManager.findById(parteSelecionada.pessoa.idPessoa).nomeFantasia : parteSelecionada.getNomeParte()}

Expressão que retorna o nome da pessoa física ou o nome fantasia da pessoa jurídica parte do processo.

[editar] Verificar papel do usuário

#{org.jboss.seam.security.identity.hasRole('<identificador do papel>')}

Expressão verifica se o usuário tem o papel passado como parâmetro. Por exemplo:

#{org.jboss.seam.security.identity.hasRole('cnj:chefesetor')}

[editar] Recuperar classe judicial do processo

#{tramitacaoProcessualService.recuperaProcesso().classeJudicial.codClasseJudicial}

Expressão recupera a classe judicial do processo. A expressão pode ser utilizada, por exemplo, na verificação de condição em uma transição. Se uma determinada transição só deve estar disponível para processos de determinada classe judicial, pode-se utilizar a o registro de condição na configuração da transição da seguinte forma:

#{tramitacaoProcessualService.recuperaProcesso().classeJudicial.codClasseJudicial == '11888'}

[editar] Definir variável

Há dois tipos de variável que podem ser criadas, variáveis de fluxo e variáveis de tarefa. - Variáveis de fluxo são variáveis que quando criadas em alguma tarefa do fluxo, continuam disponíveis para uso em qualquer tarefa do fluxo até que sejam apagadas. - Variáveis de fluxo são variáveis cujo contexto de utilização é apenas para a tarefa na qual foram criadas, desta forma, mesmo que não tenham sido apagadas durante o andamento do fluxo, estas variáveis não estarão disponíveis de uma tarefa para outra.

[editar] Definição de variáveis de fluxo

#{tramitacaoProcessualService.gravaVariavel('<nome da variável', <valor>)}

[editar] Definição de variáveis de tarefa

#{tramitacaoProcessualService.gravaVariavelTarefa('<nome da variável>', '<valor>')}

Similarmente à definição já descrita no início dessa página (aqui), define um valor para uma variável a fim de recuperá-lo posteriormente.

[editar] Recuperar variável definida anteriormente

#{tramitacaoProcessualService.recuperaVariavel('<nome da variável')}

Similarmente à recuperação já descrita com o uso de getVariable, recupera o valor de uma variável definida anteriormente. Caso não tenha sido definida, o valor retornará vazio.

A expressão pode ser utilizada, por exemplo, na definição de um nó de decisão. Pode-se optar por uma transição caso não tenha sido definida uma variável ou não tenha sido definida com o valor "true" e por outra transição caso a situação seja diferente dessa. Segue o exemplo:

#{empty tramitacaoProcessualService.recuperaVariavel('cnj:fluxo:determinacaoPrevia') or not tramitacaoProcessualService.recuperaVariavel('cnj:fluxo:determinacaoPrevia') ? 'Decisão inicial' : 'Cumprir determinação'}


Pode-se utilizar um campo do tipo "Aviso" para exibir o conteúdo de uma variável de fluxo, para isso deve-se dar um nome de variável qualquer (diferente do nome da variável que se quer exibir o conteúdo) e no campo "Label" a expresão: #{tramitacaoProcessualService.recuperaVariavel('<nome da variável')} e o campo Escrita deve estar marcado.

  • se o valor da variável for um campo datetime deve-se utilizá-la separadamente de qualquer outro texto no campo do tipo aviso, desta forma o sistema exibirá na seguinte formatação: DD/MM/AAAA, pois se este tipo de variável estiver no meio de um texto o sistema não fará esta formatação, exibindo o texto da seguinte forma: NONONONONO AAAA-MM-DD 00:00:00.

[editar] Apagar variável

#{tramitacaoProcessualService.apagaVariavel('cnj:fluxo:determinacaoPrevia')}

Similarmente à remoção já descrita anteriormente (aqui), apaga a variável definida anteriormente.

[editar] Verificar urgência

#{tramitacaoProcessualService.temUrgencia()}

Verifica se foi registrado pedido de liminar ou de antecipação de tutela para o processo ainda não apreciado.


[editar] Verificar movimento de determinado grupo

#{tramitacaoProcessualService.temMovimento('<nome do grupo>')}

Verifica se houve registro no processo de algum movimento do grupo fornecido como parâmetro.


[editar] Verificar movimento de determinado grupo até determinada data

Em construção

#{tramitacaoProcessualService.temMovimentoDoGrupo('<nome do grupo>', tramitacaoProcessualService.recuperaVariavel(<variaveldatadefinidaanteriormente>))}

Verifica se houve, até a data fornecida como parâmetro, registro no processo de algum movimento do grupo fornecido como parâmetro. Deve-se observar que a data passada como parâmetro pode vir na forma de uma variável do tipo "java.util.Date". Entre outras opções, para se obter uma data nesse formato, pode-se utilizar a seguinte função da biblioteca do PJe:

DateUtil.stringToDate(datatexto, formato)

Como exemplo, segue a chamada da EL utilizando a data formatada:

#{tramitacaoProcessualService.temMovimentoDoGrupo('Julgamento', DateUtil.stringToDate('2014-03-14', 'yyyy-MM-dd') )}


Pode-se, por exemplo, utilizar a verificação em um nó de decisão conforme exemplo de expressão abaixo:

#{tramitacaoProcessualService.temMovimentoDoGrupo('Julgamento', tramitacaoProcessualService.recuperaVariavel('pje:julgado:data')) ? 'Comunicar de decisão terminativa' : 'Cumprir decisão em pedido urgente'}

[editar] Recuperar ano do processo

#{tramitacaoProcessualService.recuperaProcesso().ano}

Recupera o campo ano de distribuição do processo. O ano está presente no número do processo conforme valor de xxxx da máscara abaixo:

nnnnnnn-nn.xxxx.n.nn.nnnn

[editar] Recuperar número sequencial do processo

#{tramitacaoProcessualService.recuperaProcesso().numeroSequencia}

Recupera o campo sequencial do número do processo, ou seja, o valor de xxxxxxx da máscara abaixo:

xxxxxxx-nn.nnnn.n.nn.nnnn


[editar] Comparar assunto

#{tramitacaoProcessualService.temAssunto(codigoAssunto)}

Verifica se o processo judicial atual tem, entre seus assuntos ativos, aquele cujo código é o passado como parâmetro.

[editar] Verificar assunto conforme agrupamento

#{tramitacaoProcessualService.temAssuntoDoGrupo(codigoAgrupamento)}

Verifica se o processo tem, entre seus assuntos, algum dos assuntos contidos no agrupamento passado como parâmetro.

[editar] Atribuir segredo de justiça

#{tramitacaoProcessualService.recuperaProcesso().setSegredoJustica(true)}

Atribui segredo de justiça ao processo. Via de regra, será utilizada ao distribuir o processo caso seja verificado que o processo tem a ele associado determinados assuntos (verificação através de expressões temAssunto e temAssuntoDoGrupo).

[editar] Verificar decisão pelo tipo de documento

#{processoDocumentoManager.findById(tramitacaoProcessualService.recuperaVariavel(“pje:atoProferido”)). tipoProcessoDocumento.idTipoProcessoDocumento == ID_TIPO_DOCUMENTO_DECISAO}

Verifica se há documento no processo que caracteriza uma decisão

[editar] Criar fluxo paralelo

#{processoJudicialService.incluirNovoFluxo(tramitacaoProcessualService.recuperaProcesso(), '<código do fluxo>')}

Inicia no processo o fluxo identificado pelo código passado como parâmetro. Abaixo, veja como fica a EL que inicia o fluxo de digitalização identificado pelo código FLXDIGIT:

#{processoJudicialService.incluirNovoFluxo(tramitacaoProcessualService.recuperaProcesso(), 'FLXDIGIT')}


[editar] Verificar magistrados vinculados

#{vinculacaoMagistradoAction.magistradosVinculados.size() > 0}

Verifica se há pelo menos um magistrado vinculado ao processo. Essa expressão é útil em instalações onde determinados processos podem ser atribuídos a magistrados que compõem o órgão julgador, mas que não estão caracterizados como titular do órgão. Essa vinculação pode ser realizada por meio da aba Processos da configuração do órgão julgador ou por meio de tarefa no fluxo.


[editar] Liberar documentos da sessão

#{sessaoProcessoDocumentoManager.liberarDocumentosSessao(processoTrfHome.instance, <ORGAO-JULGADOR>, <SESSÃO-JULGAMENTO>)}

Expressão utilizada para liberar os documentos (voto, relatório, ementa) de um dado processo, associados a um órgão julgador, para uma determinada sessão de julgamento.

Para liberar todos os documentos do relator de um processo, independentemente da sessão, utilize a EL assim: #{sessaoProcessoDocumentoManager.liberarDocumentosSessao(processoTrfHome.instance, processoTrfHome.instance.orgaoJulgador, null)}

Para liberar todos os documentos não só do relator, mas inclusive dos demais vogais, independentemente da sessão, utilize a EL assim: #{sessaoProcessoDocumentoManager.liberarDocumentosSessao(processoTrfHome.instance, null, null)}


[editar] Verificação se o relatório está assinado

#{votacaoColegiadoAction.relatorioAssinado}

Esta expressão verifica se o relatório do processo está assinado, utiliza-se esta expressão para verificar se o fluxo pode ser encaminhado para a inclusão de pauta, visto que o relatório estar assinado é condição essencial (no CNJ) para solicitar a inclusão de um processo em pauta.


[editar] Restringir tipos de documentos na reclassificação

#{tramitacaoProcessualService.gravaVariavelTarefa('pje:reclassificarDocumento:idsTipoDocumentoProibidoAlterar','12,62,63,64')}

Esta expressão restringe os tipos de documentos que serão disponibilizados na tarefa de reclassificação de documentos. A expressão deve ser configurada em uma ação no evento "Criar tarefa" da tarefa de reclassificação. Na mesma tarefa, deve-se configurar a seguinte expressão em uma ação no evento "Ao sair do nó":

#{tramitacaoProcessualService.apagaVariavelTarefa('pje:reclassificarDocumento:idsTipoDocumentoProibidoAlterar')}

[editar] Especificar tipos de documentos na reclassificação

#{tramitacaoProcessualService.gravaVariavelTarefa('pje:reclassificarDocumento:idsTipoDocumentoPermitidoAlterar','12,62,63,64')}

Esta expressão especifica os tipos de documentos que serão disponibilizados na tarefa de reclassificação de documentos. A expressão deve ser configurada em uma ação no evento "Criar tarefa" da tarefa de reclassificação. Na mesma tarefa, deve-se configurar a seguinte expressão em uma ação no evento "Ao sair do nó":

#{tramitacaoProcessualService.apagaVariavelTarefa('pje:reclassificarDocumento:idsTipoDocumentoPermitidoAlterar')}


[editar] Esconder botão gravar dos frames

#{taskInstanceUtil.deleteVariableLocally('mostrarBotaoGravarNoFluxo')}

Esta expressão especifica que não será exibido o botão "Gravar" na tela da tarefa configurada. Ela deve ser utilizada na criação de frames, em uma ação no evento "Criar tarefa".

Ferramentas pessoais
Espaços nominais

Variantes
Ações
Navegação
Informações Gerais
Aplicativos PJe
Manuais
Suporte
Ferramentas