Download as
Browse Code »

Commit c324353191f54832a8104188a494f525a939e312

Authored by Guilherme Andrade Del Cantoni
1 parent f431b6b9
Exists in feature-50

Implementação parcial do recebimento de documentos avulsos

Showing 2 changed files with 383 additions and 367 deletions   Show diff stats
rn/ProcessoEletronicoRN.php
  Diff comments   View file @c324353
@@ -60,7 +60,7 @@ class ProcessoEletronicoRN extends InfraRN { @@ -60,7 +60,7 @@ class ProcessoEletronicoRN extends InfraRN {
60 /** 60 /**
61 * Espécie documentoal não mapeada 61 * Espécie documentoal não mapeada
62 */ 62 */
63 - const MTV_RCSR_TRAM_CD_ESPECIE_NAO_MAPEADA = '03'; 63 + const MTV_RCSR_TRAM_CD_ESPECIE_NAO_MAPEADA = '04';
64 64
65 /** 65 /**
66 * Motivo para recusar de tramite de componente digital 66 * Motivo para recusar de tramite de componente digital
rn/ReceberProcedimentoRN.php
  Diff comments   View file @c324353
@@ -38,10 +38,15 @@ class ReceberProcedimentoRN extends InfraRN @@ -38,10 +38,15 @@ class ReceberProcedimentoRN extends InfraRN
38 protected function receberProcedimentoControlado($parNumIdentificacaoTramite) 38 protected function receberProcedimentoControlado($parNumIdentificacaoTramite)
39 { 39 {
40 try { 40 try {
  41 + $objSeiRN = new SeiRN();
41 $objPenParametroRN = new PenParametroRN(); 42 $objPenParametroRN = new PenParametroRN();
  43 +
  44 + // O recebimento do processo deve ser realizado na unidade definida em [UNIDADE_GERADORA_DOCUMENTO_RECEBIDO] que não deverá possuir usuários
  45 + // habilitados, funcionando como uma área dedicada unicamente para o recebimento de processos e documentos.
  46 + // Isto é necessário para que o processo recebido não seja criado diretamente dentro da unidade de destino, o que permitiria a alteração de
  47 + // todos os metadados do processo, comportamento não permitido pelas regras de negócio do PEN.
42 SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $objPenParametroRN->getParametro('PEN_UNIDADE_GERADORA_DOCUMENTO_RECEBIDO')); 48 SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $objPenParametroRN->getParametro('PEN_UNIDADE_GERADORA_DOCUMENTO_RECEBIDO'));
43 49
44 - $objSeiRN = new SeiRN();  
45 50
46 if (!isset($parNumIdentificacaoTramite)) { 51 if (!isset($parNumIdentificacaoTramite)) {
47 throw new InfraException('Parâmetro $parNumIdentificacaoTramite não informado.'); 52 throw new InfraException('Parâmetro $parNumIdentificacaoTramite não informado.');
@@ -51,172 +56,171 @@ class ReceberProcedimentoRN extends InfraRN @@ -51,172 +56,171 @@ class ReceberProcedimentoRN extends InfraRN
51 $this->gravarLogDebug("Solicitando metadados do trâmite " . $parNumIdentificacaoTramite, 4); 56 $this->gravarLogDebug("Solicitando metadados do trâmite " . $parNumIdentificacaoTramite, 4);
52 $objMetadadosProcedimento = $this->objProcessoEletronicoRN->solicitarMetadados($parNumIdentificacaoTramite); 57 $objMetadadosProcedimento = $this->objProcessoEletronicoRN->solicitarMetadados($parNumIdentificacaoTramite);
53 58
54 - if (isset($objMetadadosProcedimento)) {  
55 - $strNumeroRegistro = $objMetadadosProcedimento->metadados->NRE;  
56 - $objProcesso = $objMetadadosProcedimento->metadados->processo; 59 + if (!isset($objMetadadosProcedimento)) {
  60 + throw new InfraException("Metadados do trâmite não pode recuperado do PEN.");
  61 + }
57 62
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')); 63 + $strNumeroRegistro = $objMetadadosProcedimento->metadados->NRE;
  64 + $objProcesso = $objMetadadosProcedimento->metadados->processo;
  65 + $objDocumento = $objMetadadosProcedimento->metadados->documento;
60 66
61 - //Tratamento para evitar o recebimento simultâneo do mesmo procedimento em serviços/processos concorrentes  
62 - $this->sincronizarRecebimentoProcessos($strNumeroRegistro, $parNumIdentificacaoTramite); 67 + $objProtocolo = isset($objProcesso) ? $objProcesso : $objDocumento;
63 68
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 + $this->objProcedimentoAndamentoRN->setOpts($strNumeroRegistro, $parNumIdentificacaoTramite, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_RECEBIDO));
  70 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Iniciando recebimento de processo externo', 'S'));
69 71
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 - } 72 + //Tratamento para evitar o recebimento simultâneo do mesmo procedimento em serviços/processos concorrentes
  73 + $this->sincronizarRecebimentoProcessos($strNumeroRegistro, $parNumIdentificacaoTramite);
79 74
80 - // Validação dos dados do processo recebido  
81 - $objInfraException = new InfraException();  
82 - $this->validarDadosDestinatario($objInfraException, $objMetadadosProcedimento);  
83 - $objInfraException->lancarValidacoes(); 75 + //Verifica se processo já foi registrado para esse trâmite
  76 + if($this->tramiteRecebimentoRegistrado($strNumeroRegistro, $parNumIdentificacaoTramite)) {
  77 + $this->gravarLogDebug("Trâmite de recebimento $parNumIdentificacaoTramite já registrado para o protocolo " . $objProtocolo->protocolo, 4);
  78 + return;
  79 + }
84 80
85 - #############################INICIA O RECEBIMENTO DOS COMPONENTES DIGITAIS US010################################################  
86 - $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);  
87 - $objTramite = $arrObjTramite[0]; 81 + //Substituir a unidade destinatária para a receptora
  82 + $this->substituirDestinoParaUnidadeReceptora($objMetadadosProcedimento);
88 83
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 - } 84 + // Validação dos dados do processo recebido
  85 + $objInfraException = new InfraException();
  86 + $this->validarDadosDestinatario($objInfraException, $objMetadadosProcedimento);
94 87
95 - $this->validarComponentesDigitais($objProcesso, $parNumIdentificacaoTramite);  
96 - $this->validarExtensaoComponentesDigitais($parNumIdentificacaoTramite, $objProcesso);  
97 - $this->verificarPermissoesDiretorios($parNumIdentificacaoTramite); 88 + $objInfraException->lancarValidacoes();
98 89
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(); 90 + #############################INICIA O RECEBIMENTO DOS COMPONENTES DIGITAIS US010################################################
105 91
106 - //Percorre os componentes que precisam ser recebidos  
107 - foreach($objTramite->componenteDigitalPendenteDeRecebimento as $key => $componentePendente){ 92 + //Obtém lista de componentes digitais que precisam ser obtidos
  93 + $this->validarComponentesDigitais($objProtocolo, $parNumIdentificacaoTramite);
  94 + $this->validarExtensaoComponentesDigitais($parNumIdentificacaoTramite, $objProtocolo);
  95 + $this->verificarPermissoesDiretorios($parNumIdentificacaoTramite);
108 96
109 - if(!is_null($componentePendente)){ 97 + $this->gravarLogDebug("Obtém lista de componentes digitais que precisam ser obtidos", 4);
  98 + $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
  99 + $objTramite = $arrObjTramite[0];
110 100
111 - if(!$this->documentoJaRegistrado($strNumeroRegistro, $parNumIdentificacaoTramite, $componentePendente)){  
112 - $arrayHashPendentes[] = $componentePendente;  
113 - } 101 + if(!is_array($objTramite->componenteDigitalPendenteDeRecebimento)){
  102 + $objTramite->componenteDigitalPendenteDeRecebimento = array($objTramite->componenteDigitalPendenteDeRecebimento);
  103 + }
114 104
115 - //TODO: Download do componente digital é realizado, mesmo já existindo na base de dados, devido a comportamento obrigatório do Barramento para mudança de status  
116 - //Ajuste deverá ser feito em versões futuas  
117 - $arrayHash[] = $componentePendente; 105 + $this->gravarLogDebug("Obtendo metadados dos componentes digitais do processo", 4);
  106 + $arrStrNomeDocumento = $this->listarMetaDadosComponentesDigitais($objProtocolo);
  107 + $receberComponenteDigitalRN = new ReceberComponenteDigitalRN();
  108 + $arrAnexosComponentes = array();
  109 + $arrayHash = array();
  110 + $arrComponentesPendentesRecebimento = array();
118 111
119 - //Obter os dados do componente digital  
120 - $this->gravarLogDebug("Baixando componente digital $key", 6);  
121 - $objComponenteDigital = $this->objProcessoEletronicoRN->receberComponenteDigital($parNumIdentificacaoTramite, $componentePendente, $objTramite->protocolo);  
122 - $arrAnexosComponentes[$key][$componentePendente] = $receberComponenteDigitalRN->copiarComponenteDigitalPastaTemporaria($objComponenteDigital);  
123 - $arrAnexosComponentes[$key]['recebido'] = false; 112 + //Percorre os componentes que precisam ser recebidos
  113 + foreach($objTramite->componenteDigitalPendenteDeRecebimento as $key => $componentePendente){
124 114
125 - //Valida a integridade do hash  
126 - $this->gravarLogDebug("Validando integridade de componente digital $key", 6);  
127 - $receberComponenteDigitalRN->validarIntegridadeDoComponenteDigital($arrAnexosComponentes[$key][$componentePendente], $componentePendente, $parNumIdentificacaoTramite); 115 + if(!is_null($componentePendente)){
  116 + if(!$this->documentoJaRegistrado($strNumeroRegistro, $parNumIdentificacaoTramite, $componentePendente)){
  117 + $arrComponentesPendentesRecebimento[] = $componentePendente;
128 } 118 }
129 - }  
130 119
131 - if(count($arrAnexosComponentes) > 0){  
132 - $receberComponenteDigitalRN->setArrAnexos($arrAnexosComponentes); 120 + //TODO: Download do componente digital é realizado, mesmo já existindo na base de dados, devido a comportamento obrigatório do Barramento para mudança de status
  121 + //Ajuste deverá ser feito em versões futuas
  122 + $arrayHash[] = $componentePendente;
  123 +
  124 + //Obter os dados do componente digital
  125 + $this->gravarLogDebug("Baixando componente digital $key", 6);
  126 + $objComponenteDigital = $this->objProcessoEletronicoRN->receberComponenteDigital($parNumIdentificacaoTramite, $componentePendente, $objTramite->protocolo);
  127 + $arrAnexosComponentes[$key][$componentePendente] = $receberComponenteDigitalRN->copiarComponenteDigitalPastaTemporaria($objComponenteDigital);
  128 + $arrAnexosComponentes[$key]['recebido'] = false;
  129 +
  130 + //Valida a integridade do hash
  131 + $this->gravarLogDebug("Validando integridade de componente digital $key", 6);
  132 + $receberComponenteDigitalRN->validarIntegridadeDoComponenteDigital($arrAnexosComponentes[$key][$componentePendente], $componentePendente, $parNumIdentificacaoTramite);
133 } 133 }
  134 + }
134 135
135 - #############################TERMINA O RECEBIMENTO DOS COMPONENTES DIGITAIS US010################################################ 136 + if(count($arrAnexosComponentes) > 0){
  137 + $receberComponenteDigitalRN->setArrAnexos($arrAnexosComponentes);
  138 + }
136 139
137 - $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);  
138 - $objTramite = $arrObjTramite[0]; 140 + #############################TERMINA O RECEBIMENTO DOS COMPONENTES DIGITAIS US010################################################
  141 + $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
  142 + $objTramite = $arrObjTramite[0];
139 143
140 - //Verifica se o trâmite está recusado  
141 - if($objTramite->situacaoAtual == ProcessoEletronicoRN::$STA_SITUACAO_TRAMITE_RECUSADO) {  
142 - $this->gravarLogDebug("Trâmite $parNumIdentificacaoTramite já se encontra recusado. Cancelando o recebimento do processo", 4);  
143 - return;  
144 - } 144 + //Verifica se o trâmite está recusado
  145 + if($objTramite->situacaoAtual == ProcessoEletronicoRN::$STA_SITUACAO_TRAMITE_RECUSADO) {
  146 + $this->gravarLogDebug("Trâmite $parNumIdentificacaoTramite já se encontra recusado. Cancelando o recebimento do processo", 4);
  147 + return;
  148 + }
145 149
146 - $this->gravarLogDebug("Persistindo/atualizando dados do processo com NRE " . $strNumeroRegistro, 4);  
147 - $objProcedimentoDTO = $this->registrarProcesso($strNumeroRegistro, $parNumIdentificacaoTramite, $objProcesso, $objMetadadosProcedimento);  
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'));  
152 -  
153 - $this->gravarLogDebug("Registrando trâmite externo do processo", 4);  
154 - $objProcessoEletronicoDTO = $this->objProcessoEletronicoRN->cadastrarTramiteDeProcesso(  
155 - $objProcedimentoDTO->getDblIdProcedimento(),  
156 - $strNumeroRegistro,  
157 - $parNumIdentificacaoTramite,  
158 - ProcessoEletronicoRN::$STA_TIPO_TRAMITE_RECEBIMENTO,  
159 - null,  
160 - $objMetadadosProcedimento->metadados->remetente->identificacaoDoRepositorioDeEstruturas,  
161 - $objMetadadosProcedimento->metadados->remetente->numeroDeIdentificacaoDaEstrutura,  
162 - $objMetadadosProcedimento->metadados->destinatario->identificacaoDoRepositorioDeEstruturas,  
163 - $objMetadadosProcedimento->metadados->destinatario->numeroDeIdentificacaoDaEstrutura,  
164 - $objProcesso);  
165 -  
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 - } 150 + $this->gravarLogDebug("Persistindo/atualizando dados do processo com NRE " . $strNumeroRegistro, 4);
  151 + $objProcedimentoDTO = $this->registrarProcesso($strNumeroRegistro, $parNumIdentificacaoTramite, $objProtocolo, $objMetadadosProcedimento);
  152 +
  153 + // @join_tec US008.08 (#23092)
  154 + $this->objProcedimentoAndamentoRN->setOpts($strNumeroRegistro, $parNumIdentificacaoTramite, ProcessoEletronicoRN::obterIdTarefaModulo(ProcessoEletronicoRN::$TI_PROCESSO_ELETRONICO_PROCESSO_RECEBIDO), $objProcedimentoDTO->getDblIdProcedimento());
  155 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Obtendo metadados do processo', 'S'));
  156 +
  157 + $this->gravarLogDebug("Registrando trâmite externo do processo", 4);
  158 + $objProcessoEletronicoDTO = $this->objProcessoEletronicoRN->cadastrarTramiteDeProcesso(
  159 + $objProcedimentoDTO->getDblIdProcedimento(),
  160 + $strNumeroRegistro,
  161 + $parNumIdentificacaoTramite,
  162 + ProcessoEletronicoRN::$STA_TIPO_TRAMITE_RECEBIMENTO,
  163 + null,
  164 + $objMetadadosProcedimento->metadados->remetente->identificacaoDoRepositorioDeEstruturas,
  165 + $objMetadadosProcedimento->metadados->remetente->numeroDeIdentificacaoDaEstrutura,
  166 + $objMetadadosProcedimento->metadados->destinatario->identificacaoDoRepositorioDeEstruturas,
  167 + $objMetadadosProcedimento->metadados->destinatario->numeroDeIdentificacaoDaEstrutura,
  168 + $objProcesso);
  169 +
  170 + //Verifica se o tramite se encontra na situação correta
  171 + $arrObjTramite = $this->objProcessoEletronicoRN->consultarTramites($parNumIdentificacaoTramite);
  172 + if(!isset($arrObjTramite) || count($arrObjTramite) != 1) {
  173 + throw new InfraException("Trâmite não pode ser localizado pelo identificado $parNumIdentificacaoTramite.");
  174 + }
171 175
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 - } 176 + $objTramite = $arrObjTramite[0];
  177 + if($objTramite->situacaoAtual != ProcessoEletronicoRN::$STA_SITUACAO_TRAMITE_COMPONENTES_RECEBIDOS_DESTINATARIO) {
  178 + $this->gravarLogDebug("Desconsiderando recebimento do processo devido a situação de trâmite inconsistente: " . $objTramite->situacaoAtual, 4);
  179 + return;
  180 + }
177 181
178 - if(count($arrayHashPendentes) > 0){  
179 - //Obter dados dos componetes digitais  
180 - $this->gravarLogDebug("Iniciando o recebimento dos componentes digitais pendentes", 4);  
181 - $objComponenteDigitalDTO = new ComponenteDigitalDTO();  
182 - $objComponenteDigitalDTO->setStrNumeroRegistro($strNumeroRegistro);  
183 - $objComponenteDigitalDTO->setNumIdTramite($parNumIdentificacaoTramite);  
184 - $objComponenteDigitalDTO->setStrHashConteudo($arrayHash, InfraDTO::$OPER_IN);  
185 - $objComponenteDigitalDTO->setOrdNumOrdem(InfraDTO::$TIPO_ORDENACAO_ASC);  
186 - $objComponenteDigitalDTO->retDblIdDocumento();  
187 - $objComponenteDigitalDTO->retNumTicketEnvioComponentes();  
188 - $objComponenteDigitalDTO->retStrProtocoloDocumentoFormatado();  
189 - $objComponenteDigitalDTO->retStrHashConteudo();  
190 - $objComponenteDigitalDTO->retStrProtocolo();  
191 - $objComponenteDigitalDTO->retStrNumeroRegistro();  
192 - $objComponenteDigitalDTO->retNumIdTramite();  
193 - $objComponenteDigitalDTO->retStrNome();  
194 - $objComponenteDigitalDTO->retStrStaEstadoProtocolo();  
195 -  
196 - $objComponenteDigitalBD = new ComponenteDigitalBD($this->getObjInfraIBanco());  
197 - $arrObjComponentesDigitaisDTO = $objComponenteDigitalBD->listar($objComponenteDigitalDTO);  
198 -  
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);  
206 -  
207 - // @join_tec US008.09 (#23092)  
208 - $strMensagemRecebimento = sprintf('Recebendo %s %s', $strNomeDocumento, $objComponenteDigitalDTOEnviado->getStrProtocoloDocumentoFormatado());  
209 - $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento($strMensagemRecebimento, 'S'));  
210 - $this->gravarLogDebug($strMensagemRecebimento, 6);  
211 - } 182 + if(count($arrComponentesPendentesRecebimento) > 0){
  183 + //Obter dados dos componetes digitais
  184 + $this->gravarLogDebug("Iniciando o recebimento dos componentes digitais pendentes", 4);
  185 + $objComponenteDigitalDTO = new ComponenteDigitalDTO();
  186 + $objComponenteDigitalDTO->setStrNumeroRegistro($strNumeroRegistro);
  187 + $objComponenteDigitalDTO->setNumIdTramite($parNumIdentificacaoTramite);
  188 + $objComponenteDigitalDTO->setStrHashConteudo($arrayHash, InfraDTO::$OPER_IN);
  189 + $objComponenteDigitalDTO->setOrdNumOrdem(InfraDTO::$TIPO_ORDENACAO_ASC);
  190 + $objComponenteDigitalDTO->retDblIdDocumento();
  191 + $objComponenteDigitalDTO->retNumTicketEnvioComponentes();
  192 + $objComponenteDigitalDTO->retStrProtocoloDocumentoFormatado();
  193 + $objComponenteDigitalDTO->retStrHashConteudo();
  194 + $objComponenteDigitalDTO->retStrProtocolo();
  195 + $objComponenteDigitalDTO->retStrNumeroRegistro();
  196 + $objComponenteDigitalDTO->retNumIdTramite();
  197 + $objComponenteDigitalDTO->retStrNome();
  198 + $objComponenteDigitalDTO->retStrStaEstadoProtocolo();
  199 +
  200 + $objComponenteDigitalBD = new ComponenteDigitalBD($this->getObjInfraIBanco());
  201 + $arrObjComponentesDigitaisDTO = $objComponenteDigitalBD->listar($objComponenteDigitalDTO);
  202 +
  203 + if ($objComponenteDigitalBD->contar($objComponenteDigitalDTO) > 0) {
  204 + $objReceberComponenteDigitalRN = $receberComponenteDigitalRN;
  205 + foreach($arrObjComponentesDigitaisDTO as $objComponenteDigitalDTOEnviado) {
  206 + if($objComponenteDigitalDTOEnviado->getStrStaEstadoProtocolo() != ProtocoloRN::$TE_DOCUMENTO_CANCELADO){
  207 + $strHash = $objComponenteDigitalDTOEnviado->getStrHashConteudo();
  208 + $strNomeDocumento = (array_key_exists($strHash, $arrStrNomeDocumento)) ? $arrStrNomeDocumento[$strHash]['especieNome'] : '[Desconhecido]';
  209 + $objReceberComponenteDigitalRN->receberComponenteDigital($objComponenteDigitalDTOEnviado);
  210 +
  211 + // @join_tec US008.09 (#23092)
  212 + $strMensagemRecebimento = sprintf('Recebendo %s %s', $strNomeDocumento, $objComponenteDigitalDTOEnviado->getStrProtocoloDocumentoFormatado());
  213 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento($strMensagemRecebimento, 'S'));
  214 + $this->gravarLogDebug($strMensagemRecebimento, 6);
212 } 215 }
213 - // @join_tec US008.10 (#23092)  
214 - $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Todos os componentes digitais foram recebidos', 'S'));  
215 - }else{  
216 - $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Nenhum componente digital para receber', 'S'));  
217 } 216 }
  217 + // @join_tec US008.10 (#23092)
  218 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Todos os componentes digitais foram recebidos', 'S'));
  219 + }else{
  220 + $this->objProcedimentoAndamentoRN->cadastrar(ProcedimentoAndamentoDTO::criarAndamento('Nenhum componente digital para receber', 'S'));
218 } 221 }
219 } 222 }
  223 +
220 //$this->fecharProcedimentoEmOutraUnidades($objProcedimentoDTO, $objMetadadosProcedimento); 224 //$this->fecharProcedimentoEmOutraUnidades($objProcedimentoDTO, $objMetadadosProcedimento);
221 $this->gravarLogDebug("Enviando recibo de conclusão do trâmite $parNumIdentificacaoTramite", 6); 225 $this->gravarLogDebug("Enviando recibo de conclusão do trâmite $parNumIdentificacaoTramite", 6);
222 $objEnviarReciboTramiteRN = new EnviarReciboTramiteRN(); 226 $objEnviarReciboTramiteRN = new EnviarReciboTramiteRN();
@@ -234,6 +238,20 @@ class ReceberProcedimentoRN extends InfraRN @@ -234,6 +238,20 @@ class ReceberProcedimentoRN extends InfraRN
234 } 238 }
235 } 239 }
236 240
  241 +
  242 + private function substituirDestinoParaUnidadeReceptora($parObjMetadadosTramite)
  243 + {
  244 + if (isset($parObjMetadadosTramite->metadados->unidadeReceptora)) {
  245 + $unidadeReceptora = $parObjMetadadosTramite->metadados->unidadeReceptora;
  246 + $this->destinatarioReal = $parObjMetadadosTramite->metadados->destinatario;
  247 + $parObjMetadadosTramite->metadados->destinatario->identificacaoDoRepositorioDeEstruturas = $unidadeReceptora->identificacaoDoRepositorioDeEstruturas;
  248 + $parObjMetadadosTramite->metadados->destinatario->numeroDeIdentificacaoDaEstrutura = $unidadeReceptora->numeroDeIdentificacaoDaEstrutura;
  249 + $numUnidadeReceptora = $unidadeReceptora->numeroDeIdentificacaoDaEstrutura;
  250 + $this->gravarLogDebug("Atribuindo unidade receptora $numUnidadeReceptora para o trâmite $parNumIdentificacaoTramite", 4);
  251 + }
  252 + }
  253 +
  254 +
237 public function fecharProcedimentoEmOutraUnidades(ProcedimentoDTO $objProcedimentoDTO, $parObjMetadadosProcedimento){ 255 public function fecharProcedimentoEmOutraUnidades(ProcedimentoDTO $objProcedimentoDTO, $parObjMetadadosProcedimento){
238 256
239 $objPenUnidadeDTO = new PenUnidadeDTO(); 257 $objPenUnidadeDTO = new PenUnidadeDTO();
@@ -284,16 +302,15 @@ class ReceberProcedimentoRN extends InfraRN @@ -284,16 +302,15 @@ class ReceberProcedimentoRN extends InfraRN
284 * 302 *
285 * @return array[String] 303 * @return array[String]
286 */ 304 */
287 - private function listarMetaDadosComponentesDigitais($objProcesso){ 305 + private function listarMetaDadosComponentesDigitais($objProtocolo){
288 306
289 - $objMapBD = new GenericoBD($this->getObjInfraIBanco());  
290 $arrMetadadoDocumento = array(); 307 $arrMetadadoDocumento = array();
291 - $arrObjDocumento = is_array($objProcesso->documento) ? $objProcesso->documento : array($objProcesso->documento); 308 + $objMapBD = new GenericoBD($this->getObjInfraIBanco());
292 309
293 - foreach($arrObjDocumento as $objDocumento){ 310 + $arrObjDocumento = $this->obterDocumentosProtocolo($objProtocolo);
294 311
  312 + foreach($arrObjDocumento as $objDocumento){
295 $strHash = ProcessoEletronicoRN::getHashFromMetaDados($objDocumento->componenteDigital->hash); 313 $strHash = ProcessoEletronicoRN::getHashFromMetaDados($objDocumento->componenteDigital->hash);
296 -  
297 $objMapDTO = new PenRelTipoDocMapRecebidoDTO(true); 314 $objMapDTO = new PenRelTipoDocMapRecebidoDTO(true);
298 $objMapDTO->setNumMaxRegistrosRetorno(1); 315 $objMapDTO->setNumMaxRegistrosRetorno(1);
299 $objMapDTO->setNumCodigoEspecie($objDocumento->especie->codigo); 316 $objMapDTO->setNumCodigoEspecie($objDocumento->especie->codigo);
@@ -320,9 +337,9 @@ class ReceberProcedimentoRN extends InfraRN @@ -320,9 +337,9 @@ class ReceberProcedimentoRN extends InfraRN
320 * Valida cada componente digital, se não algum não for aceito recusa o tramite 337 * Valida cada componente digital, se não algum não for aceito recusa o tramite
321 * do procedimento para esta unidade 338 * do procedimento para esta unidade
322 */ 339 */
323 - private function validarComponentesDigitais($objProcesso, $parNumIdentificacaoTramite){  
324 -  
325 - $arrObjDocumentos = is_array($objProcesso->documento) ? $objProcesso->documento : array($objProcesso->documento); 340 + private function validarComponentesDigitais($parObjProtocolo, $parNumIdentificacaoTramite)
  341 + {
  342 + $arrObjDocumentos = $this->obterDocumentosProtocolo($parObjProtocolo);
326 343
327 foreach($arrObjDocumentos as $objDocument){ 344 foreach($arrObjDocumentos as $objDocument){
328 345
@@ -363,13 +380,24 @@ class ReceberProcedimentoRN extends InfraRN @@ -363,13 +380,24 @@ class ReceberProcedimentoRN extends InfraRN
363 380
364 } 381 }
365 382
  383 + private function obterDocumentosProtocolo($parObjProtocolo)
  384 + {
  385 + $arrObjDocumento = array();
  386 + if(isset($parObjProtocolo->documento)){
  387 + $arrObjDocumento = is_array($parObjProtocolo->documento) ? $parObjProtocolo->documento : array($parObjProtocolo->documento);
  388 + } else {
  389 + $arrObjDocumento = array($parObjProtocolo);
  390 + }
366 391
367 - private function registrarProcesso($parStrNumeroRegistro, $parNumIdentificacaoTramite, $parObjProcesso, $parObjMetadadosProcedimento) 392 + return $arrObjDocumento;
  393 + }
  394 +
  395 + private function registrarProcesso($parStrNumeroRegistro, $parNumIdentificacaoTramite, $parObjProtocolo, $parObjMetadadosProcedimento)
368 { 396 {
369 // Validação dos dados do processo recebido 397 // Validação dos dados do processo recebido
370 $objInfraException = new InfraException(); 398 $objInfraException = new InfraException();
371 - $this->validarDadosProcesso($objInfraException, $parObjProcesso);  
372 - $this->validarDadosDocumentos($objInfraException, $parObjProcesso); 399 + $this->validarDadosProcesso($objInfraException, $parObjProtocolo);
  400 + $this->validarDadosDocumentos($objInfraException, $parObjProtocolo);
373 401
374 //TODO: Regra de Negócio - Processos recebidos pelo Barramento não poderão disponibilizar a opção de reordenação e cancelamento de documentos 402 //TODO: Regra de Negócio - Processos recebidos pelo Barramento não poderão disponibilizar a opção de reordenação e cancelamento de documentos
375 //para o usuário final, mesmo possuindo permissão para isso 403 //para o usuário final, mesmo possuindo permissão para isso
@@ -377,20 +405,20 @@ class ReceberProcedimentoRN extends InfraRN @@ -377,20 +405,20 @@ class ReceberProcedimentoRN extends InfraRN
377 $objInfraException->lancarValidacoes(); 405 $objInfraException->lancarValidacoes();
378 406
379 //Verificar se procedimento já existia na base de dados do sistema 407 //Verificar se procedimento já existia na base de dados do sistema
380 - $dblIdProcedimento = $this->consultarProcedimentoExistente($parStrNumeroRegistro, $parObjProcesso->protocolo); 408 + $dblIdProcedimento = $this->consultarProcedimentoExistente($parStrNumeroRegistro, $parObjProtocolo->protocolo);
381 409
382 if(isset($dblIdProcedimento)){ 410 if(isset($dblIdProcedimento)){
383 - $objProcedimentoDTO = $this->atualizarProcedimento($dblIdProcedimento, $parObjMetadadosProcedimento, $parObjProcesso); 411 + $objProcedimentoDTO = $this->atualizarProcedimento($dblIdProcedimento, $parObjMetadadosProcedimento, $parObjProtocolo);
384 } 412 }
385 else { 413 else {
386 - $objProcedimentoDTO = $this->gerarProcedimento($parObjMetadadosProcedimento, $parObjProcesso); 414 + $objProcedimentoDTO = $this->gerarProcedimento($parObjMetadadosProcedimento, $parObjProtocolo);
387 } 415 }
388 416
389 //TODO: Fazer o envio de cada um dos procedimentos apensados (Processo principal e seus apensados, caso exista) 417 //TODO: Fazer o envio de cada um dos procedimentos apensados (Processo principal e seus apensados, caso exista)
390 //... 418 //...
391 419
392 //Chamada recursiva para registro dos processos apensados 420 //Chamada recursiva para registro dos processos apensados
393 - if(isset($objProcesso->processoApensado)) { 421 + if(isset($objProtocolo->processoApensado)) {
394 if(!is_array($objProcesso->processoApensado)) { 422 if(!is_array($objProcesso->processoApensado)) {
395 $objProcesso->processoApensado = array($objProcesso->processoApensado); 423 $objProcesso->processoApensado = array($objProcesso->processoApensado);
396 } 424 }
@@ -599,7 +627,7 @@ class ReceberProcedimentoRN extends InfraRN @@ -599,7 +627,7 @@ class ReceberProcedimentoRN extends InfraRN
599 $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO); 627 $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
600 } 628 }
601 629
602 - private function gerarProcedimento($objMetadadosProcedimento, $objProcesso){ 630 + private function gerarProcedimento($objMetadadosProcedimento, $parObjProtocolo){
603 631
604 if(!isset($objMetadadosProcedimento)){ 632 if(!isset($objMetadadosProcedimento)){
605 throw new InfraException('Parâmetro $objMetadadosProcedimento não informado.'); 633 throw new InfraException('Parâmetro $objMetadadosProcedimento não informado.');
@@ -607,31 +635,31 @@ class ReceberProcedimentoRN extends InfraRN @@ -607,31 +635,31 @@ class ReceberProcedimentoRN extends InfraRN
607 635
608 //TODO: Usar dados do destinatário em outro método específico para envio 636 //TODO: Usar dados do destinatário em outro método específico para envio
609 // Dados do procedimento enviados pelos órgão externo integrado ao PEN 637 // Dados do procedimento enviados pelos órgão externo integrado ao PEN
610 - //$objProcesso = $objMetadadosProcedimento->metadados->processo; 638 + //$parObjProtocolo = $objMetadadosProcedimento->metadados->processo;
611 $objRemetente = $objMetadadosProcedimento->metadados->remetente; 639 $objRemetente = $objMetadadosProcedimento->metadados->remetente;
612 $objDestinatario = $objMetadadosProcedimento->metadados->destinatario; 640 $objDestinatario = $objMetadadosProcedimento->metadados->destinatario;
613 641
614 //TODO: TESTES DE RECEBIMENTO DE PROCESSOS 642 //TODO: TESTES DE RECEBIMENTO DE PROCESSOS
615 //REMOVER APOS TESTES DO SISTEMA 643 //REMOVER APOS TESTES DO SISTEMA
616 - //$objProcesso->protocolo = rand(100000000, 999999999); 644 + //$parObjProtocolo->protocolo = rand(100000000, 999999999);
617 645
618 //Atribuição de dados do protocolo 646 //Atribuição de dados do protocolo
619 //TODO: Validar cada uma das informações de entrada do webservice 647 //TODO: Validar cada uma das informações de entrada do webservice
620 $objProtocoloDTO = new ProtocoloDTO(); 648 $objProtocoloDTO = new ProtocoloDTO();
621 $objProtocoloDTO->setDblIdProtocolo(null); 649 $objProtocoloDTO->setDblIdProtocolo(null);
622 - $objProtocoloDTO->setStrDescricao(utf8_decode($objProcesso->descricao));  
623 - $objProtocoloDTO->setStrStaNivelAcessoLocal($this->obterNivelSigiloSEI($objProcesso->nivelDeSigilo)); 650 + $objProtocoloDTO->setStrDescricao(utf8_decode($parObjProtocolo->descricao));
  651 + $objProtocoloDTO->setStrStaNivelAcessoLocal($this->obterNivelSigiloSEI($parObjProtocolo->nivelDeSigilo));
624 652
625 - if($this->obterNivelSigiloSEI($objProcesso->nivelDeSigilo) == ProtocoloRN::$NA_RESTRITO){ 653 + if($this->obterNivelSigiloSEI($parObjProtocolo->nivelDeSigilo) == ProtocoloRN::$NA_RESTRITO){
626 $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN(); 654 $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
627 $objPenParametroRN = new PenParametroRN(); 655 $objPenParametroRN = new PenParametroRN();
628 $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO'); 656 $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO');
629 657
630 - if (!isset($objProcesso->hipoteseLegal) || (isset($objProcesso->hipoteseLegal) && empty($objProcesso->hipoteseLegal->identificacao))) { 658 + if (!isset($parObjProtocolo->hipoteseLegal) || (isset($parObjProtocolo->hipoteseLegal) && empty($parObjProtocolo->hipoteseLegal->identificacao))) {
631 $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao); 659 $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
632 } else { 660 } else {
633 661
634 - $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($objProcesso->hipoteseLegal->identificacao); 662 + $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($parObjProtocolo->hipoteseLegal->identificacao);
635 if (empty($numIdHipoteseLegal)) { 663 if (empty($numIdHipoteseLegal)) {
636 $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao); 664 $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
637 } else { 665 } else {
@@ -640,16 +668,19 @@ class ReceberProcedimentoRN extends InfraRN @@ -640,16 +668,19 @@ class ReceberProcedimentoRN extends InfraRN
640 } 668 }
641 } 669 }
642 670
643 - $objProtocoloDTO->setStrProtocoloFormatado(utf8_decode($objProcesso->protocolo));  
644 - $objProtocoloDTO->setDtaGeracao($this->objProcessoEletronicoRN->converterDataSEI($objProcesso->dataHoraDeProducao)); 671 + $objProtocoloDTO->setStrProtocoloFormatado(utf8_decode($parObjProtocolo->protocolo));
  672 + $objProtocoloDTO->setDtaGeracao($this->parObjProtocoloEletronicoRN->converterDataSEI($parObjProtocolo->dataHoraDeProducao));
645 $objProtocoloDTO->setArrObjAnexoDTO(array()); 673 $objProtocoloDTO->setArrObjAnexoDTO(array());
646 $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array()); 674 $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());
647 $objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array()); 675 $objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array());
648 //$objProtocoloDTO->setStrStaEstado(ProtocoloRN::$TE_BLOQUEADO); 676 //$objProtocoloDTO->setStrStaEstado(ProtocoloRN::$TE_BLOQUEADO);
649 - $this->atribuirParticipantes($objProtocoloDTO, $objProcesso->interessado); 677 + $this->atribuirParticipantes($objProtocoloDTO, $parObjProtocolo->interessado);
650 678
651 - $strDescricao = sprintf('Tipo de processo no órgão de origem: %s', utf8_decode($objProcesso->processoDeNegocio)).PHP_EOL;  
652 - $strDescricao .= $objProcesso->observacao; 679 + $strDescricao = "";
  680 + if(isset($parObjProtocolo->processoDeNegocio)){
  681 + $strDescricao = sprintf('Tipo de processo no órgão de origem: %s', utf8_decode($parObjProtocolo->processoDeNegocio)).PHP_EOL;
  682 + $strDescricao .= $parObjProtocolo->observacao;
  683 + }
653 684
654 $objObservacaoDTO = new ObservacaoDTO(); 685 $objObservacaoDTO = new ObservacaoDTO();
655 686
@@ -667,8 +698,6 @@ class ReceberProcedimentoRN extends InfraRN @@ -667,8 +698,6 @@ class ReceberProcedimentoRN extends InfraRN
667 $objObservacaoDTO->setStrDescricao($strDescricao); 698 $objObservacaoDTO->setStrDescricao($strDescricao);
668 } 699 }
669 700
670 - //throw new InfraException(var_export($objObservacaoDTO, true));  
671 -  
672 $objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO)); 701 $objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO));
673 702
674 //Atribuição de dados do procedimento 703 //Atribuição de dados do procedimento
@@ -676,17 +705,15 @@ class ReceberProcedimentoRN extends InfraRN @@ -676,17 +705,15 @@ class ReceberProcedimentoRN extends InfraRN
676 $objProcedimentoDTO = new ProcedimentoDTO(); 705 $objProcedimentoDTO = new ProcedimentoDTO();
677 $objProcedimentoDTO->setDblIdProcedimento(null); 706 $objProcedimentoDTO->setDblIdProcedimento(null);
678 $objProcedimentoDTO->setObjProtocoloDTO($objProtocoloDTO); 707 $objProcedimentoDTO->setObjProtocoloDTO($objProtocoloDTO);
679 - $objProcedimentoDTO->setStrNomeTipoProcedimento(utf8_decode($objProcesso->processoDeNegocio));  
680 - $objProcedimentoDTO->setDtaGeracaoProtocolo($this->objProcessoEletronicoRN->converterDataSEI($objProcesso->dataHoraDeProducao));  
681 - $objProcedimentoDTO->setStrProtocoloProcedimentoFormatado(utf8_decode($objProcesso->protocolo)); 708 + $objProcedimentoDTO->setDtaGeracaoProtocolo($this->parObjProtocoloEletronicoRN->converterDataSEI($parObjProtocolo->dataHoraDeProducao));
  709 + $objProcedimentoDTO->setStrProtocoloProcedimentoFormatado(utf8_decode($parObjProtocolo->protocolo));
682 $objProcedimentoDTO->setStrSinGerarPendencia('S'); 710 $objProcedimentoDTO->setStrSinGerarPendencia('S');
683 - // $objProcedimentoDTO->setNumVersaoLock(0); //TODO: Avaliar o comportamento desse campo no cadastro do processo  
684 $objProcedimentoDTO->setArrObjDocumentoDTO(array()); 711 $objProcedimentoDTO->setArrObjDocumentoDTO(array());
685 712
686 //TODO: Identificar o tipo de procedimento correto para atribuição ao novo processo 713 //TODO: Identificar o tipo de procedimento correto para atribuição ao novo processo
687 $objPenParametroRN = new PenParametroRN(); 714 $objPenParametroRN = new PenParametroRN();
688 $numIdTipoProcedimento = $objPenParametroRN->getParametro('PEN_TIPO_PROCESSO_EXTERNO'); 715 $numIdTipoProcedimento = $objPenParametroRN->getParametro('PEN_TIPO_PROCESSO_EXTERNO');
689 - $this->atribuirTipoProcedimento($objProcedimentoDTO, $numIdTipoProcedimento, $objProcesso->processoDeNegocio); 716 + $this->atribuirTipoProcedimento($objProcedimentoDTO, $numIdTipoProcedimento);
690 717
691 //TODO: Obter código da unidade através de mapeamento entre SEI e Barramento 718 //TODO: Obter código da unidade através de mapeamento entre SEI e Barramento
692 $objUnidadeDTO = $this->atribuirDadosUnidade($objProcedimentoDTO, $objDestinatario); 719 $objUnidadeDTO = $this->atribuirDadosUnidade($objProcedimentoDTO, $objDestinatario);
@@ -695,18 +722,16 @@ class ReceberProcedimentoRN extends InfraRN @@ -695,18 +722,16 @@ class ReceberProcedimentoRN extends InfraRN
695 //... 722 //...
696 723
697 //TODO: Atribuir Dados do produtor do processo 724 //TODO: Atribuir Dados do produtor do processo
698 - //$this->atribuirProdutorProcesso($objProcesso, 725 + //$this->atribuirProdutorProcesso($parObjProtocolo,
699 // $objProcedimentoDTO->getNumIdUsuarioGeradorProtocolo(), 726 // $objProcedimentoDTO->getNumIdUsuarioGeradorProtocolo(),
700 // $objProcedimentoDTO->getNumIdUnidadeGeradoraProtocolo()); 727 // $objProcedimentoDTO->getNumIdUnidadeGeradoraProtocolo());
701 728
702 729
703 -  
704 -  
705 //TODO:Adicionar demais informações do processo 730 //TODO:Adicionar demais informações do processo
706 //<protocoloAnterior> 731 //<protocoloAnterior>
707 //<historico> 732 //<historico>
708 733
709 - //$objProcesso->idProcedimentoSEI = $dblIdProcedimento; 734 + //$parObjProtocolo->idProcedimentoSEI = $dblIdProcedimento;
710 735
711 //TODO: Avaliar necessidade de tal recurso 736 //TODO: Avaliar necessidade de tal recurso
712 //FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(true); 737 //FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(true);
@@ -721,12 +746,12 @@ class ReceberProcedimentoRN extends InfraRN @@ -721,12 +746,12 @@ class ReceberProcedimentoRN extends InfraRN
721 $objProcedimentoDTO->setDblIdProcedimento($objProcedimentoDTOGerado->getDblIdProcedimento()); 746 $objProcedimentoDTO->setDblIdProcedimento($objProcedimentoDTOGerado->getDblIdProcedimento());
722 747
723 $this->registrarAndamentoRecebimentoProcesso($objProcedimentoDTO, $objMetadadosProcedimento); 748 $this->registrarAndamentoRecebimentoProcesso($objProcedimentoDTO, $objMetadadosProcedimento);
724 - $this->atribuirDocumentos($objProcedimentoDTO, $objProcesso, $objUnidadeDTO, $objMetadadosProcedimento); 749 + $this->atribuirDocumentos($objProcedimentoDTO, $parObjProtocolo, $objUnidadeDTO, $objMetadadosProcedimento);
725 $this->registrarProcedimentoNaoVisualizado($objProcedimentoDTOGerado); 750 $this->registrarProcedimentoNaoVisualizado($objProcedimentoDTOGerado);
726 751
727 //TODO: Avaliar necessidade de restringir referência circular entre processos 752 //TODO: Avaliar necessidade de restringir referência circular entre processos
728 //TODO: Registrar que o processo foi recebido com outros apensados. Necessário para posterior reenvio 753 //TODO: Registrar que o processo foi recebido com outros apensados. Necessário para posterior reenvio
729 - $this->atribuirProcessosApensados($objProcedimentoDTO, $objProcesso->processoApensado); 754 + $this->atribuirProcessosApensados($objProcedimentoDTO, $parObjProtocolo->processoApensado);
730 755
731 //TODO: Finalizar o envio do documento para a respectiva unidade 756 //TODO: Finalizar o envio do documento para a respectiva unidade
732 $this->enviarProcedimentoUnidade($objProcedimentoDTO); 757 $this->enviarProcedimentoUnidade($objProcedimentoDTO);
@@ -977,29 +1002,24 @@ class ReceberProcedimentoRN extends InfraRN @@ -977,29 +1002,24 @@ class ReceberProcedimentoRN extends InfraRN
977 1002
978 //TODO: Grande parte da regra de negócio se baseou em SEIRN:199 - incluirDocumento. 1003 //TODO: Grande parte da regra de negócio se baseou em SEIRN:199 - incluirDocumento.
979 //Avaliar a refatoração para impedir a duplicação de código 1004 //Avaliar a refatoração para impedir a duplicação de código
980 - private function atribuirDocumentos($objProcedimentoDTO, $objProcesso, $objUnidadeDTO, $parObjMetadadosProcedimento) 1005 + private function atribuirDocumentos($objProcedimentoDTO, $parObjProtocolo, $objUnidadeDTO, $parObjMetadadosProcedimento)
981 { 1006 {
982 -  
983 - if(!isset($objProcesso)) {  
984 - throw new InfraException('Parâmetro $objProcesso não informado.'); 1007 + if(!isset($parObjProtocolo)) {
  1008 + throw new InfraException('Parâmetro $parObjProtocolo não informado.');
985 } 1009 }
986 1010
987 if(!isset($objUnidadeDTO)) { 1011 if(!isset($objUnidadeDTO)) {
988 throw new InfraException('Unidade responsável pelo documento não informada.'); 1012 throw new InfraException('Unidade responsável pelo documento não informada.');
989 } 1013 }
990 1014
991 - if(!isset($objProcesso->documento)) {  
992 - throw new InfraException('Lista de documentos do processo não informada.');  
993 - } 1015 + $arrObjDocumento = $this->obterDocumentosProtocolo($objProtocolo);
994 1016
995 - $arrObjDocumentos = $objProcesso->documento;  
996 - if(!is_array($arrObjDocumentos)) {  
997 - $arrObjDocumentos = array($arrObjDocumentos); 1017 + if(!isset($arrObjDocumento) || count($arrObjDocumento) == 0) {
  1018 + throw new InfraException('Lista de documentos não informada.');
998 } 1019 }
999 1020
1000 $strNumeroRegistro = $parObjMetadadosProcedimento->metadados->NRE; 1021 $strNumeroRegistro = $parObjMetadadosProcedimento->metadados->NRE;
1001 //$numTramite = $parObjMetadadosProcedimento->metadados->IDT; 1022 //$numTramite = $parObjMetadadosProcedimento->metadados->IDT;
1002 -  
1003 //Ordenação dos documentos conforme informado pelo remetente. Campo documento->ordem 1023 //Ordenação dos documentos conforme informado pelo remetente. Campo documento->ordem
1004 usort($arrObjDocumentos, array("ReceberProcedimentoRN", "comparacaoOrdemDocumentos")); 1024 usort($arrObjDocumentos, array("ReceberProcedimentoRN", "comparacaoOrdemDocumentos"));
1005 1025
@@ -1023,152 +1043,149 @@ class ReceberProcedimentoRN extends InfraRN @@ -1023,152 +1043,149 @@ class ReceberProcedimentoRN extends InfraRN
1023 foreach($arrObjDocumentos as $objDocumento){ 1043 foreach($arrObjDocumentos as $objDocumento){
1024 1044
1025 // @join_tec US027 (#3498) 1045 // @join_tec US027 (#3498)
1026 - if(isset($objDocumento->retirado) && $objDocumento->retirado === true) { 1046 + if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {
1027 //$strHashConteudo = ProcessoEletronicoRN::getHashFromMetaDados($objDocumento->componenteDigital->hash); 1047 //$strHashConteudo = ProcessoEletronicoRN::getHashFromMetaDados($objDocumento->componenteDigital->hash);
1028 // Caso já esteja cadastrado, de um reenvio anterior, então move para bloqueado 1048 // Caso já esteja cadastrado, de um reenvio anterior, então move para bloqueado
1029 - if(array_key_exists($objDocumento->ordem, $arrObjComponenteDigitalDTOIndexado)) { 1049 + if(array_key_exists($objDocumento->ordem, $arrObjComponenteDigitalDTOIndexado)) {
1030 1050
1031 //Busca o ID do protocolo 1051 //Busca o ID do protocolo
1032 //$dblIdProtocolo = $arrStrHashConteudo[$strHashConteudo]; 1052 //$dblIdProtocolo = $arrStrHashConteudo[$strHashConteudo];
1033 - $objComponenteIndexado = $arrObjComponenteDigitalDTOIndexado[$objDocumento->ordem];  
1034 - $dblIdProtocolo = $objComponenteIndexado->getDblIdDocumento(); 1053 + $objComponenteIndexado = $arrObjComponenteDigitalDTOIndexado[$objDocumento->ordem];
  1054 + $dblIdProtocolo = $objComponenteIndexado->getDblIdDocumento();
1035 1055
1036 //Instancia o DTO do protocolo 1056 //Instancia o DTO do protocolo
1037 - $objProtocoloDTO = new ProtocoloDTO();  
1038 - $objProtocoloDTO->setDblIdProtocolo($dblIdProtocolo);  
1039 - $objProtocoloDTO->retStrStaEstado(); 1057 + $objProtocoloDTO = new ProtocoloDTO();
  1058 + $objProtocoloDTO->setDblIdProtocolo($dblIdProtocolo);
  1059 + $objProtocoloDTO->retStrStaEstado();
1040 1060
1041 - $objProtocoloDTO = $objProtocoloBD->consultar($objProtocoloDTO); 1061 + $objProtocoloDTO = $objProtocoloBD->consultar($objProtocoloDTO);
1042 1062
1043 - if($objProtocoloDTO->getStrStaEstado() != ProtocoloRN::$TE_DOCUMENTO_CANCELADO){ 1063 + if($objProtocoloDTO->getStrStaEstado() != ProtocoloRN::$TE_DOCUMENTO_CANCELADO){
1044 //Instancia o DTO do protocolo 1064 //Instancia o DTO do protocolo
1045 - $objEntradaCancelarDocumentoAPI = new EntradaCancelarDocumentoAPI();  
1046 - $objEntradaCancelarDocumentoAPI->setIdDocumento($dblIdProtocolo);  
1047 - $objEntradaCancelarDocumentoAPI->setMotivo('Cancelado pelo remetente');  
1048 -  
1049 - $objSeiRN->cancelarDocumento($objEntradaCancelarDocumentoAPI); 1065 + $objEntradaCancelarDocumentoAPI = new EntradaCancelarDocumentoAPI();
  1066 + $objEntradaCancelarDocumentoAPI->setIdDocumento($dblIdProtocolo);
  1067 + $objEntradaCancelarDocumentoAPI->setMotivo('Cancelado pelo remetente');
  1068 + $objSeiRN->cancelarDocumento($objEntradaCancelarDocumentoAPI);
  1069 + }
1050 1070
1051 - }  
1052 - continue;  
1053 - }  
1054 - } 1071 + continue;
  1072 + }
  1073 + }
1055 1074
1056 - if(array_key_exists($objDocumento->ordem, $arrObjComponenteDigitalDTOIndexado)){  
1057 - $objComponenteDigitalDTO = $arrObjComponenteDigitalDTOIndexado[$objDocumento->ordem];  
1058 - $this->alterarMetadadosDocumento($objComponenteDigitalDTO->getDblIdDocumento(), $objDocumento);  
1059 - continue;  
1060 - } 1075 + if(array_key_exists($objDocumento->ordem, $arrObjComponenteDigitalDTOIndexado)){
  1076 + $objComponenteDigitalDTO = $arrObjComponenteDigitalDTOIndexado[$objDocumento->ordem];
  1077 + $this->alterarMetadadosDocumento($objComponenteDigitalDTO->getDblIdDocumento(), $objDocumento);
  1078 + continue;
  1079 + }
1061 1080
1062 //Validação dos dados dos documentos 1081 //Validação dos dados dos documentos
1063 - if(!isset($objDocumento->especie)){  
1064 - throw new InfraException('Espécie do documento ['.$objDocumento->descricao.'] não informada.');  
1065 -} 1082 + if(!isset($objDocumento->especie)){
  1083 + throw new InfraException('Espécie do documento ['.$objDocumento->descricao.'] não informada.');
  1084 + }
1066 1085
1067 -//--------------------------------------------------------------------------------------------------- 1086 + //---------------------------------------------------------------------------------------------------
  1087 + $objDocumentoDTO = new DocumentoDTO();
  1088 + $objDocumentoDTO->setDblIdDocumento(null);
  1089 + $objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento());
1068 1090
1069 -$objDocumentoDTO = new DocumentoDTO();  
1070 -$objDocumentoDTO->setDblIdDocumento(null);  
1071 -$objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento()); 1091 + $objSerieDTO = $this->obterSerieMapeada($objDocumento->especie->codigo);
1072 1092
1073 -$objSerieDTO = $this->obterSerieMapeada($objDocumento->especie->codigo); 1093 + if ($objSerieDTO==null){
  1094 + throw new InfraException('Tipo de documento [Espécie '.$objDocumento->especie->codigo.'] não encontrado.');
  1095 + }
1074 1096
1075 -if ($objSerieDTO==null){  
1076 - throw new InfraException('Tipo de documento [Espécie '.$objDocumento->especie->codigo.'] não encontrado.');  
1077 -} 1097 + if (InfraString::isBolVazia($objDocumento->dataHoraDeProducao)) {
  1098 + $objInfraException->lancarValidacao('Data do documento não informada.');
  1099 + }
1078 1100
1079 -if (InfraString::isBolVazia($objDocumento->dataHoraDeProducao)) {  
1080 - $objInfraException->lancarValidacao('Data do documento não informada.');  
1081 -} 1101 + $objProcedimentoDTO2 = new ProcedimentoDTO();
  1102 + $objProcedimentoDTO2->retDblIdProcedimento();
  1103 + $objProcedimentoDTO2->retNumIdUsuarioGeradorProtocolo();
  1104 + $objProcedimentoDTO2->retNumIdTipoProcedimento();
  1105 + $objProcedimentoDTO2->retStrStaNivelAcessoGlobalProtocolo();
  1106 + $objProcedimentoDTO2->retStrProtocoloProcedimentoFormatado();
  1107 + $objProcedimentoDTO2->retNumIdTipoProcedimento();
  1108 + $objProcedimentoDTO2->retStrNomeTipoProcedimento();
  1109 + $objProcedimentoDTO2->adicionarCriterio(array('IdProcedimento','ProtocoloProcedimentoFormatado','ProtocoloProcedimentoFormatadoPesquisa'),
  1110 + array(InfraDTO::$OPER_IGUAL,InfraDTO::$OPER_IGUAL,InfraDTO::$OPER_IGUAL),
  1111 + array($objDocumentoDTO->getDblIdProcedimento(),$objDocumentoDTO->getDblIdProcedimento(),$objDocumentoDTO->getDblIdProcedimento()),
  1112 + array(InfraDTO::$OPER_LOGICO_OR,InfraDTO::$OPER_LOGICO_OR));
1082 1113
1083 -$objProcedimentoDTO2 = new ProcedimentoDTO();  
1084 -$objProcedimentoDTO2->retDblIdProcedimento();  
1085 -$objProcedimentoDTO2->retNumIdUsuarioGeradorProtocolo();  
1086 -$objProcedimentoDTO2->retNumIdTipoProcedimento();  
1087 -$objProcedimentoDTO2->retStrStaNivelAcessoGlobalProtocolo();  
1088 -$objProcedimentoDTO2->retStrProtocoloProcedimentoFormatado();  
1089 -$objProcedimentoDTO2->retNumIdTipoProcedimento();  
1090 -$objProcedimentoDTO2->retStrNomeTipoProcedimento();  
1091 -$objProcedimentoDTO2->adicionarCriterio(array('IdProcedimento','ProtocoloProcedimentoFormatado','ProtocoloProcedimentoFormatadoPesquisa'),  
1092 - array(InfraDTO::$OPER_IGUAL,InfraDTO::$OPER_IGUAL,InfraDTO::$OPER_IGUAL),  
1093 - array($objDocumentoDTO->getDblIdProcedimento(),$objDocumentoDTO->getDblIdProcedimento(),$objDocumentoDTO->getDblIdProcedimento()),  
1094 - array(InfraDTO::$OPER_LOGICO_OR,InfraDTO::$OPER_LOGICO_OR));  
1095 -  
1096 -$objProcedimentoRN = new ProcedimentoRN();  
1097 -$objProcedimentoDTO = $objProcedimentoRN->consultarRN0201($objProcedimentoDTO2);  
1098 -  
1099 -if ($objProcedimentoDTO==null){  
1100 - throw new InfraException('Processo ['.$objDocumentoDTO->getDblIdProcedimento().'] não encontrado.');  
1101 -} 1114 + $objProcedimentoRN = new ProcedimentoRN();
  1115 + $objProcedimentoDTO = $objProcedimentoRN->consultarRN0201($objProcedimentoDTO2);
1102 1116
1103 -$objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento());  
1104 -$objDocumentoDTO->setNumIdSerie($objSerieDTO->getNumIdSerie());  
1105 -$objDocumentoDTO->setStrNomeSerie($objSerieDTO->getStrNome());  
1106 -  
1107 -$objDocumentoDTO->setDblIdDocumentoEdoc(null);  
1108 -$objDocumentoDTO->setDblIdDocumentoEdocBase(null);  
1109 -$objDocumentoDTO->setNumIdUnidadeResponsavel($objUnidadeDTO->getNumIdUnidade());  
1110 -$objDocumentoDTO->setNumIdTipoConferencia(null);  
1111 -$objDocumentoDTO->setStrConteudo(null);  
1112 -$objDocumentoDTO->setStrStaDocumento(DocumentoRN::$TD_EXTERNO);  
1113 - // $objDocumentoDTO->setNumVersaoLock(0);  
1114 -  
1115 -$objProtocoloDTO = new ProtocoloDTO();  
1116 -$objDocumentoDTO->setObjProtocoloDTO($objProtocoloDTO);  
1117 -$objProtocoloDTO->setDblIdProtocolo(null);  
1118 -$objProtocoloDTO->setStrStaProtocolo(ProtocoloRN::$TP_DOCUMENTO_RECEBIDO);  
1119 -  
1120 -if($objDocumento->descricao != '***'){  
1121 - $objProtocoloDTO->setStrDescricao(utf8_decode($objDocumento->descricao));  
1122 - $objDocumentoDTO->setStrNumero(utf8_decode($objDocumento->descricao));  
1123 -}else{  
1124 - $objProtocoloDTO->setStrDescricao("");  
1125 - $objDocumentoDTO->setStrNumero("");  
1126 -} 1117 + if ($objProcedimentoDTO==null){
  1118 + throw new InfraException('Processo ['.$objDocumentoDTO->getDblIdProcedimento().'] não encontrado.');
  1119 + }
  1120 +
  1121 + $objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento());
  1122 + $objDocumentoDTO->setNumIdSerie($objSerieDTO->getNumIdSerie());
  1123 + $objDocumentoDTO->setStrNomeSerie($objSerieDTO->getStrNome());
  1124 +
  1125 + $objDocumentoDTO->setDblIdDocumentoEdoc(null);
  1126 + $objDocumentoDTO->setDblIdDocumentoEdocBase(null);
  1127 + $objDocumentoDTO->setNumIdUnidadeResponsavel($objUnidadeDTO->getNumIdUnidade());
  1128 + $objDocumentoDTO->setNumIdTipoConferencia(null);
  1129 + $objDocumentoDTO->setStrConteudo(null);
  1130 + $objDocumentoDTO->setStrStaDocumento(DocumentoRN::$TD_EXTERNO);
  1131 + // $objDocumentoDTO->setNumVersaoLock(0);
  1132 +
  1133 + $objProtocoloDTO = new ProtocoloDTO();
  1134 + $objDocumentoDTO->setObjProtocoloDTO($objProtocoloDTO);
  1135 + $objProtocoloDTO->setDblIdProtocolo(null);
  1136 + $objProtocoloDTO->setStrStaProtocolo(ProtocoloRN::$TP_DOCUMENTO_RECEBIDO);
  1137 +
  1138 + if($objDocumento->descricao != '***'){
  1139 + $objProtocoloDTO->setStrDescricao(utf8_decode($objDocumento->descricao));
  1140 + $objDocumentoDTO->setStrNumero(utf8_decode($objDocumento->descricao));
  1141 + }else{
  1142 + $objProtocoloDTO->setStrDescricao("");
  1143 + $objDocumentoDTO->setStrNumero("");
  1144 + }
1127 //TODO: Avaliar regra de formação do número do documento 1145 //TODO: Avaliar regra de formação do número do documento
1128 1146
1129 -$objProtocoloDTO->setStrStaNivelAcessoLocal($this->obterNivelSigiloSEI($objDocumento->nivelDeSigilo));  
1130 -$objProtocoloDTO->setDtaGeracao($this->objProcessoEletronicoRN->converterDataSEI($objDocumento->dataHoraDeProducao));  
1131 -$objProtocoloDTO->setArrObjAnexoDTO(array());  
1132 -$objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());  
1133 -$objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array());  
1134 -$objProtocoloDTO->setArrObjParticipanteDTO(array()); 1147 + $objProtocoloDTO->setStrStaNivelAcessoLocal($this->obterNivelSigiloSEI($objDocumento->nivelDeSigilo));
  1148 + $objProtocoloDTO->setDtaGeracao($this->objProcessoEletronicoRN->converterDataSEI($objDocumento->dataHoraDeProducao));
  1149 + $objProtocoloDTO->setArrObjAnexoDTO(array());
  1150 + $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());
  1151 + $objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array());
  1152 + $objProtocoloDTO->setArrObjParticipanteDTO(array());
