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 PoderModeloNegocio Inserir(PoderModeloNegocio poderNegocio)
{
validacao.DescricaoValida(poderNegocio);
validacao.DescricaoExistente(poderNegocio);
Poder poder = Mapper.Map <PoderModeloNegocio, Poder>(poderNegocio);
repositorioPoderes.Add(poder);
unitOfWork.Save();
return(Mapper.Map(poder, poderNegocio));
}
public MunicipioModeloNegocio Inserir(MunicipioModeloNegocio municipioNegocio)
{
validacao.MunicipioValido(municipioNegocio);
validacao.CodigoIbgeExistente(municipioNegocio);
validacao.NomeUfExistente(municipioNegocio);
Municipio municipio = PreparaMunicipioParaInsercao(municipioNegocio);
repositorioMunicipios.Add(municipio);
unitOfWork.Save();
return(Mapper.Map <Municipio, MunicipioModeloNegocio>(municipio));
}
private void InserirHistorico(Unidade unidade, string obsFimVigencia, DateTime?now)
{
string municipioJson = JsonData.SerializeObject(unidade);
Historico historico = new Historico
{
Json = municipioJson,
InicioVigencia = unidade.InicioVigencia,
FimVigencia = now.HasValue ? now.Value : DateTime.Now,
ObservacaoFimVigencia = obsFimVigencia,
IdIdentificadorExterno = unidade.IdentificadorExterno.Id
};
repositorioHistoricos.Add(historico);
}
public EsferaOrganizacaoModeloNegocio Inserir(EsferaOrganizacaoModeloNegocio esferaOrganizacao)
{
validacao.EsferaOrganizacaoValido(esferaOrganizacao);
validacao.DescricaoValida(esferaOrganizacao.Descricao);
validacao.DescricaoExistente(esferaOrganizacao.Descricao);
var eo = Mapper.Map <EsferaOrganizacaoModeloNegocio, EsferaOrganizacao>(esferaOrganizacao);
repositorioEsferasOrganizacoes.Add(eo);
unitOfWork.Save();
return(Mapper.Map <EsferaOrganizacao, EsferaOrganizacaoModeloNegocio>(eo));
}
public UsuarioDTO CrearUsuario(UsuarioRequest request)
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
if (request.RequestUserInfo == null)
{
throw new ArgumentNullException(nameof(request.RequestUserInfo));
}
if (string.IsNullOrEmpty(request.UsuarioId))
{
throw new ArgumentNullException(nameof(request.UsuarioId));
}
if (string.IsNullOrEmpty(request.Nombre))
{
throw new ArgumentNullException(nameof(request.Nombre));
}
if (string.IsNullOrEmpty(request.Contrasenia))
{
throw new ArgumentNullException(nameof(request.Contrasenia));
}
var nuevoUsuario = _usuarioDomainService.CrearUsuario(request);
if (nuevoUsuario == null)
{
return new UsuarioDTO {
ValidationErrorMessage = "Problemas al crear usuario"
}
}
;
var transactioninfo = TransactionInfoHelper.CrearTransactionInfo(request.RequestUserInfo);
_usuarioRepositorio.Add(nuevoUsuario);
_usuarioRepositorio.UnitOfWork.Commit(transactioninfo);
return(new UsuarioDTO
{
UsuarioId = nuevoUsuario.UsuarioId,
Nombre = nuevoUsuario.Nombre
});
}
public TipoOrganizacaoModeloNegocio Inserir(TipoOrganizacaoModeloNegocio tipoOrganizacao)
{
validacao.TipoOrganizacaoValido(tipoOrganizacao);
validacao.DescricaoValida(tipoOrganizacao.Descricao);
validacao.DescricaoExistente(tipoOrganizacao.Descricao);
TipoOrganizacao td = new TipoOrganizacao();
td.Descricao = tipoOrganizacao.Descricao;
td.InicioVigencia = DateTime.Now;
repositorioTiposOrganizacoes.Add(td);
unitOfWork.Save();
return(Mapper.Map <TipoOrganizacao, TipoOrganizacaoModeloNegocio>(td));
}
private void InserirHistorico(Organizacao organizacao, string obsFimVigencia, DateTime?fimVigencia)
{
Organizacao organizacaoSimples = JsonData.DeserializeObject <Organizacao>(JsonData.SerializeObject(organizacao));
organizacaoSimples.Esfera = null;
organizacaoSimples.OrganizacaoPai = null;
organizacaoSimples.OrganizacoesFilhas = null;
organizacaoSimples.Poder = null;
organizacaoSimples.TipoOrganizacao = null;
organizacaoSimples.Unidades = null;
string json = JsonData.SerializeObject(organizacaoSimples);
Historico historico = new Historico
{
Json = json,
InicioVigencia = organizacao.InicioVigencia,
FimVigencia = fimVigencia.HasValue ? fimVigencia.Value : DateTime.Now,
ObservacaoFimVigencia = obsFimVigencia,
IdIdentificadorExterno = organizacao.IdentificadorExterno.Id
};
repositorioHistoricos.Add(historico);
}
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));
}
