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 60 /**
61 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 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 38 protected function receberProcedimentoControlado($parNumIdentificacaoTramite)
39 39 {
40 40 try {
  41 + $objSeiRN = new SeiRN();
41 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 48 SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $objPenParametroRN->getParametro('PEN_UNIDADE_GERADORA_DOCUMENTO_RECEBIDO'));
43 49  
44   - $objSeiRN = new SeiRN();
45 50  
46 51 if (!isset($parNumIdentificacaoTramite)) {
47 52 throw new InfraException('Parâmetro $parNumIdentificacaoTramite não informado.');
... ... @@ -51,172 +56,171 @@ class ReceberProcedimentoRN extends InfraRN
51 56 $this->gravarLogDebug("Solicitando metadados do trâmite " . $parNumIdentificacaoTramite, 4);
52 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 224 //$this->fecharProcedimentoEmOutraUnidades($objProcedimentoDTO, $objMetadadosProcedimento);
221 225 $this->gravarLogDebug("Enviando recibo de conclusão do trâmite $parNumIdentificacaoTramite", 6);
222 226 $objEnviarReciboTramiteRN = new EnviarReciboTramiteRN();
... ... @@ -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 255 public function fecharProcedimentoEmOutraUnidades(ProcedimentoDTO $objProcedimentoDTO, $parObjMetadadosProcedimento){
238 256  
239 257 $objPenUnidadeDTO = new PenUnidadeDTO();
... ... @@ -284,16 +302,15 @@ class ReceberProcedimentoRN extends InfraRN
284 302 *
285 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 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 313 $strHash = ProcessoEletronicoRN::getHashFromMetaDados($objDocumento->componenteDigital->hash);
296   -
297 314 $objMapDTO = new PenRelTipoDocMapRecebidoDTO(true);
298 315 $objMapDTO->setNumMaxRegistrosRetorno(1);
299 316 $objMapDTO->setNumCodigoEspecie($objDocumento->especie->codigo);
... ... @@ -320,9 +337,9 @@ class ReceberProcedimentoRN extends InfraRN
320 337 * Valida cada componente digital, se não algum não for aceito recusa o tramite
321 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 344 foreach($arrObjDocumentos as $objDocument){
328 345  
... ... @@ -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 397 // Validação dos dados do processo recebido
370 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 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 403 //para o usuário final, mesmo possuindo permissão para isso
... ... @@ -377,20 +405,20 @@ class ReceberProcedimentoRN extends InfraRN
377 405 $objInfraException->lancarValidacoes();
378 406  
379 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 410 if(isset($dblIdProcedimento)){
383   - $objProcedimentoDTO = $this->atualizarProcedimento($dblIdProcedimento, $parObjMetadadosProcedimento, $parObjProcesso);
  411 + $objProcedimentoDTO = $this->atualizarProcedimento($dblIdProcedimento, $parObjMetadadosProcedimento, $parObjProtocolo);
384 412 }
385 413 else {
386   - $objProcedimentoDTO = $this->gerarProcedimento($parObjMetadadosProcedimento, $parObjProcesso);
  414 + $objProcedimentoDTO = $this->gerarProcedimento($parObjMetadadosProcedimento, $parObjProtocolo);
387 415 }
388 416  
389 417 //TODO: Fazer o envio de cada um dos procedimentos apensados (Processo principal e seus apensados, caso exista)
390 418 //...
391 419  
392 420 //Chamada recursiva para registro dos processos apensados
393   - if(isset($objProcesso->processoApensado)) {
  421 + if(isset($objProtocolo->processoApensado)) {
394 422 if(!is_array($objProcesso->processoApensado)) {
395 423 $objProcesso->processoApensado = array($objProcesso->processoApensado);
396 424 }
... ... @@ -599,7 +627,7 @@ class ReceberProcedimentoRN extends InfraRN
599 627 $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
600 628 }
601 629  
602   - private function gerarProcedimento($objMetadadosProcedimento, $objProcesso){
  630 + private function gerarProcedimento($objMetadadosProcedimento, $parObjProtocolo){
603 631  
604 632 if(!isset($objMetadadosProcedimento)){
605 633 throw new InfraException('Parâmetro $objMetadadosProcedimento não informado.');
... ... @@ -607,31 +635,31 @@ class ReceberProcedimentoRN extends InfraRN
607 635  
608 636 //TODO: Usar dados do destinatário em outro método específico para envio
609 637 // Dados do procedimento enviados pelos órgão externo integrado ao PEN
610   - //$objProcesso = $objMetadadosProcedimento->metadados->processo;
  638 + //$parObjProtocolo = $objMetadadosProcedimento->metadados->processo;
611 639 $objRemetente = $objMetadadosProcedimento->metadados->remetente;
612 640 $objDestinatario = $objMetadadosProcedimento->metadados->destinatario;
613 641  
614 642 //TODO: TESTES DE RECEBIMENTO DE PROCESSOS
615 643 //REMOVER APOS TESTES DO SISTEMA
616   - //$objProcesso->protocolo = rand(100000000, 999999999);
  644 + //$parObjProtocolo->protocolo = rand(100000000, 999999999);
617 645  
618 646 //Atribuição de dados do protocolo
619 647 //TODO: Validar cada uma das informações de entrada do webservice
620 648 $objProtocoloDTO = new ProtocoloDTO();
621 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 654 $objHipoteseLegalRecebido = new PenRelHipoteseLegalRecebidoRN();
627 655 $objPenParametroRN = new PenParametroRN();
628 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 659 $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
632 660 } else {
633 661  
634   - $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($objProcesso->hipoteseLegal->identificacao);
  662 + $numIdHipoteseLegal = $objHipoteseLegalRecebido->getIdHipoteseLegalSEI($parObjProtocolo->hipoteseLegal->identificacao);
635 663 if (empty($numIdHipoteseLegal)) {
636 664 $objProtocoloDTO->setNumIdHipoteseLegal($numIdHipoteseLegalPadrao);
637 665 } else {
... ... @@ -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 673 $objProtocoloDTO->setArrObjAnexoDTO(array());
646 674 $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());
647 675 $objProtocoloDTO->setArrObjRelProtocoloProtocoloDTO(array());
648 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 685 $objObservacaoDTO = new ObservacaoDTO();
655 686  
... ... @@ -667,8 +698,6 @@ class ReceberProcedimentoRN extends InfraRN
667 698 $objObservacaoDTO->setStrDescricao($strDescricao);
668 699 }
669 700  
670   - //throw new InfraException(var_export($objObservacaoDTO, true));
671   -
672 701 $objProtocoloDTO->setArrObjObservacaoDTO(array($objObservacaoDTO));
673 702  
674 703 //Atribuição de dados do procedimento
... ... @@ -676,17 +705,15 @@ class ReceberProcedimentoRN extends InfraRN
676 705 $objProcedimentoDTO = new ProcedimentoDTO();
677 706 $objProcedimentoDTO->setDblIdProcedimento(null);
678 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 710 $objProcedimentoDTO->setStrSinGerarPendencia('S');
683   - // $objProcedimentoDTO->setNumVersaoLock(0); //TODO: Avaliar o comportamento desse campo no cadastro do processo
684 711 $objProcedimentoDTO->setArrObjDocumentoDTO(array());
685 712  
686 713 //TODO: Identificar o tipo de procedimento correto para atribuição ao novo processo
687 714 $objPenParametroRN = new PenParametroRN();
688 715 $numIdTipoProcedimento = $objPenParametroRN->getParametro('PEN_TIPO_PROCESSO_EXTERNO');
689   - $this->atribuirTipoProcedimento($objProcedimentoDTO, $numIdTipoProcedimento, $objProcesso->processoDeNegocio);
  716 + $this->atribuirTipoProcedimento($objProcedimentoDTO, $numIdTipoProcedimento);
690 717  
691 718 //TODO: Obter código da unidade através de mapeamento entre SEI e Barramento
692 719 $objUnidadeDTO = $this->atribuirDadosUnidade($objProcedimentoDTO, $objDestinatario);
... ... @@ -695,18 +722,16 @@ class ReceberProcedimentoRN extends InfraRN
695 722 //...
696 723  
697 724 //TODO: Atribuir Dados do produtor do processo
698   - //$this->atribuirProdutorProcesso($objProcesso,
  725 + //$this->atribuirProdutorProcesso($parObjProtocolo,
699 726 // $objProcedimentoDTO->getNumIdUsuarioGeradorProtocolo(),
700 727 // $objProcedimentoDTO->getNumIdUnidadeGeradoraProtocolo());
701 728  
702 729  
703   -
704   -
705 730 //TODO:Adicionar demais informações do processo
706 731 //<protocoloAnterior>
707 732 //<historico>
708 733  
709   - //$objProcesso->idProcedimentoSEI = $dblIdProcedimento;
  734 + //$parObjProtocolo->idProcedimentoSEI = $dblIdProcedimento;
710 735  
711 736 //TODO: Avaliar necessidade de tal recurso
712 737 //FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(true);
... ... @@ -721,12 +746,12 @@ class ReceberProcedimentoRN extends InfraRN
721 746 $objProcedimentoDTO->setDblIdProcedimento($objProcedimentoDTOGerado->getDblIdProcedimento());
722 747  
723 748 $this->registrarAndamentoRecebimentoProcesso($objProcedimentoDTO, $objMetadadosProcedimento);
724   - $this->atribuirDocumentos($objProcedimentoDTO, $objProcesso, $objUnidadeDTO, $objMetadadosProcedimento);
  749 + $this->atribuirDocumentos($objProcedimentoDTO, $parObjProtocolo, $objUnidadeDTO, $objMetadadosProcedimento);
725 750 $this->registrarProcedimentoNaoVisualizado($objProcedimentoDTOGerado);
726 751  
727 752 //TODO: Avaliar necessidade de restringir referência circular entre processos
728 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 756 //TODO: Finalizar o envio do documento para a respectiva unidade
732 757 $this->enviarProcedimentoUnidade($objProcedimentoDTO);
... ... @@ -977,29 +1002,24 @@ class ReceberProcedimentoRN extends InfraRN
977 1002  
978 1003 //TODO: Grande parte da regra de negócio se baseou em SEIRN:199 - incluirDocumento.
979 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 1011 if(!isset($objUnidadeDTO)) {
988 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 1021 $strNumeroRegistro = $parObjMetadadosProcedimento->metadados->NRE;
1001 1022 //$numTramite = $parObjMetadadosProcedimento->metadados->IDT;
1002   -
1003 1023 //Ordenação dos documentos conforme informado pelo remetente. Campo documento->ordem
1004 1024 usort($arrObjDocumentos, array("ReceberProcedimentoRN", "comparacaoOrdemDocumentos"));
1005 1025  
... ... @@ -1023,152 +1043,149 @@ class ReceberProcedimentoRN extends InfraRN
1023 1043 foreach($arrObjDocumentos as $objDocumento){
1024 1044  
1025 1045 // @join_tec US027 (#3498)
1026   - if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {
  1046 + if(isset($objDocumento->retirado) && $objDocumento->retirado === true) {
1027 1047 //$strHashConteudo = ProcessoEletronicoRN::getHashFromMetaDados($objDocumento->componenteDigital->hash);
1028 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 1051 //Busca o ID do protocolo
1032 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 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 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 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 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 1154 //TODO: Analisar se o modelo de dados do PEN possui destinatários específicos para os documentos
1137 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 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 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 1190 //$objOperacaoServicoDTO = new OperacaoServicoDTO();
1174 1191 //$this->adicionarCriteriosUnidadeProcessoDocumento ($objOperacaoServicoDTO,$objUnidadeDTO,$objProcedimentoDTO,$objDocumentoDTO);
... ... @@ -1180,86 +1197,85 @@ if ($objProcedimentoDTO-&gt;getStrStaNivelAcessoGlobalProtocolo()==ProtocoloRN::$NA
1180 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 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 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 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 1280 /* if($numIdUnidadeAtual != $numIdUnidadeGeradora){
1265 1281 SessaoSEI::getInstance(false)->simularLogin('SEI', null, null, $numIdUnidadeAtual);
... ... @@ -1782,13 +1798,13 @@ protected function receberTramiteRecusadoInternoControlado(ReceberTramiteRecusad
1782 1798 * Método que realiza a validação da extensão dos componentes digitais a serem recebidos
1783 1799 *
1784 1800 * @param integer $parIdTramite
1785   - * @param object $parObjProcesso
  1801 + * @param object $parObjProtocolo
1786 1802 * @throws InfraException
1787 1803 */
1788   - public function validarExtensaoComponentesDigitais($parIdTramite, $parObjProcesso){
  1804 + public function validarExtensaoComponentesDigitais($parIdTramite, $parObjProtocolo){
1789 1805  
1790 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 1809 //Instancia o bd do arquivoExtensão
1794 1810 $arquivoExtensaoBD = new ArquivoExtensaoBD($this->getObjInfraIBanco());
... ...