1135 1153
1136 //TODO: Analisar se o modelo de dados do PEN possui destinatários específicos para os documentos 1154 //TODO: Analisar se o modelo de dados do PEN possui destinatários específicos para os documentos
1137 //caso não possua, analisar o repasse de tais informações via parãmetros adicionais 1155 //caso não possua, analisar o repasse de tais informações via parãmetros adicionais
1138 1156
1139 -$objObservacaoDTO = new ObservacaoDTO();  
1140 -$objObservacaoDTO->setStrDescricao("Número SEI do Documento na Origem: ".$objDocumento->produtor->numeroDeIdentificacao);  
1141 -$objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO)); 1157 + $objObservacaoDTO = new ObservacaoDTO();
  1158 + $objObservacaoDTO->setStrDescricao("Número SEI do Documento na Origem: ".$objDocumento->produtor->numeroDeIdentificacao);
  1159 + $objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO));
1142 1160
  1161 + $bolReabriuAutomaticamente = false;
  1162 + if ($objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_PUBLICO || $objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_RESTRITO) {
1143 1163
1144 -$bolReabriuAutomaticamente = false;  
1145 -if ($objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_PUBLICO || $objProcedimentoDTO->getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA_RESTRITO) {  
1146 -  
1147 - $objAtividadeDTO = new AtividadeDTO();  
1148 - $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());  
1149 - $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual()); 1164 + $objAtividadeDTO = new AtividadeDTO();
  1165 + $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
  1166 + $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1150 1167
