Download as
Browse Code »

Commit ff263bdae816b0c836ebffb95123a9cd4825325f

Authored by Guilherme Andrade Del Cantoni
1 parent 712be795
Exists in master and in 19 other branches Marcelotmpdesenv, Marctmp, desenv, feature-050, feature-50, feature-76, fix-101, fix-24, fix-43, fix-58, fix-86, fix-89, fix-92, fix-93, fix-95, fix-96, fix-97, fix-99, fix-gearman

[Fixed #22] Correção de erro de consistência no recebimento de processo com concorrência

Showing 10 changed files with 1007 additions and 945 deletions   Show diff stats
PENIntegracao.php
  Diff comments   View file @ff263bd
... ... @@ -11,7 +11,7 @@ class PENIntegracao extends SeiIntegracao {
11 11 }
12 12  
13 13 public function getVersao() {
14   - return '1.1.11';
  14 + return '1.1.12';
15 15 }
16 16  
17 17 public function getInstituicao() {
... ...
dto/ProcedimentoAndamentoDTO.php
  Diff comments   View file @ff263bd
... ... @@ -17,6 +17,7 @@ class ProcedimentoAndamentoDTO extends InfraDTO {
17 17  
18 18 $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_DBL, 'IdAndamento', 'id_andamento');
19 19 $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_DBL, 'IdProcedimento', 'id_procedimento');
  20 + $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_STR, 'NumeroRegistro', 'numero_registro');
20 21 $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_DBL, 'IdTramite', 'id_tramite');
21 22 $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_STR, 'Situacao', 'situacao');
22 23 $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_DTH, 'Data', 'data');
... ...
dto/TramiteDTO.php
  Diff comments   View file @ff263bd
... ... @@ -18,6 +18,7 @@ class TramiteDTO extends InfraDTO {
18 18 $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_NUM, 'IdEstruturaOrigem', 'id_estrutura_origem');
19 19 $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_NUM, 'IdRepositorioDestino', 'id_repositorio_destino');
20 20 $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_NUM, 'IdEstruturaDestino', 'id_estrutura_destino');
  21 + $this->adicionarAtributoTabela(InfraDTO::$PREFIXO_STR, 'StaTipoTramite', 'sta_tipo_tramite');
21 22  
22 23 $this->adicionarAtributo(InfraDTO::$PREFIXO_ARR, 'ObjComponenteDigitalDTO');
23 24  
... ...
rn/ExpedirProcedimentoRN.php
  Diff comments   View file @ff263bd
... ... @@ -167,17 +167,18 @@ class ExpedirProcedimentoRN extends InfraRN {
167 167 $this->atualizarPenProtocolo($dblIdProcedimento);
168 168 if (isset($novoTramite->dadosTramiteDeProcessoCriado)) {
169 169 $objTramite = $novoTramite->dadosTramiteDeProcessoCriado;
170   - $this->objProcedimentoAndamentoRN->setOpts($dblIdProcedimento, $objTramite->IDT, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_EXPEDIDO));
  170 + $this->objProcedimentoAndamentoRN->setOpts($objTramite->NRE, $objTramite->IDT, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_EXPEDIDO), $dblIdProcedimento);
