public async Task <IActionResult> Post(DevedoresEnderecos model)
{
try
{
var devedoresEnderecos = await _repo.GetDevedoresEnderecosCEP(model.CEP);
if (devedoresEnderecos == null)
{
_repo.Add(model);
if (await _repo.SaveChangeAsync())
{
return(Ok("Devedor Endereco cadastrado com sucesso!"));
}
}
else
{
return(BadRequest($"Erro: Esse Devedor Endereco já está cadastrado!"));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex}"));
}
return(BadRequest("Erro: Não Salvou!!"));
}
public Cliente AdicionarCliente(Cliente clienteNovo)
{
var documentoSemFormatacao = FormataDocumento(clienteNovo.CPF);
var clienteExistente = _repoCliente.GetAsync(c => c.CPF == documentoSemFormatacao).Result.FirstOrDefault();
if (clienteExistente != null)
{
throw new ClienteJaCadastradoException("Cliente já existente com este CPF!");
}
clienteNovo.ClienteId = Guid.NewGuid();
clienteNovo.DataCadastro = DateTime.Now;
clienteNovo.CPF = documentoSemFormatacao;
var mensagensValidacao = ValidacaoHelper.ValidateModel(clienteNovo);
if (mensagensValidacao.Any())
{
throw new EntidadeInvalidaException(string.Join(",", mensagensValidacao));
}
_repoCliente.Add(clienteNovo);
_repoCliente.SaveChangesAsync();
return(clienteNovo);
}
public async Task <IActionResult> Post(Cidades model)
{
try
{
var cidades = await _repo.GetCidadeID(model.idCidade);
if (cidades == null)
{
_repo.Add(model);
if (await _repo.SaveChangeAsync())
{
return(Ok("Cidade cadastrada com sucesso!"));
}
}
else
{
return(BadRequest($"Erro: Essa cidade já está cadastrado!"));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex}"));
}
return(BadRequest("Erro: Não Salvou!!"));
}
public async Task <IActionResult> Post(Protestos model)
{
try
{
var Protesto = await _repo.GetProtestoId(model.idProtesto);
if (Protesto == null)
{
_repo.Add(model);
if (await _repo.SaveChangeAsync())
{
return(Ok("Protesto cadastrado com sucesso!"));
}
}
else
{
return(BadRequest($"Erro: Esse Protesto já está cadastrado!"));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex}"));
}
return(BadRequest("Erro: Não Salvou!!"));
}
public async Task <IActionResult> Post(Bancos model)
{
try
{
var banco = await _repo.GetBancoNome(model.Nome);
if (banco == null)
{
_repo.Add(model);
if (await _repo.SaveChangeAsync())
{
return(Ok("Banco cadastrado com sucesso!"));
}
}
else
{
return(BadRequest($"Erro: Esse banco já está cadastrado!"));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex}"));
}
return(BadRequest("Erro: Não Salvou!!"));
}
public async Task <IActionResult> Post(ContratosParcelas model)
{
try
{
var contratosparcelas = await _repo.GetContratoParcelaId(model.idContratoParcela);
if (contratosparcelas == null)
{
_repo.Add(model);
if (await _repo.SaveChangeAsync())
{
return(Ok("Contrato Parcela cadastrado com sucesso!"));
}
}
else
{
return(BadRequest($"Erro: Esse Contrato Parcela já está cadastrado!"));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex}"));
}
return(BadRequest("Erro: Não Salvou!!"));
}
public async Task <IActionResult> Post(UFs model)
{
try
{
var ufs = await _repo.GetUfId(model.idUf);
if (ufs == null)
{
_repo.Add(model);
if (await _repo.SaveChangeAsync())
{
return(Ok("Uf cadastrado com sucesso!"));
}
}
else
{
return(BadRequest($"Erro: Essa Ufs já está cadastrada!"));
}
}
catch (Exception ex)
{
return(BadRequest($"Erro: {ex}"));
}
return(BadRequest("Erro: Não Salvou!!"));
}
public virtual bool Inserir(IEnumerable <TEntity> items)
{
var itemsList = items.ToList();
var result = _repository.Add(itemsList);
return(result);
}
public IActionResult Post(AlunoRegistrarDto model)
{
var aluno = _mapper.Map <Aluno>(model);
_Repos.Add(aluno);
_Repos.SaveChanges();
//redireciona para GetBy
return(Created($"/api/aluno/{model.Id}", _mapper.Map <AlunoDto>(aluno)));
}
public ActionResult Alta(AlumnoViewModel alumno)
{
var data = adaptador.ToModel(alumno);
if (ModelState.IsValid)
{
repo.Add(data);
}
return(RedirectToAction("Index"));
}
public ActionResult Index()
{
ViewBag.Title = "Home Page";
_repositorio.Add(new Pais()
{
Descripcion = "Argentina"
});
return(View());
}
public virtual void Create(T item)
{
try
{
Repositorio.Add(item);
UnitOfWork.SaveChanges();
}
catch (Exception ex)
{
//_logger.Debug(item.GetType() + " Error al crear: " + ex.Message);
throw new ServiceException("Ocurrio un error al crear el item", ex);
}
}
public ClienteMovimentacao AdicionarClienteMovimentacao(ClienteMovimentacao movimentacaoNova)
{
var clienteExistente = _repoCliente.GetAsync(c =>
c.ClienteId == movimentacaoNova.ClienteId).Result.FirstOrDefault();
if (clienteExistente == null)
{
throw new ClienteNaoEncontradoException("Cliente não encontrado!");
}
var lojaExistente = _repoLoja.GetAsync(c => c.Ativo &&
c.LojaId == movimentacaoNova.LojaId).Result.FirstOrDefault();
if (lojaExistente == null)
{
throw new LojaNaoEncontradaException("Loja não encontrada!");
}
var valorFinal = clienteExistente.SaldoAtual ?? 0;
if (movimentacaoNova.Operacao == Models.Enums.Operacao.Debito)
{
valorFinal -= movimentacaoNova.Valor;
}
else
{
valorFinal += movimentacaoNova.Valor;
}
if (valorFinal < 0)
{
throw new SaldoInsuficienteException("Cliente sem saldo suficiente!");
}
movimentacaoNova.SaldoAtual = valorFinal;
movimentacaoNova.ClienteMovimentacaoId = Guid.NewGuid();
movimentacaoNova.DataOperacao = DateTime.Now;
var mensagensValidacao = ValidacaoHelper.ValidateModel(movimentacaoNova);
if (mensagensValidacao.Any())
{
throw new EntidadeInvalidaException(string.Join(",", mensagensValidacao));
}
_repoClienteMovimentacaoe.Add(movimentacaoNova);
_repoClienteMovimentacaoe.SaveChangesAsync();
return(movimentacaoNova);
}
public async Task <IActionResult> Post([FromBody] Palestrante model)
{
try
{
_proAgilRepositorio.Add(model);
if (await _proAgilRepositorio.SaveChangesAsync())
{
return(Created($"/api/evento/{model.PalestranteId}", model));
}
}
catch (System.Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
return(BadRequest());
}
public async Task <IActionResult> Post(Evento model)
{
try
{
_repo.Add(model);
if (await _repo.SaveChangesAsync())
{
return(Ok("Evento Adicionado"));
}
}
catch (Exception)
{
return(BadRequest("Não foi possível adicionar o envento. Confira a Sintaxi."));
}
return(BadRequest("Não Salvou."));
}
public async Task Create(EstablecimientoDto establecimiento)
{
var _establecimiento = _mapper.Map <Galeno.Dominio.Entidades.Establecimiento>(establecimiento);
await _repositorio.Add(_establecimiento);
}
public string PostPais(Pais pais)
{
_repositorio.Add(pais);
_repositorio.Save();
return("Se Guardo correctamente.");
}
public async Task <long> Create(PrestadorEstablecimientoDto prestadorEstablecimiento)
{
var _prestadorEstablecimiento = _mapper.Map <Galeno.Dominio.Entidades.PrestadorEstablecimiento>(prestadorEstablecimiento);
return(await _repositorio.Add(_prestadorEstablecimiento));
}
public void PublicarEdicao(Edicao edicao)
{
_repositorio.Add(edicao);
NotificarAssinantes(edicao);
}
public Task <T> Add(T entity)
{
return(_repositorio.Add(entity));
}
public async Task <long> Create(PrestadorEspecialidadDto prestadorEspecialidad)
{
var prest = _mapper.Map <Galeno.Dominio.Entidades.PrestadorEspecialidad>(prestadorEspecialidad);
return(await _repositorio.Add(prest));
}
public void Add(TEntity obj)
{
_repositorio.Add(obj);
}
public async Task Create(EspecialidadDto especialidad)
{
var _especialidad = _mapper.Map <Galeno.Dominio.Entidades.Especialidad>(especialidad);
await _repositorio.Add(_especialidad);
}
public void Post([FromBody] Cliente cli)
{
_service.Add(cli);
}
public async Task Create(LocalidadDto localidad)
{
var _localidad = _mapper.Map <Galeno.Dominio.Entidades.Localidad>(localidad);
await _repositorio.Add(_localidad);
}
public async Task Create(DiaHorarioDto diaHorario)
{
var _diaHorario = _mapper.Map <Galeno.Dominio.Entidades.DiaHorario>(diaHorario);
await _repositorio.Add(_diaHorario);
}
public async Task <long> Create(PrestadorDto prestador)
{
var _prestador = _mapper.Map <Galeno.Dominio.Entidades.Prestador>(prestador);
return(await _repositorio.Add(_prestador));
}