1151 //TODO: Possivelmente, essa regra é desnecessária já que o processo pode ser enviado para outra unidade do órgão através da expedição 1168 //TODO: Possivelmente, essa regra é desnecessária já que o processo pode ser enviado para outra unidade do órgão através da expedição
1152 - $objAtividadeRN = new AtividadeRN();  
1153 - if ($objAtividadeRN->contarRN0035($objAtividadeDTO) == 0) {  
1154 - throw new InfraException('Unidade '.$objUnidadeDTO->getStrSigla().' não possui acesso ao Procedimento '.$objProcedimentoDTO->getStrProtocoloProcedimentoFormatado().'.');  
1155 - } 1169 + $objAtividadeRN = new AtividadeRN();
  1170 + if ($objAtividadeRN->contarRN0035($objAtividadeDTO) == 0) {
  1171 + throw new InfraException('Unidade '.$objUnidadeDTO->getStrSigla().' não possui acesso ao Procedimento '.$objProcedimentoDTO->getStrProtocoloProcedimentoFormatado().'.');
  1172 + }
1156 1173
1157 - $objAtividadeDTO = new AtividadeDTO();  
1158 - $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());  
1159 - $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());  
1160 - $objAtividadeDTO->setDthConclusao(null); 1174 + $objAtividadeDTO = new AtividadeDTO();
  1175 + $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
  1176 + $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1177 + $objAtividadeDTO->setDthConclusao(null);
