<?php
/**
 * TRIBUNAL REGIONAL FEDERAL DA 4ª REGIÃO
 *
 * 30/07/2008 - criado por mga
 * 07/08/2008 - criado por leandro_db
 *
 * Versão do Gerador de Código: 1.21.0
 *
 * Versão no CVS: $Id$
 */

require_once dirname(__FILE__).'/../SEI.php';

class DocumentoRN extends InfraRN {
 
  public function __construct(){
    parent::__construct();
  }

  protected function inicializarObjInfraIBanco(){
    return BancoSEI::getInstance();
  }

  public function gerarRN0003(DocumentoDTO $objDocumentoDTO){

    $bolAcumulacaoPrevia = FeedSEIProtocolos::getInstance()->isBolAcumularFeeds();

    FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(true);

    $objDocumentoDTO = $this->gerarRN0003Interno($objDocumentoDTO);

    $objIndexacaoDTO = new IndexacaoDTO();
    $objIndexacaoRN = new IndexacaoRN();

    $objProtocoloDTO = new ProtocoloDTO();
    $objProtocoloDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

    $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));
    $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_GERACAO_PROTOCOLO);
    $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);

    if (!$bolAcumulacaoPrevia){
      FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(false);
      FeedSEIProtocolos::getInstance()->indexarFeeds();
    }

    return $objDocumentoDTO;

  }

  protected function gerarRN0003InternoControlado(DocumentoDTO $objDocumentoDTO) {
    try{
      
      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_gerar',__METHOD__,$objDocumentoDTO);

      //Regras de Negocio
      $objInfraException = new InfraException();
      
      $objDocumentoDTO->setStrStaProtocoloProtocolo(ProtocoloRN::$TP_DOCUMENTO_GERADO);

      $this->validarNumIdUnidadeResponsavelRN0915($objDocumentoDTO, $objInfraException);

      $this->validarNumIdSerieRN0009($objDocumentoDTO, $objInfraException);

      //conteudo nao existe nas telas de cadastro, apenas em documentos gerados por servicos
      if ($objDocumentoDTO->isSetStrConteudo()){
        $this->validarStrConteudo($objDocumentoDTO, $objInfraException);
      }else{
        $objDocumentoDTO->setStrConteudo(null);
      }

      $objDocumentoDTO->setStrConteudoAssinatura(null);
      $objDocumentoDTO->setStrCrcAssinatura(null);
      $objDocumentoDTO->setStrQrCodeAssinatura(null);
      $objDocumentoDTO->setStrSinBloqueado('N');
      $objDocumentoDTO->setNumIdConjuntoEstilos(null);
      $objDocumentoDTO->setNumIdTipoConferencia(null);

      $this->validarStrStaEditor($objDocumentoDTO, $objInfraException);
      $this->validarStrSinFormulario($objDocumentoDTO, $objInfraException);
      
      if ($objDocumentoDTO->isSetStrProtocoloDocumentoTextoBase() && !InfraString::isBolVazia($objDocumentoDTO->getStrProtocoloDocumentoTextoBase())){
        
        $strProtocoloDocumentoTextoBaseFormatado = str_pad($objDocumentoDTO->getStrProtocoloDocumentoTextoBase(), DIGITOS_DOCUMENTO, '0', STR_PAD_LEFT);

        $objPesquisaProtocoloDTO = new PesquisaProtocoloDTO();
        $objPesquisaProtocoloDTO->setStrStaTipo(ProtocoloRN::$TPP_DOCUMENTOS_GERADOS);
        $objPesquisaProtocoloDTO->setStrStaAcesso(ProtocoloRN::$TAP_AUTORIZADO);
        $objPesquisaProtocoloDTO->setStrProtocolo($strProtocoloDocumentoTextoBaseFormatado);
        
        $objProtocoloRN = new ProtocoloRN(); 
        $arrObjProtocoloDTO = $objProtocoloRN->pesquisarRN0967($objPesquisaProtocoloDTO);
        
        if (count($arrObjProtocoloDTO)==0){
          $objInfraException->lancarValidacao('Documento Base não encontrado.');
        }
        
        if ($arrObjProtocoloDTO[0]->getStrStaEditorDocumento()!=EditorRN::$TE_INTERNO){
          $objInfraException->lancarValidacao('Documento Base não foi gerado pelo editor interno.');
        }
        
        $objDocumentoDTO->setDblIdDocumentoTextoBase($arrObjProtocoloDTO[0]->getDblIdProtocolo());
      }

      $objInfraException->lancarValidacoes();

      $objProtocoloDTO = $objDocumentoDTO->getObjProtocoloDTO();
      $objProtocoloDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());

      $this->tratarProtocoloRN1164($objDocumentoDTO);

      $objProtocoloRN = new ProtocoloRN();
      $objProtocoloDTOGerado  = $objProtocoloRN->gerarRN0154($objProtocoloDTO);

      $objDocumentoDTO->setDblIdProcedimento($objProtocoloDTO->getDblIdProcedimento());
      $objDocumentoDTO->setDblIdDocumento($objProtocoloDTOGerado->getDblIdProtocolo());
      $objDocumentoDTO->setDblIdDocumentoEdoc(null);

      $objSerieDTO = new SerieDTO();
      $objSerieDTO->retNumIdSerie();
      $objSerieDTO->setBolExclusaoLogica(false);
      $objSerieDTO->retStrNome();
      $objSerieDTO->retStrStaNumeracao();
      $objSerieDTO->retNumIdModelo();
      $objSerieDTO->setNumIdSerie($objDocumentoDTO->getNumIdSerie());

      $objSerieRN = new SerieRN();
      $objSerieDTO = $objSerieRN->consultarRN0644($objSerieDTO);

      //Associar o documento nesta unidade e nas unidades que tem acesso ao processo
      $objAssociarDTO = new AssociarDTO();
      $objAssociarDTO->setDblIdProcedimento($objProtocoloDTO->getDblIdProcedimento());
      $objAssociarDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
      $objAssociarDTO->setNumIdUnidade(null);
      $objAssociarDTO->setNumIdUsuario(null);
      $objAssociarDTO->setStrStaNivelAcessoGlobal($objProtocoloDTOGerado->getStrStaNivelAcessoGlobal());
      $objProtocoloRN->associarRN0982($objAssociarDTO);

      $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
      $objRelProtocoloProtocoloDTO->setDblIdRelProtocoloProtocolo(null);
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo1($objProtocoloDTO->getDblIdProcedimento());
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objDocumentoDTO->getDblIdDocumento());
      $objRelProtocoloProtocoloDTO->setNumIdUsuario($objProtocoloDTO->getNumIdUsuarioGerador());
      $objRelProtocoloProtocoloDTO->setNumIdUnidade ($objProtocoloDTO->getNumIdUnidadeGeradora());
      $objRelProtocoloProtocoloDTO->setNumSequencia($objProtocoloRN->obterSequencia($objProtocoloDTO));
      $objRelProtocoloProtocoloDTO->setStrStaAssociacao (RelProtocoloProtocoloRN::$TA_DOCUMENTO_ASSOCIADO);
      $objRelProtocoloProtocoloDTO->setDthAssociacao(InfraData::getStrDataHoraAtual());

      $objRelProtocoloProtocoloRN = new RelProtocoloProtocoloRN();
      $objRelProtocoloProtocoloRN->cadastrarRN0839($objRelProtocoloProtocoloDTO);


      //numeracao - inicio
      $strNomeSerie = $objSerieDTO->getStrNome();
      $strStaNumeracao = $objSerieDTO->getStrStaNumeracao();

      if($strStaNumeracao == SerieRN::$TN_SEM_NUMERACAO){
        // nao deve entrar nunca
        if(!InfraString::isBolVazia($objDocumentoDTO->getStrNumero())){
          $objInfraException->lancarValidacao('Documento com número preenchido mas o tipo '.$strNomeSerie.' não tem numeração.');
        }
      }else if($strStaNumeracao == SerieRN::$TN_INFORMADA){
        if(InfraString::isBolVazia($objDocumentoDTO->getStrNumero())){
          $objInfraException->lancarValidacao('Tipo '.$strNomeSerie.' requer preenchimento do número do documento.');
        }else{
          $this->validarTamanhoNumeroRN0993($objDocumentoDTO, $objInfraException);
        }
      }else if (InfraString::isBolVazia($objDocumentoDTO->getStrNumero())) {
         
        $objUnidadeDTO = new UnidadeDTO();
        $objUnidadeDTO->retNumIdOrgao();
        $objUnidadeDTO->retStrSigla();
        $objUnidadeDTO->setNumIdUnidade($objDocumentoDTO->getNumIdUnidadeResponsavel());
         
        $objUnidadeRN = new UnidadeRN();
        $objUnidadeDTO = $objUnidadeRN->consultarRN0125($objUnidadeDTO);

        $objNumeracaoDTO = new NumeracaoDTO();
        $objNumeracaoDTO->retNumIdNumeracao();
        $objNumeracaoDTO->setNumIdSerie($objDocumentoDTO->getNumIdSerie());
        
        if($strStaNumeracao == SerieRN::$TN_SEQUENCIAL_UNIDADE){
          $objNumeracaoDTO->setNumIdUnidade($objDocumentoDTO->getNumIdUnidadeResponsavel());
          $objNumeracaoDTO->setNumIdOrgao(null);
          $objNumeracaoDTO->setNumAno(null);
        }else if($strStaNumeracao == SerieRN::$TN_SEQUENCIAL_ORGAO){
          $objNumeracaoDTO->setNumIdUnidade(null);
          $objNumeracaoDTO->setNumIdOrgao($objUnidadeDTO->getNumIdOrgao());
          $objNumeracaoDTO->setNumAno(null);
        }else if($strStaNumeracao == SerieRN::$TN_SEQUENCIAL_ANUAL_UNIDADE){
          $objNumeracaoDTO->setNumIdUnidade($objDocumentoDTO->getNumIdUnidadeResponsavel());
          $objNumeracaoDTO->setNumIdOrgao(null);
          $objNumeracaoDTO->setNumAno(Date('Y'));
        }else if($strStaNumeracao == SerieRN::$TN_SEQUENCIAL_ANUAL_ORGAO){
          $objNumeracaoDTO->setNumIdUnidade(null);
          $objNumeracaoDTO->setNumIdOrgao($objUnidadeDTO->getNumIdOrgao());
          $objNumeracaoDTO->setNumAno(Date('Y'));
        }else{
          $objInfraException->lancarValidacao('Tipo de numeração inválido.');
        }
        
        $objNumeracaoRN = new NumeracaoRN();
        $objNumeracaoDTORet = $objNumeracaoRN->consultar($objNumeracaoDTO);
        
        if ($objNumeracaoDTORet == null){
          $objNumeracaoDTO->setNumSequencial(0);
          $objNumeracaoDTORet = $objNumeracaoRN->cadastrar($objNumeracaoDTO);
        }
        
        $objNumeracaoDTORet = $objNumeracaoRN->bloquear($objNumeracaoDTORet);
        
        $objNumeracaoDTO = new NumeracaoDTO();
        $objNumeracaoDTO->setNumSequencial($objNumeracaoDTORet->getNumSequencial()+1);
        $objNumeracaoDTO->setNumIdNumeracao($objNumeracaoDTORet->getNumIdNumeracao());
        
        $objDocumentoDTO->setStrNumero($objNumeracaoDTO->getNumSequencial());
        
        $objNumeracaoRN->alterar($objNumeracaoDTO);
      }
      //numeracao - fim
      
      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->cadastrar($objDocumentoDTO);

      $objInfraException->lancarValidacoes();

      $this->verificarSobrestamento($objDocumentoDTO);


      $arrObjAtributoAndamentoDTO = array();
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrValor($objProtocoloDTOGerado->getStrProtocoloFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objProtocoloDTOGerado->getDblIdProtocolo());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('NIVEL_ACESSO');
      $objAtributoAndamentoDTO->setStrValor(null);
      $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      
      if (!InfraString::isBolVazia($objDocumentoDTO->getObjProtocoloDTO()->getNumIdHipoteseLegal())){
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('HIPOTESE_LEGAL');
        $objAtributoAndamentoDTO->setStrValor(null);
        $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getObjProtocoloDTO()->getNumIdHipoteseLegal());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      }      

      if (!InfraString::isBolVazia($objDocumentoDTO->getObjProtocoloDTO()->getStrStaGrauSigilo())){
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('GRAU_SIGILO');
        $objAtributoAndamentoDTO->setStrValor(null);
        $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getObjProtocoloDTO()->getStrStaGrauSigilo());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      }
      
      $objAtividadeDTO = new AtividadeDTO();
      $objAtividadeDTO->setDblIdProtocolo($objProtocoloDTO->getDblIdProcedimento());
      $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_GERACAO_DOCUMENTO);
      $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);

      $objAtividadeRN = new AtividadeRN();
      $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);

      ///

      $arrAnexos = $objProtocoloDTO->getArrObjAnexoDTO();
      for($i=0;$i<count($arrAnexos);$i++){

        $arrObjAtributoAndamentoDTO = array();
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('ANEXO');
        $objAtributoAndamentoDTO->setStrValor($arrAnexos[$i]->getStrNome());
        $objAtributoAndamentoDTO->setStrIdOrigem($arrAnexos[$i]->getNumIdAnexo());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
        $objAtributoAndamentoDTO->setStrValor($objProtocoloDTOGerado->getStrProtocoloFormatado());
        $objAtributoAndamentoDTO->setStrIdOrigem($objProtocoloDTOGerado->getDblIdProtocolo());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

        $objAtividadeDTO = new AtividadeDTO();
        $objAtividadeDTO->setDblIdProtocolo($objProtocoloDTO->getDblIdProcedimento());
        $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
        $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_ARQUIVO_ANEXADO);
        $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);
         
        $objAtividadeRN = new AtividadeRN();
        $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
         
      }

      $strStaEditor = $objDocumentoDTO->getStrStaEditor();
      
      if ($strStaEditor == EditorRN::$TE_EDOC){
         
        if (!InfraString::isBolVazia($objDocumentoDTO->getDblIdDocumentoEdocBase())){
          
          if (ConfiguracaoSEI::getInstance()->getValor('Editor','Edoc')){
          
            $objEDocRN = new EDocRN();
            $dto = new DocumentoDTO();
            $dto->setDblIdDocumento($objProtocoloDTOGerado->getDblIdProtocolo());
            $dto->setDblIdDocumentoEdoc(null);
            $dto->setDblIdDocumentoEdocBase($objDocumentoDTO->getDblIdDocumentoEdocBase());
            $dto->setDblIdTextoPadraoEdoc(null);
            $objEDocRN->processarDocumentoRN1143($dto);
            
          }else{
            
            $dto = new DocumentoDTO();
            $dto->setStrStaEditor(EditorRN::$TE_INTERNO);
            $dto->setDblIdDocumento($objProtocoloDTOGerado->getDblIdProtocolo());
            
            $objDocumentoBD->alterar($dto);
            
            $strStaEditor = EditorRN::$TE_INTERNO;
            
          }
        }
      }
        
      if ($strStaEditor == EditorRN::$TE_INTERNO){
         
        $objEditorDTO = new EditorDTO();
        $objEditorDTO->setDblIdDocumento($objProtocoloDTOGerado->getDblIdProtocolo());
        $objEditorDTO->setNumIdBaseConhecimento(null);
        
        if ($objSerieDTO->getNumIdModelo()==null){
          throw new InfraException('Tipo '.$objSerieDTO->getStrNome().' não possui modelo interno associado.');
        }
        
        $objEditorDTO->setNumIdModelo($objSerieDTO->getNumIdModelo());

        if ($objDocumentoDTO->isSetDblIdDocumentoBase() && !InfraString::isBolVazia($objDocumentoDTO->getDblIdDocumentoBase())){
          
          $objEditorDTO->setDblIdDocumentoBase($objDocumentoDTO->getDblIdDocumentoBase());

        }else if ($objDocumentoDTO->isSetDblIdDocumentoTextoBase() && !InfraString::isBolVazia($objDocumentoDTO->getDblIdDocumentoTextoBase())){
          
          $objEditorDTO->setDblIdDocumentoTextoBase($objDocumentoDTO->getDblIdDocumentoTextoBase());
        
        }else if ($objDocumentoDTO->isSetDblIdDocumentoEdocBase() && !InfraString::isBolVazia($objDocumentoDTO->getDblIdDocumentoEdocBase())){
          
          $objEditorDTO->setDblIdDocumentoEdocBase($objDocumentoDTO->getDblIdDocumentoEdocBase());
          
        }else if ($objDocumentoDTO->getStrConteudo()!=null){
          
          $objEditorDTO->setStrConteudoSecaoPrincipal($objDocumentoDTO->getStrConteudo());
          
        }else if ($objDocumentoDTO->isSetNumIdTextoPadraoInterno() && $objDocumentoDTO->getNumIdTextoPadraoInterno()!=null){
          $objEditorDTO->setNumIdTextoPadraoInterno($objDocumentoDTO->getNumIdTextoPadraoInterno());
        }
        
        $objEditorRN = new EditorRN();
        $objEditorRN->gerarVersaoInicial($objEditorDTO);
      }

      $objDocumentoDTO->setStrStaNivelAcessoGlobalProtocolo($objProtocoloDTOGerado->getStrStaNivelAcessoGlobal());
      $this->lancarAcessoControleInterno($objDocumentoDTO);

      $objSerieEscolhaDTO = new SerieEscolhaDTO();
      $objSerieEscolhaDTO->setNumIdSerie($objDocumentoDTO->getNumIdSerie());
      $objSerieEscolhaDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());

      $objSerieEscolhaRN = new SerieEscolhaRN();
      if ($objSerieEscolhaRN->contar($objSerieEscolhaDTO)==0){
        $objSerieEscolhaRN->cadastrar($objSerieEscolhaDTO);
      }

      $ret = new DocumentoDTO();
      $ret->setDblIdDocumento($objProtocoloDTOGerado->getDblIdProtocolo());
      $ret->setStrProtocoloDocumentoFormatado($objProtocoloDTOGerado->getStrProtocoloFormatado());
      return $ret;

    }catch(Exception $e){
      throw new InfraException('Erro gerando Documento.',$e);
    }
  }

  public function receberRN0991(DocumentoDTO $objDocumentoDTO){

    $bolAcumulacaoPrevia = FeedSEIProtocolos::getInstance()->isBolAcumularFeeds();
    
    FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(true);
    
    $objDocumentoDTO = $this->receberRN0991Interno($objDocumentoDTO);

    $objIndexacaoDTO = new IndexacaoDTO();
    $objIndexacaoRN = new IndexacaoRN();

    $objProtocoloDTO = new ProtocoloDTO();
    $objProtocoloDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

    $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));
    $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_GERACAO_PROTOCOLO);
    $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);
        
    if (!$bolAcumulacaoPrevia){
      FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(false);
      FeedSEIProtocolos::getInstance()->indexarFeeds();
    }
    
    return $objDocumentoDTO;
  }

  protected function receberRN0991InternoControlado(DocumentoDTO $objDocumentoDTO) {
    try{

      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_receber',__METHOD__,$objDocumentoDTO);

      //Regras de Negocio
      $objInfraException = new InfraException();
      
      $objDocumentoDTO->setStrStaProtocoloProtocolo(ProtocoloRN::$TP_DOCUMENTO_RECEBIDO);

      if ($objDocumentoDTO->isSetDblIdDocumentoEdoc() && $objDocumentoDTO->getDblIdDocumentoEdoc()!=null){
        $objInfraException->adicionarValidacao('Identificador do eDoc não pode ser informado na geração.');
      }


      $this->validarNumIdUnidadeResponsavelRN0915($objDocumentoDTO, $objInfraException);
      $this->validarNumIdSerieRN0009($objDocumentoDTO, $objInfraException);
      $this->validarTamanhoNumeroRN0993($objDocumentoDTO, $objInfraException);
      
      //conteudo nao existe nas telas de cadastro, apenas em documentos gerados por servicos
      if ($objDocumentoDTO->isSetStrConteudo()){
        $this->validarStrConteudo($objDocumentoDTO, $objInfraException);
      }else{
        $objDocumentoDTO->setStrConteudo(null);
      }

      $objDocumentoDTO->setStrConteudoAssinatura(null);
      $objDocumentoDTO->setStrCrcAssinatura(null);
      $objDocumentoDTO->setStrQrCodeAssinatura(null);
      $objDocumentoDTO->setStrSinBloqueado('N');
      $objDocumentoDTO->setStrStaEditor(EditorRN::$TE_NENHUM);
      $objDocumentoDTO->setStrSinFormulario('N');

      /*
       if (!$objDocumentoDTO->getObjProtocoloDTO()->isSetArrObjAnexoDTO() || count($objDocumentoDTO->getObjProtocoloDTO()->getArrObjAnexoDTO())==0){
      $objInfraException->adicionarValidacao('Anexo não informado.');
      }
      */

      if ($objDocumentoDTO->getObjProtocoloDTO()->isSetArrObjAnexoDTO()){
        if (count($objDocumentoDTO->getObjProtocoloDTO()->getArrObjAnexoDTO())>1){
          throw new InfraException('Mais de um anexo informado.');
        }
      }

      $this->validarNumIdTipoConferencia($objDocumentoDTO, $objInfraException);
      
      $objInfraException->lancarValidacoes();

      $objProtocoloDTO = $objDocumentoDTO->getObjProtocoloDTO();
      $objProtocoloDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());

      $this->tratarProtocoloRN1164($objDocumentoDTO);

      $objProtocoloRN = new ProtocoloRN();
      $objProtocoloDTOGerado  = $objProtocoloRN->gerarRN0154($objProtocoloDTO);

      $objDocumentoDTO->setDblIdProcedimento($objProtocoloDTO->getDblIdProcedimento());
      $objDocumentoDTO->setDblIdDocumento($objProtocoloDTOGerado->getDblIdProtocolo());
      $objDocumentoDTO->setDblIdDocumentoEdoc(null);

      $objSerieDTO = new SerieDTO();
      $objSerieDTO->setBolExclusaoLogica(false);
      $objSerieDTO->retStrNome();
      $objSerieDTO->setNumIdSerie($objDocumentoDTO->getNumIdSerie());

      $objSerieRN = new SerieRN();
      $objSerieDTO = $objSerieRN->consultarRN0644($objSerieDTO);

      //Associar o documento nesta unidade e nas unidades que tem acesso ao processo
      $objAssociarDTO = new AssociarDTO();
      $objAssociarDTO->setDblIdProcedimento($objProtocoloDTO->getDblIdProcedimento());
      $objAssociarDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
      $objAssociarDTO->setNumIdUnidade(null);
      $objAssociarDTO->setNumIdUsuario(null);
      $objAssociarDTO->setStrStaNivelAcessoGlobal($objProtocoloDTOGerado->getStrStaNivelAcessoGlobal());
      $objProtocoloRN->associarRN0982($objAssociarDTO);
      

      $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
      $objRelProtocoloProtocoloDTO->setDblIdRelProtocoloProtocolo(null);
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo1($objProtocoloDTO->getDblIdProcedimento());
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objDocumentoDTO->getDblIdDocumento());
      $objRelProtocoloProtocoloDTO->setNumIdUsuario($objProtocoloDTO->getNumIdUsuarioGerador());
      $objRelProtocoloProtocoloDTO->setNumIdUnidade ($objProtocoloDTO->getNumIdUnidadeGeradora());
      $objRelProtocoloProtocoloDTO->setStrStaAssociacao (RelProtocoloProtocoloRN::$TA_DOCUMENTO_ASSOCIADO);
      $objRelProtocoloProtocoloDTO->setNumSequencia($objProtocoloRN->obterSequencia($objProtocoloDTO));
      $objRelProtocoloProtocoloDTO->setDthAssociacao(InfraData::getStrDataHoraAtual());

      $objRelProtocoloProtocoloRN = new RelProtocoloProtocoloRN();
      $objRelProtocoloProtocoloRN->cadastrarRN0839($objRelProtocoloProtocoloDTO);

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->cadastrar($objDocumentoDTO);

      $this->verificarSobrestamento($objDocumentoDTO);


      $arrObjAtributoAndamentoDTO = array();
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrValor($objProtocoloDTOGerado->getStrProtocoloFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objProtocoloDTOGerado->getDblIdProtocolo());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('NIVEL_ACESSO');
      $objAtributoAndamentoDTO->setStrValor(null);
      $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getObjProtocoloDTO()->getStrStaNivelAcessoLocal());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      
      if (!InfraString::isBolVazia($objDocumentoDTO->getObjProtocoloDTO()->getNumIdHipoteseLegal())){
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('HIPOTESE_LEGAL');
        $objAtributoAndamentoDTO->setStrValor(null);
        $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getObjProtocoloDTO()->getNumIdHipoteseLegal());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      }

      if (!InfraString::isBolVazia($objDocumentoDTO->getObjProtocoloDTO()->getStrStaGrauSigilo())){
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('GRAU_SIGILO');
        $objAtributoAndamentoDTO->setStrValor(null);
        $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getObjProtocoloDTO()->getStrStaGrauSigilo());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      }
      
      if (!InfraString::isBolVazia($objDocumentoDTO->getNumIdTipoConferencia())){
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('TIPO_CONFERENCIA');
        $objAtributoAndamentoDTO->setStrValor(null);
        $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getNumIdTipoConferencia());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      }
      
      $objAtividadeDTO = new AtividadeDTO();
      $objAtividadeDTO->setDblIdProtocolo($objProtocoloDTO->getDblIdProcedimento());
      $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_RECEBIMENTO_DOCUMENTO);
      $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);

      $objAtividadeRN = new AtividadeRN();
      $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);

      $arrAnexos = $objProtocoloDTO->getArrObjAnexoDTO();
      for($i=0;$i<count($arrAnexos);$i++){

        $arrObjAtributoAndamentoDTO = array();
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('ANEXO');
        $objAtributoAndamentoDTO->setStrValor($arrAnexos[$i]->getStrNome());
        $objAtributoAndamentoDTO->setStrIdOrigem($arrAnexos[$i]->getNumIdAnexo());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
        $objAtributoAndamentoDTO->setStrValor($objProtocoloDTOGerado->getStrProtocoloFormatado());
        $objAtributoAndamentoDTO->setStrIdOrigem($objProtocoloDTOGerado->getDblIdProtocolo());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

        $objAtividadeDTO = new AtividadeDTO();
        $objAtividadeDTO->setDblIdProtocolo($objProtocoloDTO->getDblIdProcedimento());
        $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
        $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_ARQUIVO_ANEXADO);
        $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);
         
        $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
      }

      $objDocumentoDTO->setStrStaNivelAcessoGlobalProtocolo($objProtocoloDTOGerado->getStrStaNivelAcessoGlobal());
      $this->lancarAcessoControleInterno($objDocumentoDTO);

      //Reabertura Automática
      if ($objDocumentoDTO->isSetArrObjUnidadeDTO() && count($objDocumentoDTO->getArrObjUnidadeDTO()) > 0){
    
        if ($objProtocoloDTOGerado->getStrStaNivelAcessoGlobal()==ProtocoloRN::$NA_SIGILOSO){
          $objInfraException->lancarValidacao('Não é possível reabrir automaticamente um processo sigiloso.');
        }
        
        $objUnidadeDTO = new UnidadeDTO();
        $objUnidadeDTO->setBolExclusaoLogica(false);
        $objUnidadeDTO->retStrSigla();
        $objUnidadeDTO->retStrSinProtocolo();
        $objUnidadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
          
        $objUnidadeRN = new UnidadeRN();
        $objUnidadeDTO = $objUnidadeRN->consultarRN0125($objUnidadeDTO);
        
        if ($objUnidadeDTO->getStrSinProtocolo()=='N'){
          $objInfraException->lancarValidacao('Unidade '.$objUnidadeDTO->getStrSigla().' não está sinalizada como protocolo.');
        }
        
        $arrIdUnidadesReabertura = InfraArray::converterArrInfraDTO($objDocumentoDTO->getArrObjUnidadeDTO(),'IdUnidade');
        
        $objAtividadeDTO = new AtividadeDTO();
        $objAtividadeDTO->setDistinct(true);
        $objAtividadeDTO->retNumIdUnidade();
        $objAtividadeDTO->setStrStaNivelAcessoGlobalProtocolo(ProtocoloRN::$NA_SIGILOSO, InfraDTO::$OPER_DIFERENTE);
        $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
        $objAtividadeDTO->setNumIdTarefa(array(TarefaRN::$TI_GERACAO_PROCEDIMENTO, TarefaRN::$TI_PROCESSO_REMETIDO_UNIDADE), InfraDTO::$OPER_IN);
        $objAtividadeDTO->setNumIdUnidade($arrIdUnidadesReabertura,InfraDTO::$OPER_IN);
        
        $arrIdUnidadeTramitacao = InfraArray::converterArrInfraDTO($objAtividadeRN->listarRN0036($objAtividadeDTO),'IdUnidade');
        
        foreach($arrIdUnidadesReabertura as $numIdUnidadeReabertura){
          if (!in_array($numIdUnidadeReabertura, $arrIdUnidadeTramitacao)){
            
            $objUnidadeDTO = new UnidadeDTO();
            $objUnidadeDTO->setBolExclusaoLogica(false);
            $objUnidadeDTO->retStrSigla();
            $objUnidadeDTO->setNumIdUnidade($numIdUnidadeReabertura);
            
            $objUnidadeDTO = $objUnidadeRN->consultarRN0125($objUnidadeDTO);
            
            if ($objUnidadeDTO==null){
              $objInfraException->adicionarValidacao('Unidade ['.$numIdUnidadeReabertura.'] não encontrada para reabertura do processo.');
            }else{
              $objInfraException->adicionarValidacao('Não é possível reabrir o processo na unidade '.$objUnidadeDTO->getStrSigla().' pois não ocorreu tramitação nesta unidade.');
            }
          }
        }
        
        $objInfraException->lancarValidacoes();
        
        $objAtividadeDTO = new AtividadeDTO();
        $objAtividadeDTO->setDistinct(true);
        $objAtividadeDTO->retNumIdUnidade();
        $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
        $objAtividadeDTO->setNumIdUnidade($arrIdUnidadeTramitacao, InfraDTO::$OPER_IN);
        $objAtividadeDTO->setDthConclusao(null);
        
        $arrIdUnidadeAberto = InfraArray::converterArrInfraDTO($objAtividadeRN->listarRN0036($objAtividadeDTO),'IdUnidade');

        $objProcedimentoRN = new ProcedimentoRN();
        foreach($arrIdUnidadesReabertura as $numIdUnidadeReabertura){
          if (!in_array($numIdUnidadeReabertura, $arrIdUnidadeAberto)){
              $objReabrirProcessoDTO = new ReabrirProcessoDTO();
              $objReabrirProcessoDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());
              $objReabrirProcessoDTO->setNumIdUnidade($numIdUnidadeReabertura);
              $objReabrirProcessoDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
              $objProcedimentoRN->reabrirRN0966($objReabrirProcessoDTO);
          }
        }
      }

      $ret = new DocumentoDTO();
      $ret->setDblIdDocumento($objProtocoloDTOGerado->getDblIdProtocolo());
      $ret->setStrProtocoloDocumentoFormatado($objProtocoloDTOGerado->getStrProtocoloFormatado());
      
      return $ret;

    }catch(Exception $e){
      throw new InfraException('Erro recebendo Documento.',$e);
    }
  }

  protected function verificarSobrestamento(DocumentoDTO $objDocumentoDTO){
    try{

      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->retStrStaEstado();
      $objProtocoloDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());

      $objProtocoloRN = new ProtocoloRN();
      $objProtocoloDTO = $objProtocoloRN->consultarRN0186($objProtocoloDTO);

      if ($objProtocoloDTO->getStrStaEstado()==ProtocoloRN::$TE_PROCEDIMENTO_SOBRESTADO){


        $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
        $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objDocumentoDTO->getDblIdProcedimento());

        $objProcedimentoRN = new ProcedimentoRN();
        $objProcedimentoRN->removerSobrestamentoRN1017(array($objRelProtocoloProtocoloDTO));
      }

    }catch(Exception $e){
      throw new InfraException('Erro verificando sobrestamento do processo.',$e);
    }
  }

  public function alterarRN0004(DocumentoDTO $objDocumentoDTO){

    $bolAcumulacaoPrevia = FeedSEIProtocolos::getInstance()->isBolAcumularFeeds();

    FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(true);

    $this->alterarRN0004Interno($objDocumentoDTO);

    $objIndexacaoDTO = new IndexacaoDTO();
    $objIndexacaoRN = new IndexacaoRN();

    $objProtocoloDTO = new ProtocoloDTO();
    $objProtocoloDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());
    $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));
    $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_ALTERACAO_PROTOCOLO_METADADOS);

    $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);

    if (!$bolAcumulacaoPrevia){
      FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(false);
      FeedSEIProtocolos::getInstance()->indexarFeeds();
    }
  }

  protected function alterarRN0004InternoControlado(DocumentoDTO $parObjDocumentoDTO){
    try {

      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_alterar',__METHOD__,$parObjDocumentoDTO);

      //Regras de Negocio
      $objInfraException = new InfraException();

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      
      if ($parObjDocumentoDTO->isSetNumVersaoLock()){
        $parObjDocumentoDTO = $objDocumentoBD->bloquear($parObjDocumentoDTO);
      }

      $this->validarDocumentoPublicadoRN1211($parObjDocumentoDTO);

      $objInfraException->lancarValidacoes();

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retDblIdDocumentoEdoc();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retNumIdUnidadeResponsavel();
      $objDocumentoDTO->retNumIdSerie();
      $objDocumentoDTO->retNumIdModeloEdocSerie();
      $objDocumentoDTO->retStrNumero();
      $objDocumentoDTO->retDtaGeracaoProtocolo();
      $objDocumentoDTO->retNumIdUnidadeGeradoraProtocolo();
      $objDocumentoDTO->retStrSiglaUnidadeGeradoraProtocolo();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrStaArquivamentoProtocolo();
      $objDocumentoDTO->retNumIdTipoConferencia();
      $objDocumentoDTO->retStrSinFormulario();
      $objDocumentoDTO->retStrSinBloqueado();

      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

      $objDocumentoBancoDTO = $this->consultarRN0005($objDocumentoDTO);

      if ($parObjDocumentoDTO->isSetDblIdProcedimento()){
        if ($parObjDocumentoDTO->getDblIdProcedimento() != $objDocumentoBancoDTO->getDblIdProcedimento()){
          $objInfraException->adicionarValidacao('Não é possível alterar o processo onde o documento foi gerado.');
        }
      }else{
        $parObjDocumentoDTO->setDblIdProcedimento($objDocumentoBancoDTO->getDblIdProcedimento());
      }

      $parObjDocumentoDTO->setStrSinBloqueado($objDocumentoBancoDTO->getStrSinBloqueado());

      if($objDocumentoBancoDTO->getNumIdUnidadeGeradoraProtocolo() != SessaoSEI::getInstance()->getNumIdUnidadeAtual()){

        if ($parObjDocumentoDTO->isSetNumIdUnidadeResponsavel()){
          if ($parObjDocumentoDTO->getNumIdUnidadeResponsavel() != $objDocumentoBancoDTO->getNumIdUnidadeResponsavel()){
            $objInfraException->adicionarValidacao('Unidade Responsável somente pode ser alterada pela unidade '.$objDocumentoBancoDTO->getStrSiglaUnidadeGeradoraProtocolo().'.');
          }
        }

        if ($parObjDocumentoDTO->isSetNumIdSerie()){
          if ($parObjDocumentoDTO->getNumIdSerie() != $objDocumentoBancoDTO->getNumIdSerie()){
            $objInfraException->adicionarValidacao('Tipo do documento somente pode ser alterado pela unidade '.$objDocumentoBancoDTO->getStrSiglaUnidadeGeradoraProtocolo().'.');
          }
        }

        if ($parObjDocumentoDTO->isSetStrNumero()){
          if ($parObjDocumentoDTO->getStrNumero() != $objDocumentoBancoDTO->getStrNumero()){
            $objInfraException->adicionarValidacao('Número somente pode ser alterado pela unidade '.$objDocumentoBancoDTO->getStrSiglaUnidadeGeradoraProtocolo().'.');
          }
        }

        if ($parObjDocumentoDTO->isSetObjProtocoloDTO()){
          if ($parObjDocumentoDTO->getObjProtocoloDTO()->isSetDtaGeracao()){
            if ($parObjDocumentoDTO->getObjProtocoloDTO()->getDtaGeracao() != $objDocumentoBancoDTO->getDtaGeracaoProtocolo()){
              $objInfraException->adicionarValidacao('Data do protocolo somente pode ser alterada pela unidade '.$objDocumentoBancoDTO->getStrSiglaUnidadeGeradoraProtocolo().'.');
            }
          }
        }
      }

      if ($parObjDocumentoDTO->isSetDblIdDocumentoEdoc()){
        $parObjDocumentoDTO->unSetDblIdDocumentoEdoc();
      }

      //o conteudo é alterado apenas por uma chamada separada
      if ($parObjDocumentoDTO->isSetStrConteudo()){
        $parObjDocumentoDTO->unSetStrConteudo();
      }

      if (!$parObjDocumentoDTO->isSetStrStaProtocoloProtocolo()){
      	$parObjDocumentoDTO->setStrStaProtocoloProtocolo($objDocumentoBancoDTO->getStrStaProtocoloProtocolo());
      }
      
      if ($parObjDocumentoDTO->isSetNumIdUnidadeResponsavel()){
        $this->validarNumIdUnidadeResponsavelRN0915($parObjDocumentoDTO, $objInfraException);
      }else{
        $parObjDocumentoDTO->setNumIdUnidadeResponsavel($objDocumentoBancoDTO->getNumIdUnidadeResponsavel());
      }

      $bolAlterouSerie = false;
      if ($parObjDocumentoDTO->isSetNumIdSerie()){
        
      	if ($parObjDocumentoDTO->getNumIdSerie()!=$objDocumentoBancoDTO->getNumIdSerie()){
        	$this->validarNumIdSerieRN0009($parObjDocumentoDTO, $objInfraException);
          $bolAlterouSerie = true;
        }
        
      }else{
        $parObjDocumentoDTO->setNumIdSerie($objDocumentoBancoDTO->getNumIdSerie());
      }

      if ($parObjDocumentoDTO->isSetStrNumero()){
        $this->validarStrNumeroRN0010($parObjDocumentoDTO, $objInfraException);
      }

      if ($parObjDocumentoDTO->isSetStrConteudoAssinatura()){
        $parObjDocumentoDTO->unSetStrConteudoAssinatura();
      }

      if ($parObjDocumentoDTO->isSetStrCrcAssinatura()){
        $parObjDocumentoDTO->unSetStrCrcAssinatura();
      }

      if ($parObjDocumentoDTO->isSetStrQrCodeAssinatura()){
        $parObjDocumentoDTO->unSetStrQrCodeAssinatura();
      }
      
      if ($parObjDocumentoDTO->isSetNumIdTipoConferencia()){
        $parObjDocumentoDTO->unSetNumIdTipoConferencia();
      }
      
      if ($parObjDocumentoDTO->isSetObjProtocoloDTO()){
        $objProtocoloDTO  = $parObjDocumentoDTO->getObjProtocoloDTO();

        //evita remover anexos de formulários
        if ($objDocumentoBancoDTO->getStrSinFormulario()=='S'){
          $objProtocoloDTO->unSetArrObjAnexoDTO();
        }
        
        $objProtocoloRN = new ProtocoloRN();
        $objProtocoloRN->alterarRN0203($objProtocoloDTO);
      }

      $objInfraException->lancarValidacoes();

      $objDocumentoBD->alterar($parObjDocumentoDTO);


      if ($bolAlterouSerie){

        $objProtocoloDTO = new ProtocoloDTO();
        $objProtocoloDTO->retStrStaNivelAcessoGlobal();
        $objProtocoloDTO->setDblIdProtocolo($objDocumentoBancoDTO->getDblIdProcedimento());

        $objProtocoloRN = new ProtocoloRN();
        $objProtocoloDTO = $objProtocoloRN->consultarRN0186($objProtocoloDTO);
         
        $objDocumentoDTO = new DocumentoDTO();
        $objDocumentoDTO->setNumIdSerie($parObjDocumentoDTO->getNumIdSerie());
        $objDocumentoDTO->setDblIdProcedimento($objDocumentoBancoDTO->getDblIdProcedimento());
        $objDocumentoDTO->setStrStaNivelAcessoGlobalProtocolo($objProtocoloDTO->getStrStaNivelAcessoGlobal());

        $this->lancarAcessoControleInterno($objDocumentoDTO);
      }


      //Auditoria

      return $parObjDocumentoDTO;

    }catch(Exception $e){
      throw new InfraException('Erro alterando Documento.',$e);
    }
  }

  protected function configurarDocumentoEdocRN1175Controlado(DocumentoDTO $parObjDocumentoDTO){
    try{

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retDblIdDocumentoEdoc();
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

      $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

      if ($objDocumentoDTO->getDblIdDocumentoEdoc()!=null){
        throw new InfraException('Documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().' já possui documento associado no eDoc.');
      }


      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->setDblIdDocumentoEdoc($parObjDocumentoDTO->getDblIdDocumentoEdoc());
      $objDocumentoDTO->setStrConteudo($parObjDocumentoDTO->getStrConteudo());
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->alterar($objDocumentoDTO);

    }catch(Exception $e){
      throw new InfraException('Erro configurando documento do eDoc.',$e);
    }
  }

  public function alterarRecebidoRN0992(DocumentoDTO $parObjDocumentoDTO){

    $bolAcumulacaoPrevia = FeedSEIProtocolos::getInstance()->isBolAcumularFeeds();

    FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(true);

    $objIndexacaoRN	= new IndexacaoRN();
    $objProtocoloDTO = new ProtocoloDTO();
    $objProtocoloDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());
    
    $objIndexacaoDTO 	= new IndexacaoDTO();
    $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));
    $objIndexacaoRN->prepararRemocaoProtocolo($objIndexacaoDTO);
    
    $this->alterarRecebidoRN0992Interno($parObjDocumentoDTO);
    
    //FeedSEIProtocolos::getInstance()->indexarFeeds();
    
    $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_ALTERACAO_PROTOCOLO_CONTEUDO);
    $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);

    if (!$bolAcumulacaoPrevia){
      FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(false);
      FeedSEIProtocolos::getInstance()->indexarFeeds();
    }
  }

  protected function alterarRecebidoRN0992InternoControlado(DocumentoDTO $parObjDocumentoDTO){
    try {

      global $SEI_MODULOS;
      
      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_alterar_recebido',__METHOD__,$parObjDocumentoDTO);


      //Regras de Negocio
      $objInfraException = new InfraException();

      if ($parObjDocumentoDTO->isSetNumVersaoLock()){
        $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
        $parObjDocumentoDTO = $objDocumentoBD->bloquear($parObjDocumentoDTO);
      }

      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->retNumIdUnidadeOrigemAtividade();
      $objAtributoAndamentoDTO->retStrSiglaUnidadeOrigemAtividade();
      $objAtributoAndamentoDTO->retNumIdTarefaAtividade();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrIdOrigem($parObjDocumentoDTO->getDblIdDocumento());
      $objAtributoAndamentoDTO->setNumIdTarefaAtividade(array(TarefaRN::$TI_RECEBIMENTO_DOCUMENTO,TarefaRN::$TI_ARQUIVAMENTO),InfraDTO::$OPER_IN);

      $objAtributoAndamentoRN = new AtributoAndamentoRN();
      $arrObjAtributoAndamentoDTO = $objAtributoAndamentoRN->listarRN1367($objAtributoAndamentoDTO);
      
      $idUnidadeRecebimento = '';
      $siglaUnidadeRecebimento = '';
      $idUnidadeArquivamento = '';
      $siglaUnidadeArquivamento = '';

      $numRegistros = count($arrObjAtributoAndamentoDTO);
      for($i=0;$i<$numRegistros;$i++){
        if ($arrObjAtributoAndamentoDTO[$i]->getNumIdTarefaAtividade() == TarefaRN::$TI_RECEBIMENTO_DOCUMENTO){
          $idUnidadeRecebimento = $arrObjAtributoAndamentoDTO[$i]->getNumIdUnidadeOrigemAtividade();
          $siglaUnidadeRecebimento = $arrObjAtributoAndamentoDTO[$i]->getStrSiglaUnidadeOrigemAtividade();
        }
        if ($arrObjAtributoAndamentoDTO[$i]->getNumIdTarefaAtividade() == TarefaRN::$TI_ARQUIVAMENTO){
          $idUnidadeArquivamento = $arrObjAtributoAndamentoDTO[$i]->getNumIdUnidadeOrigemAtividade();
          $siglaUnidadeArquivamento = $arrObjAtributoAndamentoDTO[$i]->getStrSiglaUnidadeOrigemAtividade();
        }
      }

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retDblIdDocumentoEdoc();
      $objDocumentoDTO->retNumIdUnidadeResponsavel();
      $objDocumentoDTO->retNumIdSerie();
      $objDocumentoDTO->retNumIdTipoConferencia();
      $objDocumentoDTO->retStrNumero();
      $objDocumentoDTO->retStrSinBloqueado();
      $objDocumentoDTO->retDtaGeracaoProtocolo();

      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

      $objDocumentoBancoDTO = $this->consultarRN0005($objDocumentoDTO);

      if ($objDocumentoBancoDTO->getStrStaProtocoloProtocolo()!=ProtocoloRN::$TP_DOCUMENTO_RECEBIDO){
        $objInfraException->lancarValidacao('O documento '.$objDocumentoBancoDTO->getStrProtocoloDocumentoFormatado().' não é um documento externo.');
      }

      //configura para validações
      $parObjDocumentoDTO->setStrStaProtocoloProtocolo(ProtocoloRN::$TP_DOCUMENTO_RECEBIDO);


      if ($parObjDocumentoDTO->isSetDblIdProcedimento()){
        if ($parObjDocumentoDTO->getDblIdProcedimento() != $objDocumentoBancoDTO->getDblIdProcedimento()){
          $objInfraException->adicionarValidacao('Não é possível alterar o processo onde o documento foi recebido.');
        }
      }else{
        $parObjDocumentoDTO->setDblIdProcedimento($objDocumentoBancoDTO->getDblIdProcedimento());
      }

      $parObjDocumentoDTO->setStrSinBloqueado($objDocumentoBancoDTO->getStrSinBloqueado());

      if ($parObjDocumentoDTO->isSetDblIdDocumentoEdoc() && !InfraString::isBolVazia($parObjDocumentoDTO->getDblIdDocumentoEdoc())){
        $objInfraException->adicionarValidacao('Identificador do eDoc não pode ser informado na alteração de documento externo.');
      }

      if($idUnidadeRecebimento != SessaoSEI::getInstance()->getNumIdUnidadeAtual()){
        if ($parObjDocumentoDTO->isSetNumIdUnidadeResponsavel()){
          if ($parObjDocumentoDTO->getNumIdUnidadeResponsavel() != $objDocumentoBancoDTO->getNumIdUnidadeResponsavel()){
            $objInfraException->adicionarValidacao('Unidade Responsável somente pode ser alterada pela unidade '.$siglaUnidadeRecebimento.'.');
          }

          if ($parObjDocumentoDTO->isSetNumIdSerie()){
            if ($parObjDocumentoDTO->getNumIdSerie() != $objDocumentoBancoDTO->getNumIdSerie()){
              $objInfraException->adicionarValidacao('Tipo do documento somente pode ser alterado pela unidade '.$siglaUnidadeRecebimento.'.');
            }
          }

          if ($parObjDocumentoDTO->isSetStrNumero()){
            if ($parObjDocumentoDTO->getStrNumero() != $objDocumentoBancoDTO->getStrNumero()){
              $objInfraException->adicionarValidacao('Número somente pode ser alterado pela unidade '.$siglaUnidadeRecebimento.'.');
            }
          }

          if ($parObjDocumentoDTO->isSetObjProtocoloDTO()){
            if ($parObjDocumentoDTO->getObjProtocoloDTO()->isSetDtaGeracao()){
              if ($parObjDocumentoDTO->getObjProtocoloDTO()->getDtaGeracao() != $objDocumentoBancoDTO->getDtaGeracaoProtocolo()){
                $objInfraException->adicionarValidacao('Data do protocolo somente pode ser alterada pela unidade '.$siglaUnidadeRecebimento.'.');
              }
            }
          }
          
          if ($parObjDocumentoDTO->isSetNumIdTipoConferencia()){
            if ($parObjDocumentoDTO->getNumIdTipoConferencia() != $objDocumentoBancoDTO->getNumIdTipoConferencia()){
              $objInfraException->adicionarValidacao('Tipo de conferência do documento somente pode ser alterado pela unidade '.$siglaUnidadeRecebimento.'.');
            }
          }
        }
      }

      if ($parObjDocumentoDTO->isSetNumIdUnidadeResponsavel()){
        $this->validarNumIdUnidadeResponsavelRN0915($parObjDocumentoDTO, $objInfraException);
      }else{
        $parObjDocumentoDTO->setNumIdUnidadeResponsavel($objDocumentoBancoDTO->getNumIdUnidadeResponsavel());
      }

      
      $bolAlterouSerie = false;
      if ($parObjDocumentoDTO->isSetNumIdSerie()){
        
      	if ($parObjDocumentoDTO->getNumIdSerie()!=$objDocumentoBancoDTO->getNumIdSerie()){
        	$this->validarNumIdSerieRN0009($parObjDocumentoDTO, $objInfraException);
          $bolAlterouSerie = true;
        }

      }else{
        $parObjDocumentoDTO->setNumIdSerie($objDocumentoBancoDTO->getNumIdSerie());
      }

      if ($parObjDocumentoDTO->isSetStrNumero()){
        $this->validarTamanhoNumeroRN0993($parObjDocumentoDTO, $objInfraException);
      }

      if ($parObjDocumentoDTO->isSetObjProtocoloDTO()){

        if ($parObjDocumentoDTO->getObjProtocoloDTO()->isSetArrObjAnexoDTO()){

          if (count($parObjDocumentoDTO->getObjProtocoloDTO()->getArrObjAnexoDTO())>1){
            throw new InfraException('Mais de um anexo informado.');
          }

          //busca conjunto de anexos antes da alteração
          $objAnexoDTO = new AnexoDTO();
          $objAnexoDTO->retNumIdAnexo();
          $objAnexoDTO->retStrNome();
          $objAnexoDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());

          $objAnexoRN = new AnexoRN();
          $arrObjAnexoDTOOriginal = $objAnexoRN->listarRN0218($objAnexoDTO);
        }
         
        $objProtocoloDTO  = $parObjDocumentoDTO->getObjProtocoloDTO();

        $objProtocoloRN = new ProtocoloRN();
        $objProtocoloRN->alterarRN0203($objProtocoloDTO);
      }

      if ($parObjDocumentoDTO->isSetNumIdTipoConferencia()){
        
        $this->validarNumIdTipoConferencia($parObjDocumentoDTO, $objInfraException);
        
        if ($parObjDocumentoDTO->getNumIdTipoConferencia() != $objDocumentoBancoDTO->getNumIdTipoConferencia()){

          $arrObjAtributoAndamentoDTO = array();
          
          $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
          $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
          $objAtributoAndamentoDTO->setStrValor($objDocumentoBancoDTO->getStrProtocoloDocumentoFormatado());
          $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoBancoDTO->getDblIdDocumento());
          $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
          
          $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
          $objAtributoAndamentoDTO->setStrNome('TIPO_CONFERENCIA');
          $objAtributoAndamentoDTO->setStrValor(null);
          $objAtributoAndamentoDTO->setStrIdOrigem($parObjDocumentoDTO->getNumIdTipoConferencia());
          $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
        
          $objAtividadeDTO = new AtividadeDTO();
          $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
          $objAtividadeDTO->setDblIdProtocolo($objDocumentoBancoDTO->getDblIdProcedimento());
          $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_ALTERACAO_TIPO_CONFERENCIA_DOCUMENTO);
          $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);
        
          $objAtividadeRN = new AtividadeRN();
          $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
        }
        
      }else{
        $parObjDocumentoDTO->setNumIdTipoConferencia($objDocumentoBancoDTO->getNumIdTipoConferencia());
      }
            
      $objInfraException->lancarValidacoes();
      
      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->alterar($parObjDocumentoDTO);

      if ($parObjDocumentoDTO->isSetObjProtocoloDTO() && $parObjDocumentoDTO->getObjProtocoloDTO()->isSetArrObjAnexoDTO()) {

        //busca conjunto de anexos após a alteração
        $objAnexoDTO = new AnexoDTO();
        $objAnexoDTO->retNumIdAnexo();
        $objAnexoDTO->retStrNome();
        $objAnexoDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());

        $objAnexoRN = new AnexoRN();
        $arrObjAnexoDTONovo = $objAnexoRN->listarRN0218($objAnexoDTO);

        $arrIdAnexoOriginal = InfraArray::converterArrInfraDTO($arrObjAnexoDTOOriginal,'IdAnexo');
        $arrIdAnexoNovo = InfraArray::converterArrInfraDTO($arrObjAnexoDTONovo,'IdAnexo');

        sort($arrIdAnexoOriginal);
        sort($arrIdAnexoNovo);

        //verifica se houve alteração no conteúdo (adicionou, removeu ou modificou)
        if ($arrIdAnexoOriginal != $arrIdAnexoNovo){

          $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
          $objRelProtocoloProtocoloDTO->retStrSinCiencia();
          $objRelProtocoloProtocoloDTO->setDblIdProtocolo1($objDocumentoBancoDTO->getDblIdProcedimento());
          $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objDocumentoBancoDTO->getDblIdDocumento());
          $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_DOCUMENTO_ASSOCIADO);

          $objRelProtocoloProtocoloRN = new RelProtocoloProtocoloRN();
          $objRelProtocoloProtocoloDTO = $objRelProtocoloProtocoloRN->consultarRN0841($objRelProtocoloProtocoloDTO);

          if ($objRelProtocoloProtocoloDTO->getStrSinCiencia() == 'S') {
            $objInfraException->lancarValidacao('Conteúdo do documento não pode ser alterado porque recebeu ciência.');
          }

          if ($idUnidadeArquivamento!=null){
            $objInfraException->lancarValidacao('Conteúdo do documento não pode ser alterado porque foi arquivado pela unidade '.$siglaUnidadeArquivamento.'.');
          }

          if ($parObjDocumentoDTO->getStrSinBloqueado() == 'S') {
            $objInfraException->lancarValidacao('Não é mais possível alterar o conteúdo do documento.');
          }
        }

        $arrObjAnexoDTOOriginal = InfraArray::indexarArrInfraDTO($arrObjAnexoDTOOriginal, 'IdAnexo');
        $arrObjAnexoDTONovo = InfraArray::indexarArrInfraDTO($arrObjAnexoDTONovo, 'IdAnexo');

        //verifica se removeu pelo menos um anexo
        foreach ($arrObjAnexoDTOOriginal as $objAnexoDTOOriginal) {
          if (!in_array($objAnexoDTOOriginal->getNumIdAnexo(), array_keys($arrObjAnexoDTONovo))) {

            $this->cancelarAssinatura($objDocumentoDTO);

            $objProtocoloDTO = new ProtocoloDTO();
            $objProtocoloDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());
            $objProtocoloRN = new ProtocoloRN();
            $objProtocoloRN->validarProtocoloArquivadoRN1210($objProtocoloDTO);

            if (ConfiguracaoSEI::getInstance()->isSetValor('SEI', 'Modulos')) {
              foreach (array_keys(ConfiguracaoSEI::getInstance()->getValor('SEI', 'Modulos')) as $strModulo) {
                //if (method_exists($SEI_MODULOS[$strModulo]['Integracao'],'atualizarConteudoDocumento')){
                $SEI_MODULOS[$strModulo]['Integracao']->atualizarConteudoDocumento($parObjDocumentoDTO);
                //}
              }
            }
            break;
          }
        }

        //lança um andamento para cada anexo removido
        foreach ($arrObjAnexoDTOOriginal as $objAnexoDTOOriginal) {
          if (!in_array($objAnexoDTOOriginal->getNumIdAnexo(), array_keys($arrObjAnexoDTONovo))) {

            $arrObjAtributoAndamentoDTO = array();
            $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
            $objAtributoAndamentoDTO->setStrNome('ANEXO');
            $objAtributoAndamentoDTO->setStrValor($objAnexoDTOOriginal->getStrNome());
            $objAtributoAndamentoDTO->setStrIdOrigem(null);
            $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

            $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
            $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
            $objAtributoAndamentoDTO->setStrValor($objDocumentoBancoDTO->getStrProtocoloDocumentoFormatado());
            $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoBancoDTO->getDblIdDocumento());
            $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

            $objAtividadeDTO = new AtividadeDTO();
            $objAtividadeDTO->setDblIdProtocolo($objDocumentoBancoDTO->getDblIdProcedimento());
            $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
            $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_ARQUIVO_DESANEXADO);
            $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);

            $objAtividadeRN = new AtividadeRN();
            $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
          }
        }

        //lança um andamento para cada anexo incluido
        foreach ($arrObjAnexoDTONovo as $objAnexoNovo) {
          if (!in_array($objAnexoNovo->getNumIdAnexo(), array_keys($arrObjAnexoDTOOriginal))) {

            $arrObjAtributoAndamentoDTO = array();
            $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
            $objAtributoAndamentoDTO->setStrNome('ANEXO');
            $objAtributoAndamentoDTO->setStrValor($objAnexoNovo->getStrNome());
            $objAtributoAndamentoDTO->setStrIdOrigem($objAnexoNovo->getNumIdAnexo());
            $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

            $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
            $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
            $objAtributoAndamentoDTO->setStrValor($objDocumentoBancoDTO->getStrProtocoloDocumentoFormatado());
            $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoBancoDTO->getDblIdDocumento());
            $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

            $objAtividadeDTO = new AtividadeDTO();
            $objAtividadeDTO->setDblIdProtocolo($objDocumentoBancoDTO->getDblIdProcedimento());
            $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
            $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_ARQUIVO_ANEXADO);
            $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);

            $objAtividadeRN = new AtividadeRN();
            $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
          }
        }
      }

      if ($bolAlterouSerie){

        $objProtocoloDTO = new ProtocoloDTO();
        $objProtocoloDTO->retStrStaNivelAcessoGlobal();
        $objProtocoloDTO->setDblIdProtocolo($objDocumentoBancoDTO->getDblIdProcedimento());

        $objProtocoloRN = new ProtocoloRN();
        $objProtocoloDTO = $objProtocoloRN->consultarRN0186($objProtocoloDTO);
         
        $objDocumentoDTO = new DocumentoDTO();
        $objDocumentoDTO->setNumIdSerie($parObjDocumentoDTO->getNumIdSerie());
        $objDocumentoDTO->setDblIdProcedimento($objDocumentoBancoDTO->getDblIdProcedimento());
        $objDocumentoDTO->setStrStaNivelAcessoGlobalProtocolo($objProtocoloDTO->getStrStaNivelAcessoGlobal());

        $this->lancarAcessoControleInterno($objDocumentoDTO);
      }

    }catch(Exception $e){
      throw new InfraException('Erro alterando Documento Externo.',$e);
    }
  }

  public function excluirRN0006(DocumentoDTO $parObjDocumentoDTO){
     
    $objProtocoloDTO = new ProtocoloDTO();
    $objProtocoloDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());
     
    $objIndexacaoDTO = new IndexacaoDTO();
    $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));

    $objIndexacaoRN	= new IndexacaoRN();
    $objIndexacaoRN->prepararRemocaoProtocolo($objIndexacaoDTO);

    $this->excluirRN0006Interno($parObjDocumentoDTO);

    FeedSEIProtocolos::getInstance()->indexarFeeds();
     
  }

  protected function excluirRN0006InternoControlado(DocumentoDTO $parObjDocumentoDTO){
    try {

      global $SEI_MODULOS;
      
      //Regras de Negocio
      $objInfraException = new InfraException();

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retNumIdSerie();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retNumIdUnidadeGeradoraProtocolo();
      $objDocumentoDTO->retStrStaEditor();
      $objDocumentoDTO->retStrConteudo();
      $objDocumentoDTO->retStrSinBloqueado();
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
      $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

      if ($objDocumentoDTO==null){
        //throw new InfraException('Registro não encontrado.');
        $objInfraException->lancarValidacao('Documento não encontrado.');
      }

      $parObjDocumentoDTO->setStrConteudo($objDocumentoDTO->getStrConteudo());
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_excluir',__METHOD__,$parObjDocumentoDTO);

      if($objDocumentoDTO->getNumIdUnidadeGeradoraProtocolo()!= SessaoSEI::getInstance()->getNumIdUnidadeAtual()){
        $objInfraException->adicionarValidacao('Documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().' somente pode ser excluído pela unidade geradora.');
      }

      $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($parObjDocumentoDTO->getDblIdDocumento());
      $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_DOCUMENTO_MOVIDO);
      
      $objRelProtocoloProtocoloRN = new RelProtocoloProtocoloRN();
      if ($objRelProtocoloProtocoloRN->contarRN0843($objRelProtocoloProtocoloDTO)){
        $objInfraException->adicionarValidacao('Não foi possível excluir o documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().' porque ele foi movimentado entre processos.');        
      }

      if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
        $this->validarDocumentoPublicadoRN1211($parObjDocumentoDTO);
      }

      if ($objDocumentoDTO->getStrSinBloqueado()=='S'){
        $objInfraException->adicionarValidacao('Não é mais possível excluir o documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().'.');
      }

      $objAcessoExternoDTO = new AcessoExternoDTO();
      $objAcessoExternoDTO->setBolExclusaoLogica(false);
      $objAcessoExternoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
      $objAcessoExternoDTO->setStrStaTipo(AcessoExternoRN::$TA_ASSINATURA_EXTERNA);
       
      $objAcessoExternoRN = new AcessoExternoRN();
      if ($objAcessoExternoRN->contar($objAcessoExternoDTO)){
        $objInfraException->adicionarValidacao('Não foi possível excluir o documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().' porque foi dada liberação para assinatura externa.');
      }
      

      $objInfraException->lancarValidacoes();

      if (ConfiguracaoSEI::getInstance()->isSetValor('SEI','Modulos')){
        foreach(array_keys(ConfiguracaoSEI::getInstance()->getValor('SEI','Modulos')) as $strModulo){
        	//if (method_exists($SEI_MODULOS[$strModulo]['Integracao'],'excluirDocumento')){
            $SEI_MODULOS[$strModulo]['Integracao']->excluirDocumento($parObjDocumentoDTO);
        	//}
        }
      }
      
      /*
      $objAcessoExternoDTO = new AcessoExternoDTO();
      $objAcessoExternoDTO->retNumIdAcessoExterno();
      $objAcessoExternoDTO->setBolExclusaoLogica(false);
      $objAcessoExternoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
      $objAcessoExternoDTO->setStrStaTipo(AcessoExternoRN::$TA_ASSINATURA_EXTERNA);
      $objAcessoExternoRN->excluir($objAcessoExternoRN->listar($objAcessoExternoDTO));
      */
      
      $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
      $objRelProtocoloProtocoloDTO->retDblIdProtocolo1();
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objDocumentoDTO->getDblIdDocumento());
      $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_DOCUMENTO_ASSOCIADO);

      $objRelProtocoloProtocoloRN = new RelProtocoloProtocoloRN();
      $objRelProtocoloProtocoloDTO = $objRelProtocoloProtocoloRN->consultarRN0841($objRelProtocoloProtocoloDTO);


      $objAssinaturaDTO = new AssinaturaDTO();
      $objAssinaturaDTO->retNumIdAssinatura();
      $objAssinaturaDTO->setBolExclusaoLogica(false); //pode ter assinatura digital pendente de confirmação
      $objAssinaturaDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());

      $objAssinaturaRN = new AssinaturaRN();
      $objAssinaturaRN->excluirRN1321($objAssinaturaRN->listarRN1323($objAssinaturaDTO));
       
      if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_INTERNO){
        $objSecaoDocumentoDTO = new SecaoDocumentoDTO();
        $objSecaoDocumentoDTO->retNumIdSecaoDocumento();
        $objSecaoDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
         
        $objSecaoDocumentoRN = new SecaoDocumentoRN();
        $objSecaoDocumentoRN->excluir($objSecaoDocumentoRN->listar($objSecaoDocumentoDTO));
      }

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->excluir($parObjDocumentoDTO);

      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());

      $objProtocoloRN = new ProtocoloRN();
      $objProtocoloRN->excluirRN0748($objProtocoloDTO);
       
      $arrObjAtributoAndamentoDTO = array();
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrValor($objDocumentoDTO->getStrProtocoloDocumentoFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getDblIdDocumento());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

      $objAtividadeDTO = new AtividadeDTO();
      $objAtividadeDTO->setDblIdProtocolo($objRelProtocoloProtocoloDTO->getDblIdProtocolo1());
      $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_EXCLUSAO_DOCUMENTO);
      $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);

      $objAtividadeRN = new AtividadeRN();
      $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);


      $objDocumentoDTOEscolha = new DocumentoDTO();
      $objDocumentoDTOEscolha->setNumIdUnidadeGeradoraProtocolo(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objDocumentoDTOEscolha->setNumIdSerie($objDocumentoDTO->getNumIdSerie());

      if ($this->contarRN0007($objDocumentoDTOEscolha)==0){
        $objSerieEscolhaDTO = new SerieEscolhaDTO();
        $objSerieEscolhaDTO->setNumIdSerie($objDocumentoDTO->getNumIdSerie());
        $objSerieEscolhaDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
         
        $objSerieEscolhaRN = new SerieEscolhaRN();
        if ($objSerieEscolhaRN->contar($objSerieEscolhaDTO)==1){
          $objSerieEscolhaRN->excluir(array($objSerieEscolhaDTO));
        }
      }

      //Auditoria

    }catch(Exception $e){
      throw new InfraException('Erro excluindo Documento.',$e);
    }
  }

  protected function darCienciaControlado(DocumentoDTO $parObjDocumentoDTO){
    try {

      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_ciencia',__METHOD__,$parObjDocumentoDTO);


      //Regras de Negocio
      $objInfraException = new InfraException();

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrStaEditor();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retStrSinBloqueado();
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
      $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

      if ($objDocumentoDTO==null){
        $objInfraException->lancarValidacao('Documento não encontrado.');
      }

      $objInfraException->lancarValidacoes();

      
      $numVersaoCiencia = null;
      if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
        if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_INTERNO){
          $objEditorRN = new EditorRN();
          $numVersaoCiencia = $objEditorRN->obterNumeroUltimaVersao($objDocumentoDTO);
        }else if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_EDOC){
          $numVersaoCiencia = 0;
        }else{
          $numVersaoCiencia = 0;
        }
      }else{
        $objAnexoDTO = new AnexoDTO();
        $objAnexoDTO->retNumIdAnexo();
        $objAnexoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());
        
        $objAnexoRN = new AnexoRN();
        $objAnexoDTO = $objAnexoRN->consultarRN0736($objAnexoDTO);
        
        if ($objAnexoDTO!=null){
          $numVersaoCiencia = $objAnexoDTO->getNumIdAnexo();
        }else{
          $objInfraException->lancarValidacao('Documento não possui conteúdo para ciência.');
        }
      }

      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->retNumIdAtividade();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getDblIdDocumento());
      $objAtributoAndamentoDTO->setNumIdUsuarioOrigemAtividade(SessaoSEI::getInstance()->getNumIdUsuario());
      $objAtributoAndamentoDTO->setDblIdProtocoloAtividade($objDocumentoDTO->getDblIdProcedimento());
      $objAtributoAndamentoDTO->setNumIdTarefaAtividade(TarefaRN::$TI_DOCUMENTO_CIENCIA);

      $objAtributoAndamentoRN = new AtributoAndamentoRN();
      $arrObjAtributoAndamentoDTO = $objAtributoAndamentoRN->listarRN1367($objAtributoAndamentoDTO);
      
      if (count($arrObjAtributoAndamentoDTO)){
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('VERSAO_CIENCIA');
        $objAtributoAndamentoDTO->setStrValor($numVersaoCiencia);
        $objAtributoAndamentoDTO->setNumIdAtividade(InfraArray::converterArrInfraDTO($arrObjAtributoAndamentoDTO,'IdAtividade'),InfraDTO::$OPER_IN);
        
        if ($objAtributoAndamentoRN->contarRN1368($objAtributoAndamentoDTO)){
          $objInfraException->lancarValidacao('Usuário já deu ciência neste documento.');
        }
      }
      
      $arrObjAtributoAndamentoDTO = array();
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrValor($objDocumentoDTO->getStrProtocoloDocumentoFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getDblIdDocumento());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('VERSAO_CIENCIA');
      $objAtributoAndamentoDTO->setStrValor($numVersaoCiencia);
      $objAtributoAndamentoDTO->setStrIdOrigem(null);
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      
      $objAtividadeDTO = new AtividadeDTO();
      $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
      $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_DOCUMENTO_CIENCIA);
      $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);

      $objAtividadeRN = new AtividadeRN();
      $ret = $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);


      $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
      $objRelProtocoloProtocoloDTO->retDblIdRelProtocoloProtocolo();
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo1($objDocumentoDTO->getDblIdProcedimento());
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objDocumentoDTO->getDblIdDocumento());
      $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_DOCUMENTO_ASSOCIADO);

      $objRelProtocoloProtocoloRN = new RelProtocoloProtocoloRN();
      $objRelProtocoloProtocoloDTO = $objRelProtocoloProtocoloRN->consultarRN0841($objRelProtocoloProtocoloDTO);
      
      $objRelProtocoloProtocoloDTO->setStrSinCiencia('S');
      $objRelProtocoloProtocoloRN->alterar($objRelProtocoloProtocoloDTO);

      $objProcedimentoDTOBanco = new ProcedimentoDTO();
      $objProcedimentoDTOBanco->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());
      
      $objProcedimentoRN = new ProcedimentoRN();
      $objProcedimentoRN->marcarCiencia($objProcedimentoDTOBanco);      
      
      $this->bloquearProcessado($objDocumentoDTO);
      
      return $ret;

    }catch(Exception $e){
      throw new InfraException('Erro dando ciência no documento.',$e);
    }
  }

  protected function consultarRN0005Conectado(DocumentoDTO $objDocumentoDTO){
    try {

      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_consultar',__METHOD__,$objDocumentoDTO);

      //Regras de Negocio
      //$objInfraException = new InfraException();

      //$objInfraException->lancarValidacoes();

      if ($objDocumentoDTO->isRetStrIdentificacao()){
        $objDocumentoDTO->retStrNomeSerie();
        $objDocumentoDTO->retStrNumero();
      }

      if ($objDocumentoDTO->isRetObjPublicacaoDTO() || $objDocumentoDTO->isRetArrObjAssinaturaDTO()){
        $objDocumentoDTO->retDblIdDocumento();
        $objDocumentoDTO->retStrStaProtocoloProtocolo();
      }

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $ret = $objDocumentoBD->consultar($objDocumentoDTO);

      if ($ret !== null){

        if ($objDocumentoDTO->isRetObjPublicacaoDTO()){
          if ($ret->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
            $objPublicacaoDTO = new PublicacaoDTO();
            $objPublicacaoDTO->retTodos(true);
            $objPublicacaoDTO->setDblIdDocumento($ret->getDblIdDocumento());

            $objPublicacaoRN = new PublicacaoRN();
            $objPublicacaoDTO = $objPublicacaoRN->consultarRN1044($objPublicacaoDTO);

            $ret->setObjPublicacaoDTO($objPublicacaoDTO);
          }
        }

        if ($objDocumentoDTO->isRetArrObjAssinaturaDTO()){
          //if ($ret->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
            $objAssinaturaDTO = new AssinaturaDTO();
            $objAssinaturaDTO->retTodos();
            $objAssinaturaDTO->setDblIdDocumento($ret->getDblIdDocumento());

            $objAssinaturaRN = new AssinaturaRN();
            $ret->setArrObjAssinaturaDTO($objAssinaturaRN->listarRN1323($objAssinaturaDTO));
          //}
        }

        if ($objDocumentoDTO->isRetStrIdentificacao()){
          $this->montarIdentificacaoRN1151(array($ret));
        }
      }

      //Auditoria

      return $ret;
    }catch(Exception $e){
      throw new InfraException('Erro consultando Documento.',$e);
    }
  }

  protected function listarRN0008Conectado(DocumentoDTO $parObjDocumentoDTO) {
    try {

      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_listar',__METHOD__,$parObjDocumentoDTO);

      //Regras de Negocio
      //$objInfraException = new InfraException();

      //$objInfraException->lancarValidacoes();

      if ($parObjDocumentoDTO->isRetStrIdentificacao()){
        $parObjDocumentoDTO->retStrNomeSerie();
        $parObjDocumentoDTO->retStrNumero();
      }

      if ($parObjDocumentoDTO->isRetObjPublicacaoDTO() || $parObjDocumentoDTO->isRetArrObjAssinaturaDTO()){
        $parObjDocumentoDTO->retDblIdDocumento();
        $parObjDocumentoDTO->retStrStaProtocoloProtocolo();
      }

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $arrObjDocumentoDTO = $objDocumentoBD->listar($parObjDocumentoDTO);

      if (count($arrObjDocumentoDTO)){
        if ($parObjDocumentoDTO->isRetObjPublicacaoDTO() || $parObjDocumentoDTO->isRetArrObjAssinaturaDTO()){
  
          $arrIdDocumentosGerados = array();
          foreach($arrObjDocumentoDTO as $objDocumentoDTO){
            if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
              $arrIdDocumentosGerados[] = $objDocumentoDTO->getDblIdDocumento();
            }
          }
  
          if (count($arrIdDocumentosGerados)>0){
            
            if ($parObjDocumentoDTO->isRetObjPublicacaoDTO()){
  
              $objPublicacaoDTO = new PublicacaoDTO();
              $objPublicacaoDTO->retTodos(true);
              $objPublicacaoDTO->setDblIdDocumento($arrIdDocumentosGerados, InfraDTO::$OPER_IN);
  
              $objPublicacaoRN = new PublicacaoRN();
              $arrObjPublicacaoDTO = InfraArray::indexarArrInfraDTO($objPublicacaoRN->listarRN1045($objPublicacaoDTO),'IdDocumento');
  
              foreach($arrObjDocumentoDTO as $objDocumentoDTO){
                if (isset($arrObjPublicacaoDTO[$objDocumentoDTO->getDblIdDocumento()])){
                  $objDocumentoDTO->setObjPublicacaoDTO($arrObjPublicacaoDTO[$objDocumentoDTO->getDblIdDocumento()]);
                }else{
                  $objDocumentoDTO->setObjPublicacaoDTO(null);
                }
              }
            }
          }

          if ($parObjDocumentoDTO->isRetArrObjAssinaturaDTO()){
            $objAssinaturaDTO = new AssinaturaDTO();
            $objAssinaturaDTO->retTodos();
            $objAssinaturaDTO->setDblIdDocumento(InfraArray::converterArrInfraDTO($arrObjDocumentoDTO,'IdDocumento'), InfraDTO::$OPER_IN);
          
            $objAssinaturaRN = new AssinaturaRN();
            $arrObjAssinaturaDTO = $objAssinaturaRN->listarRN1323($objAssinaturaDTO);
          
            foreach($arrObjDocumentoDTO as $objDocumentoDTO){
              $arrTemp = array();
              foreach($arrObjAssinaturaDTO as $objAssinaturaDTO){
                if ($objDocumentoDTO->getDblIdDocumento()==$objAssinaturaDTO->getDblIdDocumento()){
                  $arrTemp[] = $objAssinaturaDTO;
                }
              }
              $objDocumentoDTO->setArrObjAssinaturaDTO($arrTemp);
            }
          }
        }
  
        if ($parObjDocumentoDTO->isRetStrIdentificacao()){
          $this->montarIdentificacaoRN1151($arrObjDocumentoDTO);
        }
      }
      //Auditoria

      return $arrObjDocumentoDTO;

    }catch(Exception $e){
      throw new InfraException('Erro listando Documentos.',$e);
    }
  }

  protected function contarRN0007Conectado(DocumentoDTO $objDocumentoDTO){
    try {

      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_listar',__METHOD__,$objDocumentoDTO);

      //Regras de Negocio
      //$objInfraException = new InfraException();

      //$objInfraException->lancarValidacoes();

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $ret = $objDocumentoBD->contar($objDocumentoDTO);

      //Auditoria

      return $ret;
    }catch(Exception $e){
      throw new InfraException('Erro contando Documentos.',$e);
    }
  }
  
  private function validarStrStaEditor(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
    if (InfraString::isBolVazia($objDocumentoDTO->getStrStaEditor())){
      $objInfraException->adicionarValidacao('Editor não informado.');
    }
        
    if ($objDocumentoDTO->getStrStaEditor()!=EditorRN::$TE_EDOC && $objDocumentoDTO->getStrStaEditor()!=EditorRN::$TE_INTERNO && $objDocumentoDTO->getStrStaEditor()!=EditorRN::$TE_NENHUM){
      $objInfraException->adicionarValidacao('Editor ['.$objDocumentoDTO->getStrStaEditor().'] inválido.');
    }
  }
  
  private function validarStrSinFormulario(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
    if (InfraString::isBolVazia($objDocumentoDTO->getStrSinFormulario())){
      $objInfraException->adicionarValidacao('Sinalizador de Formulário não informado.');
    }else{
      if (!InfraUtil::isBolSinalizadorValido($objDocumentoDTO->getStrSinFormulario())){
        $objInfraException->adicionarValidacao('Sinalizador de Formulário inválido.');
      }
    }
  }
  
  private function validarNumIdUnidadeResponsavelRN0915(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
    if (InfraString::isBolVazia($objDocumentoDTO->getNumIdUnidadeResponsavel ())){
      $objInfraException->adicionarValidacao('Unidade Responsável não informada.');
    }
  }

  private function validarStrCrcAssinatura(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
    if (InfraString::isBolVazia($objDocumentoDTO->getStrCrcAssinatura())){
      $objDocumentoDTO->setStrCrcAssinatura(null);
    }else{
      $objDocumentoDTO->setStrCrcAssinatura(strtoupper(trim($objDocumentoDTO->getStrCrcAssinatura())));
      if (strlen($objDocumentoDTO->getStrCrcAssinatura())>8){
        $objInfraException->lancarValidacao('Tamanho do código CRC inválido.');
      }
    }
  }

  private function validarStrCodigoVerificador(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
    if (InfraString::isBolVazia($objDocumentoDTO->getStrCodigoVerificador())){
      $objDocumentoDTO->setStrCodigoVerificador(null);
    }else{
      $objDocumentoDTO->setStrCodigoVerificador(strtoupper(trim($objDocumentoDTO->getStrCodigoVerificador())));
      if (!preg_match("/^[0-9]{10}(V)[0-9]+$/i", $objDocumentoDTO->getStrCodigoVerificador()) && strlen($objDocumentoDTO->getStrCodigoVerificador())!=7){         
        $objInfraException->lancarValidacao('Código Verificador inválido.');
      }
    }
  }
  
  private function prepararCodigoVerificador($strCodigoVerificador){    
    if (strpos($strCodigoVerificador,'v') !== false){
      $arrCodigoVerificador = explode('v',$strCodigoVerificador);
      $strCodigoVerificador = $arrCodigoVerificador[0];
    }else if (strpos($strCodigoVerificador,'V') !== false){
      $arrCodigoVerificador = explode('V',$strCodigoVerificador);
      $strCodigoVerificador = $arrCodigoVerificador[0];
    }    
    return $strCodigoVerificador;
  }

  private function validarNumIdSerieRN0009(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
     
    if (InfraString::isBolVazia($objDocumentoDTO->getNumIdSerie())){
      $objInfraException->lancarValidacao('Tipo do documento não informado.');
    }else{

    	$objSerieDTO = new SerieDTO();
    	$objSerieDTO->setBolExclusaoLogica(false);
    	$objSerieDTO->retStrStaAplicabilidade();
    	$objSerieDTO->retStrNome();
    	$objSerieDTO->setNumIdSerie($objDocumentoDTO->getNumIdSerie());
    	
    	$objSerieRN = new SerieRN();
    	$objSerieDTO = $objSerieRN->consultarRN0644($objSerieDTO);

      if ($objSerieDTO==null){
        throw new InfraException('Tipo do documento ['.$objDocumentoDTO->getNumIdSerie().'] não encontrado.');
      }

    	if ($objSerieDTO->getStrStaAplicabilidade()!=SerieRN::$TA_TODOS){
    		if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO && $objSerieDTO->getStrStaAplicabilidade()==SerieRN::$TA_EXTERNO){
    			$objInfraException->adicionarValidacao('Tipo do documento não aplicável para documentos internos.');
    		}else if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO && $objSerieDTO->getStrStaAplicabilidade()==SerieRN::$TA_INTERNO){
    			$objInfraException->adicionarValidacao('Tipo do documento não aplicável para documentos externos.');
    		}
    	}
    }
  }

  private function validarTamanhoNumeroRN0993(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
    $objDocumentoDTO->setStrNumero(trim($objDocumentoDTO->getStrNumero()));
    if (strlen($objDocumentoDTO->getStrNumero())>50){
      $objInfraException->adicionarValidacao('Número possui tamanho superior a 50 caracteres.');
    }
  }

  private function validarStrConteudo(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
    if (InfraString::isBolVazia($objDocumentoDTO->getStrConteudo())){
      $objDocumentoDTO->setStrConteudo(null);
    }
  }

  private function validarNumIdTipoConferencia(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){
    if (InfraString::isBolVazia($objDocumentoDTO->getNumIdTipoConferencia())){
      $objDocumentoDTO->setNumIdTipoConferencia(null);
    }
  }
  
  protected function prepararCloneRN1110Conectado(DocumentoDTO $objDocumentoDTO){
    try{
      
      //Recuperar os dados do documento para clonagem
      $objDocumentoCloneDTO = new DocumentoDTO();
      $objDocumentoCloneDTO->retNumIdUnidadeResponsavel();
      $objDocumentoCloneDTO->retDblIdDocumentoEdoc();
      $objDocumentoCloneDTO->retNumIdSerie();
      $objDocumentoCloneDTO->retNumIdTipoConferencia();
      $objDocumentoCloneDTO->retStrNumero();
      $objDocumentoCloneDTO->retStrDescricaoProtocolo();
      $objDocumentoCloneDTO->retStrConteudo();
      $objDocumentoCloneDTO->retStrStaProtocoloProtocolo();
      $objDocumentoCloneDTO->retDtaGeracaoProtocolo();
      $objDocumentoCloneDTO->retStrStaEditor();
      $objDocumentoCloneDTO->retStrSinFormulario();
      $objDocumentoCloneDTO->retStrStaNivelAcessoLocalProtocolo();
      $objDocumentoCloneDTO->retNumIdHipoteseLegalProtocolo();


      $objDocumentoCloneDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
      $objDocumentoCloneDTO = $this->consultarRN0005($objDocumentoCloneDTO);


      $objDocumentoCloneDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());
      $objDocumentoCloneDTO->setNumVersaoLock(0);


      $objDocumentoCloneDTO->setNumIdUnidadeResponsavel(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      
      if ($objDocumentoCloneDTO->getStrStaProtocoloProtocolo() == ProtocoloRN::$TP_DOCUMENTO_GERADO){
        
        $objSerieDTO = new SerieDTO();
        $objSerieDTO->setBolExclusaoLogica(false);
        $objSerieDTO->retStrStaNumeracao();
        $objSerieDTO->setNumIdSerie($objDocumentoCloneDTO->getNumIdSerie());
        
        $objSerieRN = new SerieRN();
        $objSerieDTO = $objSerieRN->consultarRN0644($objSerieDTO);
        
        if ($objSerieDTO->getStrStaNumeracao()==SerieRN::$TN_SEQUENCIAL_ANUAL_ORGAO ||
            $objSerieDTO->getStrStaNumeracao()==SerieRN::$TN_SEQUENCIAL_ANUAL_UNIDADE ||
            $objSerieDTO->getStrStaNumeracao()==SerieRN::$TN_SEQUENCIAL_ORGAO ||
            $objSerieDTO->getStrStaNumeracao()==SerieRN::$TN_SEQUENCIAL_UNIDADE){
          $objDocumentoCloneDTO->setStrNumero(null);
        }
      }
      
      
      $objDocumentoCloneDTO->setDblIdDocumentoEdocBase(null);
      $objDocumentoCloneDTO->setDblIdDocumentoBase(null);
      
      //usa o documento original como base
      if ($objDocumentoCloneDTO->getStrStaProtocoloProtocolo() == ProtocoloRN::$TP_DOCUMENTO_GERADO){
        if ($objDocumentoCloneDTO->getStrStaEditor()==EditorRN::$TE_EDOC){
          $objDocumentoCloneDTO->setDblIdDocumentoEdocBase($objDocumentoCloneDTO->getDblIdDocumentoEdoc());
        }else if ($objDocumentoCloneDTO->getStrStaEditor()==EditorRN::$TE_INTERNO){
          $objDocumentoCloneDTO->setDblIdDocumentoBase($objDocumentoDTO->getDblIdDocumento());
        }
      }else{
        $objDocumentoCloneDTO->setDblIdDocumentoEdoc(null);
      }
      
      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->setDtaGeracao(InfraData::getStrDataAtual());
      $objProtocoloDTO->setStrDescricao($objDocumentoCloneDTO->getStrDescricaoProtocolo());
      $objProtocoloDTO->setStrStaNivelAcessoLocal($objDocumentoCloneDTO->getStrStaNivelAcessoLocalProtocolo());
      $objProtocoloDTO->setNumIdHipoteseLegal($objDocumentoCloneDTO->getNumIdHipoteseLegalProtocolo());


      //Recuperar em ArrAssuntos os assuntos
      $objRelProtocoloAssuntoDTO = new RelProtocoloAssuntoDTO();
      $objRelProtocoloAssuntoDTO->retNumIdAssunto();
      $objRelProtocoloAssuntoDTO->retNumSequencia();
      $objRelProtocoloAssuntoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

      $objRelProtocoloAssuntoRN = new RelProtocoloAssuntoRN();
      $arrAssuntos = $objRelProtocoloAssuntoRN->listarRN0188($objRelProtocoloAssuntoDTO);
      $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO($arrAssuntos);

      //Recuperar em ArrParticipantes os participantes
      $objPartipantesDTO = new ParticipanteDTO();
      $objPartipantesDTO->retNumIdContato();
      $objPartipantesDTO->retStrStaParticipacao();
      $objPartipantesDTO->retNumSequencia();
      $objPartipantesDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

      $objPartipantesRN = new ParticipanteRN();
      $arrParticipantes = $objPartipantesRN->listarRN0189($objPartipantesDTO);
      $objProtocoloDTO->setArrObjParticipanteDTO($arrParticipantes);

      //Recuperar em ArrDominios os domínios do documento

      $objRelProtocoloAtributoDTO = new RelProtocoloAtributoDTO();
      $objRelProtocoloAtributoDTO->retNumIdAtributo();
      $objRelProtocoloAtributoDTO->retStrValor();

      $objRelProtocoloAtributoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

      $objRelProtocoloAtributoRN = new RelProtocoloAtributoRN();
      $arrAtributos = $objRelProtocoloAtributoRN->listar($objRelProtocoloAtributoDTO);

      $objProtocoloDTO->setArrObjRelProtocoloAtributoDTO($arrAtributos);

      //Recuperar em ArrObservacoes as observacoes desta unidade
      $objObservacaoDTO = new ObservacaoDTO();
      $objObservacaoDTO->retStrDescricao();

      $objObservacaoDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objObservacaoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

      $objObservacaoRN = new ObservacaoRN();
      $arrObservacoes = $objObservacaoRN->listarRN0219($objObservacaoDTO);

      $objProtocoloDTO->setArrObjObservacaoDTO($arrObservacoes);

      $objAnexoDTO = new AnexoDTO();
      $objAnexoDTO->retNumIdAnexo();
      $objAnexoDTO->retStrNome();
      $objAnexoDTO->retNumTamanho();
      $objAnexoDTO->retDthInclusao();
      $objAnexoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

      $objAnexoRN = new AnexoRN();
      $arrObjAnexoDTO = $objAnexoRN->listarRN0218($objAnexoDTO);
      
      foreach($arrObjAnexoDTO as $objAnexoDTO){

        $strNomeUpload = $objAnexoRN->gerarNomeArquivoTemporario();

        $strNomeUploadCompleto = DIR_SEI_TEMP.'/'.$strNomeUpload;
        copy($objAnexoRN->obterLocalizacao($objAnexoDTO), $strNomeUploadCompleto);

        $objAnexoDTO->setNumIdAnexo($strNomeUpload);
        $objAnexoDTO->setDthInclusao(InfraData::getStrDataHoraAtual());
        $objAnexoDTO->setStrSinDuplicando('S');
      }

      $objProtocoloDTO->setArrObjAnexoDTO($arrObjAnexoDTO);

      $objDocumentoCloneDTO->setObjProtocoloDTO($objProtocoloDTO);

      $objDocumentoCloneDTO->setDblIdDocumento(null);
      
      return $objDocumentoCloneDTO;

    }catch(Exception $e){
      throw new InfraException('Erro preparando clone do documento.',$e);
    }
  }

  protected function agruparRN1116Controlado(ProtocoloDTO $objProtocoloRecebidoDTO) {
    try{

      //Regras de Negocio
      //$objInfraException = new InfraException();

      //Obter dados da publicação através da Publicacao
      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->setDblIdProtocolo($objProtocoloRecebidoDTO->getDblIdProtocolo());
      $objProtocoloDTO->setDblIdProtocoloAgrupador($objProtocoloRecebidoDTO->getDblIdProtocoloAgrupador());

      $objProtocoloBD = new ProtocoloBD($this->getObjInfraIBanco());
      $objProtocoloBD->alterar($objProtocoloDTO);


    }catch(Exception $e){
      throw new InfraException('Erro agrupando Protocolo.',$e);
    }
  }

  protected function montarIdentificacaoRN1151Conectado($arrObjInfraDTO){
    try{
      foreach($arrObjInfraDTO as $objInfraDTO){
        if ($objInfraDTO instanceof DocumentoDTO){
          $objInfraDTO->setStrIdentificacao($objInfraDTO->getStrNomeSerie().' '.$objInfraDTO->getStrNumero());
        }else if ($objInfraDTO->getStrStaProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO || $objInfraDTO->getStrStaProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO){
          $objInfraDTO->setStrIdentificacao($objInfraDTO->getStrNomeSerieDocumento().' '.$objInfraDTO->getStrNumeroDocumento());
        }else{
          continue;
        }
      }
    }catch(Exception $e){
      throw new InfraException('Erro montando identificação de documento.',$e);
    }
  }

  private function tratarProtocoloRN1164(DocumentoDTO $objDocumentoDTO) {
    try{

      //$objInfraException = new InfraException();

      $objProtocoloDTO = $objDocumentoDTO->getObjProtocoloDTO();

      $objProtocoloDTO->setStrProtocoloFormatado(null);
      
      $objProtocoloDTO->setStrStaProtocolo($objDocumentoDTO->getStrStaProtocoloProtocolo());

      if (!$objProtocoloDTO->isSetNumIdUnidadeGeradora()){
        $objProtocoloDTO->setNumIdUnidadeGeradora(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      }

      if (!$objProtocoloDTO->isSetNumIdUsuarioGerador()){
        $objProtocoloDTO->setNumIdUsuarioGerador(SessaoSEI::getInstance()->getNumIdUsuario());
      }

      if (!$objProtocoloDTO->isSetDtaGeracao()){
        $objProtocoloDTO->setDtaGeracao(InfraData::getStrDataAtual());
      }

      if (!$objProtocoloDTO->isSetArrObjRelProtocoloAssuntoDTO()){
        $objProtocoloDTO->setArrObjRelProtocoloAssuntoDTO(array());
      }

      $objDocumentoDTO->setObjProtocoloDTO($objProtocoloDTO);

    }catch(Exception $e){
      throw new InfraException('Erro tratando protocolo do documento.',$e);
    }
  }

  protected function gerarPublicacaoRelacionadaRN1207Controlado(DocumentoDTO $parObjDocumentoDTO){
    try {

      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('publicacao_gerar_relacionada',__METHOD__,$parObjDocumentoDTO);

      //Regras de Negocio
      $objInfraException = new InfraException();

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retObjPublicacaoDTO();
      $objDocumentoDTO->retDtaGeracaoProtocolo();
      $objDocumentoDTO->retStrNumero();
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

      $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

      $objPublicacaoDTO = $objDocumentoDTO->getObjPublicacaoDTO();

      if ($objPublicacaoDTO==null){
        $objInfraException->lancarValidacao('Documento não foi publicado.');
      }

      if ($objPublicacaoDTO->getStrStaEstado()==PublicacaoRN::$TE_AGENDADO){
        $objInfraException->lancarValidacao('Documento ainda não foi publicado.');
      }

      //Clonar o documento
      $objDocumentoClonarDTO = new DocumentoDTO();
      $objDocumentoClonarDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
      $objDocumentoClonarDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());
      $objDocumentoClonarDTO = $this->prepararCloneRN1110($objDocumentoClonarDTO);
      
      if ($objDocumentoDTO->getStrNumero()!=null && $objDocumentoClonarDTO->getStrNumero()==null){
        $objDocumentoClonarDTO->setStrNumero($objDocumentoDTO->getStrNumero());
      }
      
      $objDocumentoClonarDTO->getObjProtocoloDTO()->setDtaGeracao($objDocumentoDTO->getDtaGeracaoProtocolo());
      
      $ret = $this->gerarRN0003($objDocumentoClonarDTO);

      //Recuperar o protocolo agrupador
      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->retDblIdProtocoloAgrupador();
      $objProtocoloDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());

      $objProtocoloRN = new ProtocoloRN();
      $objProtocoloDTO = $objProtocoloRN->consultarRN0186($objProtocoloDTO);

      // Agrupar os protocolos
      $dto = new ProtocoloDTO();
      $dto->setDblIdProtocolo($ret->getDblIdDocumento());
      $dto->setDblIdProtocoloAgrupador($objProtocoloDTO->getDblIdProtocoloAgrupador());
      $this->agruparRN1116($dto);

      return $ret;

    }catch(Exception $e){
      throw new InfraException('Erro gerando publicação relacionada.',$e);
    }
  }

  public function atualizarConteudoRN1205(DocumentoDTO $objDocumentoDTO){

    $this->atualizarConteudoRN1205Interno($objDocumentoDTO);

    if ($objDocumentoDTO->isSetDblIdDocumento()){
      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());
      $objIndexacaoDTO = new IndexacaoDTO();
      $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));
      $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_ALTERACAO_PROTOCOLO_CONTEUDO);

      $objIndexacaoRN = new IndexacaoRN();
      $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);
    }
  }
  
  protected function configurarEstilosControlado(DocumentoDTO $parObjDocumentoDTO){
    try {
      
      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
      $objDocumentoDTO->setNumIdConjuntoEstilos($parObjDocumentoDTO->getNumIdConjuntoEstilos());
         
      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->alterar($objDocumentoDTO);
            
      //Auditoria 

    }catch(Exception $e){
      throw new InfraException('Erro configurando estilos do documento.',$e);
    }
  }

  protected function bloquearConteudoControlado(DocumentoDTO $parObjDocumentoDTO){
    try {

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
      $objDocumentoDTO->setStrSinBloqueado('S');

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->alterar($objDocumentoDTO);

    }catch(Exception $e){
      throw new InfraException('Erro bloqueando documento.',$e);
    }
  }

  protected function bloquearConsultadoConectado(DocumentoDTO $parObjDocumentoDTO){
    try {

      $bolBloquear = false;

  		if ($parObjDocumentoDTO->getStrSinBloqueado()=='N' && SessaoSEI::getInstance()->getNumIdUnidadeAtual()!=$parObjDocumentoDTO->getNumIdUnidadeGeradoraProtocolo()){

        if ($parObjDocumentoDTO->getStrStaProtocoloProtocolo() == ProtocoloRN::$TP_DOCUMENTO_GERADO) {

          if ($parObjDocumentoDTO->getStrStaEditor()==EditorRN::$TE_NENHUM){

            //formulários
            $bolBloquear = true;

          }else{
            $objAssinaturaDTO = new AssinaturaDTO();
            $objAssinaturaDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

            $objAssinaturaRN = new AssinaturaRN();

            if ($objAssinaturaRN->contarRN1324($objAssinaturaDTO)) {

              $objRelBlocoUnidadeDTO = new RelBlocoUnidadeDTO();
              $objRelBlocoUnidadeDTO->retNumIdBloco();
              $objRelBlocoUnidadeDTO->setStrStaTipoBloco(BlocoRN::$TB_ASSINATURA);
              $objRelBlocoUnidadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
              $objRelBlocoUnidadeDTO->setStrSinRetornado('N');
              $objRelBlocoUnidadeDTO->setStrStaEstadoBloco(BlocoRN::$TE_DISPONIBILIZADO);

              $objRelBlocoUnidadeRN = new RelBlocoUnidadeRN();
              $arrObjRelBlocoUnidadeDTO = $objRelBlocoUnidadeRN->listarRN1304($objRelBlocoUnidadeDTO);

              //se tem blocos de assinatura disponibilizados
              if (count($arrObjRelBlocoUnidadeDTO)) {

                //se o documento consta como disponibilizado para assinatura
                $objRelBlocoProtocoloDTO = new RelBlocoProtocoloDTO();
                $objRelBlocoProtocoloDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());
                $objRelBlocoProtocoloDTO->setNumIdBloco(InfraArray::converterArrInfraDTO($arrObjRelBlocoUnidadeDTO, 'IdBloco'), InfraDTO::$OPER_IN);

                $objRelBlocoProtocoloRN = new RelBlocoProtocoloRN();
                if ($objRelBlocoProtocoloRN->contarRN1292($objRelBlocoProtocoloDTO)) {
                  //a unidade que possui o documento disponibilizado nao deve bloquear mesmo nao sendo a geradora
                  return;
                }
              }

              //gerado e assinado
              $bolBloquear = true;
            }
          }
        }else if ($parObjDocumentoDTO->getStrStaProtocoloProtocolo() == ProtocoloRN::$TP_DOCUMENTO_RECEBIDO) {

          $objAnexoDTO = new AnexoDTO();
          $objAnexoDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());

          $objAnexoRN = new AnexoRN();
          if ($objAnexoRN->contarRN0734($objAnexoDTO)) {

            //externo com conteúdo
            $bolBloquear = true;
          }
        }

        if ($bolBloquear) {
          $this->bloquearConteudo($parObjDocumentoDTO);
        }
 		  }
      //Auditoria 

    }catch(Exception $e){
      throw new InfraException('Erro bloqueando documento por consulta.',$e);
    }
  }

  protected function bloquearProcessadoConectado(DocumentoDTO $parObjDocumentoDTO){
    try {

      $bolBloquear = false;

      if ($parObjDocumentoDTO->getStrSinBloqueado()=='N') {

        if ($parObjDocumentoDTO->getStrStaProtocoloProtocolo() == ProtocoloRN::$TP_DOCUMENTO_GERADO) {

          if ($parObjDocumentoDTO->getStrStaEditor() == EditorRN::$TE_NENHUM) {

            //formulários
            $bolBloquear = true;

          } else {
            $objAssinaturaDTO = new AssinaturaDTO();
            $objAssinaturaDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

            $objAssinaturaRN = new AssinaturaRN();
            if ($objAssinaturaRN->contarRN1324($objAssinaturaDTO)) {

              //gerado com assinatura
              $bolBloquear = true;
            }
          }
        } else if ($parObjDocumentoDTO->getStrStaProtocoloProtocolo() == ProtocoloRN::$TP_DOCUMENTO_RECEBIDO) {

          $objAnexoDTO = new AnexoDTO();
          $objAnexoDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());

          $objAnexoRN = new AnexoRN();
          if ($objAnexoRN->contarRN0734($objAnexoDTO)) {

            //externo com conteúdo
            $bolBloquear = true;
          }
        }

        if ($bolBloquear) {
          $this->bloquearConteudo($parObjDocumentoDTO);
        }
      }
        //Auditoria

    }catch(Exception $e){
      throw new InfraException('Erro bloqueando documento por processamento.',$e);
    }
  }

  protected function bloquearTramitacaoConclusaoConectado(ProcedimentoDTO $objProcedimentoDTO){
    try {

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retStrSinBloqueado();
      $objDocumentoDTO->retStrStaEditor();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->setNumIdUnidadeGeradoraProtocolo(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objDocumentoDTO->setDblIdProcedimento($objProcedimentoDTO->getDblIdProcedimento());
      $objDocumentoDTO->setStrSinBloqueado('N');

      $arrObjDocumentoDTO = $this->listarRN0008($objDocumentoDTO);

      foreach($arrObjDocumentoDTO as $objDocumentoDTO){
        $this->bloquearProcessado($objDocumentoDTO);
      }
      
      //Auditoria 

    }catch(Exception $e){
      throw new InfraException('Erro bloqueando documento por tramitação ou conclusão do processo.',$e);
    }
  }

  protected function bloquearPublicadoConectado(DocumentoDTO $parObjDocumentoDTO){
    try {

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retStrSinBloqueado();
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
      $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

      if ($objDocumentoDTO->getStrSinBloqueado()=='N'){
        $this->bloquearConteudo($parObjDocumentoDTO);
      }

      //Auditoria

    }catch(Exception $e){
      throw new InfraException('Erro bloqueando documento por publicação.',$e);
    }
  }

  protected function atualizarConteudoRN1205InternoControlado(DocumentoDTO $parObjDocumentoDTO){
    try {

      global $SEI_MODULOS;

      //Regras de Negocio
      $objInfraException = new InfraException();

      //Edoc
      if ($parObjDocumentoDTO->isSetDblIdDocumentoEdoc()){

        //Texto padrão
        $objTextoPadraoDTO = new TextoPadraoDTO();
        $objTextoPadraoDTO->retDblIdTextoPadraoEdoc();
        $objTextoPadraoDTO->setDblIdDocumentoEdoc($parObjDocumentoDTO->getDblIdDocumentoEdoc());
         
        $objTextoPadraoRN = new TextoPadraoRN();
         
        //Descarta documentos que são texto padrão
        $objTextoPadraoDTO = $objTextoPadraoRN->consultarRN1083($objTextoPadraoDTO);
         
        if ($objTextoPadraoDTO!=null){

          //atualiza conteudo do texto padrão
          $strTexto = DocumentoINT::limparHtml($parObjDocumentoDTO->getStrConteudo());

          $posTextoPadrao = strpos($strTexto,'Texto Padrão');

          if ($posTextoPadrao!==false){
            $strTexto = substr($strTexto,$posTextoPadrao+strlen('Texto Padrão'));
          }

          $objTextoPadraoDTO->setStrConteudo($strTexto);

          $objTextoPadraoRN->alterarRN1081($objTextoPadraoDTO);
          
          return;
        }

        //base de conhecimento
        $objBaseConhecimentoDTO = new BaseConhecimentoDTO();
        $objBaseConhecimentoDTO->retNumIdBaseConhecimento();
        $objBaseConhecimentoDTO->setDblIdDocumentoEdoc($parObjDocumentoDTO->getDblIdDocumentoEdoc());
         
        $objBaseConhecimentoRN = new BaseConhecimentoRN();
        $objBaseConhecimentoDTO = $objBaseConhecimentoRN->consultar($objBaseConhecimentoDTO);
         
        if($objBaseConhecimentoDTO!=null){
          $objBaseConhecimentoDTO->setStrConteudo($parObjDocumentoDTO->getStrConteudo());
          $objBaseConhecimentoRN->alterar($objBaseConhecimentoDTO);
          return;
        }
         
        //documento
        $objDocumentoDTO = new DocumentoDTO();
        $objDocumentoDTO->retDblIdDocumento();
        $objDocumentoDTO->setDblIdDocumentoEdoc($parObjDocumentoDTO->getDblIdDocumentoEdoc());
         
        $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);
         
        if ($objDocumentoDTO == null){
          $objInfraException->lancarValidacao('Documento do SEI não encontrado para o documento '.$parObjDocumentoDTO->getDblIdDocumentoEdoc().'.');
        }
        
        $parObjDocumentoDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
      }

      $this->validarDocumentoPublicadoRN1211($parObjDocumentoDTO);
      
      $this->cancelarAssinatura($parObjDocumentoDTO);

      if (ConfiguracaoSEI::getInstance()->isSetValor('SEI','Modulos')){
        foreach(array_keys(ConfiguracaoSEI::getInstance()->getValor('SEI','Modulos')) as $strModulo){
        	//if (method_exists($SEI_MODULOS[$strModulo]['Integracao'],'atualizarConteudoDocumento')){
            $SEI_MODULOS[$strModulo]['Integracao']->atualizarConteudoDocumento($parObjDocumentoDTO);
        	//}
        }
      }
      
      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());
      $objDocumentoDTO->setStrConteudo($parObjDocumentoDTO->getStrConteudo());
         
      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->alterar($objDocumentoDTO);
            
      //Auditoria 

    }catch(Exception $e){
      throw new InfraException('Erro atualizando conteúdo do documento.',$e);
    }
  }

  public function assinar(AssinaturaDTO $objAssinaturaDTO){

    $script = $this->assinarInterno($objAssinaturaDTO);

    if ($objAssinaturaDTO->getStrStaFormaAutenticacao()==AssinaturaRN::$TA_SENHA){

      $objIndexacaoDTO = new IndexacaoDTO();
      $objIndexacaoDTO->setArrObjProtocoloDTO(InfraArray::gerarArrInfraDTO('ProtocoloDTO','IdProtocolo',InfraArray::converterArrInfraDTO($objAssinaturaDTO->getArrObjDocumentoDTO(),'IdDocumento')));
      $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_ASSINATURA_DOCUMENTO);

      $objIndexacaoRN = new IndexacaoRN();
      $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);
    }

    return $script;
  }

  protected function assinarInternoControlado(AssinaturaDTO $objAssinaturaDTO) {
    try{

      //Valida Permissao
      $objAssinaturaDTOAuditoria = clone($objAssinaturaDTO);
      $objAssinaturaDTOAuditoria->unSetStrSenhaUsuario();
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_assinar',__METHOD__,$objAssinaturaDTOAuditoria);

      //Regras de Negocio
      $objInfraException = new InfraException();

      $objRetornoAssinaturaDTO = new RetornoAssinaturaDTO();

      $objInfraParametro = new InfraParametro(BancoSEI::getInstance());

      $objUsuarioDTOPesquisa = new UsuarioDTO();
      $objUsuarioDTOPesquisa->setBolExclusaoLogica(false);
      $objUsuarioDTOPesquisa->retNumIdUsuario();
      $objUsuarioDTOPesquisa->retStrSigla();
      $objUsuarioDTOPesquisa->retStrNome();
      $objUsuarioDTOPesquisa->retDblCpf();
      $objUsuarioDTOPesquisa->retStrStaTipo();
      $objUsuarioDTOPesquisa->retStrSenha();
      $objUsuarioDTOPesquisa->retNumIdContato();
      $objUsuarioDTOPesquisa->setNumIdUsuario($objAssinaturaDTO->getNumIdUsuario());
      
      $objUsuarioRN = new UsuarioRN();
      $objUsuarioDTO = $objUsuarioRN->consultarRN0489($objUsuarioDTOPesquisa);
      
      if ($objUsuarioDTO==null){
        throw new InfraException('Assinante não cadastrado como usuário do sistema.');
      }
      
      if ($objUsuarioDTO->getStrStaTipo()==UsuarioRN::$TU_EXTERNO_PENDENTE){
        $objInfraException->lancarValidacao('Usuário externo '.$objUsuarioDTO->getStrSigla().' não foi liberado.');
      }
       
      if ($objUsuarioDTO->getStrStaTipo()!=UsuarioRN::$TU_SIP && $objUsuarioDTO->getStrStaTipo()!=UsuarioRN::$TU_EXTERNO){
        throw new InfraException('Tipo do usuário ['.$objUsuarioDTO->getStrStaTipo().'] inválido para assinatura.');
      }

      if ($objAssinaturaDTO->getStrStaFormaAutenticacao()==AssinaturaRN::$TA_CERTIFICADO_DIGITAL &&
          InfraString::isBolVazia($objUsuarioDTO->getDblCpf()) &&
          $objInfraParametro->getValor('SEI_HABILITAR_VALIDACAO_CPF_CERTIFICADO_DIGITAL')=='1'){
        $objInfraException->lancarValidacao('Assinante não possui CPF cadastrado.');
      }

      if (SessaoSEI::getInstance()->getNumIdUsuario()==$objAssinaturaDTO->getNumIdUsuario()){
        $objUsuarioDTOLogado = clone($objUsuarioDTO);
      }else{
        $objUsuarioDTOPesquisa->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
        $objUsuarioDTOLogado = $objUsuarioRN->consultarRN0489($objUsuarioDTOPesquisa);
      }
      
      $objAssinaturaRN = new AssinaturaRN();
      $objSecaoDocumentoRN = new SecaoDocumentoRN(); 

      $arrIdDocumentoAssinatura = array_unique(InfraArray::converterArrInfraDTO($objAssinaturaDTO->getArrObjDocumentoDTO(),'IdDocumento'));

      //verifica permissão de acesso ao documento
      $objPesquisaProtocoloDTO = new PesquisaProtocoloDTO();
      $objPesquisaProtocoloDTO->setStrStaTipo(ProtocoloRN::$TPP_DOCUMENTOS);
      $objPesquisaProtocoloDTO->setStrStaAcesso(ProtocoloRN::$TAP_TODOS);
      $objPesquisaProtocoloDTO->setDblIdProtocolo($arrIdDocumentoAssinatura);

      $objProtocoloRN = new ProtocoloRN();
      $arrObjProtocoloDTO = $objProtocoloRN->pesquisarRN0967($objPesquisaProtocoloDTO);

      $numDocOrigem = count($arrIdDocumentoAssinatura);
      $numDocEncontrado = count($arrObjProtocoloDTO);

      if (($numDocOrigem - $numDocEncontrado) == 1){
        if ($numDocOrigem == 1){
          $objInfraException->lancarValidacao('Documento não encontrado para assinatura.');
        }else{
          $objInfraException->lancarValidacao('Um documento não foi encontrado para assinatura.');
        }
      }else if (($numDocOrigem - $numDocEncontrado) > 1){
        $objInfraException->lancarValidacao(($numDocOrigem - $numDocEncontrado).' documentos não foram encontrados para assinatura.');
      }

      $objAcessoExternoRN = new AcessoExternoRN();
      
      foreach($arrObjProtocoloDTO as $objProtocoloDTO){

        if ($objProtocoloDTO->getStrStaEstado()==ProtocoloRN::$TE_CANCELADO){
          
          $objInfraException->adicionarValidacao('Documento '.$objProtocoloDTO->getStrProtocoloFormatado().' foi cancelado.');
          
        }else if ($objUsuarioDTOLogado->getStrStaTipo()==UsuarioRN::$TU_SIP && $objProtocoloDTO->getNumCodigoAcesso() < 0){
          
          $objInfraException->adicionarValidacao('Usuário '.$objUsuarioDTOLogado->getStrSigla().' não possui acesso ao documento '.$objProtocoloDTO->getStrProtocoloFormatado().'.');

        //só valida se o usuário externo estiver logado pois ele pode estar na instituição para assinar através do login de outro usuário    
        }elseif ($objUsuarioDTO->getStrStaTipo()==UsuarioRN::$TU_EXTERNO && $objUsuarioDTO->getNumIdUsuario()==$objUsuarioDTOLogado->getNumIdUsuario()){
             
          $objAcessoExternoDTO = new AcessoExternoDTO();
          $objAcessoExternoDTO->setNumIdContatoParticipante($objUsuarioDTO->getNumIdContato());
          $objAcessoExternoDTO->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());
          $objAcessoExternoDTO->setStrStaTipo(AcessoExternoRN::$TA_ASSINATURA_EXTERNA);
            
          if (!$objAcessoExternoRN->contar($objAcessoExternoDTO)){
            $objInfraException->adicionarValidacao('Usuário externo '.$objUsuarioDTO->getStrSigla().' não recebeu liberação para assinar o documento '.$objProtocoloDTO->getStrProtocoloFormatado().'.');
          }
        }

        if ($objProtocoloDTO->getStrStaProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
          if ($objProtocoloDTO->getStrSinPublicado()=='S'){
            $objInfraException->adicionarValidacao('Documento '.$objProtocoloDTO->getStrProtocoloFormatado().' já foi publicado.');
          }
  
          if ($objProtocoloDTO->getStrStaEditorDocumento()==EditorRN::$TE_EDOC && InfraString::isBolVazia($objProtocoloDTO->getDblIdDocumentoEdocDocumento())){
            $objInfraException->adicionarValidacao('Documento '.$objProtocoloDTO->getStrProtocoloFormatado().' não possui conteúdo.');
          }
        }

        $dto = new AssinaturaDTO();
        $dto->retStrNomeUsuario();
        $dto->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());
        $dto->setNumIdUsuario($objAssinaturaDTO->getNumIdUsuario());
        $dto = $objAssinaturaRN->consultarRN1322($dto);

        if ($dto != null){
          $objInfraException->adicionarValidacao('Documento '.$objProtocoloDTO->getStrProtocoloFormatado().' já foi assinado por "'.$dto->getStrNomeUsuario().'".');
        }
        
        if ($objProtocoloDTO->getStrStaEditorDocumento()==EditorRN::$TE_INTERNO){
          $objSecaoDocumentoDTO = new SecaoDocumentoDTO();
          $objSecaoDocumentoDTO->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());
          $objSecaoDocumentoDTO->setStrSinAssinatura('S');
          
          if ($objSecaoDocumentoRN->contar($objSecaoDocumentoDTO)==0){
            $objInfraException->adicionarValidacao('Documento '.$objProtocoloDTO->getStrProtocoloFormatado().' não contém seção de assinatura.');
          }
        }
      }
       
      $objInfraException->lancarValidacoes();

      /*
       foreach($arrObjProtocoloDTO as $objProtocoloDTO){
      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());

      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->bloquear($objDocumentoDTO);
      }
      */

      $objInfraException->lancarValidacoes();
       
      $numTipoAssinatura = null;
      if ($objAssinaturaDTO->getStrStaFormaAutenticacao()==AssinaturaRN::$TA_SENHA){

        $numTipoAssinatura = '2';

        if ($objUsuarioDTO->getStrStaTipo()==UsuarioRN::$TU_SIP){
          $objInfraSip = new InfraSip(SessaoSEI::getInstance());
          $objInfraSip->autenticar($objAssinaturaDTO->getNumIdOrgaoUsuario(),
              $objAssinaturaDTO->getNumIdContextoUsuario(),
              $objUsuarioDTO->getStrSigla(),
              $objAssinaturaDTO->getStrSenhaUsuario());
        }else{
          if ($objUsuarioDTO->getStrSenha() != md5($objAssinaturaDTO->getStrSenhaUsuario())) {
            $objInfraException->lancarValidacao('Senha inválida.');
          }
        }
         
      }else{
        $numTipoAssinatura = '1';
      }

      $arrIdDocumentoEdoc = array();
      foreach($arrObjProtocoloDTO as $objProtocoloDTO){
        if ($objProtocoloDTO->getStrStaProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
          if ($objProtocoloDTO->getStrStaEditorDocumento()==EditorRN::$TE_EDOC){
            $arrIdDocumentoEdoc[] = $objProtocoloDTO->getDblIdDocumentoEdocDocumento();
          }else if ($objProtocoloDTO->getStrStaEditorDocumento()==EditorRN::$TE_INTERNO){
            if ($objProtocoloDTO->getStrSinAssinado()=='N'){
              
              /*
              //gerar nova versao igual a anterior para substituição de dados dinâmicos (ex.: datas)
              $objVersaoSecaoDocumentoDTO = new VersaoSecaoDocumentoDTO();
              $objVersaoSecaoDocumentoDTO->retNumIdSecaoModeloSecaoDocumento();
              $objVersaoSecaoDocumentoDTO->retStrConteudo();
              $objVersaoSecaoDocumentoDTO->setDblIdDocumentoSecaoDocumento($objProtocoloDTO->getDblIdProtocolo());
              $objVersaoSecaoDocumentoDTO->setNumIdBaseConhecimentoSecaoDocumento(null);
              $objVersaoSecaoDocumentoDTO->setStrSinUltima('S');
              $objVersaoSecaoDocumentoDTO->setOrdNumOrdemSecaoDocumento(InfraDTO::$TIPO_ORDENACAO_ASC);
              
              $objVersaoSecaoDocumentoRN = new VersaoSecaoDocumentoRN();
              $arrObjVersaoSecaoDocumentoDTO = $objVersaoSecaoDocumentoRN->listar($objVersaoSecaoDocumentoDTO);
              
              $arrObjSecaoDocumentoDTO = array();
              foreach($arrObjVersaoSecaoDocumentoDTO as $objVersaoSecaoDocumentoDTO){
                $objSecaoDocumentoDTO = new SecaoDocumentoDTO();
                $objSecaoDocumentoDTO->setNumIdSecaoModelo($objVersaoSecaoDocumentoDTO->getNumIdSecaoModeloSecaoDocumento());
                $objSecaoDocumentoDTO->setStrConteudo($objVersaoSecaoDocumentoDTO->getStrConteudo());
                $arrObjSecaoDocumentoDTO[] = $objSecaoDocumentoDTO;
              }
              $objEditorDTO = new EditorDTO();
              $objEditorDTO->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());
              $objEditorDTO->setNumIdBaseConhecimento(null);
              $objEditorDTO->setArrObjSecaoDocumentoDTO($arrObjSecaoDocumentoDTO);
              
              $objEditorRN = new EditorRN();
              $objEditorRN->adicionarVersao($objEditorDTO);
              */
  
              /////////
              $objEditorDTO = new EditorDTO();
              $objEditorDTO->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());
              $objEditorDTO->setNumIdBaseConhecimento(null);
              $objEditorDTO->setStrSinCabecalho('S');
              $objEditorDTO->setStrSinRodape('S');
              $objEditorDTO->setStrSinIdentificacaoVersao('N');
        
              $objEditorRN = new EditorRN();
              $strDocumentoHTML = $objEditorRN->consultarHtmlVersao($objEditorDTO);
        
              $objDocumentoDTO = new DocumentoDTO();
              $objDocumentoDTO->setStrConteudoAssinatura($strDocumentoHTML);
              $objDocumentoDTO->setStrCrcAssinatura(strtoupper(hash('crc32b', $strDocumentoHTML)));
              
              $this->gerarQrCode($objProtocoloDTO, $objDocumentoDTO);
            }
          }
        }else{

          $objAnexoDTO = new AnexoDTO();
          $objAnexoDTO->retNumIdAnexo();
          $objAnexoDTO->retDthInclusao();
          $objAnexoDTO->setDblIdProtocolo($objProtocoloDTO->getDblIdProtocolo());
          
          $objAnexoRN = new AnexoRN();
          $objAnexoDTO = $objAnexoRN->consultarRN0736($objAnexoDTO);
          
          if ($objAnexoDTO==null){
            $objInfraException->lancarValidacao('Documento '.$objProtocoloDTO->getStrProtocoloFormatado().' não possui anexo associado.');
          }
          
          $objDocumentoDTO = new DocumentoDTO();
          $objDocumentoDTO->setStrConteudoAssinatura(null);
          $objDocumentoDTO->setStrCrcAssinatura(strtoupper(hash_file('crc32b', $objAnexoRN->obterLocalizacao($objAnexoDTO))));
          
          $this->gerarQrCode($objProtocoloDTO, $objDocumentoDTO);
        }
      }
      
      if (count($arrIdDocumentoEdoc)){
        
      	$strNomeAssinatura = null;
	      if ($objAssinaturaDTO->getStrStaFormaAutenticacao()==AssinaturaRN::$TA_SENHA){  
	        $strNomeAssinatura = 'Assinado eletronicamente por '.$objUsuarioDTO->getStrNome().' em '.substr(InfraData::getStrDataHoraAtual(),0,16);
	      }else{
	        $strNomeAssinatura = $objUsuarioDTO->getStrNome();
	      }
	        
	      $arrAssinantes = array(
	                         array(
	                           array('Nome', $strNomeAssinatura),
	                           array('Tratamento', $objAssinaturaDTO->getStrCargoFuncao()),
	                           array('CPF',$objUsuarioDTO->getDblCpf()),
	                           array('NumeroSerieCertificado',null),
	                           array('NomeSecaoInterno','Assinatura'),
	                           array('TipoAssinatura',$numTipoAssinatura)));   //Digital = 1,Eletronica = 2,Manuscrita = 3
	                                         
	      $arrParametros = array('arrIdDocumento' => $arrIdDocumentoEdoc,                            
	                               'sinDocumentoDigital' => true,
	                               'listaDeAssinaturas' => $arrAssinantes,
	                               'excluiTipoAssinatura' => '');
	  
	      $objEDocRN = new EDocRN();
	      $objEDocRN->adicionarAssinante($arrParametros);
	      
	      if ($objAssinaturaDTO->getStrStaFormaAutenticacao()==AssinaturaRN::$TA_CERTIFICADO_DIGITAL){  
	        $arrParametros = array('arrIdDocumento' => $arrIdDocumentoEdoc,
	                               'usuario' => $objUsuarioDTO->getStrSigla());
	        
	        $objRetornoAssinaturaDTO->setStrVbScript($objEDocRN->assinar($arrParametros));
	      }  
	            
      }else{
        $objRetornoAssinaturaDTO->setStrVbScript(null);
      }
      

      $objAtividadeRN = new AtividadeRN();
      $arrObjAssinaturaDTO = array();
      $arrObjDocumentoDTOCredencialAssinatura = array();
      foreach($arrObjProtocoloDTO as $objProtocoloDTO){

        $numIdAtividade = null;
        if ($objAssinaturaDTO->getStrStaFormaAutenticacao()==AssinaturaRN::$TA_SENHA){

          //lança tarefa de assinatura
          $arrObjAtributoAndamentoDTO = array();
          $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
          $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
          $objAtributoAndamentoDTO->setStrValor($objProtocoloDTO->getStrProtocoloFormatado());
          $objAtributoAndamentoDTO->setStrIdOrigem($objProtocoloDTO->getDblIdProtocolo());
          $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

          $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
          $objAtributoAndamentoDTO->setStrNome('USUARIO');
          $objAtributoAndamentoDTO->setStrValor($objUsuarioDTO->getStrSigla().'¥'.$objUsuarioDTO->getStrNome());
          $objAtributoAndamentoDTO->setStrIdOrigem($objUsuarioDTO->getNumIdUsuario());
          $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
           
          $objAtividadeDTO = new AtividadeDTO();
          $objAtividadeDTO->setDblIdProtocolo($objProtocoloDTO->getDblIdProcedimentoDocumento());
          $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
          $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_ASSINATURA_DOCUMENTO);
          $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);

          $objAtividadeDTO = $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
          $numIdAtividade = $objAtividadeDTO->getNumIdAtividade();
        }
         
        //remove ocorrência pendente, se existir
        $dto = new AssinaturaDTO();
        $dto->retNumIdAssinatura();
        $dto->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());
        $dto->setNumIdUsuario($objAssinaturaDTO->getNumIdUsuario());
        $dto->setBolExclusaoLogica(false);
        $dto->setStrSinAtivo('N');
        $dto = $objAssinaturaRN->consultarRN1322($dto);

        if ($dto!=null){
          $objAssinaturaRN->excluirRN1321(array($dto));
        }

        $dto = new AssinaturaDTO();
        $dto->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());
        $dto->setNumIdUsuario($objAssinaturaDTO->getNumIdUsuario());
        $dto->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
        $dto->setNumIdAtividade($numIdAtividade);
        $dto->setStrSiglaUsuario($objUsuarioDTO->getStrSigla());
        $dto->setStrNome($objUsuarioDTO->getStrNome());
        $dto->setStrTratamento($objAssinaturaDTO->getStrCargoFuncao());
        $dto->setDblCpf($objUsuarioDTO->getDblCpf());
        $dto->setStrStaFormaAutenticacao($objAssinaturaDTO->getStrStaFormaAutenticacao());
        $dto->setStrP7sBase64(null);
        
        if ($objAssinaturaDTO->getStrStaFormaAutenticacao()==AssinaturaRN::$TA_CERTIFICADO_DIGITAL){
          $dto->setStrSinAtivo('N');
        }else{
          $dto->setStrSinAtivo('S');
        }
        
        $objAssinaturaDTO_Temp = $objAssinaturaRN->cadastrarRN1319($dto);
        $objAssinaturaDTO_Temp->setStrStaEditorDocumento($objProtocoloDTO->getStrStaEditorDocumento());
        $arrObjAssinaturaDTO[] = $objAssinaturaDTO_Temp;

        if ($objAssinaturaDTO->getStrStaFormaAutenticacao()==AssinaturaRN::$TA_SENHA){

          $objDocumentoDTO = new DocumentoDTO();
          $objDocumentoDTO->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());

          if ($objProtocoloDTO->getStrSinCredencialAssinatura()=='S'){
            $arrObjDocumentoDTOCredencialAssinatura[] = $objDocumentoDTO;
          }
        }
      }

      $objRetornoAssinaturaDTO->setArrObjAssinaturaDTO($arrObjAssinaturaDTO);
       
      if (count($arrObjDocumentoDTOCredencialAssinatura)){
        $objAtividadeRN->concluirCredencialAssinatura($arrObjDocumentoDTOCredencialAssinatura);
      }

      return $objRetornoAssinaturaDTO;

      //Auditoria

    }catch(Exception $e){

      if(preg_match("/^Documento  \[(.+)\], NÃO é possível adicionar a assinatura\.$/i", $e->__toString(), $matches)){

        $bolErro = false;
        $strMsg = '';

        try{

          $objDocumentoDTO = new DocumentoDTO();
          $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
          $objDocumentoDTO->setDblIdDocumentoEdoc(substr($e, 12,10));

          $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

          $strMsg = str_replace(substr($e, 12,10),$objDocumentoDTO->getStrProtocoloDocumentoFormatado(),$e);

        }catch(Exception $e2){
          $bolErro = true;
        }

        if (!$bolErro){
          $objInfraException = new InfraException();
          $objInfraException->lancarValidacao($strMsg);
        }
      }

      throw new InfraException('Erro assinando documento.',$e);
    }
  }
  
  private function gerarQrCode(ProtocoloDTO $objProtocoloDTO, DocumentoDTO $objDocumentoDTO){
    try{

      $objAnexoRN = new AnexoRN();
      $strArquivoQRCaminhoCompleto = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario();
      $strUrlVerificacao = ConfiguracaoSEI::getInstance()->getValor('SEI','URL').'/controlador_externo.php?acao=documento_conferir&id_orgao_acesso_externo='.$objProtocoloDTO->getNumIdOrgaoUnidadeGeradora().'&cv='.$objProtocoloDTO->getStrProtocoloFormatado().'&crc='.$objDocumentoDTO->getStrCrcAssinatura();
      
      InfraQRCode::gerar($strUrlVerificacao, $strArquivoQRCaminhoCompleto,'L',2,1);

      $objInfraException = new InfraException();


      if (!file_exists($strArquivoQRCaminhoCompleto)){
        $objInfraException->lancarValidacao('Arquivo do QRCode não encontrado.');
      }
      
      if (filesize($strArquivoQRCaminhoCompleto)==0){
        $objInfraException->lancarValidacao('Arquivo do QRCode vazio.');
      }
      
      if (($binQrCode = file_get_contents($strArquivoQRCaminhoCompleto))===false){
        $objInfraException->lancarValidacao('Não foi possível ler o arquivo do QRCode.');
      }
      
      $objDocumentoDTO->setStrQrCodeAssinatura(base64_encode($binQrCode));
      
      $objDocumentoDTO->setDblIdDocumento($objProtocoloDTO->getDblIdProtocolo());
      
      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->alterar($objDocumentoDTO);

      unlink($strArquivoQRCaminhoCompleto);
      
    }catch(Exception $e){
      throw new InfraException('Erro gerando QRCode da assinatura.',$e);
    }
  }

  public function confirmarAssinatura(AssinaturaDTO $objAssinaturaDTO){

    $objDocumentoDTO = $this->confirmarAssinaturaInterno($objAssinaturaDTO);

    if ($objDocumentoDTO!=null){

      $objIndexacaoDTO = new IndexacaoDTO();

      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

      $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));
      $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_ASSINATURA_DOCUMENTO);

      $objIndexacaoRN = new IndexacaoRN();
      $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);
    }
  }

  protected function confirmarAssinaturaInternoControlado(AssinaturaDTO $parObjAssinaturaDTO) {
    try{

      //Regras de Negocio
      $objInfraException = new InfraException();
      //$objInfraException->lancarValidacoes();

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retStrStaEditor();

      $objAssinaturaRN = new AssinaturaRN();
      $objAssinaturaDTO = new AssinaturaDTO();
      $objAssinaturaDTO->retDblIdDocumento();
      $objAssinaturaDTO->retNumIdAssinatura();
      $objAssinaturaDTO->retStrSinAtivo();
      $objAssinaturaDTO->retNumIdUnidade();
      $objAssinaturaDTO->retNumIdUsuario();
      $objAssinaturaDTO->retStrSiglaUsuario();
      $objAssinaturaDTO->retStrSiglaOrgaoUsuario();
      $objAssinaturaDTO->retStrNomeUsuario();
      $objAssinaturaDTO->retDblCpf();
      $objAssinaturaDTO->setBolExclusaoLogica(false);

      if ($parObjAssinaturaDTO->isSetNumIdAssinatura()){
        // editor interno
        $objAssinaturaDTO->setNumIdAssinatura($parObjAssinaturaDTO->getNumIdAssinatura());
        $objAssinaturaDTO = $objAssinaturaRN->consultarRN1322($objAssinaturaDTO);

        if ($objAssinaturaDTO==null){
          $objInfraException->lancarValidacao('Assinatura '.$parObjAssinaturaDTO->getNumIdAssinatura().' não localizada no SEI.');
        }

        $objDocumentoDTO->setDblIdDocumento($objAssinaturaDTO->getDblIdDocumento());
        $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

        $parObjAssinaturaDTO->setDblCpf($objAssinaturaDTO->getDblCpf());
        $parObjAssinaturaDTO->setStrSiglaUsuario($objAssinaturaDTO->getStrSiglaUsuario());
        $parObjAssinaturaDTO->setStrSiglaOrgaoUsuario($objAssinaturaDTO->getStrSiglaOrgaoUsuario());
        $parObjAssinaturaDTO->setDblIdDocumento($objAssinaturaDTO->getDblIdDocumento());
        $parObjAssinaturaDTO->setNumIdAssinatura($objAssinaturaDTO->getNumIdAssinatura());
        $objAssinaturaRN->validarAssinaturaDocumento($parObjAssinaturaDTO, $objInfraException);

      }else if ($parObjAssinaturaDTO->isSetDblIdDocumentoEdoc()){
        // editor edoc
        $objDocumentoDTO->setDblIdDocumentoEdoc($parObjAssinaturaDTO->getDblIdDocumentoEdoc());
        $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

        if ($objDocumentoDTO==null){
          $objInfraException->lancarValidacao('Documento '.$parObjAssinaturaDTO->getDblIdDocumentoEdoc().' não possui correspondência no SEI.');
        }
         
        $objAssinaturaDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
        $objAssinaturaDTO->setStrSiglaUsuario($parObjAssinaturaDTO->getStrSiglaUsuario());
        $objAssinaturaDTO->setDblCpf($parObjAssinaturaDTO->getDblCpf());
        $objAssinaturaDTO = $objAssinaturaRN->consultarRN1322($objAssinaturaDTO);
        
        $parObjAssinaturaDTO->setNumIdAssinatura($objAssinaturaDTO->getNumIdAssinatura());
        
      }else{
        $objInfraException->lancarValidacao('Documento para confirmação de assinatura não informado.');
      }
       
      if ($objAssinaturaDTO->getStrSinAtivo()=='S'){
        $objInfraException->lancarValidacao('Não existe assinatura pendente para o documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().'/'.$objDocumentoDTO->getDblIdDocumento().' no SEI.');
      }

      SessaoSEI::getInstance()->setNumIdUsuario($objAssinaturaDTO->getNumIdUsuario());
      SessaoSEI::getInstance()->setNumIdUnidadeAtual($objAssinaturaDTO->getNumIdUnidade());

      $objAtividadeRN = new AtividadeRN();


      //verifica permissão de acesso ao documento
      $objPesquisaProtocoloDTO = new PesquisaProtocoloDTO();
      $objPesquisaProtocoloDTO->setStrStaTipo(ProtocoloRN::$TPP_DOCUMENTOS);
      $objPesquisaProtocoloDTO->setStrStaAcesso(ProtocoloRN::$TAP_AUTORIZADO);
      $objPesquisaProtocoloDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());

      $objProtocoloRN = new ProtocoloRN();
      $arrObjProtocoloDTO = $objProtocoloRN->pesquisarRN0967($objPesquisaProtocoloDTO);

      if (count($arrObjProtocoloDTO)==0){
        $objInfraException->lancarValidacao('Usuário sem acesso ao documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().' no SEI.');
      }

      if ($arrObjProtocoloDTO[0]->getStrSinCredencialAssinatura()=='S'){
        $objAtividadeRN->concluirCredencialAssinatura(array($objDocumentoDTO));
      }


      //lança tarefa de assinatura
      $arrObjAtributoAndamentoDTO = array();
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrValor($objDocumentoDTO->getStrProtocoloDocumentoFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getDblIdDocumento());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('USUARIO');
      $objAtributoAndamentoDTO->setStrValor($objAssinaturaDTO->getStrSiglaUsuario().'¥'.$objAssinaturaDTO->getStrNomeUsuario());
      $objAtributoAndamentoDTO->setStrIdOrigem($objAssinaturaDTO->getNumIdUsuario());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
       

      $objAtividadeDTO = new AtividadeDTO();
      $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
      $objAtividadeDTO->setNumIdUnidadeOrigem($objAssinaturaDTO->getNumIdUnidade());
      $objAtividadeDTO->setNumIdUnidade($objAssinaturaDTO->getNumIdUnidade());
      $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_ASSINATURA_DOCUMENTO);
      $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);


      $objAtividadeDTO = $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);

      $dto = new AssinaturaDTO();
      $dto->setStrSinAtivo('S');
      $dto->setNumIdAtividade($objAtividadeDTO->getNumIdAtividade());
      if ($objDocumentoDTO->getStrStaEditor()!=EditorRN::$TE_EDOC){
        $dto->setStrNumeroSerieCertificado($parObjAssinaturaDTO->getStrNumeroSerieCertificado());
        $dto->setStrP7sBase64($parObjAssinaturaDTO->getStrP7sBase64());
      }
      $dto->setNumIdAssinatura($parObjAssinaturaDTO->getNumIdAssinatura());
      $objAssinaturaRN->alterarRN1320($dto);

      return $objDocumentoDTO;

      //Auditoria

    }catch(Exception $e){
      throw new InfraException('Erro confirmando assinatura.',$e);
    }
  }

  protected function validarDocumentoPublicadoRN1211Controlado(DocumentoDTO $parObjDocumentoDTO){

    $objInfraException = new InfraException();

    $objDocumentoDTO = new DocumentoDTO();
    $objDocumentoDTO->retObjPublicacaoDTO();
    $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
    $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

    $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

    $objPublicacaoDTO = $objDocumentoDTO->getObjPublicacaoDTO();

    if ($objPublicacaoDTO != null){
      if ($objPublicacaoDTO->getStrStaEstado()==PublicacaoRN::$TE_AGENDADO){
        $objInfraException->lancarValidacao('Documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().' agendado para publicação em '.$objPublicacaoDTO->getDtaDisponibilizacao().'.');
      }else{
        $objInfraException->lancarValidacao('Documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().' foi publicado em '.$objPublicacaoDTO->getDtaPublicacao().'.');
      }
    }
  }

  private function validarStrNumeroRN0010(DocumentoDTO $objDocumentoDTO, InfraException $objInfraException){

    $objSerieDTO = new SerieDTO();
    $objSerieDTO->setBolExclusaoLogica(false);
    $objSerieDTO->retStrNome();
    $objSerieDTO->retStrStaNumeracao();
    $objSerieDTO->setNumIdSerie($objDocumentoDTO->getNumIdSerie());

    $objSerieRN = new SerieRN();
    $objSerieDTO = $objSerieRN->consultarRN0644($objSerieDTO);

    $strStaNumeracao = $objSerieDTO->getStrStaNumeracao();
    $strNomeSerie = $objSerieDTO->getStrNome();

    if ($strStaNumeracao == SerieRN::$TN_INFORMADA){
      if (InfraString::isBolVazia($objDocumentoDTO->getStrNumero())){
        $objInfraException->adicionarValidacao('Número não informado.');
      }else{

        $this->validarTamanhoNumeroRN0993($objDocumentoDTO, $objInfraException);
      }
    }else{

      $dto = new DocumentoDTO();
      $dto->retStrNumero();
      $dto->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
      $dto = $this->consultarRN0005($dto);

      if ($dto->getStrNumero() != $objDocumentoDTO->getStrNumero()){
        $objInfraException->adicionarValidacao('Não é possível alterar a numeração porque o tipo '.$strNomeSerie.' não aceita que o número seja informado.');
      }
    }
  }

  protected function cancelarAssinaturaControlado(DocumentoDTO $parObjDocumentoDTO){
    try {

      $objInfraException = new InfraException();

      $objAssinaturaDTO = new AssinaturaDTO();
      $objAssinaturaDTO->retNumIdAssinatura();
      $objAssinaturaDTO->retNumIdUnidade();
      $objAssinaturaDTO->retStrStaTipoUsuario();
      $objAssinaturaDTO->retStrSiglaUsuario();
      $objAssinaturaDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

      $objAssinaturaRN = new AssinaturaRN();
      $arrObjAssinaturaDTO = $objAssinaturaRN->listarRN1323($objAssinaturaDTO);

      if (count($arrObjAssinaturaDTO)>0){

        foreach($arrObjAssinaturaDTO as $objAssinaturaDTO){
          if ($objAssinaturaDTO->getStrStaTipoUsuario()==UsuarioRN::$TU_EXTERNO_PENDENTE || $objAssinaturaDTO->getStrStaTipoUsuario()==UsuarioRN::$TU_EXTERNO){
            $objInfraException->adicionarValidacao('Documento foi assinado pelo usuário externo "'.$objAssinaturaDTO->getStrSiglaUsuario().'".');
          }
        }

        $objDocumentoDTO = new DocumentoDTO();
        $objDocumentoDTO->retDblIdDocumento();
        $objDocumentoDTO->retDblIdProcedimento();
        $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
        $objDocumentoDTO->retNumIdUnidadeGeradoraProtocolo();
        $objDocumentoDTO->retStrSinBloqueado();
        $objDocumentoDTO->retStrStaEditor();
        $objDocumentoDTO->setDblIdDocumento($parObjDocumentoDTO->getDblIdDocumento());

        $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

        if ($objDocumentoDTO->getNumIdUnidadeGeradoraProtocolo()!=SessaoSEI::getInstance()->getNumIdUnidadeAtual()){
          foreach($arrObjAssinaturaDTO as $objAssinaturaDTO){
            if ($objAssinaturaDTO->getNumIdUnidade()!=SessaoSEI::getInstance()->getNumIdUnidadeAtual()){
              $objInfraException->lancarValidacao('Documento foi assinado por outra unidade.');
            }
          }
        }

        if ($objDocumentoDTO->getStrSinBloqueado()=='S'){
          $objInfraException->lancarValidacao('A assinatura do documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado().' não pode mais ser cancelada.');
        }

        $objInfraException->lancarValidacoes();

        $dto = new DocumentoDTO();
        $dto->setStrConteudoAssinatura(null);
        $dto->setStrCrcAssinatura(null);
        $dto->setStrQrCodeAssinatura(null);
        $dto->setStrSinBloqueado('N');
        $dto->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());

        $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
        $objDocumentoBD->alterar($dto);

        $objAssinaturaRN->excluirRN1321($arrObjAssinaturaDTO);


        //lança tarefa de cancelamento de assinatura
        $arrObjAtributoAndamentoDTO = array();
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
        $objAtributoAndamentoDTO->setStrValor($objDocumentoDTO->getStrProtocoloDocumentoFormatado());
        $objAtributoAndamentoDTO->setStrIdOrigem($parObjDocumentoDTO->getDblIdDocumento());
        $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

        $objAtividadeDTO = new AtividadeDTO();
        $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
        $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
        $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_CANCELAMENTO_ASSINATURA);
        $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);

        $objAtividadeRN = new AtividadeRN();
        $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);

        $objIndexacaoDTO = new IndexacaoDTO();

        $objProtocoloDTO = new ProtocoloDTO();
        $objProtocoloDTO->setDblIdProtocolo($parObjDocumentoDTO->getDblIdDocumento());

        $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));
        $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_ASSINATURA_DOCUMENTO);

        $objIndexacaoRN = new IndexacaoRN();
        $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);
      }

    }catch(Exception $e){
      throw new InfraException('Erro cancelando assinatura.',$e);
    }
  }

  public function verificarSelecaoEmail(DocumentoDTO $objDocumentoDTO){

    //exclui cancelados
    //documento externos
    //gerados assinados
    //gerados publicados
    //formulários

    return ($objDocumentoDTO->getStrStaEstadoProtocolo() != ProtocoloRN::$TE_CANCELADO  &&
             ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO ||
              ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO && ($objDocumentoDTO->getStrSinAssinado()=='S' ||	$objDocumentoDTO->getStrSinPublicado()=='S')) ||
              $objDocumentoDTO->getStrSinFormulario()=='S'));
  }
 
  public function verificarSelecaoDuplicacao(DocumentoDTO $objDocumentoDTO){

    //exclui cancelados
    //documento externos
    //gerados pela unidade atual [inclui rascunhos]
    //gerados assinados
    //gerados publicados
    //gerados com conteudo do e-Doc [exclui formulários]

    return ($objDocumentoDTO->getStrStaEstadoProtocolo() != ProtocoloRN::$TE_CANCELADO  &&
        ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO ||($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO && (($objDocumentoDTO->getNumIdUnidadeGeradoraProtocolo()==SessaoSEI::getInstance()->getNumIdUnidadeAtual() ||
            $objDocumentoDTO->getStrSinAssinado()=='S' ||
            $objDocumentoDTO->getStrSinPublicado()=='S') && $this->verificarConteudoEditavel($objDocumentoDTO) ))));
  }

  public function verificarSelecaoGeracaoPdf(DocumentoDTO $objDocumentoDTO){

    //exclui cancelados
    //documento externos (pdf, text, html)
    //formularios
    //gerados pela unidade atual [inclui rascunhos]
    //gerados assinados
    //gerados publicados

    if ($objDocumentoDTO->getStrStaEstadoProtocolo() == ProtocoloRN::$TE_CANCELADO){
      return false;
    }

    if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO){
      $objAnexoDTO = new AnexoDTO();
      $objAnexoDTO->retNumIdAnexo();
      $objAnexoDTO->retStrNome();
      $objAnexoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());
      $objAnexoRN = new AnexoRN();
      $objAnexoDTO = $objAnexoRN->consultarRN0736($objAnexoDTO);

      if ($objAnexoDTO!=null){
        if (InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'application/pdf' ||
            InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'text/plain' ||
            InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'text/html' ||
            $this->ehUmaExtensaoDeImagemPermitida($objAnexoDTO->getStrNome())){
          return true;
        }
        if ($this->processarArquivoOpenOffice($objAnexoDTO->getStrNome())){
          return true;
        }      
      }
    }
    
    if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
      
      if ($objDocumentoDTO->getStrSinFormulario()=='S'){
        return true;
      }
      
      if ($this->verificarConteudoEditavel($objDocumentoDTO)){
        if ($objDocumentoDTO->getNumIdUnidadeGeradoraProtocolo()==SessaoSEI::getInstance()->getNumIdUnidadeAtual() || 
            $objDocumentoDTO->getStrSinAssinado()=='S' || 
            $objDocumentoDTO->getStrSinPublicado()=='S'){
          return true;
        }
      }
    } 

    return false;
  }

  public function verificarSelecaoGeracaoZip(DocumentoDTO $objDocumentoDTO){
    //exclui cancelados
    //documento externos
    //formularios
    //gerados pela unidade atual [inclui rascunhos]
    //gerados assinados
    //gerados publicados

    if ($objDocumentoDTO->getStrStaEstadoProtocolo() == ProtocoloRN::$TE_CANCELADO){
      return false;
    }

    if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO){
      $objAnexoDTO = new AnexoDTO();
      $objAnexoDTO->retNumIdAnexo();
      $objAnexoDTO->retStrNome();
      $objAnexoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());
      $objAnexoRN = new AnexoRN();
      $objAnexoDTO = $objAnexoRN->consultarRN0736($objAnexoDTO);

      if ($objAnexoDTO!=null) {
        return true;
      }
    }

    if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){

      if ($objDocumentoDTO->getStrSinFormulario()=='S'){
        return true;
      }

      if ($this->verificarConteudoEditavel($objDocumentoDTO)){
        if ($objDocumentoDTO->getNumIdUnidadeGeradoraProtocolo()==SessaoSEI::getInstance()->getNumIdUnidadeAtual() ||
            $objDocumentoDTO->getStrSinAssinado()=='S' ||
            $objDocumentoDTO->getStrSinPublicado()=='S'){
          return true;
        }
      }
    }

    return false;
  }

  public function verificarSelecaoBlocoAssinatura(DocumentoDTO $objDocumentoDTO){

    //exclui sigilosos
    //exclui cancelados
    //documentos gerados
    //unidade geradora igual a unidade atual
    //gerados com conteudo do e-Doc [exclui formulários]

    return ($objDocumentoDTO->getStrStaNivelAcessoGlobalProtocolo() != ProtocoloRN::$NA_SIGILOSO &&
        $objDocumentoDTO->getStrStaEstadoProtocolo() != ProtocoloRN::$TE_CANCELADO  &&
        $objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO &&
        $objDocumentoDTO->getNumIdUnidadeGeradoraProtocolo()==SessaoSEI::getInstance()->getNumIdUnidadeAtual() &&
        $this->verificarConteudoEditavel($objDocumentoDTO));
  }

  public function verificarSelecaoAcessoExterno(DocumentoDTO $objDocumentoDTO){

    //exclui cancelados
    //documentos externos
    //forumularios
    //publicados
    //documentos gerados assinados

    return ($objDocumentoDTO->getStrStaEstadoProtocolo() != ProtocoloRN::$TE_CANCELADO &&
             ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO ||
              $objDocumentoDTO->getStrSinFormulario()=='S' ||
              $objDocumentoDTO->getStrSinPublicado()=='S' ||
                ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO && $objDocumentoDTO->getStrSinAssinado()=='S')));
  }

  public function verificarSelecaoAssinaturaExterna(DocumentoDTO $objDocumentoDTO){

    //exclui cancelados
    //documentos assinados
    //documentos não publicados
    //internos ou edoc com conteudo

    return ($objDocumentoDTO->getStrStaEstadoProtocolo()!=ProtocoloRN::$TE_CANCELADO &&
        //$objDocumentoDTO->getStrSinAssinado()=='S' &&
        $objDocumentoDTO->getStrSinPublicado()=='N' &&
        $this->verificarConteudoEditavel($objDocumentoDTO));
  }

  public function verificarConteudoEditavel(DocumentoDTO $objDocumentoDTO){
    //editor interno
    //editor edoc com conteudo
    return ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_INTERNO || ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_EDOC && $objDocumentoDTO->getDblIdDocumentoEdoc()!=null));
  }
  
  public function verificarSelecaoNotificacao(DocumentoDTO $objDocumentoDTO){

    //exclui cancelados
    //documento externos
    //gerados assinados ou publicados

    return ($objDocumentoDTO->getStrStaEstadoProtocolo() != ProtocoloRN::$TE_CANCELADO  &&
        ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO || ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO && ($objDocumentoDTO->getStrSinAssinado()=='S' || $objDocumentoDTO->getStrSinPublicado()=='S'))));
  }

  protected function lancarAcessoControleInternoControlado(DocumentoDTO $objDocumentoDTO){
    try{

      if ($objDocumentoDTO->getStrStaNivelAcessoGlobalProtocolo()!=ProtocoloRN::$NA_SIGILOSO){

        $objControleInternoDTO = new ControleInternoDTO();
        $objControleInternoDTO->setDistinct(true);
        $objControleInternoDTO->retNumIdUnidadeRelControleInternoUnidade();
        $objControleInternoDTO->setNumIdSerieRelControleInternoSerie($objDocumentoDTO->getNumIdSerie());
        $objControleInternoDTO->setNumIdOrgaoRelControleInternoOrgao(SessaoSEI::getInstance()->getNumIdOrgaoUnidadeAtual());
        $objControleInternoDTO->setNumIdUnidadeRelControleInternoUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual(),InfraDTO::$OPER_DIFERENTE);

        $objControleInternoRN = new ControleInternoRN();
        $arrObjControleInternoDTO = $objControleInternoRN->listar($objControleInternoDTO);
        
        $objProtocoloRN = new ProtocoloRN();

        foreach($arrObjControleInternoDTO as $objControleInternoDTO){

          $objAtividadeDTO = new AtividadeDTO();
          $objAtividadeDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdProcedimento());
          $objAtividadeDTO->setNumIdUnidade($objControleInternoDTO->getNumIdUnidadeRelControleInternoUnidade());

          $objAtividadeRN = new AtividadeRN();

          if ($objAtividadeRN->contarRN0035($objAtividadeDTO)==0){

            $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_ACESSO_AUTOMATICO_AO_PROCESSO);

            $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);

            //Associar o processo e seus documentos com esta unidade
            $objAssociarDTO = new AssociarDTO();
            $objAssociarDTO->setDblIdProcedimento($objDocumentoDTO->getDblIdProcedimento());
            $objAssociarDTO->setDblIdDocumento(null);
            $objAssociarDTO->setNumIdUnidade($objControleInternoDTO->getNumIdUnidadeRelControleInternoUnidade());
            $objAssociarDTO->setNumIdUsuario(null);
            $objAssociarDTO->setStrStaNivelAcessoGlobal($objDocumentoDTO->getStrStaNivelAcessoGlobalProtocolo());

            $objProtocoloRN->associarRN0982($objAssociarDTO);

          }
        }
      }
    }catch(Exception $e){
      throw new InfraException('Erro lançando acesso para o Controle Interno.',$e);
    }
  }

  protected function obterLinkAcessoControlado(LinkAcessoDTO $objLinkAcessoDTO){
    try{

      $objInfraException = new InfraException();

      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->retDblIdProtocolo();
      $objProtocoloDTO->retStrProtocoloFormatado();
      $objProtocoloDTO->retStrStaNivelAcessoGlobal();
      $objProtocoloDTO->setStrProtocoloFormatado($objLinkAcessoDTO->getStrProtocoloDocumentoFormatado());
      $objProtocoloDTO->setStrStaProtocolo(array(ProtocoloRN::$TP_DOCUMENTO_GERADO,ProtocoloRN::$TP_DOCUMENTO_RECEBIDO),InfraDTO::$OPER_IN);
      $objProtocoloDTO->setStrStaNivelAcessoGlobal(ProtocoloRN::$NA_SIGILOSO, InfraDTO::$OPER_DIFERENTE);

      $objProtocoloRN = new ProtocoloRN();
      $objProtocoloDTO = $objProtocoloRN->consultarRN0186($objProtocoloDTO);

      if ($objProtocoloDTO==null){
        $objInfraException->lancarValidacao('Documento '.$objLinkAcessoDTO->getStrProtocoloDocumentoFormatado().' não encontrado.');
      }

      //if ($objProtocoloDTO->getStrStaNivelAcessoGlobal()!=ProtocoloRN::$NA_PUBLICO){
      //  $objInfraException->lancarValidacao('Documento '.$objLinkAcessoDTO->getStrProtocoloDocumentoFormatado().' não é público.');
      //}

      //obtem processo do documento
      $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
      $objRelProtocoloProtocoloDTO->retDblIdProtocolo1();
      $objRelProtocoloProtocoloDTO->retStrProtocoloFormatadoProtocolo1();
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objProtocoloDTO->getDblIdProtocolo());
      $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_DOCUMENTO_ASSOCIADO);

      $objRelProtocoloProtocoloRN = new RelProtocoloProtocoloRN();
      $objRelProtocoloProtocoloDTO = $objRelProtocoloProtocoloRN->consultarRN0841($objRelProtocoloProtocoloDTO);

      $dblIdProcedimento = $objRelProtocoloProtocoloDTO->getDblIdProtocolo1();
      $strProtocoloProcedimentoFormatado = $objRelProtocoloProtocoloDTO->getStrProtocoloFormatadoProtocolo1();

      $dblIdDocumento = $objProtocoloDTO->getDblIdProtocolo();
      $strProtocoloDocumentoFormatado = $objProtocoloDTO->getStrProtocoloFormatado();


      $objLinkAcessoDTO = new $objLinkAcessoDTO();
      $objLinkAcessoDTO->setDblIdProcedimento($dblIdProcedimento);
      $objLinkAcessoDTO->setStrProtocoloProcedimentoFormatado($strProtocoloProcedimentoFormatado);
      $objLinkAcessoDTO->setStrLinkProcesso(ConfiguracaoSEI::getInstance()->getValor('SEI','URL').'/controlador.php?acao=procedimento_trabalhar&id_procedimento='.$dblIdProcedimento);
      $objLinkAcessoDTO->setDblIdDocumento($dblIdDocumento);
      $objLinkAcessoDTO->setStrProtocoloDocumentoFormatado($strProtocoloDocumentoFormatado);
      $objLinkAcessoDTO->setStrLinkDocumento(ConfiguracaoSEI::getInstance()->getValor('SEI','URL').'/controlador.php?acao=procedimento_trabalhar&id_procedimento='.$dblIdProcedimento.'&id_documento='.$dblIdDocumento);

      return $objLinkAcessoDTO;

    }catch(Exception $e){
      throw new InfraException('Erro obtendo link de acesso.',$e);
    }
  }

  protected function obterDocumentoAutenticidadeConectado(DocumentoDTO $parObjDocumentoDTO){
    try{

      $objInfraException = new InfraException();

      $this->validarStrCodigoVerificador($parObjDocumentoDTO, $objInfraException);
      $this->validarStrCrcAssinatura($parObjDocumentoDTO, $objInfraException);

      $strCodigoVerificador = $this->prepararCodigoVerificador($parObjDocumentoDTO->getStrCodigoVerificador());
      
      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retStrNomeSerie();
      $objDocumentoDTO->retStrNumero();
      $objDocumentoDTO->retStrCrcAssinatura();
      $objDocumentoDTO->retStrStaEditor();
      $objDocumentoDTO->retStrStaEstadoProtocolo();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrConteudoAssinatura();
      $objDocumentoDTO->retStrSinBloqueado();
      $objDocumentoDTO->retNumIdUnidadeGeradoraProtocolo();
      $objDocumentoDTO->setStrProtocoloDocumentoFormatado($strCodigoVerificador);

      $objDocumentoDTO2 = $this->consultarRN0005($objDocumentoDTO);
      
      if ($objDocumentoDTO2==null){
        $objDocumentoDTO->unSetStrProtocoloDocumentoFormatado();
        $objDocumentoDTO->setDblIdDocumentoEdoc($strCodigoVerificador);
        $objDocumentoDTO2 = $this->consultarRN0005($objDocumentoDTO);
      }
      
      $objDocumentoDTO = $objDocumentoDTO2;
      
      if ($objDocumentoDTO==null){
        $objInfraException->lancarValidacao('Nenhum documento encontrado para o código verificador informado.');
      }
      
      if ($objDocumentoDTO->getStrStaEstadoProtocolo()==ProtocoloRN::$TE_CANCELADO){
        $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
        $objAtributoAndamentoDTO->retDthAberturaAtividade();
        $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
        $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getDblIdDocumento());
        $objAtributoAndamentoDTO->setNumIdTarefaAtividade(TarefaRN::$TI_CANCELAMENTO_DOCUMENTO);
        $objAtributoAndamentoDTO->setDblIdProtocoloAtividade($objDocumentoDTO->getDblIdProcedimento());

        $objAtributoAndamentoRN = new AtributoAndamentoRN();
        $objAtributoAndamentoDTO = $objAtributoAndamentoRN->consultarRN1366($objAtributoAndamentoDTO);

        $objInfraException->lancarValidacao('Este documento foi cancelado em '.$objAtributoAndamentoDTO->getDthAberturaAtividade().'.');
      }
      
      if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_INTERNO){
        if ($objDocumentoDTO->getStrCrcAssinatura() != $parObjDocumentoDTO->getStrCrcAssinatura()){
          $objInfraException->lancarValidacao('O código CRC informado não confere com a última versão do documento.');
        }
        $objEditorDTO = new EditorDTO();
        $objEditorDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
        $objEditorDTO->setNumIdBaseConhecimento(null);
        $objEditorDTO->setStrSinCabecalho('S');
        $objEditorDTO->setStrSinRodape('S');
        $objEditorDTO->setStrSinIdentificacaoVersao('N');
        $objEditorRN = new EditorRN();
        $objDocumentoDTO->setStrConteudo($objEditorRN->consultarHtmlVersao($objEditorDTO));
      }else if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_EDOC){
        $objEDocRN = new EDocRN();
        $arrParametros = array('CodigoVerificador' => $parObjDocumentoDTO->getStrCodigoVerificador(),
            'CRC' => $parObjDocumentoDTO->getStrCrcAssinatura());

        $objDocumentoDTO->setStrConteudo($objEDocRN->confereAutenticidadeDocumento($arrParametros));
      }else if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO){
          
        if ($objDocumentoDTO->getStrCrcAssinatura() != $parObjDocumentoDTO->getStrCrcAssinatura()){
          $objInfraException->lancarValidacao('O código CRC informado não confere com a última versão do documento.');
        }
        
      }else{
        $objInfraException->lancarValidacao('Nenhum documento encontrado para o código verificador informado.');
      }


      $objAssinaturaDTO = new AssinaturaDTO();
      $objAssinaturaDTO->retNumIdAssinatura();
      $objAssinaturaDTO->retDblIdDocumento();
      $objAssinaturaDTO->retDblIdProcedimentoDocumento();
      $objAssinaturaDTO->retStrNome();
      $objAssinaturaDTO->retStrTratamento();
      $objAssinaturaDTO->retDblCpf();
      $objAssinaturaDTO->retStrNumeroSerieCertificado();
      $objAssinaturaDTO->retDthAberturaAtividade();
      $objAssinaturaDTO->retStrStaFormaAutenticacao();
      $objAssinaturaDTO->retStrSiglaUnidade();
      $objAssinaturaDTO->retStrDescricaoUnidade();
      $objAssinaturaDTO->retStrStaProtocoloProtocolo();
      $objAssinaturaDTO->retStrStaEditorDocumento();
      $objAssinaturaDTO->retStrP7sBase64();
      $objAssinaturaDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
      $objAssinaturaDTO->setOrdStrNomeUsuario(InfraDTO::$TIPO_ORDENACAO_ASC);

      $objAssinaturaRN = new AssinaturaRN();
      $objDocumentoDTO->setArrObjAssinaturaDTO($objAssinaturaRN->listarRN1323($objAssinaturaDTO));
      
      return $objDocumentoDTO;
      
    }catch(Exception $e){
      throw new InfraException('Erro obtendo documento para conferência de autentidade.',$e);
    }
  }
  
  protected function obterDocumentoAssinaturaConectado(AssinaturaDTO $parObjAssinaturaDTO){
    try{

      $ret = null;
      
      $objAssinaturaDTO = new AssinaturaDTO();
      $objAssinaturaDTO->setBolExclusaoLogica(false);
      $objAssinaturaDTO->setNumIdAssinatura($parObjAssinaturaDTO->getNumIdAssinatura());
      $objAssinaturaDTO->setDblIdDocumento($parObjAssinaturaDTO->getDblIdDocumento());
      $objAssinaturaDTO->setStrSinAtivo('N');
      
      $objAssinaturaRN = new AssinaturaRN();
      if (!$objAssinaturaRN->contarRN1324($objAssinaturaDTO)){
        throw new InfraException('Assinatura pendente não encontrada.');
      }
     
      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrConteudoAssinatura();
      $objDocumentoDTO->setDblIdDocumento($parObjAssinaturaDTO->getDblIdDocumento());

      $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);

      if ($objDocumentoDTO==null){
        throw new InfraException('Documento para assinatura não encontrado.');
      }
      
      if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_GERADO){
        $ret = $objDocumentoDTO->getStrConteudoAssinatura();
      }else{
        
        $objAnexoDTO = new AnexoDTO();
        $objAnexoDTO->retNumIdAnexo();
        $objAnexoDTO->retStrNome();
        $objAnexoDTO->retDblIdProtocolo();
        $objAnexoDTO->retDthInclusao();
        $objAnexoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());
        
        $objAnexoRN = new AnexoRN();
        $objAnexoDTO = $objAnexoRN->consultarRN0736($objAnexoDTO);
        
        if ($objAnexoDTO==null){
          throw new InfraException('Anexo do documento para assinatura não encontrado.');
        }

        $strCaminhoAnexo = $objAnexoRN->obterLocalizacao($objAnexoDTO);
        $fp = fopen($strCaminhoAnexo, "rb");
        $ret = fread($fp, filesize($strCaminhoAnexo));
        fclose($fp);        
      }
            
      return $ret;
      
    }catch(Exception $e){
      throw new InfraException('Erro obtendo documento para assinatura.',$e);
    }
  }
  
  private function ehUmaExtensaoDeImagemPermitida($strNomeArquivo){
    switch(InfraUtil::getStrMimeType($strNomeArquivo)){
      case 'image/jpeg':
        return true;
        break;
      case 'image/png':
        return true;
        break;
      case 'image/gif':
        return true;
        break;
      case 'image/bmp':
        return true;
        break;
      default:
        return false;
  
    }
  }
  
  private function processarArquivoOpenOffice($strNomeArquivo){
    
    if (!ConfiguracaoSEI::getInstance()->isSetValor('JODConverter','Servidor') || ConfiguracaoSEI::getInstance()->getValor('JODConverter','Servidor')==''){
      return false;
    }
    
    switch(InfraUtil::getStrMimeType($strNomeArquivo)){
      case 'text/csv':
      case 'application/msword':
      case 'application/vnd.oasis.opendocument.spreadsheet':
      case 'application/vnd.oasis.opendocument.text':
      case 'application/vnd.ms-powerpoint':
      case 'text/rtf':
      case 'application/vnd.ms-excel':
      case 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet':
      case 'application/vnd.openxmlformats-officedocument.spreadsheetml.template':
      case 'application/vnd.openxmlformats-officedocument.presentationml.template':
      case 'application/vnd.openxmlformats-officedocument.presentationml.slideshow':
      case 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
      case 'application/vnd.openxmlformats-officedocument.presentationml.slide':
      case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
      case 'application/vnd.openxmlformats-officedocument.wordprocessingml.template':
      case 'application/vnd.ms-excel.addin.macroEnabled.12':
      case 'application/vnd.ms-excel.sheet.binary.macroEnabled.12':
      case 'application/vnd.oasis.opendocument.text-template':
      case 'application/vnd.oasis.opendocument.presentation':
        return true;
        break;
      default:
        return false;
    }
  }
    
  protected function gerarPdfConectado($parArrObjDocumentoDTO) {
    try{
      
      $objInfraException = new InfraException();

      $arrIdDocumentos = InfraArray::converterArrInfraDTO($parArrObjDocumentoDTO,'IdDocumento');
      
      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrNumero();
      $objDocumentoDTO->retStrNomeSerie();
      $objDocumentoDTO->retStrNumero();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retStrProtocoloProcedimentoFormatado();
      $objDocumentoDTO->retStrSiglaUnidadeGeradoraProtocolo();
      $objDocumentoDTO->retStrStaEditor();
      $objDocumentoDTO->retDblIdDocumentoEdoc();
      $objDocumentoDTO->retStrConteudo();
      $objDocumentoDTO->setDblIdDocumento($arrIdDocumentos, InfraDTO::$OPER_IN);
      
      $arrObjDocumentoDTO = $this->listarRN0008($objDocumentoDTO);
      
      if (count($arrObjDocumentoDTO)==0){
        throw new InfraException('Nenhum documento informado.');
      }
      
      $strProtocoloProcedimentoFormatado = $arrObjDocumentoDTO[0]->getStrProtocoloProcedimentoFormatado();
      
      $arrObjDocumentoDTO = InfraArray::indexarArrInfraDTO($arrObjDocumentoDTO,'IdDocumento');
      
      $strDocumentosGeracaoPdf = '';
      $arrComandoExecucao = array();
      $numParteArquivoPdf = 1;
      $arrArquivoPdfParcial = array();
      $arrArquivoTemp = array();
      $objAnexoRN = new AnexoRN();

      foreach($arrIdDocumentos as $dblIdDocumento){
        $objDocumentoDTO = $arrObjDocumentoDTO[$dblIdDocumento]; 
        if ($strDocumentosGeracaoPdf){
          $strDocumentosGeracaoPdf .= ',"'.addslashes(str_replace('"','',DocumentoINT::montarIdentificacaoArvore($objDocumentoDTO))).'"';
        }else{
          $strDocumentosGeracaoPdf = '"'.addslashes(str_replace('"','',DocumentoINT::montarIdentificacaoArvore($objDocumentoDTO))).'"';
        }        
        $strDocumento = '';
        if ($objDocumentoDTO->getStrStaProtocoloProtocolo() == ProtocoloRN::$TP_DOCUMENTO_GERADO){                   
          if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_EDOC){
            if ($objDocumentoDTO->getDblIdDocumentoEdoc()==null){
              $strDocumento .= 'Documento Edoc '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado() .' não encontrado.';
              $objInfraException->adicionarValidacao('Documento Edoc '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado() .' não encontrado.');
            }else{
              $strDocumento .= EDocINT::montarVisualizacaoDocumento($objDocumentoDTO->getDblIdDocumentoEdoc());
            }
          }else if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_INTERNO){
            $objEditorDTO = new EditorDTO();
            $objEditorDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
            $objEditorDTO->setNumIdBaseConhecimento(null);
            $objEditorDTO->setStrSinCabecalho('S');
            $objEditorDTO->setStrSinRodape('S');
            $objEditorDTO->setStrSinIdentificacaoVersao('S');

            $objEditorRN = new EditorRN();
            $strDocumento .= $objEditorRN->consultarHtmlVersao($objEditorDTO);
          }else{
            // email, por exemplo
            $strDocumento .= '<div style="width:100%;text-align:center;font-weight:bold;">'.DocumentoINT::montarIdentificacaoArvore($objDocumentoDTO).'</div>';
            $strDocumento .= DocumentoINT::formatarExibicaoConteudo(DocumentoINT::$TV_HTML, $objDocumentoDTO->getStrConteudo());
          }
          $strArquivoHtmlTemp = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('.html');
          $arrArquivoTemp[] = $strArquivoHtmlTemp;
          if (file_put_contents($strArquivoHtmlTemp,$strDocumento) === false){
            throw new InfraException('Erro criando arquivo html temporário para criação de pdf.');
          }
          $strArquivoPdfParcial = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('-parte'.$numParteArquivoPdf++.'.pdf');
          $arrArquivoPdfParcial[] = $strArquivoPdfParcial;
          $arrComandoExecucao[] = dirname(__FILE__).'/../'.DIR_FERRAMENTAS.'/wkhtmltopdf-amd64 --quiet --title processo-'.InfraUtil::retirarFormatacao($objDocumentoDTO->getStrProtocoloProcedimentoFormatado()) .' ' .$strArquivoHtmlTemp.' ' .$strArquivoPdfParcial .' 2>&1';
        }else if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO){
          $objAnexoDTO = new AnexoDTO();
          $objAnexoDTO->retNumIdAnexo();
          $objAnexoDTO->retStrNome();
          $objAnexoDTO->retDthInclusao();
          $objAnexoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());
          $objAnexoRN = new AnexoRN();
          $objAnexoDTO = $objAnexoRN->consultarRN0736($objAnexoDTO);
          if (InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'application/pdf' || InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'text/html' || InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'text/plain' || $this->ehUmaExtensaoDeImagemPermitida($objAnexoDTO->getStrNome()) || $this->processarArquivoOpenOffice($objAnexoDTO->getStrNome())){
            if ($objAnexoDTO==null){
              $objInfraException->adicionarValidacao('Documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado() .' não encontrado.');
            }else{

              if (InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'application/pdf'){
                $strArquivoPdfParcial = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('-parte'.$numParteArquivoPdf++.'.pdf');
                if ($this->copiarArquivo($objAnexoRN->obterLocalizacao($objAnexoDTO), $strArquivoPdfParcial) === false){
                  throw new InfraException('Erro criando arquivo pdf temporário para criação de pdf.');
                }
                $arrArquivoPdfParcial[] = $strArquivoPdfParcial;
              }else if (InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'text/html'){
                $strArquivoHtmlTemp = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('.html');
                $arrArquivoTemp[] = $strArquivoHtmlTemp;
                if ($this->copiarArquivo($objAnexoRN->obterLocalizacao($objAnexoDTO), $strArquivoHtmlTemp) === false){
                  throw new InfraException('Erro criando arquivo html temporário para criação de pdf.');
                }
                $strArquivoPdfParcial = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('-parte'.$numParteArquivoPdf++.'.pdf');
                $arrArquivoPdfParcial[] = $strArquivoPdfParcial;
                $arrComandoExecucao[] = dirname(__FILE__).'/../'.DIR_FERRAMENTAS.'/wkhtmltopdf-amd64 --quiet --title processo-'.InfraUtil::retirarFormatacao($objDocumentoDTO->getStrProtocoloProcedimentoFormatado()) .' ' .$strArquivoHtmlTemp  .' ' .$strArquivoPdfParcial .' 2>&1';
              }else if (InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) == 'text/plain'){
                $strCaminhoCompletoArquivoTxt = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('.txt');
                if ($this->copiarArquivo($objAnexoRN->obterLocalizacao($objAnexoDTO), $strCaminhoCompletoArquivoTxt) === false){
                  throw new InfraException('Erro criando arquivo txt temporário para criação de pdf.');
                }
                $strArquivoPdfParcial = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('-parte'.$numParteArquivoPdf++.'.pdf');
                $arrArquivoPdfParcial[] = $strArquivoPdfParcial;
                $arrComandoExecucao[] = dirname(__FILE__).'/../'.DIR_FERRAMENTAS.'/wkhtmltopdf-amd64 --quiet --title processo-'.InfraUtil::retirarFormatacao($objDocumentoDTO->getStrProtocoloProcedimentoFormatado()) .' ' .$strCaminhoCompletoArquivoTxt  .' ' .$strArquivoPdfParcial .' 2>&1';
              }else if ($this->ehUmaExtensaoDeImagemPermitida($objAnexoDTO->getStrNome())){
                // criar imagem temp
                $strCaminhoCompletoArquivoImagem = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('.imagem');
                $arrArquivoTemp[] = $strCaminhoCompletoArquivoImagem;
                if ($this->copiarArquivo($objAnexoRN->obterLocalizacao($objAnexoDTO), $strCaminhoCompletoArquivoImagem) === false){
                  throw new InfraException('Erro criando arquivo de imagem temporária para criação de html.');
                }

                // criar html que contenha a imagem
                $strDocumentoHTML = "<html>\n<head>\n<title>Anexo Imagem</title>\n";
                $strDocumentoHTML .= "</head>\n<body>\n";
                $strDocumentoHTML .= "<img src=\"". $strCaminhoCompletoArquivoImagem . "\">";
                $strDocumentoHTML .= "</body>\n</html>";
                $strArquivoHtmlTemp = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('.html');
                $arrArquivoTemp[] = $strArquivoHtmlTemp;
                if (file_put_contents($strArquivoHtmlTemp,$strDocumentoHTML) === false){
                  throw new InfraException('Erro criando arquivo html com imagem temporário para criação de pdf.');
                }
                $strArquivoPdfParcial = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('-parte'.$numParteArquivoPdf++.'.pdf');
                $arrArquivoPdfParcial[] = $strArquivoPdfParcial;
                $arrComandoExecucao[] = dirname(__FILE__).'/../'.DIR_FERRAMENTAS.'/wkhtmltopdf-amd64 --quiet --title processo-'.InfraUtil::retirarFormatacao($objDocumentoDTO->getStrProtocoloProcedimentoFormatado()) .' ' .$strArquivoHtmlTemp  .' ' .$strArquivoPdfParcial .' 2>&1';

              }else if ($this->processarArquivoOpenOffice($objAnexoDTO->getStrNome())){
                $strCaminhoCompletoArquivoOpenOffice = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('.oo');
                $arrArquivoTemp[] = $strCaminhoCompletoArquivoOpenOffice;
                if ($this->copiarArquivo($objAnexoRN->obterLocalizacao($objAnexoDTO), $strCaminhoCompletoArquivoOpenOffice) === false){
                  throw new InfraException('Erro criando arquivo openoffice temporário para criação de pdf.');
                }
                $strArquivoPdfParcial = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario('-parte'.$numParteArquivoPdf++.'.pdf');
                $arrArquivoPdfParcial[] = $strArquivoPdfParcial;
                $arrComandoExecucao[] = 'wget --no-proxy --quiet ' .ConfiguracaoSEI::getInstance()->getValor('JODConverter','Servidor') .' --post-file=' .$strCaminhoCompletoArquivoOpenOffice .' --header="Content-Type: ' .InfraUtil::getStrMimeType($objAnexoDTO->getStrNome()) .'" --header="Accept: application/pdf" --output-document=' .$strArquivoPdfParcial .' 2>&1';
              }
            }
          }
        }else{
          $objInfraException->adicionarValidacao('Não foi possível detectar o tipo do documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado());
        }
      }

      foreach($arrComandoExecucao as $strComandoExecucao){
        $ret = shell_exec($strComandoExecucao);
        if ($ret != ''){
          //LogSEI::getInstance()->gravar("Erro gerando PDF.\n\nComando:\n".$strComandoExecucao."\n\nRetorno:\n".$ret);
          throw new InfraException('Erro gerando PDF.', null, 'Comando:\n'.$strComandoExecucao.'\n\nRetorno:\n'.$ret);
        }
      }           
  
  
      $objInfraException->lancarValidacoes();

      $strCaminhoCompletoArquivoPdfTotal = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario();
      $strComandoExecucao = "LANG=pt_BR.iso-8859-1; java -jar " .dirname(__FILE__)."/../".DIR_FERRAMENTAS."/itextmerge.jar -p " .$strProtocoloProcedimentoFormatado ." -o " .$strCaminhoCompletoArquivoPdfTotal ." -d " .escapeshellcmd($strDocumentosGeracaoPdf)." -i ".implode(',',$arrArquivoPdfParcial) ." 2>&1";

      $ret = shell_exec($strComandoExecucao);

      if ($ret != ''){
      	if ($ret = preg_match('/<INFRA_VALIDACAO>(.*)<\/INFRA_VALIDACAO>/', $ret, $matches)){      			      		
      		$objInfraException = new InfraException();
      		$objInfraException->lancarValidacao('Erro gerando PDF.\n\nRetorno:\n'.$matches[1].'\n\nTente regerar o pdf sem o documento problemático.');      		
      	}else{
        	//LogSEI::getInstance()->gravar("Erro gerando PDF.\n\nComando:\n".$strComandoExecucao."\n\nRetorno:\n".$ret);
        	throw new InfraException('Erro gerando PDF.', null, 'Comando:\n'.$strComandoExecucao.'\n\nRetorno:\n'.$ret);
      	}
      }

      foreach($arrArquivoPdfParcial as $strArquivoPdfParcial){
        unlink($strArquivoPdfParcial);
      }

      foreach($arrArquivoTemp as $strArquivoTemp){
        unlink($strArquivoTemp);
      }

      if (file_exists($strCaminhoCompletoArquivoPdfTotal.'-watermarked.pdf')){
        unlink($strCaminhoCompletoArquivoPdfTotal.'-watermarked.pdf');
      }

      $objAnexoDTO = new AnexoDTO();
      $arrNomeArquivo = explode('/',$strCaminhoCompletoArquivoPdfTotal);
      $objAnexoDTO->setStrNome($arrNomeArquivo[count($arrNomeArquivo)-1]);

      return $objAnexoDTO;
      
    }catch(Exception $e){
      throw new InfraException('Erro gerando pdf.',$e);
    }
  }

  protected function gerarZipConectado($parArrObjDocumentoDTO) {
    try{

      $objInfraException = new InfraException();

      $arrIdDocumentos = InfraArray::converterArrInfraDTO($parArrObjDocumentoDTO,'IdDocumento');

      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retDblIdProcedimento();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrNumero();
      $objDocumentoDTO->retStrNomeSerie();
      $objDocumentoDTO->retStrNumero();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->retStrProtocoloProcedimentoFormatado();
      $objDocumentoDTO->retStrSiglaUnidadeGeradoraProtocolo();
      $objDocumentoDTO->retStrStaEditor();
      $objDocumentoDTO->retDblIdDocumentoEdoc();
      $objDocumentoDTO->retStrConteudo();
      $objDocumentoDTO->setDblIdDocumento($arrIdDocumentos, InfraDTO::$OPER_IN);

      $arrObjDocumentoDTO = $this->listarRN0008($objDocumentoDTO);

      if (count($arrObjDocumentoDTO)==0){
        throw new InfraException('Nenhum documento informado.');
      }

      $objAnexoRN = new AnexoRN();
      $strCaminhoCompletoArquivoZip = DIR_SEI_TEMP.'/'.$objAnexoRN->gerarNomeArquivoTemporario();

      $zipFile= new ZipArchive();
      $zipFile->open($strCaminhoCompletoArquivoZip, ZIPARCHIVE::CREATE);

      $arrObjDocumentoDTO = InfraArray::indexarArrInfraDTO($arrObjDocumentoDTO,'IdDocumento');
      $numCasas=floor(log10(count($arrObjDocumentoDTO)))+1;
      $numSequencial = 0;

      foreach($arrIdDocumentos as $dblIdDocumento){
        $numSequencial++;
        $numDocumento=str_pad($numSequencial, $numCasas, "0", STR_PAD_LEFT);
        $objDocumentoDTO = $arrObjDocumentoDTO[$dblIdDocumento];
        $strDocumento = '';
        if ($objDocumentoDTO->getStrStaProtocoloProtocolo() == ProtocoloRN::$TP_DOCUMENTO_GERADO){
          if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_EDOC){
            if ($objDocumentoDTO->getDblIdDocumentoEdoc()==null){
              $strDocumento .= 'Documento Edoc '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado() .' não encontrado.';
              $objInfraException->adicionarValidacao('Documento Edoc '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado() .' não encontrado.');
            }else{
              $strDocumento .= EDocINT::montarVisualizacaoDocumento($objDocumentoDTO->getDblIdDocumentoEdoc());
            }
          }else if ($objDocumentoDTO->getStrStaEditor()==EditorRN::$TE_INTERNO){
            $objEditorDTO = new EditorDTO();
            $objEditorDTO->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
            $objEditorDTO->setNumIdBaseConhecimento(null);
            $objEditorDTO->setStrSinCabecalho('S');
            $objEditorDTO->setStrSinRodape('S');
            $objEditorDTO->setStrSinIdentificacaoVersao('S');

            $objEditorRN = new EditorRN();
            $strDocumento .= $objEditorRN->consultarHtmlVersao($objEditorDTO);
          }else{
            // email, por exemplo
            $strDocumento .= '<div style="width:100%;text-align:center;font-weight:bold;">'.DocumentoINT::montarIdentificacaoArvore($objDocumentoDTO).'</div>';
            $strDocumento .= DocumentoINT::formatarExibicaoConteudo(DocumentoINT::$TV_HTML, $objDocumentoDTO->getStrConteudo());
          }
          $strNomeArquivo = $objDocumentoDTO->getStrProtocoloDocumentoFormatado().'-'.$objDocumentoDTO->getStrNomeSerie();
          if (!InfraString::isBolVazia($objDocumentoDTO->getStrNumero())){
            $strNomeArquivo .= '-'.$objDocumentoDTO->getStrNumero();
          }
          $strNomeArquivo .='.html';

          if ($zipFile->addFromString('['.$numDocumento.']-'.InfraUtil::formatarNomeArquivo($strNomeArquivo),$strDocumento) === false){
            throw new InfraException('Erro adicionando conteúdo html ao zip.');
          }
        }else if ($objDocumentoDTO->getStrStaProtocoloProtocolo()==ProtocoloRN::$TP_DOCUMENTO_RECEBIDO){
          $objAnexoDTO = new AnexoDTO();
          $objAnexoDTO->retNumIdAnexo();
          $objAnexoDTO->retStrNome();
          $objAnexoDTO->retDthInclusao();
          $objAnexoDTO->setDblIdProtocolo($objDocumentoDTO->getDblIdDocumento());
          $objAnexoRN = new AnexoRN();
          $objAnexoDTO = $objAnexoRN->consultarRN0736($objAnexoDTO);
          if ($objAnexoDTO==null){
            $objInfraException->adicionarValidacao('Documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado() .' não encontrado.');
          }else{
            $ext = explode('.',$objAnexoDTO->getStrNome());
            $ext = strtolower($ext[count($ext)-1]);
            $strNomeArquivo = $objDocumentoDTO->getStrProtocoloDocumentoFormatado().'-'.$objDocumentoDTO->getStrNomeSerie();
            if (!InfraString::isBolVazia($objDocumentoDTO->getStrNumero())){
              $strNomeArquivo .= '-'.$objDocumentoDTO->getStrNumero();
            }
            $strNomeArquivo .='.'.$ext;
            if ($zipFile->addFile($objAnexoRN->obterLocalizacao($objAnexoDTO),'['.$numDocumento.']-'.InfraUtil::formatarNomeArquivo($strNomeArquivo)) === false){
              throw new InfraException('Erro adicionando arquivo externo ao zip.');
            }
          }
        }else{
          $objInfraException->adicionarValidacao('Não foi possível detectar o tipo do documento '.$objDocumentoDTO->getStrProtocoloDocumentoFormatado());
        }
      }
      $objInfraException->lancarValidacoes();

      if ($zipFile->close() === false) {
        throw new InfraException('Não foi possível fechar arquivo zip.');
      }

      $objAnexoDTO = new AnexoDTO();
      $arrNomeArquivo = explode('/',$strCaminhoCompletoArquivoZip);
      $objAnexoDTO->setStrNome($arrNomeArquivo[count($arrNomeArquivo)-1]);

      return $objAnexoDTO;

    }catch(Exception $e){
      throw new InfraException('Erro gerando zip.',$e);
    }
  }

  private function copiarArquivo($strOriginal,$strCopia){
    $fpOriginal = fopen($strOriginal, "rb");
    $fpCopia = fopen($strCopia,"wb");
    while (!feof($fpOriginal)) {
      if (fwrite($fpCopia, fread($fpOriginal, TAM_BLOCO_LEITURA_ARQUIVO))===false){
        return false;
      }
    }
    fclose($fpCopia);
    fclose($fpOriginal);
    return true;
  }
  
  public function mover(MoverDocumentoDTO $objMoverDocumentoDTO){

    $bolAcumulacaoPrevia = FeedSEIProtocolos::getInstance()->isBolAcumularFeeds();

    FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(true);

    $objRelProtocoloProtodoloDTO = $this->moverInterno($objMoverDocumentoDTO);

    $objIndexacaoDTO = new IndexacaoDTO();
    $objProtocoloDTO = new ProtocoloDTO();
    $objProtocoloDTO->setDblIdProtocolo($objMoverDocumentoDTO->getDblIdDocumento());
    $objIndexacaoDTO->setArrObjProtocoloDTO(array($objProtocoloDTO));
    $objIndexacaoDTO->setStrStaOperacao(IndexacaoRN::$TO_ALTERACAO_PROTOCOLO_METADADOS);
    
    $objIndexacaoRN = new IndexacaoRN();
    $objIndexacaoRN->indexarProtocolo($objIndexacaoDTO);

    if (!$bolAcumulacaoPrevia){
      FeedSEIProtocolos::getInstance()->setBolAcumularFeeds(false);
      FeedSEIProtocolos::getInstance()->indexarFeeds();
    }

    return $objRelProtocoloProtodoloDTO;
        
  }
  
  protected function moverInternoControlado(MoverDocumentoDTO $objMoverDocumentoDTO){
    try {
  
      //Valida Permissao
      SessaoSEI::getInstance()->validarAuditarPermissao('documento_mover',__METHOD__,$objMoverDocumentoDTO);
  
      //Regras de Negocio
      $objInfraException = new InfraException();
       
      $objProtocoloRN = new ProtocoloRN();
      $objRelProtocoloProtocoloRN = new RelProtocoloProtocoloRN();
      $objAtividadeRN = new AtividadeRN();
  
      $objProtocoloDTOAtual = new ProtocoloDTO();
      $objProtocoloDTOAtual->retDblIdProtocolo();
      $objProtocoloDTOAtual->retStrStaProtocolo();
      $objProtocoloDTOAtual->retStrStaEstado();
      $objProtocoloDTOAtual->retStrStaNivelAcessoGlobal();
      $objProtocoloDTOAtual->retStrProtocoloFormatado();
      $objProtocoloDTOAtual->setDblIdProtocolo($objMoverDocumentoDTO->getDblIdProcedimentoOrigem());
  
      $objProtocoloDTOAtual = $objProtocoloRN->consultarRN0186($objProtocoloDTOAtual);
      
      if ($objProtocoloDTOAtual==null){
        throw new InfraException('Processo origem não encontrado.');
      }
  
      if($objProtocoloDTOAtual->getStrStaProtocolo() != ProtocoloRN::$TP_PROCEDIMENTO){
        $objInfraException->lancarValidacao('Protocolo '.$objProtocoloDTOAtual->getStrProtocoloFormatado().' não é um processo.');
      }
  
      if($objProtocoloDTOAtual->getStrStaNivelAcessoGlobal() == ProtocoloRN::$NA_SIGILOSO){
        $objInfraException->lancarValidacao('Processo '.$objProtocoloDTOAtual->getStrProtocoloFormatado().' não pode ser sigiloso.');
      }
  
      	
      $objProtocoloDTODestino = new ProtocoloDTO();
      $objProtocoloDTODestino->retDblIdProtocolo();
      $objProtocoloDTODestino->retStrStaProtocolo();
      $objProtocoloDTODestino->retStrStaEstado();
      $objProtocoloDTODestino->retStrProtocoloFormatado();
      $objProtocoloDTODestino->retStrStaNivelAcessoGlobal();
      $objProtocoloDTODestino->setDblIdProtocolo($objMoverDocumentoDTO->getDblIdProcedimentoDestino());
      	
      $objProtocoloDTODestino = $objProtocoloRN->consultarRN0186($objProtocoloDTODestino);
      	
      if ($objProtocoloDTODestino==null){
        throw new InfraException('Processo destino não encontrado.');
      }
      
      if($objProtocoloDTODestino->getStrStaProtocolo() != ProtocoloRN::$TP_PROCEDIMENTO){
        $objInfraException->lancarValidacao('Protocolo '.$objProtocoloDTODestino->getStrProtocoloFormatado().' não é um processo.');
      }
      	
      if ($objProtocoloDTOAtual->getDblIdProtocolo() == $objProtocoloDTODestino->getDblIdProtocolo()){
        $objInfraException->lancarValidacao('Processo destino deve ser diferente do processo de origem.');
      }
      	
      if($objProtocoloDTODestino->getStrStaNivelAcessoGlobal() == ProtocoloRN::$NA_SIGILOSO){
        $objInfraException->lancarValidacao('Processo '.$objProtocoloDTODestino->getStrProtocoloFormatado().' não pode ser sigiloso.');
      }
      	
      if($objProtocoloDTODestino->getStrStaEstado() == ProtocoloRN::$TE_PROCEDIMENTO_SOBRESTADO){
        $objInfraException->lancarValidacao('Processo '.$objProtocoloDTODestino->getStrProtocoloFormatado().' não pode estar sobrestado.');
      }
      	
      if($objProtocoloDTODestino->getStrStaEstado() == ProtocoloRN::$TE_PROCEDIMENTO_ANEXADO){
        $objInfraException->lancarValidacao('Processo '.$objProtocoloDTODestino->getStrProtocoloFormatado().' não pode estar anexado a outro processo.');
      }
  
      $objDocumentoDTO = new DocumentoDTO();
      $objDocumentoDTO->retDblIdDocumento();
      $objDocumentoDTO->retStrStaProtocoloProtocolo();
      $objDocumentoDTO->retStrProtocoloDocumentoFormatado();
      $objDocumentoDTO->setDblIdDocumento($objMoverDocumentoDTO->getDblIdDocumento());
      $objDocumentoDTO = $this->consultarRN0005($objDocumentoDTO);
      
      if ($objDocumentoDTO==null){
        throw new InfraException('Documento não encontrado.');
      }
      
      if($objDocumentoDTO->getStrStaProtocoloProtocolo() != ProtocoloRN::$TP_DOCUMENTO_RECEBIDO){
        $objInfraException->lancarValidacao('Somente documentos externos podem ser movidos.');
      }
      
      //muda o processo do documento
      $objDocumentoDTO2 = new DocumentoDTO();
      $objDocumentoDTO2->setDblIdProcedimento($objMoverDocumentoDTO->getDblIdProcedimentoDestino());
      $objDocumentoDTO2->setDblIdDocumento($objDocumentoDTO->getDblIdDocumento());
      
      $objDocumentoBD = new DocumentoBD($this->getObjInfraIBanco());
      $objDocumentoBD->alterar($objDocumentoDTO2);

      //muda o tipo da associacao do documento com o processo antigo
      $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
      $objRelProtocoloProtocoloDTO->retDblIdRelProtocoloProtocolo();
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo1($objMoverDocumentoDTO->getDblIdProcedimentoOrigem());
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objMoverDocumentoDTO->getDblIdDocumento());
      $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_DOCUMENTO_ASSOCIADO);
      $objRelProtocoloProtocoloDTOAtual = $objRelProtocoloProtocoloRN->consultarRN0841($objRelProtocoloProtocoloDTO);
      $objRelProtocoloProtocoloDTOAtual->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_DOCUMENTO_MOVIDO);
      $objRelProtocoloProtocoloRN->alterar($objRelProtocoloProtocoloDTOAtual);

      $objProtocoloDTO = new ProtocoloDTO();
      $objProtocoloDTO->setDblIdProcedimento($objMoverDocumentoDTO->getDblIdProcedimentoDestino());
      $numSequencia = $objProtocoloRN->obterSequencia($objProtocoloDTO);
      
      //Criar associação entre o documento e o processo novo
      $objRelProtocoloProtocoloDTO = new RelProtocoloProtocoloDTO();
      $objRelProtocoloProtocoloDTO->setDblIdRelProtocoloProtocolo(null);
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo1($objMoverDocumentoDTO->getDblIdProcedimentoDestino());
      $objRelProtocoloProtocoloDTO->setDblIdProtocolo2($objMoverDocumentoDTO->getDblIdDocumento());
      $objRelProtocoloProtocoloDTO->setNumIdUsuario(SessaoSEI::getInstance()->getNumIdUsuario());
      $objRelProtocoloProtocoloDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objRelProtocoloProtocoloDTO->setStrStaAssociacao(RelProtocoloProtocoloRN::$TA_DOCUMENTO_ASSOCIADO);
      $objRelProtocoloProtocoloDTO->setNumSequencia($numSequencia);
      $objRelProtocoloProtocoloDTO->setDthAssociacao(InfraData::getStrDataHoraAtual());
      $objRelProtocoloProtocoloDTODestino = $objRelProtocoloProtocoloRN->cadastrarRN0839($objRelProtocoloProtocoloDTO);
      
      //remove acessos atuais do documento
      $objAcessoDTO = new AcessoDTO();
      $objAcessoDTO->retNumIdAcesso();
      $objAcessoDTO->setDblIdProtocolo($objMoverDocumentoDTO->getDblIdDocumento());
      $objAcessoRN = new AcessoRN();
      $objAcessoRN->excluir($objAcessoRN->listar($objAcessoDTO));
      
             
      //recalcular nível de acesso do processo origem
      $objMudarNivelAcessoDTO = new MudarNivelAcessoDTO();
      $objMudarNivelAcessoDTO->setStrStaOperacao(ProtocoloRN::$TMN_MOVIMENTACAO);
      $objMudarNivelAcessoDTO->setDblIdProtocolo($objMoverDocumentoDTO->getDblIdProcedimentoOrigem());
      $objMudarNivelAcessoDTO->setStrStaNivel(null);
      $objProtocoloRN->mudarNivelAcesso($objMudarNivelAcessoDTO);      

      //recalcular nível de acesso do processo destino
      $objMudarNivelAcessoDTO = new MudarNivelAcessoDTO();
      $objMudarNivelAcessoDTO->setStrStaOperacao(ProtocoloRN::$TMN_MOVIMENTACAO);
      $objMudarNivelAcessoDTO->setDblIdProtocolo($objMoverDocumentoDTO->getDblIdProcedimentoDestino());
      $objMudarNivelAcessoDTO->setStrStaNivel(null);
      $strStaNivelAcessoGlobal = $objProtocoloRN->mudarNivelAcesso($objMudarNivelAcessoDTO);      
      
      //Associar o documento nesta unidade e nas unidades que tem acesso ao processo
      $objAssociarDTO = new AssociarDTO();
      $objAssociarDTO->setDblIdProcedimento($objMoverDocumentoDTO->getDblIdProcedimentoDestino());
      $objAssociarDTO->setDblIdDocumento($objMoverDocumentoDTO->getDblIdDocumento());
      $objAssociarDTO->setNumIdUnidade(null);
      $objAssociarDTO->setNumIdUsuario(null);
      $objAssociarDTO->setStrStaNivelAcessoGlobal($strStaNivelAcessoGlobal);
      $objProtocoloRN->associarRN0982($objAssociarDTO);
      
      $arrObjAtributoAndamentoDTO = array();
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrValor($objDocumentoDTO->getStrProtocoloDocumentoFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getDblIdDocumento());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('PROCESSO');
      $objAtributoAndamentoDTO->setStrValor($objProtocoloDTODestino->getStrProtocoloFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objProtocoloDTODestino->getDblIdProtocolo());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;

      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('MOTIVO');
      $objAtributoAndamentoDTO->setStrValor($objMoverDocumentoDTO->getStrMotivo());
      $objAtributoAndamentoDTO->setStrIdOrigem($objRelProtocoloProtocoloDTOAtual->getDblIdRelProtocoloProtocolo());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      
      $objAtividadeDTO = new AtividadeDTO();
      $objAtividadeDTO->setDblIdProtocolo($objProtocoloDTOAtual->getDblIdProtocolo());
      $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_DOCUMENTO_MOVIDO_PARA_PROCESSO);
      $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);
      $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);

      $arrObjAtributoAndamentoDTO = array();
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('DOCUMENTO');
      $objAtributoAndamentoDTO->setStrValor($objDocumentoDTO->getStrProtocoloDocumentoFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objDocumentoDTO->getDblIdDocumento());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('PROCESSO');
      $objAtributoAndamentoDTO->setStrValor($objProtocoloDTOAtual->getStrProtocoloFormatado());
      $objAtributoAndamentoDTO->setStrIdOrigem($objProtocoloDTOAtual->getDblIdProtocolo());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
       
      $objAtributoAndamentoDTO = new AtributoAndamentoDTO();
      $objAtributoAndamentoDTO->setStrNome('MOTIVO');
      $objAtributoAndamentoDTO->setStrValor($objMoverDocumentoDTO->getStrMotivo());
      $objAtributoAndamentoDTO->setStrIdOrigem($objRelProtocoloProtocoloDTODestino->getDblIdRelProtocoloProtocolo());
      $arrObjAtributoAndamentoDTO[] = $objAtributoAndamentoDTO;
      
      $objAtividadeDTO = new AtividadeDTO();
      $objAtividadeDTO->setDblIdProtocolo($objProtocoloDTODestino->getDblIdProtocolo());
      $objAtividadeDTO->setNumIdUnidade(SessaoSEI::getInstance()->getNumIdUnidadeAtual());
      $objAtividadeDTO->setNumIdTarefa(TarefaRN::$TI_DOCUMENTO_MOVIDO_DO_PROCESSO);
      $objAtividadeDTO->setArrObjAtributoAndamentoDTO($arrObjAtributoAndamentoDTO);
      $objAtividadeRN->gerarInternaRN0727($objAtividadeDTO);
      
      return $objRelProtocoloProtocoloDTOAtual;
      //Auditoria
  
    }catch(Exception $e){
      throw new InfraException('Erro movendo documento.',$e);
    }
  }
}
?>