Exemple #1
0
        public bool EmPosse(int processo, int msg = 0)
        {
            try
            {
                if (!_da.EmPosse(processo))
                {
                    switch (msg)
                    {
                    case 1:
                        Validacao.Add(Mensagem.Processo.PosseProcessoNecessariaEditar);
                        break;

                    case 2:
                        Validacao.Add(Mensagem.Processo.PosseProcessoNecessaria);
                        break;

                    default:
                        break;
                    }

                    return(false);
                }

                return(true);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }
            return(false);
        }
Exemple #2
0
        public bool ValidarVisualizarAlterarSituacao(CARSolicitacao entidade, int funcionarioId)
        {
            if (entidade.SituacaoId == (int)eCARSolicitacaoSituacao.Invalido ||
                entidade.SituacaoId == (int)eCARSolicitacaoSituacao.EmCadastro ||
                entidade.SituacaoId == (int)eCARSolicitacaoSituacao.Nulo ||
                entidade.SituacaoId == (int)eCARSolicitacaoSituacao.SubstituidoPeloTituloCAR ||
                entidade.SituacaoId == (int)eCARSolicitacaoSituacao.Suspenso)
            {
                return(true);
            }

            if (_validar.validarFuncionario(funcionarioId, (int)ePermissao.CadastroAmbientalRuralSolicitacaoInvalida))
            {
                return(false);
            }
            else
            {
                if (!(entidade.Protocolo.Id.GetValueOrDefault() > 0 && _protocoloDa.EmPosse(entidade.Protocolo.Id.GetValueOrDefault())))
                {
                    return(true);
                }
                else
                {
                    if (entidade.SituacaoId != (int)eCARSolicitacaoSituacao.Pendente)
                    {
                        return(true);
                    }
                }
            }

            return(false);
        }
        public bool ValidarAcesso(Fiscalizacao fiscalizacao)
        {
            if (fiscalizacao.Situacao == eFiscalizacaoSituacao.EmAndamento ||
                fiscalizacao.Situacao == eFiscalizacaoSituacao.CadastroConcluido ||
                fiscalizacao.Situacao == eFiscalizacaoSituacao.CancelarConclusao)
            {
                Validacao.Add(Mensagem.Acompanhamento.Acompanhamentos);
                return(false);
            }

            if (!_protocoloDa.EmPosse(fiscalizacao.ProtocoloId))
            {
                Validacao.Add(Mensagem.Fiscalizacao.PosseProcessoNecessaria);
                return(false);
            }

            return(Validacao.EhValido);
        }
        public bool AlterarSituacaoAbrir(Titulo titulo)
        {
            #region Validacao de Posse
            if (titulo.Protocolo.Id > 0 && !_protocoloDa.EmPosse(titulo.Protocolo.Id.Value))
            {
                Validacao.Add((titulo.Protocolo.IsProcesso) ? Mensagem.TituloAlterarSituacao.ProcessoPosseAltSituacao : Mensagem.TituloAlterarSituacao.DocumentoPosseAltSituacao);
            }
            #endregion

            return(Validacao.EhValido);
        }