1161 1178
1162 - if ($objAtividadeRN->contarRN0035($objAtividadeDTO) == 0) { 1179 + if ($objAtividadeRN->contarRN0035($objAtividadeDTO) == 0) {
1163 //reabertura automática 1180 //reabertura automática
1164 - $objReabrirProcessoDTO = new ReabrirProcessoDTO();  
1165 - $objReabrirProcessoDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());  
1166 - $objReabrirProcessoDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());  
1167 - $objReabrirProcessoDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());  
1168 - $objProcedimentoRN->reabrirRN0966($objReabrirProcessoDTO);  
1169 - $bolReabriuAutomaticamente = true;  
1170 - }  
1171 -} 1181 + $objReabrirProcessoDTO = new ReabrirProcessoDTO();
  1182 + $objReabrirProcessoDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());
  1183 + $objReabrirProcessoDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1184 + $objReabrirProcessoDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
  1185 + $objProcedimentoRN->reabrirRN0966($objReabrirProcessoDTO);
  1186 + $bolReabriuAutomaticamente = true;
  1187 + }
  1188 + }
1172 1189
1173 //$objOperacaoServicoDTO = new OperacaoServicoDTO(); 1190 //$objOperacaoServicoDTO = new OperacaoServicoDTO();
1174 //$this->adicionarCriteriosUnidadeProcessoDocumento ($objOperacaoServicoDTO,$objUnidadeDTO,$objProcedimentoDTO,$objDocumentoDTO); 1191 //$this->adicionarCriteriosUnidadeProcessoDocumento ($objOperacaoServicoDTO,$objUnidadeDTO,$objProcedimentoDTO,$objDocumentoDTO);
@@ -1180,86 +1197,85 @@ if ($objProcedimentoDTO-&gt;getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA @@ -1180,86 +1197,85 @@ if ($objProcedimentoDTO-&gt;getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA
1180 // $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().'].'); 1197 // $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().'].');
1181 //} 1198 //}
1182 1199
1183 -$objTipoProcedimentoDTO = new TipoProcedimentoDTO();  
1184 -$objTipoProcedimentoDTO->retStrStaNivelAcessoSugestao();  
1185 -$objTipoProcedimentoDTO->retStrStaGrauSigiloSugestao();  
1186 -$objTipoProcedimentoDTO->retNumIdHipoteseLegalSugestao();  
1187 -$objTipoProcedimentoDTO->setNumIdTipoProcedimento($objProcedimentoDTO->getNumIdTipoProcedimento()); 1200 + $objTipoProcedimentoDTO = new TipoProcedimentoDTO();
  1201 + $objTipoProcedimentoDTO->retStrStaNivelAcessoSugestao();
  1202 + $objTipoProcedimentoDTO->retStrStaGrauSigiloSugestao();
  1203 + $objTipoProcedimentoDTO->retNumIdHipoteseLegalSugestao();
  1204 + $objTipoProcedimentoDTO->setNumIdTipoProcedimento($objProcedimentoDTO->getNumIdTipoProcedimento());
1188 1205
1189 -$objTipoProcedimentoRN = new TipoProcedimentoRN();  
1190 -$objTipoProcedimentoDTO = $objTipoProcedimentoRN->consultarRN0267($objTipoProcedimentoDTO); 1206 + $objTipoProcedimentoRN = new TipoProcedimentoRN();
  1207 + $objTipoProcedimentoDTO = $objTipoProcedimentoRN->consultarRN0267($objTipoProcedimentoDTO);
1191 1208
1192 -if (InfraString::isBolVazia($objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal()) || $objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal()==$objTipoProcedimentoDTO->getStrStaNivelAcessoSugestao()) {  
1193 - $objDocumentoDTO->getObjProtocoloDTO()->setStrStaNivelAcessoLocal($objTipoProcedimentoDTO->getStrStaNivelAcessoSugestao());  
1194 - $objDocumentoDTO->getObjProtocoloDTO()->setStrStaGrauSigilo($objTipoProcedimentoDTO->getStrStaGrauSigiloSugestao());  
1195 - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($objTipoProcedimentoDTO->getNumIdHipoteseLegalSugestao());  
1196 -} 1209 + if (InfraString::isBolVazia($objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal()) || $objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal()==$objTipoProcedimentoDTO->getStrStaNivelAcessoSugestao()) {
  1210 + $objDocumentoDTO->getObjProtocoloDTO()->setStrStaNivelAcessoLocal($objTipoProcedimentoDTO->getStrStaNivelAcessoSugestao());
  1211 + $objDocumentoDTO->getObjProtocoloDTO()->setStrStaGrauSigilo($objTipoProcedimentoDTO->getStrStaGrauSigiloSugestao());
  1212 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($objTipoProcedimentoDTO->getNumIdHipoteseLegalSugestao());
  1213 + }
1197 1214
1198 -if ($this->obterNivelSigiloSEI($objDocumento->nivelDeSigilo) == ProtocoloRN::$NA_RESTRITO) {  
1199 - $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();  
1200 - $objPenParametroRN = new PenParametroRN();  
1201 - $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO'); 1215 + if ($this->obterNivelSigiloSEI($objDocumento->nivelDeSigilo) == ProtocoloRN::$NA_RESTRITO) {
  1216 + $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
  1217 + $objPenParametroRN = new PenParametroRN();
  1218 + $numIdHipoteseLegalPadrao = $objPenParametroRN->getParametro('HIPOTESE_LEGAL_PADRAO');
1202 1219
1203 - if (!isset($objDocumento->hipoteseLegal) || (isset($objDocumento->hipoteseLegal) && empty($objDocumento->hipoteseLegal->identificacao))) {  
1204 - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);  
1205 - } else { 1220 + if (!isset($objDocumento->hipoteseLegal) || (isset($objDocumento->hipoteseLegal) && empty($objDocumento->hipoteseLegal->identificacao))) {
  1221 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
  1222 + } else {
1206 1223
1207 - $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($objDocumento->hipoteseLegal->identificacao);  
1208 - if (empty($numIdHipoteseLegal)) {  
1209 - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);  
1210 - } else {  
1211 - $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegal);  
1212 - }  
1213 - }  
1214 -} 1224 + $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($objDocumento->hipoteseLegal->identificacao);
  1225 + if (empty($numIdHipoteseLegal)) {
  1226 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
  1227 + } else {
  1228 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdHipoteseLegal($numIdHipoteseLegal);
  1229 + }
  1230 + }
  1231 + }