171 171 try {
172 172  
173 173 $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Envio do metadados do processo', 'S'));
174 174 $idAtividadeExpedicao = $this->bloquearProcedimentoExpedicao($objExpedirProcedimentoDTO, $objProcesso->idProcedimentoSEI);
175 175  
  176 +
176 177 $this->objProcessoEletronicoRN->cadastrarTramiteDeProcesso(
177 178 $objProcesso->idProcedimentoSEI,
178 179 $objTramite->NRE,
179 180 $objTramite->IDT,
180   - //ProcessoEletronicoRN::STA_TIPO_TRAMITE_ENVIO,
  181 + ProcessoEletronicoRN::$STA_TIPO_TRAMITE_ENVIO,
181 182 $objTramite->dataHoraDeRegistroDoTramite,
182 183 $objExpedirProcedimentoDTO->getNumIdRepositorioOrigem(),
183 184 $objExpedirProcedimentoDTO->getNumIdUnidadeOrigem(),
... ...
rn/PenAtualizarSeiRN.php
  Diff comments   View file @ff263bd
... ... @@ -53,6 +53,7 @@ class PenAtualizarSeiRN extends PenAtualizadorRN {
53 53 case '1.1.8': $this->instalarV119();
54 54 case '1.1.9': $this->instalarV1110();
55 55 case '1.1.10': $this->instalarV1111();
  56 + case '1.1.11': $this->instalarV1112();
56 57  
57 58 break;
58 59 default:
... ... @@ -354,12 +355,10 @@ class PenAtualizarSeiRN extends PenAtualizadorRN {
354 355 $objInfraSequencia = new InfraSequencia($objInfraBanco);
355 356  
356 357 if (!$objInfraSequencia->verificarSequencia('md_pen_procedimento_andamento')) {
357   -
358 358 $objInfraSequencia->criarSequencia('md_pen_procedimento_andamento', '1', '1', '9999999999');
359 359 }
360 360  
361 361 if (!$objInfraSequencia->verificarSequencia('md_pen_tramite_pendente')) {
362   -
363 362 $objInfraSequencia->criarSequencia('md_pen_tramite_pendente', '1', '1', '9999999999');
364 363 }
365 364 //----------------------------------------------------------------------
... ... @@ -1200,4 +1199,48 @@ class PenAtualizarSeiRN extends PenAtualizadorRN {
1200 1199 $objInfraParametroBD->alterar($objInfraParametroDTO);
1201 1200 }
1202 1201  
  1202 +
  1203 + /* Contem atualizações da versao 1.1.12 do módulo */
  1204 + protected function instalarV1112() {
  1205 + $objInfraMetaBD = new InfraMetaBD($this->getObjInfraIBanco());
  1206 +
  1207 +
  1208 + //[#22] Correção de erro de consistência no recebimento de processos com concorrência
  1209 + $objInfraMetaBD->adicionarColuna('md_pen_tramite','sta_tipo_tramite', $objInfraMetaBD->tipoTextoFixo(1), 'null');
  1210 + $objInfraMetaBD->alterarColuna('md_pen_procedimento_andamento','id_procedimento',$objInfraMetaBD->tipoNumeroGrande(),'null');
  1211 + $objInfraMetaBD->adicionarColuna('md_pen_procedimento_andamento','numero_registro', $objInfraMetaBD->tipoTextoFixo(16), 'null');
  1212 +
  1213 + $objTramiteDTO = new TramiteDTO();
  1214 + $objTramiteDTO->retNumIdTramite();
  1215 + $objTramiteDTO->retStrNumeroRegistro();
  1216 +
  1217 + $objTramiteRN = new TramiteBD($this->inicializarObjInfraIBanco());
  1218 + $arrObjTramiteDTO = $objTramiteRN->listar($objTramiteDTO);
  1219 +
  1220 + foreach ($arrObjTramiteDTO as $objTramiteDTO) {
  1221 + $objProcedimentoAndamentoDTO = new ProcedimentoAndamentoDTO();
  1222 + $objProcedimentoAndamentoDTO->retDblIdAndamento();
  1223 + $objProcedimentoAndamentoDTO->retStrNumeroRegistro();
  1224 + $objProcedimentoAndamentoDTO->retDblIdTramite();
  1225 + $objProcedimentoAndamentoDTO->setDblIdTramite($objTramiteDTO->getNumIdTramite());
  1226 +
  1227 + $objProcedimentoAndamentoBD = new ProcedimentoAndamentoBD($this->getObjInfraIBanco());
  1228 + $arrObjProcedimentoAndamentoDTO = $objProcedimentoAndamentoBD->listar($objProcedimentoAndamentoDTO);
  1229 + foreach ($arrObjProcedimentoAndamentoDTO as $objProcedimentoAndamentoDTO) {
  1230 +
  1231 + $objProcedimentoAndamentoDTO->setStrNumeroRegistro($objTramiteDTO->getStrNumeroRegistro());
  1232 + $objProcedimentoAndamentoBD->alterar($objProcedimentoAndamentoDTO);
  1233 + }
  1234 + }
  1235 +
  1236 + $objInfraMetaBD->alterarColuna('md_pen_procedimento_andamento','numero_registro', $objInfraMetaBD->tipoTextoFixo(16), 'not null');
  1237 +
  1238 + //altera o parâmetro da versão de banco
  1239 + $objInfraParametroBD = new InfraParametroBD($this->inicializarObjInfraIBanco());
  1240 + $objInfraParametroDTO = new InfraParametroDTO();
  1241 + $objInfraParametroDTO->setStrNome(self::PARAMETRO_VERSAO_MODULO);
  1242 + $objInfraParametroDTO->setStrValor('1.1.12');
  1243 + $objInfraParametroBD->alterar($objInfraParametroDTO);
  1244 + }
  1245 +
1203 1246 }
... ...
rn/ProcedimentoAndamentoRN.php
  Diff comments   View file @ff263bd
... ... @@ -11,10 +11,9 @@ class ProcedimentoAndamentoRN extends InfraRN {
11 11  
12 12 protected $isSetOpts = false;
13 13 protected $dblIdProcedimento;
14   - protected $dblIdTramit;
  14 + protected $dblIdTramite;
15 15 protected $numTarefa;
16   -
17   -
  16 + protected $strNumeroRegistro;
18 17  
19 18 /**
20 19 * Invés de aproveitar o singleton do BancoSEI criamos uma nova instância para
... ... @@ -26,11 +25,11 @@ class ProcedimentoAndamentoRN extends InfraRN {
26 25 return BancoSEI::getInstance();
27 26 }
28 27  
29   -
30   - public function setOpts($dblIdProcedimento = 0, $dblIdTramit = 0, $numTarefa){
31   -
  28 + public function setOpts($strNumeroRegistro, $dblIdTramite, $numTarefa, $dblIdProcedimento=null)
  29 + {
  30 + $this->strNumeroRegistro = $strNumeroRegistro;
  31 + $this->dblIdTramite = $dblIdTramite;
32 32 $this->dblIdProcedimento = $dblIdProcedimento;
33   - $this->dblIdTramit = $dblIdTramit;
34 33 $this->numTarefa = $numTarefa;
35 34 $this->isSetOpts = true;
36 35 }
... ... @@ -54,12 +53,12 @@ class ProcedimentoAndamentoRN extends InfraRN {
54 53 $objProcedimentoAndamentoDTO->setStrSituacao($strSituacao);
55 54 $objProcedimentoAndamentoDTO->setDthData(date('d/m/Y H:i:s'));
56 55 $objProcedimentoAndamentoDTO->setDblIdProcedimento($this->dblIdProcedimento);
57   - $objProcedimentoAndamentoDTO->setDblIdTramite($this->dblIdTramit);
  56 + $objProcedimentoAndamentoDTO->setStrNumeroRegistro($this->strNumeroRegistro);
  57 + $objProcedimentoAndamentoDTO->setDblIdTramite($this->dblIdTramite);
58 58 $objProcedimentoAndamentoDTO->setStrSituacao($strSituacao);
59 59 $objProcedimentoAndamentoDTO->setStrMensagem($strMensagem);
60 60 $objProcedimentoAndamentoDTO->setStrHash($hash);
61 61 $objProcedimentoAndamentoDTO->setNumTarefa($this->numTarefa);
62   -
63 62 $objProcedimentoAndamentoBD = new ProcedimentoAndamentoBD($this->getObjInfraIBanco());
64 63 $objProcedimentoAndamentoBD->cadastrar($objProcedimentoAndamentoDTO);
65 64 }
... ...
rn/ProcessoEletronicoRN.php
  Diff comments   View file @ff263bd
... ... @@ -30,6 +30,10 @@ class ProcessoEletronicoRN extends InfraRN {
30 30 public static $STA_SITUACAO_TRAMITE_RECUSADO = 8; // Trâmite do processo recusado pelo destinatário (Situações 2, 3, 4)
31 31 public static $STA_SITUACAO_TRAMITE_CIENCIA_RECUSA = 9; // Remetente ciente da recusa do trâmite
32 32  
  33 + /* TIPO DE TRÂMITE EXTERNO DE PROCESSO */
  34 + public static $STA_TIPO_TRAMITE_ENVIO = 'E'; // Trâmite de ENVIO de processo externo
  35 + public static $STA_TIPO_TRAMITE_RECEBIMENTO = 'R'; // Trâmite de RECEBIMENTO de processo externo
  36 +
33 37 public static $STA_TIPO_RECIBO_ENVIO = '1'; // Recibo de envio
34 38 public static $STA_TIPO_RECIBO_CONCLUSAO_ENVIADO = '2'; // Recibo de recebimento enviado
35 39 public static $STA_TIPO_RECIBO_CONCLUSAO_RECEBIDO = '3'; // Recibo de recebimento recebido
... ... @@ -553,9 +557,10 @@ class ProcessoEletronicoRN extends InfraRN {
553 557  
554 558 }
555 559  
556   - public function cadastrarTramiteDeProcesso($parDblIdProcedimento, $parStrNumeroRegistro, $parNumIdentificacaoTramite, $parDthRegistroTramite, $parNumIdRepositorioOrigem,
  560 + public function cadastrarTramiteDeProcesso($parDblIdProcedimento, $parStrNumeroRegistro, $parNumIdentificacaoTramite, $parStrStaTipoTramite, $parDthRegistroTramite, $parNumIdRepositorioOrigem,
557 561 $parNumIdEstruturaOrigem, $parNumIdRepositorioDestino, $parNumIdEstruturaDestino, $parObjProcesso, $parNumTicketComponentesDigitais = null, $parObjComponentesDigitaisSolicitados = null)
558 562 {
  563 +
559 564 if(!isset($parDblIdProcedimento) || $parDblIdProcedimento == 0) {
560 565 throw new InfraException('Parâmetro $parDblIdProcedimento não informado.');
561 566 }
... ... @@ -568,6 +573,10 @@ class ProcessoEletronicoRN extends InfraRN {
568 573 throw new InfraException('Parâmetro $parStrNumeroRegistro não informado.');
569 574 }
570 575  
  576 + if(!isset($parStrStaTipoTramite) || !in_array($parStrStaTipoTramite, array(ProcessoEletronicoRN::$STA_TIPO_TRAMITE_ENVIO, ProcessoEletronicoRN::$STA_TIPO_TRAMITE_RECEBIMENTO))) {
  577 + throw new InfraException('Parâmetro $parStrStaTipoTramite inválio');
  578 + }
  579 +
571 580 if(!isset($parNumIdRepositorioOrigem) || $parNumIdRepositorioOrigem == 0) {
572 581 throw new InfraException('Parâmetro $parNumIdRepositorioOrigem não informado.');
573 582 }
... ... @@ -624,7 +633,7 @@ class ProcessoEletronicoRN extends InfraRN {
624 633 $objTramiteDTO->setNumIdEstruturaOrigem($parNumIdEstruturaOrigem);
625 634 $objTramiteDTO->setNumIdRepositorioDestino($parNumIdRepositorioDestino);
626 635 $objTramiteDTO->setNumIdEstruturaDestino($parNumIdEstruturaDestino);
627   -
  636 + $objTramiteDTO->setStrStaTipoTramite($parStrStaTipoTramite);
628 637 $objProcessoEletronicoDTO->setArrObjTramiteDTO(array($objTramiteDTO));
629 638  
630 639 //Monta dados dos componentes digitais
... ... @@ -692,7 +701,6 @@ class ProcessoEletronicoRN extends InfraRN {
692 701 //Registra informações sobre o componente digital do documento
693 702 $arrObjComponenteDigitalDTO = array();
694 703 $objComponenteDigitalBD = new ComponenteDigitalBD($this->getObjInfraIBanco());
695   -
696 704 $numOrdem = 1;
697 705  
698 706 foreach ($parObjTramiteDTO->getArrObjComponenteDigitalDTO() as $objComponenteDigitalDTO) {
... ...
rn/ReceberProcedimentoRN.php
  Diff comments   View file @ff263bd
... ... @@ -6,78 +6,32 @@ require_once dirname(__FILE__) . '/../../../SEI.php';
6 6  
7 7 class ReceberProcedimentoRN extends InfraRN
8 8 {
9   - const STR_APENSACAO_PROCEDIMENTOS = 'Relacionamento representando a apensação de processos recebidos externamente';
  9 + const STR_APENSACAO_PROCEDIMENTOS = 'Relacionamento representando a apensação de processos recebidos externamente';
10 10  
11   - private $objProcessoEletronicoRN;
12   - private $objInfraParametro;
13   - private $objProcedimentoAndamentoRN;
14   - private $documentosRetirados = array();
  11 + private $objProcessoEletronicoRN;
  12 + private $objInfraParametro;
  13 + private $objProcedimentoAndamentoRN;
  14 + private $documentosRetirados = array();
15 15  
16   - public $destinatarioReal = null;
  16 + public $destinatarioReal = null;
17 17  
18   - public function __construct()
19   - {
20   - parent::__construct();
21   -
22   - $this->objInfraParametro = new InfraParametro(BancoSEI::getInstance());
23   - $this->objProcessoEletronicoRN = new ProcessoEletronicoRN();
24   - $this->objProcedimentoAndamentoRN = new ProcedimentoAndamentoRN();
25   - }
26   -
27   - protected function inicializarObjInfraIBanco()
28   - {
29   - return BancoSEI::getInstance();
30   - }
31   -
32   - protected function listarPendenciasConectado()
33   - {
34   - $arrObjPendencias = $this->objProcessoEletronicoRN->listarPendencias(true);
35   - return $arrObjPendencias;
36   - }
37   -
38   - public function fecharProcedimentoEmOutraUnidades(ProcedimentoDTO $objProcedimentoDTO, $parObjMetadadosProcedimento){
39   -
40   - $objPenUnidadeDTO = new PenUnidadeDTO();
41   - $objPenUnidadeDTO->setNumIdUnidadeRH($parObjMetadadosProcedimento->metadados->destinatario->numeroDeIdentificacaoDaEstrutura);
42   - $objPenUnidadeDTO->retNumIdUnidade();
43   -
44   - $objGenericoBD = new GenericoBD($this->inicializarObjInfraIBanco());
45   - $objPenUnidadeDTO = $objGenericoBD->consultar($objPenUnidadeDTO);
46   -
47   - if(empty($objPenUnidadeDTO)) {
48   - return false;
49   - }
50   -
51   - $objAtividadeDTO = new AtividadeDTO();
52   - $objAtividadeDTO->setDistinct(true);
53   - $objAtividadeDTO->setNumIdUnidade($objPenUnidadeDTO->getNumIdUnidade(), InfraDTO::$OPER_DIFERENTE);
54   - $objAtividadeDTO->setDblIdProtocolo($objProcedimentoDTO->getDblIdProcedimento());
55   - $objAtividadeDTO->setDthConclusao(null);
56   - $objAtividadeDTO->setOrdStrSiglaUnidade(InfraDTO::$TIPO_ORDENACAO_ASC);
57   - $objAtividadeDTO->setOrdStrSiglaUsuarioAtribuicao(InfraDTO::$TIPO_ORDENACAO_DESC);
58   - $objAtividadeDTO->retStrSiglaUnidade();
59   - $objAtividadeDTO->retStrDescricaoUnidade();
60   - $objAtividadeDTO->retNumIdUsuarioAtribuicao();
61   - $objAtividadeDTO->retStrSiglaUsuarioAtribuicao();
62   - $objAtividadeDTO->retStrNomeUsuarioAtribuicao();
63   - $objAtividadeDTO->retNumIdUnidade();
64   -
65   - $objAtividadeRN = new AtividadeRN();
66   - $arrObjAtividadeDTO = (array)$objAtividadeRN->listarRN0036($objAtividadeDTO);
67   -
68   - $objInfraSessao = SessaoSEI::getInstance();
69   - $numIdUnidade = $objInfraSessao->getNumIdUnidadeAtual();
70   -
71   - foreach($arrObjAtividadeDTO as $objAtividadeDTO) {
  18 + public function __construct()
  19 + {
  20 + parent::__construct();
  21 + $this->objInfraParametro = new InfraParametro(BancoSEI::getInstance());
  22 + $this->objProcessoEletronicoRN = new ProcessoEletronicoRN();
  23 + $this->objProcedimentoAndamentoRN = new ProcedimentoAndamentoRN();
  24 + }
72 25  
73   - $objInfraSessao->setNumIdUnidadeAtual($objAtividadeDTO->getNumIdUnidade());
74   - $objInfraSessao->trocarUnidadeAtual();
  26 + protected function inicializarObjInfraIBanco()
  27 + {
  28 + return BancoSEI::getInstance();
  29 + }
75 30  
76   - $objProcedimentoRN = new ProcedimentoRN();
77   - $objProcedimentoRN->concluir(array($objProcedimentoDTO));
78   - }
79   - $objInfraSessao->setNumIdUnidadeAtual($numIdUnidade);
80   - $objInfraSessao->trocarUnidadeAtual();
  31 + protected function listarPendenciasConectado()
  32 + {
  33 + $arrObjPendencias = $this->objProcessoEletronicoRN->listarPendencias(true);
  34 + return $arrObjPendencias;
81 35 }
82 36  
83 37  
... ... @@ -90,64 +44,69 @@ class ReceberProcedimentoRN extends InfraRN
90 44 $objSeiRN = new SeiRN();
91 45  
92 46 if (!isset($parNumIdentificacaoTramite)) {
93   - throw new InfraException('Parâmetro $parNumIdentificacaoTramite não informado.');
  47 + throw new InfraException('Parâmetro $parNumIdentificacaoTramite não informado.');
94 48 }
95 49  
96 50 //TODO: Urgente: Verificar o status do trâmite e verificar se ele já foi salvo na base de dados
97 51 $this->gravarLogDebug("Solicitando metadados do trâmite " . $parNumIdentificacaoTramite, 4);
98 52 $objMetadadosProcedimento = $this->objProcessoEletronicoRN->solicitarMetadados($parNumIdentificacaoTramite);
99 53  
100   - //Substituir a unidade destinatária para a receptora
101   - if (isset($objMetadadosProcedimento->metadados->unidadeReceptora)) {
102   - $unidadeReceptora = $objMetadadosProcedimento->metadados->unidadeReceptora;
103   - $this->destinatarioReal = $objMetadadosProcedimento->metadados->destinatario;
104   - $objMetadadosProcedimento->metadados->destinatario->identificacaoDoRepositorioDeEstruturas = $unidadeReceptora->identificacaoDoRepositorioDeEstruturas;
105   - $objMetadadosProcedimento->metadados->destinatario->numeroDeIdentificacaoDaEstrutura = $unidadeReceptora->numeroDeIdentificacaoDaEstrutura;
106   - $numUnidadeReceptora = $unidadeReceptora->numeroDeIdentificacaoDaEstrutura;
107   - $this->gravarLogDebug("Atribuindo unidade receptora $numUnidadeReceptora para o trâmite $parNumIdentificacaoTramite", 4);
108   - }
109   -
110 54 if (isset($objMetadadosProcedimento)) {
111   - $strNumeroRegistro = $objMetadadosProcedimento->metadados->NRE;
112   - $objProcesso = $objMetadadosProcedimento->metadados->processo;
113   -
114   - //Verifica se processo já foi registrado para esse trâmite
115   - //TODO: Ajuste para receber corretamente processo em outra unidade do mesmo sistema passando pelo Barramento
116   - //Comentando o trecho abaixo funciona, mas o processo fica aberto na unidade de destino
117   - if($this->tramiteRegistrado($strNumeroRegistro, $parNumIdentificacaoTramite)) {
118   - $this->gravarLogDebug("Trâmite $parNumIdentificacaoTramite já para o processo " . $objProcesso->protocolo, 4);
119   - }
120   -
121   - // Validação dos dados do processo recebido
122   - $objInfraException = new InfraException();
123   - $this->validarDadosDestinatario($objInfraException, $objMetadadosProcedimento);
124   - $objInfraException->lancarValidacoes();
125   -
126   - #############################INICIA O RECEBIMENTO DOS COMPONENTES DIGITAIS US010################################################
127   - $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
128   - $objTramite = $arrObjTramite[0];
129   -
130   - //Obtém lista de componentes digitais que precisam ser obtidos
131   - $this->gravarLogDebug("Obtém lista de componentes digitais que precisam ser obtidos", 4);
132   - if(!is_array($objTramite->componenteDigitalPendenteDeRecebimento)){
133   - $objTramite->componenteDigitalPendenteDeRecebimento = array($objTramite->componenteDigitalPendenteDeRecebimento);
134   - }
135   -
136   - $this->validarComponentesDigitais($objProcesso, $parNumIdentificacaoTramite);
137   - $this->validarExtensaoComponentesDigitais($parNumIdentificacaoTramite, $objProcesso);
138   - $this->verificarPermissoesDiretorios($parNumIdentificacaoTramite);
139   -
140   - $this->gravarLogDebug("Obtendo metadados dos componentes digitais do processo", 4);
141   - $arrStrNomeDocumento = $this->listarMetaDadosComponentesDigitais($objProcesso);
142   - $receberComponenteDigitalRN = new ReceberComponenteDigitalRN();
143   - $arrAnexosComponentes = array();
144   - $arrayHash = array();
145   - $arrayHashPendentes = array();
146   -
147   - //Percorre os componentes que precisam ser recebidos
148   - foreach($objTramite->componenteDigitalPendenteDeRecebimento as $key => $componentePendente){
149   -
150   - if(!is_null($componentePendente)){
  55 + $strNumeroRegistro = $objMetadadosProcedimento->metadados->NRE;
  56 + $objProcesso = $objMetadadosProcedimento->metadados->processo;
  57 +
  58 + $this->objProcedimentoAndamentoRN->setOpts($strNumeroRegistro, $parNumIdentificacaoTramite, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_RECEBIDO));
  59 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Iniciando recebimento de processo externo', 'S'));
  60 +
  61 + //Tratamento para evitar o recebimento simultâneo do mesmo procedimento em serviços/processos concorrentes
  62 + $this->sincronizarRecebimentoProcessos($strNumeroRegistro, $parNumIdentificacaoTramite);
  63 +
  64 + //Verifica se processo já foi registrado para esse trâmite
  65 + if($this->tramiteRecebimentoRegistrado($strNumeroRegistro, $parNumIdentificacaoTramite)) {
  66 + $this->gravarLogDebug("Trâmite de recebimento $parNumIdentificacaoTramite já registrado para o processo " . $objProcesso->protocolo, 4);
  67 + return;
  68 + }
  69 +
  70 + //Substituir a unidade destinatária para a receptora
  71 + if (isset($objMetadadosProcedimento->metadados->unidadeReceptora)) {
  72 + $unidadeReceptora = $objMetadadosProcedimento->metadados->unidadeReceptora;
  73 + $this->destinatarioReal = $objMetadadosProcedimento->metadados->destinatario;
  74 + $objMetadadosProcedimento->metadados->destinatario->identificacaoDoRepositorioDeEstruturas = $unidadeReceptora->identificacaoDoRepositorioDeEstruturas;
  75 + $objMetadadosProcedimento->metadados->destinatario->numeroDeIdentificacaoDaEstrutura = $unidadeReceptora->numeroDeIdentificacaoDaEstrutura;
  76 + $numUnidadeReceptora = $unidadeReceptora->numeroDeIdentificacaoDaEstrutura;
  77 + $this->gravarLogDebug("Atribuindo unidade receptora $numUnidadeReceptora para o trâmite $parNumIdentificacaoTramite", 4);
  78 + }
  79 +
  80 + // Validação dos dados do processo recebido
  81 + $objInfraException = new InfraException();
  82 + $this->validarDadosDestinatario($objInfraException, $objMetadadosProcedimento);
  83 + $objInfraException->lancarValidacoes();
  84 +
  85 + #############################INICIA O RECEBIMENTO DOS COMPONENTES DIGITAIS US010################################################
  86 + $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
  87 + $objTramite = $arrObjTramite[0];
  88 +
  89 + //Obtém lista de componentes digitais que precisam ser obtidos
  90 + $this->gravarLogDebug("Obtém lista de componentes digitais que precisam ser obtidos", 4);
  91 + if(!is_array($objTramite->componenteDigitalPendenteDeRecebimento)){
  92 + $objTramite->componenteDigitalPendenteDeRecebimento = array($objTramite->componenteDigitalPendenteDeRecebimento);
  93 + }
  94 +
  95 + $this->validarComponentesDigitais($objProcesso, $parNumIdentificacaoTramite);
  96 + $this->validarExtensaoComponentesDigitais($parNumIdentificacaoTramite, $objProcesso);
  97 + $this->verificarPermissoesDiretorios($parNumIdentificacaoTramite);
  98 +
  99 + $this->gravarLogDebug("Obtendo metadados dos componentes digitais do processo", 4);
  100 + $arrStrNomeDocumento = $this->listarMetaDadosComponentesDigitais($objProcesso);
  101 + $receberComponenteDigitalRN = new ReceberComponenteDigitalRN();
  102 + $arrAnexosComponentes = array();
  103 + $arrayHash = array();
  104 + $arrayHashPendentes = array();
  105 +
  106 + //Percorre os componentes que precisam ser recebidos
  107 + foreach($objTramite->componenteDigitalPendenteDeRecebimento as $key => $componentePendente){
  108 +
  109 + if(!is_null($componentePendente)){
151 110  
152 111 if(!$this->documentoJaRegistrado($strNumeroRegistro, $parNumIdentificacaoTramite, $componentePendente)){
153 112 $arrayHashPendentes[] = $componentePendente;
... ... @@ -166,36 +125,37 @@ class ReceberProcedimentoRN extends InfraRN
166 125 //Valida a integridade do hash
167 126 $this->gravarLogDebug("Validando integridade de componente digital $key", 6);
168 127 $receberComponenteDigitalRN->validarIntegridadeDoComponenteDigital($arrAnexosComponentes[$key][$componentePendente], $componentePendente, $parNumIdentificacaoTramite);
169   - }
170   - }
  128 + }
  129 + }
171 130  
172   - if(count($arrAnexosComponentes) > 0){
  131 + if(count($arrAnexosComponentes) > 0){
173 132 $receberComponenteDigitalRN->setArrAnexos($arrAnexosComponentes);
174   - }
175   - #############################TERMINA O RECEBIMENTO DOS COMPONENTES DIGITAIS US010################################################
  133 + }
176 134  
177   - $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
178   - $objTramite = $arrObjTramite[0];
  135 + #############################TERMINA O RECEBIMENTO DOS COMPONENTES DIGITAIS US010################################################
179 136  
180   - //Verifica se o trâmite está recusado
181   - if($objTramite->situacaoAtual == ProcessoEletronicoRN::$STA_SITUACAO_TRAMITE_RECUSADO) {
  137 + $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
  138 + $objTramite = $arrObjTramite[0];
  139 +
  140 + //Verifica se o trâmite está recusado
  141 + if($objTramite->situacaoAtual == ProcessoEletronicoRN::$STA_SITUACAO_TRAMITE_RECUSADO) {
182 142 $this->gravarLogDebug("Trâmite $parNumIdentificacaoTramite já se encontra recusado. Cancelando o recebimento do processo", 4);
183 143 return;
184   - }
185   -
186   - $this->gravarLogDebug("Persistindo/atualizando dados do processo com NRE " . $strNumeroRegistro, 4);
187   - $objProcedimentoDTO = $this->registrarProcesso($strNumeroRegistro, $parNumIdentificacaoTramite, $objProcesso, $objMetadadosProcedimento);
  144 + }
188 145  
189   - // @join_tec US008.08 (#23092)
190   - $this->objProcedimentoAndamentoRN->setOpts($objProcedimentoDTO->getDblIdProcedimento(), $parNumIdentificacaoTramite, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_RECEBIDO));
191   - $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Obtendo metadados do processo', 'S'));
  146 + $this->gravarLogDebug("Persistindo/atualizando dados do processo com NRE " . $strNumeroRegistro, 4);
  147 + $objProcedimentoDTO = $this->registrarProcesso($strNumeroRegistro, $parNumIdentificacaoTramite, $objProcesso, $objMetadadosProcedimento);
192 148  
  149 + // @join_tec US008.08 (#23092)
  150 + $this->objProcedimentoAndamentoRN->setOpts($strNumeroRegistro, $parNumIdentificacaoTramite, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_RECEBIDO), $objProcedimentoDTO->getDblIdProcedimento());
  151 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Obtendo metadados do processo', 'S'));
193 152  
194   - $this->gravarLogDebug("Registrando trâmite externo do processo", 4);
195   - $objProcessoEletronicoDTO = $this->objProcessoEletronicoRN->cadastrarTramiteDeProcesso(
  153 + $this->gravarLogDebug("Registrando trâmite externo do processo", 4);
  154 + $objProcessoEletronicoDTO = $this->objProcessoEletronicoRN->cadastrarTramiteDeProcesso(
196 155 $objProcedimentoDTO->getDblIdProcedimento(),
197 156 $strNumeroRegistro,
198 157 $parNumIdentificacaoTramite,
  158 + ProcessoEletronicoRN::$STA_TIPO_TRAMITE_RECEBIMENTO,
199 159 null,
200 160 $objMetadadosProcedimento->metadados->remetente->identificacaoDoRepositorioDeEstruturas,
201 161 $objMetadadosProcedimento->metadados->remetente->numeroDeIdentificacaoDaEstrutura,
... ... @@ -203,19 +163,19 @@ class ReceberProcedimentoRN extends InfraRN
203 163 $objMetadadosProcedimento->metadados->destinatario->numeroDeIdentificacaoDaEstrutura,
204 164 $objProcesso);
205 165  
206   - //Verifica se o tramite se encontra na situação correta
207   - $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
208   - if(!isset($arrObjTramite) || count($arrObjTramite) != 1) {
209   - throw new InfraException("Trâmite não pode ser localizado pelo identificado $parNumIdentificacaoTramite.");
210   - }
  166 + //Verifica se o tramite se encontra na situação correta
  167 + $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
  168 + if(!isset($arrObjTramite) || count($arrObjTramite) != 1) {
  169 + throw new InfraException("Trâmite não pode ser localizado pelo identificado $parNumIdentificacaoTramite.");
  170 + }
211 171  
212   - $objTramite = $arrObjTramite[0];
213   - if($objTramite->situacaoAtual != ProcessoEletronicoRN::$STA_SITUACAO_TRAMITE_COMPONENTES_RECEBIDOS_DESTINATARIO) {
214   - $this->gravarLogDebug("Desconsiderando recebimento do processo devido a situação de trâmite inconsistente: " . $objTramite->situacaoAtual, 4);
215   - return;
216   - }
  172 + $objTramite = $arrObjTramite[0];
  173 + if($objTramite->situacaoAtual != ProcessoEletronicoRN::$STA_SITUACAO_TRAMITE_COMPONENTES_RECEBIDOS_DESTINATARIO) {
  174 + $this->gravarLogDebug("Desconsiderando recebimento do processo devido a situação de trâmite inconsistente: " . $objTramite->situacaoAtual, 4);
  175 + return;
  176 + }
217 177  
218   - if(count($arrayHashPendentes) > 0){
  178 + if(count($arrayHashPendentes) > 0){
219 179 //Obter dados dos componetes digitais
220 180 $this->gravarLogDebug("Iniciando o recebimento dos componentes digitais pendentes", 4);
221 181 $objComponenteDigitalDTO = new ComponenteDigitalDTO();
... ... @@ -236,27 +196,26 @@ class ReceberProcedimentoRN extends InfraRN
236 196 $objComponenteDigitalBD = new ComponenteDigitalBD($this->getObjInfraIBanco());
237 197 $arrObjComponentesDigitaisDTO = $objComponenteDigitalBD->listar($objComponenteDigitalDTO);
238 198  
239   - if ($objComponenteDigitalBD->contar($objComponenteDigitalDTO) > 0) {
240   - $objReceberComponenteDigitalRN = $receberComponenteDigitalRN;
241   - foreach($arrObjComponentesDigitaisDTO as $objComponenteDigitalDTOEnviado) {
242   - if($objComponenteDigitalDTOEnviado->getStrStaEstadoProtocolo() != ProtocoloRN::$TE_DOCUMENTO_CANCELADO){
243   - $strHash = $objComponenteDigitalDTOEnviado->getStrHashConteudo();
244   - $strNomeDocumento = (array_key_exists($strHash, $arrStrNomeDocumento)) ? $arrStrNomeDocumento[$strHash]['especieNome'] : '[Desconhecido]';
245   - $objReceberComponenteDigitalRN->receberComponenteDigital($objComponenteDigitalDTOEnviado);
  199 + if ($objComponenteDigitalBD->contar($objComponenteDigitalDTO) > 0) {
  200 + $objReceberComponenteDigitalRN = $receberComponenteDigitalRN;
  201 + foreach($arrObjComponentesDigitaisDTO as $objComponenteDigitalDTOEnviado) {
  202 + if($objComponenteDigitalDTOEnviado->getStrStaEstadoProtocolo() != ProtocoloRN::$TE_DOCUMENTO_CANCELADO){
  203 + $strHash = $objComponenteDigitalDTOEnviado->getStrHashConteudo();
  204 + $strNomeDocumento = (array_key_exists($strHash, $arrStrNomeDocumento)) ? $arrStrNomeDocumento[$strHash]['especieNome'] : '[Desconhecido]';
  205 + $objReceberComponenteDigitalRN->receberComponenteDigital($objComponenteDigitalDTOEnviado);
246 206  
247 207 // @join_tec US008.09 (#23092)
248   - $strMensagemRecebimento = sprintf('Recebendo %s %s', $strNomeDocumento, $objComponenteDigitalDTOEnviado->getStrProtocoloDocumentoFormatado());
249   - $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento($strMensagemRecebimento, 'S'));
250   - $this->gravarLogDebug($strMensagemRecebimento, 6);
251   - }
252   - }
  208 + $strMensagemRecebimento = sprintf('Recebendo %s %s', $strNomeDocumento, $objComponenteDigitalDTOEnviado->getStrProtocoloDocumentoFormatado());
  209 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento($strMensagemRecebimento, 'S'));
  210 + $this->gravarLogDebug($strMensagemRecebimento, 6);
  211 + }
  212 + }
253 213 // @join_tec US008.10 (#23092)
254 214 $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Todos os componentes digitais foram recebidos', 'S'));
255   -
256 215 }else{
257   - $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Nenhum componente digital para receber', 'S'));
  216 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Nenhum componente digital para receber', 'S'));
258 217 }
259   - }
  218 + }
260 219 }
261 220 //$this->fecharProcedimentoEmOutraUnidades($objProcedimentoDTO, $objMetadadosProcedimento);
262 221 $this->gravarLogDebug("Enviando recibo de conclusão do trâmite $parNumIdentificacaoTramite", 6);
... ... @@ -275,6 +234,51 @@ class ReceberProcedimentoRN extends InfraRN
275 234 }
276 235 }
277 236  
  237 + public function fecharProcedimentoEmOutraUnidades(ProcedimentoDTO $objProcedimentoDTO, $parObjMetadadosProcedimento){
  238 +
  239 + $objPenUnidadeDTO = new PenUnidadeDTO();
  240 + $objPenUnidadeDTO->setNumIdUnidadeRH($parObjMetadadosProcedimento->metadados->destinatario->numeroDeIdentificacaoDaEstrutura);
  241 + $objPenUnidadeDTO->retNumIdUnidade();
  242 +
  243 + $objGenericoBD = new GenericoBD($this->inicializarObjInfraIBanco());
  244 + $objPenUnidadeDTO = $objGenericoBD->consultar($objPenUnidadeDTO);
  245 +
  246 + if(empty($objPenUnidadeDTO)) {
  247 + return false;
  248 + }
  249 +
  250 + $objAtividadeDTO = new AtividadeDTO();
  251 + $objAtividadeDTO->setDistinct(true);
  252 + $objAtividadeDTO->setNumIdUnidade($objPenUnidadeDTO->getNumIdUnidade(), InfraDTO::$OPER_DIFERENTE);
  253 + $objAtividadeDTO->setDblIdProtocolo($objProcedimentoDTO->getDblIdProcedimento());
  254 + $objAtividadeDTO->setDthConclusao(null);
  255 + $objAtividadeDTO->setOrdStrSiglaUnidade(InfraDTO::$TIPO_ORDENACAO_ASC);
  256 + $objAtividadeDTO->setOrdStrSiglaUsuarioAtribuicao(InfraDTO::$TIPO_ORDENACAO_DESC);
  257 + $objAtividadeDTO->retStrSiglaUnidade();
  258 + $objAtividadeDTO->retStrDescricaoUnidade();
  259 + $objAtividadeDTO->retNumIdUsuarioAtribuicao();
  260 + $objAtividadeDTO->retStrSiglaUsuarioAtribuicao();
  261 + $objAtividadeDTO->retStrNomeUsuarioAtribuicao();
  262 + $objAtividadeDTO->retNumIdUnidade();
  263 +
  264 + $objAtividadeRN = new AtividadeRN();
  265 + $arrObjAtividadeDTO = (array)$objAtividadeRN->listarRN0036($objAtividadeDTO);
  266 +
  267 + $objInfraSessao = SessaoSEI::getInstance();
  268 + $numIdUnidade = $objInfraSessao->getNumIdUnidadeAtual();
  269 +
  270 + foreach($arrObjAtividadeDTO as $objAtividadeDTO) {
  271 +
  272 + $objInfraSessao->setNumIdUnidadeAtual($objAtividadeDTO->getNumIdUnidade());
  273 + $objInfraSessao->trocarUnidadeAtual();
  274 +
  275 + $objProcedimentoRN = new ProcedimentoRN();
  276 + $objProcedimentoRN->concluir(array($objProcedimentoDTO));
  277 + }
  278 + $objInfraSessao->setNumIdUnidadeAtual($numIdUnidade);
  279 + $objInfraSessao->trocarUnidadeAtual();
  280 + }
  281 +
278 282 /**
279 283 * Retorna um array com alguns metadados, onde o indice de é o hash do arquivo
280 284 *
... ... @@ -337,18 +341,12 @@ class ReceberProcedimentoRN extends InfraRN
337 341 }
338 342 }
339 343  
340   -
341   -// $objInfraParametro = new InfraParametro(BancoSEI::getInstance());
342   -// $numTamDocExterno = $objInfraParametro->getValor('SEI_TAM_MB_DOC_EXTERNO');
343 344 $objPenParametroRN = new PenParametroRN();
344 345 $numTamDocExterno = $objPenParametroRN->getParametro('PEN_TAMANHO_MAXIMO_DOCUMENTO_EXPEDIDO');
345 346  
346 347  
347 348 foreach($arrObjDocumentos as $objDocument) {
348   -
349   -
350 349 if (is_null($objDocument->componenteDigital->tamanhoEmBytes) || $objDocument->componenteDigital->tamanhoEmBytes == 0){
351   -
352 350 throw new InfraException('Tamanho de componente digital não informado.', null, 'RECUSA: '.ProcessoEletronicoRN::MTV_RCSR_TRAM_CD_OUTROU);
353 351  
354 352 }
... ... @@ -365,115 +363,112 @@ class ReceberProcedimentoRN extends InfraRN
365 363 }
366 364  
367 365  
368   - private function registrarProcesso($parStrNumeroRegistro, $parNumIdentificacaoTramite, $parObjProcesso, $parObjMetadadosProcedimento)
369   - {
370   - // Validação dos dados do processo recebido
371   - $objInfraException = new InfraException();
372   - $this->validarDadosProcesso($objInfraException, $parObjProcesso);
373   - $this->validarDadosDocumentos($objInfraException, $parObjProcesso);
374   -
375   - //TODO: Regra de Negócio - Processos recebidos pelo Barramento não poderão disponibilizar a opção de reordenação e cancelamento de documentos
376   - //para o usuário final, mesmo possuindo permissão para isso
377   -
378   - $objInfraException->lancarValidacoes();
379   -
380   - //Verificar se procedimento já existia na base de dados do sistema
381   - $dblIdProcedimento = $this->consultarProcedimentoExistente($parStrNumeroRegistro, $parObjProcesso->protocolo);
  366 + private function registrarProcesso($parStrNumeroRegistro, $parNumIdentificacaoTramite, $parObjProcesso, $parObjMetadadosProcedimento)
  367 + {
  368 + // Validação dos dados do processo recebido
  369 + $objInfraException = new InfraException();
  370 + $this->validarDadosProcesso($objInfraException, $parObjProcesso);
  371 + $this->validarDadosDocumentos($objInfraException, $parObjProcesso);
382 372  
383   - if(isset($dblIdProcedimento)){
384   - $objProcedimentoDTO = $this->atualizarProcedimento($dblIdProcedimento, $parObjMetadadosProcedimento, $parObjProcesso);
385   - }
386   - else {
387   - $objProcedimentoDTO = $this->gerarProcedimento($parObjMetadadosProcedimento, $parObjProcesso);
388   - }
  373 + //TODO: Regra de Negócio - Processos recebidos pelo Barramento não poderão disponibilizar a opção de reordenação e cancelamento de documentos
  374 + //para o usuário final, mesmo possuindo permissão para isso
389 375  
390   - //TODO: Fazer o envio de cada um dos procedimentos apensados (Processo principal e seus apensados, caso exista)
391   - //...
  376 + $objInfraException->lancarValidacoes();
392 377  
393   - //Chamada recursiva para registro dos processos apensados
394   - if(isset($objProcesso->processoApensado)) {
395   - if(!is_array($objProcesso->processoApensado)) {
396   - $objProcesso->processoApensado = array($objProcesso->processoApensado);
397   - }
  378 + //Verificar se procedimento já existia na base de dados do sistema
  379 + $dblIdProcedimento = $this->consultarProcedimentoExistente($parStrNumeroRegistro, $parObjProcesso->protocolo);
398 380  
399   - foreach ($objProcesso->processoApensado as $objProcessoApensado) {
400   - $this->registrarProcesso($parStrNumeroRegistro, $parNumIdentificacaoTramite, $objProcessoApensado, $parObjMetadadosProcedimento);
401   - }
402   - }
  381 + if(isset($dblIdProcedimento)){
  382 + $objProcedimentoDTO = $this->atualizarProcedimento($dblIdProcedimento, $parObjMetadadosProcedimento, $parObjProcesso);
  383 + }
  384 + else {
  385 + $objProcedimentoDTO = $this->gerarProcedimento($parObjMetadadosProcedimento, $parObjProcesso);
  386 + }
403 387  
404   - return $objProcedimentoDTO;
405   - }
  388 + //TODO: Fazer o envio de cada um dos procedimentos apensados (Processo principal e seus apensados, caso exista)
  389 + //...
406 390  
407   - private function tramiteRegistrado($parStrNumeroRegistro, $parNumIdentificacaoTramite)
408   - {
  391 + //Chamada recursiva para registro dos processos apensados
  392 + if(isset($objProcesso->processoApensado)) {
  393 + if(!is_array($objProcesso->processoApensado)) {
  394 + $objProcesso->processoApensado = array($objProcesso->processoApensado);
  395 + }
409 396  
410   - $objTramiteDTO = new TramiteDTO();
411   - $objTramiteDTO->setStrNumeroRegistro($parStrNumeroRegistro);
412   - $objTramiteDTO->setNumIdTramite($parNumIdentificacaoTramite);
  397 + foreach ($objProcesso->processoApensado as $objProcessoApensado) {
  398 + $this->registrarProcesso($parStrNumeroRegistro, $parNumIdentificacaoTramite, $objProcessoApensado, $parObjMetadadosProcedimento);
  399 + }
  400 + }
413 401  
414   - $objTramiteBD = new TramiteBD($this->getObjInfraIBanco());
415   - return $objTramiteBD->contar($objTramiteDTO) > 0;
416   - }
  402 + return $objProcedimentoDTO;
  403 + }
417 404  
  405 + private function tramiteRecebimentoRegistrado($parStrNumeroRegistro, $parNumIdentificacaoTramite)
  406 + {
  407 + $objTramiteDTO = new TramiteDTO();
  408 + $objTramiteDTO->setStrNumeroRegistro($parStrNumeroRegistro);
  409 + $objTramiteDTO->setNumIdTramite($parNumIdentificacaoTramite);
  410 + $objTramiteDTO->setStrStaTipoTramite(ProcessoEletronicoRN::$STA_TIPO_TRAMITE_RECEBIMENTO);
  411 + $objTramiteBD = new TramiteBD($this->getObjInfraIBanco());
  412 + return $objTramiteBD->contar($objTramiteDTO) > 0;
  413 + }
418 414  
419   - private function documentoJaRegistrado($parStrNumeroRegistro, $parNumIdentificacaoTramite, $parStrHashComponenteDigital)
420   - {
421   - //Verifica se componente digital já está registrado para o documento
422   - $objComponenteDigitalDTO = new ComponenteDigitalDTO();
423   - $objComponenteDigitalDTO->setStrNumeroRegistro($parStrNumeroRegistro);
424   - $objComponenteDigitalDTO->setNumIdTramite($parNumIdentificacaoTramite);
425   - $objComponenteDigitalDTO->setStrHashConteudo($parStrHashComponenteDigital);
426   - // $objComponenteDigitalDTO->retDblIdDocumento();
427   - // $objComponenteDigitalDTO->retNumTicketEnvioComponentes();
428   - // $objComponenteDigitalDTO->retStrProtocoloDocumentoFormatado();
429   - // $objComponenteDigitalDTO->retStrHashConteudo();
430   - // $objComponenteDigitalDTO->retStrProtocolo();
431   - // $objComponenteDigitalDTO->retStrNumeroRegistro();
432   - // $objComponenteDigitalDTO->retNumIdTramite();
433   - // $objComponenteDigitalDTO->retStrNome();
434   - // $objComponenteDigitalDTO->retStrStaEstadoProtocolo();
435   -
436   - $objComponenteDigitalBD = new ComponenteDigitalBD($this->getObjInfraIBanco());
437   - return $objComponenteDigitalBD->contar($objComponenteDigitalDTO) > 0;
438   - }
439 415  
  416 + private function documentoJaRegistrado($parStrNumeroRegistro, $parNumIdentificacaoTramite, $parStrHashComponenteDigital)
  417 + {
  418 + //Verifica se componente digital já está registrado para o documento
  419 + $objComponenteDigitalDTO = new ComponenteDigitalDTO();
  420 + $objComponenteDigitalDTO->setStrNumeroRegistro($parStrNumeroRegistro);
  421 + $objComponenteDigitalDTO->setNumIdTramite($parNumIdentificacaoTramite);
  422 + $objComponenteDigitalDTO->setStrHashConteudo($parStrHashComponenteDigital);
  423 + // $objComponenteDigitalDTO->retDblIdDocumento();
  424 + // $objComponenteDigitalDTO->retNumTicketEnvioComponentes();
  425 + // $objComponenteDigitalDTO->retStrProtocoloDocumentoFormatado();
  426 + // $objComponenteDigitalDTO->retStrHashConteudo();
  427 + // $objComponenteDigitalDTO->retStrProtocolo();
  428 + // $objComponenteDigitalDTO->retStrNumeroRegistro();
  429 + // $objComponenteDigitalDTO->retNumIdTramite();
  430 + // $objComponenteDigitalDTO->retStrNome();
  431 + // $objComponenteDigitalDTO->retStrStaEstadoProtocolo();
440 432  
441   - private function consultarProcedimentoExistente($parStrNumeroRegistro, $parStrProtocolo = null) {
  433 + $objComponenteDigitalBD = new ComponenteDigitalBD($this->getObjInfraIBanco());
  434 + return $objComponenteDigitalBD->contar($objComponenteDigitalDTO) > 0;
  435 + }
442 436  
443   - $dblIdProcedimento = null;
444 437  
445   - $objProcessoEletronicoDTO = new ProcessoEletronicoDTO();
446   - $objProcessoEletronicoDTO->retDblIdProcedimento();
447   - $objProcessoEletronicoDTO->setStrNumeroRegistro($parStrNumeroRegistro);
  438 + private function consultarProcedimentoExistente($parStrNumeroRegistro, $parStrProtocolo = null)
  439 + {
  440 + $dblIdProcedimento = null;
  441 + $objProcessoEletronicoDTO = new ProcessoEletronicoDTO();
  442 + $objProcessoEletronicoDTO->retDblIdProcedimento();
  443 + $objProcessoEletronicoDTO->setStrNumeroRegistro($parStrNumeroRegistro);
448 444  
449 445 //TODO: Manter o padrão o sistema em chamar uma classe de regra de negócio (RN) e não diretamente um classe BD
450   - $objProcessoEletronicoBD = new ProcessoEletronicoBD($this->getObjInfraIBanco());
451   - $objProcessoEletronicoDTO = $objProcessoEletronicoBD->consultar($objProcessoEletronicoDTO);
452   -
453   - if(isset($objProcessoEletronicoDTO)){
454   - $dblIdProcedimento = $objProcessoEletronicoDTO->getDblIdProcedimento();
455   - }
456   -
457   - return $dblIdProcedimento;
458   - }
  446 + $objProcessoEletronicoBD = new ProcessoEletronicoBD($this->getObjInfraIBanco());
  447 + $objProcessoEletronicoDTO = $objProcessoEletronicoBD->consultar($objProcessoEletronicoDTO);
459 448  
460   - private function atualizarProcedimento($parDblIdProcedimento, $objMetadadosProcedimento, $objProcesso)
461   - {
  449 + if(isset($objProcessoEletronicoDTO)){
  450 + $dblIdProcedimento = $objProcessoEletronicoDTO->getDblIdProcedimento();
  451 + }
462 452  
463   - if(!isset($parDblIdProcedimento)){
464   - throw new InfraException('Parâmetro $parDblIdProcedimento não informado.');
  453 + return $dblIdProcedimento;
465 454 }
466 455  
467   - if(!isset($objMetadadosProcedimento)){
468   - throw new InfraException('Parâmetro $objMetadadosProcedimento não informado.');
469   - }
  456 + private function atualizarProcedimento($parDblIdProcedimento, $objMetadadosProcedimento, $objProcesso)
  457 + {
  458 + if(!isset($parDblIdProcedimento)){
  459 + throw new InfraException('Parâmetro $parDblIdProcedimento não informado.');
  460 + }
470 461  
  462 + if(!isset($objMetadadosProcedimento)){
  463 + throw new InfraException('Parâmetro $objMetadadosProcedimento não informado.');
  464 + }
471 465  
472   - if ($this->destinatarioReal) {
473   - $objDestinatario = $this->destinatarioReal;
474   - } else {
475   - $objDestinatario = $objMetadadosProcedimento->metadados->destinatario;
476   - }
  466 +
  467 + if ($this->destinatarioReal) {
  468 + $objDestinatario = $this->destinatarioReal;
  469 + } else {
  470 + $objDestinatario = $objMetadadosProcedimento->metadados->destinatario;
  471 + }
477 472  
478 473 //TODO: Refatorar código para criar método de pesquisa do procedimento e reutilizá-la
479 474  
... ... @@ -535,44 +530,44 @@ class ReceberProcedimentoRN extends InfraRN
535 530 $this->registrarAndamentoRecebimentoProcesso($objProcedimentoDTO, $objMetadadosProcedimento);
536 531  
537 532  
538   - if($flgReabrir){
  533 + if($flgReabrir){
539 534 $objEntradaReabrirProcessoAPI = new EntradaReabrirProcessoAPI();
540 535 $objEntradaReabrirProcessoAPI->setIdProcedimento($parDblIdProcedimento);
541 536 $objSeiRN->reabrirProcesso($objEntradaReabrirProcessoAPI);
542   - }
  537 + }
543 538  
544 539 //Cadastro das atividades para quando o destinatário é desviado pelo receptor (!3!)
545 540 if ($this->destinatarioReal->numeroDeIdentificacaoDaEstrutura) {
546   - $this->gerarAndamentoUnidadeReceptora($parDblIdProcedimento);
  541 + $this->gerarAndamentoUnidadeReceptora($parDblIdProcedimento);
547 542 }
548 543  
549   - $objEntradaDesbloquearProcessoAPI = new EntradaDesbloquearProcessoAPI();
550   - $objEntradaDesbloquearProcessoAPI->setIdProcedimento($parDblIdProcedimento);
551   - $objSeiRN->desbloquearProcesso($objEntradaDesbloquearProcessoAPI);
  544 + $objEntradaDesbloquearProcessoAPI = new EntradaDesbloquearProcessoAPI();
  545 + $objEntradaDesbloquearProcessoAPI->setIdProcedimento($parDblIdProcedimento);
  546 + $objSeiRN->desbloquearProcesso($objEntradaDesbloquearProcessoAPI);
552 547  
553   - //TODO: Obter código da unidade através de mapeamento entre SEI e Barramento
554   - $objUnidadeDTO = $this->atribuirDadosUnidade($objProcedimentoDTO, $objDestinatario);
  548 + //TODO: Obter código da unidade através de mapeamento entre SEI e Barramento
  549 + $objUnidadeDTO = $this->atribuirDadosUnidade($objProcedimentoDTO, $objDestinatario);
555 550  
556   - $this->atribuirDocumentos($objProcedimentoDTO, $objProcesso, $objUnidadeDTO, $objMetadadosProcedimento);
557   - $this->registrarProcedimentoNaoVisualizado($objProcedimentoDTO);
  551 + $this->atribuirDocumentos($objProcedimentoDTO, $objProcesso, $objUnidadeDTO, $objMetadadosProcedimento);
  552 + $this->registrarProcedimentoNaoVisualizado($objProcedimentoDTO);
558 553  
559 554 //TODO: Avaliar necessidade de restringir referência circular entre processos
560 555 //TODO: Registrar que o processo foi recebido com outros apensados. Necessário para posterior reenvio
561   - $this->atribuirProcessosApensados($objProcedimentoDTO, $objProcesso->processoApensado);
  556 + $this->atribuirProcessosApensados($objProcedimentoDTO, $objProcesso->processoApensado);
562 557  
563   - //Realiza a alteração dos metadados do processo
564   - //TODO: Implementar alteração de todos os metadados
565   - $this->alterarMetadadosProcedimento($objProcedimentoDTO->getDblIdProcedimento(), $objProcesso);
  558 + //Realiza a alteração dos metadados do processo
  559 + //TODO: Implementar alteração de todos os metadados
  560 + $this->alterarMetadadosProcedimento($objProcedimentoDTO->getDblIdProcedimento(), $objProcesso);
566 561  
567   - //TODO: Finalizar o envio do documento para a respectiva unidade
568   - $this->enviarProcedimentoUnidade($objProcedimentoDTO, true);
  562 + //TODO: Finalizar o envio do documento para a respectiva unidade
  563 + $this->enviarProcedimentoUnidade($objProcedimentoDTO, true);
569 564  
570   - //$this->removerAndamentosProcedimento($objProcedimentoDTO);
571   - return $objProcedimentoDTO;
  565 + //$this->removerAndamentosProcedimento($objProcedimentoDTO);
  566 + return $objProcedimentoDTO;
572 567  
573   - }
  568 + }
574 569  
575   - private function gerarAndamentoUnidadeReceptora($parNumIdProcedimento) {
  570 + private function gerarAndamentoUnidadeReceptora($parNumIdProcedimento) {
576 571  
577 572 $objUnidadeDTO = new PenUnidadeDTO();
578 573 $objUnidadeDTO->setNumIdUnidadeRH($this->destinatarioReal->numeroDeIdentificacaoDaEstrutura);
... ... @@ -605,15 +600,15 @@ class ReceberProcedimentoRN extends InfraRN
605 600  
606 601 private function gerarProcedimento($objMetadadosProcedimento, $objProcesso){
607 602  
608   - if(!isset($objMetadadosProcedimento)){
609   - throw new InfraException('Parâmetro $objMetadadosProcedimento não informado.');
610   - }
  603 + if(!isset($objMetadadosProcedimento)){
  604 + throw new InfraException('Parâmetro $objMetadadosProcedimento não informado.');
  605 + }
611 606  
612 607 //TODO: Usar dados do destinatário em outro método específico para envio
613 608 // Dados do procedimento enviados pelos órgão externo integrado ao PEN
614 609 //$objProcesso = $objMetadadosProcedimento->metadados->processo;
615   - $objRemetente = $objMetadadosProcedimento->metadados->remetente;
616   - $objDestinatario = $objMetadadosProcedimento->metadados->destinatario;
  610 + $objRemetente = $objMetadadosProcedimento->metadados->remetente;
  611 + $objDestinatario = $objMetadadosProcedimento->metadados->destinatario;
617 612  
618 613 //TODO: TESTES DE RECEBIMENTO DE PROCESSOS
619 614 //REMOVER APOS TESTES DO SISTEMA
... ... @@ -621,69 +616,69 @@ class ReceberProcedimentoRN extends InfraRN
621 616  
622 617 //Atribuição de dados do protocolo
623 618 //TODO: Validar cada uma das informações de entrada do webservice
624   - $objProtocoloDTO = new ProtocoloDTO();
625   - $objProtocoloDTO->setDblIdProtocolo(null);
626   - $objProtocoloDTO->setStrDescricao(utf8_decode($objProcesso->descricao));
627   - $objProtocoloDTO->setStrStaNivelAcessoLocal($this->obterNivelSigiloSEI($objProcesso->nivelDeSigilo));
628   -
629   - if($this->obterNivelSigiloSEI($objProcesso->nivelDeSigilo) == ProtocoloRN::$NA_RESTRITO){
630   - $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
631   - $objPenParametroRN = new PenParametroRN();
632   - $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO');
  619 + $objProtocoloDTO = new ProtocoloDTO();
  620 + $objProtocoloDTO->setDblIdProtocolo(null);
  621 + $objProtocoloDTO->setStrDescricao(utf8_decode($objProcesso->descricao));
  622 + $objProtocoloDTO->setStrStaNivelAcessoLocal($this->obterNivelSigiloSEI($objProcesso->nivelDeSigilo));
633 623  
634   - if (!isset($objProcesso->hipoteseLegal) || (isset($objProcesso->hipoteseLegal) && empty($objProcesso->hipoteseLegal->identificacao))) {
635   - $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
636   - } else {
  624 + if($this->obterNivelSigiloSEI($objProcesso->nivelDeSigilo) == ProtocoloRN::$NA_RESTRITO){
  625 + $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
  626 + $objPenParametroRN = new PenParametroRN();
  627 + $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO');
637 628  
638   - $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($objProcesso->hipoteseLegal->identificacao);
639   - if (empty($numIdHipoteseLegal)) {
  629 + if (!isset($objProcesso->hipoteseLegal) || (isset($objProcesso->hipoteseLegal) && empty($objProcesso->hipoteseLegal->identificacao))) {
640 630 $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
641 631 } else {
642   - $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegal);
  632 +
  633 + $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($objProcesso->hipoteseLegal->identificacao);
  634 + if (empty($numIdHipoteseLegal)) {
  635 + $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
  636 + } else {
  637 + $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegal);
  638 + }
643 639 }
644 640 }
645   - }
646   -
647   - $objProtocoloDTO->setStrProtocoloFormatado(utf8_decode($objProcesso->protocolo));
648   - $objProtocoloDTO->setDtaGeracao($this->objProcessoEletronicoRN->converterDataSEI($objProcesso->dataHoraDeProducao));
649   - $objProtocoloDTO->setArrObjAnexoDTO(array());
650   - $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());
651   - $objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array());
652   - //$objProtocoloDTO->setStrStaEstado(ProtocoloRN::$TE_BLOQUEADO);
653   - $this->atribuirParticipantes($objProtocoloDTO, $objProcesso->interessado);
654 641  
655   - $strDescricao = sprintf('Tipo de processo no órgão de origem: %s', utf8_decode($objProcesso->processoDeNegocio)).PHP_EOL;
656   - $strDescricao .= $objProcesso->observacao;
657   -
658   - $objObservacaoDTO = new ObservacaoDTO();
659   -
660   - //!Criação da observação de aviso para qual é a real unidade emitida (!2!)
661   - if ($this->destinatarioReal) {
662   - $objUnidadeDTO = new PenUnidadeDTO();
663   - $objUnidadeDTO->setNumIdUnidadeRH($this->destinatarioReal->numeroDeIdentificacaoDaEstrutura);
664   - $objUnidadeDTO->setStrSinAtivo('S');
665   - $objUnidadeDTO->retStrDescricao();
666   -
667   - $objUnidadeRN = new UnidadeRN();
668   - $objUnidadeDTO = $objUnidadeRN->consultarRN0125($objUnidadeDTO);
669   - $objObservacaoDTO->setStrDescricao($strDescricao . PHP_EOL .'Processo remetido para a unidade ' . $objUnidadeDTO->getStrDescricao());
670   - } else {
671   - $objObservacaoDTO->setStrDescricao($strDescricao);
672   - }
  642 + $objProtocoloDTO->setStrProtocoloFormatado(utf8_decode($objProcesso->protocolo));
  643 + $objProtocoloDTO->setDtaGeracao($this->objProcessoEletronicoRN->converterDataSEI($objProcesso->dataHoraDeProducao));
  644 + $objProtocoloDTO->setArrObjAnexoDTO(array());
  645 + $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());
  646 + $objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array());
  647 + //$objProtocoloDTO->setStrStaEstado(ProtocoloRN::$TE_BLOQUEADO);
  648 + $this->atribuirParticipantes($objProtocoloDTO, $objProcesso->interessado);
  649 +
  650 + $strDescricao = sprintf('Tipo de processo no órgão de origem: %s', utf8_decode($objProcesso->processoDeNegocio)).PHP_EOL;
  651 + $strDescricao .= $objProcesso->observacao;
  652 +
  653 + $objObservacaoDTO = new ObservacaoDTO();
  654 +
  655 + //!Criação da observação de aviso para qual é a real unidade emitida (!2!)
  656 + if ($this->destinatarioReal) {
  657 + $objUnidadeDTO = new PenUnidadeDTO();
  658 + $objUnidadeDTO->setNumIdUnidadeRH($this->destinatarioReal->numeroDeIdentificacaoDaEstrutura);
  659 + $objUnidadeDTO->setStrSinAtivo('S');
  660 + $objUnidadeDTO->retStrDescricao();
  661 +
  662 + $objUnidadeRN = new UnidadeRN();
  663 + $objUnidadeDTO = $objUnidadeRN->consultarRN0125($objUnidadeDTO);
  664 + $objObservacaoDTO->setStrDescricao($strDescricao . PHP_EOL .'Processo remetido para a unidade ' . $objUnidadeDTO->getStrDescricao());
  665 + } else {
  666 + $objObservacaoDTO->setStrDescricao($strDescricao);
  667 + }
673 668  
674   - //throw new InfraException(var_export($objObservacaoDTO, true));
  669 + //throw new InfraException(var_export($objObservacaoDTO, true));
675 670  
676   - $objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO));
  671 + $objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO));
677 672  
678 673 //Atribuição de dados do procedimento
679 674 //TODO: Validar cada uma das informações de entrada do webservice
680   - $objProcedimentoDTO = new ProcedimentoDTO();
681   - $objProcedimentoDTO->setDblIdProcedimento(null);
682   - $objProcedimentoDTO->setObjProtocoloDTO($objProtocoloDTO);
683   - $objProcedimentoDTO->setStrNomeTipoProcedimento(utf8_decode($objProcesso->processoDeNegocio));
684   - $objProcedimentoDTO->setDtaGeracaoProtocolo($this->objProcessoEletronicoRN->converterDataSEI($objProcesso->dataHoraDeProducao));
685   - $objProcedimentoDTO->setStrProtocoloProcedimentoFormatado(utf8_decode($objProcesso->protocolo));
686   - $objProcedimentoDTO->setStrSinGerarPendencia('S');
  675 + $objProcedimentoDTO = new ProcedimentoDTO();
  676 + $objProcedimentoDTO->setDblIdProcedimento(null);
  677 + $objProcedimentoDTO->setObjProtocoloDTO($objProtocoloDTO);
  678 + $objProcedimentoDTO->setStrNomeTipoProcedimento(utf8_decode($objProcesso->processoDeNegocio));
  679 + $objProcedimentoDTO->setDtaGeracaoProtocolo($this->objProcessoEletronicoRN->converterDataSEI($objProcesso->dataHoraDeProducao));
  680 + $objProcedimentoDTO->setStrProtocoloProcedimentoFormatado(utf8_decode($objProcesso->protocolo));
  681 + $objProcedimentoDTO->setStrSinGerarPendencia('S');
687 682 // $objProcedimentoDTO->setNumVersaoLock(0); //TODO: Avaliar o comportamento desse campo no cadastro do processo
688 683 $objProcedimentoDTO->setArrObjDocumentoDTO(array());
689 684  
... ... @@ -737,10 +732,10 @@ class ReceberProcedimentoRN extends InfraRN
737 732  
738 733 //$this->removerAndamentosProcedimento($objProcedimentoDTO);
739 734 return $objProcedimentoDTO;
740   - }
741   -
742   - private function alterarMetadadosProcedimento($parNumIdProcedimento, $parObjMetadadoProcedimento){
  735 + }
743 736  
  737 + private function alterarMetadadosProcedimento($parNumIdProcedimento, $parObjMetadadoProcedimento)
  738 + {
744 739 //Realiza a alteração dos metadados do processo(Por hora, apenas do nível de sigilo e hipótese legal)
745 740 $objProtocoloDTO = new ProtocoloDTO();
746 741 $objProtocoloDTO->setDblIdProtocolo($parNumIdProcedimento);
... ... @@ -766,12 +761,11 @@ class ReceberProcedimentoRN extends InfraRN
766 761  
767 762 $objProtocoloRN = new ProtocoloRN();
768 763 $objProtocoloRN->alterarRN0203($objProtocoloDTO);
769   -
770 764 }
771 765  
772 766  
773   - private function removerAndamentosProcedimento($parObjProtocoloDTO)
774   - {
  767 + private function removerAndamentosProcedimento($parObjProtocoloDTO)
  768 + {
775 769 //TODO: Remover apenas as atividades geradas pelo recebimento do processo, não as atividades geradas anteriormente
776 770 $objAtividadeDTO = new AtividadeDTO();
777 771 $objAtividadeDTO->retNumIdAtividade();
... ... @@ -780,10 +774,10 @@ class ReceberProcedimentoRN extends InfraRN
780 774  
781 775 $objAtividadeRN = new AtividadeRN();
782 776 $objAtividadeRN->excluirRN0034($objAtividadeRN->listarRN0036($objAtividadeDTO));
783   - }
  777 + }
784 778  
785   - private function registrarAndamentoRecebimentoProcesso(ProcedimentoDTO $objProcedimentoDTO, $parObjMetadadosProcedimento)
786   - {
  779 + private function registrarAndamentoRecebimentoProcesso(ProcedimentoDTO $objProcedimentoDTO, $parObjMetadadosProcedimento)
  780 + {
787 781 //Processo recebido da entidade @ENTIDADE_ORIGEM@ - @REPOSITORIO_ORIGEM@
788 782 //TODO: Atribuir atributos necessários para formação da mensagem do andamento
789 783 //TODO: Especificar quais andamentos serão registrados
... ... @@ -798,9 +792,9 @@ class ReceberProcedimentoRN extends InfraRN
798 792  
799 793 //TODO: Otimizar código. Apenas buscar no barramento os dados da estrutura 1 única vez (AtribuirRemetente também utiliza)
800 794 $objEstrutura = $this->objProcessoEletronicoRN->consultarEstrutura(
801   - $objRemetente->identificacaoDoRepositorioDeEstruturas,
802   - $objRemetente->numeroDeIdentificacaoDaEstrutura,
803   - true
  795 + $objRemetente->identificacaoDoRepositorioDeEstruturas,
  796 + $objRemetente->numeroDeIdentificacaoDaEstrutura,
  797 + true
804 798 );
805 799  
806 800 $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
... ... @@ -864,68 +858,65 @@ class ReceberProcedimentoRN extends InfraRN
864 858 $objAtividadeRN = new AtividadeRN();
865 859 $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
866 860  
867   -
868   -
869   - }
  861 + }
870 862  
871 863  
872 864 //TODO: Avaliar a necessidade de registrar os dados do remetente como participante do processo
873   - private function atribuirRemetente(ProtocoloDTO $objProtocoloDTO, $objRemetente)
874   - {
  865 + private function atribuirRemetente(ProtocoloDTO $objProtocoloDTO, $objRemetente)
  866 + {
875 867 $arrObjParticipantesDTO = array();
876 868 if($objProtocoloDTO->isSetArrObjParticipanteDTO()) {
877   - $arrObjParticipantesDTO = $objProtocoloDTO->getArrObjParticipanteDTO();
  869 + $arrObjParticipantesDTO = $objProtocoloDTO->getArrObjParticipanteDTO();
878 870 }
879 871  
880 872 //Obtenção de detalhes do remetente na infraestrutura do PEN
881 873 $objEstruturaDTO = $this->objProcessoEletronicoRN->consultarEstrutura(
882   - $objRemetente->identificacaoDoRepositorioDeEstruturas,
883   - $objRemetente->numeroDeIdentificacaoDaEstrutura);
  874 + $objRemetente->identificacaoDoRepositorioDeEstruturas,
  875 + $objRemetente->numeroDeIdentificacaoDaEstrutura);
884 876  
885 877 if(!empty($objEstruturaDTO)) {
886   - $objParticipanteDTO = new ParticipanteDTO();
887   - $objParticipanteDTO->setStrSiglaContato($objEstruturaDTO->getStrSigla());
888   - $objParticipanteDTO->setStrNomeContato($objEstruturaDTO->getStrNome());
889   - $objParticipanteDTO->setStrStaParticipacao(ParticipanteRN::$TP_REMETENTE);
890   - $objParticipanteDTO->setNumSequencia(0);
891   - $arrObjParticipantesDTO[] = $objParticipanteDTO;
892   - $arrObjParticipantesDTO = $this->prepararParticipantes($arrObjParticipantesDTO);
  878 + $objParticipanteDTO = new ParticipanteDTO();
  879 + $objParticipanteDTO->setStrSiglaContato($objEstruturaDTO->getStrSigla());
  880 + $objParticipanteDTO->setStrNomeContato($objEstruturaDTO->getStrNome());
  881 + $objParticipanteDTO->setStrStaParticipacao(ParticipanteRN::$TP_REMETENTE);
  882 + $objParticipanteDTO->setNumSequencia(0);
  883 + $arrObjParticipantesDTO[] = $objParticipanteDTO;
  884 + $arrObjParticipantesDTO = $this->prepararParticipantes($arrObjParticipantesDTO);
893 885 }
894 886  
895 887 $objProtocoloDTO->setArrObjParticipanteDTO($arrObjParticipantesDTO);
896   - }
  888 + }
897 889  
898 890  
899   - private function atribuirParticipantes(ProtocoloDTO $objProtocoloDTO, $arrObjInteressados)
900   - {
  891 + private function atribuirParticipantes(ProtocoloDTO $objProtocoloDTO, $arrObjInteressados)
  892 + {
901 893 $arrObjParticipantesDTO = array();
902 894 if($objProtocoloDTO->isSetArrObjParticipanteDTO()) {
903   - $arrObjParticipantesDTO = $objProtocoloDTO->getArrObjParticipanteDTO();
  895 + $arrObjParticipantesDTO = $objProtocoloDTO->getArrObjParticipanteDTO();
904 896 }
905 897  
906 898 if (!is_array($arrObjInteressados)) {
907   - $arrObjInteressados = array($arrObjInteressados);
  899 + $arrObjInteressados = array($arrObjInteressados);
908 900 }
909 901  
910 902 for($i=0; $i < count($arrObjInteressados); $i++){
911   - $objInteressado = $arrObjInteressados[$i];
912   - $objParticipanteDTO = new ParticipanteDTO();
913   - $objParticipanteDTO->setStrSiglaContato($objInteressado->numeroDeIdentificacao);
914   - $objParticipanteDTO->setStrNomeContato(utf8_decode($objInteressado->nome));
915   - $objParticipanteDTO->setStrStaParticipacao(ParticipanteRN::$TP_INTERESSADO);
916   - $objParticipanteDTO->setNumSequencia($i);
917   - $arrObjParticipantesDTO[] = $objParticipanteDTO;
  903 + $objInteressado = $arrObjInteressados[$i];
  904 + $objParticipanteDTO = new ParticipanteDTO();
  905 + $objParticipanteDTO->setStrSiglaContato($objInteressado->numeroDeIdentificacao);
  906 + $objParticipanteDTO->setStrNomeContato(utf8_decode($objInteressado->nome));
  907 + $objParticipanteDTO->setStrStaParticipacao(ParticipanteRN::$TP_INTERESSADO);
  908 + $objParticipanteDTO->setNumSequencia($i);
  909 + $arrObjParticipantesDTO[] = $objParticipanteDTO;
918 910 }
919 911  
920 912 $arrObjParticipanteDTO = $this->prepararParticipantes($arrObjParticipantesDTO);
921 913 $objProtocoloDTO->setArrObjParticipanteDTO($arrObjParticipantesDTO);
  914 + }
922 915  
923   - }
924   -
925   - private function atribuirTipoProcedimento(ProcedimentoDTO $objProcedimentoDTO, $numIdTipoProcedimento)
926   - {
  916 + private function atribuirTipoProcedimento(ProcedimentoDTO $objProcedimentoDTO, $numIdTipoProcedimento)
  917 + {
927 918 if(!isset($numIdTipoProcedimento)){
928   - throw new InfraException('Parâmetro $numIdTipoProcedimento não informado.');
  919 + throw new InfraException('Parâmetro $numIdTipoProcedimento não informado.');
929 920 }
930 921  
931 922 $objTipoProcedimentoDTO = new TipoProcedimentoDTO();
... ... @@ -937,7 +928,7 @@ class ReceberProcedimentoRN extends InfraRN
937 928 $objTipoProcedimentoDTO = $objTipoProcedimentoRN->consultarRN0267($objTipoProcedimentoDTO);
938 929  
939 930 if ($objTipoProcedimentoDTO==null){
940   - throw new InfraException('Tipo de processo não encontrado.');
  931 + throw new InfraException('Tipo de processo não encontrado.');
941 932 }
942 933  
943 934 $objProcedimentoDTO->setNumIdTipoProcedimento($objTipoProcedimentoDTO->getNumIdTipoProcedimento());
... ... @@ -954,54 +945,55 @@ class ReceberProcedimentoRN extends InfraRN
954 945 $arrObjAssuntoDTO = $objProcedimentoDTO->getObjProtocoloDTO()->getArrObjRelProtocoloAssuntoDTO();
955 946  
956 947 foreach($arrObjRelTipoProcedimentoAssuntoDTO as $objRelTipoProcedimentoAssuntoDTO){
957   - $objRelProtocoloAssuntoDTO = new RelProtocoloAssuntoDTO();
958   - $objRelProtocoloAssuntoDTO->setNumIdAssunto($objRelTipoProcedimentoAssuntoDTO->getNumIdAssunto());
959   - $objRelProtocoloAssuntoDTO->setNumSequencia($objRelTipoProcedimentoAssuntoDTO->getNumSequencia());
960   - $arrObjAssuntoDTO[] = $objRelProtocoloAssuntoDTO;
  948 + $objRelProtocoloAssuntoDTO = new RelProtocoloAssuntoDTO();
  949 + $objRelProtocoloAssuntoDTO->setNumIdAssunto($objRelTipoProcedimentoAssuntoDTO->getNumIdAssunto());
  950 + $objRelProtocoloAssuntoDTO->setNumSequencia($objRelTipoProcedimentoAssuntoDTO->getNumSequencia());
  951 + $arrObjAssuntoDTO[] = $objRelProtocoloAssuntoDTO;
961 952 }
962 953  
963 954 $objProcedimentoDTO->getObjProtocoloDTO()->setArrObjRelProtocoloAssuntoDTO($arrObjAssuntoDTO);
964   - }
  955 + }
965 956  
966   - protected function atribuirDadosUnidade(ProcedimentoDTO $objProcedimentoDTO, $objDestinatario){
  957 + protected function atribuirDadosUnidade(ProcedimentoDTO $objProcedimentoDTO, $objDestinatario)
  958 + {
967 959  
968 960 if(!isset($objDestinatario)){
969   - throw new InfraException('Parâmetro $objDestinatario não informado.');
  961 + throw new InfraException('Parâmetro $objDestinatario não informado.');
970 962 }
971 963  
972 964 $objUnidadeDTOEnvio = $this->obterUnidadeMapeada($objDestinatario->numeroDeIdentificacaoDaEstrutura);
973 965  
974 966 if(!isset($objUnidadeDTOEnvio))
975   - throw new InfraException('Unidade de destino não pode ser encontrada. Repositório: '.$objDestinatario->identificacaoDoRepositorioDeEstruturas.', Número: ' . $objDestinatario->numeroDeIdentificacaoDaEstrutura);
  967 + throw new InfraException('Unidade de destino não pode ser encontrada. Repositório: '.$objDestinatario->identificacaoDoRepositorioDeEstruturas.', Número: ' . $objDestinatario->numeroDeIdentificacaoDaEstrutura);
976 968  
977 969 $arrObjUnidadeDTO = array();
978 970 $arrObjUnidadeDTO[] = $objUnidadeDTOEnvio;
979 971 $objProcedimentoDTO->setArrObjUnidadeDTO($arrObjUnidadeDTO);
980 972  
981 973 return $objUnidadeDTOEnvio;
982   - }
  974 + }
983 975  
984 976  
985 977 //TODO: Grande parte da regra de negócio se baseou em SEIRN:199 - incluirDocumento.
986 978 //Avaliar a refatoração para impedir a duplicação de código
987   - private function atribuirDocumentos($objProcedimentoDTO, $objProcesso, $objUnidadeDTO, $parObjMetadadosProcedimento)
988   - {
  979 + private function atribuirDocumentos($objProcedimentoDTO, $objProcesso, $objUnidadeDTO, $parObjMetadadosProcedimento)
  980 + {
989 981  
990 982 if(!isset($objProcesso)) {
991   - throw new InfraException('Parâmetro $objProcesso não informado.');
  983 + throw new InfraException('Parâmetro $objProcesso não informado.');
992 984 }
993 985  
994 986 if(!isset($objUnidadeDTO)) {
995   - throw new InfraException('Unidade responsável pelo documento não informada.');
  987 + throw new InfraException('Unidade responsável pelo documento não informada.');
996 988 }
997 989  
998 990 if(!isset($objProcesso->documento)) {
999   - throw new InfraException('Lista de documentos do processo não informada.');
  991 + throw new InfraException('Lista de documentos do processo não informada.');
1000 992 }
1001 993  
1002 994 $arrObjDocumentos = $objProcesso->documento;
1003 995 if(!is_array($arrObjDocumentos)) {
1004   - $arrObjDocumentos = array($arrObjDocumentos);
  996 + $arrObjDocumentos = array($arrObjDocumentos);
1005 997 }
1006 998  
1007 999 $strNumeroRegistro = $parObjMetadadosProcedimento->metadados->NRE;
... ... @@ -1021,7 +1013,6 @@ class ReceberProcedimentoRN extends InfraRN
1021 1013 $objComponenteDigitalBD = new ComponenteDigitalBD($this->getObjInfraIBanco());
1022 1014 $arrObjComponenteDigitalDTO = $objComponenteDigitalBD->listar($objComponenteDigitalDTO);
1023 1015 $arrObjComponenteDigitalDTOIndexado = InfraArray::indexarArrInfraDTO($arrObjComponenteDigitalDTO, "Ordem");
1024   - // $arrStrHashConteudo = InfraArray::converterArrInfraDTO($arrObjComponenteDigitalDTO, 'IdDocumento', 'HashConteudo');
1025 1016  
1026 1017 $objProtocoloBD = new ProtocoloBD($this->getObjInfraIBanco());
1027 1018 $objSeiRN = new SeiRN();
... ... @@ -1031,159 +1022,152 @@ class ReceberProcedimentoRN extends InfraRN
1031 1022 foreach($arrObjDocumentos as $objDocumento){
1032 1023  
1033 1024 // @join_tec US027 (#3498)
1034   - if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {
1035   -
  1025 + if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {
1036 1026 //$strHashConteudo = ProcessoEletronicoRN::getHashFromMetaDados($objDocumento->componenteDigital->hash);
1037   -
1038   -
1039 1027 // Caso já esteja cadastrado, de um reenvio anterior, então move para bloqueado
1040   - if(array_key_exists($objDocumento->ordem, $arrObjComponenteDigitalDTOIndexado)) {
  1028 + if(array_key_exists($objDocumento->ordem, $arrObjComponenteDigitalDTOIndexado)) {
1041 1029  
1042 1030 //Busca o ID do protocolo
1043 1031 //$dblIdProtocolo = $arrStrHashConteudo[$strHashConteudo];
1044   - $objComponenteIndexado = $arrObjComponenteDigitalDTOIndexado[$objDocumento->ordem];
1045   - $dblIdProtocolo = $objComponenteIndexado->getDblIdDocumento();
  1032 + $objComponenteIndexado = $arrObjComponenteDigitalDTOIndexado[$objDocumento->ordem];
  1033 + $dblIdProtocolo = $objComponenteIndexado->getDblIdDocumento();
1046 1034  
1047 1035 //Instancia o DTO do protocolo
1048   - $objProtocoloDTO = new ProtocoloDTO();
1049   - $objProtocoloDTO->setDblIdProtocolo($dblIdProtocolo);
1050   - $objProtocoloDTO->retStrStaEstado();
  1036 + $objProtocoloDTO = new ProtocoloDTO();
  1037 + $objProtocoloDTO->setDblIdProtocolo($dblIdProtocolo);
  1038 + $objProtocoloDTO->retStrStaEstado();
1051 1039  
1052   - $objProtocoloDTO = $objProtocoloBD->consultar($objProtocoloDTO);
  1040 + $objProtocoloDTO = $objProtocoloBD->consultar($objProtocoloDTO);
1053 1041  
1054   - if($objProtocoloDTO->getStrStaEstado() != ProtocoloRN::$TE_DOCUMENTO_CANCELADO){
  1042 + if($objProtocoloDTO->getStrStaEstado() != ProtocoloRN::$TE_DOCUMENTO_CANCELADO){
1055 1043 //Instancia o DTO do protocolo
1056   - $objEntradaCancelarDocumentoAPI = new EntradaCancelarDocumentoAPI();
1057   - $objEntradaCancelarDocumentoAPI->setIdDocumento($dblIdProtocolo);
1058   - $objEntradaCancelarDocumentoAPI->setMotivo('Cancelado pelo remetente');
  1044 + $objEntradaCancelarDocumentoAPI = new EntradaCancelarDocumentoAPI();
  1045 + $objEntradaCancelarDocumentoAPI->setIdDocumento($dblIdProtocolo);
  1046 + $objEntradaCancelarDocumentoAPI->setMotivo('Cancelado pelo remetente');
1059 1047  
1060   - $objSeiRN->cancelarDocumento($objEntradaCancelarDocumentoAPI);
  1048 + $objSeiRN->cancelarDocumento($objEntradaCancelarDocumentoAPI);
1061 1049  
1062   - }
  1050 + }
  1051 + continue;
  1052 + }
  1053 + }
1063 1054  
  1055 + if(array_key_exists($objDocumento->ordem, $arrObjComponenteDigitalDTOIndexado)){
  1056 + $objComponenteDigitalDTO = $arrObjComponenteDigitalDTOIndexado[$objDocumento->ordem];
  1057 + $this->alterarMetadadosDocumento($objComponenteDigitalDTO->getDblIdDocumento(), $objDocumento);
  1058 + continue;
  1059 + }
1064 1060  
1065   - continue;
  1061 + //Validação dos dados dos documentos
  1062 + if(!isset($objDocumento->especie)){
  1063 + throw new InfraException('Espécie do documento ['.$objDocumento->descricao.'] não informada.');
  1064 +}
1066 1065  
1067   - }
1068   - //continue;
1069   - }
  1066 +//---------------------------------------------------------------------------------------------------
1070 1067  
1071   - if(array_key_exists($objDocumento->ordem, $arrObjComponenteDigitalDTOIndexado)){
1072   - $objComponenteDigitalDTO = $arrObjComponenteDigitalDTOIndexado[$objDocumento->ordem];
1073   - $this->alterarMetadadosDocumento($objComponenteDigitalDTO->getDblIdDocumento(), $objDocumento);
1074   - continue;
1075   - }
  1068 +$objDocumentoDTO = new DocumentoDTO();
  1069 +$objDocumentoDTO->setDblIdDocumento(null);
  1070 +$objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento());
1076 1071  
1077   - //Validação dos dados dos documentos
1078   - if(!isset($objDocumento->especie)){
1079   - throw new InfraException('Espécie do documento ['.$objDocumento->descricao.'] não informada.');
1080   - }
  1072 +$objSerieDTO = $this->obterSerieMapeada($objDocumento->especie->codigo);
1081 1073  
1082   -//---------------------------------------------------------------------------------------------------
  1074 +if ($objSerieDTO==null){
  1075 + throw new InfraException('Tipo de documento [Espécie '.$objDocumento->especie->codigo.'] não encontrado.');
  1076 +}
  1077 +
  1078 +if (InfraString::isBolVazia($objDocumento->dataHoraDeProducao)) {
  1079 + $objInfraException->lancarValidacao('Data do documento não informada.');
  1080 +}
  1081 +
  1082 +$objProcedimentoDTO2 = new ProcedimentoDTO();
  1083 +$objProcedimentoDTO2->retDblIdProcedimento();
  1084 +$objProcedimentoDTO2->retNumIdUsuarioGeradorProtocolo();
  1085 +$objProcedimentoDTO2->retNumIdTipoProcedimento();
  1086 +$objProcedimentoDTO2->retStrStaNivelAcessoGlobalProtocolo();
  1087 +$objProcedimentoDTO2->retStrProtocoloProcedimentoFormatado();
  1088 +$objProcedimentoDTO2->retNumIdTipoProcedimento();
  1089 +$objProcedimentoDTO2->retStrNomeTipoProcedimento();
  1090 +$objProcedimentoDTO2->adicionarCriterio(array('IdProcedimento','ProtocoloProcedimentoFormatado','ProtocoloProcedimentoFormatadoPesquisa'),
  1091 + array(InfraDTO::$OPER_IGUAL,InfraDTO::$OPER_IGUAL,InfraDTO::$OPER_IGUAL),
  1092 + array($objDocumentoDTO->getDblIdProcedimento(),$objDocumentoDTO->getDblIdProcedimento(),$objDocumentoDTO->getDblIdProcedimento()),
  1093 + array(InfraDTO::$OPER_LOGICO_OR,InfraDTO::$OPER_LOGICO_OR));
  1094 +
  1095 +$objProcedimentoRN = new ProcedimentoRN();
  1096 +$objProcedimentoDTO = $objProcedimentoRN->consultarRN0201($objProcedimentoDTO2);
  1097 +
  1098 +if ($objProcedimentoDTO==null){
  1099 + throw new InfraException('Processo ['.$objDocumentoDTO->getDblIdProcedimento().'] não encontrado.');
  1100 +}
  1101 +
  1102 +$objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento());
  1103 +$objDocumentoDTO->setNumIdSerie($objSerieDTO->getNumIdSerie());
  1104 +$objDocumentoDTO->setStrNomeSerie($objSerieDTO->getStrNome());
1083 1105  
1084   - $objDocumentoDTO = new DocumentoDTO();
1085   - $objDocumentoDTO->setDblIdDocumento(null);
1086   - $objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento());
1087   -
1088   - $objSerieDTO = $this->obterSerieMapeada($objDocumento->especie->codigo);
1089   -
1090   - if ($objSerieDTO==null){
1091   - throw new InfraException('Tipo de documento [Espécie '.$objDocumento->especie->codigo.'] não encontrado.');
1092   - }
1093   -
1094   - if (InfraString::isBolVazia($objDocumento->dataHoraDeProducao)) {
1095   - $objInfraException->lancarValidacao('Data do documento não informada.');
1096   - }
1097   -
1098   - $objProcedimentoDTO2 = new ProcedimentoDTO();
1099   - $objProcedimentoDTO2->retDblIdProcedimento();
1100   - $objProcedimentoDTO2->retNumIdUsuarioGeradorProtocolo();
1101   - $objProcedimentoDTO2->retNumIdTipoProcedimento();
1102   - $objProcedimentoDTO2->retStrStaNivelAcessoGlobalProtocolo();
1103   - $objProcedimentoDTO2->retStrProtocoloProcedimentoFormatado();
1104   - $objProcedimentoDTO2->retNumIdTipoProcedimento();
1105   - $objProcedimentoDTO2->retStrNomeTipoProcedimento();
1106   - $objProcedimentoDTO2->adicionarCriterio(array('IdProcedimento','ProtocoloProcedimentoFormatado','ProtocoloProcedimentoFormatadoPesquisa'),
1107   - array(InfraDTO::$OPER_IGUAL,InfraDTO::$OPER_IGUAL,InfraDTO::$OPER_IGUAL),
1108   - array($objDocumentoDTO->getDblIdProcedimento(),$objDocumentoDTO->getDblIdProcedimento(),$objDocumentoDTO->getDblIdProcedimento()),
1109   - array(InfraDTO::$OPER_LOGICO_OR,InfraDTO::$OPER_LOGICO_OR));
1110   -
1111   - $objProcedimentoRN = new ProcedimentoRN();
1112   - $objProcedimentoDTO = $objProcedimentoRN->consultarRN0201($objProcedimentoDTO2);
1113   -
1114   - if ($objProcedimentoDTO==null){
1115   - throw new InfraException('Processo ['.$objDocumentoDTO->getDblIdProcedimento().'] não encontrado.');
1116   - }
1117   -
1118   - $objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento());
1119   - $objDocumentoDTO->setNumIdSerie($objSerieDTO->getNumIdSerie());
1120   - $objDocumentoDTO->setStrNomeSerie($objSerieDTO->getStrNome());
1121   -
1122   - $objDocumentoDTO->setDblIdDocumentoEdoc(null);
1123   - $objDocumentoDTO->setDblIdDocumentoEdocBase(null);
1124   - $objDocumentoDTO->setNumIdUnidadeResponsavel($objUnidadeDTO->getNumIdUnidade());
1125   - $objDocumentoDTO->setNumIdTipoConferencia(null);
1126   - $objDocumentoDTO->setStrConteudo(null);
1127   - $objDocumentoDTO->setStrStaDocumento(DocumentoRN::$TD_EXTERNO);
  1106 +$objDocumentoDTO->setDblIdDocumentoEdoc(null);
  1107 +$objDocumentoDTO->setDblIdDocumentoEdocBase(null);
  1108 +$objDocumentoDTO->setNumIdUnidadeResponsavel($objUnidadeDTO->getNumIdUnidade());
  1109 +$objDocumentoDTO->setNumIdTipoConferencia(null);
  1110 +$objDocumentoDTO->setStrConteudo(null);
  1111 +$objDocumentoDTO->setStrStaDocumento(DocumentoRN::$TD_EXTERNO);
1128 1112 // $objDocumentoDTO->setNumVersaoLock(0);
1129 1113  
1130   - $objProtocoloDTO = new ProtocoloDTO();
1131   - $objDocumentoDTO->setObjProtocoloDTO($objProtocoloDTO);
1132   - $objProtocoloDTO->setDblIdProtocolo(null);
1133   - $objProtocoloDTO->setStrStaProtocolo(ProtocoloRN::$TP_DOCUMENTO_RECEBIDO);
1134   -
1135   - if($objDocumento->descricao != '***'){
1136   - $objProtocoloDTO->setStrDescricao(utf8_decode($objDocumento->descricao));
1137   - $objDocumentoDTO->setStrNumero(utf8_decode($objDocumento->descricao));
1138   - }else{
1139   - $objProtocoloDTO->setStrDescricao("");
1140   - $objDocumentoDTO->setStrNumero("");
1141   - }
  1114 +$objProtocoloDTO = new ProtocoloDTO();
  1115 +$objDocumentoDTO->setObjProtocoloDTO($objProtocoloDTO);
  1116 +$objProtocoloDTO->setDblIdProtocolo(null);
  1117 +$objProtocoloDTO->setStrStaProtocolo(ProtocoloRN::$TP_DOCUMENTO_RECEBIDO);
  1118 +
  1119 +if($objDocumento->descricao != '***'){
  1120 + $objProtocoloDTO->setStrDescricao(utf8_decode($objDocumento->descricao));
  1121 + $objDocumentoDTO->setStrNumero(utf8_decode($objDocumento->descricao));
  1122 +}else{
  1123 + $objProtocoloDTO->setStrDescricao("");
  1124 + $objDocumentoDTO->setStrNumero("");
  1125 +}
1142 1126 //TODO: Avaliar regra de formação do número do documento
1143 1127  
1144   - $objProtocoloDTO->setStrStaNivelAcessoLocal($this->obterNivelSigiloSEI($objDocumento->nivelDeSigilo));
1145   - $objProtocoloDTO->setDtaGeracao($this->objProcessoEletronicoRN->converterDataSEI($objDocumento->dataHoraDeProducao));
1146   - $objProtocoloDTO->setArrObjAnexoDTO(array());
1147   - $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());
1148   - $objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array());
1149   - $objProtocoloDTO->setArrObjParticipanteDTO(array());
  1128 +$objProtocoloDTO->setStrStaNivelAcessoLocal($this->obterNivelSigiloSEI($objDocumento->nivelDeSigilo));
  1129 +$objProtocoloDTO->setDtaGeracao($this->objProcessoEletronicoRN->converterDataSEI($objDocumento->dataHoraDeProducao));
  1130 +$objProtocoloDTO->setArrObjAnexoDTO(array());
  1131 +$objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());
  1132 +$objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array());
  1133 +$objProtocoloDTO->setArrObjParticipanteDTO(array());
1150 1134  
1151 1135 //TODO: Analisar se o modelo de dados do PEN possui destinatários específicos para os documentos
1152 1136 //caso não possua, analisar o repasse de tais informações via parãmetros adicionais
1153 1137  
1154   - $objObservacaoDTO = new ObservacaoDTO();
1155   - $objObservacaoDTO->setStrDescricao("Número SEI do Documento na Origem: ".$objDocumento->produtor->numeroDeIdentificacao);
1156   - $objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO));
  1138 +$objObservacaoDTO = new ObservacaoDTO();
  1139 +$objObservacaoDTO->setStrDescricao("Número SEI do Documento na Origem: ".$objDocumento->produtor->numeroDeIdentificacao);
  1140 +$objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO));
1157 1141  
1158 1142  
1159   - $bolReabriuAutomaticamente = false;
1160   - if ($objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_PUBLICO || $objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_RESTRITO) {
  1143 +$bolReabriuAutomaticamente = false;
  1144 +if ($objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_PUBLICO || $objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_RESTRITO) {
1161 1145  
1162   - $objAtividadeDTO = new AtividadeDTO();
1163   - $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
1164   - $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1146 + $objAtividadeDTO = new AtividadeDTO();
  1147 + $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
  1148 + $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1165 1149  
1166 1150 //TODO: Possivelmente, essa regra é desnecessária já que o processo pode ser enviado para outra unidade do órgão através da expedição
1167   - $objAtividadeRN = new AtividadeRN();
1168   - if ($objAtividadeRN->contarRN0035($objAtividadeDTO) == 0) {
1169   - throw new InfraException('Unidade '.$objUnidadeDTO->getStrSigla().' não possui acesso ao Procedimento '.$objProcedimentoDTO->getStrProtocoloProcedimentoFormatado().'.');
1170   - }
  1151 + $objAtividadeRN = new AtividadeRN();
  1152 + if ($objAtividadeRN->contarRN0035($objAtividadeDTO) == 0) {
  1153 + throw new InfraException('Unidade '.$objUnidadeDTO->getStrSigla().' não possui acesso ao Procedimento '.$objProcedimentoDTO->getStrProtocoloProcedimentoFormatado().'.');
  1154 + }
1171 1155  
1172   - $objAtividadeDTO = new AtividadeDTO();
1173   - $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
1174   - $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1175   - $objAtividadeDTO->setDthConclusao(null);
  1156 + $objAtividadeDTO = new AtividadeDTO();
  1157 + $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
  1158 + $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1159 + $objAtividadeDTO->setDthConclusao(null);
1176 1160  
1177   - if ($objAtividadeRN->contarRN0035($objAtividadeDTO) == 0) {
  1161 + if ($objAtividadeRN->contarRN0035($objAtividadeDTO) == 0) {
1178 1162 //reabertura automática
1179   - $objReabrirProcessoDTO = new ReabrirProcessoDTO();
1180   - $objReabrirProcessoDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());
1181   - $objReabrirProcessoDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1182   - $objReabrirProcessoDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
1183   - $objProcedimentoRN->reabrirRN0966($objReabrirProcessoDTO);
1184   - $bolReabriuAutomaticamente = true;
1185   - }
1186   - }
  1163 + $objReabrirProcessoDTO = new ReabrirProcessoDTO();
  1164 + $objReabrirProcessoDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());
  1165 + $objReabrirProcessoDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1166 + $objReabrirProcessoDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
  1167 + $objProcedimentoRN->reabrirRN0966($objReabrirProcessoDTO);
  1168 + $bolReabriuAutomaticamente = true;
  1169 + }
  1170 +}
1187 1171  
1188 1172 //$objOperacaoServicoDTO = new OperacaoServicoDTO();
1189 1173 //$this->adicionarCriteriosUnidadeProcessoDocumento ($objOperacaoServicoDTO,$objUnidadeDTO,$objProcedimentoDTO,$objDocumentoDTO);
... ... @@ -1195,239 +1179,228 @@ class ReceberProcedimentoRN extends InfraRN
1195 1179 // $objInfraException->lancarValidacao('Nenhuma operação configurada para inclusão de documento do Tipo ['.$objSerieDTO->getStrNome().'] no Tipo de Processo ['.$objProcedimentoDTO->getStrNomeTipoProcedimento().'] na Unidade ['.$objUnidadeDTO->getStrSigla().'] pelo Serviço ['.$objServicoDTO->getStrIdentificacao().'] do Sistema ['.$objServicoDTO->getStrSiglaUsuario().'].');
1196 1180 //}
1197 1181  
1198   - $objTipoProcedimentoDTO = new TipoProcedimentoDTO();
1199   - $objTipoProcedimentoDTO->retStrStaNivelAcessoSugestao();
1200   - $objTipoProcedimentoDTO->retStrStaGrauSigiloSugestao();
1201   - $objTipoProcedimentoDTO->retNumIdHipoteseLegalSugestao();
1202   - $objTipoProcedimentoDTO->setNumIdTipoProcedimento($objProcedimentoDTO->getNumIdTipoProcedimento());
  1182 +$objTipoProcedimentoDTO = new TipoProcedimentoDTO();
  1183 +$objTipoProcedimentoDTO->retStrStaNivelAcessoSugestao();
  1184 +$objTipoProcedimentoDTO->retStrStaGrauSigiloSugestao();
  1185 +$objTipoProcedimentoDTO->retNumIdHipoteseLegalSugestao();
  1186 +$objTipoProcedimentoDTO->setNumIdTipoProcedimento($objProcedimentoDTO->getNumIdTipoProcedimento());
1203 1187  
1204   - $objTipoProcedimentoRN = new TipoProcedimentoRN();
1205   - $objTipoProcedimentoDTO = $objTipoProcedimentoRN->consultarRN0267($objTipoProcedimentoDTO);
  1188 +$objTipoProcedimentoRN = new TipoProcedimentoRN();
  1189 +$objTipoProcedimentoDTO = $objTipoProcedimentoRN->consultarRN0267($objTipoProcedimentoDTO);
1206 1190  
1207   - if (InfraString::isBolVazia($objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal()) || $objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal()==$objTipoProcedimentoDTO->getStrStaNivelAcessoSugestao()) {
1208   - $objDocumentoDTO->getObjProtocoloDTO()->setStrStaNivelAcessoLocal($objTipoProcedimentoDTO->getStrStaNivelAcessoSugestao());
1209   - $objDocumentoDTO->getObjProtocoloDTO()->setStrStaGrauSigilo($objTipoProcedimentoDTO->getStrStaGrauSigiloSugestao());
1210   - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($objTipoProcedimentoDTO->getNumIdHipoteseLegalSugestao());
1211   - }
  1191 +if (InfraString::isBolVazia($objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal()) || $objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal()==$objTipoProcedimentoDTO->getStrStaNivelAcessoSugestao()) {
  1192 + $objDocumentoDTO->getObjProtocoloDTO()->setStrStaNivelAcessoLocal($objTipoProcedimentoDTO->getStrStaNivelAcessoSugestao());
  1193 + $objDocumentoDTO->getObjProtocoloDTO()->setStrStaGrauSigilo($objTipoProcedimentoDTO->getStrStaGrauSigiloSugestao());
  1194 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($objTipoProcedimentoDTO->getNumIdHipoteseLegalSugestao());
  1195 +}
1212 1196  
1213   - if ($this->obterNivelSigiloSEI($objDocumento->nivelDeSigilo) == ProtocoloRN::$NA_RESTRITO) {
1214   - $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
1215   - $objPenParametroRN = new PenParametroRN();
1216   - $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO');
  1197 +if ($this->obterNivelSigiloSEI($objDocumento->nivelDeSigilo) == ProtocoloRN::$NA_RESTRITO) {
  1198 + $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
  1199 + $objPenParametroRN = new PenParametroRN();
  1200 + $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO');
1217 1201  
1218   - if (!isset($objDocumento->hipoteseLegal) || (isset($objDocumento->hipoteseLegal) && empty($objDocumento->hipoteseLegal->identificacao))) {
1219   - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
1220   - } else {
  1202 + if (!isset($objDocumento->hipoteseLegal) || (isset($objDocumento->hipoteseLegal) && empty($objDocumento->hipoteseLegal->identificacao))) {
  1203 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
  1204 + } else {
1221 1205  
1222   - $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($objDocumento->hipoteseLegal->identificacao);
1223   - if (empty($numIdHipoteseLegal)) {
1224   - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
1225   - } else {
1226   - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegal);
1227   - }
1228   - }
1229   - }
  1206 + $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($objDocumento->hipoteseLegal->identificacao);
  1207 + if (empty($numIdHipoteseLegal)) {
  1208 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
  1209 + } else {
  1210 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegal);
  1211 + }
  1212 + }
  1213 +}
1230 1214  
1231   - $objDocumentoDTO->getObjProtocoloDTO()->setArrObjParticipanteDTO($this->prepararParticipantes($objDocumentoDTO->getObjProtocoloDTO()->getArrObjParticipanteDTO()));
  1215 +$objDocumentoDTO->getObjProtocoloDTO()->setArrObjParticipanteDTO($this->prepararParticipantes($objDocumentoDTO->getObjProtocoloDTO()->getArrObjParticipanteDTO()));
1232 1216  
1233   - $objDocumentoRN = new DocumentoRN();
  1217 +$objDocumentoRN = new DocumentoRN();
1234 1218  
1235   - $strConteudoCodificado = $objDocumentoDTO->getStrConteudo();
1236   - $objDocumentoDTO->setStrConteudo(null);
  1219 +$strConteudoCodificado = $objDocumentoDTO->getStrConteudo();
  1220 +$objDocumentoDTO->setStrConteudo(null);
1237 1221 //$objDocumentoDTO->setStrSinFormulario('N');
1238 1222  
1239   - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdUnidadeGeradora(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1240   - $objDocumentoDTO->setStrSinBloqueado('S');
  1223 +$objDocumentoDTO->getObjProtocoloDTO()->setNumIdUnidadeGeradora(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1224 +$objDocumentoDTO->setStrSinBloqueado('S');
1241 1225  
1242 1226 //TODO: Fazer a atribuição dos componentes digitais do processo a partir desse ponto
1243   - $this->atribuirComponentesDigitais($objDocumentoDTO, $objDocumento->componenteDigital);
1244   - $objDocumentoDTOGerado = $objDocumentoRN->cadastrarRN0003($objDocumentoDTO);
  1227 +$this->atribuirComponentesDigitais($objDocumentoDTO, $objDocumento->componenteDigital);
  1228 +$objDocumentoDTOGerado = $objDocumentoRN->cadastrarRN0003($objDocumentoDTO);
1245 1229  
1246   - $objAtividadeDTOVisualizacao = new AtividadeDTO();
1247   - $objAtividadeDTOVisualizacao->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
1248   - $objAtividadeDTOVisualizacao->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1230 +$objAtividadeDTOVisualizacao = new AtividadeDTO();
  1231 +$objAtividadeDTOVisualizacao->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
  1232 +$objAtividadeDTOVisualizacao->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1249 1233  
1250   - if (!$bolReabriuAutomaticamente){
1251   - $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_ATENCAO);
1252   - }else{
1253   - $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_NAO_VISUALIZADO | AtividadeRN::$TV_ATENCAO);
1254   - }
  1234 +if (!$bolReabriuAutomaticamente){
  1235 + $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_ATENCAO);
  1236 +}else{
  1237 + $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_NAO_VISUALIZADO | AtividadeRN::$TV_ATENCAO);
  1238 +}
1255 1239  
1256   - $objAtividadeRN = new AtividadeRN();
1257   - $objAtividadeRN->atualizarVisualizacaoUnidade($objAtividadeDTOVisualizacao);
  1240 +$objAtividadeRN = new AtividadeRN();
  1241 +$objAtividadeRN->atualizarVisualizacaoUnidade($objAtividadeDTOVisualizacao);
1258 1242  
1259   - $objDocumento->idDocumentoSEI = $objDocumentoDTO->getDblIdDocumento();
1260   - $arrObjDocumentoDTO[] = $objDocumentoDTO;
  1243 +$objDocumento->idDocumentoSEI = $objDocumentoDTO->getDblIdDocumento();
  1244 +$arrObjDocumentoDTO[] = $objDocumentoDTO;
1261 1245  
1262   - if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {
1263   - $this->documentosRetirados[] = $objDocumento->idDocumentoSEI;
1264   - }
  1246 +if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {
  1247 + $this->documentosRetirados[] = $objDocumento->idDocumentoSEI;
  1248 +}
1265 1249  
1266   - }
  1250 +}
1267 1251  
1268   - foreach($this->documentosRetirados as $documentoCancelado){
  1252 +foreach($this->documentosRetirados as $documentoCancelado){
1269 1253 //Instancia o DTO do protocolo
1270   - $objEntradaCancelarDocumentoAPI = new EntradaCancelarDocumentoAPI();
1271   - $objEntradaCancelarDocumentoAPI->setIdDocumento($documentoCancelado);
1272   - $objEntradaCancelarDocumentoAPI->setMotivo('Cancelado pelo remetente');
1273   - $objSeiRN = new SeiRN();
1274   - $objSeiRN->cancelarDocumento($objEntradaCancelarDocumentoAPI);
1275   - }
  1254 + $objEntradaCancelarDocumentoAPI = new EntradaCancelarDocumentoAPI();
  1255 + $objEntradaCancelarDocumentoAPI->setIdDocumento($documentoCancelado);
  1256 + $objEntradaCancelarDocumentoAPI->setMotivo('Cancelado pelo remetente');
  1257 + $objSeiRN = new SeiRN();
  1258 + $objSeiRN->cancelarDocumento($objEntradaCancelarDocumentoAPI);
  1259 +}
1276 1260  
1277   - $objProcedimentoDTO->setArrObjDocumentoDTO($arrObjDocumentoDTO);
  1261 +$objProcedimentoDTO->setArrObjDocumentoDTO($arrObjDocumentoDTO);
1278 1262  
1279 1263 /* if($numIdUnidadeAtual != $numIdUnidadeGeradora){
1280 1264 SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $numIdUnidadeAtual);
1281 1265 } */
1282   - }
  1266 + }
1283 1267  
1284 1268 //TODO: Método deverá poderá ser transferido para a classe responsável por fazer o recebimento dos componentes digitais
1285   - private function atribuirComponentesDigitais(DocumentoDTO $parObjDocumentoDTO, $parArrObjComponentesDigitais)
1286   - {
  1269 + private function atribuirComponentesDigitais(DocumentoDTO $parObjDocumentoDTO, $parArrObjComponentesDigitais)
  1270 + {
1287 1271 if(!isset($parArrObjComponentesDigitais)) {
1288 1272 throw new InfraException('Componentes digitais do documento não informado.');
1289   - }
  1273 + }
1290 1274  
1291 1275 //TODO: Aplicar mesmas validações realizadas no momento do upload de um documento InfraPagina::processarUpload
1292 1276 //TODO: Avaliar a refatoração do código abaixo para impedir a duplicação de regras de negócios
1293 1277  
1294 1278  
1295   - $arrObjAnexoDTO = array();
1296   - if($parObjDocumentoDTO->getObjProtocoloDTO()->isSetArrObjAnexoDTO()) {
  1279 + $arrObjAnexoDTO = array();
  1280 + if($parObjDocumentoDTO->getObjProtocoloDTO()->isSetArrObjAnexoDTO()) {
1297 1281 $arrObjAnexoDTO = $parObjDocumentoDTO->getObjProtocoloDTO()->getArrObjAnexoDTO();
1298   - }
  1282 + }
1299 1283  
1300   - if (!is_array($parArrObjComponentesDigitais)) {
  1284 + if (!is_array($parArrObjComponentesDigitais)) {
1301 1285 $parArrObjComponentesDigitais = array($parArrObjComponentesDigitais);
1302   - }
  1286 + }
1303 1287  
1304 1288 //TODO: Tratar a ordem dos componentes digitais
1305 1289 //...
1306 1290  
1307 1291  
1308   - $parObjDocumentoDTO->getObjProtocoloDTO()->setArrObjAnexoDTO($arrObjAnexoDTO);
1309   - }
  1292 + $parObjDocumentoDTO->getObjProtocoloDTO()->setArrObjAnexoDTO($arrObjAnexoDTO);
  1293 + }
1310 1294  
1311   - private function atribuirAssunto(ProtocoloDTO $objProtocoloDTO, $numIdAssunto)
1312   - {
  1295 + private function atribuirAssunto(ProtocoloDTO $objProtocoloDTO, $numIdAssunto)
  1296 + {
1313 1297 //TODO: Removido. Serão utilizados os tipos de procedimento enviados atribuídos ao tipo de processo externo (PEN_TIPO_PROCESSO_EXTERNO)
1314   - }
  1298 + }
1315 1299  
1316   - private function atribuirProcessosApensados(ProcedimentoDTO $objProtocoloDTO, $objProcedimento)
1317   - {
1318   - if(isset($objProcedimento->processoApensado)) {
1319   - if(!is_array($objProcedimento->processoApensado)){
  1300 + private function atribuirProcessosApensados(ProcedimentoDTO $objProtocoloDTO, $objProcedimento)
  1301 + {
  1302 + if(isset($objProcedimento->processoApensado)) {
  1303 + if(!is_array($objProcedimento->processoApensado)){
1320 1304 $objProcedimento->processoApensado = array($objProcedimento->processoApensado);
1321   - }
  1305 + }
1322 1306  
1323   - $objProcedimentoDTOApensado = null;
1324   - foreach ($objProcedimento->processoApensado as $processoApensado) {
  1307 + $objProcedimentoDTOApensado = null;
  1308 + foreach ($objProcedimento->processoApensado as $processoApensado) {
1325 1309 $objProcedimentoDTOApensado = $this->gerarProcedimento($objMetadadosProcedimento, $processoApensado);
1326 1310 $this->relacionarProcedimentos($objProcedimentoDTOPrincipal, $objProcedimentoDTOApensado);
1327 1311 $this->registrarProcedimentoNaoVisualizado($objProcedimentoDTOApensado);
1328   - }
1329 1312 }
1330   - }
1331   -
1332   - private function bloquearProcedimento($objProcesso){
1333   -
1334   - }
1335   -
1336   - private function atribuirDataHoraDeRegistro(){
1337   -
1338   - }
1339   -
1340   - private function cadastrarTramiteDeProcesso($objTramite, $objProcesso){
1341   -
1342   - }
  1313 + }
  1314 +}
1343 1315  
1344   - private function validarDadosDestinatario(InfraException $objInfraException, $objMetadadosProcedimento){
1345 1316  
1346   - if(isset($objDestinatario)){
1347   - throw new InfraException("Parâmetro $objDestinatario não informado.");
1348   - }
  1317 +private function validarDadosDestinatario(InfraException $objInfraException, $objMetadadosProcedimento)
  1318 +{
  1319 + if(isset($objDestinatario)){
  1320 + throw new InfraException("Parâmetro $objDestinatario não informado.");
  1321 + }
1349 1322  
1350   - $objDestinatario = $objMetadadosProcedimento->metadados->destinatario;
  1323 + $objDestinatario = $objMetadadosProcedimento->metadados->destinatario;
1351 1324  
1352   - $objPenParametroRN = new PenParametroRN();
1353   - $numIdRepositorioOrigem = $objPenParametroRN->getParametro('PEN_ID_REPOSITORIO_ORIGEM');
1354   - $numIdRepositorioDestinoProcesso = $objDestinatario->identificacaoDoRepositorioDeEstruturas;
1355   - $numeroDeIdentificacaoDaEstrutura = $objDestinatario->numeroDeIdentificacaoDaEstrutura;
  1325 + $objPenParametroRN = new PenParametroRN();
  1326 + $numIdRepositorioOrigem = $objPenParametroRN->getParametro('PEN_ID_REPOSITORIO_ORIGEM');
  1327 + $numIdRepositorioDestinoProcesso = $objDestinatario->identificacaoDoRepositorioDeEstruturas;
  1328 + $numeroDeIdentificacaoDaEstrutura = $objDestinatario->numeroDeIdentificacaoDaEstrutura;
1356 1329  
1357 1330 //Validação do repositório de destino do processo
1358   - if($numIdRepositorioDestinoProcesso != $numIdRepositorioOrigem){
1359   - $objInfraException->adicionarValidacao("Identificação do repositório de origem do processo [$numIdRepositorioDestinoProcesso] não reconhecida.");
1360   - }
  1331 + if($numIdRepositorioDestinoProcesso != $numIdRepositorioOrigem){
  1332 + $objInfraException->adicionarValidacao("Identificação do repositório de origem do processo [$numIdRepositorioDestinoProcesso] não reconhecida.");
  1333 + }
1361 1334  
1362 1335 //Validação do unidade de destino do processo
1363   - $objUnidadeDTO = new PenUnidadeDTO();
1364   - $objUnidadeDTO->setNumIdUnidadeRH($numeroDeIdentificacaoDaEstrutura);
1365   - $objUnidadeDTO->setStrSinAtivo('S');
1366   - $objUnidadeDTO->retNumIdUnidade();
  1336 + $objUnidadeDTO = new PenUnidadeDTO();
  1337 + $objUnidadeDTO->setNumIdUnidadeRH($numeroDeIdentificacaoDaEstrutura);
  1338 + $objUnidadeDTO->setStrSinAtivo('S');
  1339 + $objUnidadeDTO->retNumIdUnidade();
1367 1340  
1368   - $objUnidadeRN = new UnidadeRN();
1369   - $objUnidadeDTO = $objUnidadeRN->consultarRN0125($objUnidadeDTO);
  1341 + $objUnidadeRN = new UnidadeRN();
  1342 + $objUnidadeDTO = $objUnidadeRN->consultarRN0125($objUnidadeDTO);
1370 1343  
1371   - if(!isset($objUnidadeDTO)){
1372   - $objInfraException->adicionarValidacao("Unidade [Estrutura: {$numeroDeIdentificacaoDaEstrutura}] não configurada para receber processos externos no sistema de destino.");
1373   - }
1374   - }
  1344 + if(!isset($objUnidadeDTO)){
  1345 + $objInfraException->adicionarValidacao("Unidade [Estrutura: {$numeroDeIdentificacaoDaEstrutura}] não configurada para receber processos externos no sistema de destino.");
  1346 + }
  1347 +}
1375 1348  
1376   - private function validarDadosRemetente(InfraException $objInfraException, $objMetadadosProcedimento){
  1349 +private function validarDadosRemetente(InfraException $objInfraException, $objMetadadosProcedimento){
1377 1350  
1378   - }
  1351 +}
1379 1352  
1380   - private function validarDadosProcesso(InfraException $objInfraException, $objMetadadosProcedimento){
  1353 +private function validarDadosProcesso(InfraException $objInfraException, $objMetadadosProcedimento){
1381 1354  
1382   - }
  1355 +}
1383 1356  
1384   - private function validarDadosDocumentos(InfraException $objInfraException, $objMetadadosProcedimento){
  1357 +private function validarDadosDocumentos(InfraException $objInfraException, $objMetadadosProcedimento){
1385 1358  
1386   - }
  1359 +}
1387 1360  
1388   - private function obterNivelSigiloSEI($strNivelSigiloPEN) {
1389   - switch ($strNivelSigiloPEN) {
1390   -
1391   - case ProcessoEletronicoRN::$STA_SIGILO_PUBLICO: return ProtocoloRN::$NA_PUBLICO;
1392   - break;
1393   - case ProcessoEletronicoRN::$STA_SIGILO_RESTRITO: return ProtocoloRN::$NA_RESTRITO;
1394   - break;
1395   - case ProcessoEletronicoRN::$STA_SIGILO_SIGILOSO: return ProtocoloRN::$NA_SIGILOSO;
1396   - break;
1397   - default:
1398   - break;
1399   - }
1400   - }
  1361 +private function obterNivelSigiloSEI($strNivelSigiloPEN) {
  1362 + switch ($strNivelSigiloPEN) {
  1363 +
  1364 + case ProcessoEletronicoRN::$STA_SIGILO_PUBLICO: return ProtocoloRN::$NA_PUBLICO;
  1365 + break;
  1366 + case ProcessoEletronicoRN::$STA_SIGILO_RESTRITO: return ProtocoloRN::$NA_RESTRITO;
  1367 + break;
  1368 + case ProcessoEletronicoRN::$STA_SIGILO_SIGILOSO: return ProtocoloRN::$NA_SIGILOSO;
  1369 + break;
  1370 + default:
  1371 + break;
  1372 + }
  1373 +}
1401 1374  
1402   - private function obterHipoteseLegalSEI($parNumIdHipoteseLegalPEN) {
  1375 +private function obterHipoteseLegalSEI($parNumIdHipoteseLegalPEN) {
1403 1376 //Atribuí a hipótese legal
1404   - $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
1405   - $objPenParametroRN = new PenParametroRN();
1406   - $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO');
  1377 + $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
  1378 + $objPenParametroRN = new PenParametroRN();
  1379 + $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO');
1407 1380  
1408   - $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($parNumIdHipoteseLegalPEN);
  1381 + $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($parNumIdHipoteseLegalPEN);
1409 1382  
1410   - if (empty($numIdHipoteseLegal)) {
1411   - return $numIdHipoteseLegalPadrao;
1412   - } else {
1413   - return $numIdHipoteseLegal;
1414   - }
  1383 + if (empty($numIdHipoteseLegal)) {
  1384 + return $numIdHipoteseLegalPadrao;
  1385 + } else {
  1386 + return $numIdHipoteseLegal;
1415 1387 }
  1388 +}
1416 1389  
1417 1390 //TODO: Implementar o mapeamento entre as unidade do SEI e Barramento de Serviços (Secretaria de Saúde: 218794)
1418   - private function obterUnidadeMapeada($numIdentificacaoDaEstrutura)
1419   - {
1420   - $objUnidadeDTO = new PenUnidadeDTO();
1421   - $objUnidadeDTO->setNumIdUnidadeRH($numIdentificacaoDaEstrutura);
1422   - $objUnidadeDTO->setStrSinAtivo('S');
1423   - $objUnidadeDTO->retNumIdUnidade();
1424   - $objUnidadeDTO->retNumIdOrgao();
1425   - $objUnidadeDTO->retStrSigla();
1426   - $objUnidadeDTO->retStrDescricao();
1427   -
1428   - $objUnidadeRN = new UnidadeRN();
1429   - return $objUnidadeRN->consultarRN0125($objUnidadeDTO);
1430   - }
  1391 +private function obterUnidadeMapeada($numIdentificacaoDaEstrutura)
  1392 +{
  1393 + $objUnidadeDTO = new PenUnidadeDTO();
  1394 + $objUnidadeDTO->setNumIdUnidadeRH($numIdentificacaoDaEstrutura);
  1395 + $objUnidadeDTO->setStrSinAtivo('S');
  1396 + $objUnidadeDTO->retNumIdUnidade();
  1397 + $objUnidadeDTO->retNumIdOrgao();
  1398 + $objUnidadeDTO->retStrSigla();
  1399 + $objUnidadeDTO->retStrDescricao();
  1400 +
  1401 + $objUnidadeRN = new UnidadeRN();
  1402 + return $objUnidadeRN->consultarRN0125($objUnidadeDTO);
  1403 +}
1431 1404  
1432 1405  
1433 1406 /**
... ... @@ -1451,9 +1424,9 @@ class ReceberProcedimentoRN extends InfraRN
1451 1424 $objMapDTO->setStrPadrao('S');
1452 1425 $objMapDTO->setNumMaxRegistrosRetorno(1);
1453 1426 $objMapDTO = $objGenericoBD->consultar($objMapDTO);
1454   - }
  1427 + }
1455 1428  
1456   - if(!empty($objMapDTO)) {
  1429 + if(!empty($objMapDTO)) {
1457 1430 $objSerieDTO = new SerieDTO();
1458 1431 $objSerieDTO->retStrNome();
1459 1432 $objSerieDTO->retNumIdSerie();
... ... @@ -1461,347 +1434,347 @@ class ReceberProcedimentoRN extends InfraRN
1461 1434  
1462 1435 $objSerieRN = new SerieRN();
1463 1436 $objSerieDTO = $objSerieRN->consultarRN0644($objSerieDTO);
1464   - }
1465   -
1466   - return $objSerieDTO;
1467 1437 }
1468 1438  
1469   - private function relacionarProcedimentos($objProcedimentoDTO1, $objProcedimentoDTO2)
1470   - {
1471   - if(!isset($objProcedimentoDTO1) || !isset($objProcedimentoDTO1)) {
1472   - throw new InfraException('Parâmetro $objProcedimentoDTO não informado.');
1473   - }
  1439 + return $objSerieDTO;
  1440 + }
  1441 +
  1442 + private function relacionarProcedimentos($objProcedimentoDTO1, $objProcedimentoDTO2)
  1443 + {
  1444 + if(!isset($objProcedimentoDTO1) || !isset($objProcedimentoDTO1)) {
  1445 + throw new InfraException('Parâmetro $objProcedimentoDTO não informado.');
  1446 + }
1474 1447  
1475   - $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
1476   - $objRelProtocoloProtocoloDTO->setDblIdProtocolo1($objProcedimentoDTO2->getDblIdProcedimento());
1477   - $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objProcedimentoDTO1->getDblIdProcedimento());
1478   - $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_PROCEDIMENTO_RELACIONADO);
1479   - $objRelProtocoloProtocoloDTO->setStrMotivo(self::STR_APENSACAO_PROCEDIMENTOS);
  1448 + $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
  1449 + $objRelProtocoloProtocoloDTO->setDblIdProtocolo1($objProcedimentoDTO2->getDblIdProcedimento());
  1450 + $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objProcedimentoDTO1->getDblIdProcedimento());
  1451 + $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_PROCEDIMENTO_RELACIONADO);
  1452 + $objRelProtocoloProtocoloDTO->setStrMotivo(self::STR_APENSACAO_PROCEDIMENTOS);
1480 1453  
1481   - $objProcedimentoRN = new ProcedimentoRN();
1482   - $objProcedimentoRN->relacionarProcedimentoRN1020($objRelProtocoloProtocoloDTO);
1483   - }
  1454 + $objProcedimentoRN = new ProcedimentoRN();
  1455 + $objProcedimentoRN->relacionarProcedimentoRN1020($objRelProtocoloProtocoloDTO);
  1456 +}
1484 1457  
1485 1458 //TODO: Método identico ao localizado na classe SeiRN:2214
1486 1459 //Refatorar código para evitar problemas de manutenção
1487   - private function prepararParticipantes($arrObjParticipanteDTO)
1488   - {
1489   - $objContatoRN = new ContatoRN();
1490   - $objUsuarioRN = new UsuarioRN();
  1460 +private function prepararParticipantes($arrObjParticipanteDTO)
  1461 +{
  1462 + $objContatoRN = new ContatoRN();
  1463 + $objUsuarioRN = new UsuarioRN();
1491 1464  
1492   - foreach($arrObjParticipanteDTO as $objParticipanteDTO) {
  1465 + foreach($arrObjParticipanteDTO as $objParticipanteDTO) {
1493 1466  
1494   - $objContatoDTO = new ContatoDTO();
1495   - $objContatoDTO->retNumIdContato();
  1467 + $objContatoDTO = new ContatoDTO();
  1468 + $objContatoDTO->retNumIdContato();
1496 1469  
1497   - if (!InfraString::isBolVazia($objParticipanteDTO->getStrSiglaContato()) && !InfraString::isBolVazia($objParticipanteDTO->getStrNomeContato())) {
1498   - $objContatoDTO->setStrSigla($objParticipanteDTO->getStrSiglaContato());
1499   - $objContatoDTO->setStrNome($objParticipanteDTO->getStrNomeContato());
  1470 + if (!InfraString::isBolVazia($objParticipanteDTO->getStrSiglaContato()) && !InfraString::isBolVazia($objParticipanteDTO->getStrNomeContato())) {
  1471 + $objContatoDTO->setStrSigla($objParticipanteDTO->getStrSiglaContato());
  1472 + $objContatoDTO->setStrNome($objParticipanteDTO->getStrNomeContato());
1500 1473  
1501   - } else if (!InfraString::isBolVazia($objParticipanteDTO->getStrSiglaContato())) {
1502   - $objContatoDTO->setStrSigla($objParticipanteDTO->getStrSiglaContato());
  1474 + } else if (!InfraString::isBolVazia($objParticipanteDTO->getStrSiglaContato())) {
  1475 + $objContatoDTO->setStrSigla($objParticipanteDTO->getStrSiglaContato());
1503 1476  
1504   - } else if (!InfraString::isBolVazia($objParticipanteDTO->getStrNomeContato())) {
1505   - $objContatoDTO->setStrNome($objParticipanteDTO->getStrNomeContato());
1506   - } else {
1507   - if ($objParticipanteDTO->getStrStaParticipacao()==ParticipanteRN::$TP_INTERESSADO) {
1508   - throw new InfraException('Interessado vazio ou nulo.');
1509   - }
1510   - else if ($objParticipanteDTO->getStrStaParticipacao()==ParticipanteRN::$TP_REMETENTE) {
1511   - throw new InfraException('Remetente vazio ou nulo.');
1512   - }
1513   - else if ($objParticipanteDTO->getStrStaParticipacao()==ParticipanteRN::$TP_DESTINATARIO) {
1514   - throw new InfraException('Destinatário vazio ou nulo.');
1515   - }
1516   - }
  1477 + } else if (!InfraString::isBolVazia($objParticipanteDTO->getStrNomeContato())) {
  1478 + $objContatoDTO->setStrNome($objParticipanteDTO->getStrNomeContato());
  1479 + } else {
  1480 + if ($objParticipanteDTO->getStrStaParticipacao()==ParticipanteRN::$TP_INTERESSADO) {
  1481 + throw new InfraException('Interessado vazio ou nulo.');
  1482 + }
  1483 + else if ($objParticipanteDTO->getStrStaParticipacao()==ParticipanteRN::$TP_REMETENTE) {
  1484 + throw new InfraException('Remetente vazio ou nulo.');
  1485 + }
  1486 + else if ($objParticipanteDTO->getStrStaParticipacao()==ParticipanteRN::$TP_DESTINATARIO) {
  1487 + throw new InfraException('Destinatário vazio ou nulo.');
  1488 + }
  1489 + }
1517 1490  
1518   - $arrObjContatoDTO = $objContatoRN->listarRN0325($objContatoDTO);
  1491 + $arrObjContatoDTO = $objContatoRN->listarRN0325($objContatoDTO);
1519 1492  
1520   - if (count($arrObjContatoDTO)) {
  1493 + if (count($arrObjContatoDTO)) {
1521 1494  
1522   - $objContatoDTO = null;
  1495 + $objContatoDTO = null;
1523 1496  
1524 1497 //preferencia para contatos que representam usuarios
1525   - foreach($arrObjContatoDTO as $dto) {
  1498 + foreach($arrObjContatoDTO as $dto) {
1526 1499  
1527   - $objUsuarioDTO = new UsuarioDTO();
1528   - $objUsuarioDTO->setBolExclusaoLogica(false);
1529   - $objUsuarioDTO->setNumIdContato($dto->getNumIdContato());
  1500 + $objUsuarioDTO = new UsuarioDTO();
  1501 + $objUsuarioDTO->setBolExclusaoLogica(false);
  1502 + $objUsuarioDTO->setNumIdContato($dto->getNumIdContato());
1530 1503  
1531   - if ($objUsuarioRN->contarRN0492($objUsuarioDTO)) {
1532   - $objContatoDTO = $dto;
1533   - break;
1534   - }
1535   - }
  1504 + if ($objUsuarioRN->contarRN0492($objUsuarioDTO)) {
  1505 + $objContatoDTO = $dto;
  1506 + break;
  1507 + }
  1508 +}
1536 1509  
1537 1510 //nao achou contato de usuario pega o primeiro retornado
1538   - if ($objContatoDTO==null) {
1539   - $objContatoDTO = $arrObjContatoDTO[0];
1540   - }
1541   - } else {
1542   - $objContatoDTO = $objContatoRN->cadastrarContextoTemporario($objContatoDTO);
1543   - }
  1511 +if ($objContatoDTO==null) {
  1512 + $objContatoDTO = $arrObjContatoDTO[0];
  1513 +}
  1514 +} else {
  1515 + $objContatoDTO = $objContatoRN->cadastrarContextoTemporario($objContatoDTO);
  1516 +}
1544 1517  
1545   - $objParticipanteDTO->setNumIdContato($objContatoDTO->getNumIdContato());
1546   - }
  1518 +$objParticipanteDTO->setNumIdContato($objContatoDTO->getNumIdContato());
  1519 +}
1547 1520  
1548   - return $arrObjParticipanteDTO;
1549   - }
  1521 +return $arrObjParticipanteDTO;
  1522 +}
1550 1523  
1551   - private function registrarProcedimentoNaoVisualizado(ProcedimentoDTO $parObjProcedimentoDTO)
1552   - {
1553   - $objAtividadeDTOVisualizacao = new AtividadeDTO();
1554   - $objAtividadeDTOVisualizacao->setDblIdProtocolo($parObjProcedimentoDTO->getDblIdProcedimento());
1555   - $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_NAO_VISUALIZADO);
  1524 +private function registrarProcedimentoNaoVisualizado(ProcedimentoDTO $parObjProcedimentoDTO)
  1525 +{
  1526 + $objAtividadeDTOVisualizacao = new AtividadeDTO();
  1527 + $objAtividadeDTOVisualizacao->setDblIdProtocolo($parObjProcedimentoDTO->getDblIdProcedimento());
  1528 + $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_NAO_VISUALIZADO);
1556 1529  
1557   - $objAtividadeRN = new AtividadeRN();
1558   - $objAtividadeRN->atualizarVisualizacao($objAtividadeDTOVisualizacao);
1559   - }
  1530 + $objAtividadeRN = new AtividadeRN();
  1531 + $objAtividadeRN->atualizarVisualizacao($objAtividadeDTOVisualizacao);
  1532 +}
1560 1533  
1561   - private function enviarProcedimentoUnidade(ProcedimentoDTO $parObjProcedimentoDTO, $retransmissao = false)
1562   - {
1563   - $objAtividadeRN = new PenAtividadeRN();
1564   - $objInfraException = new InfraException();
  1534 +private function enviarProcedimentoUnidade(ProcedimentoDTO $parObjProcedimentoDTO, $retransmissao = false)
  1535 +{
  1536 + $objAtividadeRN = new PenAtividadeRN();
  1537 + $objInfraException = new InfraException();
1565 1538  
1566   - if(!$parObjProcedimentoDTO->isSetArrObjUnidadeDTO() || count($parObjProcedimentoDTO->getArrObjUnidadeDTO()) == 0) {
1567   - $objInfraException->lancarValidacao('Unidade de destino do processo não informada.');
1568   - }
  1539 + if(!$parObjProcedimentoDTO->isSetArrObjUnidadeDTO() || count($parObjProcedimentoDTO->getArrObjUnidadeDTO()) == 0) {
  1540 + $objInfraException->lancarValidacao('Unidade de destino do processo não informada.');
  1541 + }
1569 1542  
1570   - $arrObjUnidadeDTO = $parObjProcedimentoDTO->getArrObjUnidadeDTO();
  1543 + $arrObjUnidadeDTO = $parObjProcedimentoDTO->getArrObjUnidadeDTO();
1571 1544  
1572   - if(count($parObjProcedimentoDTO->getArrObjUnidadeDTO()) > 1) {
1573   - $objInfraException->lancarValidacao('Não permitido a indicação de múltiplas unidades de destino para um processo recebido externamente.');
1574   - }
  1545 + if(count($parObjProcedimentoDTO->getArrObjUnidadeDTO()) > 1) {
  1546 + $objInfraException->lancarValidacao('Não permitido a indicação de múltiplas unidades de destino para um processo recebido externamente.');
  1547 + }
1575 1548  
1576   - $arrObjUnidadeDTO = array_values($parObjProcedimentoDTO->getArrObjUnidadeDTO());
1577   - $objUnidadeDTO = $arrObjUnidadeDTO[0];
  1549 + $arrObjUnidadeDTO = array_values($parObjProcedimentoDTO->getArrObjUnidadeDTO());
  1550 + $objUnidadeDTO = $arrObjUnidadeDTO[0];
1578 1551  
1579   - $objProcedimentoDTO = new ProcedimentoDTO();
1580   - $objProcedimentoDTO->retDblIdProcedimento();
1581   - $objProcedimentoDTO->retNumIdTipoProcedimento();
1582   - $objProcedimentoDTO->retStrProtocoloProcedimentoFormatado();
1583   - $objProcedimentoDTO->retNumIdTipoProcedimento();
1584   - $objProcedimentoDTO->retStrNomeTipoProcedimento();
1585   - $objProcedimentoDTO->retStrStaNivelAcessoGlobalProtocolo();
  1552 + $objProcedimentoDTO = new ProcedimentoDTO();
  1553 + $objProcedimentoDTO->retDblIdProcedimento();
  1554 + $objProcedimentoDTO->retNumIdTipoProcedimento();
  1555 + $objProcedimentoDTO->retStrProtocoloProcedimentoFormatado();
  1556 + $objProcedimentoDTO->retNumIdTipoProcedimento();
  1557 + $objProcedimentoDTO->retStrNomeTipoProcedimento();
  1558 + $objProcedimentoDTO->retStrStaNivelAcessoGlobalProtocolo();
1586 1559 // $objProcedimentoDTO->retStrStaEstadoProtocolo();
1587   - $objProcedimentoDTO->setStrProtocoloProcedimentoFormatado($parObjProcedimentoDTO->getStrProtocoloProcedimentoFormatado());
  1560 + $objProcedimentoDTO->setStrProtocoloProcedimentoFormatado($parObjProcedimentoDTO->getStrProtocoloProcedimentoFormatado());
1588 1561  
1589   - $objProcedimentoRN = new ProcedimentoRN();
1590   - $objProcedimentoDTO = $objProcedimentoRN->consultarRN0201($objProcedimentoDTO);
  1562 + $objProcedimentoRN = new ProcedimentoRN();
  1563 + $objProcedimentoDTO = $objProcedimentoRN->consultarRN0201($objProcedimentoDTO);
1591 1564  
1592   - if ($objProcedimentoDTO == null || $objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_SIGILOSO) {
1593   - $objInfraException->lancarValidacao('Processo ['.$parObjProcedimentoDTO->getStrProtocoloProcedimentoFormatado().'] não encontrado.');
1594   - }
  1565 + if ($objProcedimentoDTO == null || $objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_SIGILOSO) {
  1566 + $objInfraException->lancarValidacao('Processo ['.$parObjProcedimentoDTO->getStrProtocoloProcedimentoFormatado().'] não encontrado.');
  1567 + }
1595 1568  
1596   - if ($objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_RESTRITO) {
1597   - $objAcessoDTO = new AcessoDTO();
1598   - $objAcessoDTO->setDblIdProtocolo($objProcedimentoDTO->getDblIdProcedimento());
1599   - $objAcessoDTO->setNumIdUnidade($objUnidadeDTO->getNumIdUnidade());
  1569 + if ($objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_RESTRITO) {
  1570 + $objAcessoDTO = new AcessoDTO();
  1571 + $objAcessoDTO->setDblIdProtocolo($objProcedimentoDTO->getDblIdProcedimento());
  1572 + $objAcessoDTO->setNumIdUnidade($objUnidadeDTO->getNumIdUnidade());
1600 1573  
1601   - $objAcessoRN = new AcessoRN();
1602   - if ($objAcessoRN->contar($objAcessoDTO)==0) {
  1574 + $objAcessoRN = new AcessoRN();
  1575 + if ($objAcessoRN->contar($objAcessoDTO)==0) {
1603 1576 // AVALIAR $objInfraException->adicionarValidacao('Unidade ['.$objUnidadeDTO->getStrSigla().'] não possui acesso ao processo ['.$objProcedimentoDTO->getStrProtocoloProcedimentoFormatado().'].');
1604   - }
1605   - }
  1577 + }
  1578 + }
1606 1579  
1607   - $objPesquisaPendenciaDTO = new PesquisaPendenciaDTO();
1608   - $objPesquisaPendenciaDTO->setDblIdProtocolo(array($objProcedimentoDTO->getDblIdProcedimento()));
1609   - $objPesquisaPendenciaDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
1610   - $objPesquisaPendenciaDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1580 + $objPesquisaPendenciaDTO = new PesquisaPendenciaDTO();
  1581 + $objPesquisaPendenciaDTO->setDblIdProtocolo(array($objProcedimentoDTO->getDblIdProcedimento()));
  1582 + $objPesquisaPendenciaDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
  1583 + $objPesquisaPendenciaDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1611 1584  
1612   - if($retransmissao){
1613   - $objAtividadeRN->setStatusPesquisa(false);
  1585 + if($retransmissao){
  1586 + $objAtividadeRN->setStatusPesquisa(false);
1614 1587  
1615   - }
  1588 +}
1616 1589  
1617   - $objAtividadeDTO2 = new AtividadeDTO();
1618   - $objAtividadeDTO2->setDblIdProtocolo($objProcedimentoDTO->getDblIdProcedimento());
1619   - $objAtividadeDTO2->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1620   - $objAtividadeDTO2->setDthConclusao(null);
  1590 +$objAtividadeDTO2 = new AtividadeDTO();
  1591 +$objAtividadeDTO2->setDblIdProtocolo($objProcedimentoDTO->getDblIdProcedimento());
  1592 +$objAtividadeDTO2->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1593 +$objAtividadeDTO2->setDthConclusao(null);
1621 1594  
1622 1595  
1623   - if ($objAtividadeRN->contarRN0035($objAtividadeDTO2) == 0) {
  1596 +if ($objAtividadeRN->contarRN0035($objAtividadeDTO2) == 0) {
1624 1597  
1625 1598 //reabertura automática
1626   - $objReabrirProcessoDTO = new ReabrirProcessoDTO();
1627   - $objReabrirProcessoDTO->setDblIdProcedimento($objAtividadeDTO2->getDblIdProtocolo());
1628   - $objReabrirProcessoDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1629   - $objReabrirProcessoDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
1630   - $objProcedimentoRN->reabrirRN0966($objReabrirProcessoDTO);
  1599 + $objReabrirProcessoDTO = new ReabrirProcessoDTO();
  1600 + $objReabrirProcessoDTO->setDblIdProcedimento($objAtividadeDTO2->getDblIdProtocolo());
  1601 + $objReabrirProcessoDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1602 + $objReabrirProcessoDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
  1603 + $objProcedimentoRN->reabrirRN0966($objReabrirProcessoDTO);
1631 1604  
1632   - }
  1605 +}
1633 1606  
1634 1607 //$objPenAtividadeRN = new PenAtividadeRN();
1635   - $arrObjProcedimentoDTO = $objAtividadeRN->listarPendenciasRN0754($objPesquisaPendenciaDTO);
  1608 +$arrObjProcedimentoDTO = $objAtividadeRN->listarPendenciasRN0754($objPesquisaPendenciaDTO);
1636 1609  
1637   - $objInfraException->lancarValidacoes();
  1610 +$objInfraException->lancarValidacoes();
1638 1611  
1639 1612  
1640   - $objEnviarProcessoDTO = new EnviarProcessoDTO();
1641   - $objEnviarProcessoDTO->setArrAtividadesOrigem($arrObjProcedimentoDTO[0]->getArrObjAtividadeDTO());
  1613 +$objEnviarProcessoDTO = new EnviarProcessoDTO();
  1614 +$objEnviarProcessoDTO->setArrAtividadesOrigem($arrObjProcedimentoDTO[0]->getArrObjAtividadeDTO());
1642 1615  
1643   - $objAtividadeDTO = new AtividadeDTO();
1644   - $objAtividadeDTO->setDblIdProtocolo($objProcedimentoDTO->getDblIdProcedimento());
1645   - $objAtividadeDTO->setNumIdUsuario(null);
1646   - $objAtividadeDTO->setNumIdUsuarioOrigem(SessaoSEI::getInstance()->getNumIdUsuario());
1647   - $objAtividadeDTO->setNumIdUnidade($objUnidadeDTO->getNumIdUnidade());
1648   - $objAtividadeDTO->setNumIdUnidadeOrigem(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1649   - $objEnviarProcessoDTO->setArrAtividades(array($objAtividadeDTO));
  1616 +$objAtividadeDTO = new AtividadeDTO();
  1617 +$objAtividadeDTO->setDblIdProtocolo($objProcedimentoDTO->getDblIdProcedimento());
  1618 +$objAtividadeDTO->setNumIdUsuario(null);
  1619 +$objAtividadeDTO->setNumIdUsuarioOrigem(SessaoSEI::getInstance()->getNumIdUsuario());
  1620 +$objAtividadeDTO->setNumIdUnidade($objUnidadeDTO->getNumIdUnidade());
  1621 +$objAtividadeDTO->setNumIdUnidadeOrigem(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1622 +$objEnviarProcessoDTO->setArrAtividades(array($objAtividadeDTO));
1650 1623  
1651   - $objPenParametroRN = new PenParametroRN();
  1624 +$objPenParametroRN = new PenParametroRN();
1652 1625  
1653   - $objEnviarProcessoDTO->setStrSinManterAberto('N');
1654   - $strEnviaEmailNotificacao = $objPenParametroRN->getParametro('PEN_ENVIA_EMAIL_NOTIFICACAO_RECEBIMENTO');
1655   - $objEnviarProcessoDTO->setStrSinEnviarEmailNotificacao($strEnviaEmailNotificacao);
1656   - $objEnviarProcessoDTO->setStrSinRemoverAnotacoes('S');
1657   - $objEnviarProcessoDTO->setDtaPrazo(null);
1658   - $objEnviarProcessoDTO->setNumDias(null);
1659   - $objEnviarProcessoDTO->setStrSinDiasUteis('N');
  1626 +$objEnviarProcessoDTO->setStrSinManterAberto('N');
  1627 +$strEnviaEmailNotificacao = $objPenParametroRN->getParametro('PEN_ENVIA_EMAIL_NOTIFICACAO_RECEBIMENTO');
  1628 +$objEnviarProcessoDTO->setStrSinEnviarEmailNotificacao($strEnviaEmailNotificacao);
  1629 +$objEnviarProcessoDTO->setStrSinRemoverAnotacoes('S');
  1630 +$objEnviarProcessoDTO->setDtaPrazo(null);
  1631 +$objEnviarProcessoDTO->setNumDias(null);
  1632 +$objEnviarProcessoDTO->setStrSinDiasUteis('N');
1660 1633  
1661   - $objAtividadeRN->enviarRN0023($objEnviarProcessoDTO);
  1634 +$objAtividadeRN->enviarRN0023($objEnviarProcessoDTO);
1662 1635  
1663   - }
  1636 +}
1664 1637  
1665   - /* Essa é a função estática de comparação */
1666   - static function comparacaoOrdemDocumentos($parDocumento1, $parDocumento2)
1667   - {
1668   - $numOrdemDocumento1 = strtolower($parDocumento1->ordem);
1669   - $numOrdemDocumento2 = strtolower($parDocumento2->ordem);
1670   - return $numOrdemDocumento1 - $numOrdemDocumento2;
1671   - }
  1638 +/* Essa é a função estática de comparação */
  1639 +static function comparacaoOrdemDocumentos($parDocumento1, $parDocumento2)
  1640 +{
  1641 + $numOrdemDocumento1 = strtolower($parDocumento1->ordem);
  1642 + $numOrdemDocumento2 = strtolower($parDocumento2->ordem);
  1643 + return $numOrdemDocumento1 - $numOrdemDocumento2;
  1644 +}
1672 1645  
1673 1646  
1674   - public function receberTramitesRecusados($parNumIdentificacaoTramite)
1675   - {
1676   - try {
1677   - if (empty($parNumIdentificacaoTramite)) {
1678   - throw new InfraException('Parâmetro $parNumIdentificacaoTramite não informado.');
1679   - }
  1647 +public function receberTramitesRecusados($parNumIdentificacaoTramite)
  1648 +{
  1649 + try {
  1650 + if (empty($parNumIdentificacaoTramite)) {
  1651 + throw new InfraException('Parâmetro $parNumIdentificacaoTramite não informado.');
  1652 + }
1680 1653  
1681 1654 //Busca os dados do trâmite no barramento
1682   - $tramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
  1655 + $tramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
1683 1656  
1684   - if(!isset($tramite[0])){
1685   - throw new InfraException("Não foi encontrado no PEN o trâmite de número {$parNumIdentificacaoTramite} para realizar a ciência da recusa");
1686   - }
  1657 + if(!isset($tramite[0])){
  1658 + throw new InfraException("Não foi encontrado no PEN o trâmite de número {$parNumIdentificacaoTramite} para realizar a ciência da recusa");
  1659 + }
1687 1660  
1688   - $tramite = $tramite[0];
  1661 + $tramite = $tramite[0];
1689 1662  
1690   - $objTramiteDTO = new TramiteDTO();
1691   - $objTramiteDTO->setNumIdTramite($parNumIdentificacaoTramite);
1692   - $objTramiteDTO->retNumIdUnidade();
  1663 + $objTramiteDTO = new TramiteDTO();
  1664 + $objTramiteDTO->setNumIdTramite($parNumIdentificacaoTramite);
  1665 + $objTramiteDTO->retNumIdUnidade();
1693 1666  
1694   - $objTramiteBD = new TramiteBD(BancoSEI::getInstance());
1695   - $objTramiteDTO = $objTramiteBD->consultar($objTramiteDTO);
  1667 + $objTramiteBD = new TramiteBD(BancoSEI::getInstance());
  1668 + $objTramiteDTO = $objTramiteBD->consultar($objTramiteDTO);
1696 1669  
1697   - if(!isset($objTramiteDTO)){
1698   - throw new InfraException("Não foi encontrado no sistema o trâmite de número {$parNumIdentificacaoTramite} para realizar a ciência da recusa");
1699   - }
  1670 + if(!isset($objTramiteDTO)){
  1671 + throw new InfraException("Não foi encontrado no sistema o trâmite de número {$parNumIdentificacaoTramite} para realizar a ciência da recusa");
  1672 + }
1700 1673  
1701   - SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $objTramiteDTO->getNumIdUnidade());
  1674 + SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $objTramiteDTO->getNumIdUnidade());
1702 1675  
1703 1676 //Busca os dados do procedimento
1704   - $this->gravarLogDebug("Buscando os dados de procedimento com NRE " . $tramite->NRE, 2);
1705   - $objProcessoEletronicoDTO = new ProcessoEletronicoDTO();
1706   - $objProcessoEletronicoDTO->setStrNumeroRegistro($tramite->NRE);
1707   - $objProcessoEletronicoDTO->retDblIdProcedimento();
1708   - $objProcessoEletronicoBD = new ProcessoEletronicoBD($this->getObjInfraIBanco());
1709   - $objProcessoEletronicoDTO = $objProcessoEletronicoBD->consultar($objProcessoEletronicoDTO);
  1677 + $this->gravarLogDebug("Buscando os dados de procedimento com NRE " . $tramite->NRE, 2);
  1678 + $objProcessoEletronicoDTO = new ProcessoEletronicoDTO();
  1679 + $objProcessoEletronicoDTO->setStrNumeroRegistro($tramite->NRE);
  1680 + $objProcessoEletronicoDTO->retDblIdProcedimento();
  1681 + $objProcessoEletronicoBD = new ProcessoEletronicoBD($this->getObjInfraIBanco());
  1682 + $objProcessoEletronicoDTO = $objProcessoEletronicoBD->consultar($objProcessoEletronicoDTO);
1710 1683  
1711 1684 //Busca a última atividade de trâmite externo
1712   - $this->gravarLogDebug("Buscando última atividade de trâmite externo do processo " . $objProcessoEletronicoDTO->getDblIdProcedimento(), 2);
1713   - $objAtividadeDTO = new AtividadeDTO();
1714   - $objAtividadeDTO->setDblIdProtocolo($objProcessoEletronicoDTO->getDblIdProcedimento());
1715   - $objAtividadeDTO->setNumIdTarefa(ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_EXPEDIDO));
1716   - $objAtividadeDTO->setNumMaxRegistrosRetorno(1);
1717   - $objAtividadeDTO->setOrdDthAbertura(InfraDTO::$TIPO_ORDENACAO_DESC);
1718   - $objAtividadeDTO->retNumIdAtividade();
1719   - $objAtividadeBD = new AtividadeBD($this->getObjInfraIBanco());
1720   - $objAtividadeDTO = $objAtividadeBD->consultar($objAtividadeDTO);
  1685 + $this->gravarLogDebug("Buscando última atividade de trâmite externo do processo " . $objProcessoEletronicoDTO->getDblIdProcedimento(), 2);
  1686 + $objAtividadeDTO = new AtividadeDTO();
  1687 + $objAtividadeDTO->setDblIdProtocolo($objProcessoEletronicoDTO->getDblIdProcedimento());
  1688 + $objAtividadeDTO->setNumIdTarefa(ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_EXPEDIDO));
  1689 + $objAtividadeDTO->setNumMaxRegistrosRetorno(1);
  1690 + $objAtividadeDTO->setOrdDthAbertura(InfraDTO::$TIPO_ORDENACAO_DESC);
  1691 + $objAtividadeDTO->retNumIdAtividade();
  1692 + $objAtividadeBD = new AtividadeBD($this->getObjInfraIBanco());
  1693 + $objAtividadeDTO = $objAtividadeBD->consultar($objAtividadeDTO);
1721 1694  
1722 1695 //Busca a unidade de destino
1723   - $this->gravarLogDebug("Buscando informações sobre a unidade de destino", 2);
1724   - $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
1725   - $objAtributoAndamentoDTO->setNumIdAtividade($objAtividadeDTO->getNumIdAtividade());
1726   - $objAtributoAndamentoDTO->setStrNome('UNIDADE_DESTINO');
1727   - $objAtributoAndamentoDTO->retStrValor();
1728   - $objAtributoAndamentoBD = new AtributoAndamentoBD($this->getObjInfraIBanco());
1729   - $objAtributoAndamentoDTO = $objAtributoAndamentoBD->consultar($objAtributoAndamentoDTO);
  1696 + $this->gravarLogDebug("Buscando informações sobre a unidade de destino", 2);
  1697 + $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
  1698 + $objAtributoAndamentoDTO->setNumIdAtividade($objAtividadeDTO->getNumIdAtividade());
  1699 + $objAtributoAndamentoDTO->setStrNome('UNIDADE_DESTINO');
  1700 + $objAtributoAndamentoDTO->retStrValor();
  1701 + $objAtributoAndamentoBD = new AtributoAndamentoBD($this->getObjInfraIBanco());
  1702 + $objAtributoAndamentoDTO = $objAtributoAndamentoBD->consultar($objAtributoAndamentoDTO);
1730 1703  
1731 1704 //Monta o DTO de receber tramite recusado
1732   - $this->gravarLogDebug("Preparando recebimento de trâmite " . $parNumIdentificacaoTramite . " recusado", 2);
1733   - $objReceberTramiteRecusadoDTO = new ReceberTramiteRecusadoDTO();
1734   - $objReceberTramiteRecusadoDTO->setNumIdTramite($parNumIdentificacaoTramite);
1735   - $objReceberTramiteRecusadoDTO->setNumIdProtocolo($objProcessoEletronicoDTO->getDblIdProcedimento());
1736   - $objReceberTramiteRecusadoDTO->setNumIdUnidadeOrigem(null);
1737   - $objReceberTramiteRecusadoDTO->setNumIdTarefa(ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_TRAMITE_RECUSADO));
1738   - $objReceberTramiteRecusadoDTO->setStrMotivoRecusa(utf8_decode($tramite->justificativaDaRecusa));
1739   - $objReceberTramiteRecusadoDTO->setStrNomeUnidadeDestino($objAtributoAndamentoDTO->getStrValor());
  1705 + $this->gravarLogDebug("Preparando recebimento de trâmite " . $parNumIdentificacaoTramite . " recusado", 2);
  1706 + $objReceberTramiteRecusadoDTO = new ReceberTramiteRecusadoDTO();
  1707 + $objReceberTramiteRecusadoDTO->setNumIdTramite($parNumIdentificacaoTramite);
  1708 + $objReceberTramiteRecusadoDTO->setNumIdProtocolo($objProcessoEletronicoDTO->getDblIdProcedimento());
  1709 + $objReceberTramiteRecusadoDTO->setNumIdUnidadeOrigem(null);
  1710 + $objReceberTramiteRecusadoDTO->setNumIdTarefa(ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_TRAMITE_RECUSADO));
  1711 + $objReceberTramiteRecusadoDTO->setStrMotivoRecusa(utf8_decode($tramite->justificativaDaRecusa));
  1712 + $objReceberTramiteRecusadoDTO->setStrNomeUnidadeDestino($objAtributoAndamentoDTO->getStrValor());
1740 1713  
1741 1714 //Faz o tratamento do processo e do trâmite recusado
1742   - $this->gravarLogDebug("Atualizando dados do processo " . $objProcessoEletronicoDTO->getDblIdProcedimento() ." e do trâmite recusado " . $parNumIdentificacaoTramite, 2);
1743   - $this->receberTramiteRecusadoInterno($objReceberTramiteRecusadoDTO);
1744   -
1745   - } catch (Exception $e) {
1746   - $mensagemErro = InfraException::inspecionar($e);
1747   - $this->gravarLogDebug($mensagemErro);
1748   - LogSEI::getInstance()->gravar($mensagemErro);
1749   - throw $e;
1750   - }
  1715 + $this->gravarLogDebug("Atualizando dados do processo " . $objProcessoEletronicoDTO->getDblIdProcedimento() ." e do trâmite recusado " . $parNumIdentificacaoTramite, 2);
  1716 + $this->receberTramiteRecusadoInterno($objReceberTramiteRecusadoDTO);
  1717 +
  1718 + } catch (Exception $e) {
  1719 + $mensagemErro = InfraException::inspecionar($e);
  1720 + $this->gravarLogDebug($mensagemErro);
  1721 + LogSEI::getInstance()->gravar($mensagemErro);
  1722 + throw $e;
1751 1723 }
  1724 +}
1752 1725  
1753   - protected function receberTramiteRecusadoInternoControlado(ReceberTramiteRecusadoDTO $objReceberTramiteRecusadoDTO)
1754   - {
  1726 +protected function receberTramiteRecusadoInternoControlado(ReceberTramiteRecusadoDTO $objReceberTramiteRecusadoDTO)
  1727 +{
1755 1728 //Realiza o desbloqueio do processo
1756   - $this->gravarLogDebug("Realizando o desbloqueio do processo", 4);
1757   - $objProtocoloDTO = new ProtocoloDTO();
1758   - $objProtocoloDTO->setDblIdProtocolo($objReceberTramiteRecusadoDTO->getNumIdProtocolo());
1759   - $objProtocoloDTO->setStrStaEstado(ProtocoloRN::$TE_PROCEDIMENTO_BLOQUEADO);
1760   - $objProtocoloRN = new ProtocoloRN();
1761   - if($objProtocoloRN->contarRN0667($objProtocoloDTO) != 0) {
1762   - $objEntradaDesbloquearProcessoAPI = new EntradaDesbloquearProcessoAPI();
1763   - $objEntradaDesbloquearProcessoAPI->setIdProcedimento($objReceberTramiteRecusadoDTO->getNumIdProtocolo());
1764   - $objSeiRN = new SeiRN();
1765   - $objSeiRN->desbloquearProcesso($objEntradaDesbloquearProcessoAPI);
1766   - } else {
1767   - $this->gravarLogDebug("Processo " . $objReceberTramiteRecusadoDTO->getNumIdProtocolo() . " já se encontra desbloqueado!", 6);
1768   - }
  1729 + $this->gravarLogDebug("Realizando o desbloqueio do processo", 4);
  1730 + $objProtocoloDTO = new ProtocoloDTO();
  1731 + $objProtocoloDTO->setDblIdProtocolo($objReceberTramiteRecusadoDTO->getNumIdProtocolo());
  1732 + $objProtocoloDTO->setStrStaEstado(ProtocoloRN::$TE_PROCEDIMENTO_BLOQUEADO);
  1733 + $objProtocoloRN = new ProtocoloRN();
  1734 + if($objProtocoloRN->contarRN0667($objProtocoloDTO) != 0) {
  1735 + $objEntradaDesbloquearProcessoAPI = new EntradaDesbloquearProcessoAPI();
  1736 + $objEntradaDesbloquearProcessoAPI->setIdProcedimento($objReceberTramiteRecusadoDTO->getNumIdProtocolo());
  1737 + $objSeiRN = new SeiRN();
  1738 + $objSeiRN->desbloquearProcesso($objEntradaDesbloquearProcessoAPI);
  1739 + } else {
  1740 + $this->gravarLogDebug("Processo " . $objReceberTramiteRecusadoDTO->getNumIdProtocolo() . " já se encontra desbloqueado!", 6);
  1741 + }
1769 1742  
1770 1743 //Adiciona um andamento para o trâmite recusado
1771   - $this->gravarLogDebug("Adicionando andamento para registro da recusa do trâmite", 4);
1772   - $arrObjAtributoAndamentoDTO = array();
1773   - $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
1774   - $objAtributoAndamentoDTO->setStrNome('MOTIVO');
1775   - $objAtributoAndamentoDTO->setStrValor($objReceberTramiteRecusadoDTO->getStrMotivoRecusa());
1776   - $objAtributoAndamentoDTO->setStrIdOrigem($objReceberTramiteRecusadoDTO->getNumIdUnidadeOrigem());
1777   - $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
1778   -
1779   - $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
1780   - $objAtributoAndamentoDTO->setStrNome('UNIDADE_DESTINO');
1781   - $objAtributoAndamentoDTO->setStrValor($objReceberTramiteRecusadoDTO->getStrNomeUnidadeDestino());
1782   - $objAtributoAndamentoDTO->setStrIdOrigem($objReceberTramiteRecusadoDTO->getNumIdUnidadeOrigem());
1783   - $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
1784   -
1785   - $objAtividadeDTO = new AtividadeDTO();
1786   - $objAtividadeDTO->setDblIdProtocolo($objReceberTramiteRecusadoDTO->getNumIdProtocolo());
1787   - $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1788   - $objAtividadeDTO->setNumIdTarefa($objReceberTramiteRecusadoDTO->getNumIdTarefa());
1789   - $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);
1790   -
1791   - $objAtividadeRN = new AtividadeRN();
1792   - $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
  1744 + $this->gravarLogDebug("Adicionando andamento para registro da recusa do trâmite", 4);
  1745 + $arrObjAtributoAndamentoDTO = array();
  1746 + $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
  1747 + $objAtributoAndamentoDTO->setStrNome('MOTIVO');
  1748 + $objAtributoAndamentoDTO->setStrValor($objReceberTramiteRecusadoDTO->getStrMotivoRecusa());
  1749 + $objAtributoAndamentoDTO->setStrIdOrigem($objReceberTramiteRecusadoDTO->getNumIdUnidadeOrigem());
  1750 + $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
  1751 +
  1752 + $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
  1753 + $objAtributoAndamentoDTO->setStrNome('UNIDADE_DESTINO');
  1754 + $objAtributoAndamentoDTO->setStrValor($objReceberTramiteRecusadoDTO->getStrNomeUnidadeDestino());
  1755 + $objAtributoAndamentoDTO->setStrIdOrigem($objReceberTramiteRecusadoDTO->getNumIdUnidadeOrigem());
  1756 + $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
  1757 +
  1758 + $objAtividadeDTO = new AtividadeDTO();
  1759 + $objAtividadeDTO->setDblIdProtocolo($objReceberTramiteRecusadoDTO->getNumIdProtocolo());
  1760 + $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1761 + $objAtividadeDTO->setNumIdTarefa($objReceberTramiteRecusadoDTO->getNumIdTarefa());
  1762 + $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);
  1763 +
  1764 + $objAtividadeRN = new AtividadeRN();
  1765 + $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
1793 1766  
1794 1767 //Sinaliza na PenProtocolo que o processo obteve recusa
1795   - $this->gravarLogDebug("Atualizando protocolo sobre obtenção da ciência de recusa", 4);
1796   - $objProtocolo = new PenProtocoloDTO();
1797   - $objProtocolo->setDblIdProtocolo($objReceberTramiteRecusadoDTO->getNumIdProtocolo());
1798   - $objProtocolo->setStrSinObteveRecusa('S');
1799   - $objProtocoloBD = new ProtocoloBD($this->getObjInfraIBanco());
1800   - $objProtocoloBD->alterar($objProtocolo);
1801   -
1802   - $this->gravarLogDebug("Notificando serviços do PEN sobre ciência da recusa do trâmite " . $objReceberTramiteRecusadoDTO->getNumIdTramite(), 4);
1803   - $this->objProcessoEletronicoRN->cienciaRecusa($objReceberTramiteRecusadoDTO->getNumIdTramite());
1804   - }
  1768 + $this->gravarLogDebug("Atualizando protocolo sobre obtenção da ciência de recusa", 4);
  1769 + $objProtocolo = new PenProtocoloDTO();
  1770 + $objProtocolo->setDblIdProtocolo($objReceberTramiteRecusadoDTO->getNumIdProtocolo());
  1771 + $objProtocolo->setStrSinObteveRecusa('S');
  1772 + $objProtocoloBD = new ProtocoloBD($this->getObjInfraIBanco());
  1773 + $objProtocoloBD->alterar($objProtocolo);
  1774 +
  1775 + $this->gravarLogDebug("Notificando serviços do PEN sobre ciência da recusa do trâmite " . $objReceberTramiteRecusadoDTO->getNumIdTramite(), 4);
  1776 + $this->objProcessoEletronicoRN->cienciaRecusa($objReceberTramiteRecusadoDTO->getNumIdTramite());
  1777 +}