Exemple #5
0
        public bool ValidarAcesso(Fiscalizacao fiscalizacao)
        {
            if (fiscalizacao.Autuante.Id != FiscalizacaoBus.User.EtramiteIdentity.FuncionarioId)
            {
                Validacao.Add(Mensagem.NotificacaoMsg.AgenteFiscalInvalido);
            }

            if (fiscalizacao.ProtocoloId > 0)
            {
                if (!_protocoloDa.EmPosse(fiscalizacao.ProtocoloId))
                {
                    Validacao.Add(Mensagem.Fiscalizacao.PosseProcessoNecessaria);
                }
            }

            return(Validacao.EhValido);
        }
        public bool PodeAlterarSituacao(Fiscalizacao fiscalizacao)
        {
            eFiscalizacaoSituacao situacaoAtual = (eFiscalizacaoSituacao)fiscalizacao.SituacaoId;

            if (situacaoAtual == eFiscalizacaoSituacao.EmAndamento)
            {
                Validacao.Add(Mensagem.Fiscalizacao.SituacaoEmAndamentoNaoPodeAlterar);
                return(Validacao.EhValido);
            }

            ProtocoloDa protocoloDA = new ProtocoloDa();

            if (situacaoAtual == eFiscalizacaoSituacao.Protocolado ||
                situacaoAtual == eFiscalizacaoSituacao.MultaPaga ||
                situacaoAtual == eFiscalizacaoSituacao.ComDecisaoManutencaoMulta ||
                situacaoAtual == eFiscalizacaoSituacao.ComDecisaoMultaCancelada ||
                situacaoAtual == eFiscalizacaoSituacao.DefesaApresentada ||
                situacaoAtual == eFiscalizacaoSituacao.EmParcelamento ||
                situacaoAtual == eFiscalizacaoSituacao.EnviadoParaSEAMA ||
                situacaoAtual == eFiscalizacaoSituacao.InscritoEmDividaAtiva ||
                situacaoAtual == eFiscalizacaoSituacao.InscritoNoCADIN ||
                situacaoAtual == eFiscalizacaoSituacao.ParceladoPagamentoAtrasado ||
                situacaoAtual == eFiscalizacaoSituacao.ParceladopagamentoEmDia ||
                situacaoAtual == eFiscalizacaoSituacao.RecursoApresentado)
            {
                if (!protocoloDA.EmPosse(fiscalizacao.ProtocoloId))
                {
                    Validacao.Add(Mensagem.Fiscalizacao.PosseProcessoNecessaria);
                    return(Validacao.EhValido);
                }
            }

            if ((fiscalizacao.Autuante.Id != FiscalizacaoBus.User.EtramiteIdentity.FuncionarioId && fiscalizacao.SituacaoId < (int)eFiscalizacaoSituacao.Protocolado) &&
                !(User as EtramitePrincipal).IsInRole(ePermissao.FiscalizacaoSemPosse.ToString()))
            {
                Validacao.Add(Mensagem.Fiscalizacao.AgenteFiscalInvalido("alterar"));
            }

            return(Validacao.EhValido);
        }
        public bool Salvar(CARSolicitacao entidade)
        {
            if (!_protocoloDa.EmPosse(entidade.Protocolo.Id.GetValueOrDefault()))
            {
                Validacao.Add(Mensagem.CARSolicitacao.ProtocoloPosse);
                return(false);
            }

            if (entidade.SituacaoId <= 0)
            {
                Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoSituacaoObrigatoria);
            }

            if (entidade.Protocolo == null || entidade.Protocolo.Id.GetValueOrDefault(0) <= 0)
            {
                Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoProtocoloObrigatorio);
            }

            if (entidade.Requerimento.Id <= 0)
            {
                Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoRequerimentoObrigatorio);
            }

            _requerimentoValidar.Existe(entidade.Requerimento.Id);

            if (entidade.SituacaoId == (int)eCARSolicitacaoSituacao.EmCadastro)
            {
                if (entidade.Protocolo.Id.GetValueOrDefault() != entidade.ProtocoloSelecionado.Id.GetValueOrDefault())
                {
                    if (!_da.ExisteProtocoloAssociado(entidade.Protocolo.Id.GetValueOrDefault(), entidade.ProtocoloSelecionado.Id.GetValueOrDefault()))
                    {
                        Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoRequerimentoDesassociadoProtocolo(entidade.Requerimento.Numero.ToString()));
                    }
                }

                String numeroProtocoloPai = _da.ObterNumeroProtocoloPai(entidade.Protocolo.Id.GetValueOrDefault(0));
                if (!String.IsNullOrWhiteSpace(numeroProtocoloPai))
                {
                    Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoProtocoloApensadoEmOutroProcesso(numeroProtocoloPai));
                }
            }

            #region Atividade

            if (entidade.Atividade.Id <= 0)
            {
                Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoAtividadeObrigatoria);
            }
            else
            {
                if (entidade.Atividade.Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.CadastroAmbientalRural))
                {
                    Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoAtividadeInvalida);
                }
            }

            #endregion Atividade

            #region Validar Dados do Titulo

            String tituloSituacao = _da.ObterSituacaoTituloCARExistente(entidade.Empreendimento.Id);

            if (!String.IsNullOrWhiteSpace(tituloSituacao))
            {
                Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoPossuiTitulo(tituloSituacao));
                return(false);
            }

            #endregion Validar Dados do Titulo

            #region Empreendimento

            if (!entidade.Empreendimento.Codigo.HasValue)
            {
                Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoEmpreendimentoCodigoObrigatorio);
            }

            if (entidade.Empreendimento.Id <= 0)
            {
                Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoEmpreendimentoObrigatorio);
            }
            else
            {
                String situacao = _da.EmpreendimentoPossuiSolicitacao(entidade.Id, entidade.Empreendimento.Id);
                if (!String.IsNullOrEmpty(situacao))
                {
                    Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoJaPossuiSolicitacao(situacao));
                    return(Validacao.EhValido);
                }

                situacao = _carSolicitacaoCredenciadoBus.EmpreendimentoPossuiSolicitacao(entidade.Empreendimento.Id);
                if (!String.IsNullOrEmpty(situacao))
                {
                    Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoJaPossuiSolicitacao(situacao));
                    return(Validacao.EhValido);
                }

                entidade.Empreendimento.CNPJ = _da.ObterCNPJEmpreendimento(entidade.Empreendimento.Id);
                if (!String.IsNullOrWhiteSpace(entidade.Empreendimento.CNPJ))
                {
                    situacao = _carSolicitacaoCredenciadoBus.EmpreendimentoPossuiSolicitacao(entidade.Empreendimento.CNPJ);
                    if (!String.IsNullOrEmpty(situacao))
                    {
                        Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoJaPossuiSolicitacao(situacao));
                        return(Validacao.EhValido);
                    }
                }
            }

            #endregion Empreendimento

            #region Validar Dados da Caracterizacao

            if (_da.EmpreendimentoProjetoGeograficoDominialidadeNaoFinalizado(entidade.Empreendimento.Id))
            {
                Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoProjetoGeograficoDominialidadeNaoFinalizado);
            }
            else
            {
                int idCaracterizacao = 0;
                List <Dependencia> dependencias;

                idCaracterizacao = _caracterizacaoBus.Existe(entidade.Empreendimento.Id, eCaracterizacao.Dominialidade);

                if (idCaracterizacao > 0)
                {
                    dependencias = _caracterizacaoBus.ObterDependencias(idCaracterizacao, eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao);
                    if (_caracterizacaoValidar.DependenciasAlteradas(entidade.Empreendimento.Id, (int)eCaracterizacao.Dominialidade, eCaracterizacaoDependenciaTipo.Caracterizacao, dependencias) != String.Empty)
                    {
                        Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoDominialidadeInvalida);
                    }
                }
                else
                {
                    Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoDominialidadeInexistente);
                }
            }

            #endregion Validar Dados da Caracterizacao

            if (entidade.Declarante.Id <= 0)
            {
                Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoDeclaranteObrigatorio);
            }

            return(Validacao.EhValido);
        }
 public bool EmPosse(int documento)
 {
     return(_da.EmPosse(documento));
 }
        public bool Salvar(Documento documento)
        {
            #region Validações Genéricas

            if (documento.SetorId <= 0 && documento.Id.GetValueOrDefault() <= 0)
            {
                Validacao.Add(Mensagem.Documento.SetorObrigatorio);
            }

            if (!documento.DataCadastro.Data.HasValue)
            {
                Validacao.Add(Mensagem.Documento.DataCriacaoObrigatoria);
            }
            else
            {
                if (documento.DataCadastro.Data > DateTime.Today)
                {
                    Validacao.Add(Mensagem.Documento.DataCriacaoMaiorAtual);
                }
            }

            if (documento.Tipo.Id <= 0)
            {
                Validacao.Add(Mensagem.Documento.DocumentoTipoObrigatorio);
            }

            if (documento.Volume.GetValueOrDefault() <= 0 && documento.Tipo.QuantidadeDocumentoObrigatorio)             //Documento Avulso
            {
                Validacao.Add(Mensagem.Documento.QuantidadeDocumentoObrigatoria);
            }

            if (string.IsNullOrEmpty(documento.Nome) && documento.Tipo.NomeObrigatorio)
            {
                Validacao.Add(Mensagem.Documento.NomeObrigatorio);
            }

            if (string.IsNullOrEmpty(documento.Assunto) && documento.Tipo.AssuntoObrigatorio)
            {
                Validacao.Add(Mensagem.Documento.AssuntoObrigatorio);
            }

            if (string.IsNullOrEmpty(documento.Descricao) && documento.Tipo.DescricaoObrigatoria)
            {
                Validacao.Add(Mensagem.Documento.DescricaoObrigatoria);
            }

            if (documento.Tipo.DestinatarioLivreObrigatorio)
            {
                if (string.IsNullOrWhiteSpace(documento.Descricao))
                {
                    Validacao.Add(Mensagem.Documento.ConteudoOficioObrigatorio);
                }

                if (string.IsNullOrWhiteSpace(documento.OrgaoDestino))
                {
                    Validacao.Add(Mensagem.Documento.OrgaoDestinoObrigatorio);
                }

                if (string.IsNullOrWhiteSpace(documento.CargoFuncaoDestinatario))
                {
                    Validacao.Add(Mensagem.Documento.CargoFuncaoDestinatarioObrigatorio);
                }

                if (string.IsNullOrWhiteSpace(documento.NomeDestinatario))
                {
                    Validacao.Add(Mensagem.Documento.NomeDestinatarioObrigatorio);
                }

                if (string.IsNullOrWhiteSpace(documento.EnderecoDestinatario))
                {
                    Validacao.Add(Mensagem.Documento.EnderecoDestinatarioObrigatorio);
                }
            }

            if (documento.Tipo.Id == (int)eProtocoloTipo.FiscalizacaoSemAI_TEI_TAD)
            {
                if (documento.Fiscalizacao.Id == 0)
                {
                    Validacao.Add(Mensagem.Documento.FiscalizacaoObrigatoria);
                }
                else
                {
                    FiscalizacaoValidar fiscValidar = new FiscalizacaoValidar();

                    if (fiscValidar.PossuiAI_TED_TAD(documento.Fiscalizacao.Id))
                    {
                        Validacao.Add(Mensagem.Documento.PossuiAI_TEI_TAD);
                    }

                    String numeroProtocoloAssociado = ValidarFiscalizacaoAssociadaOutroProtocolo(documento.Id.GetValueOrDefault(0), documento.Fiscalizacao.Id);
                    if (!String.IsNullOrWhiteSpace(numeroProtocoloAssociado))
                    {
                        Validacao.Add(Mensagem.Fiscalizacao.FiscalizacaoJaAssociada(numeroProtocoloAssociado));
                    }
                }
            }

            if (documento.Tipo.Id <= 0)
            {
                return(false);
            }

            ListaBus      listaBus = new ListaBus();
            ProtocoloTipo configuracaoDocumentoTipo = listaBus.TiposDocumento.FirstOrDefault(x => x.Id == documento.Tipo.Id);
            Documento     documentoOriginal         = documento.Id.GetValueOrDefault() > 0 ? _da.Obter(documento.Id.Value) as Documento : new Documento();

            if (configuracaoDocumentoTipo.ProcessoObrigatorio && documento.ProtocoloAssociado.Id.GetValueOrDefault() <= 0)
            {
                Validacao.Add(Mensagem.Documento.ProcessoObrigatorio);
            }

            if (configuracaoDocumentoTipo.ChecagemPendenciaObrigatorio)
            {
                if (documento.ChecagemPendencia.Id <= 0)
                {
                    Validacao.Add(Mensagem.Documento.ChecagemPendenciaObrigatoria);
                }
                else
                {
                    ChecagemPendenciaJaAssociada(documento.ChecagemPendencia.Id, documento.Id.GetValueOrDefault());
                }
            }

            if (configuracaoDocumentoTipo.InteressadoObrigatorio && documento.Interessado.Id == 0)
            {
                Validacao.Add(Mensagem.Documento.InteressadoObrigatorio);
            }

            if (configuracaoDocumentoTipo.RequerimentoObrigatorio)
            {
                if (documento.ChecagemRoteiro.Id <= 0)
                {
                    Validacao.Add(Mensagem.Documento.ChecagemObrigatoria);
                }

                if (documento.Requerimento.Id <= 0)
                {
                    Validacao.Add(Mensagem.Documento.RequerimentoObrigatorio);
                }
                else
                {
                    if (_requerimentoValidar.RequerimentoDeclaratorio(documento.Requerimento.Id))
                    {
                        Validacao.Add(Mensagem.Documento.AssociarDeclaratorio);
                    }

                    RequerimentoFinalizado(documento.Requerimento.Id, documento.Id.GetValueOrDefault());

                    ResponsavelTecnico(documento.Responsaveis);

                    if (documento.Atividades.Count <= 0)
                    {
                        Validacao.Add(Mensagem.Documento.AtividadeObrigatoria);
                    }
                    else
                    {
                        Atividades(documento.Atividades, (documentoOriginal.Requerimento.Id != documento.Requerimento.Id));

                        if (documentoOriginal.Requerimento.Id == documento.Requerimento.Id)
                        {
                            foreach (Atividade atividade in documentoOriginal.Atividades)
                            {
                                Atividade atividadeAux = documento.Atividades.SingleOrDefault(x => x.Id == atividade.Id);
                                foreach (var finalidade in atividade.Finalidades)
                                {
                                    if (!atividadeAux.Finalidades.Exists(x => x.Id == finalidade.Id) && _atividadeDa.VerificarAtividadeAssociadaTitulo(documentoOriginal.Id.Value, false, atividade.Id, finalidade.TituloModelo))
                                    {
                                        Validacao.Add(Mensagem.Atividade.FinalidadeAssociadaTitulo(finalidade.TituloModeloTexto));
                                    }
                                }
                            }
                        }
                    }
                }
            }

            #endregion

            if (documento.Id > 0)
            {
                #region Editar

                if (!_da.EmPosse(documento.Id.Value))
                {
                    Validacao.Add(Mensagem.Documento.PosseDocumentoNecessariaEditar);
                    return(Validacao.EhValido);
                }

                if ((documento.ChecagemRoteiro.Id > 0 && documento.Requerimento.Id > 0) &&
                    (documentoOriginal.ChecagemRoteiro.Id != documento.ChecagemRoteiro.Id || documentoOriginal.Requerimento.Id != documento.Requerimento.Id))
                {
                    _requerimentoValidar.RoteirosChecagemRequerimento(documento.ChecagemRoteiro.Id, documento.Requerimento.Id, documento.Requerimento.SituacaoId);
                }

                if (documentoOriginal.ChecagemRoteiro.Id != documento.ChecagemRoteiro.Id)
                {
                    if (_da.VerificarChecagemTemTituloPendencia(ModeloCodigosPendencia, documento.Id.Value).Count > 0)
                    {
                        Validacao.Add(Mensagem.Documento.ChecagemAssociadaTitulo);
                    }
                    else
                    {
                        _busCheckListRoteiro.ValidarAssociarCheckList(documento.ChecagemRoteiro.Id, documento.Id.Value, false);
                    }
                }

                if (documentoOriginal.Requerimento.Id != documento.Requerimento.Id)
                {
                    List <String> titulos = _da.VerificarAtividadeAssociadaTitulo(documento.Id.GetValueOrDefault());

                    if (titulos.Count < 0)
                    {
                        Validacao.Add(Mensagem.Documento.RequerimentoAssociadoTitulo());
                    }
                }

                if (documento.ChecagemPendencia.Id != documentoOriginal.ChecagemPendencia.Id)
                {
                    Validacao.Add(Mensagem.Documento.ChecagemPendenciaAlterada);
                }

                #endregion
            }
            else
            {
                #region Criar

                if (documento.ChecagemRoteiro != null && documento.ChecagemRoteiro.Id > 0)
                {
                    _busCheckListRoteiro.ValidarAssociarCheckList(documento.ChecagemRoteiro.Id, documento.Id.GetValueOrDefault(), false);
                }

                if ((documento.ChecagemRoteiro != null && documento.ChecagemRoteiro.Id > 0) && (documento.Requerimento != null && documento.Requerimento.Id > 0))
                {
                    _requerimentoValidar.RoteirosChecagemRequerimento(documento.ChecagemRoteiro.Id, documento.Requerimento.Id, documento.Requerimento.SituacaoId);
                }

                #endregion
            }

            return(Validacao.EhValido);
        }
 public bool EmPosse(int processoId)
 {
     return(_da.EmPosse(processoId));
 }
Exemple #11
0
 public bool PosseProtocoloFuncionario(int protocoloId, int usuarioId)
 {
     return(_da.EmPosse(protocoloId, usuarioId));
 }