public void Salvar(Titulo titulo)
{
try
{
titulo.Autor = new Funcionario()
{
Id = User.FuncionarioId
};
if (titulo.Id <= 0)
{
titulo.Situacao.Id = (int)eTituloSituacao.EmCadastro;
titulo.DataCriacao.Data = DateTime.Now;
}
if (titulo.Modelo.Regra(eRegra.NumeracaoAutomatica))
{
titulo.Numero.Inteiro = null;
titulo.Numero.Ano = null;
}
//Carrega o Modelo e suas regras do modelo
titulo.Modelo = _busModelo.Obter(titulo.Modelo.Id);
IEspecificidadeBus busEsp = EspecificiadadeBusFactory.Criar(titulo.Modelo.Codigo.GetValueOrDefault());
string jsonEsp = (titulo.Especificidade != null) ? titulo.Especificidade.Json : null;
titulo.Especificidade = (Especificidade)busEsp.Deserialize(jsonEsp);
titulo.Especificidade = titulo.ToEspecificidade();
//Delega a validação de especificidade
_validar.ValidarEspecificidade = () =>
{
busEsp.Validar.Salvar(titulo.Especificidade);
};
if (_validar.Salvar(titulo))
{
#region Arquivos/Diretorio
ArquivoBus _busArquivo = new ArquivoBus(eExecutorTipo.Interno);
if (!titulo.Modelo.Regra(eRegra.PdfGeradoSistema) && titulo.ArquivoPdf.Id == 0)
{
titulo.ArquivoPdf = _busArquivo.Copiar(titulo.ArquivoPdf);
}
if (titulo.Anexos != null && titulo.Anexos.Count > 0)
{
foreach (Anexo anexo in titulo.Anexos)
{
if (anexo.Arquivo.Id == 0)
{
anexo.Arquivo = _busArquivo.Copiar(anexo.Arquivo);
}
}
}
#endregion
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
GerenciadorTransacao.ObterIDAtual();
bancoDeDados.IniciarTransacao();
#region Arquivos/Banco
ArquivoDa arquivoDa = new ArquivoDa();
if (!titulo.Modelo.Regra(eRegra.PdfGeradoSistema))
{
arquivoDa.Salvar(titulo.ArquivoPdf, User.FuncionarioId, User.Name, User.Login, (int)eExecutorTipo.Interno, User.FuncionarioTid, bancoDeDados);
}
if (titulo.Anexos != null && titulo.Anexos.Count > 0)
{
foreach (Anexo anexo in titulo.Anexos)
{
if (anexo.Arquivo.Id == 0)
{
arquivoDa.Salvar(anexo.Arquivo, User.FuncionarioId, User.Name, User.Login, (int)eExecutorTipo.Interno, User.FuncionarioTid, bancoDeDados);
}
}
}
#endregion
_da.Salvar(titulo, bancoDeDados);
//Atualiza os Ids em Especificidade
titulo.Especificidade = titulo.ToEspecificidade();
busEsp.Salvar(titulo.Especificidade, bancoDeDados);
//Trata quando o catch do busEsp.Salvar silencia o erro.
if (!Validacao.EhValido)
{
return;
}
bancoDeDados.Commit();
}
Validacao.Add(Mensagem.Titulo.Salvar);
}
}
catch (Exception exc)
{
Validacao.AddErro(exc);
}
}
public bool ReservaLegalSalvar(ReservaLegal reserva)
{
if (reserva.SituacaoId <= 0)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalSituacaoObrigatorio);
}
if (reserva.SituacaoId == (int)eReservaLegalSituacao.NaoInformada)
{
return(Validacao.EhValido);
}
if (reserva.SituacaoId == (int)eReservaLegalSituacao.Proposta)
{
switch (reserva.LocalizacaoId)
{
#region Receptora
case (int)eReservaLegalLocalizacao.CompensacaoEmpreendimentoReceptora:
if (reserva.CedentePossuiEmpreendimento < 0)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalCedentePossuiCodigoEmpreendimentoObrigatorio);
}
if (reserva.CedentePossuiEmpreendimento == 1)
{
if (reserva.EmpreendimentoCompensacao.Id > 0)
{
ValidarEmpreendimentoCedente(reserva);
VerificarRLAssociadaEmOutroEmpreendimentoCedente(reserva.Id, reserva.EmpreendimentoCompensacao.Id, reserva.IdentificacaoARLCedente);
}
}
break;
#endregion
#region Cedente
case (int)eReservaLegalLocalizacao.CompensacaoEmpreendimentoCedente:
if (reserva.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.Preservada && reserva.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.EmRecuperacao)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalCedentePreservadaOuEmRecuperacao);
}
break;
#endregion
case (int)eReservaLegalLocalizacao.NestaMatricula:
case (int)eReservaLegalLocalizacao.NestaPosse:
break;
default:
Validacao.Add(Mensagem.Dominialidade.ReservaLegalLocalizacaoObrigatorio);
break;
}
}
if (reserva.SituacaoId == (int)eReservaLegalSituacao.Registrada)
{
switch (reserva.LocalizacaoId)
{
#region Receptora
case (int)eReservaLegalLocalizacao.CompensacaoEmpreendimentoReceptora:
if (reserva.CedentePossuiEmpreendimento < 0)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalCedentePossuiCodigoEmpreendimentoObrigatorio);
}
ValidarCamposSituacaoRegistrada(reserva);
if (reserva.CedentePossuiEmpreendimento == 0)
{
if (reserva.ARLCedida <= 0)
{
Validacao.Add(Mensagem.Dominialidade.ARLCedidaObrigatorio);
}
if (reserva.SituacaoVegetalId <= 0)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalSituacaoVegetalObrigatorio);
}
if (reserva.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.EmRecuperacao && reserva.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.Preservada)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalSituacaoVegetalInvalido);
}
}
if (reserva.CedentePossuiEmpreendimento == 1)
{
if (reserva.IdentificacaoARLCedente > 0)
{
ValidarEmpreendimentoCedente(reserva);
VerificarRLAssociadaEmOutroEmpreendimentoCedente(reserva.Id, reserva.EmpreendimentoCompensacao.Id, reserva.IdentificacaoARLCedente);
}
}
break;
#endregion
#region Cedente
case (int)eReservaLegalLocalizacao.CompensacaoEmpreendimentoCedente:
if (reserva.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.Preservada && reserva.SituacaoVegetalId != (int)eReservaLegalSituacaoVegetal.EmRecuperacao)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalCedentePreservadaOuEmRecuperacao);
}
ValidarCamposSituacaoRegistrada(reserva);
if (reserva.ARLRecebida <= 0)
{
Validacao.Add(Mensagem.Dominialidade.ARLRecebidaObrigatorio);
}
break;
#endregion
#region Nesta Matrícula
case (int)eReservaLegalLocalizacao.NestaMatricula:
case (int)eReservaLegalLocalizacao.NestaPosse:
ValidarCamposSituacaoRegistrada(reserva);
break;
#endregion
default:
Validacao.Add(Mensagem.Dominialidade.ReservaLegalLocalizacaoObrigatorio);
break;
}
}
return(Validacao.EhValido);
}
public List <Roteiro> ObterRoteirosPorAtividades(List <Atividade> atividades, BancoDeDados bancoInterno)
{
List <Roteiro> roteiros = new List <Roteiro>();
if (atividades == null || atividades.Count <= 0)
{
return(roteiros);
}
Roteiro roteiroPadrao = ListaCredenciadoBus.RoteiroPadrao.FirstOrDefault(x => x.Setor == atividades[0].SetorId);
if (roteiroPadrao != null)
{
roteiroPadrao = ObterSimplificado(roteiroPadrao.Id, bancoInterno);
}
List <String> titulos = new List <String>();
foreach (var atividade in atividades)
{
foreach (var finalidade in atividade.Finalidades)
{
finalidade.AtividadeId = atividade.Id;
finalidade.AtividadeNome = atividade.NomeAtividade;
finalidade.AtividadeSetorId = atividade.SetorId;
String modeloTituloNaoAdicionadoRoteiro = _da.ModeloTituloNaoAdicionadoRoteiro(finalidade, bancoInterno);
if (!String.IsNullOrWhiteSpace(modeloTituloNaoAdicionadoRoteiro))
{
titulos.Add("\"" + modeloTituloNaoAdicionadoRoteiro + "\"");
continue;
}
Roteiro roteiroAux = _da.ObterRoteirosPorAtividades(finalidade, bancoInterno);
if (roteiroAux == null)
{
roteiroPadrao.AtividadeTexto = atividade.NomeAtividade;
roteiros.Add(roteiroPadrao);
continue;
}
roteiros.Add(roteiroAux);
}
}
if (titulos.Count > 0)
{
Validacao.Add(Mensagem.Roteiro.TituloNaoAdicionadoRoteiroCredenciado(Mensagem.Concatenar(titulos)));
}
#region Faz a magica de agrupar os resultados
roteiros = roteiros.GroupBy(x => x.Id).Select(y => new Roteiro
{
Id = y.First().Id,
Nome = y.First().Nome,
VersaoAtual = y.First().VersaoAtual,
Tid = y.First().Tid,
AtividadeTexto = y.Select(w => w.AtividadeTexto).Distinct().Aggregate((total, atual) => total + " / " + atual)
}).ToList();
#endregion
return(roteiros);
}
public bool Salvar(LocalInfracao localInfracao)
{
if (localInfracao.SetorId == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.SelecioneSetor);
}
if (localInfracao.AreaFiscalizacao == null)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.AreaFiscalizacaoObrigatoria);
}
if (localInfracao.DentroEmpreendimento == 1 && (localInfracao.EmpreendimentoId == null || localInfracao.EmpreendimentoId == 0))
{
Validacao.Add(Mensagem.LocalInfracaoMsg.EmpreendimentoObrigatorio);
}
else if (localInfracao.DentroEmpreendimento == 0 && (localInfracao.PessoaId == 0 || localInfracao.PessoaId == null))
{
Validacao.Add(Mensagem.LocalInfracaoMsg.PessoaObrigatorio);
}
else if (localInfracao.PessoaId.GetValueOrDefault() == 0 && localInfracao.EmpreendimentoId.GetValueOrDefault() == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.PessoaEmpreendimentoObrigatorio);
}
if (localInfracao.EmpreendimentoId.GetValueOrDefault() > 0 && localInfracao.ResponsavelPropriedadeId.GetValueOrDefault() == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.ResponsavelPropriedadeObrigatorio);
}
if (localInfracao.DentroEmpreendimento == 0)
{
if (string.IsNullOrWhiteSpace(localInfracao.LonEasting))
{
Validacao.Add(Mensagem.LocalInfracaoMsg.EastingUtmObrigatorio);
}
if (string.IsNullOrWhiteSpace(localInfracao.LatNorthing))
{
Validacao.Add(Mensagem.LocalInfracaoMsg.NorthingUtmObrigatorio);
}
if (localInfracao.MunicipioId == null || localInfracao.MunicipioId < 1)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.MunicipioObrigatorio);
}
if (string.IsNullOrWhiteSpace(localInfracao.Local))
{
Validacao.Add(Mensagem.LocalInfracaoMsg.LocalObrigatorio);
}
}
else
{
if (localInfracao.PessoaId != localInfracao.ResponsavelId)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.AutuadoDiferenteEmpreendimento);
}
}
return(Validacao.EhValido);
}
internal bool Salvar(Dominialidade dominialidade)
{
if (!_caracterizacaoValidar.Basicas(dominialidade.EmpreendimentoId))
{
return(false);
}
if (dominialidade.Id <= 0 && (_da.ObterPorEmpreendimento(dominialidade.EmpreendimentoId, true) ?? new Dominialidade()).Id > 0)
{
Validacao.Add(Mensagem.Caracterizacao.EmpreendimentoCaracterizacaoJaCriada);
return(false);
}
if (!_caracterizacaoValidar.Dependencias(empreendimentoId: dominialidade.EmpreendimentoId, projetoDigitalId: dominialidade.ProjetoDigitalId, caracterizacaoTipo: (int)eCaracterizacao.Dominialidade))
{
return(false);
}
if (Dominios(dominialidade.Dominios))
{
foreach (Dominio dominio in dominialidade.Dominios)
{
DominioSalvar(dominio);
if (dominio.ReservasLegais != null && dominio.ReservasLegais.Count > 0)
{
foreach (ReservaLegal reserva in dominio.ReservasLegais)
{
ReservaLegalSalvar(reserva);
}
}
}
}
string prefixo = "Dominialidade";
if (!dominialidade.PossuiAreaExcedenteMatricula.HasValue)
{
Validacao.Add(Mensagem.Dominialidade.PossuiAreaExcedenteMatriculaObrigatorio);
}
if (String.IsNullOrWhiteSpace(dominialidade.ConfrontacaoNorte))
{
Validacao.Add(Mensagem.Dominialidade.ConfrontacaoNorteObrigatorio(prefixo));
}
if (String.IsNullOrWhiteSpace(dominialidade.ConfrontacaoSul))
{
Validacao.Add(Mensagem.Dominialidade.ConfrontacaoSulObrigatorio(prefixo));
}
if (String.IsNullOrWhiteSpace(dominialidade.ConfrontacaoLeste))
{
Validacao.Add(Mensagem.Dominialidade.ConfrontacaoLesteObrigatorio(prefixo));
}
if (String.IsNullOrWhiteSpace(dominialidade.ConfrontacaoOeste))
{
Validacao.Add(Mensagem.Dominialidade.ConfrontacaoOesteObrigatorio(prefixo));
}
List <string> auxiliar = _da.VerificarExcluirDominios(dominialidade);
if (auxiliar != null && auxiliar.Count > 0)
{
foreach (var item in auxiliar)
{
Validacao.Add(Mensagem.Dominialidade.DominioAssossiadoReserva(item));
}
}
return(Validacao.EhValido);
}
public bool ValidarRepresentante(Pessoa representante, bool isConjuge = false)
{
VerificarCriarCpf(representante, isConjuge);
if (String.IsNullOrWhiteSpace(representante.Fisica.Nome))
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioNomeMsg(isConjuge));
}
if (string.IsNullOrWhiteSpace(representante.Fisica.Nacionalidade))
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioNacionalidadeMsg(isConjuge));
}
if (string.IsNullOrWhiteSpace(representante.Fisica.Naturalidade))
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioNaturalidadeMsg(isConjuge));
}
if (!representante.Fisica.Sexo.HasValue && isConjuge)
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioSexoMsg(isConjuge));
}
else
{
if (representante.Fisica.Sexo <= 0)
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioSexoMsg(isConjuge));
}
}
if (representante.Fisica.EstadoCivil <= 0)
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioEstadoCivilMsg(isConjuge));
}
if (representante.Fisica.DataNascimento.GetValueOrDefault() == DateTime.MinValue)
{
Validacao.Add(Mensagem.Pessoa.DataNascimentoObrigatoriaMsg(isConjuge));
}
else
{
VerificarFisicaDataNascimento(representante.Fisica.DataNascimento, isConjuge);
}
if (representante.Fisica.ConjugeId.GetValueOrDefault() > 0)
{
if (_da.ExistePessoa(representante.Fisica.ConjugeCPF, representante.CredenciadoId.GetValueOrDefault()) <= 0)
{
Validacao.Add(Mensagem.Pessoa.ConjugeNaoExiste);
}
if (representante.Fisica.ConjugeId == representante.Id)
{
Validacao.Add(Mensagem.Pessoa.PessoaConjugeSaoIguais);
}
if (_da.ValidarConjugeAssociado(representante.CPFCNPJ, representante.Fisica.ConjugeCPF, User.EtramiteIdentity.FuncionarioId))
{
Validacao.Add(Mensagem.Pessoa.ConjugeJaAssociado);
}
}
else if (representante.Fisica.Conjuge != null && !string.IsNullOrEmpty(representante.Fisica.Conjuge.CPFCNPJ))
{
if (representante.Fisica.Conjuge.CPFCNPJ == representante.CPFCNPJ)
{
Validacao.Add(Mensagem.Pessoa.PessoaConjugeSaoIguais);
}
if (_da.ValidarConjugeAssociado(representante.CPFCNPJ, representante.Fisica.Conjuge.CPFCNPJ, representante.CredenciadoId.GetValueOrDefault()))
{
Validacao.Add(Mensagem.Pessoa.ConjugeJaAssociado);
}
}
return(Validacao.EhValido);
}
public bool SalvarArquivo(TramitacaoArquivo arquivo)
{
if (string.IsNullOrEmpty(arquivo.Nome))
{
Validacao.Add(Msg.NomeArquivoObrigratorio);
}
if (arquivo.SetorId.GetValueOrDefault() <= 0)
{
Validacao.Add(Msg.SetorArquivoObrigratorio);
}
if (arquivo.TipoId.GetValueOrDefault() <= 0)
{
Validacao.Add(Msg.TipoArquivoObrigratorio);
}
if (arquivo.Estantes == null || arquivo.Estantes.Count <= 0)
{
Validacao.Add(Msg.EstanteArquivoObrigratorio);
}
int contator = 0;
int i = 0;
foreach (Estante estante in arquivo.Estantes)
{
if (string.IsNullOrWhiteSpace(estante.Texto))
{
Validacao.Add(Msg.EstanteObrigratorio(i));
i++;
continue;
}
else
{
contator = 0;
foreach (var item in arquivo.Estantes)
{
if (estante.Texto.ToUpper() == item.Texto.ToUpper())
{
contator++;
}
}
if (contator > 1)
{
Validacao.Add(Msg.EstanteNomeIguais(estante.Texto));
}
}
if (estante.Prateleiras.Count <= 0)
{
Validacao.Add(Msg.PrateleiraEstanteObrigratorio(estante.Texto));
}
foreach (var prateleira in estante.Prateleiras)
{
if (prateleira.ModoId == 0)
{
Validacao.Add(Msg.ModoObrigratorioEstante(estante.Texto));
i++;
continue;
}
if (string.IsNullOrWhiteSpace(prateleira.Texto))
{
Validacao.Add(Msg.IdentificadorObrigratorio(estante.Texto));
i++;
continue;
}
contator = 0;
foreach (var item in estante.Prateleiras)
{
if (prateleira.ModoId == item.ModoId && prateleira.Texto.ToUpper() == item.Texto.ToUpper())
{
contator++;
}
}
if (contator > 1)
{
Validacao.Add(Msg.EstanteComModosIdenticacaoRepetidos(estante.Texto));
}
}
i++;
}
if (arquivo.ProtocoloSituacao.GetValueOrDefault() <= 0)
{
Validacao.Add(Msg.ProcessoOuDocumentoArqObrigratorio);
}
if (arquivo.Id.HasValue && arquivo.Id.Value > 0)
{
EstantesExcluirDeArquivo(arquivo);
PrateleirasExcluirDeArquivo(arquivo);
TramitacaoArquivo arquivoOriginal = _da.Obter(arquivo.Id.Value, true);
if (arquivoOriginal.SetorId != arquivo.SetorId)
{
if (_da.PossuiProtocolo(arquivo.Id.Value))
{
Validacao.Add(Mensagem.Tramitacao.ArquivoEditarSetorNaoEhPossivelPorPossuirProtocolo(eTipoMensagem.Advertencia));
}
}
}
return(Validacao.EhValido);
}
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);
}
public Resultados <credenciado.ListarFiltro> FiltrarHabilitarEmissao(IDictionary <string, DadoFiltro> filtros)
{
Resultados <credenciado.ListarFiltro> retorno = new Resultados <credenciado.ListarFiltro>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
string comandtxt = string.Empty;
Comando comando = bancoDeDados.CriarComando("");
#region Adicionando Filtros
if (filtros.ContainsKey("nomerazaosocial"))
{
comandtxt += " and upper(nvl(tp.nome, tp.razao_social)) like '%'|| upper(:nomerazaosocial)||'%'";
comando.AdicionarParametroEntrada("nomerazaosocial", filtros["nomerazaosocial"].Valor, filtros["nomerazaosocial"].Tipo);
}
if (filtros.ContainsKey("cpfcnpj"))
{
if (ValidacoesGenericasBus.Cpf(filtros["cpfcnpj"].Valor.ToString()) ||
ValidacoesGenericasBus.Cnpj(filtros["cpfcnpj"].Valor.ToString()))
{
comandtxt += " and ((tp.cpf = :cpfcnpj) or (tp.cnpj = :cpfcnpj))";
}
else
{
comandtxt += "and ((tp.cpf like '%'|| :cpfcnpj ||'%') or (tp.cnpj = '%'|| :cpfcnpj ||'%'))";
}
comando.AdicionarParametroEntrada("cpfcnpj", filtros["cpfcnpj"].Valor, filtros["cpfcnpj"].Tipo);
}
if (filtros.ContainsKey("situacao"))
{
comandtxt += " and tc.situacao = :situacao";
comando.AdicionarParametroEntrada("situacao", filtros["situacao"].Valor, filtros["situacao"].Tipo);
}
if (filtros.ContainsKey("tipo"))
{
comandtxt += " and tc.tipo = :tipo";
comando.AdicionarParametroEntrada("tipo", filtros["tipo"].Valor, filtros["tipo"].Tipo);
}
if (filtros.ContainsKey("data_ativacao"))
{
comandtxt += " and to_char(tc.data_cadastro, 'dd/mm/yyyy') = :data_ativacao";
comando.AdicionarParametroEntrada("data_ativacao", filtros["data_ativacao"].Valor, filtros["data_ativacao"].Tipo);
}
List <String> ordenar = new List <String>();
List <String> colunas = new List <String>()
{
"nome", "cpfcnpj", "tipo", "ativacao", "situacao"
};
if (filtros.ContainsKey("ordenar"))
{
ordenar.Add(filtros["ordenar"].Valor.ToString());
}
else
{
ordenar.Add("nome");
}
#endregion
#region Executa a pesquisa nas tabelas
comando.DbCommand.CommandText = DaHelper.FormatarSql(@"select count(*) from {1}tab_credenciado tc, {0}tab_pessoa tp,
{1}lov_credenciado_tipo lct, {1}lov_credenciado_situacao lcs where tc.pessoa = tp.id
and tc.tipo = lct.id and tc.situacao = lcs.id and tc.situacao <> 1 " + comandtxt, UsuarioInterno, UsuarioCredenciado);
retorno.Quantidade = Convert.ToInt32(bancoDeDados.ExecutarScalar(comando));
if (retorno.Quantidade < 1)
{
Validacao.Add(Mensagem.Funcionario.NaoEncontrouRegistros);
}
if (filtros.ContainsKey("menor"))
{
comando.AdicionarParametroEntrada("menor", filtros["menor"].Valor, filtros["menor"].Tipo);
}
else
{
comando.AdicionarParametroEntrada("menor", 1, DbType.Int32);
}
if (filtros.ContainsKey("maior"))
{
comando.AdicionarParametroEntrada("maior", filtros["maior"].Valor, filtros["maior"].Tipo);
}
else
{
comando.AdicionarParametroEntrada("maior", 10, DbType.Int32);
}
comandtxt = String.Format(@"select tc.id, nvl(tp.nome, tp.razao_social) nome,
nvl(tp.cpf, tp.cnpj) cpfcnpj, lct.texto tipo, to_char(tc.data_cadastro, 'dd/mm/yyyy') ativacao, lcs.id situacao,
lcs.texto situacao_texto from {2}tab_credenciado tc, {3}tab_pessoa tp,
{2}lov_credenciado_tipo lct, {2}lov_credenciado_situacao lcs
where tc.pessoa = tp.id and tc.tipo = lct.id and tc.situacao = lcs.id and tc.situacao <> 1 {0} {1}" ,
comandtxt, DaHelper.Ordenar(colunas, ordenar),
String.IsNullOrEmpty(UsuarioCredenciado) ? "" : UsuarioCredenciado + ".",
String.IsNullOrEmpty(UsuarioInterno) ? "" : UsuarioInterno + "."); //1 - Aguardando Ativação
comando.DbCommand.CommandText = @"select * from (select a.*, rownum rnum from ( " + comandtxt + @") a) where rnum <= :maior and rnum >= :menor";
#endregion
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
credenciado.ListarFiltro item;
while (reader.Read())
{
item = new credenciado.ListarFiltro();
item.Id = reader["id"].ToString();
item.NomeRazaoSocial = reader["nome"].ToString();
item.CpfCnpj = reader["cpfcnpj"].ToString();
item.DataAtivacao = reader["ativacao"].ToString();
item.Situacao = Convert.ToInt32(reader["situacao"]);
item.SituacaoTexto = reader["situacao_texto"].ToString();
item.TipoTexto = reader["tipo"].ToString();
retorno.Itens.Add(item);
}
reader.Close();
}
}
return(retorno);
}
internal bool Salvar(ExploracaoFlorestal caracterizacao)
{
if (!_caracterizacaoValidar.Basicas(caracterizacao.EmpreendimentoId))
{
return(false);
}
if (caracterizacao.Id <= 0 && (_da.ObterPorEmpreendimento(caracterizacao.EmpreendimentoId, true) ?? new ExploracaoFlorestal()).Id > 0)
{
Validacao.Add(Mensagem.Caracterizacao.EmpreendimentoCaracterizacaoJaCriada);
return(false);
}
if (!Acessar(caracterizacao.EmpreendimentoId))
{
return(false);
}
if (caracterizacao.FinalidadeExploracao <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.FinalidadeExploracaoObrigatorio);
}
else
{
if (caracterizacao.FinalidadeExploracao == (int)eExploracaoFlorestalFinalidade.Outros && String.IsNullOrWhiteSpace(caracterizacao.FinalidadeEspecificar))
{
Validacao.Add(Mensagem.ExploracaoFlorestal.FinalidadeExploracaoEspecificarObrigatorio);
}
}
foreach (ExploracaoFlorestalExploracao item in caracterizacao.Exploracoes)
{
if (item.GeometriaTipoId == (int)eExploracaoFlorestalGeometria.Poligono)
{
if (!String.IsNullOrWhiteSpace(item.AreaRequeridaTexto))
{
if (!ValidacoesGenericasBus.ValidarDecimal(DecimalEtx.ClearMask(item.AreaRequeridaTexto), 7, 2))
{
Validacao.Add(Mensagem.ExploracaoFlorestal.AreaRequiridaInvalida(item.Identificacao));
}
else if (item.AreaRequerida <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.AreaRequiridaMaiorZero(item.Identificacao));
}
}
else
{
Validacao.Add(Mensagem.ExploracaoFlorestal.AreaRequiridaObrigatoria(item.Identificacao));
}
}
else
{
if (item.GeometriaTipoId == (int)eExploracaoFlorestalGeometria.Ponto || item.GeometriaTipoId == (int)eExploracaoFlorestalGeometria.Linha)
{
#region Arvores Requeridas
if (!String.IsNullOrWhiteSpace(item.ArvoresRequeridas))
{
if (Convert.ToDecimal(item.ArvoresRequeridas) <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.ArvoresRequeridasMaiorZero(item.Identificacao));
}
}
else
{
Validacao.Add(Mensagem.ExploracaoFlorestal.ArvoresRequeridasObrigatoria(item.Identificacao));
}
#endregion
#region Numero de Arvores
if (!String.IsNullOrWhiteSpace(item.QuantidadeArvores))
{
bool existeProdutoSemRendimento = item.Produtos.Where(x => x.ProdutoId == (int)eProduto.SemRendimento).ToList().Count() > 0;
if (!existeProdutoSemRendimento)
{
if (Convert.ToInt32(item.QuantidadeArvores) <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.QdeArvoresRequeridasMaiorZero(item.Identificacao));
}
}
}
else
{
Validacao.Add(Mensagem.ExploracaoFlorestal.QdeArvoresRequeridasObrigatoria(item.Identificacao));
}
#endregion
}
}
if (item.ExploracaoTipoId <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.ExploracaoTipoObrigatorio(item.Identificacao));
}
if (item.ClassificacaoVegetacaoId <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.ClassificacaoVegetacaoObrigatoria(item.Identificacao));
}
if (item.Produtos.Count == 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.ProdutoObrigatorio(item.Identificacao));
}
else
{
foreach (ExploracaoFlorestalProduto produto in item.Produtos)
{
if (produto.ProdutoId == (int)eProduto.SemRendimento)
{
continue;
}
if (!String.IsNullOrWhiteSpace(produto.Quantidade))
{
if (!ValidacoesGenericasBus.ValidarDecimal(DecimalEtx.ClearMask(produto.Quantidade), 7, 2))
{
Validacao.Add(Mensagem.Dominialidade.AreaInvalida("exploracao" + item.Identificacao, "Quantidade"));
}
else if (DecimalEtx.ToDecimalMask(produto.Quantidade).GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.Dominialidade.AreaMaiorZero("exploracao" + item.Identificacao, "Quantidade"));
}
}
else
{
Validacao.Add(Mensagem.Dominialidade.AreaObrigatoria("exploracao" + item.Identificacao, "Quantidade"));
}
}
}
}
return(Validacao.EhValido);
}
public bool Salvar(ComplementacaoDados complementacao)
{
#region Dados do Responsavel
if (complementacao.AutuadoTipo == (int)eTipoAutuado.Empreendimento)
{
if (complementacao.AutuadoId <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.ResponsavelObrigatorio);
}
}
if (complementacao.ResidePropriedadeTipo <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.ResidePropriedadeObrigatorio);
}
if (complementacao.RendaMensalFamiliarTipo <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.RendaMensalFamiliarObrigatoria);
}
if (complementacao.NivelEscolaridadeTipo <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.NivelEscolaridadeObrigatorio);
}
if (complementacao.VinculoComPropriedadeTipo <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.VinculoComPropriedadeObrigatorio);
}
else
{
if (complementacao.VinculoComPropriedadeTipo == (int)eVinculoPropriedade.Outro)
{
if (String.IsNullOrWhiteSpace(complementacao.VinculoComPropriedadeEspecificarTexto))
{
Validacao.Add(Mensagem.ComplementacaoDados.VinculoComPropriedadeEspecificarObrigatorio);
}
}
}
if (complementacao.ConhecimentoLegislacaoTipo <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.ConhecimentoLegislacaoObrigatorio);
}
else
{
if (complementacao.ConhecimentoLegislacaoTipo != (int)eRespostasDefault.NaoSeAplica)
{
if (String.IsNullOrWhiteSpace(complementacao.Justificativa))
{
Validacao.Add(Mensagem.ComplementacaoDados.JustificativaObrigatoria);
}
}
}
#endregion
#region Dados da propriedade
if (complementacao.AutuadoTipo == (int)eTipoAutuado.Empreendimento)
{
#region AreaTotalInformada
if (!String.IsNullOrWhiteSpace(complementacao.AreaTotalInformada))
{
Decimal aux = 0;
if (Decimal.TryParse(complementacao.AreaTotalInformada, out aux))
{
if (aux <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.AreaTotalInformadaMaiorZero);
}
}
else
{
Validacao.Add(Mensagem.ComplementacaoDados.AreaTotalInformadaInvalida);
}
}
#endregion
#region AreaCoberturaFlorestalNativa
if (!String.IsNullOrWhiteSpace(complementacao.AreaCoberturaFlorestalNativa))
{
Decimal aux = 0;
if (Decimal.TryParse(complementacao.AreaCoberturaFlorestalNativa, out aux))
{
if (aux <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.AreaCoberturaFlorestalNativaMaiorZero);
}
}
else
{
Validacao.Add(Mensagem.ComplementacaoDados.AreaCoberturaFlorestalNativaInvalida);
}
}
#endregion
if (complementacao.ReservalegalTipo <= 0)
{
Validacao.Add(Mensagem.ComplementacaoDados.ReservalegalObrigatoria);
}
}
#endregion
return(Validacao.EhValido);
}
internal Resultados <EmpreendimentoAtividade> Filtrar(Dictionary <string, DadoFiltro> filtros)
{
Resultados <EmpreendimentoAtividade> retorno = new Resultados <EmpreendimentoAtividade>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
string comandtxt = string.Empty;
Comando comando = bancoDeDados.CriarComando("");
#region Adicionando Filtros
if (filtros.ContainsKey("secao"))
{
comandtxt += " and upper(secao) like upper(:secao)";
comando.AdicionarParametroEntrada("secao", filtros["secao"].Valor + "%", filtros["secao"].Tipo);
}
if (filtros.ContainsKey("divisao"))
{
comandtxt += " and divisao = :divisao ";
comando.AdicionarParametroEntrada("divisao", filtros["divisao"].Valor, filtros["divisao"].Tipo);
}
if (filtros.ContainsKey("atividade"))
{
comandtxt += " and upper(atividade) like upper(:atividade)";
comando.AdicionarParametroEntrada("atividade", filtros["atividade"].Valor + "%", filtros["atividade"].Tipo);
}
if (filtros.ContainsKey("cnae"))
{
comandtxt += " and upper(cod_cnae) like upper(:cnae)";
comando.AdicionarParametroEntrada("cnae", filtros["cnae"].Valor + "%", filtros["cnae"].Tipo);
}
List <String> ordenar = new List <String>();
List <String> colunas = new List <String>()
{
"cod_cnae", "atividade"
};
if (filtros.ContainsKey("ordenar"))
{
ordenar.Add(filtros["ordenar"].Valor.ToString());
}
else
{
ordenar.Add("cod_cnae");
}
#endregion
#region Quantidade de registro do resultado
comando.DbCommand.CommandText = String.Format("select count(*) from {0}tab_empreendimento_atividade a where a.id > 0" + comandtxt, (string.IsNullOrEmpty(EsquemaBanco) ? "" : "."));
retorno.Quantidade = Convert.ToInt32(bancoDeDados.ExecutarScalar(comando));
if (retorno.Quantidade < 1)
{
Mensagem msgSemRegistros = Mensagem.Funcionario.NaoEncontrouRegistros;
Validacao.Add(msgSemRegistros);
}
if (filtros.ContainsKey("menor"))
{
comando.AdicionarParametroEntrada("menor", filtros["menor"].Valor, filtros["menor"].Tipo);
}
else
{
comando.AdicionarParametroEntrada("menor", 1, DbType.Int32);
}
if (filtros.ContainsKey("maior"))
{
comando.AdicionarParametroEntrada("maior", filtros["maior"].Valor, filtros["maior"].Tipo);
}
else
{
comando.AdicionarParametroEntrada("maior", 10, DbType.Int32);
}
comandtxt = String.Format(@"select a.id, a.secao, a.divisao, a.atividade, a.tid, a.cod_cnae from
{0}tab_empreendimento_atividade a where a.id > 0" + comandtxt + DaHelper.Ordenar(colunas, ordenar), (string.IsNullOrEmpty(EsquemaBanco) ? "" : "."));
comando.DbCommand.CommandText = @"select * from (select a.*, rownum rnum from ( " + comandtxt + @") a) where rnum <= :maior and rnum >= :menor";
#endregion
using (IDataReader reader = bancoDeDados.ExecutarReader(comando))
{
#region Adicionando os dados na classe de retorno
EmpreendimentoAtividade atividade;
while (reader.Read())
{
atividade = new EmpreendimentoAtividade();
atividade.Id = Convert.ToInt32(reader["id"]);
atividade.Secao = reader["secao"].ToString();
atividade.CNAE = reader["cod_cnae"].ToString();
if (reader["divisao"] != null && !Convert.IsDBNull(reader["divisao"]))
{
atividade.Divisao = Convert.ToInt32(reader["divisao"]);
}
atividade.Atividade = reader["atividade"].ToString();
atividade.Tid = reader["tid"].ToString();
retorno.Itens.Add(atividade);
}
reader.Close();
#endregion
}
}
return(retorno);
}
public bool Posse(Posse posse, int empreendimentoId)
{
if (string.IsNullOrWhiteSpace(posse.Identificacao))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.CampoObrigatorio);
}
if (posse.AreaCroqui <= 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.CampoObrigatorio);
}
if (posse.AreaRequerida <= 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.AreaRequeridaObrigatoria);
}
if (posse.RegularizacaoTipo <= 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.TipoRegularizacaoObrigatorio);
}
if (posse.ComprovacaoId == 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.ComprovacaoObrigatoria);
}
if (posse.AreaPosseDocumento <= 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.AreaPosseDocumento);
}
if (string.IsNullOrEmpty(posse.ConfrontacoesNorte))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.ConfrontacoesNorte);
}
if (string.IsNullOrEmpty(posse.ConfrontacoesSul))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.ConfrontacoesSul);
}
if (string.IsNullOrEmpty(posse.ConfrontacoesLeste))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.ConfrontacoesLeste);
}
if (string.IsNullOrEmpty(posse.ConfrontacoesOeste))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.ConfrontacoesOeste);
}
if (string.IsNullOrEmpty(posse.DescricaoComprovacao))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.DescricaoComprovacao);
}
#region Dominios Avulsos
if (!posse.PossuiDominioAvulso.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.PossuiDominioAvulsoObrigatorio);
}
if (posse.PossuiDominioAvulsoBool)
{
if (posse.DominiosAvulsos == null || posse.DominiosAvulsos.Count <= 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.DominioAvulsoObrigatorio);
}
else
{
posse.DominiosAvulsos.ForEach(dominio => {
DominioAvulso(posse.DominiosAvulsos.Where(x => x != dominio).ToList(), dominio);
});
}
}
#endregion
#region Transmitentes
if (posse.Transmitentes.Count(x => x.TempoOcupacao <= 0) > 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.TempoDeOcupacaoObrigatorio);
}
if (posse.Transmitentes.Count(x => x.Transmitente.Id <= 0) > 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.TrasmitenteObrigatorio);
}
if (posse.Transmitentes.Any(x => posse.Transmitentes.Count(y => y.Transmitente.Id == x.Transmitente.Id) > 1))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.TrasmitenteJaAdicionado);
}
#endregion
if (_da.EmpreendimentoZonaAlterada(empreendimentoId, posse.Zona))
{
Validacao.Add(Mensagem.Caracterizacao.SegmentoEmpreendimentoAlterado);
return(Validacao.EhValido);
}
#region Zona Rural
if (posse.Zona == (int)eZonaLocalizacao.Rural)
{
if (posse.UsoAtualSolo.Count <= 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.UsoSoloObrigatorio);
}
if (posse.UsoAtualSolo.Count(x => x.AreaPorcentagem <= 0) > 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.UsoSoloTipoObrigatorio);
}
int porcentagem = posse.UsoAtualSolo.Sum(x => x.AreaPorcentagem);
if (porcentagem > 100)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.UsoSoloLimitePorcentagem);
}
if (posse.RelacaoTrabalho <= 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.RelacaoTrabalhoObrigatorio);
}
if (string.IsNullOrWhiteSpace(posse.Benfeitorias))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.BenfeitoriasEdificacoesObrigatorio);
}
}
#endregion
#region Opções
foreach (Opcao opcao in posse.Opcoes)
{
switch (opcao.TipoEnum)
{
case eTipoOpcao.TerrenoDevoluto:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.TerrenoDevolutoObrigatorio);
break;
}
if (String.IsNullOrEmpty(opcao.Outro) || opcao.Outro == "0")
{
if (opcao.Valor == 0)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.EspecificarDominialidadeObrigatorio);
}
else
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.HomologacaoAprovadaObrigatoria);
}
}
break;
case eTipoOpcao.RequerenteResideNaPosse:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.RequerenteResidePosseObrigatorio);
}
ValidacoesGenericasBus.DataMensagem(new DateTecno()
{
DataTexto = opcao.Outro
}, "DataArquisicao", "aquisição ou ocupação");
break;
case eTipoOpcao.ExisteLitigio:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.ExisteLitigioObrigatorio);
break;
}
if (opcao.Valor == 1 && String.IsNullOrEmpty(opcao.Outro))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.NomeLitigioObrigatorio);
}
break;
case eTipoOpcao.SobrepoeSeDivisa:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.SobrepoeFaixaDivisaObrigatorio);
break;
}
if (opcao.Valor == 1 && opcao.Outro == "0")
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.AQuemPertenceLimiteObrigatorio);
}
break;
case eTipoOpcao.BanhadoPorRioCorrego:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.BanhadoRioCorregoObrigatorio);
break;
}
if (opcao.Valor == 1 && String.IsNullOrEmpty(opcao.Outro))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.NomeRioCorregoObrigatorio);
}
break;
case eTipoOpcao.PossuiNascente:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.PossuiNascenteObrigatorio);
}
break;
case eTipoOpcao.RedeAgua:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.RedeAguaObrigatorio);
}
break;
case eTipoOpcao.RedeEsgoto:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.RedeEsgotoObrigatorio);
}
break;
case eTipoOpcao.LuzEletrica:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.LuzEletricaDomiciliarObrigatorio);
}
break;
case eTipoOpcao.IluminacaoPublica:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.IluminacaoViaPublicaObrigatorio);
}
break;
case eTipoOpcao.RedeTelefonica:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.RedeTelefonicaObrigatorio);
}
break;
case eTipoOpcao.Calcada:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.CalcadaObrigatorio);
}
break;
case eTipoOpcao.Pavimentacao:
if (!opcao.Valor.HasValue)
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.PavimentacaoObrigatorio);
break;
}
if (opcao.Valor == 1 && String.IsNullOrEmpty(opcao.Outro))
{
Validacao.Add(Mensagem.RegularizacaoFundiaria.TipoPavimentacaoObrigatorio);
}
break;
}
}
#endregion
return(Validacao.EhValido);
}
public int Importar(Requerimento requerimento, BancoDeDados bancoCredenciado, BancoDeDados bancoInterno)
{
BancoDeDados bancoDeDadosInterno = null;
BancoDeDados bancoDeDadosCredenciado = null;
int empreedimentoIdInterno = 0;
RequerimentoCredenciadoBus busRequerimentoCredenciado = new RequerimentoCredenciadoBus();
var requerimentoCredenciado = busRequerimentoCredenciado.Obter(requerimento.Id, bancoCredenciado,
bancoInterno, true);
requerimentoCredenciado.SetorId = 20; //Departamento de Recursos Naturais Renováveis
requerimentoCredenciado.Empreendimento.SelecaoTipo = (int)eExecutorTipo.Credenciado;
requerimentoCredenciado.Pessoas.ForEach(p =>
{
p.SelecaoTipo = (int)eExecutorTipo.Credenciado;
});
List <Pessoa> pessoasRelacionadas = ObterPessoasRelacionadas(requerimentoCredenciado, bancoCredenciado);
requerimentoCredenciado.IsCredenciado = true;
GerenciadorTransacao.ObterIDAtual();
using (bancoDeDadosInterno = BancoDeDados.ObterInstancia(bancoInterno))
{
bancoDeDadosInterno.IniciarTransacao();
using (bancoDeDadosCredenciado = BancoDeDados.ObterInstancia(bancoCredenciado, UsuarioCredenciado))
{
bancoDeDadosCredenciado.IniciarTransacao();
requerimentoCredenciado = ImportarPessoas(requerimentoCredenciado, pessoasRelacionadas,
bancoDeDadosInterno);
if (requerimentoCredenciado.Empreendimento.Id > 0)
{
requerimentoCredenciado = ImportarEmpreendimento(requerimentoCredenciado, bancoDeDadosInterno,
bancoDeDadosCredenciado);
}
_daREq.Importar(requerimentoCredenciado, bancoDeDadosInterno);
busRequerimentoCredenciado.AlterarSituacao(
new Requerimento()
{
Id = requerimentoCredenciado.Id,
SituacaoId = (int)eRequerimentoSituacao.Importado
}, bancoDeDadosCredenciado, bancoDeDadosInterno);
AlterarSituacao(requerimentoCredenciado.Id, eProjetoDigitalSituacao.Finalizado, bancoDeDadosCredenciado);
bancoDeDadosCredenciado.Commit();
}
bancoDeDadosInterno.Commit();
Validacao.Add(Mensagem.ProjetoDigital.RequerimentoImportado(requerimento.Numero.ToString()));
}
return(empreedimentoIdInterno);
}
public List <Mensagem> SalvarItemUnidadeProducao(UnidadeProducaoItem unidade, int empreendimentoID)
{
List <Mensagem> mensagens = new List <Mensagem>();
if (unidade.PossuiCodigoUP)
{
if (unidade.CodigoUP < 1)
{
mensagens.Add(Mensagem.UnidadeProducao.CodigoUPObrigatorio);
}
else
{
if (unidade.CodigoUP.ToString().Length < 15)
{
mensagens.Add(Mensagem.UnidadeProducao.CodigoUPInvalido);
}
else
{
if (_da.CodigoUPExistente(unidade, empreendimentoID))
{
mensagens.Add(Mensagem.UnidadeProducao.CodigoUPJaExiste);
}
}
}
}
if (unidade.TipoProducao == (int)eUnidadeProducaoTipoProducao.MaterialPropagacao)
{
if (String.IsNullOrEmpty(unidade.RenasemNumero))
{
mensagens.Add(Mensagem.UnidadeProducao.RenasemNumeroObrigatorio);
}
if (String.IsNullOrEmpty(unidade.DataValidadeRenasem))
{
mensagens.Add(Mensagem.Padrao.DataObrigatoria("UnidadeProducaoItem_DataValidadeRenasem", "validade"));
}
if (!String.IsNullOrEmpty(unidade.DataValidadeRenasem) && !ValidacoesGenericasBus.ValidarData(unidade.DataValidadeRenasem))
{
mensagens.Add(Mensagem.Padrao.DataInvalida("UnidadeProducaoItem_DataValidadeRenasem", "validade"));
}
if (!String.IsNullOrEmpty(unidade.DataValidadeRenasem) && ValidacoesGenericasBus.ValidarData(unidade.DataValidadeRenasem) && Convert.ToDateTime(unidade.DataValidadeRenasem) <= DateTime.Today)
{
mensagens.Add(Mensagem.UnidadeProducao.RenasemDataVencimentoMenorQueDataAtual);
}
}
else
{
unidade.RenasemNumero = string.Empty;
unidade.DataValidadeRenasem = string.Empty;
}
if (unidade.AreaHA <= 0)
{
mensagens.Add(Mensagem.UnidadeProducao.AreaHAObrigatorio);
}
if (unidade.Coordenada.EastingUtm.GetValueOrDefault() < 1 || unidade.Coordenada.NorthingUtm.GetValueOrDefault() < 1)
{
mensagens.Add(Mensagem.UnidadeProducao.CoordenadaObrigatorio);
}
if (unidade.Coordenada.EastingUtm <= 0)
{
mensagens.Add(Mensagem.UnidadeProducao.EastingUtmObrigatorio);
}
if (unidade.Coordenada.NorthingUtm <= 0)
{
mensagens.Add(Mensagem.UnidadeProducao.NorthingUtmObrigatorio);
}
if (unidade.CulturaId < 1)
{
mensagens.Add(Mensagem.UnidadeProducao.CulturaObrigatorio);
}
if (unidade.CultivarId < 1)
{
mensagens.Add(Mensagem.UnidadeProducao.CultivarObrigatorio);
}
if (string.IsNullOrEmpty(unidade.DataPlantioAnoProducao))
{
mensagens.Add(Mensagem.UnidadeProducao.DataPlantioAnoProducaoObrigatorio);
}
else
{
string[] mesAno = unidade.DataPlantioAnoProducao.Split('/');
if (unidade.DataPlantioAnoProducao.Length != 7 || mesAno.Length < 2 || Convert.ToInt32(mesAno.GetValue(0)) <= 0 || Convert.ToInt32(mesAno.GetValue(0)) > 12 || Convert.ToInt32(mesAno.GetValue(1)) <= 0)
{
mensagens.Add(Mensagem.UnidadeProducao.DataPlantioAnoProducaoInvalida);
}
else
{
if (Convert.ToInt32(mesAno.GetValue(1)) > DateTime.Now.Year || (Convert.ToInt32(mesAno.GetValue(0)) > DateTime.Now.Month && Convert.ToInt32(mesAno.GetValue(1)) == DateTime.Now.Year))
{
mensagens.Add(Mensagem.UnidadeProducao.DataPlantioAnoProducaoMaiorAtual);
}
}
}
if (unidade.Produtores.Count < 1)
{
Validacao.Add(Mensagem.UnidadeProducao.ProdutorObrigatorio);
}
unidade.Produtores.ForEach(x =>
{
if (!_da.VerificarResponsavelEmpreendimento(empreendimentoID, x.Id.GetValueOrDefault()))
{
Validacao.Add(Mensagem.UnidadeProducao.ProdutorNaoEstaMaisVinculadoNoEmpreendimento(x.NomeRazao));
}
});
if (unidade.ResponsaveisTecnicos.Count < 1)
{
mensagens.Add(Mensagem.UnidadeProducao.ResponsavelTecnicoObrigatorio);
}
else
{
foreach (var item in unidade.ResponsaveisTecnicos)
{
if (!item.ArtCargoFuncao)
{
if (!ValidacoesGenericasBus.ValidarData(item.DataValidadeART))
{
mensagens.Add(Mensagem.Padrao.DataInvalida("UnidadeProducaoItem_ResponsavelTecnico_DataValidadeART", "validade da ART"));
}
}
else
{
item.DataValidadeART = string.Empty;
}
}
}
if (unidade.EstimativaProducaoQuantidadeAno <= 0)
{
mensagens.Add(Mensagem.UnidadeProducao.EstimativaProducaoQuantidadeAnoObrigatorio);
}
if (string.IsNullOrEmpty(unidade.EstimativaProducaoUnidadeMedida))
{
mensagens.Add(Mensagem.UnidadeProducao.EstimativaProducaoUnidadeMedidaObrigatorio);
}
return(mensagens);
}
public bool ValidarAtividade(List <Atividade> atividades, string local = null)
{
if (atividades.Count <= 0)
{
Validacao.Add(Msg.AtividadeObrigatorio);
return(Validacao.EhValido);
}
int SetorId = atividades[0].SetorId;
int titulos = 0;
int titulosDeclaratorio = 0;
string tituloDeclaratorioModelo = string.Empty;
foreach (Atividade atividade in atividades)
{
#region Atividades
if (SetorId != atividade.SetorId)
{
Validacao.Add(Msg.AtividadesSetoresDiferentes);
return(Validacao.EhValido);
}
if (atividade.Finalidades.Count < 1)
{
Validacao.Add(Msg.TituloObrigatorio(atividade.NomeAtividade));
return(Validacao.EhValido);
}
if (!_atividadeBus.AtividadeAtiva(atividade.Id))
{
Validacao.Add(Msg.AtividadeDesativada(atividade.NomeAtividade, local));
}
foreach (var item in atividade.Finalidades)
{
#region Finalidades
if (item.TituloModelo == 0)
{
Validacao.Add(Msg.TituloObrigatorio(atividade.NomeAtividade));
}
//Verifica se a situação da atividade é encerrada ou já tem título emitido
if (atividade.Protocolo.Id > 0 && _atividadeBus.ValidarAtividadeComTituloOuEncerrada(atividade.Protocolo.Id.Value, atividade.Protocolo.IsProcesso, atividade.Id, item.TituloModelo))
{
continue;
}
if (!_atividadeConfigurada.AtividadeConfigurada(atividade.Id, item.TituloModelo))
{
Validacao.Add(Msg.TituloNaoConfiguradoAtividade(item.TituloModeloTexto, atividade.NomeAtividade, local));
continue;
}
TituloModelo modelo = _tituloModeloBus.Obter(item.TituloModelo);
if (modelo.TipoDocumentoEnum == eTituloModeloTipoDocumento.Titulo)
{
++titulos;
}
else
{
++titulosDeclaratorio;
tituloDeclaratorioModelo = modelo.Nome;
}
if (titulos > 0 && titulosDeclaratorio > 0)
{
Validacao.Add(Msg.TituloDeclaratorioOutroRequerimento(tituloDeclaratorioModelo));
}
if (item.Id == 3) //Renovação
{
#region Renovacao
if (!modelo.Regra(eRegra.Renovacao))
{
Validacao.Add(Msg.TituloNaoEhRenovacao(item.TituloModeloTexto, atividade.NomeAtividade, local));
}
if (modelo.Regra(eRegra.Renovacao))
{
if (item.EmitidoPorInterno)
{
if (item.TituloModeloAnteriorId == 0 || item.TituloModeloAnteriorId == null)
{
Validacao.Add(Msg.TituloAnteriorObrigatorio(item.TituloModeloTexto, atividade.NomeAtividade));
}
if (string.IsNullOrWhiteSpace(item.TituloAnteriorNumero))
{
Validacao.Add(Msg.NumeroAnteriorObrigatorio(item.TituloModeloTexto, atividade.NomeAtividade));
}
else
{
if (!ValidacoesGenericasBus.ValidarMaskNumeroBarraAno(item.TituloAnteriorNumero))
{
Validacao.Add(Msg.TituloAnteriorNumeroInvalido);
}
}
CarregarTituloAnteriorSigla(item);
}
else
{
ValidarTituloNumeroOrgaoTexto(item, atividade);
}
}
#endregion
}
else
{
#region Fase Anterior
if (!modelo.Regra(eRegra.FaseAnterior) && (item.TituloModeloAnteriorId != null && item.TituloModeloAnteriorId != 0))
{
Validacao.Add(Msg.TituloNaoTemTituloAnterior(item.TituloModeloAnteriorTexto, item.TituloModeloTexto, local));
continue;
}
Boolean adicionouTituloAnterior = false;
Boolean validarTituloAnterior = Convert.ToBoolean((modelo.Resposta(eRegra.FaseAnterior, eResposta.TituloAnteriorObrigatorio) ?? new TituloModeloResposta()).Valor);
if (item.EmitidoPorInterno)
{
adicionouTituloAnterior = (item.TituloAnteriorId.GetValueOrDefault(0) > 0) || (!String.IsNullOrWhiteSpace(item.TituloAnteriorNumero));
}
else
{
adicionouTituloAnterior = (!String.IsNullOrWhiteSpace(item.TituloModeloAnteriorTexto)) || (!String.IsNullOrWhiteSpace(item.TituloAnteriorNumero)) || (!String.IsNullOrWhiteSpace(item.OrgaoExpedidor));
}
validarTituloAnterior = validarTituloAnterior || adicionouTituloAnterior;
if (modelo.Regra(eRegra.FaseAnterior) && validarTituloAnterior)
{
List <TituloModeloResposta> respostas = modelo.Respostas(eRegra.FaseAnterior, eResposta.Modelo);
if (respostas == null || respostas.Count < 1)
{
Validacao.Add(Msg.TituloNaoEhFaseAnterior(item.TituloModeloTexto, local));
}
if (item.EmitidoPorInterno)
{
if (item.TituloModeloAnteriorId != null && item.TituloModeloAnteriorId != 0)
{
if (respostas.SingleOrDefault(x => x.Valor.ToString() == item.TituloModeloAnteriorId.ToString()) == null)
{
Validacao.Add(Msg.TituloNaoTemTituloAnterior(item.TituloModeloTexto, item.TituloModeloAnteriorTexto, local));
}
}
if (string.IsNullOrWhiteSpace(item.TituloAnteriorNumero))
{
Validacao.Add(Msg.NumeroAnteriorObrigatorio(item.TituloModeloTexto, atividade.NomeAtividade));
}
else
{
if (!(ValidacoesGenericasBus.ValidarMaskNumeroBarraAno(item.TituloAnteriorNumero) ||
ValidacoesGenericasBus.ValidarNumero(item.TituloAnteriorNumero, 12)))
{
Validacao.Add(Msg.TituloAnteriorNumeroInvalido);
}
else
{
if (ValidacoesGenericasBus.ValidarNumero(item.TituloAnteriorNumero, 12) &&
_da.ValidarNumeroSemAnoExistente(item.TituloAnteriorNumero, item.TituloModeloAnteriorId.GetValueOrDefault()))
{
Validacao.Add(Msg.TituloNumeroSemAnoEncontrado);
}
}
}
CarregarTituloAnteriorSigla(item);
}
else
{
ValidarTituloNumeroOrgaoTexto(item, atividade);
}
}
#endregion
}
#endregion
}
#endregion
}
return(Validacao.EhValido);
}
public bool Salvar(UnidadeProducao caracterizacao)
{
try
{
if (!_validar.Salvar(caracterizacao))
{
return(Validacao.EhValido);
}
#region Configurar Salvar
if (!caracterizacao.PossuiCodigoPropriedade)
{
if (caracterizacao.Id < 1)
{
caracterizacao.CodigoPropriedade = _da.ObterSequenciaCodigoPropriedade();
}
else
{
caracterizacao.CodigoPropriedade = ObterPorEmpreendimento(caracterizacao.Empreendimento.Id, true).CodigoPropriedade;
}
}
RequestJson requestJson = new RequestJson();
ResponseJsonData <dynamic> resposta = new ResponseJsonData <dynamic>();
UnidadeProducao caracterizacaoBanco = ObterPorEmpreendimento(caracterizacao.Empreendimento.Id);
int ultimoCodigoUP = _da.ObterUltimoCodigoUP(caracterizacao.Empreendimento.Id);
foreach (long item in caracterizacao.UnidadesProducao.Where(x => x.PossuiCodigoUP).Select(x => x.CodigoUP))
{
int aux = Convert.ToInt32(item.ToString().Substring(14));
if (aux > ultimoCodigoUP)
{
ultimoCodigoUP = aux;
}
}
foreach (UnidadeProducaoItem item in caracterizacao.UnidadesProducao)
{
int codigoIbge = 0;
resposta = requestJson.Executar <dynamic>(_configCoord.Obter <String>(ConfiguracaoCoordenada.KeyUrlObterMunicipioCoordenada) + "?easting=" + item.Coordenada.EastingUtm + "&northing=" + item.Coordenada.NorthingUtm);
if (resposta.Erros != null && resposta.Erros.Count > 0)
{
Validacao.Erros.AddRange(resposta.Erros);
return(Validacao.EhValido);
}
var objJson = resposta.Data;
if (objJson["EstaNoEstado"] && (objJson["Municipio"] == null || Convert.ToInt32(objJson["Municipio"]["IBGE"] ?? 0) == 0))
{
Validacao.Add(Mensagem.Mapas.MunicipioSemRetorno);
}
if (!Validacao.EhValido)
{
return(Validacao.EhValido);
}
if (objJson["Municipio"] != null)
{
codigoIbge = Convert.ToInt32(objJson["Municipio"]["IBGE"] ?? 0);
}
ListaValoresDa listaValoresDa = new ListaValoresDa();
item.Municipio = listaValoresDa.ObterMunicipio(codigoIbge);
if (!item.PossuiCodigoUP)
{
item.AnoAbertura = DateTime.Today.Year.ToString().Substring(2);
if (item.Id < 1)
{
ultimoCodigoUP++;
item.CodigoUP = Convert.ToInt64(
item.Municipio.Ibge.ToString() +
caracterizacao.CodigoPropriedade.ToString("D4") +
item.AnoAbertura +
ultimoCodigoUP.ToString("D2"));
}
else
{
item.CodigoUP = caracterizacaoBanco.UnidadesProducao.Single(x => x.Id == item.Id).CodigoUP;
}
}
else
{
item.AnoAbertura = item.CodigoUP.ToString().Substring(11, 2);
}
foreach (var aux in item.ResponsaveisTecnicos)
{
aux.CFONumero = aux.CFONumero.Split('-').GetValue(0).ToString();
}
}
#endregion
if (caracterizacao.UnidadesProducao.Any(x => caracterizacao.UnidadesProducao.Count(y => y.CodigoUP == x.CodigoUP) > 1))
{
Validacao.Add(Mensagem.UnidadeProducao.UnidadeProducaoItemIncorreto);
return(false);
}
foreach (var item in caracterizacao.UnidadesProducao)
{
if (item.CodigoUP.ToString().Substring(7, 4) != caracterizacao.CodigoPropriedade.ToString("D4"))
{
Validacao.Add(Mensagem.UnidadeProducao.CodigoUPNaoContemCodPropriedade(item.CodigoUP));
return(false);
}
}
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
bancoDeDados.IniciarTransacao();
_da.Salvar(caracterizacao, bancoDeDados);
Validacao.Add(Mensagem.UnidadeProducao.SalvoSucesso);
bancoDeDados.Commit();
}
}
catch (Exception e)
{
Validacao.AddErro(e);
}
return(Validacao.EhValido);
}
public void ConcluirCadastro(int fiscalizacaoId)
{
Fiscalizacao fiscalizacao = new Fiscalizacao();
bool gerarAutosTermo = false;
bool gerouVencimento = false;
try
{
if (_validar.Finalizar(fiscalizacaoId))
{
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
bancoDeDados.IniciarTransacao();
fiscalizacao = Obter(fiscalizacaoId, banco: bancoDeDados);
//Fiscalizacao
gerarAutosTermo = fiscalizacao.Infracao.IsGeradaSistema.GetValueOrDefault() ||
fiscalizacao.ObjetoInfracao.TeiGeradoPeloSistema.GetValueOrDefault() > 0 ||
fiscalizacao.MaterialApreendido.IsTadGeradoSistema.GetValueOrDefault();
#region AI
if (fiscalizacao.Infracao.IsGeradaSistema.HasValue)
{
if (!fiscalizacao.Infracao.IsGeradaSistema.GetValueOrDefault() && !gerarAutosTermo)
{
fiscalizacao.Vencimento.Data = fiscalizacao.Infracao.DataLavraturaAuto.Data.Value.AddDays(_prazoVencimentoDias);
gerouVencimento = true;
}
}
#endregion
#region TEI
if (fiscalizacao.ObjetoInfracao.TeiGeradoPeloSistema.HasValue)
{
if (!gerouVencimento && fiscalizacao.ObjetoInfracao.TeiGeradoPeloSistema.GetValueOrDefault() == 0 && !gerarAutosTermo)
{
fiscalizacao.Vencimento.Data = fiscalizacao.ObjetoInfracao.DataLavraturaTermo.Data.Value.AddDays(_prazoVencimentoDias);
gerouVencimento = true;
}
}
#endregion
#region TAD
if (fiscalizacao.MaterialApreendido.IsTadGeradoSistema.HasValue)
{
if (!gerouVencimento && !fiscalizacao.MaterialApreendido.IsTadGeradoSistema.GetValueOrDefault() && !gerarAutosTermo)
{
fiscalizacao.Vencimento.Data = fiscalizacao.MaterialApreendido.DataLavratura.Data.Value.AddDays(_prazoVencimentoDias);
gerouVencimento = true;
}
}
#endregion
if (!gerouVencimento)
{
fiscalizacao.Vencimento.Data = DateTime.Now.AddDays(_prazoVencimentoDias);
}
_da.ConcluirCadastro(fiscalizacao, gerarAutosTermo, bancoDeDados);
_daPrjGeo.ConcluirCadastro(fiscalizacao.Id, bancoDeDados);
ArquivoDa arquivoDa = new ArquivoDa();
ArquivoBus arquivoBus = new ArquivoBus(eExecutorTipo.Interno);
PdfFiscalizacao pdf = new PdfFiscalizacao();
if (gerarAutosTermo)
{
//AutoTermo
fiscalizacao.PdfAutoTermo = new Arquivo();
fiscalizacao.PdfAutoTermo.Nome = "AutoTermoFiscalizacao";
fiscalizacao.PdfAutoTermo.Extensao = ".pdf";
fiscalizacao.PdfAutoTermo.ContentType = "application/pdf";
fiscalizacao.PdfAutoTermo.Buffer = pdf.GerarAutoTermoFiscalizacao(fiscalizacao.Id, false, bancoDeDados);
arquivoBus.Salvar(fiscalizacao.PdfAutoTermo);
arquivoDa.Salvar(fiscalizacao.PdfAutoTermo, User.EtramiteIdentity.FuncionarioId, User.EtramiteIdentity.Name,
User.EtramiteIdentity.Login, (int)eExecutorTipo.Interno, User.EtramiteIdentity.FuncionarioTid, bancoDeDados);
}
else
{
fiscalizacao.PdfAutoTermo.Id = null;
}
//Laudo
fiscalizacao.PdfLaudo = new Arquivo();
fiscalizacao.PdfLaudo.Nome = "LaudoFiscalizacao";
fiscalizacao.PdfLaudo.Extensao = ".pdf";
fiscalizacao.PdfLaudo.ContentType = "application/pdf";
fiscalizacao.PdfLaudo.Buffer = pdf.GerarLaudoFiscalizacao(fiscalizacao.Id, false, bancoDeDados);
arquivoBus.Salvar(fiscalizacao.PdfLaudo);
arquivoDa.Salvar(fiscalizacao.PdfLaudo, User.EtramiteIdentity.FuncionarioId, User.EtramiteIdentity.Name,
User.EtramiteIdentity.Login, (int)eExecutorTipo.Interno, User.EtramiteIdentity.FuncionarioTid, bancoDeDados);
Arquivo arqCroqui = fiscalizacao.ProjetoGeo.Arquivos.SingleOrDefault(x => x.Tipo == (int)eProjetoGeograficoArquivoTipo.Croqui);
if (arqCroqui != null && arqCroqui.Id > 0)
{
arqCroqui = arquivoBus.Obter(arqCroqui.Id.GetValueOrDefault());
try
{
//Croqui
fiscalizacao.PdfCroqui = new Arquivo();
fiscalizacao.PdfCroqui.Nome = "CroquiFiscalizacao";
fiscalizacao.PdfCroqui.Extensao = ".pdf";
fiscalizacao.PdfCroqui.ContentType = "application/pdf";
fiscalizacao.PdfCroqui.Buffer = arqCroqui.Buffer;
arquivoBus.Salvar(fiscalizacao.PdfCroqui);
arquivoDa.Salvar(fiscalizacao.PdfCroqui, User.EtramiteIdentity.FuncionarioId, User.EtramiteIdentity.Name,
User.EtramiteIdentity.Login, (int)eExecutorTipo.Interno, User.EtramiteIdentity.FuncionarioTid, bancoDeDados);
}
finally
{
if (arqCroqui != null && arqCroqui.Buffer != null)
{
arqCroqui.Buffer.Close();
}
}
}
_da.SalvarDocumentosGerados(fiscalizacao, bancoDeDados);
_da.GerarHistorico(fiscalizacao.Id, eHistoricoAcao.finalizar, bancoDeDados);
_da.GerarConsulta(fiscalizacao.Id, bancoDeDados);
Validacao.Add(Mensagem.Fiscalizacao.Concluir);
bancoDeDados.Commit();
}
}
}
catch (Exception e)
{
Validacao.AddErro(e);
}
}
public bool VerificarPessoaFisica(Pessoa pessoa, bool isConjuge = false)
{
VerificarCriarCpf(pessoa, isConjuge);
if (String.IsNullOrWhiteSpace(pessoa.Fisica.Nome))
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioNomeMsg(isConjuge));
}
if (string.IsNullOrWhiteSpace(pessoa.Fisica.Nacionalidade))
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioNacionalidadeMsg(isConjuge));
}
if (string.IsNullOrWhiteSpace(pessoa.Fisica.Naturalidade))
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioNaturalidadeMsg(isConjuge));
}
if (!pessoa.Fisica.Sexo.HasValue && isConjuge)
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioSexoMsg(isConjuge));
}
else
{
if (pessoa.Fisica.Sexo <= 0)
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioSexoMsg(isConjuge));
}
}
if (pessoa.Fisica.EstadoCivil <= 0)
{
Validacao.Add(Mensagem.Pessoa.ObrigatorioEstadoCivilMsg(isConjuge));
}
if (pessoa.Fisica.DataNascimento.GetValueOrDefault() == DateTime.MinValue)
{
Validacao.Add(Mensagem.Pessoa.DataNascimentoObrigatoriaMsg(isConjuge));
}
else
{
VerificarFisicaDataNascimento(pessoa.Fisica.DataNascimento, isConjuge);
}
if (pessoa.Fisica.ConjugeId.GetValueOrDefault() > 0)
{
if (_da.ExistePessoa(pessoa.Fisica.ConjugeCPF, pessoa.CredenciadoId.GetValueOrDefault(), BancoValidar) <= 0)
{
Validacao.Add(Mensagem.Pessoa.ConjugeNaoExiste);
}
if (pessoa.Fisica.ConjugeId == pessoa.Id)
{
Validacao.Add(Mensagem.Pessoa.PessoaConjugeSaoIguais);
}
if (_da.ValidarConjugeAssociado(pessoa.CPFCNPJ, pessoa.Fisica.ConjugeCPF, User.EtramiteIdentity.FuncionarioId))
{
Validacao.Add(Mensagem.Pessoa.ConjugeJaAssociado);
}
}
else if (pessoa.Fisica.Conjuge != null && !string.IsNullOrEmpty(pessoa.Fisica.Conjuge.CPFCNPJ))
{
if (pessoa.Fisica.Conjuge.CPFCNPJ == pessoa.CPFCNPJ)
{
Validacao.Add(Mensagem.Pessoa.PessoaConjugeSaoIguais);
}
if (_da.ValidarConjugeAssociado(pessoa.CPFCNPJ, pessoa.Fisica.Conjuge.CPFCNPJ, pessoa.CredenciadoId.GetValueOrDefault()))
{
Validacao.Add(Mensagem.Pessoa.ConjugeJaAssociado);
}
}
if (!pessoa.IsCopiado && pessoa.Fisica.ConjugeId.GetValueOrDefault() > 0 && !isConjuge && User != null)
{
pessoa.Fisica.Conjuge = _da.Obter(pessoa.Fisica.ConjugeId.GetValueOrDefault(), null, simplificado: false);
VerificarPessoaFisica(pessoa.Fisica.Conjuge, true);
}
return(Validacao.EhValido);
}
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)
{
Validacao.Add(Mensagem.Documento.QuantidadeDocumentoObrigatoria);
}
if (string.IsNullOrEmpty(documento.Nome))
{
Validacao.Add(Mensagem.Documento.NomeObrigatorio);
}
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 ActionResult Editar(int id, int tipoCadastro = 0, int internoId = 0, bool isCopiado = false, bool isConjuge = false)
{
PessoaVM vm = new PessoaVM();
vm.IsConjuge = isConjuge;
if (id > 0)
{
vm.Pessoa = _bus.Obter(id);
if (!_validar.EmPosseCredenciado(vm.Pessoa))
{
Validacao.Add(Mensagem.Pessoa.Posse);
if (Request.IsAjaxRequest())
{
return(Json(new { @EhValido = Validacao.EhValido, @Msg = Validacao.Erros }, JsonRequestBehavior.AllowGet));
}
return(RedirectToAction("Index", Validacao.QueryParamSerializer()));
}
}
else
{
vm.Pessoa = _busInterno.Obter(internoId);
vm.Pessoa.IsCopiado = true;
Pessoa pesCredenciado = _bus.Obter(vm.Pessoa.CPFCNPJ, credenciadoId: _bus.User.FuncionarioId);
vm.Pessoa.Id = pesCredenciado.Id;
vm.Pessoa.InternoId = internoId;
if (vm.Pessoa.IsJuridica)
{
vm.Pessoa.Juridica.Representantes.ForEach(representante =>
{
representante.InternoId = representante.Id;
representante.Id = 0;
representante.IsCopiado = true;
});
}
else
{
if (vm.Pessoa.Fisica.ConjugeId > 0)
{
Pessoa pesCredenciadoAux = _bus.Obter(vm.Pessoa.Fisica.ConjugeCPF, simplificado: true, credenciadoId: _bus.User.FuncionarioId);
vm.Pessoa.Fisica.ConjugeInternoId = vm.Pessoa.Fisica.ConjugeId;
vm.Pessoa.Fisica.ConjugeId = pesCredenciadoAux.Id;
}
}
if (!isCopiado && pesCredenciado.Fisica.ConjugeId.GetValueOrDefault() > 0)
{
vm.Pessoa.Fisica.ConjugeId = pesCredenciado.Fisica.ConjugeId.GetValueOrDefault();
}
}
vm.CpfCnpjValido = true;
vm.ExibirMensagensPartial = true;
vm.OcultarLimparPessoa = true;
vm.TipoCadastro = tipoCadastro;
CarregaCampos(vm);
PreencheSalvarVM(vm);
vm.UrlAcao = Url.Action("Editar", "Pessoa");
if (Request.IsAjaxRequest())
{
return(PartialView("PessoaPartial", vm));
}
return(View(vm));
}
internal bool Salvar(RegistroAtividadeFlorestal caracterizacao)
{
if (!_caracterizacaoValidar.Basicas(caracterizacao.EmpreendimentoId))
{
return(false);
}
if (caracterizacao.Id <= 0 && (_da.ObterPorEmpreendimento(caracterizacao.EmpreendimentoId, true) ?? new RegistroAtividadeFlorestal()).Id > 0)
{
Validacao.Add(Mensagem.Caracterizacao.EmpreendimentoCaracterizacaoJaCriada);
return(false);
}
#region Numero
if (!caracterizacao.PossuiNumero.HasValue)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.PossuiNumeroObrigatorio);
}
if (string.IsNullOrWhiteSpace(caracterizacao.NumeroRegistro) && caracterizacao.PossuiNumero.GetValueOrDefault())
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroRegistroObrigatorio);
}
else if (!ValidacoesGenericasBus.ValidarNumero(caracterizacao.NumeroRegistro, 9) && caracterizacao.PossuiNumero.GetValueOrDefault())
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroRegistroInvalido);
}
else if (_da.IsNumeroUtilizado(caracterizacao.NumeroRegistro, caracterizacao.EmpreendimentoId))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroUtilizado);
}
else if (caracterizacao.PossuiNumero.GetValueOrDefault())
{
int numeroMaximo = _config.RegAtvFlorestalNumeroMaximo;
if (Convert.ToInt32(caracterizacao.NumeroRegistro) > numeroMaximo)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroRegistroSuperiorMax(numeroMaximo.ToString()));
}
}
#endregion
if (caracterizacao.Consumos.Count <= 0)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.ConsumoObrigatorio);
}
#region Consumos
var count = 0;
caracterizacao.Consumos.ForEach(r =>
{
if (caracterizacao.Consumos.Any(x => caracterizacao.Consumos.Count(y => y.Atividade == x.Atividade) > 1))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.CategoriaDuplicada);
return;
}
AtividadeSolicitada atividadeSolicitada = _da.ObterAtividadeSolicitada(r.Atividade);
if (atividadeSolicitada != null && !atividadeSolicitada.Situacao)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.AtividadeDesabilitada(atividadeSolicitada.Texto, count));
}
else
{
if (r.Atividade == ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.FabricanteMotosserra) ||
r.Atividade == ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.ComercianteMotosserra))
{
r.FontesEnergia.Clear();
}
else
{
if (r.Atividade == 0)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.CategoriaObrigatoria(count));
return;
}
if (r.FontesEnergia.Count == 0)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.FonteEnergiaObrigatoria(count));
return;
}
}
if (!r.PossuiLicencaAmbiental.HasValue)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.PossuiLicencaAmbiental(count));
}
else
{
switch (r.PossuiLicencaAmbiental.GetValueOrDefault())
{
case ConfiguracaoSistema.NAO:
if (_caracterizacaoValidar.AtividadeLicencaObrigatoria(r.Atividade))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.LicencaAmbientalObrigatoria(count, atividadeSolicitada.Categoria + " - " + atividadeSolicitada.Texto));
}
break;
case ConfiguracaoSistema.SIM:
if (!r.Licenca.EmitidoPorInterno.HasValue)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.EmitidoIDAFOuExterno(count));
}
else
{
if (r.Licenca.TituloModelo == 0)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.ModeloLicencaObrigatorio(count));
}
if (string.IsNullOrWhiteSpace(r.Licenca.TituloModeloTexto))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.ModeloLicencaObrigatorio(count));
}
if (string.IsNullOrWhiteSpace(r.Licenca.TituloNumero))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroLicencaObrigatorio(count));
}
else
{
if (r.Licenca.EmitidoPorInterno.Value && !ValidacoesGenericasBus.ValidarMaskNumeroBarraAno(r.Licenca.TituloNumero))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroLicencaInvalido(count));
}
}
ValidacoesGenericasBus.DataMensagem(r.Licenca.TituloValidadeData, "TituloValidadeData_DataTexto" + count, "validade", false);
if (string.IsNullOrWhiteSpace(r.Licenca.ProtocoloNumero))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroProtocoloLicencaObrigatorio(count));
}
if (r.Licenca.TituloValidadeData.Data.GetValueOrDefault() < DateTime.Today || !r.Licenca.ProtocoloRenovacaoData.IsEmpty)
{
ValidacoesGenericasBus.DataMensagem(r.Licenca.ProtocoloRenovacaoData, "ProtocoloRenovacaoData_DataTexto" + count, "renovação");
}
if (!r.Licenca.ProtocoloRenovacaoData.IsEmpty && r.Licenca.TituloValidadeData.Data.GetValueOrDefault() < r.Licenca.ProtocoloRenovacaoData.Data)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.RenovacaoDataMaiorValidade(count));
}
if (r.Licenca.TituloValidadeData.Data.GetValueOrDefault() < DateTime.Today && string.IsNullOrWhiteSpace(r.Licenca.ProtocoloRenovacaoNumero))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroProtocoloRenovacaoObrigatorio(count));
}
if (!r.Licenca.EmitidoPorInterno.Value && string.IsNullOrWhiteSpace(r.Licenca.OrgaoExpedidor))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.OrgaoExpedidoObrigatorio(count));
}
}
break;
case ConfiguracaoSistema.Dispensado:
if (!r.Licenca.EmitidoPorInterno.HasValue)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.GrupoDispensadoEmitidoIDAFOuExterno(count));
}
if (string.IsNullOrWhiteSpace(r.Licenca.TituloModeloTexto))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.DocumentoObrigatorio(count));
}
if (string.IsNullOrWhiteSpace(r.Licenca.ProtocoloNumero))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.NumeroProtocoloLicencaObrigatorio(count));
}
if (string.IsNullOrWhiteSpace(r.Licenca.OrgaoExpedidor))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.OrgaoEmissorObrigatorio(count));
}
break;
default:
break;
}
}
if (string.IsNullOrWhiteSpace(r.DUANumero))
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.DUANumeroObrigatorio(count));
}
if (Convert.ToDecimal(r.DUAValor) <= 0)
{
Validacao.Add(Mensagem.RegistroAtividadeFlorestal.DUAValorObrigatorio(count));
}
ValidacoesGenericasBus.DataMensagem(r.DUADataPagamento, "DUADataPagamento" + count, "pagamento do DUA");
}
count++;
});
#endregion
return(Validacao.EhValido);
}
public bool CopiarDadosCredenciado(int projetoDigitalID, BancoDeDados banco, BancoDeDados bancoCredenciado)
{
CaractCredBus.CaracterizacaoBus caracCredBus = new CaractCredBus.CaracterizacaoBus();
ProjetoDigitalCredenciadoBus projetoDigitalCredenciadoBus = new ProjetoDigitalCredenciadoBus();
int empreendimentoID = projetoDigitalCredenciadoBus.Obter(projetoDigitalID, 0, null, null).EmpreendimentoId ?? 0;
if (empreendimentoID < 1)
{
return(false);
}
EmpreendimentoCaracterizacao empreendimento = caracCredBus.ObterEmpreendimentoSimplificado(empreendimentoID);
ProjetoGeograficoBus projetoGeograficoBus = new ProjetoGeograficoBus();
List <Dependencia> dependencias = projetoDigitalCredenciadoBus.ObterDependencias(projetoDigitalID);
ICaracterizacaoBus caracterizacaoBus;
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
bancoDeDados.IniciarTransacao();
foreach (Dependencia item in dependencias.Where(x => x.DependenciaTipo == (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico).ToList())
{
projetoGeograficoBus.CopiarDadosCredenciado(item, empreendimento.InternoID, bancoDeDados, bancoCredenciado);
if (!Validacao.EhValido)
{
break;
}
}
if (!Validacao.EhValido)
{
bancoDeDados.Rollback();
return(false);
}
foreach (Dependencia item in dependencias.Where(x => x.DependenciaTipo == (int)eCaracterizacaoDependenciaTipo.Caracterizacao).ToList())
{
caracterizacaoBus = CaracterizacaoBusFactory.Criar((eCaracterizacao)item.DependenciaCaracterizacao);
if (caracterizacaoBus == null)
{
Validacao.Add(eTipoMensagem.Erro, item.DependenciaCaracterizacaoTexto + " Bus não criada");
}
if (!caracterizacaoBus.CopiarDadosCredenciado(item, empreendimento.InternoID, bancoDeDados, bancoCredenciado))
{
break;
}
}
if (!Validacao.EhValido)
{
bancoDeDados.Rollback();
return(false);
}
Validacao.Add(Mensagem.ProjetoDigital.CopiarCaracterizacao);
bancoDeDados.Commit();
}
return(true);
}
public virtual void OnAuthorization(AuthorizationContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException("filterContext");
}
if (AuthorizeCore(filterContext.HttpContext))
{
// ** IMPORTANT **
// Since we're performing authorization at the action level, the authorization code runs
// after the output caching module. In the worst case this could allow an authorized user
// to cause the page to be cached, then an unauthorized user would later be served the
// cached page. We work around this by telling proxies not to cache the sensitive page,
// then we hook our custom authorization code into the caching mechanism so that we have
// the final say on whether a page should be served from the cache.
HttpCachePolicyBase cachePolicy = filterContext.HttpContext.Response.Cache;
cachePolicy.SetProxyMaxAge(new TimeSpan(0));
cachePolicy.AddValidationCallback(CacheValidateHandler, null /* data */);
}
else
{
// auth failed, redirect to login page
/*if (filterContext.HttpContext.User.Identity.IsAuthenticated &&
* _rolesSplit.Length > 0)
* {
* PermissaoValidar validar = new PermissaoValidar();
* validar.Verificar(_rolesSplit.Select(x => (ePermissao)Enum.Parse(typeof(ePermissao), x)).ToArray());
* }*/
/*if (filterContext.HttpContext.User.Identity.IsAuthenticated && filterContext.HttpContext.Request.IsAjaxRequest())
* {
* filterContext.Result = new JsonResult
* {
* Data = new
* {
* MsgPermissoes = Validacao.Erros
* },
* JsonRequestBehavior = JsonRequestBehavior.AllowGet
* };
*
* filterContext.HttpContext.Response.StatusCode = 500;
* //filterContext.HttpContext.Response.SubStatusCode = 1;
* filterContext.HttpContext.Response.StatusDescription = Mensagem.Concatenar(Validacao.Erros.Select(x => x.Texto).ToList());
* filterContext.HttpContext.Response.SuppressContent = false;
* filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
* }
* else
* {*/
Validacao.Add(new Mensagem()
{
Tipo = eTipoMensagem.Erro, Texto = "Usuário não associado as regras do sistema. Contate o Administrador do sistema."
});
filterContext.Result = new HttpUnauthorizedResult();
//string url = Validacao.QueryParamSerializer(FormsAuthentication.LoginUrl);
//filterContext.Result = new RedirectResult(url);
//}
}
}
public bool DominioSalvar(Dominio dominio)
{
switch (dominio.Tipo)
{
case eDominioTipo.Matricula:
#region Matricula
if (String.IsNullOrWhiteSpace(dominio.Matricula))
{
Validacao.Add(Mensagem.Dominialidade.DominioMatriculaObrigatorio);
}
if (String.IsNullOrWhiteSpace(dominio.Folha))
{
Validacao.Add(Mensagem.Dominialidade.DominioFolhaObrigatorio);
}
if (String.IsNullOrWhiteSpace(dominio.Livro))
{
Validacao.Add(Mensagem.Dominialidade.DominioLivroObrigatorio);
}
if (String.IsNullOrWhiteSpace(dominio.Cartorio))
{
Validacao.Add(Mensagem.Dominialidade.DominioCartorioObrigatorio);
}
break;
#endregion
case eDominioTipo.Posse:
#region Posse
if (dominio.ComprovacaoId <= 0)
{
Validacao.Add(Mensagem.Dominialidade.DominioComprovacaoObrigatorio);
}
if (dominio.ComprovacaoId != (int)eDominioComprovacao.PosseiroPrimitivo)
{
if (dominio.ComprovacaoId != (int)eDominioComprovacao.Recibo &&
dominio.ComprovacaoId != (int)eDominioComprovacao.CertidaoPrefeitura &&
dominio.ComprovacaoId != (int)eDominioComprovacao.ContratoCompraVenda &&
dominio.ComprovacaoId != (int)eDominioComprovacao.Declaracao &&
dominio.ComprovacaoId != (int)eDominioComprovacao.Outros &&
dominio.ComprovacaoId != (int)eDominioComprovacao.CertificadoCadastroImovelRuralCCIR)
{
if (String.IsNullOrWhiteSpace(dominio.DescricaoComprovacao))
{
Validacao.Add(Mensagem.Dominialidade.RegistroObrigatorio);
}
}
}
break;
#endregion
}
if (dominio.Tipo == eDominioTipo.Matricula || dominio.ComprovacaoId != (int)eDominioComprovacao.PosseiroPrimitivo)
{
if (!String.IsNullOrWhiteSpace(dominio.AreaDocumentoTexto))
{
if (!ValidacoesGenericasBus.ValidarDecimal(DecimalEtx.ClearMask(dominio.AreaDocumentoTexto), 13, 2))
{
Validacao.Add(Mensagem.Dominialidade.AreaInvalida("DominioAreaDocumento", "Área " + ((dominio.Tipo == eDominioTipo.Matricula) ? "Matrícula" : "Posse") + " Documento"));
}
else if (DecimalEtx.ToDecimalMask(dominio.AreaDocumentoTexto).GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.Dominialidade.AreaMaiorZero("DominioAreaDocumento", "Área " + ((dominio.Tipo == eDominioTipo.Matricula) ? "Matrícula" : "Posse") + " Documento"));
}
}
else
{
Validacao.Add(Mensagem.Dominialidade.AreaObrigatoria("DominioAreaDocumento", "Área " + ((dominio.Tipo == eDominioTipo.Matricula) ? "Matrícula" : "Posse") + " Documento"));
}
}
#region Empreendimento com localizacao Zona Rural
if (!dominio.DataUltimaAtualizacao.IsEmpty)
{
ValidacoesGenericasBus.DataMensagem(dominio.DataUltimaAtualizacao, "DominioDataUltimaAtualizacao_DataTexto", "última atualização");
}
#endregion
if (dominio.ReservasLegais == null || dominio.ReservasLegais.Count <= 0)
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalObrigatoria);
}
if (dominio.ReservasLegais.Exists(x => x.SituacaoId == (int)eReservaLegalSituacao.NaoInformada) &&
dominio.ReservasLegais.Exists(x => x.SituacaoId == (int)eReservaLegalSituacao.Proposta || x.SituacaoId == (int)eReservaLegalSituacao.Registrada))
{
Validacao.Add(Mensagem.Dominialidade.ReservaLegalNaoInformadaDeclarada);
}
string prefixo = "Dominio";
if (String.IsNullOrWhiteSpace(dominio.ConfrontacaoNorte))
{
Validacao.Add(Mensagem.Dominialidade.ConfrontacaoNorteObrigatorio(prefixo));
}
if (String.IsNullOrWhiteSpace(dominio.ConfrontacaoSul))
{
Validacao.Add(Mensagem.Dominialidade.ConfrontacaoSulObrigatorio(prefixo));
}
if (String.IsNullOrWhiteSpace(dominio.ConfrontacaoLeste))
{
Validacao.Add(Mensagem.Dominialidade.ConfrontacaoLesteObrigatorio(prefixo));
}
if (String.IsNullOrWhiteSpace(dominio.ConfrontacaoOeste))
{
Validacao.Add(Mensagem.Dominialidade.ConfrontacaoOesteObrigatorio(prefixo));
}
return(Validacao.EhValido);
}
internal bool Salvar(CARSolicitacao carSolicitacao)
{
if (carSolicitacao.ProjetoId < 1)
{
Validacao.Add(Mensagem.CARSolicitacao.ProjetoObrigatorio);
return(false);
}
if (carSolicitacao.Requerimento.Id < 1)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoRequerimentoObrigatorio);
}
if (carSolicitacao.Atividade.Id < 1)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoAtividadeObrigatoria);
}
if (carSolicitacao.Atividade.Id != ConfiguracaoAtividade.ObterId((int)eAtividadeCodigo.CadastroAmbientalRural))
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoAtividadeInvalida);
}
if (carSolicitacao.Empreendimento.Id < 1)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoEmpreendimentoObrigatorio);
}
if (carSolicitacao.Empreendimento.Codigo < 1)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoEmpreendimentoCodigoObrigatorio);
}
if (string.IsNullOrEmpty(carSolicitacao.Empreendimento.NomeRazao))
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoEmpreendimentoNomeRazaoObrigatorio);
}
if (carSolicitacao.Declarante.Id < 1)
{
Validacao.Add(Mensagem.CARSolicitacao.SolicitacaoDeclaranteObrigatorio);
}
#region Projeto Digital
ProjetoDigital projetoDigital = _busProjetoDigital.Obter(carSolicitacao.ProjetoId);
if (projetoDigital.Situacao != (int)eProjetoDigitalSituacao.AguardandoImportacao)
{
Validacao.Add(Mensagem.CARSolicitacao.SituacaoDeveSerAguardandoImportacao);
}
#endregion
#region Requerimento
Requerimento requerimento = _busRequerimento.ObterSimplificado(carSolicitacao.Requerimento.Id);
if (requerimento == null || requerimento.Id < 1)
{
Validacao.Add(Mensagem.Requerimento.Inexistente);
}
if (requerimento.CredenciadoId != User.FuncionarioId)
{
Validacao.Add(Mensagem.Requerimento.PosseCredenciado);
}
if (requerimento.Empreendimento.Id < 1)
{
Validacao.Add(Mensagem.CARSolicitacao.ProjetoDigitalSemEmpreendimento);
}
#endregion
#region Solitação de CAR
EmpreendimentoCaracterizacao empreendimento = _busCaracterizacao.ObterEmpreendimentoSimplificado(carSolicitacao.Empreendimento.Id);
if (!EmpreendimentoSolicitacaoCAR(empreendimento))
{
return(false);
}
#endregion Solitação de CAR
#region Validar Dados da Caracterizacao
if (projetoDigital.Dependencias.Count(x => x.DependenciaTipo == (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico) < 1)
{
Validacao.Add(Mensagem.CARSolicitacao.ProjetoDigitalDominialidadeAssociada);
}
projetoDigital.Dependencias.ForEach(x =>
{
if (x.DependenciaTipo == (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico && x.DependenciaCaracterizacao == (int)eCaracterizacao.Dominialidade)
{
if (_busProjetoGeografico.ObterSitacaoProjetoGeografico(x.DependenciaId) != (int)eProjetoGeograficoSituacao.Finalizado)
{
Validacao.Add(Mensagem.CARSolicitacao.ProjetoGeograficoNaoEstaFinalizado);
}
}
});
#endregion
#region Validar Dados do Titulo
String tituloSituacao = _carSolicitacaoInternoDa.ObterSituacaoTituloCARExistente(empreendimento.InternoID);
if (!String.IsNullOrWhiteSpace(tituloSituacao))
{
Validacao.Add(Mensagem.CARSolicitacao.EmpreendimentoPossuiTitulo(tituloSituacao));
}
#endregion
return(Validacao.EhValido);
}
private bool Assinantes(Titulo titulo)
{
if (titulo == null)
{
return(false);
}
//Obrigatoriedade de assinante conforme configuração
if (titulo.Modelo.Assinantes != null && titulo.Modelo.Assinantes.Count > 0)
{
// valida se título deve ter ao menos um assinante Dominio
if (titulo.Assinantes != null && titulo.Assinantes.Count() <= 0)
{
Validacao.Add(Mensagem.Titulo.AssinanteObrigatorio);
return(false);
}
}
else
{
// valida se título deve ter ao menos um assinante Dominio
if (titulo.Assinantes != null && titulo.Assinantes.Count() > 0)
{
Validacao.Add(Mensagem.Titulo.AssinanteDesmarcar);
return(false);
}
//Não há mais validações de assinantes
return(true);
}
List <FuncionarioLst> lstCnfFuncRespSetor = new List <FuncionarioLst>();
FuncionarioLst respSetor = null;
foreach (Assinante configAssinante in titulo.Modelo.Assinantes.Where(x => x.TipoId == 1))
{
respSetor = _funcionarioBus.ObterResponsavelSetor(configAssinante.SetorId);
if (respSetor != null)
{
lstCnfFuncRespSetor.Add(_funcionarioBus.ObterResponsavelSetor(configAssinante.SetorId));
}
}
//Validar configuração de regras do modelo.
if (lstCnfFuncRespSetor.Count == 0 && titulo.Modelo.Assinantes.Exists(x => x.TipoId == 1))
{
Validacao.Add(Mensagem.Titulo.AssinanteSetorSemResponsavel);
return(false);
}
foreach (TituloAssinante assinante in titulo.Assinantes)
{
//Assinante configurado como Responsavel no modelo
if (lstCnfFuncRespSetor.Any(x => x.Id == assinante.FuncionarioId))
{
continue;
}
//Assinante configurado como qualquer funcionario do setor
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
bool noSetor = false;
foreach (Assinante configAssinante in titulo.Modelo.Assinantes.Where(x => x.TipoId == 2))
{
if (_funcionarioBus.VerificarFuncionarioContidoSetor(assinante.FuncionarioId, configAssinante.SetorId, bancoDeDados))
{
noSetor = true;
break;
}
}
if (noSetor)
{
continue;
}
}
Validacao.Add(Mensagem.Titulo.AssinanteInvalidoDesmarcar(_funcionarioBus.Obter(assinante.FuncionarioId).Nome));
}
if (titulo.Assinantes != null && titulo.Assinantes.Count > 0)
{
// valida se há algum assinante sem cargo escolhido
foreach (TituloAssinante assinante in titulo.Assinantes)
{
if (assinante.FuncionarioCargoId <= 0)
{
Validacao.Add(Mensagem.Titulo.AssinanteCargoObrigatorio);
}
}
}
return(Validacao.EhValido);
}
public bool Dependencias(int empreendimentoId, int caracterizacaoTipo, List <Caracterizacao> caracterizacoes = null, bool isDependencia = false, bool validarProjetoGeoProprio = true, bool validarDscLicAtividadeProprio = true)
{
List <DependenciaLst> dependencias = _caracterizacaoConfig.Obter <List <DependenciaLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoesDependencias);
if (dependencias == null || dependencias.Count <= 0)
{
return(true);
}
if (caracterizacoes == null)
{
caracterizacoes = _da.ObterCaracterizacoes(empreendimentoId);
}
List <CaracterizacaoLst> caracterizacoesCache = _caracterizacaoConfig.Obter <List <CaracterizacaoLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoes);
string caracterizacaoTexto = caracterizacoesCache.SingleOrDefault(x => x.Id == caracterizacaoTipo).Texto;
dependencias = dependencias.Where(x => x.DependenteTipo == caracterizacaoTipo && x.TipoDetentorId == (int)eCaracterizacaoDependenciaTipo.Caracterizacao).ToList();
Caracterizacao caracterizacao = null;
foreach (DependenciaLst dependencia in dependencias)
{
caracterizacao = caracterizacoes.SingleOrDefault(y => (int)y.Tipo == dependencia.DependenciaTipo) ?? new Caracterizacao();
switch (dependencia.TipoId)
{
case (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico:
if (dependencia.DependenciaTipo == caracterizacaoTipo)
{
if (!validarProjetoGeoProprio)
{
continue;
}
else if (caracterizacao.ProjetoId > 0 && caracterizacaoTipo != (int)eCaracterizacao.ExploracaoFlorestal)
{
if (!string.IsNullOrEmpty(DependenciasAlteradas(empreendimentoId, caracterizacaoTipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico,
_da.ObterDependencias(caracterizacao.ProjetoId, (eCaracterizacao)caracterizacaoTipo, eCaracterizacaoDependenciaTipo.ProjetoGeografico))))
{
Validacao.Add(Mensagem.Caracterizacao.DependenciaDesatualizada(true, caracterizacaoTexto));
continue;
}
}
}
if (dependencia.DependenteTipo == (int)eCaracterizacao.RegularizacaoFundiaria && caracterizacao.ProjetoId <= 0 && caracterizacaoTipo != (int)eCaracterizacao.RegularizacaoFundiaria)
{
Validacao.Add(Mensagem.Caracterizacao.DependenciasProjetoGeoSalvar(caracterizacaoTexto, false, caracterizacoesCache.SingleOrDefault(x => x.Id == (int)eCaracterizacao.Dominialidade).Texto));
continue;
}
if (dependencia.DependenteTipo == (int)eCaracterizacao.ExploracaoFlorestal && caracterizacao.ProjetoId <= 0 && caracterizacaoTipo != (int)eCaracterizacao.ExploracaoFlorestal)
{
Validacao.Add(Mensagem.Caracterizacao.DependenciasProjetoGeoSalvar(caracterizacaoTexto, false, caracterizacoesCache.SingleOrDefault(x => x.Id == dependencia.DependenciaTipo).Texto));
continue;
}
break;
case (int)eCaracterizacaoDependenciaTipo.Caracterizacao:
if (caracterizacao.Id <= 0)
{
Validacao.Add(Mensagem.Caracterizacao.DependenciasCaracterizacaoSalvar(caracterizacaoTexto, false, caracterizacoesCache.SingleOrDefault(x => x.Id == dependencia.DependenciaTipo).Texto));
continue;
}
else if (validarProjetoGeoProprio || validarDscLicAtividadeProprio)
{
if (!string.IsNullOrEmpty(DependenciasAlteradas(empreendimentoId, dependencia.DependenciaTipo, eCaracterizacaoDependenciaTipo.Caracterizacao,
_da.ObterDependencias(caracterizacao.Id, (eCaracterizacao)dependencia.DependenciaTipo, eCaracterizacaoDependenciaTipo.Caracterizacao))))
{
Validacao.Add(Mensagem.Caracterizacao.DependenciaDesatualizada(false, caracterizacoesCache.SingleOrDefault(x => x.Id == dependencia.DependenciaTipo).Texto));
continue;
}
}
Dependencias(empreendimentoId, (int)caracterizacao.Tipo, caracterizacoes, true);
break;
case (int)eCaracterizacaoDependenciaTipo.DescricaoLicenciamentoAtividade:
if (!validarDscLicAtividadeProprio)
{
if (!string.IsNullOrEmpty(DependenciasAlteradas(empreendimentoId, dependencia.DependenciaTipo, eCaracterizacaoDependenciaTipo.Caracterizacao,
_da.ObterDependencias(caracterizacao.Id, (eCaracterizacao)dependencia.DependenciaTipo, eCaracterizacaoDependenciaTipo.Caracterizacao))))
{
Validacao.Add(Mensagem.Caracterizacao.DependenciaDesatualizada(false, caracterizacoesCache.SingleOrDefault(x => x.Id == dependencia.DependenciaTipo).Texto));
continue;
}
}
break;
}
}
return(Validacao.EhValido);
}
private void Obrigatoriedades(Titulo titulo)
{
if (titulo.Autor == null || titulo.Autor.Id <= 0)
{
Validacao.Add(Mensagem.Titulo.AutorObrigatorio);
}
if (titulo.Id == 0 && titulo.DataCriacao.IsEmpty)
{
Validacao.Add(Mensagem.Titulo.DataCriacaoObrigatorio);
}
if (titulo.Id == 0 && !titulo.DataCriacao.IsValido)
{
Validacao.Add(Mensagem.Titulo.DataCriacaoInvalida);
}
if (titulo.Setor == null || titulo.Setor.Id <= 0)
{
Validacao.Add(Mensagem.Titulo.SetorCadastroObrigatorio);
}
if (titulo.Situacao.Id <= 0)
{
Validacao.Add(Mensagem.Titulo.SituacaoObrigatorio);
}
if (titulo.LocalEmissao == null || titulo.LocalEmissao.Id <= 0)
{
Validacao.Add(Mensagem.Titulo.LocalEmissaoObrigatorio);
}
if (titulo.Modelo == null || titulo.Modelo.Id <= 0)
{
Validacao.Add(Mensagem.Titulo.ModeloObrigatorio);
return;
}
//Valida a obrigatoriedade do protocolo [Processo/Documento]
if (titulo.Modelo.Regra(eRegra.ProtocoloObrigatorio))
{
switch (titulo.Modelo.TipoProtocoloEnum)
{
case eTipoProtocolo.Processo:
if (titulo.Protocolo == null || !titulo.Protocolo.IsProcesso || titulo.Protocolo.Id <= 0)
{
Validacao.Add(Mensagem.Titulo.ProcessoObrigatorio);
}
break;
case eTipoProtocolo.Documento:
if (titulo.Protocolo == null || titulo.Protocolo.IsProcesso || titulo.Protocolo.Id <= 0)
{
Validacao.Add(Mensagem.Titulo.DocumentoObrigatorio);
}
break;
case eTipoProtocolo.Protocolo:
if (titulo.Protocolo == null || titulo.Protocolo.Id <= 0)
{
Validacao.Add((titulo.Protocolo.IsProcesso) ? Mensagem.Titulo.ProcessoObrigatorio : Mensagem.Titulo.DocumentoObrigatorio);
}
break;
}
}
else
{
switch (titulo.Modelo.TipoProtocoloEnum)
{
case eTipoProtocolo.Processo:
//Verifica se é documento para apresentar mensagem
if (titulo.Protocolo != null && !titulo.Protocolo.IsProcesso && titulo.Protocolo.Id > 0)
{
Validacao.Add(Mensagem.Titulo.ProcessoOuEmpreendimentoObrigatorio);
}
break;
case eTipoProtocolo.Documento:
//Verifica se é processo para apresentar mensagem
if (titulo.Protocolo != null && titulo.Protocolo.IsProcesso && titulo.Protocolo.Id > 0)
{
Validacao.Add(Mensagem.Titulo.DocumentoOuEmpreendimentoObrigatorio);
}
break;
}
if ((titulo.Protocolo == null || titulo.Protocolo.Id == 0) && (titulo.EmpreendimentoId ?? 0) == 0)
{
string textoProcDoc = "processo/documento";
if (titulo.Modelo.TipoProtocoloEnum == eTipoProtocolo.Processo)
{
textoProcDoc = "processo";
}
if (titulo.Modelo.TipoProtocoloEnum == eTipoProtocolo.Documento)
{
textoProcDoc = "documento";
}
Validacao.Add(Mensagem.Titulo.ObrigatorioProcDocEmp(textoProcDoc));
}
}
}
public void AlterarSituacao(Titulo titulo, BancoDeDados banco = null)
{
Titulo atualTitulo = _da.ObterSimplificado(titulo.Id);
bool isGerarNumero = false;
bool isGerarPdf = false;
if (!_validar.AlterarSituacao(titulo, atualTitulo.Situacao.Id == (int)eTituloSituacao.EmCadastro))
{
return;
}
#region Configurar Nova Situacao
//Situação Nova
switch ((eTituloSituacao)titulo.Situacao.Id)
{
#region 3 - Valido
case eTituloSituacao.Valido:
if (atualTitulo.Situacao.Id == (int)eTituloSituacao.EmCadastro)
{
isGerarNumero = true;
isGerarPdf = true;
}
break;
#endregion
}
#endregion
#region Numero de Titulo
if (isGerarNumero)
{
titulo.Numero.ReiniciaPorAno = titulo.Modelo.Regra(eRegra.NumeracaoReiniciada);
if (titulo.Modelo.Regra(eRegra.NumeracaoAutomatica))
{
titulo.Numero.Automatico = true;
TituloModeloResposta iniciarEm = titulo.Modelo.Resposta(eRegra.NumeracaoAutomatica, eResposta.InicioNumeracao);
titulo.Numero.IniciaEm = null;
titulo.Numero.IniciaEmAno = null;
if (iniciarEm != null)
{
if (iniciarEm.Valor == null || !ValidacoesGenericasBus.ValidarMaskNumeroBarraAno(iniciarEm.Valor.ToString()))
{
Validacao.Add(Mensagem.Titulo.IniciarEmInvalido);
return;
}
string[] iniciar = iniciarEm.Valor.ToString().Split('/');
titulo.Numero.IniciaEm = Convert.ToInt32(iniciar[0]);
titulo.Numero.IniciaEmAno = Convert.ToInt32(iniciar[1]);
if (titulo.Numero.IniciaEmAno.GetValueOrDefault() != DateTime.Now.Year)
{
titulo.Numero.IniciaEm = null;
titulo.Numero.IniciaEmAno = null;
}
}
}
titulo.Numero.Ano = DateTime.Today.Year;
}
#endregion
GerenciadorTransacao.ObterIDAtual();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia(banco))
{
bancoDeDados.IniciarTransacao();
_da.DeclaratorioAlterarSituacao(titulo, bancoDeDados);
#region Atividades
AtividadeBus atividadeBus = new AtividadeBus();
#region Título Valido
if (titulo.Situacao.Id == (int)eTituloSituacao.Valido)
{
if (titulo.Atividades != null && titulo.Atividades.Count > 0)
{
foreach (Atividade atividade in titulo.Atividades)
{
if (VerificarDeclaratorioSituacao(atividade, eTituloSituacao.Valido, titulo.EmpreendimentoId.GetValueOrDefault(), bancoDeDados))
{
atividade.SituacaoId = (int)eAtividadeSituacao.Regular;
atividadeBus.AlterarSituacao(atividade, bancoDeDados);
}
}
}
}
#endregion
#region Título Suspenso
if (titulo.Situacao.Id == (int)eTituloSituacao.SuspensoDeclaratorio)
{
if (titulo.Atividades != null && titulo.Atividades.Count > 0)
{
foreach (Atividade atividade in titulo.Atividades)
{
if (VerificarDeclaratorioSituacao(atividade, eTituloSituacao.SuspensoDeclaratorio, titulo.EmpreendimentoId.GetValueOrDefault(), bancoDeDados))
{
atividade.SituacaoId = (int)eAtividadeSituacao.Suspensa;
atividadeBus.AlterarSituacao(atividade, bancoDeDados);
}
}
}
}
#endregion
#region Título Encerrado
if (titulo.Situacao.Id == (int)eTituloSituacao.EncerradoDeclaratorio)
{
if (titulo.Atividades != null && titulo.Atividades.Count > 0)
{
foreach (Atividade atividade in titulo.Atividades)
{
if (VerificarDeclaratorioSituacao(atividade, eTituloSituacao.EncerradoDeclaratorio, titulo.EmpreendimentoId.GetValueOrDefault(), bancoDeDados))
{
atividade.SituacaoId = (int)eAtividadeSituacao.Irregular;
atividadeBus.AlterarSituacao(atividade, bancoDeDados);
}
}
}
}
#endregion
#endregion
#region Gerar Pdf de Titulo
ArquivoBus arqBus = new ArquivoBus(eExecutorTipo.Interno);
if (isGerarPdf && titulo.Modelo.Regra(eRegra.PdfGeradoSistema))
{
TituloBus bus = new TituloBus();
titulo.ArquivoPdf.Nome = "Titulo.pdf";
titulo.ArquivoPdf.Extensao = ".pdf";
titulo.ArquivoPdf.ContentType = "application/pdf";
titulo.ArquivoPdf.Buffer = bus.GerarPdf(titulo, bancoDeDados);
if (titulo.ArquivoPdf.Buffer != null)
{
arqBus.Salvar(titulo.ArquivoPdf);
ArquivoDa _arquivoDa = new ArquivoDa();
_arquivoDa.Salvar(titulo.ArquivoPdf, User.FuncionarioId, User.Name,
User.Login, (int)eExecutorTipo.Interno, User.FuncionarioTid, bancoDeDados);
_da.SalvarPdfTitulo(titulo, bancoDeDados);
}
}
#endregion
#region Gerar/Enviar Email
#region Gerar Email
Email email = null;
if (titulo.Situacao.Id == (int)eTituloSituacao.Valido && titulo.Modelo.Regra(eRegra.EnviarEmail))
{
if (titulo.Modelo.Resposta(eRegra.EnviarEmail, eResposta.TextoEmail).Valor != null)
{
string textoEmail = titulo.Modelo.Resposta(eRegra.EnviarEmail, eResposta.TextoEmail).Valor.ToString();
if (!String.IsNullOrWhiteSpace(textoEmail))
{
Dictionary <String, String> emailKeys = new Dictionary <string, string>();
emailKeys.Add("[orgão sigla]", _configSys.Obter <String>(ConfiguracaoSistema.KeyOrgaoSigla));
emailKeys.Add("[data da conclusão]", titulo.Modelo.Regra(eRegra.Prazo) ? titulo.DataInicioPrazo.DataTexto : titulo.DataEmissao.DataTexto);
emailKeys.Add("[nome do modelo]", titulo.Modelo.Nome);
emailKeys.Add("[nome do subtipo]", titulo.Modelo.SubTipo);
emailKeys.Add("[nº do título]", titulo.Numero.Texto);
emailKeys.Add("[nº processo/documento do título]", titulo.Protocolo.Numero);
emailKeys.Add("[nome do empreendimento]", titulo.EmpreendimentoTexto);
foreach (string key in emailKeys.Keys)
{
textoEmail = textoEmail.Replace(key, emailKeys[key]);
}
email = new Email();
email.Assunto = _configSys.Obter <String>(ConfiguracaoSistema.KeyOrgaoSigla);
email.Texto = textoEmail;
email.Tipo = eEmailTipo.TituloConcluir;
email.Codigo = titulo.Id;
}
}
}
#endregion
if (email != null)
{
List <String> lstEmail = _da.ObterEmails(titulo.Id, bancoDeDados);
if (lstEmail != null && lstEmail.Count > 0)
{
email.Destinatario = String.Join(", ", lstEmail.ToArray());
if (titulo.Modelo.Regra(eRegra.AnexarPDFTitulo))
{
email.Anexos.Add(titulo.ArquivoPdf);
}
EmailBus emailBus = new EmailBus();
emailBus.Enviar(email, bancoDeDados);
}
}
#endregion
if (!Validacao.EhValido)
{
bancoDeDados.Rollback();
return;
}
#region Salvar A especificidade
if (EspecificiadadeBusFactory.Possui(titulo.Modelo.Codigo.GetValueOrDefault()))
{
IEspecificidadeBus busEsp = EspecificiadadeBusFactory.Criar(titulo.Modelo.Codigo.GetValueOrDefault());
titulo.Especificidade = busEsp.Obter(titulo.Id) as Especificidade;
titulo.Especificidade = titulo.ToEspecificidade();
busEsp.Salvar(titulo.Especificidade, bancoDeDados);
List <DependenciaLst> lstDependencias = busEsp.ObterDependencias(titulo.Especificidade);
if (isGerarPdf && lstDependencias != null && lstDependencias.Count > 0)
{
if (!lstDependencias.Exists(x => x.TipoId == (int)eTituloDependenciaTipo.Caracterizacao && x.DependenciaTipo == (int)eCaracterizacao.Dominialidade))
{
lstDependencias.Add(new DependenciaLst()
{
TipoId = (int)eTituloDependenciaTipo.Caracterizacao, DependenciaTipo = (int)eCaracterizacao.Dominialidade
});
}
_da.Dependencias(titulo.Id, titulo.Modelo.Id, titulo.EmpreendimentoId.GetValueOrDefault(), lstDependencias);
}
}
#endregion
#region Histórico
_da.Historico.Gerar(titulo.Id, eHistoricoArtefato.titulo, eHistoricoAcao.alterarsituacao, bancoDeDados);
_da.Consulta.Gerar(titulo.Id, eHistoricoArtefato.titulo, bancoDeDados);
#endregion
bancoDeDados.Commit();
Validacao.Add(Mensagem.TituloAlterarSituacao.TituloAltSituacaoSucesso);
}
}