1215 1232
1216 -$objDocumentoDTO->getObjProtocoloDTO()->setArrObjParticipanteDTO($this->prepararParticipantes($objDocumentoDTO->getObjProtocoloDTO()->getArrObjParticipanteDTO())); 1233 + $objDocumentoDTO->getObjProtocoloDTO()->setArrObjParticipanteDTO($this->prepararParticipantes($objDocumentoDTO->getObjProtocoloDTO()->getArrObjParticipanteDTO()));
1217 1234
1218 -$objDocumentoRN = new DocumentoRN(); 1235 + $objDocumentoRN = new DocumentoRN();
1219 1236
1220 -$strConteudoCodificado = $objDocumentoDTO->getStrConteudo();  
1221 -$objDocumentoDTO->setStrConteudo(null); 1237 + $strConteudoCodificado = $objDocumentoDTO->getStrConteudo();
  1238 + $objDocumentoDTO->setStrConteudo(null);
1222 //$objDocumentoDTO->setStrSinFormulario('N'); 1239 //$objDocumentoDTO->setStrSinFormulario('N');
1223 1240
1224 -$objDocumentoDTO->getObjProtocoloDTO()->setNumIdUnidadeGeradora(SessaoSEI::getInstance()->getNumIdUnidadeAtual());  
1225 -$objDocumentoDTO->setStrSinBloqueado('S'); 1241 + $objDocumentoDTO->getObjProtocoloDTO()->setNumIdUnidadeGeradora(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
  1242 + $objDocumentoDTO->setStrSinBloqueado('S');
1226 1243
1227 //TODO: Fazer a atribuição dos componentes digitais do processo a partir desse ponto 1244 //TODO: Fazer a atribuição dos componentes digitais do processo a partir desse ponto
1228 -$this->atribuirComponentesDigitais($objDocumentoDTO, $objDocumento->componenteDigital);  
1229 -$objDocumentoDTOGerado = $objDocumentoRN->cadastrarRN0003($objDocumentoDTO);  
1230 -  
1231 -$objAtividadeDTOVisualizacao = new AtividadeDTO();  
1232 -$objAtividadeDTOVisualizacao->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());  
1233 -$objAtividadeDTOVisualizacao->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual()); 1245 + $this->atribuirComponentesDigitais($objDocumentoDTO, $objDocumento->componenteDigital);
  1246 + $objDocumentoDTOGerado = $objDocumentoRN->cadastrarRN0003($objDocumentoDTO);
