internal HabilitarEmissaoCFOCFOC ObterPorCredenciado(int credenciadoId, bool simplificado = false, BancoDeDados banco = null)
{
HabilitarEmissaoCFOCFOC retorno = null;
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
Comando comando = bancoDeDados.CriarComando(@"select h.id from tab_hab_emi_cfo_cfoc h where h.responsavel = :credenciado_id", EsquemaBanco);
comando.AdicionarParametroEntrada("credenciado_id", credenciadoId, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
retorno = new HabilitarEmissaoCFOCFOC();
retorno.Id = reader.GetValue <int>("id");
}
reader.Close();
}
if (retorno != null)
{
retorno = Obter(retorno.Id, simplificado);
}
}
return(retorno);
}
public ActionResult ValidarUnidadeProducaoItem(UnidadeProducaoItem unidade, int empreendimento)
{
HabilitarEmissaoCFOCFOC credenciadoHabilitado = null;
List <Mensagem> Validacoes = new List <Mensagem>();
Cultura cultura = new Cultura()
{
Id = unidade.CulturaId, Nome = unidade.CulturaTexto
};
foreach (var responsavel in unidade.ResponsaveisTecnicos)
{
credenciadoHabilitado = _busHabilitacaoCFOCFOC.ObterPorCredenciado(responsavel.Id);
if (Validacao.EhValido)
{
credenciadoHabilitado.Pragas.ForEach(x =>
{
x.Praga.Culturas = _pragaBus.ObterCulturas(x.Praga.Id);
});
_validar.ValidarResponsavelTecnicoHabilitado(credenciadoHabilitado, cultura);
}
}
Validacao.Erros.AddRange(_validar.SalvarItemUnidadeProducao(unidade, empreendimento));
return(Json(new
{
@Msg = Validacao.Erros,
@EhValido = Validacao.EhValido,
}));
}
public bool AlterarSituacao(HabilitarEmissaoCFOCFOC habilitar)
{
try
{
if (habilitar.Situacao == 1 && !_da.ValidarPodeAtivar(habilitar.Id))
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.SituacaoAnteriorVigente);
return(Validacao.EhValido);
}
if (_validar.AlterarSituacao(habilitar))
{
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
bancoDeDados.IniciarTransacao();
_da.AlterarSituacao(habilitar, bancoDeDados);
bancoDeDados.Commit();
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(Validacao.EhValido);
}
internal HabilitarEmissaoCFOCFOC ObterCredenciado(int id)
{
HabilitarEmissaoCFOCFOC habilitar = null;
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
#region Habilitar Emissão
Comando comando = bancoDeDados.CriarComando(@"select tc.id responsavel, cc.cpf responsavel_cpf, cc.nome responsavel_nome, pc.registro registro_crea from
tab_credenciado tc, cre_pessoa cc, cre_pessoa_profissao pc where tc.pessoa = cc.id and cc.id = pc.pessoa(+) and tc.id = :id" , UsuarioCredenciado);
comando.AdicionarParametroEntrada("id", id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
habilitar = new HabilitarEmissaoCFOCFOC();
habilitar.Responsavel.Id = reader.GetValue <Int32>("responsavel");
habilitar.Responsavel.Pessoa.NomeRazaoSocial = reader.GetValue <String>("responsavel_nome");
habilitar.Responsavel.Pessoa.CPFCNPJ = reader.GetValue <String>("responsavel_cpf");
habilitar.RegistroCrea = reader.GetValue <String>("registro_crea");
}
reader.Close();
}
#endregion
}
return(habilitar);
}
public bool ValidarResponsavelTecnicoHabilitado(HabilitarEmissaoCFOCFOC habilitacao, Cultura cultura)
{
if (habilitacao.Situacao == (int)eHabilitacaoCFOCFOCSituacao.Inativo)
{
Validacao.Add(Mensagem.UnidadeProducao.HabilitacaoInativa);
return(false);
}
if (!habilitacao.Pragas.SelectMany(p => p.Praga.Culturas).ToList().Exists(c => c.Id == cultura.Id))
{
Validacao.Add(Mensagem.UnidadeProducao.ResponsavelTecnicoNaoHabilitadoParaCultura);
return(Validacao.EhValido);
}
List <PragaHabilitarEmissao> lista = habilitacao.Pragas.Where(p => p.Praga.Culturas.Exists(c => c.Id == cultura.Id)).ToList();
foreach (var item in lista)
{
if (DateTime.Parse(item.DataFinalHabilitacao) < DateTime.Today)
{
Validacao.Add(Mensagem.UnidadeProducao.PragaCulturaDataFinalVencida);
break;
}
}
return(Validacao.EhValido);
}
internal List <HabilitarEmissaoCFOCFOC> ObterEmissoesComValidadeVencida(BancoDeDados banco = null)
{
List <HabilitarEmissaoCFOCFOC> lista = new List <HabilitarEmissaoCFOCFOC>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
Comando comando = bancoDeDados.CriarComando(@"select c.id, 3 motivo from tab_hab_emi_cfo_cfoc c where c.validade_registro < sysdate
union select a.hab id, 4 motivo from (select count(p.id) qtd, p.habilitar_emi_id hab from tab_hab_emi_cfo_cfoc_praga p group by p.habilitar_emi_id) a,
(select count(p.id) qtd_venc, p.habilitar_emi_id hab_venc from tab_hab_emi_cfo_cfoc_praga p where p.data_habilitacao_final < sysdate
group by p.habilitar_emi_id) b where a.hab = b.hab_venc and a.qtd = b.qtd_venc order by 2 desc" );
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
while (reader.Read())
{
HabilitarEmissaoCFOCFOC entidade = new HabilitarEmissaoCFOCFOC();
entidade.Id = reader.GetValue <Int32>("id");
entidade.Motivo = reader.GetValue <Int32>("motivo");
lista.Add(entidade);
}
reader.Close();
}
}
return(lista);
}
public bool VerificarAlterarSituacao(HabilitarEmissaoCFOCFOC habilitar)
{
if (String.IsNullOrEmpty(habilitar.SituacaoData))
{
Validacao.Add(Msg.SituacaoDataObrigatoria);
}
else
{
if (!ValidacoesGenericasBus.ValidarData(habilitar.SituacaoData))
{
Validacao.Add(Msg.SituacaoDataInvalida);
}
}
if (habilitar.Situacao == 0)
{
Validacao.Add(Msg.SituacaoObrigatoria);
}
if (habilitar.Situacao == 3)
{
if (habilitar.Motivo == 0)
{
Validacao.Add(Msg.MotivoObrigatorio);
}
}
if (String.IsNullOrEmpty(habilitar.Observacao))
{
Validacao.Add(Msg.SituacaoObservacaoObrigatoria);
}
return(Validacao.EhValido);
}
internal void AlterarSituacao(HabilitarEmissaoCFOCFOC habilitar, BancoDeDados banco = null, Executor executor = null)
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
bancoDeDados.IniciarTransacao();
#region HabilitarEmissaoCFOCFOC
bancoDeDados.IniciarTransacao();
Comando comando = bancoDeDados.CriarComando(@"
update tab_hab_emi_cfo_cfoc p set p.motivo = :motivo, p.observacao = :observacao, p.situacao_data =:situacao_data,
p.situacao = :situacao, p.tid = :tid where p.id = :id" , EsquemaBanco);
comando.AdicionarParametroEntrada("id", habilitar.Id, DbType.Int32);
comando.AdicionarParametroEntrada("motivo", (habilitar.Motivo.HasValue && habilitar.Motivo > 0) ? habilitar.Motivo : null, DbType.Int32);
comando.AdicionarParametroEntrada("observacao", DbType.String, 250, habilitar.Observacao);
comando.AdicionarParametroEntrada("situacao_data", habilitar.SituacaoData, DbType.DateTime);
comando.AdicionarParametroEntrada("situacao", habilitar.Situacao, DbType.Int32);
comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
bancoDeDados.ExecutarNonQuery(comando);
#endregion
Historico.Gerar(habilitar.Id, eHistoricoArtefato.habilitaremissaocfocfoc, eHistoricoAcao.alterarsituacao, bancoDeDados, executor);
bancoDeDados.Commit();
}
}
public HabilitarEmissaoCFOCFOCVM()
{
Situacoes = new List <SelectListItem>();
Estados = new List <SelectListItem>();
HabilitarEmissao = new HabilitarEmissaoCFOCFOC();
IsVisualizar = false;
IsAjaxRequest = false;
}
public HabilitarEmissaoCFOCFOCVM(List <Situacao> situacoes, List <Estado> estados, List <Lista> motivos)
{
SituacaoMotivos = ViewModelHelper.CriarSelectList(motivos, true);
Situacoes = ViewModelHelper.CriarSelectList(situacoes, true);
Estados = ViewModelHelper.CriarSelectList(estados, itemTextoPadrao: false);
HabilitarEmissao = new HabilitarEmissaoCFOCFOC();
IsVisualizar = false;
IsAjaxRequest = false;
}
public bool VerificarAlterarSituacao(HabilitarEmissaoCFOCFOC habilitar)
{
if (String.IsNullOrEmpty(habilitar.SituacaoData))
{
Validacao.Add(Msg.SituacaoDataObrigatoria);
}
else
{
if (!ValidacoesGenericasBus.ValidarData(habilitar.SituacaoData) ||
Convert.ToDateTime(habilitar.SituacaoData) < new DateTime(2000, 1, 1))
{
Validacao.Add(Msg.SituacaoDataInvalida);
}
}
//Nenhuma
if (habilitar.Situacao == 0)
{
Validacao.Add(Msg.SituacaoObrigatoria);
}
//Ativo
if (habilitar.Situacao == 1)
{
if (string.IsNullOrWhiteSpace(habilitar.NumeroDua))
{
Validacao.Add(Msg.NumeroDuaObrigatorio);
}
if (string.IsNullOrWhiteSpace(habilitar.DataPagamentoDUA))
{
Validacao.Add(Msg.DataPagamentoObrigatorio);
}
}
//Inativo
if (habilitar.Situacao == 3)
{
if (habilitar.Motivo == null || habilitar.Motivo == 0)
{
Validacao.Add(Msg.MotivoObrigatorio);
}
else if ((habilitar.Motivo == (int)eHabilitacaoCFOCFOCMotivo.Suspensao || habilitar.Motivo == (int)eHabilitacaoCFOCFOCMotivo.Descredenciamento) &&
string.IsNullOrWhiteSpace(habilitar.NumeroProcesso))
{
Validacao.Add(Msg.NumeroProcessoObrigatorio);
}
}
if (String.IsNullOrEmpty(habilitar.Observacao))
{
Validacao.Add(Msg.SituacaoObservacaoObrigatoria);
}
return(Validacao.EhValido);
}
public bool ValidarAssociarResponsavelTecnicoHabilitado(HabilitarEmissaoCFOCFOC habilitacao, List <Cultivar> cultivares)
{
#region Configurar
cultivares = cultivares ?? new List <Cultivar>();
if (habilitacao.Pragas == null || habilitacao.Pragas.Count < 1)
{
habilitacao = new HabilitarEmissaoCFOCFOCBus().ObterPorCredenciado(habilitacao.Responsavel.Id);
if (Validacao.EhValido)
{
PragaInternoBus pragaBus = new PragaInternoBus();
habilitacao.Pragas.ForEach(x =>
{
x.Praga.Culturas = pragaBus.ObterCulturas(x.Praga.Id);
});
}
else
{
return(false);
}
}
#endregion
if (habilitacao.Situacao == (int)eHabilitacaoCFOCFOCSituacao.Inativo)
{
Validacao.Add(Mensagem.UnidadeConsolidacao.HabilitacaoInativa);
return(false);
}
if (!habilitacao.Pragas.SelectMany(p => p.Praga.Culturas).ToList().Exists(c => cultivares.Exists(x => x.CulturaId == c.Id)))
{
Validacao.Add(Mensagem.UnidadeConsolidacao.ResponsavelTecnicoNaoHabilitadoParaCultura);
return(false);
}
foreach (var habPraga in habilitacao.Pragas)
{
foreach (var cultivarItem in habPraga.Praga.Culturas.SelectMany(x => x.LstCultivar))
{
foreach (var item in cultivares)
{
if (cultivarItem.Id == item.Id && DateTime.Parse(habPraga.DataFinalHabilitacao) < DateTime.Today)
{
Validacao.Add(Mensagem.UnidadeConsolidacao.ResponsavelTecnicoHabilitacaoPragaVencida);
return(false);
}
}
}
}
return(Validacao.EhValido);
}
public bool VerificarEditar(HabilitarEmissaoCFOCFOC habilitar)
{
if (_da.ValidarNumeroHabilitacao(habilitar.Id, habilitar.NumeroHabilitacao))
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.NumeroHabilitacaoJaExiste);
}
VerificarHabilitarEmissaoCFOCFOC(habilitar);
return(Validacao.EhValido);
}
public bool ValidarPraga(HabilitarEmissaoCFOCFOC habilitar, PragaHabilitarEmissao praga)
{
try
{
_validar.VerificarAdicionarPraga(habilitar, praga);
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(Validacao.EhValido);
}
public bool Salvar(HabilitarEmissaoCFOCFOC habilitar)
{
if (habilitar.Id > 0)
{
VerificarEditar(habilitar);
}
else
{
VerificarCriar(habilitar);
}
return(Validacao.EhValido);
}
public ActionResult AlterarHabilitarEmissaoCFOCFOC(HabilitarEmissaoCFOCFOC habilitar)
{
HabilitarEmissaoCFOCFOCVM viewModel = new HabilitarEmissaoCFOCFOCVM(_busLista.HabilitacaoCFOSituacoes, _busLista.Estados, _busLista.HabilitacaoCFOMotivos);
if (Validacao.EhValido && habilitar != null)
{
viewModel.HabilitarEmissao = habilitar;
viewModel.HabilitarEmissao.UF = viewModel.HabilitarEmissao.UF == 0 ? ViewModelHelper.EstadoDefaultId() : viewModel.HabilitarEmissao.UF;
viewModel.IsEditar = true;
viewModel.IsVisualizar = false;
viewModel.IsAjaxRequest = true;
}
return(PartialView("HabilitarEmissaoCFOCFOCSalvar", viewModel));
}
public ActionResult AlterarSituacaoHabilitacaoCFO(HabilitarEmissaoCFOCFOC habilitar)
{
if (_busHabilitar.AlterarSituacao(habilitar))
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.Alterado);
string urlRedireciona = Url.Action("IndexHabilitarEmissaoCFOCFOC", "Credenciado");
urlRedireciona += "?Msg=" + Validacao.QueryParam();
return(Json(new { EhValido = Validacao.EhValido, UrlRedireciona = urlRedireciona, Msg = Validacao.Erros }));
}
else
{
return(Json(new { EhValido = false, Msg = Validacao.Erros }));
}
}
public HabilitarEmissaoCFOCFOC Obter(int id, Boolean isCredenciado = false)
{
HabilitarEmissaoCFOCFOC retorno = _da.Obter(id, isCredenciado: isCredenciado);
if (retorno != null)
{
return(retorno);
}
else
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.CpfNaoCadastrado);
}
return(retorno);
}
public bool Salvar(HabilitarEmissaoCFOCFOC habilitar)
{
try
{
if (_validar.Salvar(habilitar))
{
#region Arquivos/Diretorio
ArquivoBus _busArquivo = new ArquivoBus(eExecutorTipo.Interno);
if (habilitar.Arquivo != null && !String.IsNullOrWhiteSpace(habilitar.Arquivo.TemporarioNome))
{
if (habilitar.Arquivo.Id == 0)
{
habilitar.Arquivo = _busArquivo.Copiar(habilitar.Arquivo);
}
}
#endregion
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
bancoDeDados.IniciarTransacao();
#region Arquivos/Banco
ArquivoDa arquivoDa = new ArquivoDa();
if (habilitar.Arquivo != null && !String.IsNullOrWhiteSpace(habilitar.Arquivo.TemporarioNome))
{
if (habilitar.Arquivo.Id == 0)
{
arquivoDa.Salvar(habilitar.Arquivo, User.FuncionarioId, User.Name, User.Login, (int)eExecutorTipo.Interno, User.FuncionarioTid, bancoDeDados);
}
}
#endregion
_da.Salvar(habilitar, bancoDeDados);
bancoDeDados.Commit();
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(Validacao.EhValido);
}
public void Salvar(HabilitarEmissaoCFOCFOC habilitar, BancoDeDados banco = null, Executor executor = null)
{
if (habilitar == null)
{
throw new Exception("Habilitar emissão é nulo.");
}
if (habilitar.Id <= 0)
{
Criar(habilitar, banco, executor);
}
else
{
Editar(habilitar, banco, executor);
}
}
public bool VerificarCriar(HabilitarEmissaoCFOCFOC habilitar)
{
if (_da.ValidarNumeroHabilitacao(habilitar.Id, habilitar.NumeroHabilitacao))
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.NumeroHabilitacaoJaExiste);
}
VerificarHabilitarEmissaoCFOCFOC(habilitar);
if (_da.ValidarResponsavelHabilitado(habilitar.Responsavel.Id))
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.ResponsavelHabilitado);
}
return(Validacao.EhValido);
}
public bool VerificarAdicionarPraga(HabilitarEmissaoCFOCFOC habilitar, PragaHabilitarEmissao praga)
{
if (String.IsNullOrEmpty(praga.Praga.NomeCientifico))
{
Validacao.Add(Msg.PragaNomeObrigatorio);
}
if (String.IsNullOrEmpty(praga.DataInicialHabilitacao))
{
Validacao.Add(Msg.DataInicialHabilitacaoObrigatoria);
}
else
{
if (!ValidacoesGenericasBus.ValidarData(praga.DataInicialHabilitacao))
{
Validacao.Add(Msg.DataInicialHabilitacaoInvalida);
}
else if (Convert.ToDateTime(praga.DataInicialHabilitacao) > DateTime.Today.AddDays(1).Subtract(TimeSpan.FromSeconds(1)))
{
Validacao.Add(Msg.DataInicialHabilitacaoMaiorAtual);
}
}
if (String.IsNullOrEmpty(praga.DataFinalHabilitacao))
{
Validacao.Add(Msg.DataFinalHabilitacaoObrigatorio);
}
else
{
if (!ValidacoesGenericasBus.ValidarData(praga.DataFinalHabilitacao))
{
Validacao.Add(Msg.DataFinalHabilitacaoInvalida);
}
}
var existe = habilitar.Pragas.Exists(x => !String.IsNullOrWhiteSpace(praga.Praga.NomeCientifico) && (x.Praga.NomeCientifico.Trim() == praga.Praga.NomeCientifico.Trim()));
if (existe)
{
Validacao.Add(Msg.PragaJaAdicionada);
}
return(Validacao.EhValido);
}
public HabilitarEmissaoCFOCFOC ObterPorCredenciado(int credenciadoId, bool simplificado = false)
{
HabilitarEmissaoCFOCFOC retorno = null;
try
{
retorno = _da.ObterPorCredenciado(credenciadoId, simplificado);
if (retorno == null || retorno.Id < 1)
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.NaoExisteHabilitacaoParaEsteCredenciado);
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(retorno);
}
public ActionResult ObterResponsavelTecnico(int credenciadoId, Cultura cultura, Cultivar cultivar)
{
HabilitarEmissaoCFOCFOC credenciadoHabilitado = _busHabilitacaoCFOCFOC.ObterPorCredenciado(credenciadoId);
if (Validacao.EhValido)
{
credenciadoHabilitado.Pragas.ForEach(x =>
{
x.Praga.Culturas = _pragaBus.ObterCulturas(x.Praga.Id);
});
_validar.ValidarResponsavelTecnicoHabilitado(credenciadoHabilitado, cultura);
}
return(Json(new
{
@Msg = Validacao.Erros,
@EhValido = Validacao.EhValido,
@Habilitacao = credenciadoHabilitado
}));
}
internal void AlterarSituacao(HabilitarEmissaoCFOCFOC entidade, BancoDeDados banco)
{
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
bancoDeDados.IniciarTransacao();
Comando comando = bancoDeDados.CriarComando(@"
update tab_hab_emi_cfo_cfoc p set p.motivo = :motivo, p.observacao = :observacao, p.situacao_data = sysdate, p.situacao = :situacao,
p.tid = :tid where p.id = :id and p.situacao != 3" , EsquemaBanco);
comando.AdicionarParametroEntrada("id", entidade.Id, DbType.Int32);
comando.AdicionarParametroEntrada("motivo", (entidade.Motivo.HasValue && entidade.Motivo > 0) ? entidade.Motivo : null, DbType.Int32);
comando.AdicionarParametroEntrada("observacao", DbType.String, 250, entidade.Observacao);
comando.AdicionarParametroEntrada("situacao", entidade.Situacao, DbType.Int32);
comando.AdicionarParametroEntrada("tid", DbType.String, 36, GerenciadorTransacao.ObterIDAtual());
bancoDeDados.ExecutarNonQuery(comando);
Historico.Gerar(entidade.Id, eHistoricoArtefato.habilitaremissaocfocfoc, eHistoricoAcao.alterarsituacao, bancoDeDados);
bancoDeDados.Commit();
}
}
public bool AlterarSituacao(HabilitarEmissaoCFOCFOC habilitar)
{
try
{
if (_validar.AlterarSituacao(habilitar))
{
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
bancoDeDados.IniciarTransacao();
_da.AlterarSituacao(habilitar, bancoDeDados);
bancoDeDados.Commit();
}
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
return(Validacao.EhValido);
}
public HabilitarEmissaoCFOCFOC Obter(int id, Boolean isCredenciado = false, Boolean isEditar = false)
{
HabilitarEmissaoCFOCFOC retorno = _da.Obter(id, isCredenciado: isCredenciado);
if (retorno == null && isCredenciado)
{
retorno = ObterCredenciado(id, isCredenciado);
}
if (retorno != null && retorno.Responsavel.Id > 0)
{
CredenciadoBus _busCredenciado = new CredenciadoBus();
var pessoa = _busCredenciado.Obter(retorno.Responsavel.Pessoa.Fisica.CPF);
retorno.Responsavel.Pessoa = pessoa.Pessoa;
if (_da.ValidarResponsavelHabilitado(retorno.Id) && !isEditar && !isCredenciado)
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.ResponsavelHabilitado);
}
if (retorno.Responsavel.Pessoa.Fisica.Profissao.Id == 0 || String.IsNullOrWhiteSpace(retorno.Responsavel.Pessoa.Fisica.Profissao.Registro))
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.SemProfissaoRegistro);
}
return(retorno);
}
else
{
Validacao.Add(Mensagem.HabilitarEmissaoCFOCFOC.CpfNaoCadastrado);
}
return(retorno);
}
public bool VerificarHabilitarEmissaoCFOCFOC(HabilitarEmissaoCFOCFOC habilitar)
{
if (habilitar.Responsavel.Id == 0)
{
Validacao.Add(Msg.ResponsavelObrigatorio);
}
int auxiliar = 0;
if (int.TryParse(habilitar.NumeroHabilitacao, out auxiliar) && String.IsNullOrEmpty(habilitar.NumeroHabilitacao))
{
Validacao.Add(Msg.NumeroHabilitacaoObrigatorio);
}
else
{
if (habilitar.NumeroHabilitacao.Length != 8)
{
Validacao.Add(Msg.NumeroHabilitacaoTamanhoInvalido);
}
}
if (String.IsNullOrEmpty(habilitar.ValidadeRegistro))
{
Validacao.Add(Msg.ValidadeRegistroObrigatorio);
}
else
{
if (!ValidacoesGenericasBus.ValidarData(habilitar.ValidadeRegistro))
{
Validacao.Add(Msg.ValidadeRegistroInvalida);
}
}
if (String.IsNullOrEmpty(habilitar.NumeroDua))
{
Validacao.Add(Msg.NumeroDuaObrigatorio);
}
if (Convert.ToBoolean(habilitar.ExtensaoHabilitacao))
{
if (string.IsNullOrWhiteSpace(habilitar.NumeroHabilitacaoOrigem))
{
Validacao.Add(Msg.NumeroHabilitacaoOrigemObrigatorio);
}
else
{
if (habilitar.NumeroHabilitacaoOrigem.Length != 8)
{
Validacao.Add(Msg.NumeroHabilitacaoOrigemTamanhoInvalido);
}
if (habilitar.NumeroHabilitacao != habilitar.NumeroHabilitacaoOrigem)
{
Validacao.Add(Msg.NumeroHabilitacaoOrigemInvalido);
}
}
}
if (habilitar.UF == 0)
{
Validacao.Add(Msg.UFObrigatorio);
}
else
{
ListaBus listaBus = new ListaBus();
Estado estadoPadrao = listaBus.Estados.SingleOrDefault(x => String.Equals(x.Texto, _configSys.Obter <String>(ConfiguracaoSistema.KeyEstadoDefault), StringComparison.InvariantCultureIgnoreCase));
if (estadoPadrao.Id != habilitar.UF && string.IsNullOrWhiteSpace(habilitar.NumeroVistoCrea))
{
Validacao.Add(Msg.NumeroVistoCreaObrigatorio);
}
}
if (habilitar.Pragas.Count == 0)
{
Validacao.Add(Msg.PragaObrigatorio);
}
foreach (var item in habilitar.Pragas)
{
if (String.IsNullOrEmpty(item.DataInicialHabilitacao))
{
Validacao.Add(Msg.DataInicialHabilitacaoObrigatoria);
}
else
{
if (!ValidacoesGenericasBus.ValidarData(item.DataInicialHabilitacao))
{
Validacao.Add(Msg.DataInicialHabilitacaoInvalida);
}
else if (Convert.ToDateTime(item.DataInicialHabilitacao) > DateTime.Today.AddDays(1).Subtract(TimeSpan.FromSeconds(1)))
{
Validacao.Add(Msg.DataInicialHabilitacaoMaiorAtual);
}
}
if (String.IsNullOrEmpty(item.DataFinalHabilitacao))
{
Validacao.Add(Msg.DataFinalHabilitacaoObrigatorio);
}
else
{
if (!ValidacoesGenericasBus.ValidarData(item.DataFinalHabilitacao))
{
Validacao.Add(Msg.DataFinalHabilitacaoInvalida);
}
}
}
return(Validacao.EhValido);
}
internal HabilitarEmissaoCFOCFOC Obter(int id, bool simplificado = false, string _schemaBanco = null, bool isCredenciado = false)
{
HabilitarEmissaoCFOCFOC habilitar = null;
PragaHabilitarEmissao praga = null;
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
#region Habilitar Emissão
Comando comando = bancoDeDados.CriarComando(@"select t.id, t.tid, cc.id pessoa, t.responsavel, t.responsavel_arquivo, aa.nome responsavel_arquivo_nome, cc.cpf responsavel_cpf, cc.nome responsavel_nome,
pc.registro registro_crea, t.numero_habilitacao, trunc(t.validade_registro) validade_registro, trunc(t.situacao_data) situacao_data, t.situacao, ls.texto situacao_texto, t.motivo,
lm.texto motivo_texto, t.observacao, t.numero_dua, t.extensao_habilitacao, t.numero_habilitacao_ori, t.uf, t.numero_visto_crea, t.tid from tab_hab_emi_cfo_cfoc t, tab_credenciado tc,
cre_pessoa cc, cre_pessoa_profissao pc, lov_hab_emissao_cfo_situacao ls, lov_hab_emissao_cfo_motivo lm, tab_arquivo aa where t.situacao = ls.id and t.motivo = lm.id(+)
and t.responsavel_arquivo = aa.id(+) and tc.id = t.responsavel and tc.pessoa = cc.id and cc.id = pc.pessoa(+) and t.id = :id" , UsuarioCredenciado);
if (isCredenciado)
{
comando.DbCommand.CommandText = comando.DbCommand.CommandText.Replace("and t.id = :id", "and t.responsavel = :id");
}
comando.AdicionarParametroEntrada("id", id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
habilitar = new HabilitarEmissaoCFOCFOC();
habilitar.Id = reader.GetValue <Int32>("id");
habilitar.Tid = reader.GetValue <String>("tid");
habilitar.Responsavel.Id = reader.GetValue <Int32>("responsavel");
habilitar.Responsavel.Pessoa.Id = reader.GetValue <Int32>("pessoa");
habilitar.Arquivo.Id = reader.GetValue <Int32>("responsavel_arquivo");
habilitar.Arquivo.Nome = reader.GetValue <String>("responsavel_arquivo_nome");
habilitar.Responsavel.Pessoa.NomeRazaoSocial = reader.GetValue <String>("responsavel_nome");
habilitar.Responsavel.Pessoa.CPFCNPJ = reader.GetValue <String>("responsavel_cpf");
habilitar.NumeroHabilitacao = reader.GetValue <String>("numero_habilitacao");
habilitar.ValidadeRegistro = reader.GetValue <DateTime>("validade_registro").ToShortDateString();
habilitar.SituacaoData = reader.GetValue <DateTime>("situacao_data").ToShortDateString();
habilitar.Situacao = reader.GetValue <Int32>("situacao");
habilitar.SituacaoTexto = reader.GetValue <String>("situacao_texto");
habilitar.Motivo = reader.GetValue <Int32>("motivo");
habilitar.MotivoTexto = reader.GetValue <String>("motivo_texto");
habilitar.Observacao = reader.GetValue <String>("observacao");
habilitar.NumeroDua = reader.GetValue <String>("numero_dua");
habilitar.ExtensaoHabilitacao = reader.GetValue <Int32>("extensao_habilitacao");
habilitar.NumeroHabilitacaoOrigem = reader.GetValue <String>("numero_habilitacao_ori");
habilitar.RegistroCrea = reader.GetValue <String>("registro_crea");
habilitar.UF = reader.GetValue <Int32>("uf");
habilitar.NumeroVistoCrea = reader.GetValue <String>("numero_visto_crea");
}
reader.Close();
}
#endregion
if (simplificado)
{
return(habilitar);
}
#region Pragas
if (habilitar != null)
{
comando = bancoDeDados.CriarComando(@"
select hp.id, hp.praga, pa.nome_cientifico, pa.nome_comum, trunc(hp.data_habilitacao_inicial) data_habilitacao_inicial,
trunc(hp.data_habilitacao_final) data_habilitacao_final, hp.tid, stragg(c.texto) cultura
from tab_hab_emi_cfo_cfoc_praga hp, tab_praga pa, tab_praga_cultura pc, tab_cultura c
where pa.id = hp.praga and hp.praga = pc.praga(+) and pc.cultura = c.id(+) and hp.habilitar_emi_id = :id
group by hp.id, hp.praga, pa.nome_cientifico, pa.nome_comum, hp.data_habilitacao_inicial, hp.data_habilitacao_final, hp.tid" , UsuarioCredenciado);
comando.AdicionarParametroEntrada("id", habilitar.Id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
while (reader.Read())
{
praga = new PragaHabilitarEmissao();
praga.Id = reader.GetValue <Int32>("id");
praga.Praga.Id = reader.GetValue <Int32>("praga");
praga.Praga.NomeCientifico = reader.GetValue <String>("nome_cientifico");
praga.Praga.NomeComum = reader.GetValue <String>("nome_comum");
praga.DataInicialHabilitacao = reader.GetValue <DateTime>("data_habilitacao_inicial").ToShortDateString();;
praga.DataFinalHabilitacao = reader.GetValue <DateTime>("data_habilitacao_final").ToShortDateString();;
praga.Tid = reader.GetValue <String>("tid");
praga.Cultura = reader.GetValue <String>("cultura");
habilitar.Pragas.Add(praga);
}
reader.Close();
}
comando = bancoDeDados.CriarComando(@"select
(select c.valor from cre_pessoa_meio_contato c where c.pessoa = :id and c.meio_contato = 1) res,
(select c.valor from cre_pessoa_meio_contato c where c.pessoa = :id and c.meio_contato = 2) cel,
(select c.valor from cre_pessoa_meio_contato c where c.pessoa = :id and c.meio_contato = 3) fax,
(select c.valor from cre_pessoa_meio_contato c where c.pessoa = :id and c.meio_contato = 4) com,
(select c.valor from cre_pessoa_meio_contato c where c.pessoa = :id and c.meio_contato = 5) email
from dual" , UsuarioCredenciado);
comando.AdicionarParametroEntrada("id", habilitar.Responsavel.Pessoa.Id, DbType.Int32);
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
if (reader.Read())
{
habilitar.TelefoneResidencial = reader.GetValue <String>("res");
habilitar.TelefoneCelular = reader.GetValue <String>("cel");
habilitar.TelefoneFax = reader.GetValue <String>("fax");
habilitar.TelefoneComercial = reader.GetValue <String>("com");
habilitar.Email = reader.GetValue <String>("email");
}
reader.Close();
}
}
#endregion
}
return(habilitar);
}
public ActionResult ValidarAdicionarPraga(HabilitarEmissaoCFOCFOC habilitar, PragaHabilitarEmissao praga)
{
_busHabilitar.ValidarPraga(habilitar, praga);
return(Json(new { @EhValido = Validacao.EhValido, @Msg = Validacao.Erros }, JsonRequestBehavior.AllowGet));
}