public PoderModeloNegocio Pesquisar(int id)
{
Poder poder = repositorioPoderes.Where(p => p.Id == id).SingleOrDefault();
validacao.NaoEncontrado(poder);
return(Mapper.Map <Poder, PoderModeloNegocio>(poder));
}
private void NumeroDigitosValido(ContatoModeloNegocio contato)
{
TipoContato tipoContato = repositorioTiposContato.Where(t => t.Id == contato.TipoContato.Id).Single();
if (contato.Telefone.Length != tipoContato.QuantidadeDigitos)
{
throw new OrganogramaRequisicaoInvalidaException("Telefone do tipo " + tipoContato.Descricao + " devem possuir " + tipoContato.QuantidadeDigitos + " dígitos.");
}
}
internal void DescricaoExistente(PoderModeloNegocio poder)
{
//O registro a ser alterado deve ser desconsiderado na validação de duplicidade (quando for inserção, a id é 0. Então a segunda condição é sempre verdadeira)
Poder poderDominio = repositorioPoderes.Where(p => p.Descricao.ToUpper().Equals(poder.Descricao.ToUpper())).Where(p => p.Id != poder.Id).SingleOrDefault();
if (poderDominio != null)
{
throw new OrganogramaRequisicaoInvalidaException("Já existe um poder com esta descrição.");
}
}
public Guid Search(string sigla)
{
OrganizacaoModeloNegocio organizacaoNegocio = new OrganizacaoModeloNegocio();
Guid guid = _repositorioOrganizacoes.Where(o => o.Sigla.Trim().ToUpper().Equals(sigla.Trim().ToUpper()))
.Select(o => o.IdentificadorExterno.Guid)
.SingleOrDefault();
_validacao.NaoEncontrado(guid);
return(guid);
}
internal void PossuiFilho(int id)
{
if (repositorioOrganizacoes.Where(o => o.IdOrganizacaoPai == id).ToList().Count > 0)
{
throw new OrganogramaRequisicaoInvalidaException("Organização possui organizações filhas.");
}
}
internal void Existe(EsferaOrganizacaoModeloNegocio esfera)
{
if (repositorioEsferasOrganizacoes.Where(e => e.Id == esfera.Id).SingleOrDefault() == null)
{
throw new OrganogramaNaoEncontradoException("Esfera de organização não existe");
}
}
internal void NaoEncontrado(ContatoModeloNegocio contato)
{
if (repositorioContatos.Where(c => c.Id == contato.Id).SingleOrDefault() == null)
{
throw new OrganogramaNaoEncontradoException("Contato não encontrado");
}
}
internal void CodigoIbgeExistente(MunicipioModeloNegocio municipio)
{
var resultado = repositorioMunicipios.Where(m => m.CodigoIbge == municipio.CodigoIbge);
if (!string.IsNullOrWhiteSpace(municipio.Guid))
{
Guid gMunicipio = new Guid(municipio.Guid);
resultado = resultado.Where(m => !m.IdentificadorExterno.Guid.Equals(gMunicipio));
}
var mun = resultado.SingleOrDefault();
if (mun != null)
{
throw new OrganogramaRequisicaoInvalidaException("Já existe um município cadastrado com código IBGE informado.");
}
}
internal void CnpjExiste(OrganizacaoModeloNegocio organizacaoNegocio)
{
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.Cnpj == organizacaoNegocio.Cnpj && o.Id != organizacaoNegocio.Id).SingleOrDefault();
if (organizacao != null)
{
throw new OrganogramaRequisicaoInvalidaException("O Cnpj informado já pertence a uma organização.");
}
}
internal void Existe(TipoOrganizacaoModeloNegocio tipoOrganizacao)
{
if (tipoOrganizacao != null)
{
if (repositorioTiposOrganizacoes.Where(e => e.Id == tipoOrganizacao.Id).SingleOrDefault() == null)
{
throw new OrganogramaNaoEncontradoException("Tipo da organização não existe");
}
}
}
internal void Existe(TipoUnidadeModeloNegocio tipoUnidade)
{
var tUnidade = repositorioTiposUnidades.Where(tu => tu.Id == tipoUnidade.Id)
.SingleOrDefault();
if (tUnidade == null)
{
throw new OrganogramaNaoEncontradoException("Tipo de unidade não encontrado.");
}
}
public MunicipioModeloNegocio Pesquisar(string guid)
{
validacao.GuidValido(guid);
Municipio municipioDominio = new Municipio();
MunicipioModeloNegocio municipioNegocio = new MunicipioModeloNegocio();
Guid gMunicipio = new Guid(guid);
municipioDominio = repositorioMunicipios.Where(m => m.IdentificadorExterno.Guid.Equals(gMunicipio))
.Include(m => m.IdentificadorExterno)
.SingleOrDefault();
validacao.MunicipioNaoExistente(municipioDominio);
municipioNegocio = Mapper.Map <Municipio, MunicipioModeloNegocio>(municipioDominio);
return(municipioNegocio);
}
public OrganizacaoModeloNegocio PesquisarOrganograma(string guid, bool filhas)
{
Guid g = new Guid(guid);
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.IdentificadorExterno.Guid.Equals(g))
.Include(o => o.Esfera)
.Include(o => o.Poder)
.Include(o => o.IdentificadorExterno)
.SingleOrDefault();
validacao.NaoEncontrado(organizacao);
OrganizacaoModeloNegocio omn = Mapper.Map <Organizacao, OrganizacaoModeloNegocio>(organizacao);
if (filhas)
{
var organizacoes = repositorioOrganizacoes.Where(o => o.Id != organizacao.Id)
.Include(o => o.Esfera)
.Include(o => o.Poder)
.Include(o => o.IdentificadorExterno)
.OrderBy(o => o.RazaoSocial)
.ToList();
List <OrganizacaoModeloNegocio> omns = Mapper.Map <List <Organizacao>, List <OrganizacaoModeloNegocio> >(organizacoes);
MontarOrganograma(omn, omns);
}
List <int> idsOrganizacoes = IdsOrganizacoesOrganograma(omn);
var unidades = repositorioUnidades.Where(u => idsOrganizacoes.Contains(u.IdOrganizacao))
.Include(o => o.Organizacao)
.Include(o => o.UnidadePai)
.Include(o => o.IdentificadorExterno)
.OrderBy(u => u.Nome)
.ToList();
List <UnidadeModeloNegocio> umns = Mapper.Map <List <Unidade>, List <UnidadeModeloNegocio> >(unidades);
MontarOrganograma(omn, umns);
return(omn);
}
internal void PossuiFilho(int id)
{
var unidadesFilhas = repositorioUnidades.Where(u => u.IdUnidadePai == id)
.ToList();
if (unidadesFilhas != null && unidadesFilhas.Count > 0)
{
throw new OrganogramaRequisicaoInvalidaException("A unidade possui unidades filhas.");
}
}
public void Alterar(int id, TipoOrganizacaoModeloNegocio tipoOrganizacao)
{
validacao.TipoOrganizacaoValido(tipoOrganizacao);
validacao.IdValido(id);
validacao.IdValido(tipoOrganizacao.Id);
validacao.IdAlteracaoValido(id, tipoOrganizacao);
validacao.IdExistente(id);
validacao.DescricaoValida(tipoOrganizacao.Descricao);
validacao.DescricaoExistente(tipoOrganizacao.Descricao);
TipoOrganizacao td = repositorioTiposOrganizacoes.Where(t => t.Id == tipoOrganizacao.Id).Single();
td.Descricao = tipoOrganizacao.Descricao;
unitOfWork.Save();
}
public void Alterar(int id, EsferaOrganizacaoModeloNegocio esferaOrganizacao)
{
validacao.EsferaOrganizacaoValido(esferaOrganizacao);
validacao.IdValido(id);
validacao.IdValido(esferaOrganizacao.Id);
validacao.IdAlteracaoValido(id, esferaOrganizacao);
validacao.DescricaoValida(esferaOrganizacao.Descricao);
validacao.DescricaoExistente(esferaOrganizacao.Descricao);
EsferaOrganizacao eo = repositorioEsferasOrganizacoes.Where(e => e.Id == esferaOrganizacao.Id).SingleOrDefault();
validacao.NaoEncontrado(eo);
eo.Descricao = esferaOrganizacao.Descricao;
unitOfWork.Save();
}
public void Alterar(string guid, UnidadeModeloNegocio unidade)
{
#region Verificação básica de Id
unidadeValidacao.NaoNula(unidade);
unidadeValidacao.GuidValido(guid);
unidadeValidacao.GuidAlteracaoValido(guid, unidade);
#endregion
Guid g = new Guid(unidade.Guid);
var unidadeDominio = repositorioUnidades.Where(u => u.IdentificadorExterno.Guid.Equals(g))
.Include(un => un.IdentificadorExterno)
.Include(un => un.Organizacao).ThenInclude(o => o.IdentificadorExterno)
.Include(un => un.TipoUnidade)
.Include(un => un.UnidadePai).ThenInclude(up => up.IdentificadorExterno)
.SingleOrDefault();
//Verificação da unidade na base de dados
unidadeValidacao.NaoEncontrado(unidadeDominio);
Mapper.Map(unidadeDominio, unidade);
#region Verificação de campos obrigatórios
unidadeValidacao.NaoNula(unidade);
unidadeValidacao.Preenchida(unidade);
tipoUnidadeValidacao.NaoNulo(unidade.TipoUnidade);
tipoUnidadeValidacao.IdPreenchido(unidade.TipoUnidade);
organizacaoValidacao.NaoNulo(unidade.Organizacao);
organizacaoValidacao.IdPreenchido(unidade.Organizacao);
unidadeValidacao.UnidadePaiPreenchida(unidade.UnidadePai);
#endregion
#region Validação de Negócio
unidadeValidacao.Valida(unidade);
tipoUnidadeValidacao.Existe(unidade.TipoUnidade);
organizacaoValidacao.Existe(unidade.Organizacao);
unidadeValidacao.UnidadePaiValida(unidade.UnidadePai);
if (unidade.UnidadePai != null)
{
unidade.UnidadePai.Guid = null;
}
unidade.Guid = null;
#endregion
DateTime agora = DateTime.Now;
InserirHistorico(unidadeDominio, "Edição", agora);
Mapper.Map(unidade, unidadeDominio);
unidadeDominio.InicioVigencia = agora;
unitOfWork.Save();
}
public UnidadeModeloNegocio Inserir(UnidadeModeloNegocio unidade)
{
#region Verificação de campos obrigatórios
unidadeValidacao.NaoNula(unidade);
unidadeValidacao.Preenchida(unidade);
tipoUnidadeValidacao.NaoNulo(unidade.TipoUnidade);
tipoUnidadeValidacao.IdPreenchido(unidade.TipoUnidade);
organizacaoValidacao.NaoNulo(unidade.Organizacao);
organizacaoValidacao.GuidPreenchido(unidade.Organizacao);
unidadeValidacao.UnidadePaiPreenchida(unidade.UnidadePai);
enderecoValidacao.Preenchido(unidade.Endereco);
contatoValidacao.Preenchido(unidade.Contatos);
emailValidacao.Preenchido(unidade.Emails);
siteValidacao.Preenchido(unidade.Sites);
#endregion
#region Validação de Negócio
unidadeValidacao.Valida(unidade);
tipoUnidadeValidacao.Existe(unidade.TipoUnidade);
organizacaoValidacao.GuidValido(unidade.Organizacao.Guid);
organizacaoValidacao.ExistePorGuid(unidade.Organizacao);
unidadeValidacao.UnidadePaiValida(unidade.UnidadePai);
enderecoValidacao.Valido(unidade.Endereco);
contatoValidacao.Valido(unidade.Contatos);
emailValidacao.Valido(unidade.Emails);
siteValidacao.Valido(unidade.Sites);
#endregion
Guid guidOrganziacao = new Guid(unidade.Organizacao.Guid);
unidade.Organizacao.Id = repositorioOrganizcoes.Where(o => o.IdentificadorExterno.Guid.Equals(guidOrganziacao))
.Select(o => o.Id)
.Single();
if (unidade.UnidadePai != null)
{
Guid guidUnidadePai = new Guid(unidade.UnidadePai.Guid);
unidade.UnidadePai.Id = repositorioUnidades.Where(u => u.IdentificadorExterno.Guid.Equals(guidUnidadePai))
.Select(u => u.Id)
.Single();
}
if (unidade.Endereco != null)
{
Guid guidMunicipio = new Guid(unidade.Endereco.Municipio.Guid);
unidade.Endereco.Municipio.Id = repositorioMunicipios.Where(m => m.IdentificadorExterno.Guid.Equals(guidMunicipio))
.Select(m => m.Id)
.Single();
}
unidade.Guid = Guid.NewGuid().ToString("D");
var unid = Mapper.Map <UnidadeModeloNegocio, Unidade>(unidade);
unid.InicioVigencia = DateTime.Now;
repositorioUnidades.Add(unid);
unitOfWork.Save();
return(Mapper.Map <Unidade, UnidadeModeloNegocio>(unid));
}
public void ExcluirSemSalvar(string guid)
{
validacao.GuidValido(guid);
validacao.Existe(guid);
Guid g = new Guid(guid);
validacao.UsuarioTemPermissao(_currentUser.UserGuidsOrganizacao, guid);
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.IdentificadorExterno.Guid.Equals(g))
.Include(o => o.IdentificadorExterno)
.Include(i => i.Endereco)
.Include(i => i.ContatosOrganizacao).ThenInclude(c => c.Contato)
.Include(i => i.SitesOrganizacao).ThenInclude(s => s.Site)
.Include(i => i.EmailsOrganizacao).ThenInclude(s => s.Email).Single();
validacao.PossuiFilho(organizacao.Id);
validacao.PossuiUnidade(organizacao.Id);
InserirHistorico(organizacao, "Exclusão", null);
ExcluiContatos(organizacao);
ExcluiEndereco(organizacao);
ExcluiEmails(organizacao);
ExcluiSites(organizacao);
repositorioOrganizacoes.Remove(organizacao);
}
private int BuscarIdMunicipio(string guidMunicipio)
{
Guid guid = new Guid(guidMunicipio);
return(repositorioMunicipios.Where(o => o.IdentificadorExterno.Guid.Equals(guid)).Single().Id);
}