1234 1247
1235 -if (!$bolReabriuAutomaticamente){  
1236 - $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_ATENCAO);  
1237 -}else{  
1238 - $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_NAO_VISUALIZADO | AtividadeRN::$TV_ATENCAO);  
1239 -} 1248 + $objAtividadeDTOVisualizacao = new AtividadeDTO();
  1249 + $objAtividadeDTOVisualizacao->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
  1250 + $objAtividadeDTOVisualizacao->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
1240 1251
1241 -$objAtividadeRN = new AtividadeRN();  
1242 -$objAtividadeRN->atualizarVisualizacaoUnidade($objAtividadeDTOVisualizacao); 1252 + if (!$bolReabriuAutomaticamente){
  1253 + $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_ATENCAO);
  1254 + }else{
  1255 + $objAtividadeDTOVisualizacao->setNumTipoVisualizacao(AtividadeRN::$TV_NAO_VISUALIZADO | AtividadeRN::$TV_ATENCAO);
  1256 + }
1243 1257
1244 -$objDocumento->idDocumentoSEI = $objDocumentoDTO->getDblIdDocumento();  
1245 -$arrObjDocumentoDTO[] = $objDocumentoDTO; 1258 + $objAtividadeRN = new AtividadeRN();
  1259 + $objAtividadeRN->atualizarVisualizacaoUnidade($objAtividadeDTOVisualizacao);