1805 1778  
1806 1779  
1807 1780 /**
... ... @@ -1869,6 +1842,24 @@ class ReceberProcedimentoRN extends InfraRN
1869 1842 }
1870 1843 }
1871 1844  
  1845 + private function sincronizarRecebimentoProcessos($parStrNumeroRegistro, $parNumIdentificacaoTramite)
  1846 + {
  1847 + $objProcedimentoAndamentoDTO = new ProcedimentoAndamentoDTO();
  1848 + $objProcedimentoAndamentoDTO->retDblIdAndamento();
  1849 + $objProcedimentoAndamentoDTO->setStrNumeroRegistro($parStrNumeroRegistro);
  1850 + $objProcedimentoAndamentoDTO->setDblIdTramite($parNumIdentificacaoTramite);
  1851 + $objProcedimentoAndamentoDTO->setNumTarefa(ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_RECEBIDO));
  1852 + $objProcedimentoAndamentoDTO->setNumMaxRegistrosRetorno(1);
  1853 +
  1854 + $objProcedimentoAndamentoBD = new ProcedimentoAndamentoBD($this->getObjInfraIBanco());
  1855 + $objProcedimentoAndamentoDTORet = $objProcedimentoAndamentoBD->consultar($objProcedimentoAndamentoDTO);
  1856 +
  1857 + $this->gravarLogDebug("Sincronizando o recebimento de processos concorrentes...", 4);
  1858 + $objProcedimentoAndamentoDTO = $objProcedimentoAndamentoBD->bloquear($objProcedimentoAndamentoDTORet) ? isset($objProcedimentoAndamentoDTORet) : false;
  1859 + $this->gravarLogDebug("Liberando processo concorrente de recebimento de processo ...", 4);
  1860 + return $objProcedimentoAndamentoDTO;
  1861 + }
  1862 +
1872 1863 private function gravarLogDebug($strMensagem, $numIdentacao=0)
1873 1864 {
1874 1865 $strDataLog = date("d/m/Y H:i:s");
... ...
rn/ReceberReciboTramiteRN.php
  Diff comments   View file @ff263bd
... ... @@ -201,7 +201,7 @@ class ReceberReciboTramiteRN extends InfraRN
201 201 $objProtocoloBD = new ProtocoloBD(BancoSEI::getInstance());
202 202 $objProtocoloDTO = $objProtocoloBD->consultar($objProtocoloDTO);
203 203  
204   - $this->objProcedimentoAndamentoRN->setOpts($objProcessoEletronicoDTO->getDblIdProcedimento(), $parNumIdTramite, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_EXPEDIDO));
  204 + $this->objProcedimentoAndamentoRN->setOpts($objTramiteDTO->getStrNumeroRegistro(), $parNumIdTramite, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_EXPEDIDO), $objProcessoEletronicoDTO->getDblIdProcedimento());
205 205 $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento(sprintf('Trâmite do processo %s foi concluído', $objProtocoloDTO->getStrProtocoloFormatado()), 'S'));
206 206 //Registra o recbimento do recibo no histórico e realiza a conclusão do processo
207 207 $this->registrarRecebimentoRecibo($objProtocoloDTO->getDblIdProtocolo(), $objProtocoloDTO->getStrProtocoloFormatado(), $parNumIdTramite);
... ...
sip_atualizar_versao_modulo_pen.php
  Diff comments   View file @ff263bd
... ... @@ -93,6 +93,7 @@ class PenAtualizarSipRN extends InfraRN {
93 93 case '1.1.8': $this->instalarV119();
94 94 case '1.1.9': $this->instalarV1110();
95 95 case '1.1.10': $this->instalarV1111();
  96 + case '1.1.11': $this->instalarV1112();
96 97  
97 98 break;
98 99 default:
... ... @@ -1021,6 +1022,23 @@ class PenAtualizarSipRN extends InfraRN {
1021 1022 $objInfraParametroDTO->setStrValor('1.1.11');
1022 1023 $objInfraParametroBD->alterar($objInfraParametroDTO);
1023 1024 }
  1025 +
  1026 + /**
  1027 + * Instala/Atualiza os módulo PEN para versão 1.1.12
  1028 + */
  1029 + protected function instalarV1112()
  1030 + {
  1031 + //Corrigir a versão do módulo no banco de dados
  1032 + $objInfraParametroDTO = new InfraParametroDTO();
  1033 + $objInfraParametroDTO->setStrNome(self::PARAMETRO_VERSAO_MODULO);
  1034 + $objInfraParametroDTO->retTodos();
  1035 + $objInfraParametroBD = new InfraParametroBD($this->inicializarObjInfraIBanco());
  1036 + $objInfraParametroDTO = $objInfraParametroBD->consultar($objInfraParametroDTO);
  1037 + $objInfraParametroDTO->setStrValor('1.1.12');
  1038 + $objInfraParametroBD->alterar($objInfraParametroDTO);
  1039 + }
  1040 +
  1041 +
1024 1042 }
1025 1043  
1026 1044 try {
... ...