public ClienteEnderecoViewModel Adicionar(ClienteEnderecoViewModel clienteEnderecoViewModel)
{
var cliente = Mapper.Map <ClienteEnderecoViewModel, Cliente>(clienteEnderecoViewModel);
var endereco = Mapper.Map <ClienteEnderecoViewModel, Endereco>(clienteEnderecoViewModel);
cliente.Enderecos.Add(endereco);
_clienteService.Adicionar(cliente);
return(clienteEnderecoViewModel);
}
public async Task <IActionResult> Adicionar(ClienteViewModel clienteViewModel)
{
var cliente = await MapearParaCliente(clienteViewModel);
if (cliente != null)
{
await _clienteService.Adicionar(cliente);
}
return(CustomResponse(cliente));
}
public async Task <ActionResult <ClienteViewModel> > Adicionar(ClienteViewModel ClienteViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
await _clienteService.Adicionar(_mapper.Map <Cliente>(ClienteViewModel, Tratamento));
return(CustomResponse(ClienteViewModel));
}
public void Post([FromBody] Cliente cliente)
{
try
{
_service.Adicionar(cliente);
}
catch (Exception)
{
Response.StatusCode = 400;
}
}
public ClienteCommand Cadastrar(ClienteCommand clienteCommand)
{
var cliente = _clienteService.Adicionar(ClienteAdapter.ToDomainModel(clienteCommand));
if (Commit())
{
return(ClienteAdapter.ToModelDomain(cliente));
}
return(null);
}
public string Get()
{
var cliente = new Cliente
{
Nome = "Josias"
};
_clienteService.Adicionar(cliente);
return("Adicionado");
}
public async Task <ClienteViewModel> Adicionar(ClienteViewModel clienteViewModel)
{
var cliente = _mapper.Map <Cliente>(clienteViewModel);
cliente = await _clienteService.Adicionar(cliente);
//if (clienteReturn.ValidationResult.IsValid)
Commit();
clienteViewModel = _mapper.Map <ClienteViewModel>(cliente);
return(clienteViewModel);
}
public IActionResult Post([FromBody] ClienteViewModel clienteViewModel)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(Response(clienteViewModel));
}
Cliente cliente = _clienteService.Adicionar(_mapper.Map <Cliente>(clienteViewModel));
return(Response(_mapper.Map <ClienteResultViewModel>(cliente), HttpStatusCode.Created));
}
public IActionResult ClientesAdd(ClienteViewModel model)
{
if (!ModelState.IsValid)
{
NotificarErroModelInvalida();
return(Response(model));
}
_clienteService.Adicionar(_mapper.Map <ClienteModel>(model));
return(Response());
}
public ClienteViewModel Adicionar(ClienteViewModel cliente)
{
var pessoa = Mapper.Map <Pessoa>(cliente.Pessoa);
var endereco = Mapper.Map <Endereco>(cliente.Endereco);
switch (pessoa.TipoPessoa)
{
case TipoPessoa.PessoaFisica:
var pessoaFisica = Mapper.Map <PessoaFisica>(cliente.PessoaFisica);
pessoaFisica.AdicionarEndereco(endereco);
pessoa.PessoaFisica = pessoaFisica;
//var clienteReturn = _clienteService.Adicionar(pessoa);
//if (SalvarImagemCliente(cliente.Foto2, pessoa.Id))
//{
// break;
//}
break;
case TipoPessoa.PessoaJuridica:
var pessoaJuridica = Mapper.Map <PessoaJuridica>(cliente.PessoaJuridica);
pessoaJuridica.AdicionarEndereco(endereco);
pessoa.PessoaJuridica = pessoaJuridica;
//var _clienteService.Adicionar(pessoa);
//SalvarImagemCliente(cliente.Foto2, pessoa.Id);
break;
default:
break;
}
cliente.Pessoa = Mapper.Map <PessoaViewModel>(_clienteService.Adicionar(pessoa));
if (!Commit())
{
//gravar erro
}
return(cliente);
}
public NewClienteViewModel Adicionar(NewClienteViewModel clienteModel)
{
var cliente = _mapper.Map <Cliente>(clienteModel);
var clienteResult = _clienteService.Adicionar(cliente);
if (clienteResult.ValidationResult.IsValid)
{
commit();
}
clienteModel = _mapper.Map <NewClienteViewModel>(clienteResult);
return(clienteModel);
}
public void Adicionar(ClienteEnderecoViewModel clienteEnederecoViewModel)
{
var cliente = Mapper.Map <ClienteEnderecoViewModel, Cliente>(clienteEnederecoViewModel);
var endereco = Mapper.Map <ClienteEnderecoViewModel, Endereco>(clienteEnederecoViewModel);
cliente.Enderecos.Add(endereco);
BeginTransaction();
_clienteService.Adicionar(cliente);
Commit();
}
public void Adicionar(ClienteEnderecoVM clienteEnderecoVm)
{
var cliente = Mapper.Map <ClienteEnderecoVM, Cliente>(clienteEnderecoVm);
var endereco = Mapper.Map <ClienteEnderecoVM, Endereco>(clienteEnderecoVm);
cliente.Enderecos.Add(endereco);
BeginTransaction();
_clienteRepository.Adicionar(cliente);
Commit();
}
public async Task <ActionResult <ClienteViewModel> > Post([FromBody] ClienteViewModel clienteViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var cliente = _mapper.Map <Cliente>(clienteViewModel);
await _clienteService.Adicionar(cliente);
return(CustomResponse(clienteViewModel));
}
public ClienteEnderecoViewModel Adicionar(ClienteEnderecoViewModel clienteEnderecoViewModel)
{
var cliente = Mapper.Map <ClienteEnderecoViewModel, Cliente>(clienteEnderecoViewModel);
var endereco = Mapper.Map <ClienteEnderecoViewModel, Endereco>(clienteEnderecoViewModel);
cliente.Enderecos.Add(endereco);
cliente.DataCadastro = DateTime.Now;
var clienteReturn = _clieteService.Adicionar(cliente);
clienteEnderecoViewModel = Mapper.Map <Cliente, ClienteEnderecoViewModel>(clienteReturn);
return(clienteEnderecoViewModel);
}
public async Task <IActionResult> Create(ClienteViewModel clienteViewModel)
{
if (!ModelState.IsValid)
{
return(View(clienteViewModel));
}
//Criação vai ser pela classe de serviço.
var cliente = _mapper.Map <Cliente>(clienteViewModel);
await _clienteService.Adicionar(cliente);
return(RedirectToAction("Index"));
}
public ClienteViewModel Adicionar(ClienteViewModel clienteViewModel)
{
var cliente = Mapper.Map <Cliente>(clienteViewModel);
var clienteReturn = _clienteService.Adicionar(cliente);
// Se deu tudo certo no dominio
if (clienteReturn.ValidationResult.IsValid)
{
Commit();
}
clienteViewModel = Mapper.Map <ClienteViewModel>(clienteReturn);
return(clienteViewModel);
}
public ClienteViewModel Adicionar(ClienteViewModel clienteViewModel)
{
var cliente = Mapper.Map <ClienteViewModel, Cliente>(clienteViewModel);
var clienteReturn = _clienteService.Adicionar(cliente);
clienteViewModel = Mapper.Map <Cliente, ClienteViewModel>(clienteReturn);
if (clienteReturn.ValidationResult.IsValid)
{
Commit();
}
return(clienteViewModel);
}
public ClienteViewModel Adicionar(ClienteViewModel ClienteViewModel)
{
var Cliente = Mapper.Map <Cliente>(ClienteViewModel);
var ClienteRet = _ClienteService.Adicionar(Cliente);
if (Cliente.ValidationResult.IsValid)
{
Commit();
ClienteRet.ValidationResult.Message = "Cliente salva com sucesso";
}
ClienteViewModel = Mapper.Map <ClienteViewModel>(ClienteRet);
return(ClienteViewModel);
}
public IActionResult Cadastro(ClienteViewModel model)
{
try
{
if (ModelState.IsValid)
{
_clienteService.Adicionar(model);
return(View());
}
return(View(model));
}
catch (Exception)
{
return(View());
}
}
public ClienteEnderecoViewModel Adicionar(ClienteEnderecoViewModel clienteEnderecoViewModel)
{
var cliente = AutoMapperSingleton.GetInstance().Map <Cliente>(clienteEnderecoViewModel.Cliente);
var endereco = AutoMapperSingleton.GetInstance().Map <Endereco>(clienteEnderecoViewModel.Endereco);
cliente.Enderecos.Add(endereco);
var clienteReturn = _clienteService.Adicionar(cliente);
if (clienteReturn.ValidationResult.IsValid)
{
Commit();
}
clienteEnderecoViewModel.Cliente = AutoMapperSingleton.GetInstance().Map <ClienteViewModel>(clienteReturn);
return(clienteEnderecoViewModel);
}
public ClienteEnderecoViewModel Adicionar(ClienteEnderecoViewModel clienteEnderecoViewModel)
{
var cliente = Mapper.Map <Cliente>(clienteEnderecoViewModel);
var endereco = Mapper.Map <Endereco>(clienteEnderecoViewModel);
cliente.Enderecos.Add(endereco);
var clienteReturn = _clienteService.Adicionar(cliente);
//Verificar se o dominio não criticou nada!
if (clienteReturn.ValidationResult.IsValid)
{
Commit();
}
return(Mapper.Map <ClienteEnderecoViewModel>(clienteReturn));
}
public async Task <IActionResult> Adicionar(ClienteViewModel clienteViewModel)
{
if (!ModelState.IsValid)
{
return(View(clienteViewModel));
}
var cliente = _mapper.Map <Cliente>(clienteViewModel);
await _service.Adicionar(cliente);
if (!OperacaoValida())
{
return(View(clienteViewModel));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Adicionar(ClienteViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var cliente = new Cliente
{
Nome = model.Nome,
Email = model.Email
};
await _servico.Adicionar(cliente);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Get()
{
try {
Cliente c = new Cliente("Manoel", "03403028607");
c.Contato.Add(new Contato()
{
Nome = "jose", Email = "*****@*****.**", Telefone = "959454-02155"
});
c.Contato.Add(new Contato()
{
Nome = "maria", Email = "*****@*****.**", Telefone = "45844-1244"
});
c.Contato.Add(new Contato()
{
Nome = "silvia", Email = "*****@*****.**", Telefone = "87554-1244"
});
_clienteService.Adicionar(c);
var clietne = _clienteService.ObterTodos();
var rng = new Random();
var range = Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = rng.Next(-20, 55),
Summary = Summaries[rng.Next(Summaries.Length)]
})
.ToArray();
return(await ResponseAsync(clietne, _clienteService));
}
catch (Exception e)
{
return(await ResponseExceptionAsync(e));
}
}
public ClienteEnderecoViewModel Adicionar(ClienteEnderecoViewModel clienteEnderecoViewModel)
{
var cliente = Mapper.Map <Cliente>(clienteEnderecoViewModel.Cliente);
var endereco = Mapper.Map <Endereco>(clienteEnderecoViewModel.Endereco);
cliente.DefinirComoAtivo();
cliente.AdicionarEndereco(endereco);
//Repassando a responsabilidade para camada de domínio
var clienteReturn = _clienteService.Adicionar(cliente);
//BeginTransaction();
////blabla
//try
//{
// Commit();
//}
//catch (Exception)
//{
// Rollback();
//}
//add um registro secundário
if (clienteReturn.ValidationResult.IsValid)
{
if (!SaveChanges())
{
AdicionarErrosValidacao(cliente.ValidationResult, "Ocorreu um erro no momento" +
" de salvar");
}
}
if (!clienteReturn.ValidationResult.IsValid)
{
//Devolver validações para a camada de apresentação
clienteEnderecoViewModel.Cliente.ValidationResult =
clienteReturn.ValidationResult;
}
return(clienteEnderecoViewModel);
}
public async Task <ActionResult <ClienteViewModel> > Add(ClienteViewModel clienteViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var cliente = _mapper.Map <Cliente>(clienteViewModel);
if (clienteViewModel.Suporte?.FuncionarioId > 0)
{
cliente.Suporte = await _funcionarioRepository.ObterPorId(clienteViewModel.Suporte.FuncionarioId);
}
await _clienteService.Adicionar(cliente);
return(CustomResponse(clienteViewModel));
}
public ClienteEnderecoViewModel Adicionar(ClienteEnderecoViewModel clienteEnderecoViewModel)
{
var cliente = Mapper.Map <Cliente>(clienteEnderecoViewModel); //TRANSFORMAR O ClienteEnderecoViewModel EM UM CLIENTE
var endereco = Mapper.Map <Endereco>(clienteEnderecoViewModel); //TRANSFORMAR O ClienteEnderecoViewModel EM UM ENDERECO
cliente.Enderecos.Add(endereco);
var clienteReturn = _clienteService.Adicionar(cliente);
//VERIFICAR SE O DOMINIO NÃO CRITICOU NADA
if (clienteReturn.ValidationResult.IsValid)
{
cliente.Ativo = true; //gambi
Commit();
}
return(Mapper.Map <ClienteEnderecoViewModel>(clienteReturn));
}
public async Task <ActionResult <object> > PostCliente(Cliente cliente,
[FromServices] SigningConfigurations signingConfigurations,
[FromServices] TokenConfigurations tokenConfigurations)
{
if (!ModelState.IsValid)
{
return(BadRequest(cliente));
}
await _clienteService.Adicionar(cliente);
if (!OperacaoValida())
{
return(this.BadRequest());
}
return(CreateToken(signingConfigurations, tokenConfigurations, cliente));
}
public async Task <IActionResult> Adicionar(ClienteViewModel clienteViewModel)
{
clienteViewModel = await PopularSolucoes(clienteViewModel);
if (!ModelState.IsValid)
{
return(View(clienteViewModel));
}
var cliente = Mapear(clienteViewModel);
await _clienteService.Adicionar(cliente);
if (!OperacaoValida())
{
return(View(clienteViewModel));
}
return(RedirectToAction(nameof(Index)));
}
