public int Criar(Fiscalizacao fiscalizacao, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                Comando comando = bancoDeDados.CriarComando(@"insert into {0}tab_fiscalizacao (id, situacao, situacao_data, autuante, tid)
															values ({0}seq_tab_fiscalizacao.nextval, :situacao, :situacao_data, :autuante,
															:tid) returning id into :id"                                                            , EsquemaBanco);

                comando.AdicionarParametroEntrada("situacao", (int)eFiscalizacaoSituacao.EmAndamento, DbType.Int32);
                comando.AdicionarParametroEntrada("situacao_data", DateTime.Now, DbType.Date);
                comando.AdicionarParametroEntrada("autuante", fiscalizacao.Autuante.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroSaida("id", DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                fiscalizacao.Id = Convert.ToInt32(comando.ObterValorParametro("id"));

                bancoDeDados.Commit();
            }

            return(fiscalizacao.Id);
        }
Exemple #2
0
        internal Fiscalizacao ObterFiscalizacaoPorHistorico(int fiscalizacaoId, string fiscalizacaoTid, int protocoloId, string protocoloTid, BancoDeDados banco = null)
        {
            Fiscalizacao fiscalizacoes = new Fiscalizacao();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = bancoDeDados.CriarComando(@"select f.fiscalizacao_id Id, f.fiscalizacao_id NumeroFiscalizacao, f.situacao_id situacaoId,
															f.situacao_texto situacaoTexto, l.data DataFiscalizacao, i.infracao_autuada InfracaoAutuada,
															(select p.numero || '/' || p.ano from hst_protocolo p where p.fiscalizacao_id = f.fiscalizacao_id and 
															p.id_protocolo = :protocoloId and p.tid = :protocoloTid) NumeroProcesso, f.tid Tid from hst_fiscalizacao f,
															hst_fisc_local_infracao l, hst_fisc_infracao i where f.fiscalizacao_id = :fiscalizacao_id and 
															f.tid = :fiscalizacao_tid and f.data_execucao = (select max(data_execucao) from hst_fiscalizacao
															where fiscalizacao_id = :fiscalizacao_id and tid = f.tid) and l.id_hst = f.id and i.fiscalizacao_id_hst = f.id"                                                            , EsquemaBanco);

                comando.AdicionarParametroEntrada("fiscalizacao_id", fiscalizacaoId, DbType.Int32);
                comando.AdicionarParametroEntrada("fiscalizacao_tid", fiscalizacaoTid, DbType.String);
                comando.AdicionarParametroEntrada("protocoloId", protocoloId, DbType.Int32);
                comando.AdicionarParametroEntrada("protocoloTid", protocoloTid, DbType.String);

                fiscalizacoes = bancoDeDados.ObterEntity <Fiscalizacao>(comando, (IDataReader reader, Fiscalizacao fiscalizacaoItem) =>
                {
                    fiscalizacaoItem.DataFiscalizacao = Convert.ToDateTime(reader.GetValue <String>("DataFiscalizacao")).ToShortDateString();
                });
            }

            return(fiscalizacoes);
        }
        public void ConcluirCadastro(Fiscalizacao fiscalizacao, bool gerarAutosTermo, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                Comando comando = bancoDeDados.CriarComando(@"update {0}tab_fiscalizacao t set " + (gerarAutosTermo ? @"t.autos = {0}seq_fiscalizacao_autos.nextval," : @"") +
                                                            @"t.vencimento	= :vencimento, t.tid = :tid where t.id = :id", EsquemaBanco);

                comando.AdicionarParametroEntrada("vencimento", fiscalizacao.Vencimento.DataTexto.ToString() == "01/01/0001" ? null : fiscalizacao.Vencimento.DataTexto, DbType.DateTime);
                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroEntrada("id", fiscalizacao.Id, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                #region Alterar Situacao

                fiscalizacao.SituacaoNovaTipo      = (int)eFiscalizacaoSituacao.CadastroConcluido;
                fiscalizacao.SituacaoNovaData.Data = DateTime.Now;

                AlterarSituacao(fiscalizacao, banco);

                #endregion

                bancoDeDados.Commit();
            }
        }
Exemple #4
0
        public Fiscalizacao Obter(int id, bool simplificado = false, BancoDeDados banco = null)
        {
            Fiscalizacao entidade = null;

            try
            {
                using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
                {
                    entidade = _da.Obter(id, bancoDeDados);

                    if (simplificado)
                    {
                        return(entidade);
                    }

                    entidade.LocalInfracao       = _daLocalInfracao.Obter(id, bancoDeDados);
                    entidade.ComplementacaoDados = _daComplementacaoDados.Obter(id, bancoDeDados);
                    entidade.Enquadramento       = _daEnquadramento.Obter(id, bancoDeDados);
                    entidade.Infracao            = _daInfracao.ObterHistoricoPorFiscalizacao(id, bancoDeDados);
                    entidade.ObjetoInfracao      = _daObjetoInfracao.Obter(id, bancoDeDados);
                    entidade.MaterialApreendido  = _daMaterialApreendido.Obter(id, bancoDeDados);
                    entidade.ConsideracaoFinal   = _daConsideracaoFinal.Obter(id, bancoDeDados);
                    entidade.ProjetoGeo          = _daPrjGeo.ObterProjetoGeograficoPorFiscalizacao(id, bancoDeDados);

                    entidade.AutuadoPessoa         = entidade.LocalInfracao.PessoaId.GetValueOrDefault() > 0 ? new PessoaBus().Obter(entidade.LocalInfracao.PessoaId.Value) : new Pessoa();
                    entidade.AutuadoEmpreendimento = entidade.LocalInfracao.EmpreendimentoId.GetValueOrDefault() > 0 ? new EmpreendimentoBus().Obter(entidade.LocalInfracao.EmpreendimentoId.Value) : new Empreendimento();
                }
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(entidade);
        }
Exemple #5
0
        public bool AlterarSituacao(Fiscalizacao fiscalizacao)
        {
            try
            {
                if (_validar.AlterarSituacao(fiscalizacao))
                {
                    GerenciadorTransacao.ObterIDAtual();

                    using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
                    {
                        bancoDeDados.IniciarTransacao();

                        if (fiscalizacao.SituacaoNovaTipo == (int)eFiscalizacaoSituacao.CancelarConclusao)
                        {
                            fiscalizacao.SituacaoNovaTipo = (int)eFiscalizacaoSituacao.EmAndamento;
                            _daPrjGeo.Refazer(fiscalizacao.Id, bancoDeDados);
                        }

                        _da.AlterarSituacao(fiscalizacao, bancoDeDados);

                        _da.GerarHistorico(fiscalizacao.Id, eHistoricoAcao.alterarsituacao, bancoDeDados);

                        _da.GerarConsulta(fiscalizacao.Id, bancoDeDados);

                        bancoDeDados.Commit();
                    }
                }
            }
            catch (Exception e)
            {
                Validacao.AddErro(e);
            }

            return(Validacao.EhValido);
        }
Exemple #6
0
        public AlterarSituacaoVM(Fiscalizacao fiscalizacao, List <Setor> setores, List <Segmento> segmentos, List <Lista> situacoes)
        {
            Fiscalizacao = fiscalizacao;

            Setores       = ViewModelHelper.CriarSelectList(setores, true, true, selecionado: Fiscalizacao.LocalInfracao.SetorId.ToString());
            Segmentos     = ViewModelHelper.CriarSelectList(segmentos, true, true, selecionado: Fiscalizacao.AutuadoEmpreendimento.Segmento.GetValueOrDefault().ToString());
            SituacaoAtual = ViewModelHelper.CriarSelectList(situacoes, true, true, selecionado: Fiscalizacao.SituacaoId.ToString());

            List <Lista> _situacaonovalst = new List <Lista>();

            if (Fiscalizacao.SituacaoId == (int)eFiscalizacaoSituacao.CadastroConcluido)
            {
                _situacaonovalst = situacoes.Where(x => x.Id == ((int)eFiscalizacaoSituacao.CancelarConclusao).ToString()).ToList();
            }
            else
            {
                if (Fiscalizacao.SituacaoId == (int)eFiscalizacaoSituacao.Protocolado)
                {
                    _situacaonovalst = situacoes.Where(x => x.Id != ((int)eFiscalizacaoSituacao.Protocolado).ToString() &&
                                                       x.Id != ((int)eFiscalizacaoSituacao.EmAndamento).ToString() &&
                                                       x.Id != ((int)eFiscalizacaoSituacao.CadastroConcluido).ToString() &&
                                                       x.Id != ((int)eFiscalizacaoSituacao.CancelarConclusao).ToString()).ToList();
                }
                else
                {
                    _situacaonovalst = situacoes.Where(x => x.Id != ((int)eFiscalizacaoSituacao.Protocolado).ToString() &&
                                                       x.Id != ((int)eFiscalizacaoSituacao.CadastroConcluido).ToString() &&
                                                       x.Id != ((int)eFiscalizacaoSituacao.CancelarConclusao).ToString() &&
                                                       x.Id != ((int)eFiscalizacaoSituacao.EmAndamento).ToString() &&
                                                       x.Id != Fiscalizacao.SituacaoId.ToString()).ToList();
                }
            }

            SituacaoNova = ViewModelHelper.CriarSelectList(_situacaonovalst, true, true);
        }
        public Fiscalizacao ObterHistorico(int id, BancoDeDados banco = null)
        {
            Fiscalizacao fiscalizacao = new Fiscalizacao();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = bancoDeDados.CriarComando(@"select t.fiscalizacao_id Id, t.situacao_id SituacaoId, t.situacao_data, t.situacao_texto SituacaoTexto, 
					t.tid Tid, t.autos NumeroAutos, t.vencimento vencimentoFisc, t.pdf_auto_termo, t.pdf_laudo, t.pdf_croqui
					from {0}hst_fiscalizacao t where t.id = :id"                    , EsquemaBanco);

                comando.AdicionarParametroEntrada("id", id, DbType.Int32);

                fiscalizacao = bancoDeDados.ObterEntity <Fiscalizacao>(comando, (IDataReader reader, Fiscalizacao fiscalizacaoItem) =>
                {
                    fiscalizacaoItem.Vencimento.Data        = reader.GetValue <DateTime>("vencimentoFisc");
                    fiscalizacaoItem.SituacaoAtualData.Data = reader.GetValue <DateTime>("situacao_data");

                    fiscalizacaoItem.PdfAutoTermo.Id = reader.GetValue <Int32>("pdf_auto_termo");
                    fiscalizacaoItem.PdfLaudo.Id     = reader.GetValue <Int32>("pdf_laudo");
                    fiscalizacaoItem.PdfCroqui.Id    = reader.GetValue <Int32>("pdf_croqui");
                });
            }

            return(fiscalizacao);
        }
Exemple #8
0
        private bool RealizarAlteracaoSituacao(Fiscalizacao fiscalizacao, BancoDeDados banco = null)
        {
            try
            {
                GerenciadorTransacao.ObterIDAtual();

                using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
                {
                    bancoDeDados.IniciarTransacao();

                    _da.AlterarSituacao(fiscalizacao, bancoDeDados);

                    #region Histórico

                    _da.GerarHistorico(fiscalizacao.Id, eHistoricoAcao.alterarsituacao, bancoDeDados);

                    _da.GerarConsulta(fiscalizacao.Id, bancoDeDados);

                    #endregion

                    bancoDeDados.Commit();
                }
            }
            catch (Exception e)
            {
                Validacao.AddErro(e);
            }

            return(Validacao.EhValido);
        }
Exemple #9
0
        public Fiscalizacao ObterHistorico(int id, bool simplificado = false, BancoDeDados banco = null)
        {
            Fiscalizacao entidade = null;

            try
            {
                using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
                {
                    entidade = _da.ObterHistorico(id, bancoDeDados);

                    if (simplificado)
                    {
                        return(entidade);
                    }

                    entidade.LocalInfracao = _daLocalInfracao.ObterHistorico(id);

                    entidade.AutuadoPessoa         = entidade.LocalInfracao.PessoaId.GetValueOrDefault() > 0 ? _daLocalInfracao.ObterPessoaSimplificadaPorHistorico(entidade.LocalInfracao.PessoaId.Value, entidade.LocalInfracao.PessoaTid) : new Pessoa();
                    entidade.AutuadoEmpreendimento = entidade.LocalInfracao.EmpreendimentoId.GetValueOrDefault() > 0 ? new EmpreendimentoBus().ObterHistorico(entidade.LocalInfracao.EmpreendimentoId.Value, entidade.LocalInfracao.EmpreendimentoTid) : new Empreendimento();
                }
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(entidade);
        }
        public bool Excluir(Fiscalizacao fiscalizacao)
        {
            if (fiscalizacao.Situacao != eFiscalizacaoSituacao.EmAndamento)
            {
                Validacao.Add(Mensagem.Fiscalizacao.ExcluirInvalido(fiscalizacao.SituacaoTexto));
                return(Validacao.EhValido);
            }

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

            if (_da.ExisteTituloCertidaoDebido(fiscalizacao.Id))
            {
                Validacao.Add(Mensagem.Fiscalizacao.ExcluirCertidaoDebidoFiscalizacao);
            }

            if (_da.GeradoNumeroIUFDigital(fiscalizacao.Id))
            {
                Validacao.Add(Mensagem.Fiscalizacao.ExcluirIUFGerado);
            }

            return(Validacao.EhValido);
        }
        public Fiscalizacao Obter(int id, BancoDeDados banco = null)
        {
            Fiscalizacao fiscalizacao = new Fiscalizacao();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                Comando comando = bancoDeDados.CriarComando(@"select t.id Id, t.situacao SituacaoId, t.situacao_data, ls.texto SituacaoTexto, t.tid Tid, tf.nome funcionarioNome, 
				tf.id funcionarioId, tu.login funcionarioLogin, t.autos NumeroAutos, t.vencimento vencimentoFisc, p.id ProtocoloId, t.pdf_auto_termo, t.pdf_laudo 
				from {0}tab_fiscalizacao t, {0}tab_protocolo p, {0}lov_fiscalizacao_situacao ls, {0}tab_funcionario tf, {0}tab_usuario tu where t.situacao = ls.id(+) 
				and t.autuante = tf.id and tf.usuario = tu.id and p.fiscalizacao(+) = t.id and t.id = :id"                , EsquemaBanco);

                comando.AdicionarParametroEntrada("id", id, DbType.Int32);

                fiscalizacao = bancoDeDados.ObterEntity <Fiscalizacao>(comando, (IDataReader reader, Fiscalizacao fiscalizacaoItem) =>
                {
                    fiscalizacaoItem.Autuante.Id            = reader.GetValue <int>("funcionarioId");
                    fiscalizacaoItem.Autuante.Nome          = reader.GetValue <string>("funcionarioNome");
                    fiscalizacaoItem.Autuante.Usuario.Login = reader.GetValue <string>("funcionarioLogin");
                    fiscalizacaoItem.Vencimento.Data        = reader.GetValue <DateTime>("vencimentoFisc");
                    fiscalizacaoItem.SituacaoAtualData.Data = reader.GetValue <DateTime>("situacao_data");
                    fiscalizacaoItem.PdfAutoTermo.Id        = reader.GetValue <int>("pdf_auto_termo");
                    fiscalizacaoItem.PdfLaudo.Id            = reader.GetValue <int>("pdf_laudo");
                });

                fiscalizacao.DataConclusao = ObterDataConclusao(fiscalizacao.Id);
            }
            return(fiscalizacao);
        }
        public bool AlterarSituacao(Fiscalizacao fiscalizacao)
        {
            Fiscalizacao aux = _da.Obter(fiscalizacao.Id);

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

            if (aux.SituacaoId != fiscalizacao.SituacaoAtualTipo)
            {
                Validacao.Add(Mensagem.Fiscalizacao.SituacaoJaAlterada);
                return(Validacao.EhValido);
            }

            if (fiscalizacao.SituacaoNovaTipo <= 0)
            {
                Validacao.Add(Mensagem.Fiscalizacao.SituacaoNovaObrigatorio);
            }

            if (String.IsNullOrWhiteSpace(fiscalizacao.SituacaoNovaMotivoTexto))
            {
                Validacao.Add(Mensagem.Fiscalizacao.SituacaoMotivoObrigatorio);
            }

            ValidacoesGenericasBus.DataMensagem(fiscalizacao.SituacaoNovaData, "Fiscalizacao_SituacaoNovaData_DataTexto", "nova situação");

            return(Validacao.EhValido);
        }
Exemple #13
0
        public bool Salvar(Fiscalizacao entidade)
        {
            try
            {
                if (_validar.Salvar(entidade))
                {
                    entidade.Autuante.Id = User.EtramiteIdentity.FuncionarioId;
                    eHistoricoAcao acao = entidade.Id > 0 ? eHistoricoAcao.atualizar : eHistoricoAcao.criar;

                    GerenciadorTransacao.ObterIDAtual();

                    using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
                    {
                        bancoDeDados.IniciarTransacao();

                        _da.Salvar(entidade, bancoDeDados);

                        #region Local da Infração

                        if (entidade.LocalInfracao.Id < 1)
                        {
                            entidade.LocalInfracao.Id = _daLocalInfracao.ObterID(entidade.Id);
                        }

                        entidade.LocalInfracao.FiscalizacaoId = entidade.Id;

                        //se não foi usado o filtro de local, as informações de local são salvas a partir do empreendimento
                        if (entidade.LocalInfracao.EmpreendimentoId != null)
                        {
                            Empreendimento empreendimento = _daEmpreendimento.Obter(entidade.LocalInfracao.EmpreendimentoId.Value);

                            entidade.LocalInfracao.LatNorthing = entidade.LocalInfracao.LatNorthing ?? empreendimento.Coordenada.NorthingUtm.ToString();
                            entidade.LocalInfracao.LonEasting  = entidade.LocalInfracao.LonEasting ?? empreendimento.Coordenada.EastingUtm.ToString();
                            entidade.LocalInfracao.MunicipioId = (entidade.LocalInfracao.MunicipioId != null && entidade.LocalInfracao.MunicipioId > 0) ? entidade.LocalInfracao.MunicipioId : empreendimento.Enderecos[0].MunicipioId;
                            entidade.LocalInfracao.Local       = entidade.LocalInfracao.Local ?? empreendimento.Denominador;
                        }

                        _daLocalInfracao.Salvar(entidade.LocalInfracao, bancoDeDados);

                        #endregion

                        _da.GerarHistorico(entidade.Id, acao, bancoDeDados);

                        _da.GerarConsulta(entidade.Id, bancoDeDados);

                        Validacao.Add(Mensagem.Fiscalizacao.Salvar(entidade.Id.ToString()));

                        bancoDeDados.Commit();
                    }
                }
            }
            catch (Exception e)
            {
                Validacao.AddErro(e);
            }

            return(Validacao.EhValido);
        }
        public bool ValidarAssociar(int fiscalizacaoId)
        {
            Fiscalizacao fisc = _da.Obter(fiscalizacaoId);

            if (fisc.SituacaoId != (int)eFiscalizacaoSituacao.CadastroConcluido)
            {
                Validacao.Add(Mensagem.Fiscalizacao.SituacaoInvalida);
            }

            return(Validacao.EhValido);
        }
Exemple #15
0
        public Fiscalizacao ObterParaConclusao(int id, bool simplificado = false, BancoDeDados banco = null)
        {
            Fiscalizacao entidade = null;

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                entidade = _da.Obter(id, bancoDeDados);
            }

            return(entidade);
        }
Exemple #16
0
        public Fiscalizacao ObterComAcompanhamento(int id, int acompanhamentoId, bool simplificado = false, BancoDeDados banco = null)
        {
            Fiscalizacao entidade = null;

            try
            {
                using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
                {
                    entidade = _da.Obter(id, bancoDeDados);

                    if (simplificado)
                    {
                        return(entidade);
                    }

                    entidade.LocalInfracao       = _daLocalInfracao.Obter(id, bancoDeDados);
                    entidade.ComplementacaoDados = _daComplementacaoDados.Obter(id, bancoDeDados);
                    entidade.Enquadramento       = _daEnquadramento.Obter(id, bancoDeDados);
                    entidade.Infracao            = _daInfracao.ObterHistoricoPorFiscalizacao(id, bancoDeDados);
                    entidade.ObjetoInfracao      = _daObjetoInfracao.Obter(id, bancoDeDados);
                    entidade.MaterialApreendido  = _daMaterialApreendido.Obter(id, bancoDeDados);
                    entidade.ConsideracaoFinal   = _daConsideracaoFinal.Obter(id, bancoDeDados);
                    entidade.ProjetoGeo          = _daPrjGeo.ObterProjetoGeograficoPorFiscalizacao(id, bancoDeDados);

                    entidade.AutuadoPessoa         = entidade.LocalInfracao.PessoaId.GetValueOrDefault() > 0 ? new PessoaBus().Obter(entidade.LocalInfracao.PessoaId.Value) : new Pessoa();
                    entidade.AutuadoEmpreendimento = entidade.LocalInfracao.EmpreendimentoId.GetValueOrDefault() > 0 ? new EmpreendimentoBus().Obter(entidade.LocalInfracao.EmpreendimentoId.Value) : new Empreendimento();

                    Acompanhamento acomp = _daAcompanhamento.Obter(acompanhamentoId);

                    entidade.ComplementacaoDados.AreaTotalInformada           = acomp.AreaTotal;
                    entidade.ComplementacaoDados.AreaCoberturaFlorestalNativa = acomp.AreaFlorestalNativa;
                    entidade.ComplementacaoDados.ReservalegalTipo             = acomp.ReservalegalTipo;
                    entidade.ObjetoInfracao.OpniaoAreaDanificada = acomp.OpniaoAreaEmbargo;
                    entidade.ObjetoInfracao.ExisteAtvAreaDegrad  = acomp.AtividadeAreaEmbargada;
                    entidade.ObjetoInfracao.ExisteAtvAreaDegradEspecificarTexto = acomp.AtividadeAreaEmbargadaEspecificarTexto;
                    entidade.ObjetoInfracao.UsoSoloAreaDanificada            = acomp.UsoAreaSoloDescricao;
                    entidade.ObjetoInfracao.CaracteristicaSoloAreaDanificada = acomp.CaracteristicaSoloAreaDanificada;
                    entidade.ObjetoInfracao.AreaDeclividadeMedia             = acomp.AreaDeclividadeMedia;
                    entidade.ObjetoInfracao.InfracaoResultouErosaoTipo       = acomp.InfracaoResultouErosao;
                    entidade.ObjetoInfracao.InfracaoResultouErosaoTipoTexto  = acomp.InfracaoResultouErosaoEspecificar;
                    entidade.MaterialApreendido.Opiniao   = acomp.OpniaoDestMaterialApreend;
                    entidade.ConsideracaoFinal.Assinantes = acomp.Assinantes;
                    entidade.ConsideracaoFinal.Anexos     = acomp.Anexos;
                }
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(entidade);
        }
Exemple #17
0
        public bool AlterarSituacao(Fiscalizacao fiscalizacao, BancoDeDados banco = null)
        {
            if (_validar.AlterarSituacao(fiscalizacao))
            {
                if (fiscalizacao.SituacaoNovaTipo == (int)eFiscalizacaoSituacao.CancelarConclusao)
                {
                    fiscalizacao.SituacaoNovaTipo = (int)eFiscalizacaoSituacao.EmAndamento;
                }

                return(this.RealizarAlteracaoSituacao(fiscalizacao, banco));
            }
            return(Validacao.EhValido);
        }
        public bool ValidarDesassociar(int fiscalizacaoId)
        {
            Fiscalizacao fisc = _da.Obter(fiscalizacaoId);

            if (fisc.SituacaoId != (int)eFiscalizacaoSituacao.Protocolado &&
                fisc.SituacaoId != (int)eFiscalizacaoSituacao.CadastroConcluido &&
                fisc.SituacaoId != (int)eFiscalizacaoSituacao.CancelarConclusao)
            {
                Validacao.Add(Mensagem.Fiscalizacao.NaoPodeDesassociar(fisc.Id.ToString(), fisc.SituacaoTexto));
            }

            return(Validacao.EhValido);
        }
Exemple #19
0
        public Fiscalizacao Obter(int id, bool simplificado = false, BancoDeDados banco = null)
        {
            Fiscalizacao entidade = null;

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                entidade = _da.Obter(id, bancoDeDados);

                if (simplificado)
                {
                    return(entidade);
                }

                entidade.LocalInfracao = _daLocalInfracao.Obter(id, bancoDeDados);
                //entidade.Infracao = _daInfracao.ObterHistoricoPorFiscalizacao(id, bancoDeDados);
                entidade.Infracao           = _daInfracao.Obter(id, bancoDeDados);
                entidade.ObjetoInfracao     = _daObjetoInfracao.Obter(id, bancoDeDados);
                entidade.MaterialApreendido = _daMaterialApreendido.Obter(id, bancoDeDados);

                if (entidade.MaterialApreendido == null)
                {
                    entidade.MaterialApreendido = _daMaterialApreendido.ObterAntigo(id, bancoDeDados);
                }

                entidade.Multa = _daMulta.Obter(id, bancoDeDados);

                if (entidade.Multa == null)
                {
                    entidade.Multa = _daMulta.ObterAntigo(id, bancoDeDados);
                }

                entidade.OutrasPenalidades = _daOutrasPenalidades.Obter(id, bancoDeDados);

                entidade.ConsideracaoFinal = _daConsideracaoFinal.Obter(id, bancoDeDados);
                entidade.ProjetoGeo        = _daPrjGeo.ObterProjetoGeograficoPorFiscalizacao(id, bancoDeDados);

                for (int i = 0; i < 4; i++)
                {
                    if (entidade.Infracao.IdsOutrasPenalidades.Count <= i)
                    {
                        entidade.Infracao.IdsOutrasPenalidades.Add(0);
                    }
                }

                entidade.AutuadoPessoa         = entidade.LocalInfracao.PessoaId.GetValueOrDefault() > 0 ? new PessoaBus().Obter(entidade.LocalInfracao.PessoaId.Value) : new Pessoa();
                entidade.AutuadoEmpreendimento = entidade.LocalInfracao.EmpreendimentoId.GetValueOrDefault() > 0 ? new EmpreendimentoBus().Obter(entidade.LocalInfracao.EmpreendimentoId.Value) : new Empreendimento();
            }

            return(entidade);
        }
        public void Editar(Fiscalizacao fiscalizacao, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                Comando comando = bancoDeDados.CriarComando(@"update {0}tab_fiscalizacao t set t.tid = :tid where t.id = :id", EsquemaBanco);

                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroEntrada("id", fiscalizacao.Id, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);
                bancoDeDados.Commit();
            }
        }
        public bool PodeAlterarSituacao(Acompanhamento acompanhamento, Fiscalizacao fiscalizacao)
        {
            if (!_protocoloDa.EmPosse(fiscalizacao.ProtocoloId))
            {
                Validacao.Add(Mensagem.Acompanhamento.PosseProcessoAlterarSituacao);
                return(false);
            }

            if (acompanhamento.SituacaoId == (int)eAcompanhamentoSituacao.Nulo || acompanhamento.SituacaoId == (int)eAcompanhamentoSituacao.Cancelado)
            {
                Validacao.Add(Mensagem.Acompanhamento.SituacaoInvalidaAlterarSituacao(acompanhamento.SituacaoTexto));
                return(false);
            }

            return(Validacao.EhValido);
        }
Exemple #22
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);
        }