1246 1260
1247 -if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {  
1248 - $this->documentosRetirados[] = $objDocumento->idDocumentoSEI;  
1249 -} 1261 + $objDocumento->idDocumentoSEI = $objDocumentoDTO->getDblIdDocumento();
  1262 + $arrObjDocumentoDTO[] = $objDocumentoDTO;
1250 1263
1251 -} 1264 + if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {
  1265 + $this->documentosRetirados[] = $objDocumento->idDocumentoSEI;
  1266 + }
  1267 + }
1252 1268
1253 -foreach($this->documentosRetirados as $documentoCancelado){ 1269 + foreach($this->documentosRetirados as $documentoCancelado){
1254 //Instancia o DTO do protocolo 1270 //Instancia o DTO do protocolo
1255 - $objEntradaCancelarDocumentoAPI = new EntradaCancelarDocumentoAPI();  
1256 - $objEntradaCancelarDocumentoAPI->setIdDocumento($documentoCancelado);  
1257 - $objEntradaCancelarDocumentoAPI->setMotivo('Cancelado pelo remetente');  
1258 - $objSeiRN = new SeiRN();  
1259 - $objSeiRN->cancelarDocumento($objEntradaCancelarDocumentoAPI);  
1260 -} 1271 + $objEntradaCancelarDocumentoAPI = new EntradaCancelarDocumentoAPI();
  1272 + $objEntradaCancelarDocumentoAPI->setIdDocumento($documentoCancelado);
  1273 + $objEntradaCancelarDocumentoAPI->setMotivo('Cancelado pelo remetente');
  1274 + $objSeiRN = new SeiRN();
  1275 + $objSeiRN->cancelarDocumento($objEntradaCancelarDocumentoAPI);
  1276 + }
