internal bool Salvar(BarragemDispensaLicenca caracterizacao)
{
if (caracterizacao.AtividadeID <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.SelecioneAtividade);
}
if (!caracterizacao.BarragemTipo.HasValue)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.SelecioneTipoBarragem);
}
if (caracterizacao.FinalidadeAtividade <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.SelecioneFinalidade);
}
if (string.IsNullOrWhiteSpace(caracterizacao.CursoHidrico))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeCursoHidrico);
}
if (caracterizacao.VazaoEnchente.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeVazaoInchenteZero);
}
if (caracterizacao.AreaBaciaContribuicao.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeAreaBaciaContribuicaoZero);
}
if (caracterizacao.Precipitacao.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformePrecipitacaoZero);
}
if (caracterizacao.PeriodoRetorno.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformePeriodoRetornoZero);
}
if (string.IsNullOrWhiteSpace(caracterizacao.CoeficienteEscoamento))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeCoeficienteEscoamentoZero);
}
if (string.IsNullOrWhiteSpace(caracterizacao.TempoConcentracao))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeTempoConcentracao);
}
if (string.IsNullOrWhiteSpace(caracterizacao.EquacaoCalculo))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeEquacaoCalculo);
}
if (caracterizacao.AreaAlagada.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeAreaAlagadaZero);
}
if (caracterizacao.VolumeArmazanado.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeVolumeArmazenadoZero);
}
if (caracterizacao.Fase.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeFase);
}
if (caracterizacao.Fase.HasValue)
{
switch (caracterizacao.Fase.GetValueOrDefault())
{
case (int)eFase.Construida:
#region FASE: Construida
if (!caracterizacao.PossuiMonge.HasValue)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformePossuiMonge);
}
else if (Convert.ToBoolean(caracterizacao.PossuiMonge))
{
if (!caracterizacao.MongeTipo.HasValue || caracterizacao.MongeTipo.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeTipoMonge);
}
else if (caracterizacao.MongeTipo.GetValueOrDefault() == (int)eMongeTipo.Outros && string.IsNullOrWhiteSpace(caracterizacao.EspecificacaoMonge))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeEspecificacaoMonge);
}
}
if (!caracterizacao.PossuiVertedouro.HasValue)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformePossuiVertedouro);
}
else if (Convert.ToBoolean(caracterizacao.PossuiVertedouro))
{
if (!caracterizacao.VertedouroTipo.HasValue || caracterizacao.VertedouroTipo <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeTipoVertedouro);
}
else if (caracterizacao.VertedouroTipo == (int)eVertedouroTipo.Outros && string.IsNullOrWhiteSpace(caracterizacao.EspecificacaoVertedouro))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeEspecificacaoVertedouro);
}
}
if ((caracterizacao.PossuiMonge.HasValue && !Convert.ToBoolean(caracterizacao.PossuiMonge)) ||
(caracterizacao.PossuiVertedouro.HasValue && !Convert.ToBoolean(caracterizacao.PossuiVertedouro)))
{
if (!caracterizacao.PossuiEstruturaHidraulica.HasValue)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformePossuiEstruturaHidraulica);
}
}
if ((caracterizacao.PossuiMonge.HasValue && !Convert.ToBoolean(caracterizacao.PossuiMonge)) ||
(caracterizacao.PossuiVertedouro.HasValue && !Convert.ToBoolean(caracterizacao.PossuiVertedouro)) ||
(caracterizacao.PossuiEstruturaHidraulica.HasValue && !Convert.ToBoolean(caracterizacao.PossuiEstruturaHidraulica)))
{
if (string.IsNullOrWhiteSpace(caracterizacao.AdequacoesRealizada))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeAdequacoesRealizada);
}
}
#endregion
break;
case (int)eFase.AConstruir:
#region FASE: A construir
if (!caracterizacao.MongeTipo.HasValue || caracterizacao.MongeTipo.GetValueOrDefault() <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeTipoMonge);
}
else if (caracterizacao.MongeTipo == (int)eMongeTipo.Outros && string.IsNullOrWhiteSpace(caracterizacao.EspecificacaoMonge))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeEspecificacaoMonge);
}
if (!caracterizacao.VertedouroTipo.HasValue || caracterizacao.VertedouroTipo <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeTipoVertedouro);
}
else if (caracterizacao.VertedouroTipo == (int)eVertedouroTipo.Outros && string.IsNullOrWhiteSpace(caracterizacao.EspecificacaoVertedouro))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeEspecificacaoVertedouro);
}
#region datas da obra
DateTime testeDataInicio;
if (string.IsNullOrWhiteSpace(caracterizacao.DataInicioObra))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeDataInicioObra);
}
else
{
if (!DateTime.TryParse(caracterizacao.DataInicioObra, out testeDataInicio))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeDataInicioObraFormatoValido);
}
}
DateTime testeDataTermino;
if (string.IsNullOrWhiteSpace(caracterizacao.DataPrevisaoTerminoObra))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeDataPrevisaoTerminoObra);
}
else
{
if (!DateTime.TryParse(caracterizacao.DataPrevisaoTerminoObra, out testeDataTermino))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeDataPrevisaoTerminoObraFormatoValido);
}
}
if (DateTime.TryParse(caracterizacao.DataInicioObra, out testeDataInicio) && DateTime.TryParse(caracterizacao.DataPrevisaoTerminoObra, out testeDataTermino))
{
if (testeDataInicio > testeDataTermino)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.PeriodoObraValido);
}
}
#endregion
#endregion
break;
}
}
if (string.IsNullOrWhiteSpace(caracterizacao.Coordenada.EastingUtmTexto))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeCoordEasting);
}
if (string.IsNullOrWhiteSpace(caracterizacao.Coordenada.NorthingUtmTexto))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeCoordNorthing);
}
if (caracterizacao.FormacaoRT <= 0)
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeFormacaoRT);
}
if (((Convert.ToInt32(eFormacaoRTCodigo.Outros) & caracterizacao.FormacaoRT) != 0) && string.IsNullOrWhiteSpace(caracterizacao.EspecificacaoRT))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeEspecificacaoRT);
}
if (caracterizacao.Autorizacao == null || string.IsNullOrWhiteSpace(caracterizacao.Autorizacao.Nome))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeArquivo);
}
if (string.IsNullOrWhiteSpace(caracterizacao.NumeroARTElaboracao))
{
Validacao.Add(Mensagem.BarragemDispensaLicenca.InformeNumeroARTElaboracao);
}
return(Validacao.EhValido);
}
public ActionResult Editar(Aquicultura caracterizacao)
{
string textoMerge = _caracterizacaoValidar.DependenciasAlteradas(
caracterizacao.EmpreendimentoId,
(int)eCaracterizacao.Aquicultura,
eCaracterizacaoDependenciaTipo.Caracterizacao,
caracterizacao.Dependencias);
if (!string.IsNullOrEmpty(textoMerge))
{
return(Json(new { @TextoMerge = textoMerge }, JsonRequestBehavior.AllowGet));
}
_bus.Salvar(caracterizacao);
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@UrlRedirecionar = Url.Action("", "Caracterizacao", new { id = caracterizacao.EmpreendimentoId, Msg = Validacao.QueryParam() })
}, JsonRequestBehavior.AllowGet));
}
public UsuarioTransfer ValidarConsulta(UsuarioTransfer usuarioTransfer)
{
UsuarioTransfer usuarioValidacao;
try {
usuarioValidacao = new UsuarioTransfer(usuarioTransfer);
if (usuarioValidacao != null)
{
//-- Id
if ((usuarioValidacao.IdDe <= 0) && (usuarioValidacao.IdAte > 0))
{
usuarioValidacao.IncluirMensagem("Informe apenas o Id (De) para consultar um Id específico, ou os valores De e Até para consultar uma faixa de Id");
}
else if ((usuarioValidacao.IdDe > 0) && (usuarioValidacao.IdAte > 0))
{
if (usuarioValidacao.IdDe >= usuarioValidacao.IdAte)
{
usuarioValidacao.IncluirMensagem("O valor mínimo (De) do Id deve ser menor que o valor máximo (Até)");
}
}
//-- Apelido (Nome de usuário)
if (!string.IsNullOrEmpty(usuarioValidacao.Apelido))
{
if (usuarioValidacao.Apelido.Length > 20)
{
usuarioValidacao.IncluirMensagem("Nome de Usuário deve ter no máximo 20 caracteres");
}
else if (!Validacao.ValidarCharAaN(usuarioValidacao.Apelido))
{
usuarioValidacao.IncluirMensagem("Nome de Usuário possui caracteres inválidos");
usuarioValidacao.IncluirMensagem("Caracteres válidos: letras e números");
}
}
//-- Nome de apresentação
if (!string.IsNullOrEmpty(usuarioValidacao.NomeApresentacao))
{
if (usuarioValidacao.NomeApresentacao.Length > 20)
{
usuarioValidacao.IncluirMensagem("Nome de Apresentacao deve ter no máximo 20 caracteres");
}
else if (!Validacao.ValidarCharAaBN(usuarioValidacao.NomeApresentacao))
{
usuarioValidacao.IncluirMensagem("Nome de Apresentacao possui caracteres inválidos");
usuarioValidacao.IncluirMensagem("Caracteres válidos: letras, números e espaço em branco");
}
}
//-- Nome Completo
if (!string.IsNullOrEmpty(usuarioValidacao.NomeCompleto))
{
if (usuarioValidacao.NomeCompleto.Length > 100)
{
usuarioValidacao.IncluirMensagem("Nome Completo deve ter no máximo 100 caracteres");
}
else if (!Validacao.ValidarCharAaB(usuarioValidacao.NomeCompleto))
{
usuarioValidacao.IncluirMensagem("Nome Completo possui caracteres inválidos");
usuarioValidacao.IncluirMensagem("Caracteres válidos: letras e espaço em branco");
}
}
//-- Data de Criação
if ((usuarioValidacao.CriacaoDe == DateTime.MinValue) && (usuarioValidacao.CriacaoAte != DateTime.MinValue))
{
usuarioValidacao.IncluirMensagem("Informe apenas a Data de Criação (De) para consultar uma data específica, ou os valores De e Até para consultar uma faixa de datas");
}
else if ((usuarioValidacao.CriacaoDe > DateTime.MinValue) && (usuarioValidacao.CriacaoAte > DateTime.MinValue))
{
if (usuarioValidacao.CriacaoDe >= usuarioValidacao.CriacaoAte)
{
usuarioValidacao.IncluirMensagem("O valor mínimo (De) da Data de Criação deve ser menor que o valor máximo (Até)");
}
}
//-- Data de Alteração
if ((usuarioValidacao.AlteracaoDe == DateTime.MinValue) && (usuarioValidacao.AlteracaoAte != DateTime.MinValue))
{
usuarioValidacao.IncluirMensagem("Informe apenas a Data de Alteração (De) para consultar uma data específica, ou os valores De e Até para consultar uma faixa de datas");
}
else if ((usuarioValidacao.AlteracaoDe > DateTime.MinValue) && (usuarioValidacao.AlteracaoAte > DateTime.MinValue))
{
if (usuarioValidacao.AlteracaoDe >= usuarioValidacao.AlteracaoAte)
{
usuarioValidacao.IncluirMensagem("O valor mínimo (De) da Data de Alteração deve ser menor que o valor máximo (Até)");
}
}
}
else
{
usuarioValidacao = new UsuarioTransfer();
usuarioValidacao.IncluirMensagem("É necessário informar os dados do Usuário");
}
usuarioValidacao.Validacao = true;
if (usuarioValidacao.Mensagens != null)
{
if (usuarioValidacao.Mensagens.Count > 0)
{
usuarioValidacao.Validacao = false;
}
}
usuarioValidacao.Erro = false;
} catch (Exception ex) {
usuarioValidacao = new UsuarioTransfer();
usuarioValidacao.IncluirMensagem("Erro em UsuarioBusiness Validar [" + ex.Message + "]");
usuarioValidacao.Validacao = false;
usuarioValidacao.Erro = true;
}
return(usuarioValidacao);
}
internal bool Salvar(IEnumerable <ExploracaoFlorestal> exploracoes)
{
foreach (var caracterizacao in exploracoes)
{
if (!_caracterizacaoValidar.Basicas(caracterizacao.EmpreendimentoId))
{
return(false);
}
if (!Acessar(caracterizacao.EmpreendimentoId))
{
return(false);
}
if (caracterizacao.TipoExploracao <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.ExploracaoTipoObrigatorio);
}
foreach (ExploracaoFlorestalExploracao item in caracterizacao.Exploracoes)
{
if (item.GeometriaTipoId == (int)eExploracaoFlorestalGeometria.Poligono)
{
if (!String.IsNullOrWhiteSpace(item.AreaRequeridaTexto))
{
if (!ValidacoesGenericasBus.ValidarDecimal(DecimalEtx.ClearMask(item.AreaRequeridaTexto), 8, 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 && (item.ParecerFavoravel ?? false))
{
if (Convert.ToInt32(item.QuantidadeArvores) <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.QdeArvoresRequeridasMaiorZero(item.Identificacao));
}
}
}
else
{
Validacao.Add(Mensagem.ExploracaoFlorestal.QdeArvoresRequeridasObrigatoria(item.Identificacao));
}
#endregion
}
}
if (item.FinalidadeExploracao <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.FinalidadeExploracaoObrigatorio);
}
else
{
if (item.FinalidadeExploracao == (int)eExploracaoFlorestalFinalidade.Outros && String.IsNullOrWhiteSpace(item.FinalidadeEspecificar))
{
Validacao.Add(Mensagem.ExploracaoFlorestal.FinalidadeExploracaoEspecificarObrigatorio(item.Identificacao));
}
}
if (item.ClassificacaoVegetacaoId <= 0)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.ClassificacaoVegetacaoObrigatoria(item.Identificacao));
}
if (item.ParecerFavoravel == null)
{
Validacao.Add(Mensagem.ExploracaoFlorestal.ParecerFavoravelObrigatorio(item.Identificacao));
}
if (Convert.ToBoolean(item.ParecerFavoravel))
{
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), 8, 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);
}
internal bool Salvar(EmissaoCFO entidade)
{
//Valida a habilitacao antes do salvar o credenciado.
if (!entidade.TipoNumero.HasValue)
{
Validacao.Add(Mensagem.EmissaoCFO.TipoNumeroObrigatorio);
}
else
{
if (entidade.TipoNumero == (int)eDocumentoFitossanitarioTipoNumero.Bloco)
{
if (!ValidarNumeroBloco(entidade.Numero, entidade.Id))
{
return(false);
}
ValidacoesGenericasBus.DataMensagem(entidade.DataEmissao, "CFO_DataEmissao", "emissão");
}
if (entidade.TipoNumero == (int)eDocumentoFitossanitarioTipoNumero.Digital)
{
//VerificarNumeroDigitalDisponivel foi validado na BUS
if (!_da.NumeroCancelado(entidade.Numero))
{
Validacao.Add(Mensagem.EmissaoCFO.NumeroCancelado);
return(false);
}
}
}
if (!_da.VerificarProdutorAssociado(entidade.ProdutorId))
{
Validacao.Add(Mensagem.EmissaoCFO.ProdutorNaoEstaMaisAssociado);
}
if (!_da.VerificarProdutorAssociadoEmpreendimento(entidade.ProdutorId))
{
Validacao.Add(Mensagem.EmissaoCFO.ProdutorNaoEstaMaisAssociadoEmpreendimento);
}
if (entidade.ProdutorId <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.ProdutorObrigatorio);
}
if (entidade.EmpreendimentoId <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.EmpreendimentoObrigatorio);
}
if (entidade.Produtos.Count <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.ProdutoObrigatorio);
}
else
{
if (entidade.Produtos.Count > 5)
{
Validacao.Add(Mensagem.EmissaoCFO.LimiteMaximo);
}
else
{
entidade.Produtos.ForEach(produto =>
{
ResponsavelTecnico responsavel = _da.ObterResponsavelUC(produto.UnidadeProducao);
if (!string.IsNullOrEmpty(responsavel.DataValidadeART) && DateTime.Parse(responsavel.DataValidadeART) < DateTime.Today)
{
Validacao.Add(Mensagem.EmissaoCFO.DataValidadeARTMenorAtual);
}
ValidarProduto(entidade.Id, entidade.EmpreendimentoId, produto, entidade.Produtos);
});
}
}
if (entidade.Pragas.Count <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.PragaAssociadaCulturaObrigatorio);
}
else
{
entidade.Pragas.ForEach(praga =>
{
ValidarPraga(praga);
});
}
if (!entidade.PossuiLaudoLaboratorial.HasValue)
{
Validacao.Add(Mensagem.EmissaoCFO.PossuiLaudoLaboratorialObrigatorio);
}
else
{
if (entidade.PossuiLaudoLaboratorial.Value)
{
if (string.IsNullOrEmpty(entidade.NomeLaboratorio))
{
Validacao.Add(Mensagem.EmissaoCFO.NomeLaboratorioObrigatorio);
}
if (string.IsNullOrEmpty(entidade.NumeroLaudoResultadoAnalise))
{
Validacao.Add(Mensagem.EmissaoCFO.NumeroLaudoResultadoAnaliseObrigatorio);
}
if (entidade.EstadoId <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.EstadoObrigatorio);
}
if (entidade.MunicipioId <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.MunicipioObrigatorio);
}
}
}
if (entidade.ProdutoEspecificacao <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.ProdutoEspecificacaoObrigatorio);
}
if (!entidade.PossuiTratamentoFinsQuarentenario.HasValue)
{
Validacao.Add(Mensagem.EmissaoCFO.PossuiTratamentoFinsQuarentenarioObrigatorio);
}
else
{
if (entidade.PossuiTratamentoFinsQuarentenario.Value)
{
entidade.TratamentosFitossanitarios.ForEach(tratamento =>
{
ValidarTratamento(tratamento);
});
}
}
if (entidade.PartidaLacradaOrigem && string.IsNullOrEmpty(entidade.NumeroLacre) && string.IsNullOrEmpty(entidade.NumeroPorao) && string.IsNullOrEmpty(entidade.NumeroContainer))
{
Validacao.Add(Mensagem.EmissaoCFO.LacrePoraoConteinerObrigatorio);
}
if (entidade.ValidadeCertificado <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.ValidadeCertificadoObrigatorio);
}
else if (entidade.ValidadeCertificado > 30)
{
Validacao.Add(Mensagem.EmissaoCFO.ValidadeCertificadoMaxima);
}
if (entidade.MunicipioEmissaoId <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.MunicipioEmissaoObrigatorio);
}
return(Validacao.EhValido);
}
public ActionResult ImportarProjetoDigital(int analiseId, int requerimentoId, int protocoloId)
{
int projetoDigitalId = _busProjetoDigitalCredenciado.ObterProjetoDigitalId(requerimentoId);
bool isImportado = _bus.ImportarProjetoDigital(analiseId, projetoDigitalId);
string urlRedireciona = Url.Action("Analisar", "AnaliseItens", new { @protocoloId = protocoloId, @requerimentoId = requerimentoId }) + "&Msg=" + Validacao.QueryParam() + "&acaoId=" + analiseId.ToString();
return(Json(new { @Msg = Validacao.Erros, @IsImportado = true.ToString().ToLower(), @Url = urlRedireciona }, JsonRequestBehavior.AllowGet));
}
public ActionResult CopiarDadosInstitucional(int id, int projetoDigitalID, int caracterizacaoTipo)
{
ProjetoDigitalCredenciadoBus projetoDigitalCredenciadoBus = new ProjetoDigitalCredenciadoBus();
_bus.CopiarDadosInstitucional(id, (eCaracterizacao)caracterizacaoTipo, projetoDigitalID, projetoDigitalCredenciadoBus.AlterarCaracterizacao);
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@UrlRedirecionar = Url.Action("", "Caracterizacao", new { id = id, projetoDigitalId = projetoDigitalID, Msg = Validacao.QueryParam() })
}, JsonRequestBehavior.AllowGet));
}
public bool Salvar(LocalInfracao localInfracao)
{
if (localInfracao.SetorId == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.SelecioneSetor);
}
if (localInfracao.Data.IsEmpty || !localInfracao.Data.IsValido)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.DataFiscalizacaoObrigatoria);
}
else if (localInfracao.Data.Data.GetValueOrDefault() > DateTime.Now)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.DataFiscalizacaoMenorAtual);
}
if (!localInfracao.LonEastingToDecimal.HasValue)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.EastingUtmObrigatorio);
}
if (!localInfracao.LatNorthingToDecimal.HasValue)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.NorthingUtmObrigatorio);
}
if (localInfracao.MunicipioId == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.MunicipioObrigatorio);
}
if (string.IsNullOrWhiteSpace(localInfracao.AreaAbrangencia))
{
Validacao.Add(Mensagem.LocalInfracaoMsg.AreaAbrangenciaObrigatoria);
}
else
{
int areaAbran = 0;
if (!int.TryParse(localInfracao.AreaAbrangencia, out areaAbran))
{
Validacao.Add(Mensagem.LocalInfracaoMsg.AreaAbrangenciaInvalida);
}
else if (areaAbran == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.AreaAbrangenciaMaiorZero);
}
}
if (string.IsNullOrWhiteSpace(localInfracao.Local))
{
Validacao.Add(Mensagem.LocalInfracaoMsg.LocalObrigatorio);
}
if (localInfracao.PessoaId.GetValueOrDefault() == 0 && localInfracao.EmpreendimentoId.GetValueOrDefault() == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.PessoaEmpreendimentoObrigatorio);
}
if (localInfracao.EmpreendimentoId.GetValueOrDefault() > 0 && localInfracao.ResponsavelId.GetValueOrDefault() == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.ResponsavelObrigatorio);
}
if (localInfracao.EmpreendimentoId.GetValueOrDefault() > 0 && localInfracao.ResponsavelPropriedadeId.GetValueOrDefault() == 0)
{
Validacao.Add(Mensagem.LocalInfracaoMsg.ResponsavelPropriedadeObrigatorio);
}
return(Validacao.EhValido);
}
internal bool AlterarSituacao(Titulo titulo, bool validarTitulo)
{
if (titulo.Situacao.Id <= 0)
{
Validacao.Add(Mensagem.Titulo.SituacaoObrigatoria);
}
Titulo tituloAux = _da.ObterSimplificado(titulo.Id);
if (tituloAux == null)
{
return(false);
}
switch ((eTituloSituacao)titulo.Situacao.Id)
{
#region Valido
case eTituloSituacao.Valido:
if (tituloAux.Situacao.Id != (int)eTituloSituacao.EmCadastro && tituloAux.Situacao.Id != (int)eTituloSituacao.Suspenso)
{
Validacao.Add(Mensagem.TituloAlterarSituacao.SituacaoInvalida("Válido", "Em cadastro ou Suspenso"));
}
break;
#endregion
#region Suspenso
case eTituloSituacao.Suspenso:
if (tituloAux.Situacao.Id != (int)eTituloSituacao.Valido)
{
Validacao.Add(Mensagem.TituloAlterarSituacao.SituacaoInvalida("Suspenso", "Válido"));
}
if (string.IsNullOrWhiteSpace(titulo.MotivoSuspensao))
{
Validacao.Add(Mensagem.Titulo.MotivoObrigatorio);
}
break;
#endregion
#region Encerrado
case eTituloSituacao.EncerradoDeclaratorio:
if (tituloAux.Situacao.Id != (int)eTituloSituacao.Valido && tituloAux.Situacao.Id != (int)eTituloSituacao.Suspenso)
{
Validacao.Add(Mensagem.TituloAlterarSituacao.SituacaoInvalida("Encerrado", "Válido ou Suspenso"));
}
if (titulo.MotivoEncerramentoId <= 0)
{
Validacao.Add(Mensagem.Titulo.MotivoEncerramentoObrigatorio);
}
break;
#endregion
}
if (!Validacao.EhValido)
{
return(false);
}
//Validar Titulo
if (validarTitulo)
{
Titulo(titulo);
if (EspecificiadadeBusFactory.Possui(titulo.Modelo.Codigo.Value))
{
IEspecificidadeBus busEsp = EspecificiadadeBusFactory.Criar(titulo.Modelo.Codigo.Value);
titulo.Especificidade = busEsp.Obter(titulo.Id) as Especificidade;
titulo.Especificidade = titulo.ToEspecificidade();
busEsp.Validar.Emitir(titulo.Especificidade);
}
}
else if (titulo.Situacao.Id != (int)eTituloSituacao.EncerradoDeclaratorio)
{
if (titulo.Atividades != null)
{
foreach (var item in titulo.Atividades)
{
if (!item.Ativada)
{
Validacao.Add(Mensagem.AtividadeEspecificidade.AtividadeDesativada(item.NomeAtividade));
}
}
}
}
return(Validacao.EhValido);
}
public ActionResult DesassociarCaracterizacaoProjetoDigital(ProjetoDigital projetoDigital)
{
ProjetoDigitalCredenciadoBus projetoDigitalBus = new ProjetoDigitalCredenciadoBus();
projetoDigitalBus.DesassociarDependencias(projetoDigital);
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@UrlRedirecionar = Url.Action("", "Caracterizacao", new { id = projetoDigital.EmpreendimentoId, projetoDigitalId = projetoDigital.Id, Msg = Validacao.QueryParam() })
}, JsonRequestBehavior.AllowGet));
}
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 ActionResult Criar(int empreendimento, int tipo, bool isCadastrarCaracterizacao)
{
if (!_caracterizacaoValidar.Dependencias(empreendimento, tipo))
{
return(RedirectToAction("", "Caracterizacao", new { id = empreendimento, Msg = Validacao.QueryParam() }));
}
DescricaoLicenciamentoAtividadeVM vm = new DescricaoLicenciamentoAtividadeVM();
DescricaoLicenciamentoAtividade dscLicAtividade = _bus.ObterPorEmpreendimento(empreendimento, (eCaracterizacao)tipo);
dscLicAtividade = _bus.ObterDadosGeo(empreendimento, (eCaracterizacao)tipo, dscLicAtividade);
if (dscLicAtividade.Id == 0)
{
dscLicAtividade.Tipo = tipo;
}
vm.CaracterizacaoTipoTexto = _caracterizacaoBus.ObterCaracterizacoesEmpreendimento(empreendimento).SingleOrDefault(x => (int)x.Tipo == tipo).Nome;
dscLicAtividade.EmpreendimentoId = empreendimento;
vm.DscLicAtividade = dscLicAtividade;
vm.IsCadastrarCaracterizacao = isCadastrarCaracterizacao;
vm.ResponsaveisEmpreendimento = ViewModelHelper.CriarSelectList(_bus.ObterResponsaveis(empreendimento));
vm.FontesAbastecimentoAguaTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvFontesAbastecimentoAguaTipo);
vm.PontosLancamentoEfluenteTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvPontosLancamentoEfluenteTipo);
vm.OutorgaAguaTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvOutorgaAguaTipo);
vm.FontesGeracaoTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvFontesGeracaoTipo);
vm.UnidadeTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvUnidadeTipo);
vm.CombustivelTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvCombustivelTipo);
vm.VegetacaoAreaUtil = _listaBus.DscLicAtvVegetacaoAreaUtil;
vm.Acondicionamento = _listaBus.DscLicAtvAcondicionamento;
vm.Estocagem = _listaBus.DscLicAtvEstocagem;
vm.Tratamento = _listaBus.DscLicAtvTratamento;
vm.DestinoFinal = _listaBus.DscLicAtvDestinoFinal;
if (vm.DscLicAtividade.Id > 0)
{
vm.DscLicAtividade.Dependencias = _caracterizacaoBus.ObterDependencias(vm.DscLicAtividade.Id, vm.DscLicAtividade.GetTipo, eCaracterizacaoDependenciaTipo.DescricaoLicenciamentoAtividade);
vm.TextoMerge = _caracterizacaoValidar.DependenciasAlteradas(
vm.DscLicAtividade.EmpreendimentoId,
vm.DscLicAtividade.Tipo,
eCaracterizacaoDependenciaTipo.DescricaoLicenciamentoAtividade,
vm.DscLicAtividade.Dependencias);
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
}
if (vm.ResponsaveisEmpreendimento != null && vm.ResponsaveisEmpreendimento.Count == 2)
{
vm.DscLicAtividade.RespAtividade = Int32.Parse(vm.ResponsaveisEmpreendimento.First(x => int.Parse(x.Value) > 0).Value);
}
vm.UrlAvancar = CaracterizacaoVM.GerarUrl(empreendimento, isCadastrarCaracterizacao, (eCaracterizacao)tipo);
return(View("Criar", vm));
}
public ActionResult Index(int id, int empreendimento, int tipo, bool isCadastrarCaracterizacao)
{
PermissaoValidar permissaoValidar = new PermissaoValidar();
if (isCadastrarCaracterizacao && permissaoValidar.ValidarAny(new[] { ePermissao.DescricaoLicenciamentoAtividadeCriar }, false))
{
return(Criar(empreendimento, tipo, isCadastrarCaracterizacao));
}
if (!isCadastrarCaracterizacao && permissaoValidar.ValidarAny(new[] { ePermissao.DescricaoLicenciamentoAtividadeEditar }, false))
{
return(Editar(id, empreendimento, tipo, isCadastrarCaracterizacao));
}
if (permissaoValidar.ValidarAny(new[] { ePermissao.DescricaoLicenciamentoAtividadeVisualizar }, false))
{
return(Visualizar(empreendimento, tipo, isCadastrarCaracterizacao));
}
permissaoValidar.ValidarAny(new[] {
ePermissao.DescricaoLicenciamentoAtividadeCriar,
ePermissao.DescricaoLicenciamentoAtividadeEditar,
ePermissao.DescricaoLicenciamentoAtividadeVisualizar
});
return(RedirectToAction("", "Caracterizacao", new { id = empreendimento, Msg = Validacao.QueryParam() }));
}
public ActionResult Visualizar(int empreendimento, int tipo, bool isCadastrarCaracterizacao)
{
if (!_caracterizacaoValidar.Dependencias(empreendimento, tipo))
{
return(RedirectToAction("", "Caracterizacao", new { id = empreendimento, Msg = Validacao.QueryParam() }));
}
DescricaoLicenciamentoAtividadeVM vm = new DescricaoLicenciamentoAtividadeVM();
DescricaoLicenciamentoAtividade dscLicAtividade = _bus.ObterPorEmpreendimento(empreendimento, (eCaracterizacao)tipo);
dscLicAtividade = _bus.ObterDadosGeo(empreendimento, (eCaracterizacao)tipo, dscLicAtividade);
vm.CaracterizacaoTipoTexto = _caracterizacaoBus.ObterCaracterizacoesEmpreendimento(empreendimento).SingleOrDefault(x => (int)x.Tipo == tipo).Nome;
dscLicAtividade.EmpreendimentoId = empreendimento;
vm.DscLicAtividade = dscLicAtividade;
vm.IsCadastrarCaracterizacao = isCadastrarCaracterizacao;
vm.ResponsaveisEmpreendimento = ViewModelHelper.CriarSelectList(_bus.ObterResponsaveis(empreendimento));
vm.FontesAbastecimentoAguaTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvFontesAbastecimentoAguaTipo);
vm.PontosLancamentoEfluenteTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvPontosLancamentoEfluenteTipo);
vm.OutorgaAguaTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvOutorgaAguaTipo);
vm.FontesGeracaoTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvFontesGeracaoTipo);
vm.UnidadeTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvUnidadeTipo);
vm.CombustivelTipo = ViewModelHelper.CriarSelectList(_listaBus.DscLicAtvCombustivelTipo);
vm.VegetacaoAreaUtil = _listaBus.DscLicAtvVegetacaoAreaUtil;
vm.Acondicionamento = _listaBus.DscLicAtvAcondicionamento;
vm.Estocagem = _listaBus.DscLicAtvEstocagem;
vm.Tratamento = _listaBus.DscLicAtvTratamento;
vm.DestinoFinal = _listaBus.DscLicAtvDestinoFinal;
if (vm.DscLicAtividade.Id > 0)
{
vm.DscLicAtividade.Dependencias = _caracterizacaoBus.ObterDependencias(vm.DscLicAtividade.Id, vm.DscLicAtividade.GetTipo, eCaracterizacaoDependenciaTipo.DescricaoLicenciamentoAtividade);
vm.TextoMerge = _caracterizacaoValidar.DependenciasAlteradas(
vm.DscLicAtividade.EmpreendimentoId,
vm.DscLicAtividade.Tipo,
eCaracterizacaoDependenciaTipo.DescricaoLicenciamentoAtividade,
vm.DscLicAtividade.Dependencias, true);
vm.AtualizarDependenciasModalTitulo = Mensagem.Caracterizacao.AtualizarDependenciasModalTitulo.Texto;
}
Boolean podeCriarEditar = new PermissaoValidar().ValidarAny(new[] { ePermissao.DescricaoLicenciamentoAtividadeCriar, ePermissao.DescricaoLicenciamentoAtividadeEditar }, false);
if (!String.IsNullOrWhiteSpace(vm.TextoMerge) && !podeCriarEditar)
{
Validacao.Add(Mensagem.DescricaoLicenciamentoAtividadeMsg.NaoPodeVisualizarComDependenciasAlteradas(vm.CaracterizacaoTipoTexto));
return(RedirectToAction("", "Caracterizacao", new { id = empreendimento, Msg = Validacao.QueryParam() }));
}
vm.UrlAvancar = CaracterizacaoVM.GerarUrl(empreendimento, isCadastrarCaracterizacao, (eCaracterizacao)tipo);
vm.IsVisualizar = true;
return(View("Criar", vm));
}
public ActionResult Index(int id, int projetoDigitalId, bool visualizar = false)
{
ProjetoDigitalCredenciadoBus projetoDigitalCredenciadoBus = new ProjetoDigitalCredenciadoBus();
if (id == 0)
{
if (!visualizar)
{
ProjetoDigital projetoDigital = projetoDigitalCredenciadoBus.AlterarEtapa(projetoDigitalId, eProjetoDigitalEtapa.Envio);
}
return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
}
EmpreendimentoCaracterizacao empreendimento = _bus.ObterEmpreendimentoSimplificado(id);
CaracterizacaoVM vm = new CaracterizacaoVM(empreendimento);
if (empreendimento.InternoID > 0)
{
Empreendimento empreendimentoInterno = new EmpreendimentoInternoBus().ObterSimplificado(empreendimento.InternoID);
if (empreendimento.InternoTID != empreendimentoInterno.Tid)
{
vm.MensagensNotificacoes.Add(Mensagem.Caracterizacao.EmpreendimentoDesatualizado(empreendimentoInterno.Denominador).Texto);
}
}
if (empreendimento.Id == 0)
{
Validacao.Add(Mensagem.Caracterizacao.EmpreendimentoNaoEncontrado);
return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
}
vm.ProjetoDigitalId = projetoDigitalId;
vm.IsVisualizar = visualizar;
List <CaracterizacaoLst> caracterizacoes = _bus.ObterCaracterizacoesPorProjetoDigital(projetoDigitalId);
if (caracterizacoes.All(carac => carac.Permissao == ePermissaoTipo.NaoPermitido))
{
Validacao.Add(Mensagem.Caracterizacao.UsuarioNaoPermitidoParaCaracterizacao);
}
caracterizacoes.RemoveAll(caract => caract.Permissao == ePermissaoTipo.NaoPermitido);
#region Projeto Digital
if (caracterizacoes == null || caracterizacoes.Count <= 0)
{
ProjetoDigital projetoDigital = projetoDigitalCredenciadoBus.AlterarEtapa(projetoDigitalId, eProjetoDigitalEtapa.Envio);
return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
}
ProjetoDigitalCredenciadoValidar projetoDigitalCredenciadoValidar = new ProjetoDigitalCredenciadoValidar();
if (!projetoDigitalCredenciadoValidar.PossuiCaracterizacaoAtividade(caracterizacoes, projetoDigitalId))
{
if (!visualizar)
{
ProjetoDigital projetoDigital = projetoDigitalCredenciadoBus.AlterarEtapa(projetoDigitalId, eProjetoDigitalEtapa.Envio);
}
return(RedirectToAction("Operar", "ProjetoDigital", Validacao.QueryParamSerializer(new { id = projetoDigitalId, area = "" })));
}
else
{
vm.MostrarFinalizar = (projetoDigitalCredenciadoBus.Obter(projetoDigitalId).Etapa == (int)eProjetoDigitalEtapa.Caracterizacao) && !visualizar;
}
#endregion
List <Caracterizacao> caracterizacoesAssociadas = _bus.ObterCaracterizacoesAssociadasProjetoDigital(projetoDigitalId);
List <Caracterizacao> cadastradas = _bus.ObterCaracterizacoesEmpreendimento(id, projetoDigitalId) ?? new List <Caracterizacao>();
List <Caracterizacao> cadastradasInterno = _internoBus.ObterCaracterizacoesAtuais(empreendimento.InternoID, caracterizacoes);
if (cadastradas != null && cadastradas.Count > 0)
{
List <int> desatualizadas = new List <int>();
string msgDesatualizadas = _validar.CaracterizacoesCadastradasDesatualizadas(empreendimento.Id, cadastradas, cadastradasInterno, out desatualizadas);
if (!string.IsNullOrEmpty(msgDesatualizadas))
{
vm.MensagensNotificacoes.Add(msgDesatualizadas);
}
vm.CaracterizacoesPossivelCopiar = _bus.ObterPossivelCopiar(cadastradas);
vm.CaracterizacoesPossivelCopiar.AddRange(desatualizadas.Where(x => !vm.CaracterizacoesPossivelCopiar.Exists(y => y == x)));
}
vm.CaracterizacoesNaoCadastradas = caracterizacoes
.Where(x => !cadastradas.Any(y => y.Id > 0 && (int)y.Tipo == x.Id))
.Select(z => new CaracterizacaoVME()
{
Tipo = (eCaracterizacao)z.Id, Nome = z.Texto
}).ToList();
vm.CaracterizacoesCadastradas = caracterizacoes
.Where(x => cadastradas.Where(y => !caracterizacoesAssociadas.Exists(z => z.Tipo == y.Tipo)).Any(y => y.Id > 0 && (int)y.Tipo == x.Id))
.Select(z => new CaracterizacaoVME()
{
Tipo = (eCaracterizacao)z.Id, Nome = z.Texto
}).ToList();
vm.CaracterizacoesAssociadas = caracterizacoesAssociadas
.Select(z => new CaracterizacaoVME()
{
Tipo = (eCaracterizacao)z.Tipo, Nome = z.Nome
}).ToList();
List <DependenciaLst> dependencias = _bus.CaracterizacaoConfig.Obter <List <DependenciaLst> >(ConfiguracaoCaracterizacao.KeyCaracterizacoesDependencias);
#region Não Cadastradas
vm.CaracterizacoesNaoCadastradas.ForEach(x =>
{
ICaracterizacaoBus caracterizacaoBus = CaracterizacaoBusFactory.Criar(x.Tipo);
if (caracterizacaoBus != null)
{
x.PodeCopiar = cadastradasInterno.Exists(y => y.Tipo == x.Tipo) && caracterizacaoBus.PodeCopiar(empreendimento.InternoID);
}
x.PodeCadastrar = User.IsInRole(String.Format("{0}Criar", x.Tipo.ToString()));
x.ProjetoGeografico = User.IsInRole("ProjetoGeograficoCriar");
x.ProjetoGeoObrigatorio = dependencias.Exists(y =>
y.DependenteTipo == (int)x.Tipo &&
y.DependenciaTipo == (int)x.Tipo &&
y.TipoId == (int)eCaracterizacaoDependenciaTipo.ProjetoGeografico);
x.ProjetoGeograficoId = (cadastradas.FirstOrDefault(y => y.Tipo == x.Tipo) ?? new Caracterizacao()).ProjetoRascunhoId;
if (x.ProjetoGeograficoId <= 0)
{
x.ProjetoGeograficoId = (cadastradas.SingleOrDefault(y => y.Tipo == x.Tipo) ?? new Caracterizacao()).ProjetoId;
}
x.UrlCriar = Url.Action("Criar", x.Tipo.ToString());
});
#endregion
#region Cadastradas
vm.CaracterizacoesCadastradas.ForEach(x =>
{
if (User.IsInRole("ProjetoGeograficoEditar") || User.IsInRole("ProjetoGeograficoVisualizar"))
{
x.ProjetoGeografico = true;
}
x.ProjetoGeograficoVisualizar = visualizar;
x.PodeEditar = User.IsInRole(String.Format("{0}Editar", x.Tipo.ToString()));
x.PodeVisualizar = User.IsInRole(String.Format("{0}Visualizar", x.Tipo.ToString()));
x.PodeExcluir = (User.IsInRole(String.Format("{0}Excluir", x.Tipo.ToString())) && (x.Tipo == eCaracterizacao.UnidadeConsolidacao || x.Tipo == eCaracterizacao.UnidadeProducao));
x.PodeCopiar = cadastradasInterno.Exists(y => y.Tipo == x.Tipo);
x.PodeAssociar = !caracterizacoesAssociadas.Exists(y => y.Tipo == x.Tipo);
x.ProjetoGeograficoId = cadastradas.SingleOrDefault(y => y.Tipo == x.Tipo).ProjetoId;
x.UrlEditar = Url.Action("Editar", x.Tipo.ToString());
x.UrlVisualizar = Url.Action("Visualizar", x.Tipo.ToString());
x.UrlExcluirConfirm = Url.Action("ExcluirConfirm", x.Tipo.ToString());
x.UrlExcluir = Url.Action("Excluir", x.Tipo.ToString());
});
#endregion
#region Associadas
vm.CaracterizacoesAssociadas.ForEach(x =>
{
if (User.IsInRole("ProjetoGeograficoVisualizar"))
{
x.ProjetoGeografico = true;
x.ProjetoGeograficoVisualizar = true;
x.ProjetoGeograficoId = cadastradas.SingleOrDefault(y => y.Tipo == x.Tipo).ProjetoId;
}
x.PodeVisualizar = User.IsInRole(String.Format("{0}Visualizar", x.Tipo.ToString()));
x.UrlVisualizar = Url.Action("Visualizar", x.Tipo.ToString());
});
#endregion
return(View("Caracterizacao", vm));
}
internal bool Salvar(Terraplanagem caracterizacao)
{
if (!_caracterizacaoValidar.Basicas(caracterizacao.EmpreendimentoId))
{
return(false);
}
if (caracterizacao.Id <= 0 && (_da.ObterPorEmpreendimento(caracterizacao.EmpreendimentoId, true) ?? new Terraplanagem()).Id > 0)
{
Validacao.Add(Mensagem.Caracterizacao.EmpreendimentoCaracterizacaoJaCriada);
return(false);
}
if (!Acessar(caracterizacao.EmpreendimentoId))
{
return(false);
}
if (caracterizacao.Atividade <= 0)
{
Validacao.Add(Mensagem.Terraplanagem.AtividadeObrigatoria);
}
_coordenadaValidar.Salvar(caracterizacao.CoordenadaAtividade);
#region Área de terraplanagem
if (!String.IsNullOrWhiteSpace(caracterizacao.Area))
{
decimal aux = 0;
if (!Decimal.TryParse(caracterizacao.Area, out aux))
{
Validacao.Add(Mensagem.Terraplanagem.AreaInvalida);
}
else if (aux <= 0)
{
Validacao.Add(Mensagem.Terraplanagem.AreaMaiorZero);
}
}
else
{
Validacao.Add(Mensagem.Terraplanagem.AreaObrigatoria);
}
#endregion
#region Volume de terra movimentado
if (!String.IsNullOrWhiteSpace(caracterizacao.VolumeMovimentado))
{
decimal aux = 0;
if (!Decimal.TryParse(caracterizacao.VolumeMovimentado, out aux))
{
Validacao.Add(Mensagem.Terraplanagem.VolumeInvalido);
}
else if (aux <= 0)
{
Validacao.Add(Mensagem.Terraplanagem.VolumeMaiorZero);
}
}
#endregion
return(Validacao.EhValido);
}
//[ControleAcesso(Acao = (int)eControleAcessoAcao.visualizar, Artefato = (int)eHistoricoArtefatoCaracterizacao.barragemitem)]
public ActionResult SalvarFinalidades(int idBarragem, int idBarragemGeral, int idEmpreendimento, List <int> idsFinalidades)
{
if (idsFinalidades != null && idsFinalidades.Count > 0)
{
_bus.SalvarEdicaoFinalidades(idBarragem, idBarragemGeral, idsFinalidades);
}
else
{
Validacao.Add(Mensagem.BarragemMsg.SelecioneFinalidade);
}
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@Url = Url.Action("Editar", "Barragem", new { id = idEmpreendimento, Msg = Validacao.QueryParam() })
}, JsonRequestBehavior.AllowGet));
}
public void ValidarProduto(int cfo, int empreendimento, IdentificacaoProduto item, List <IdentificacaoProduto> lista)
{
lista = lista ?? new List <IdentificacaoProduto>();
if (item.UnidadeProducao <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.ProdutoUnidadeProducaoObrigatorio);
return;
}
TituloInternoBus tituloBus = new TituloInternoBus();
Titulo titulo = tituloBus.UnidadeProducaoPossuiAberturaConcluido(item.UnidadeProducao);
if (titulo == null || titulo.Id <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.UPTituloConcluido);
}
if (item.Quantidade <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.ProdutoQuantidadeObrigatorio);
}
ValidacoesGenericasBus.DataMensagem(item.DataInicioColheita, "CFO_Produto_InicioColheita", "início da colheita", false);
ValidacoesGenericasBus.DataMensagem(item.DataFimColheita, "CFO_Produto_FimColheita", "fim da colheita", false);
if (!Validacao.EhValido)
{
return;
}
if (DateTime.Parse(item.DataFimColheita.DataTexto) < DateTime.Parse(item.DataInicioColheita.DataTexto))
{
Validacao.Add(Mensagem.EmissaoCFO.DataFimColheitaNaoPodeSerMenorQueDataInicial);
}
TituloInternoDa tituloInternoDa = new TituloInternoDa();
var dependencia = tituloInternoDa.ObterDependencia(titulo.Id, eCaracterizacao.UnidadeProducao);
UnidadeProducao UnidadeProducao = _da.ObterUnidadeProducao(dependencia.Id, dependencia.DependenciaTid);
UnidadeProducaoItem unidade = UnidadeProducao.UnidadesProducao.FirstOrDefault(x => x.Id == item.UnidadeProducao);
if (unidade == null || unidade.Id <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.UPDessassociada(item.CodigoUP));
}
else
{
if (unidade.TipoProducao == (int)eUnidadeProducaoTipoProducao.MaterialPropagacao)
{
if (string.IsNullOrEmpty(unidade.DataValidadeRenasem) || DateTime.Parse(unidade.DataValidadeRenasem) < DateTime.Today)
{
Validacao.Add(Mensagem.EmissaoCFO.DataValidadeRENASEMMenorAtual(item.CodigoUP));
}
}
eUnidadeProducaoTipoProducao tipoProducao = ValidacoesGenericasBus.ObterTipoProducao(item.UnidadeMedidaId);
DateTime dataSaldo = titulo.DataSituacao.Data.GetValueOrDefault();
if (titulo.DataSituacao.Data.GetValueOrDefault().Year < DateTime.Today.Year)
{
dataSaldo = new DateTime(DateTime.Today.Year - 1, dataSaldo.Month, dataSaldo.Day);
}
decimal totalTela = item.Quantidade + lista.Where(x => !x.Equals(item) && x.CultivarId == item.CultivarId && x.UnidadeMedidaId == item.UnidadeMedidaId).Sum(x => x.Quantidade);
if (unidade.EstimativaProducaoQuantidadeAno < _da.ObterQuantidadeProduto(empreendimento, item.CultivarId, tipoProducao, item.UnidadeProducao, cfo, dataSaldo) + totalTela)
{
Validacao.Add(Mensagem.EmissaoCFO.QuantidadeMensalInvalida(unidade.CodigoUP.ToString()));
}
}
if (lista.Count(x => !x.Equals(item)) >= 5)
{
Validacao.Add(Mensagem.EmissaoCFO.LimiteMaximo);
}
if (lista.Any(x => x.UnidadeProducao == item.UnidadeProducao && !x.Equals(item)))
{
Validacao.Add(Mensagem.EmissaoCFO.UnidadeProducaoJaAdicionado);
}
}
public bool ValidarProduto(PTVOutroProduto item, List <PTVOutroProduto> lista)
{
if (item.OrigemTipo <= 0)
{
Validacao.Add(Mensagem.PTVOutro.TipoOrigemObrigatorio);
}
if (string.IsNullOrEmpty(item.OrigemNumero))
{
Validacao.Add(Mensagem.PTVOutro.OrigemObrigatorio);
item.OrigemNumero = string.Empty;
}
else
{
if (item.OrigemTipo <= 3 && item.OrigemNumero.Length != 10)
{
Validacao.Add(Mensagem.PTVOutro.QuantidadeMaximoCFOCFOC(item.OrigemTipoTexto));
}
if (item.OrigemTipo > 4 && item.OrigemNumero.Length != 20)
{
Validacao.Add(Mensagem.PTVOutro.QuantidadeMaximoCFCFRTF(item.OrigemTipoTexto));
}
}
if (string.IsNullOrEmpty(item.OrigemNumero))
{
Validacao.Add(Mensagem.PTVOutro.OrigemObrigatorio);
}
if (item.Cultura <= 0)
{
Validacao.Add(Mensagem.PTVOutro.CulturaObrigatorio);
}
if (item.Cultivar <= 0)
{
Validacao.Add(Mensagem.PTVOutro.CultivarObrigatorio);
}
if (item.UnidadeMedida <= 0)
{
Validacao.Add(Mensagem.PTVOutro.UnidadeMedidaObrigatorio);
}
if (item.Quantidade <= 0)
{
Validacao.Add(Mensagem.PTVOutro.QuantidadeObrigatorio);
}
if (lista.Count(x => !x.Equals(item)) >= 5)
{
Validacao.Add(Mensagem.PTVOutro.QauntidadeItensUltrapassado);
}
if (Validacao.EhValido && lista.Count > 0)
{
if (lista.Count(x => x.OrigemTipo == item.OrigemTipo && x.OrigemNumero == item.OrigemNumero && item.Cultivar == x.Cultivar && x.UnidadeMedida == item.UnidadeMedida && !x.Equals(item)) > 0)
{
Validacao.Add(Mensagem.PTVOutro.ITemProdutoJaAdicionado(item.OrigemTipoTexto));
}
}
return(Validacao.EhValido);
}
public bool ValidarAssociarResponsavelTecnicoHabilitado(EmissaoCFO entidade)
{
#region Configurar
List <Cultivar> cultivares = new List <Cultivar>();
foreach (var item in entidade.Produtos)
{
cultivares.Add(new Cultivar()
{
CulturaId = item.CulturaId, Id = item.CultivarId
});
}
if (cultivares.Count <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.ProdutoObrigatorio);
return(false);
}
HabilitarEmissaoCFOCFOCBus habilitarEmissaoCFOCFOCBus = new HabilitarEmissaoCFOCFOCBus();
HabilitarEmissaoCFOCFOC habilitacao = new HabilitarEmissaoCFOCFOCBus().ObterPorCredenciado(User.FuncionarioId);
if (Validacao.EhValido)
{
PragaInternoBus pragaBus = new PragaInternoBus();
habilitacao.Pragas.ForEach(x =>
{
x.Praga.Culturas = pragaBus.ObterCulturas(x.Praga.Id);
});
}
else
{
return(false);
}
#endregion
if (habilitacao.Id <= 0)
{
Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoNaoHabilitado);
return(false);
}
if (habilitacao.Situacao == (int)eHabilitacaoCFOCFOCSituacao.Inativo)
{
Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoInativo);
return(false);
}
if (!habilitacao.Pragas.SelectMany(p => p.Praga.Culturas).ToList().Exists(c => cultivares.Exists(x => x.CulturaId == c.Id)))
{
Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoNaoHabilitadoParaCultura);
return(false);
}
if (DateTime.Parse(habilitacao.ValidadeRegistro) < DateTime.Today)
{
Validacao.Add(Mensagem.EmissaoCFO.ValidadeRegistroMenorAtual);
return(false);
}
foreach (var item in entidade.Pragas)
{
if (!habilitacao.Pragas.Exists(y => y.Praga.Id == item.Id))
{
Validacao.Add(Mensagem.EmissaoCFO.PragaNaoAssociadaHabilitacao(item.NomeCientifico, item.NomeComum));
return(false);
}
}
List <string> aux = new List <string>();
foreach (var habPraga in habilitacao.Pragas)
{
foreach (var cultivarItem in habPraga.Praga.Culturas.SelectMany(x => x.LstCultivar))
{
foreach (var item in cultivares)
{
if (cultivarItem.Id == item.Id && DateTime.Parse(habPraga.DataFinalHabilitacao) < DateTime.Today)
{
if (!aux.Any(a => a == cultivarItem.Nome))
{
aux.Add(cultivarItem.Nome);
}
}
}
}
}
if (aux.Count > 0)
{
if ((eDocumentoFitossanitarioTipoNumero)entidade.TipoNumero == eDocumentoFitossanitarioTipoNumero.Bloco)
{
Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoHabilitacaoPragaVencidaBloco(Mensagem.Concatenar(aux)));
}
else
{
Validacao.Add(Mensagem.EmissaoCFO.ResponsavelTecnicoHabilitacaoPragaVencidaDigital(Mensagem.Concatenar(aux)));
}
}
return(Validacao.EhValido);
}
internal bool Salvar(PTVOutro ptv)
{
if (!ValidarSituacao(ptv))
{
return(Validacao.EhValido);
}
if (ptv.Numero <= 0)
{
Validacao.Add(Mensagem.PTVOutro.NumeroPTVObrigatorio);
}
else if (ptv.Numero.ToString().Length != 10)
{
Validacao.Add(Mensagem.PTVOutro.NumeroPTVInvalido);
}
ValidacoesGenericasBus.DataMensagem(ptv.DataEmissao, "DataEmissao", "emissão");
if (ptv.Situacao <= 0)
{
Validacao.Add(Mensagem.PTVOutro.SituacaoObrigatorio);
}
if (string.IsNullOrWhiteSpace(ptv.Interessado))
{
Validacao.Add(Mensagem.PTVOutro.InteressadoObrigatorio);
}
if (string.IsNullOrWhiteSpace(ptv.InteressadoCnpjCpf))
{
Validacao.Add(Mensagem.PTVOutro.InteressadoCnpjCpfObrigatorio);
}
else if ((ptv.InteressadoCnpjCpf.Length == 14 && !ValidacoesGenericasBus.Cpf(ptv.InteressadoCnpjCpf)) || (ptv.InteressadoCnpjCpf.Length == 18 && !ValidacoesGenericasBus.Cnpj(ptv.InteressadoCnpjCpf)))
{
Validacao.Add(Mensagem.PTVOutro.InteressadoCnpjCpfInvalido);
}
if (string.IsNullOrWhiteSpace(ptv.InteressadoEndereco))
{
Validacao.Add(Mensagem.PTVOutro.InteressadoEnderecoObrigatorio);
}
if (ptv.InteressadoEstadoId <= 0)
{
Validacao.Add(Mensagem.PTVOutro.InteressadoEstadoObrigatorio);
}
if (ptv.InteressadoMunicipioId <= 0)
{
Validacao.Add(Mensagem.PTVOutro.InteressadoMunicipioObrigatorio);
}
if (ptv.Produtos.Count <= 0)
{
Validacao.Add(Mensagem.PTVOutro.Identificacao_Produto_Obrigatorio);
}
if (ptv.DestinatarioID <= 0)
{
Validacao.Add(Mensagem.PTVOutro.DestinatarioObrigatorio);
}
if (ptv.Estado <= 0)
{
Validacao.Add(Mensagem.PTVOutro.EstadoObrigatorio);
}
if (ptv.Municipio <= 0)
{
Validacao.Add(Mensagem.PTVOutro.MunicipioObrigatorio);
}
if (ValidacoesGenericasBus.DataMensagem(ptv.ValidoAte, "ValidoAte", "validade", false))
{
if (ptv.ValidoAte.Data < ptv.DataEmissao.Data)
{
Validacao.Add(Mensagem.PTVOutro.DataValidadeMenorDataEmissao);
}
else
{
DateTime data = (DateTime)ptv.ValidoAte.Data;
DateTime dt = DateTime.Today.AddDays(30).Subtract(TimeSpan.FromSeconds(1));
if (data > dt)
{
Validacao.Add(Mensagem.PTVOutro.DataValidadeInvalida);
}
}
}
if (string.IsNullOrWhiteSpace(ptv.RespTecnico))
{
Validacao.Add(Mensagem.PTVOutro.ResponsavelTecnicoObrigatorio);
}
if (string.IsNullOrWhiteSpace(ptv.RespTecnicoNumHab))
{
Validacao.Add(Mensagem.PTVOutro.RespTecnicoNumHabObrigatorio);
}
return(Validacao.EhValido);
}
public bool Salvar(ConfigFiscalizacao configuracao)
{
Mensagem msg = null;
List <string> lstMsg = new List <string>();
if (configuracao.ClassificacaoId == 0)
{
Validacao.Add(Mensagem.FiscalizacaoConfiguracao.ClassificacaoObrigatorio);
}
if (configuracao.TipoId == 0)
{
Validacao.Add(Mensagem.FiscalizacaoConfiguracao.TipoObrigatorio);
}
else if (!_da.TipoIsAtivo(configuracao.TipoId))
{
msg = Mensagem.FiscalizacaoConfiguracao.ItemDesativado("Tipo de infração", configuracao.TipoTexto);
msg.Campo = "Configuracao_Tipo";
Validacao.Add(msg);
}
if (configuracao.ItemId == 0)
{
Validacao.Add(Mensagem.FiscalizacaoConfiguracao.ItemObrigatorio);
}
else if (!_da.ItemIsAtivo(configuracao.ItemId))
{
msg = Mensagem.FiscalizacaoConfiguracao.ItemDesativado("Item", configuracao.ItemTexto);
msg.Campo = "Configuracao_Item";
Validacao.Add(msg);
}
if (configuracao.Id == 0)
{
var config = _da.Obter(configuracao.ClassificacaoId, configuracao.TipoId, configuracao.ItemId);
if (config.GetValue <int>("Id") > 0)
{
Validacao.Add(Mensagem.FiscalizacaoConfiguracao.ConfiguracaoCadastrada);
}
}
configuracao.Subitens.ForEach(x =>
{
if (!_da.SubitemIsAtivo(x.SubItemId))
{
lstMsg.Add(x.SubItemTexto);
}
});
if (lstMsg.Count == 1)
{
msg = Mensagem.FiscalizacaoConfiguracao.ItemDesativado("Subitem", lstMsg[0]);
msg.Campo = "fsSubitens";
Validacao.Add(msg);
}
else if (lstMsg.Count > 1)
{
msg = Mensagem.FiscalizacaoConfiguracao.ItemDesativado("Subitens", Mensagem.Concatenar(lstMsg), true);
msg.Campo = "fsSubitens";
Validacao.Add(msg);
}
lstMsg = new List <string>();
configuracao.Perguntas.ForEach(x =>
{
if (!_da.PerguntaIsAtivo(x.PerguntaId))
{
lstMsg.Add(x.PerguntaTexto);
}
});
if (lstMsg.Count == 1)
{
msg = Mensagem.FiscalizacaoConfiguracao.ItemDesativado("Pergunta", lstMsg[0]);
msg.Campo = "fsPerguntas";
Validacao.Add(msg);
}
else if (lstMsg.Count > 1)
{
msg = Mensagem.FiscalizacaoConfiguracao.ItemDesativado("Perguntas", Mensagem.Concatenar(lstMsg), true);
msg.Campo = "fsPerguntas";
Validacao.Add(msg);
}
lstMsg = new List <string>();
configuracao.Campos.ForEach(x =>
{
if (!_da.CampoIsAtivo(x.CampoId))
{
lstMsg.Add(x.CampoTexto);
}
});
if (lstMsg.Count == 1)
{
msg = Mensagem.FiscalizacaoConfiguracao.ItemDesativado("Campo", lstMsg[0]);
msg.Campo = "fsCampos";
Validacao.Add(msg);
}
else if (lstMsg.Count > 1)
{
msg = Mensagem.FiscalizacaoConfiguracao.ItemDesativado("Campos", Mensagem.Concatenar(lstMsg), true);
msg.Campo = "fsCampos";
Validacao.Add(msg);
}
return(Validacao.EhValido);
}
public ActionResult NotificacaoCriar(Notificacao notificacao)
{
_bus.Salvar(notificacao);
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@UrlRedirecionar = Url.Action("NotificacaoVisualizar", "FiscalizacaoNotificacao", new { id = notificacao.FiscalizacaoId, Msg = Validacao.QueryParam(new List <Mensagem>()
{
Mensagem.NotificacaoMsg.Salvar
}) })
}, JsonRequestBehavior.AllowGet));
}
public UsuarioTransfer Validar(UsuarioTransfer usuarioTransfer)
{
UsuarioTransfer usuarioValidacao;
try {
usuarioValidacao = new UsuarioTransfer(usuarioTransfer);
//-- Apelido (Nome de usuário)
if (string.IsNullOrEmpty(usuarioValidacao.Usuario.Apelido))
{
usuarioValidacao.IncluirMensagem("Necessário informar o Nome de Usuário");
}
else if ((usuarioValidacao.Usuario.Apelido.Length < 3) ||
(usuarioValidacao.Usuario.Apelido.Length > 20))
{
usuarioValidacao.IncluirMensagem("Nome de Usuário deve ter entre 3 e 20 caracteres");
}
else if (!Validacao.ValidarCharAaN(usuarioValidacao.Usuario.Apelido))
{
usuarioValidacao.IncluirMensagem("Nome de Usuário possui caracteres inválidos");
usuarioValidacao.IncluirMensagem("Caracteres válidos: letras e números");
}
//-- Senha
if (usuarioValidacao.TipoAcao != "Alteracao")
{
if (string.IsNullOrEmpty(usuarioValidacao.Usuario.Senha))
{
usuarioValidacao.IncluirMensagem("Necessário informar a Senha");
}
else if ((usuarioValidacao.Usuario.Senha.Length < 5) ||
(usuarioValidacao.Usuario.Senha.Length > 20))
{
usuarioValidacao.IncluirMensagem("Senha deve ter entre 5 e 20 caracteres");
}
else if (!Validacao.ValidarCharAaBEN(usuarioValidacao.Usuario.Senha))
{
usuarioValidacao.IncluirMensagem("Senha possui caracteres inválidos");
usuarioValidacao.IncluirMensagem("Caracteres válidos: letras, números, espaço em branco e especiais");
}
else if (!Validacao.ValidarBrancoIniFim(usuarioValidacao.Usuario.Senha))
{
usuarioValidacao.IncluirMensagem("Senha não deve começar ou terminar com espaço em branco");
}
}
//-- Nome de apresentação
if (!string.IsNullOrEmpty(usuarioValidacao.Usuario.NomeApresentacao))
{
if ((usuarioValidacao.Usuario.NomeApresentacao.Length < 3) ||
(usuarioValidacao.Usuario.NomeApresentacao.Length > 20))
{
usuarioValidacao.IncluirMensagem("Nome de Apresentação deve ter entre 3 e 20 caracteres");
}
else if (!Validacao.ValidarCharAaBN(usuarioValidacao.Usuario.NomeApresentacao))
{
usuarioValidacao.IncluirMensagem("Nome de Apresentação possui caracteres inválidos");
usuarioValidacao.IncluirMensagem("Caracteres válidos: letras, números e espaço em branco");
}
else if (!Validacao.ValidarBrancoIniFim(usuarioValidacao.Usuario.NomeApresentacao))
{
usuarioValidacao.IncluirMensagem("Nome de Apresentação não deve começar ou terminar com espaço em branco");
}
}
//-- Nome Completo
if (!string.IsNullOrEmpty(usuarioValidacao.Usuario.NomeCompleto))
{
if ((usuarioValidacao.Usuario.NomeCompleto.Length < 3) ||
(usuarioValidacao.Usuario.NomeCompleto.Length > 100))
{
usuarioValidacao.IncluirMensagem("Nome Completo deve ter entre 3 e 100 caracteres");
}
else if (!Validacao.ValidarCharAaB(usuarioValidacao.Usuario.NomeCompleto))
{
usuarioValidacao.IncluirMensagem("Nome Completo possui caracteres inválidos");
usuarioValidacao.IncluirMensagem("Caracteres válidos: letras e espaço em branco");
}
else if (!Validacao.ValidarBrancoIniFim(usuarioValidacao.Usuario.NomeCompleto))
{
usuarioValidacao.IncluirMensagem("Nome Completo não deve começar ou terminar com espaço em branco");
}
}
usuarioValidacao.Validacao = true;
if (usuarioValidacao.Mensagens != null)
{
if (usuarioValidacao.Mensagens.Count > 0)
{
usuarioValidacao.Validacao = false;
}
}
usuarioValidacao.Erro = false;
} catch (Exception ex) {
usuarioValidacao = new UsuarioTransfer();
usuarioValidacao.IncluirMensagem("Erro em UsuarioBusiness Validar [" + ex.Message + "]");
usuarioValidacao.Validacao = false;
usuarioValidacao.Erro = true;
}
return(usuarioValidacao);
}
public Resultados <Cred.ListarFiltro> Filtrar(Filtro <Cred.ListarFiltro> filtros)
{
Resultados <Cred.ListarFiltro> retorno = new Resultados <Cred.ListarFiltro>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
string credenciado = String.IsNullOrEmpty(UsuarioCredenciado) ? "" : UsuarioCredenciado + ".";
string comandtxt = string.Empty;
Comando comando = bancoDeDados.CriarComando("");
#region Adicionando Filtros
comandtxt += comando.FiltroAndLike("nvl(tp.nome, tp.razao_social)", "nome", filtros.Dados.NomeRazaoSocial, true, true);
if (!string.IsNullOrWhiteSpace(filtros.Dados.CpfCnpj))
{
if (ValidacoesGenericasBus.Cpf(filtros.Dados.CpfCnpj) || ValidacoesGenericasBus.Cnpj(filtros.Dados.CpfCnpj))
{
comandtxt += " and ((tp.cpf = :cpfcnpj) or (tp.cnpj = :cpfcnpj))";
}
else
{
comandtxt += " and ((tp.cpf like '%'|| :cpfcnpj ||'%') or (tp.cnpj = '%'|| :cpfcnpj ||'%'))";
}
comando.AdicionarParametroEntrada("cpfcnpj", filtros.Dados.CpfCnpj, DbType.String);
}
comandtxt += comando.FiltroAnd("cc.numero_habilitacao", "numero_habilitacao", filtros.Dados.NumeroHabilitacao);
if (!string.IsNullOrWhiteSpace(filtros.Dados.NomeComumPraga))
{
comandtxt += " and cc.id in (select ca.habilitar_emi_id from tab_hab_emi_cfo_cfoc_praga ca, tab_praga pa where ca.praga = pa.id and lower(pa.nome_cientifico) like '%'|| :praga ||'%')";
comando.AdicionarParametroEntrada("praga", filtros.Dados.NomeComumPraga.ToLower(), DbType.String);
}
if (!string.IsNullOrWhiteSpace(filtros.Dados.NomeCultura))
{
comandtxt += @" and cc.id in ( select aa.habilitar_emi_id from tab_hab_emi_cfo_cfoc_praga aa, tab_praga_cultura bb, tab_cultura c where aa.praga = bb.praga and c.id = bb.cultura
and lower(c.texto) like '%'|| :cultura ||'%' )" ;
comando.AdicionarParametroEntrada("cultura", filtros.Dados.NomeCultura.ToLower(), DbType.String);
}
List <String> ordenar = new List <String>();
List <String> colunas = new List <String>()
{
"nome", "numero_habilitacao", "situacao_texto"
};
if (filtros.OdenarPor > 0)
{
ordenar.Add(colunas.ElementAtOrDefault(filtros.OdenarPor - 1));
}
else
{
ordenar.Add("nome");
}
#endregion
#region Executa a pesquisa nas tabelas
comando.DbCommand.CommandText = String.Format(@"select count(*) from tab_credenciado tc, cre_pessoa tp,
{0}lov_credenciado_tipo lct, {0}lov_credenciado_situacao lcs, tab_hab_emi_cfo_cfoc cc where tc.pessoa = tp.id
and tc.tipo = lct.id and tc.situacao = lcs.id and cc.responsavel = tc.id" + comandtxt, credenciado);
retorno.Quantidade = Convert.ToInt32(bancoDeDados.ExecutarScalar(comando));
if (retorno.Quantidade < 1)
{
Validacao.Add(Mensagem.Funcionario.NaoEncontrouRegistros);
}
comando.AdicionarParametroEntrada("menor", filtros.Menor);
comando.AdicionarParametroEntrada("maior", filtros.Maior);
comandtxt = String.Format(@"select cc.id, tc.tid, 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, cc.numero_habilitacao from tab_credenciado tc, cre_pessoa tp,
{2}lov_credenciado_tipo lct, lov_hab_emissao_cfo_situacao lcs, tab_hab_emi_cfo_cfoc cc where tc.pessoa = tp.id and tc.tipo = lct.id and cc.situacao = lcs.id
and cc.responsavel = tc.id {0} {1}" , comandtxt, DaHelper.Ordenar(colunas, ordenar), credenciado);
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
Cred.ListarFiltro item;
while (reader.Read())
{
item = new Cred.ListarFiltro();
item.Id = reader.GetValue <String>("id");
item.Tid = reader.GetValue <String>("tid");
item.NomeRazaoSocial = reader.GetValue <String>("nome");
item.CpfCnpj = reader.GetValue <String>("cpfcnpj");
item.DataAtivacao = reader.GetValue <String>("ativacao");
item.Situacao = reader.GetValue <Int32>("situacao");
item.SituacaoTexto = reader.GetValue <String>("situacao_texto");
item.TipoTexto = reader.GetValue <String>("tipo");
item.NumeroHabilitacao = reader.GetValue <String>("numero_habilitacao");
retorno.Itens.Add(item);
}
reader.Close();
#endregion
}
}
return(retorno);
}
public ActionResult Editar(RegistroAtividadeFlorestal caracterizacao)
{
_bus.Salvar(caracterizacao);
return(Json(new
{
@EhValido = Validacao.EhValido,
@Msg = Validacao.Erros,
@UrlRedirecionar = Url.Action("", "Caracterizacao", new { id = caracterizacao.EmpreendimentoId, Msg = Validacao.QueryParam() })
}, JsonRequestBehavior.AllowGet));
}
public bool Salvar(TituloModelo tituloModelo)
{
TituloModeloResposta resposta = null;
if (tituloModelo.Tipo < 1)
{
Validacao.Add(Mensagem.TituloModelo.TipoObrigatorio);
}
if (string.IsNullOrWhiteSpace(tituloModelo.Nome))
{
Validacao.Add(Mensagem.TituloModelo.NomeObrigatorio);
}
if (string.IsNullOrWhiteSpace(tituloModelo.Sigla))
{
Validacao.Add(Mensagem.TituloModelo.SiglaObrigatorio);
}
if (tituloModelo.TipoProtocolo < 1)
{
Validacao.Add(Mensagem.TituloModelo.TipoProtocoloObrigatorio);
}
else
{
if (tituloModelo.TipoDocumentoEnum == eTituloModeloTipoDocumento.TituloDeclaratorio && tituloModelo.TipoProtocolo != 4) //Nao possui
{
Validacao.Add(Mensagem.TituloModelo.DeclaratorioTipoProtocolo);
}
}
if (tituloModelo.Setores.Count < 1)
{
Validacao.Add(Mensagem.TituloModelo.SetoresObrigatorio);
}
if (tituloModelo.Regra(eRegra.PdfGeradoSistema))
{
if (tituloModelo.Arquivo == null || tituloModelo.Arquivo.Id == null)
{
Validacao.Add(Mensagem.TituloModelo.ArquivoObrigatorio);
}
}
if (tituloModelo.Regra(eRegra.Prazo))
{
resposta = tituloModelo.Resposta(eRegra.Prazo, eResposta.InicioPrazo);
if (resposta == null || resposta.Valor == null || Convert.ToInt32(resposta.Valor) < 1)
{
Validacao.Add(Mensagem.TituloModelo.InicioPrazoObrigatorio);
}
resposta = tituloModelo.Resposta(eRegra.Prazo, eResposta.TipoPrazo);
if (resposta == null || resposta.Valor == null || Convert.ToInt32(resposta.Valor) < 1)
{
Validacao.Add(Mensagem.TituloModelo.TipoPrazoObrigatorio);
}
}
if (tituloModelo.Regra(eRegra.EnviarEmail))
{
resposta = tituloModelo.Resposta(eRegra.EnviarEmail, eResposta.TextoEmail);
if (resposta == null || resposta.Valor == null || string.IsNullOrWhiteSpace(resposta.Valor.ToString()))
{
Validacao.Add(Mensagem.TituloModelo.TextoEmailObrigatorio);
}
else
{
if (resposta.Valor.ToString().Length > 500)
{
Validacao.Add(Mensagem.TituloModelo.TextoEmailTamanhoMaximo);
}
}
}
if (tituloModelo.Regra(eRegra.FaseAnterior))
{
List <TituloModeloResposta> respostas = tituloModelo.Respostas(eRegra.FaseAnterior, eResposta.Modelo);
if (respostas.Count < 1)
{
Validacao.Add(Mensagem.TituloModelo.ModeloAnteriorObrigatorio);
}
else
{
respostas.ForEach(x =>
{
int count = 0;
respostas.ForEach(y => { if (x.Valor.ToString() == y.Valor.ToString())
{
count++;
}
});
if (count > 1)
{
Validacao.Add(Mensagem.TituloModelo.ModeloAnteriorDuplicado);
}
});
}
}
return(Validacao.EhValido);
}
public Resultados <AtividadeListarFiltro> Filtrar(Filtro <AtividadeListarFiltro> filtros, BancoDeDados banco = null)
{
Resultados <AtividadeListarFiltro> retorno = new Resultados <AtividadeListarFiltro>();
using (BancoDeDados bancoDeDados = BancoDeDados.ObterInstancia())
{
string comandtxt = string.Empty;
Comando comando = bancoDeDados.CriarComando("");
#region Adicionando Filtros
if (!string.IsNullOrWhiteSpace(filtros.Dados.AtividadeNome))
{
comandtxt += " and lower(trim(ta.atividade)) like '%'||:atividade||'%' ";
comando.AdicionarParametroEntrada("atividade", filtros.Dados.AtividadeNome.ToLower().Trim(), DbType.String);
}
if (filtros.Dados.SetorId > 0)
{
comandtxt += " and ts.id = :setor ";
comando.AdicionarParametroEntrada("setor", filtros.Dados.SetorId, DbType.Int32);
}
if (filtros.Dados.AgrupadorId > 0)
{
comandtxt += " and ta.agrupador = :agrupador ";
comando.AdicionarParametroEntrada("agrupador", filtros.Dados.AgrupadorId, DbType.Int32);
}
if (filtros.Dados.ExibirCredenciado.HasValue)
{
comandtxt += " and ta.exibir_credenciado = :exibir_credenciado";
comando.AdicionarParametroEntrada("exibir_credenciado", Convert.ToInt32(filtros.Dados.ExibirCredenciado.Value), DbType.Int32);
}
List <String> ordenar = new List <String>();
List <String> colunas = new List <String>()
{
"setor_texto", "atividade", "agrupador_texto"
};
if (filtros.OdenarPor > 0)
{
ordenar.Add(colunas.ElementAtOrDefault(filtros.OdenarPor - 1));
}
else
{
ordenar.Add("setor_texto");
}
#endregion
#region Executa a pesquisa nas tabelas
comando.DbCommand.CommandText = String.Format(@"select count(*) from {0}tab_atividade ta, {0}tab_setor ts where ta.situacao=1 and ta.setor = ts.id " + comandtxt, (string.IsNullOrEmpty(EsquemaBanco) ? "" : "."));
retorno.Quantidade = Convert.ToInt32(bancoDeDados.ExecutarScalar(comando));
if (retorno.Quantidade < 1)
{
Validacao.Add(Mensagem.Processo.NaoEncontrouRegistros);
}
comando.AdicionarParametroEntrada("menor", filtros.Menor);
comando.AdicionarParametroEntrada("maior", filtros.Maior);
comandtxt = String.Format(@"select ta.id, ta.atividade, ta.setor setor_id, ts.sigla setor_sigla, ts.nome setor_texto, taa.nome agrupador_texto
from {2}tab_atividade ta, {2}tab_setor ts, {2}tab_atividade_agrupador taa where ta.situacao=1 and ta.agrupador = taa.id and ta.setor = ts.id {0} {1}" ,
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))
{
AtividadeListarFiltro atividade;
while (reader.Read())
{
atividade = new AtividadeListarFiltro();
atividade.Id = Convert.ToInt32(reader["id"]);
atividade.AtividadeNome = reader["atividade"].ToString();
atividade.SetorId = Convert.ToInt32(reader["setor_id"]);
atividade.SetorTexto = reader["setor_texto"].ToString();
atividade.SetorSigla = reader["setor_sigla"].ToString();
atividade.AgrupadorTexto = reader["agrupador_texto"].ToString();
retorno.Itens.Add(atividade);
}
reader.Close();
}
}
return(retorno);
}
public ActionResult Criar(Profissao profissao)
{
if (!_bus.Salvar(profissao))
{
return(Json(new { EhValido = Validacao.EhValido, Msg = Validacao.Erros }));
}
return(Json(new
{
EhValido = Validacao.EhValido,
Msg = Validacao.Erros,
UrlRedirecionar = Url.Action("Criar", "Profissao", new { acaoId = profissao.Id, Msg = Validacao.QueryParam() })
}, JsonRequestBehavior.AllowGet));
}
public ActionResult Excluir(int id)
{
string urlRedireciona = string.Empty;
if (_bus.Excluir(id))
{
urlRedireciona = Url.Action("Index", "Caracterizacao", new { id = id, Msg = Validacao.QueryParam() });
}
return(Json(new { @EhValido = Validacao.EhValido, @Msg = Validacao.Erros, urlRedireciona = urlRedireciona }, JsonRequestBehavior.AllowGet));
}
public void IncluirErro(Validacao erro)
{
if (this.Erros.All(ent => ent.Campo != erro.Campo))
Erros.Add(erro);
}