Exemple #23
0
        public bool Salvar(Fiscalizacao entidade)
        {
            try
            {
                if (_validar.Salvar(entidade))
                {
                    entidade.Autuante.Id = User.EtramiteIdentity.FuncionarioId;
                    eHistoricoAcao acao = entidade.Id > 0 ? eHistoricoAcao.atualizar : eHistoricoAcao.criar;

                    GerenciadorTransacao.ObterIDAtual();

                    using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
                    {
                        bancoDeDados.IniciarTransacao();

                        _da.Salvar(entidade, bancoDeDados);

                        #region Local da Infração

                        if (entidade.LocalInfracao.Id < 1)
                        {
                            entidade.LocalInfracao.Id = _daLocalInfracao.ObterID(entidade.Id);
                        }

                        entidade.LocalInfracao.FiscalizacaoId = entidade.Id;
                        _daLocalInfracao.Salvar(entidade.LocalInfracao, bancoDeDados);

                        #endregion

                        _da.GerarHistorico(entidade.Id, acao, bancoDeDados);

                        _da.GerarConsulta(entidade.Id, bancoDeDados);

                        Validacao.Add(Mensagem.Fiscalizacao.Salvar(entidade.Id.ToString()));

                        bancoDeDados.Commit();
                    }
                }
            }
            catch (Exception e)
            {
                Validacao.AddErro(e);
            }

            return(Validacao.EhValido);
        }
        public bool Acompanhamentos(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 int Salvar(Fiscalizacao fiscalizacao, BancoDeDados banco = null)
        {
            if (fiscalizacao == null)
            {
                throw new Exception("Fiscalização é nulo.");
            }

            if (fiscalizacao.Id <= 0)
            {
                Criar(fiscalizacao, banco);
            }
            else
            {
                Editar(fiscalizacao, banco);
            }

            return(fiscalizacao.Id);
        }
Exemple #26
0
        public bool AlterarSituacaoProcDoc(Fiscalizacao fiscalizacao, BancoDeDados banco = null)
        {
            GerenciadorTransacao.ObterIDAtual();

            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                if (fiscalizacao.SituacaoNovaTipo == (int)eFiscalizacaoSituacao.CancelarConclusao)
                {
                    fiscalizacao.SituacaoNovaTipo = (int)eFiscalizacaoSituacao.EmAndamento;
                    _daPrjGeo.Refazer(fiscalizacao.Id, banco);
                }

                this.RealizarAlteracaoSituacao(fiscalizacao, banco);

                bancoDeDados.Commit();
            }
            return(Validacao.EhValido);
        }
        internal void SalvarDocumentosGerados(Fiscalizacao fiscalizacao, BancoDeDados banco = null)
        {
            using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
            {
                bancoDeDados.IniciarTransacao();

                Comando comando = bancoDeDados.CriarComando(@"update {0}tab_fiscalizacao t set t.pdf_auto_termo = :pdf_auto_termo, 
					t.pdf_laudo = :pdf_laudo, t.pdf_croqui = :pdf_croqui, t.tid = :tid where t.id = :id"                    , EsquemaBanco);

                comando.AdicionarParametroEntrada("pdf_auto_termo", fiscalizacao.PdfAutoTermo.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("pdf_laudo", fiscalizacao.PdfLaudo.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("pdf_croqui", fiscalizacao.PdfCroqui.Id, DbType.Int32);
                comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
                comando.AdicionarParametroEntrada("id", fiscalizacao.Id, DbType.Int32);

                bancoDeDados.ExecutarNonQuery(comando);

                bancoDeDados.Commit();
            }
        }
        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);
        }
Exemple #29
0
        public Stream LaudoFiscalizacaoPdf(int id, int arquivo = 0, int historico = 0, BancoDeDados banco = null)
        {
            try
            {
                PdfFiscalizacao _pdf         = new PdfFiscalizacao();
                Fiscalizacao    fiscalizacao = Obter(id, true);

                if (historico == 0 && fiscalizacao.SituacaoId == (int)eFiscalizacaoSituacao.EmAndamento)
                {
                    return(_pdf.GerarLaudoFiscalizacao(id, banco: banco));
                }

                if (historico > 0)
                {
                    fiscalizacao = ObterHistorico(historico);
                }

                if (fiscalizacao.PdfLaudo.Id.GetValueOrDefault() == 0 || (historico > 0 && fiscalizacao.PdfLaudo.Id != arquivo))
                {
                    Validacao.Add(Mensagem.Fiscalizacao.ArquivoNaoEncontrado);
                    return(null);
                }

                ArquivoBus arquivoBus = new ArquivoBus(eExecutorTipo.Interno);
                Arquivo    pdf        = arquivoBus.Obter(fiscalizacao.PdfLaudo.Id.GetValueOrDefault());

                if (historico > 0)
                {
                    pdf.Buffer = PdfMetodosAuxiliares.TarjaVermelha(pdf.Buffer, "CANCELADO " + fiscalizacao.SituacaoAtualData.DataTexto);
                }

                return(pdf.Buffer);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(null);
        }
Exemple #30
0
        public Arquivo BaixarArquivo(int id, int historico = 0)
        {
            try
            {
                ArquivoBus arquivoBus = new ArquivoBus(eExecutorTipo.Interno);
                Arquivo    pdf        = arquivoBus.Obter(id);

                if (historico > 0)
                {
                    Fiscalizacao fiscalizacao = ObterHistorico(historico);
                    pdf.Buffer = PdfMetodosAuxiliares.TarjaVermelha(pdf.Buffer, "CANCELADO " + fiscalizacao.SituacaoAtualData.DataTexto);
                }

                return(pdf);
            }
            catch (Exception exc)
            {
                Validacao.AddErro(exc);
            }

            return(null);
        }