1261 1277
1262 -$objProcedimentoDTO->setArrObjDocumentoDTO($arrObjDocumentoDTO); 1278 + $objProcedimentoDTO->setArrObjDocumentoDTO($arrObjDocumentoDTO);
1263 1279
1264 /* if($numIdUnidadeAtual != $numIdUnidadeGeradora){ 1280 /* if($numIdUnidadeAtual != $numIdUnidadeGeradora){
1265 SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $numIdUnidadeAtual); 1281 SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $numIdUnidadeAtual);
@@ -1782,13 +1798,13 @@ protected function receberTramiteRecusadoInternoControlado(ReceberTramiteRecusad @@ -1782,13 +1798,13 @@ protected function receberTramiteRecusadoInternoControlado(ReceberTramiteRecusad
1782 * Método que realiza a validação da extensão dos componentes digitais a serem recebidos 1798 * Método que realiza a validação da extensão dos componentes digitais a serem recebidos
1783 * 1799 *
1784 * @param integer $parIdTramite 1800 * @param integer $parIdTramite
1785 - * @param object $parObjProcesso 1801 + * @param object $parObjProtocolo
1786 * @throws InfraException 1802 * @throws InfraException
1787 */ 1803 */
1788 - public function validarExtensaoComponentesDigitais($parIdTramite, $parObjProcesso){ 1804 + public function validarExtensaoComponentesDigitais($parIdTramite, $parObjProtocolo){
1789 1805
1790 //Armazena o array de documentos 1806 //Armazena o array de documentos
1791 - $arrDocumentos = is_array($parObjProcesso->documento) ? $parObjProcesso->documento : array($parObjProcesso->documento) ; 1807 + $arrDocumentos = $this->obterDocumentosProtocolo($parObjProtocolo);
1792 1808
1793 //Instancia o bd do arquivoExtensão 1809 //Instancia o bd do arquivoExtensão
1794 $arquivoExtensaoBD = new ArquivoExtensaoBD($this->getObjInfraIBanco()); 1810 $arquivoExtensaoBD = new ArquivoExtensaoBD($this->getObjInfraIBanco());