private void NomeFantasiaValido(OrganizacaoModeloNegocio organizacaoNegocio)
{
if (organizacaoNegocio.NomeFantasia.Length > 100)
{
throw new OrganogramaRequisicaoInvalidaException("Sigla deve possuir no máximo 100 caracteres.");
}
}
internal void GuidAlteracaoValido(string guid, OrganizacaoModeloNegocio organizacaoNegocio)
{
if (!guid.Equals(organizacaoNegocio.Guid))
{
throw new OrganogramaRequisicaoInvalidaException("Identificadores de Organização diferentes.");
}
}
internal void NaoNulo(OrganizacaoModeloNegocio organizacao)
{
if (organizacao == null)
{
throw new OrganogramaRequisicaoInvalidaException("Organização não pode ser nulo.");
}
}
private void SiglaValida(OrganizacaoModeloNegocio organizacao)
{
if (organizacao.Sigla.Length > 10)
{
throw new OrganogramaRequisicaoInvalidaException("Sigla deve possuir no máximo 10 caracteres.");
}
}
private void MontarOrganograma(OrganizacaoModeloNegocio organizacao, List <OrganizacaoModeloNegocio> organizacoes)
{
int quantidadeOrganizacoes = organizacoes.Count;
organizacao.OrganizacoesFilhas = organizacoes.Where(o => o.OrganizacaoPai != null &&
o.OrganizacaoPai.Id == organizacao.Id)
.ToList();
if (organizacao.OrganizacoesFilhas.Count > 0)
{
organizacoes.RemoveAll(o => o.OrganizacaoPai != null && o.OrganizacaoPai.Id == organizacao.Id);
}
else
{
organizacao.OrganizacoesFilhas = null;
}
if (organizacoes.Count < quantidadeOrganizacoes)
{
foreach (var org in organizacao.OrganizacoesFilhas)
{
MontarOrganograma(org, organizacoes);
}
}
}
private void MontarOrganograma(OrganizacaoModeloNegocio organizacao, List <UnidadeModeloNegocio> unidades)
{
var unidadesOrganizacao = unidades.Where(u => u.Organizacao != null &&
u.Organizacao.Id == organizacao.Id)
.ToList();
if (unidadesOrganizacao != null && unidadesOrganizacao.Count > 0)
{
unidades.RemoveAll(u => u.Organizacao != null && u.Organizacao.Id == organizacao.Id);
var unidadesSemPai = unidadesOrganizacao.Where(u => u.UnidadePai == null)
.ToList();
if (unidadesSemPai != null && unidadesSemPai.Count > 0)
{
unidadesOrganizacao.RemoveAll(u => u.UnidadePai == null);
organizacao.Unidades = unidadesSemPai;
foreach (var u in organizacao.Unidades)
{
MontarOrganograma(u, unidadesOrganizacao);
}
}
}
if (organizacao.OrganizacoesFilhas != null && organizacao.OrganizacoesFilhas.Count > 0)
{
foreach (var org in organizacao.OrganizacoesFilhas)
{
MontarOrganograma(org, unidades);
}
}
}
internal void PaiPreenchido(OrganizacaoModeloNegocio organizacaoPai)
{
if (organizacaoPai == null)
{
throw new OrganogramaRequisicaoInvalidaException("Organização pai não pode ser nula.");
}
}
private Organizacao PreparaInsercao(OrganizacaoModeloNegocio organizacaoNegocio)
{
organizacaoNegocio.Guid = Guid.NewGuid().ToString("D");
if (organizacaoNegocio.OrganizacaoPai != null)
{
var organizacaoPai = Pesquisar(organizacaoNegocio.OrganizacaoPai.Guid);
organizacaoNegocio.OrganizacaoPai.Id = organizacaoPai.Id;
organizacaoNegocio.Esfera = new EsferaOrganizacaoModeloNegocio {
Id = organizacaoPai.Esfera.Id
};
organizacaoNegocio.Poder = new PoderModeloNegocio {
Id = organizacaoPai.Poder.Id
};
}
if (organizacaoNegocio.Endereco != null)
{
organizacaoNegocio.Endereco.Municipio.Id = BuscarIdMunicipio(organizacaoNegocio.Endereco.Municipio.Guid);
}
Organizacao organizacao = new Organizacao();
organizacao = Mapper.Map <OrganizacaoModeloNegocio, Organizacao>(organizacaoNegocio);
return(organizacao);
}
internal void IdValido(OrganizacaoModeloNegocio organizacao)
{
if (organizacao.Id < 0)
{
throw new OrganogramaRequisicaoInvalidaException("Id da organização não é valido");
}
}
public OrganizacaoModeloNegocio PesquisarPatriarca(string guid)
{
OrganizacaoModeloNegocio organizacaoNegocio = new OrganizacaoModeloNegocio();
Guid g = new Guid(guid);
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.IdentificadorExterno.Guid.Equals(g))
.SingleOrDefault();
validacao.NaoEncontrado(organizacao);
int idOrganizacaoPatriarca = ObterOrganizacaoPatriarca(organizacao);
Organizacao organizacaoPatriarca = repositorioOrganizacoes.Where(o => o.Id == idOrganizacaoPatriarca)
.Include(e => e.Endereco).ThenInclude(m => m.Municipio).ThenInclude(m => m.IdentificadorExterno)
.Include(e => e.Esfera)
.Include(p => p.Poder)
.Include(c => c.ContatosOrganizacao).ThenInclude(co => co.Contato).ThenInclude(tc => tc.TipoContato)
.Include(eo => eo.EmailsOrganizacao).ThenInclude(e => e.Email)
.Include(so => so.SitesOrganizacao).ThenInclude(s => s.Site)
.Include(to => to.TipoOrganizacao)
.Include(to => to.IdentificadorExterno)
.SingleOrDefault();
return(Mapper.Map(organizacaoPatriarca, organizacaoNegocio));
}
public OrganizacaoModeloPut InserirPatriarca(OrganizacaoModeloPost organizacaoPost)
{
OrganizacaoModeloNegocio organizacaoModeloNegocio = new OrganizacaoModeloNegocio();
Mapper.Map(organizacaoPost, organizacaoModeloNegocio);
return(Mapper.Map <OrganizacaoModeloNegocio, OrganizacaoModeloPut>(organizacaoNegocio.InserirPatriarca(organizacaoModeloNegocio)));
}
private void RazaoSocialExiste(OrganizacaoModeloNegocio organizacaoNegocio)
{
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.RazaoSocial.Equals(organizacaoNegocio.RazaoSocial) && o.Id != organizacaoNegocio.Id).SingleOrDefault();
if (organizacao != null)
{
throw new OrganogramaRequisicaoInvalidaException("A Razão Social informada já pertence a uma organização.");
}
}
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 PaiDiferente(OrganizacaoModeloNegocio organizacao)
{
if (organizacao != null && organizacao.OrganizacaoPai != null)
{
if (organizacao.Guid.Equals(organizacao.OrganizacaoPai.Guid))
{
throw new OrganogramaNaoEncontradoException("A organização pai deve ser diferente.");
}
}
}
internal void PaiValido(OrganizacaoModeloNegocio organizacaoPai)
{
if (organizacaoPai != null)
{
GuidPaiPreenchido(organizacaoPai.Guid);
GuidValido(organizacaoPai.Guid);
PaiExiste(organizacaoPai);
PaiDiferente(organizacaoPai);
}
}
internal void Valido(OrganizacaoModeloNegocio organizacao)
{
cnpjValidacao.CnpjExiste(organizacao);
cnpjValidacao.CnpjValido(organizacao.Cnpj);
//RazaoSocialExiste(organizacao);
SiglaValida(organizacao);
//SiglaExiste(organizacao);
NomeFantasiaValido(organizacao);
//NomeFantasiaExiste(organizacao);
}
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 PaiExiste(OrganizacaoModeloNegocio organizacaoPai)
{
if (organizacaoPai != null)
{
Guid guid = new Guid(organizacaoPai.Guid);
if (repositorioOrganizacoes.Where(o => o.IdentificadorExterno.Guid.Equals(guid)).SingleOrDefault() == null)
{
throw new OrganogramaNaoEncontradoException("Organização pai não existe.");
}
}
}
private Organizacao BuscaObjetoDominio(OrganizacaoModeloNegocio organizacaoNegocio)
{
Guid g = new Guid(organizacaoNegocio.Guid);
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.IdentificadorExterno.Guid.Equals(g))
.Include(un => un.IdentificadorExterno)
.Include(e => e.Esfera)
.Include(p => p.Poder)
.Include(to => to.TipoOrganizacao)
.Single();
PreencheOrganizacaoPai(organizacao);
Mapper.Map(organizacao, organizacaoNegocio);
return(organizacao);
}
public OrganizacaoModeloNegocio InserirFilha(OrganizacaoModeloNegocio organizacaoNegocio)
{
//Preenchimentos primeiro (pois não interagem com banco de dados nem fazem validações complexas)
validacao.Preenchido(organizacaoNegocio);
validacao.PaiPreenchido(organizacaoNegocio.OrganizacaoPai);
contatoValidacao.Preenchido(organizacaoNegocio.Contatos);
emailValidacao.Preenchido(organizacaoNegocio.Emails);
enderecoValidacao.NaoNulo(organizacaoNegocio.Endereco);
enderecoValidacao.Preenchido(organizacaoNegocio.Endereco);
//esferaValidacao.IdPreenchido(organizacaoNegocio.Esfera);
//poderValidacao.IdPreenchido(organizacaoNegocio.Poder);
siteValidacao.Preenchido(organizacaoNegocio.Sites);
tipoOrganizacaoValidacao.IdPreenchido(organizacaoNegocio.TipoOrganizacao);
//Validações utilizam cálculos e/ou interagem com o banco de dados
validacao.PaiValido(organizacaoNegocio.OrganizacaoPai);
validacao.Valido(organizacaoNegocio);
if (organizacaoNegocio.OrganizacaoPai != null)
{
validacao.UsuarioTemPermissao(_currentUser.UserGuidsOrganizacao, organizacaoNegocio.OrganizacaoPai.Guid);
}
contatoValidacao.Valido(organizacaoNegocio.Contatos);
emailValidacao.Valido(organizacaoNegocio.Emails);
enderecoValidacao.Valido(organizacaoNegocio.Endereco);
//esferaValidacao.Existe(organizacaoNegocio.Esfera);
//poderValidacao.Existe(organizacaoNegocio.Poder);
siteValidacao.Valido(organizacaoNegocio.Sites);
tipoOrganizacaoValidacao.Existe(organizacaoNegocio.TipoOrganizacao);
Organizacao organizacao = PreparaInsercao(organizacaoNegocio);
organizacao.InicioVigencia = DateTime.Now;
repositorioOrganizacoes.Add(organizacao);
unitOfWork.Attach(organizacao.TipoOrganizacao);
unitOfWork.Attach(organizacao.Esfera);
unitOfWork.Attach(organizacao.Poder);
unitOfWork.Save();
return(Mapper.Map <Organizacao, OrganizacaoModeloNegocio>(organizacao));
}
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);
}
public OrganizacaoModeloNegocio PesquisarPorSigla(string sigla)
{
OrganizacaoModeloNegocio organizacaoNegocio = new OrganizacaoModeloNegocio();
Organizacao organizacao = repositorioOrganizacoes.Where(o => o.Sigla.Trim().ToUpper().Equals(sigla.Trim().ToUpper()))
.Include(e => e.Endereco).ThenInclude(m => m.Municipio).ThenInclude(m => m.IdentificadorExterno)
.Include(e => e.Esfera)
.Include(p => p.Poder)
.Include(c => c.ContatosOrganizacao).ThenInclude(co => co.Contato).ThenInclude(tc => tc.TipoContato)
.Include(eo => eo.EmailsOrganizacao).ThenInclude(e => e.Email)
.Include(so => so.SitesOrganizacao).ThenInclude(s => s.Site)
.Include(to => to.TipoOrganizacao)
.Include(to => to.IdentificadorExterno)
.SingleOrDefault();
validacao.NaoEncontrado(organizacao);
PreencheOrganizacaoPai(organizacao);
return(Mapper.Map(organizacao, organizacaoNegocio));
}
internal void Preenchido(OrganizacaoModeloNegocio organizacao)
{
if (string.IsNullOrEmpty(organizacao.Cnpj))
{
throw new OrganogramaRequisicaoInvalidaException("Cnpj não preenchido.");
}
if (string.IsNullOrEmpty(organizacao.RazaoSocial))
{
throw new OrganogramaRequisicaoInvalidaException("Razão Social não preenchida.");
}
if (string.IsNullOrEmpty(organizacao.NomeFantasia))
{
throw new OrganogramaRequisicaoInvalidaException("Nome fantasia não preenchido.");
}
if (string.IsNullOrEmpty(organizacao.Sigla))
{
throw new OrganogramaRequisicaoInvalidaException("Sigla não preenchida.");
}
}
public void Alterar(string guid, OrganizacaoModeloNegocio organizacaoNegocio)
{
validacao.GuidPreenchido(guid);
validacao.GuidValido(guid);
validacao.NaoNulo(organizacaoNegocio);
validacao.GuidPreenchido(organizacaoNegocio.Guid);
validacao.GuidValido(organizacaoNegocio);
validacao.GuidAlteracaoValido(guid, organizacaoNegocio);
Organizacao organizacao = BuscaObjetoDominio(organizacaoNegocio);
validacao.Preenchido(organizacaoNegocio);
validacao.Valido(organizacaoNegocio);
validacao.PaiValido(organizacaoNegocio.OrganizacaoPai);
cnpjValidacao.CnpjExiste(organizacaoNegocio);
cnpjValidacao.CnpjValido(organizacaoNegocio.Cnpj);
esferaValidacao.IdPreenchido(organizacaoNegocio.Esfera);
esferaValidacao.IdValido(organizacaoNegocio.Esfera);
poderValidacao.IdPreenchido(organizacaoNegocio.Poder);
poderValidacao.IdValido(organizacaoNegocio.Poder);
tipoOrganizacaoValidacao.IdPreenchido(organizacaoNegocio.TipoOrganizacao);
tipoOrganizacaoValidacao.IdValido(organizacaoNegocio.TipoOrganizacao);
validacao.Existe(organizacaoNegocio);
esferaValidacao.Existe(organizacaoNegocio.Esfera);
poderValidacao.Existe(organizacaoNegocio.Poder);
tipoOrganizacaoValidacao.Existe(organizacaoNegocio.TipoOrganizacao);
DateTime agora = DateTime.Now;
InserirHistorico(organizacao, "Edição", agora);
Mapper.Map(organizacaoNegocio, organizacao);
organizacao.InicioVigencia = agora;
unitOfWork.Save();
}
private void SiglaExiste(OrganizacaoModeloNegocio organizacaoNegocio)
{
var query = repositorioOrganizacoes.Where(o => o.Sigla.ToUpper().Equals(organizacaoNegocio.Sigla.ToUpper()) &&
o.Id != organizacaoNegocio.Id);
if (organizacaoNegocio.OrganizacaoPai == null)
{
query = query.Where(o => o.OrganizacaoPai == null);
}
else
{
Guid g = new Guid(organizacaoNegocio.OrganizacaoPai.Guid);
query = query.Where(o => o.OrganizacaoPai.IdentificadorExterno.Guid.Equals(g));
}
Organizacao organizacao = query.SingleOrDefault();
if (organizacao != null)
{
throw new OrganogramaRequisicaoInvalidaException("A Sigla informada já pertence a uma organização.");
}
}
private List <int> IdsOrganizacoesOrganograma(OrganizacaoModeloNegocio organizacao)
{
List <int> idsOrganizacoes = null;
if (organizacao != null)
{
idsOrganizacoes = new List <int>();
idsOrganizacoes.Add(organizacao.Id);
//var idsOrganizacoesFilhas = organizacao.OrganizacoesFilhas.Select(of => of.Id)
// .ToList();
if (organizacao.OrganizacoesFilhas != null && organizacao.OrganizacoesFilhas.Count > 0)
{
foreach (var org in organizacao.OrganizacoesFilhas)
{
idsOrganizacoes.AddRange(IdsOrganizacoesOrganograma(org));
}
}
}
return(idsOrganizacoes);
}
internal void IdPreenchido(OrganizacaoModeloNegocio organizacao)
{
IdPreenchido(organizacao.Id);
}
internal void GuidValido(OrganizacaoModeloNegocio organizacaoNegocio)
{
GuidValido(organizacaoNegocio.Guid);
}
internal void GuidPreenchido(OrganizacaoModeloNegocio organizacao)
{
GuidPreenchido(organizacao.Guid);
}
internal void ExistePorGuid(OrganizacaoModeloNegocio organizacao)
{
Existe(organizacao.Guid);
}
