public async Task <IActionResult> Put([FromRoute] long id, [FromBody] EmpresaDto empresa)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != empresa.Id)
{
return(BadRequest());
}
var Empresa = await Task.Run(() =>
{
return(_empresaService.Update(empresa));
});
try
{
return(Ok(Empresa));
}
catch (DbUpdateConcurrencyException)
{
var validation = _empresaService.GetById(Empresa.Id);
if (validation == null)
{
return(NotFound());
}
else
{
throw;
}
}
}
public void AlterarEmpresa(long id, EmpresaDto empresa)
{
var empresaExistente = _mapper.Map <Empresa>(empresa);
empresaExistente.Id = id;
_repository.SaveOrUpdate(empresaExistente);
}
public IHttpActionResult EditarEmpresa([FromBody] EmpresaDto empresa)
{
try
{
empresasNegocio = new EmpresasNegocio();
string res = empresasNegocio.CreaModificaEmpresa("U", empresa);
return(Content(HttpStatusCode.OK, new Mensaje()
{
codigoRespuesta = Catalogo.OK, mensajeRespuesta = "", objetoRespuesta = res
}));
}
catch (ExcepcionOperacion exOp)
{
return(Content(HttpStatusCode.InternalServerError, new Mensaje()
{
codigoRespuesta = Catalogo.ERROR, mensajeRespuesta = Catalogo.FALLO_CONSULTA_MENU + exOp.Message
}));
}
catch (Exception ex)
{
return(Content(HttpStatusCode.InternalServerError, new Mensaje()
{
codigoRespuesta = Catalogo.ERROR, mensajeRespuesta = Catalogo.FALLO_CONSULTA_MENU + ex.Message
}));
}
}
public async Task <IActionResult> Put(int id, [FromBody] EmpresaDto dto)
{
dto.Id = id;
servicoDeDominioDeEmpresas.Atualizar(iMapper.Map <Empresa>(dto));
return(Ok());
}
public async Task <IActionResult> PutEmpresa([FromRoute] long id, [FromBody] EmpresaDto empresaDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != empresaDto.Id)
{
return(BadRequest());
}
var empresa = _empresaServicio.Modificar(empresaDto);
try
{
_empresaServicio.Guardar();
// Verificar linea , no aplica
return(Ok(empresa));
}
catch (DbUpdateConcurrencyException)
{
if (!EmpresaExiste(id))
{
return(NotFound());
}
else
{
throw;
}
}
}
public async Task ArmazenarAsync(EmpresaDto empresaDto)
{
empresaDto = empresaDto ?? new EmpresaDto();
var empresa = empresaDto.Id > 0 ?
await _editarUmaEmpresaRepositorio.EditarAsync(empresaDto) :
CriarUmaNovaEmpresa(empresaDto);
if (NotificacaoDeDominio.HasNotifications)
{
return;
}
if (!empresa.Validar())
{
await NotificarValidacoesDeDominioAsync(empresa.ValidationResult);
}
await _validadorCnpjDaEmpresaJaExistente.ValidarAsync(empresa.Cnpj, empresa.Id);
if (!NotificacaoDeDominio.HasNotifications && empresa.Id == 0)
{
await _empresaRepositorio.AdicionarAsync(empresa);
}
}
public async Task <IActionResult> Put(int Id, EmpresaDto model)
{
try
{
var empresa = await _repo.GetEmpresaAsyncById(Id);
if (empresa == null)
{
return(NotFound());
}
_mapper.Map(model, empresa);
_repo.Update(empresa);
if (await _repo.SaveChangesAsync())
{
return(Created($"/api/Empresa/{empresa.Id}", _mapper.Map <EmpresaDto>(empresa)));
}
}
catch (System.Exception)
{
return(StatusCode(
StatusCodes.Status500InternalServerError,
"Ocorreu um erro no banco de dados"));
}
return(BadRequest());
}
public void Update(EmpresaDto empresa)
{
var empresaModificar = Mapper.Map <EmpresaDto, Domain.Core.Entities.Empresa>(empresa);
Uow.Repository <Domain.Core.Entities.Empresa>().Update(empresaModificar);
Uow.Commit();
}
public IActionResult CreateEmpresa([FromBody] EmpresaDto empresa)
{
var creacao = _tipologiaAplicacao.AddEmpresa(empresa);
_automacaoFreedomUnitOfWork.Save();
return(CreatedAtRoute("GetEmpresa", new { id = creacao.Id }, creacao));
}
public async Task <IActionResult> Put(long id, [FromBody] EmpresaDto empresa)
{
empresa.Id = id;
await _armazenadorDeEmpresa.Armazenar(empresa);
return(Ok());
}
public long Insertar(EmpresaDto dto)
{
using (var context = new ModeloXCommerceContainer())
{
var nuevoEmpresa = new AccesoDatos.Empresa
{
CondicionIvaId = dto.CondicionIvaId,
NombreFantasia = dto.NombreFantasia,
RazonSocial = dto.RazonSocial,
Cuit = dto.Cuit,
Telefono = dto.Telefono,
Mail = dto.Email,
Sucursal = dto.Sucursal,
Logo = dto.Logo,
Direccion = new Direccion
{
Calle = dto.Calle,
Numero = dto.Numero,
Piso = dto.Piso,
Dpto = dto.Dpto,
Casa = dto.Casa,
Lote = dto.Lote,
Barrio = dto.Barrio,
Mza = dto.Mza,
LocalidadId = dto.LocalidadId
}
};
context.Empresas.Add(nuevoEmpresa);
context.SaveChanges();
return(nuevoEmpresa.Id);
}
}
public void Modificar(EmpresaDto empresa)
{
using (var context = new ModeloXCommerceContainer())
{
var empresaMod = context.Empresas.FirstOrDefault();
if (empresaMod == null)
{
throw new Exception("Error no se encuentra la entidad");
}
empresaMod.CondicionIvaId = empresa.CondicionIvaId;
empresaMod.Cuit = empresa.Cuit;
empresaMod.Logo = empresa.Logo;
empresaMod.Mail = empresa.Mail;
empresaMod.NombreFantasia = empresa.NombreFantasia;
empresaMod.RazonSocial = empresa.RazonSocial;
empresaMod.Sucursal = empresa.Sucursal;
empresaMod.Telefono = empresa.Telefono;
empresaMod.Direccion = new Direccion
{
Calle = empresa.Calle,
Numero = empresa.Numero,
Piso = empresa.Piso,
Dpto = empresa.Dpto,
Casa = empresa.Casa,
Lote = empresa.Lote,
Barrio = empresa.Barrio,
Mza = empresa.Mza,
LocalidadId = empresa.LocalidadId
};
context.SaveChanges();
};
}
public async Task <IActionResult> Put(int id, EmpresaDto empresaDto)
{
empresaDto.Id = id;
await _armazenadorDeEmpresa.ArmazenarAsync(empresaDto);
return(Ok());
}
public long?Agregar(EmpresaDto empresa)
{
using (var context = new ModeloXCommerceContainer())
{
var empresaNueva = new AccesoDatos.Empresa
{
CondicionIvaId = empresa.CondicionIvaId,
Cuit = empresa.Cuit,
Logo = empresa.Logo,
Mail = empresa.Mail,
ProductoBruto = "",
NombreFantasia = empresa.NombreFantasia,
RazonSocial = empresa.RazonSocial,
Sucursal = empresa.Sucursal,
Telefono = empresa.Telefono,
Direccion = new Direccion
{
Calle = empresa.Calle,
Numero = empresa.Numero,
Piso = empresa.Piso,
Dpto = empresa.Dpto,
Casa = empresa.Casa,
Lote = empresa.Lote,
Barrio = empresa.Barrio,
Mza = empresa.Mza,
LocalidadId = empresa.LocalidadId
}
};
context.Empresas.Add(empresaNueva);
context.SaveChanges();
return(empresaNueva.Id);
}
}
public IList <string> Adicionar(EmpresaDto obj)
{
mensagens = new List <string>();
Empresa empresa = EmpresaAdapter.Mapear(obj);
if (!empresa.Validar())
{
mensagens.Add("Empresa invalida");
}
try
{
if (mensagens.Count == 0)
{
_empresaRepository.Adicionar(empresa);
}
}
catch (Exception e)
{
mensagens.Add(e.Message);
}
return(mensagens);
}
public async Task <IActionResult> Put(long id, [FromBody] EmpresaDto valueDto)
{
var result = new ResultDto <bool>();
try
{
var modelExists = await _empresaService.GetByIdAsync(id);
if (modelExists == null)
{
throw new AwayException("No existe el registro que desea editar.");
}
valueDto.Id = modelExists.Id;
result.Data = await _empresaService.UpdateAsync(valueDto);
}
catch (AwayException ex)
{
_logger.Error(KOriginApp, ex.Message, ex);
result.AddError(ex.Message);
}
catch (Exception ex)
{
_logger.Error(KOriginApp, ex.Message, ex);
result.AddError("Ocurrió un error al intentar editar los datos del registro.");
}
return(Ok(result));
}
public async Task Armazenar(EmpresaDto dto)
{
await ValidarEmpresaComMesmoNome(dto);
var empresa = new Empresa(dto.Nome, dto.Cnpj);
if (!NotificacaoDeDominio.HasNotifications())
{
if (dto.Id > 0)
{
empresa = await _empresaRepositorio.ObterPorIdAsync(dto.Id);
empresa.AlterarNome(dto.Nome);
empresa.AlterarCnpj(dto.Cnpj);
}
empresa.AlterarDataFundacao(dto.DataFundacao);
if (!empresa.Validar())
{
await NotificarValidacoesDeDominio(empresa.ValidationResult);
}
if (empresa.Id == 0)
{
await _empresaRepositorio.AdicionarAsync(empresa);
}
}
}
public void Modificar(EmpresaDto dto)
{
using (var context = new ModeloXCommerceContainer())
{
var empresaModificar = context.Empresas
.Include(x => x.Direccion)
.FirstOrDefault(x => x.Id == dto.Id);
if (empresaModificar == null)
{
throw new Exception("No se encontro la Empresa");
}
empresaModificar.NombreFantasia = dto.NombreFantasia;
empresaModificar.RazonSocial = dto.RazonSocial;
empresaModificar.Cuit = dto.Cuit;
empresaModificar.Telefono = dto.Telefono;
empresaModificar.Mail = dto.Email;
empresaModificar.Sucursal = dto.Sucursal;
empresaModificar.Logo = dto.Logo;
empresaModificar.CondicionIvaId = dto.CondicionIvaId;
empresaModificar.Direccion.Calle = dto.Calle;
empresaModificar.Direccion.Numero = dto.Numero;
empresaModificar.Direccion.Piso = dto.Piso;
empresaModificar.Direccion.Dpto = dto.Dpto;
empresaModificar.Direccion.Barrio = dto.Barrio;
empresaModificar.Direccion.LocalidadId = dto.LocalidadId;
context.SaveChanges();
}
}
public EmpresaDto Add(EmpresaDto Empresa)
{
var novoEmpresa = Mapper.Map <Empresa>(Empresa);
var creado = _repositorio.Add(novoEmpresa);
var entidade = Mapper.Map <EmpresaDto>(creado);
return(entidade);
}
private async Task VerifyInsertEmpresa(EmpresaDto empresaDto, Empresa empresa)
{
await _armazenadorDeEmpresa.Armazenar(empresaDto);
_empresaRepository.Verify(r => r.Add(empresa), Times.Never);
Assert.False(empresa.Valid);
Assert.True(empresa.ValidationResult.Errors.Count > 0);
}
public void Insert(EmpresaDto empresa)
{
var empresaNueva = Mapper.Map <EmpresaDto, Domain.Core.Entities.Empresa>(empresa);
Uow.Repository <Domain.Core.Entities.Empresa>()
.Insert(empresaNueva);
Uow.Commit();
}
public async Task Insertar(EmpresaDto dto)
{
using (var context = new DataContext())
{
var empresa = _mapper.Map <Dominio.Entidades.Empresa>(dto);
await _empresaRepositorio.Create(empresa);
}
}
public EmpresaDto Alterar(EmpresaDto empresaDto)
{
var empresa = _empresaRepository.BuscarPorId(empresaDto.Id);
empresa.update(empresaDto.Nome, empresaDto.DataFundacao);
_empresaRepository.Alterador(empresa);
return(empresaDto);
}
public IHttpActionResult Put(EmpresaDto empresa)
{
_empresaRepository.Put(empresa);
if (_notification.Any)
{
return(Content(HttpStatusCode.BadRequest, _notification.Get));
}
return(Ok());
}
public async Task DeveNotificarErrosDeDominioQuandoExistir()
{
var empresaDto = new EmpresaDto();
await _armazenadorDeEmpresa.Armazenar(empresaDto);
_notificacaoDeDominioMock.Verify(notificacao =>
notificacao.HandleAsync(It.Is <DomainNotification>(d => d.Key == TipoDeNotificacao.ErroDeDominio.ToString())));
}
private async Task ValidarEmpresaComMesmoNome(EmpresaDto dto)
{
var empresaComMesmaNome = await _empresaRepositorio.ObterPorNomeAsync(dto.Nome);
if (empresaComMesmaNome != null && empresaComMesmaNome.Id != dto.Id)
{
await NotificarValidacaoDeServico(string.Format(CommonResources.MsgDominioComMesmoNomeNoFeminino, CommonResources.EmpresaDominio));
}
}
private bool ValidarId(int id, EmpresaDto empresaDto)
{
if (id != empresaDto.Id)
{
_notificationContext.AddNotification("", Resource.EmpresaNaoIdentificada);
return(false);
}
return(true);
}
public IHttpActionResult Post(EmpresaDto empresa)
{
_empresaService.IsValidCnpj(empresa.Cnpj);
_empresaRepository.Post(empresa);
if (_notification.Any)
{
return(Content(HttpStatusCode.BadRequest, _notification.Get));
}
return(Ok());
}
public IActionResult CreateOrEdit(EmpresaViewModel model)
{
EmpresaDto dto = new EmpresaDto();
SetPropriy(model, dto);
_empresastore.Store(dto);
return(RedirectToAction("Index"));
}
public ActionResult Create(EmpresaDto empresa)
{
if (ModelState.IsValid)
{
_empresaServicio.Insertar(empresa);
return(View());
}
return(View());
}