public ActionResult Create(ClienteViewModel cliente)
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(cliente);
_clienteApp.Add(clienteDomain);
return(RedirectToAction("Index")); // adicionar e retornar para a pagina inicial
}
return(View()); // retornar para a mesma view os dados preenchidos
}
public ActionResult Create(ClienteViewModel clienteViewModel)
{
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(clienteViewModel);
_clienteApp.Add(clienteDomain);
return(RedirectToAction("Index"));
}
return(View(clienteViewModel));
}
//[ValidateAntiForgeryToken]
public IActionResult Create(ClienteEnderecoViewModel cliente)
{
string erroMensagem = "";
if (!ModelState.IsValid)
{
foreach (var item in ModelState.Values.SelectMany(v => v.Errors).ToList())
{
erroMensagem += string.Format("{0}<br>", item.ErrorMessage);
}
return(BadRequest(erroMensagem));
}
var clienteResult = _clienteAppService.Add(cliente);
//return RedirectToAction(nameof(Index));
if (clienteResult.IsValid)
{
ViewBag.ClienteId = cliente.ClienteId.ToString();
return(Json(new { ClienteId = cliente.ClienteId }));
}
else
{
foreach (var item in clienteResult.Erros.OrderBy(e => e.Message))
{
erroMensagem += string.Format("{0}<br>", item.Message);
}
return(BadRequest(erroMensagem));
}
}
public ActionResult Salvar(ClienteViewModel model)
{
if (!ModelState.IsValid)
{
return(View("FormCliente", model));
}
try
{
if (model.Id == 0)
{
_clienteAppService.Add(Mapper.Map <ClienteViewModel, Cliente>(model));
}
else
{
_clienteAppService.Update(Mapper.Map <ClienteViewModel, Cliente>(model));
}
}
catch (Exception)
{
return(View("FormCliente", model));
}
return(RedirectToAction("Index"));
}
public IHttpActionResult PostCliente(ClienteViewModel cliente)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
_service.Add(cliente);
}
catch (DbUpdateException)
{
if (Exists(cliente.ClienteId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = cliente.ClienteId }, cliente));
}
public ActionResult <ClienteDTO> Add([FromBody] RegistrarClienteViewModel registrarCliente)
{
try
{
var generarIdUsuario = _usuarioAppService.GenerarCodigo();
UsuarioDTO usuarioDTO = new UsuarioDTO
{
IdUsuario = generarIdUsuario,
NombreUsuario = registrarCliente.nombreUsuario,
Contraseña = registrarCliente.contraseña
};
_usuarioAppService.Add(usuarioDTO);
ClienteDTO cliente = new ClienteDTO
{
Nombre = registrarCliente.Nombre,
Direccion = registrarCliente.Direccion,
Telefono = registrarCliente.Telefono,
NombreContacto = registrarCliente.NombreContacto,
Distrito = registrarCliente.Distrito,
Estado = "A",
IdUsuario = generarIdUsuario
};
cliente.IdCliente = _clienteAppService.GenerarCodigo();
_clienteAppService.Add(cliente);
_clienteAppService.Save();
return(CreatedAtAction(nameof(Add), new { id = cliente.IdCliente }, cliente));
}
catch (Exception)
{
return(BadRequest());
}
}
public ActionResult Create(ClienteViewModel cliente)
{
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(cliente);
_clienteApp.Add(clienteDomain);
return(RedirectToAction("Index"));
}
public IHttpActionResult Post([FromBody] ClientViewModel cliente)
{
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <ClientViewModel, Client>(cliente);
_clienteApp.Add(clienteDomain);
cliente.Id = clienteDomain.Id;
return(Ok(cliente));
}
return(BadRequest(ModelState));
}
public ActionResult Create([Bind(Include = "ClienteId,Nome,Cpf")] ClienteViewModel clienteViewModel)
{
if (ModelState.IsValid)
{
clienteViewModel.ClienteId = Guid.NewGuid();
_service.Add(clienteViewModel);
return(RedirectToAction("Index"));
}
return(View(clienteViewModel));
}
public ActionResult Create(ClienteModel clienteModel)
{
if (ModelState.IsValid)
{
var cliente = new ClienteTransformation().TransformarClienteModelEmCliente(clienteModel);
_clienteApp.Add(cliente);
return(RedirectToAction("Index"));
}
return(View(clienteModel));
}
//[Authorize(Roles = "User")]
public HttpResponseMessage Insert(Cliente entity)
{
try
{
_clienteApp.Add(entity);
return(Request.CreateResponse(HttpStatusCode.OK));
}
catch
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError));
}
}
public ActionResult Create(ClienteViewModel cliente)
{
if (!ModelState.IsValid)
{
return(View(cliente));
}
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(cliente);
_clienteApp.Add(clienteDomain);
return(RedirectToAction("Details", clienteDomain.ClienteId));
}
public ActionResult Create(ClienteViewModel cliente)
{
// TODO: Add insert logic here
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(cliente);
_clientApp.Add(clienteDomain);
return(RedirectToAction("Index"));
}
return(View());
}
public ActionResult Create(ClienteViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(model);
_clienteAppService.Add(clienteDomain);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Add(Cliente cliente)
{
try
{
cliente = await _clienteAppService.Add(cliente);
return(Ok(cliente));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult Create(ClienteViewModel clienteViewModel)
{
try
{
var model = Mapper.Map <ClienteViewModel, Cliente>(clienteViewModel);
_clienteApp.Add(model);
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(View());
}
}
public ActionResult Create(ClienteViewModel cliente)
{
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(cliente);
_clienteApp.Add(clienteDomain);
TempData["success"] = "Paciente cadastrado com sucesso.";
return(RedirectToAction("Index"));
}
return(View(cliente));
}
public ActionResult Create(ClienteViewModel clienteViewModel, HttpPostedFileBase Imagem)
{
if (!ModelState.IsValid)
{
return(View(clienteViewModel));
}
clienteViewModel.ClienteId = Guid.NewGuid();
var cliente = _clienteAppService.Add(clienteViewModel);
SalvarImagemCliente(Imagem, cliente);
return(RegistarClienteParaFazerLogin(cliente, out var actionResult)
? actionResult
: RedirectToAction("Index"));
}
public void Post(ClienteViewModel clienteViewModel)
{
if (clienteViewModel.Nome != null && clienteViewModel.Email != null)
{
var cliente = Mapper.Map <ClienteViewModel, Cliente>(clienteViewModel);
if (clienteViewModel.ClienteId == 0)
{
_clienteApp.Add(cliente);
}
else
{
_clienteApp.Update(cliente);
}
}
}
public ActionResult Cadastrar(ClienteEnderecoViewModel clienteEnderecoViewModel)
{
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <Cliente> (clienteEnderecoViewModel.ClienteViewModel);
var enderecoDomain = Mapper.Map <Endereco>(clienteEnderecoViewModel.EnderecoViewModel);
clienteDomain.Endereco = enderecoDomain;
_clienteApp.Add(clienteDomain);
return(RedirectToAction("Index"));
}
return(View(clienteEnderecoViewModel));
}
public async Task<HttpResponseMessage> Post([FromBody]Cliente cliente)
{
try
{
await _clienteAppService.Add(cliente);
NotificationHub.SendMessageNew(string.Format("Cadastro de cliente efetuado com Sucesso {0}-{1}", cliente.NomeCliente, cliente.ClienteId));
return await Task.Factory.StartNew(() => new HttpResponseMessage { StatusCode = HttpStatusCode.OK });
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Create(CadastroPFViewModel p_ClienteViewModel, FormCollection p_FormCollection)
{
try
{//ClienteID é obrigatório
if (ModelState.IsValid)
{
p_ClienteViewModel.Cliente.GeneroID = Convert.ToInt32(p_FormCollection["GeneroID"]);
p_ClienteViewModel.Cliente.ComoSerTratadoID = Convert.ToInt32(p_FormCollection["ComoSerTratadoID"]);
p_ClienteViewModel.Cliente.ComplementoID = Convert.ToInt32(p_FormCollection["ComplementoID"]);
p_ClienteViewModel.Cliente.CidadeID = Convert.ToInt32(p_FormCollection["CidadeID"]);
p_ClienteViewModel.Cliente.EstadoID = Convert.ToInt32(p_FormCollection["EstadoID"]);
ClienteViewModel v_ClienteViewModel = p_ClienteViewModel.Cliente;
CartaoCreditoViewModel v_CartaoViewModel = p_ClienteViewModel.CartaoCredito;
EnderecoInformacaoViewModel v_EndeerecoViewModel = p_ClienteViewModel.EnderecoInformacao;
v_ClienteViewModel.DataCadastro = DateTime.Now;
Cliente v_Cliente = Mapper.Map <ClienteViewModel, Cliente>(v_ClienteViewModel);
CartaoCredito v_CartaoCredito = Mapper.Map <CartaoCreditoViewModel, CartaoCredito>(v_CartaoViewModel);
EnderecoInformacao v_Endereco = Mapper.Map <EnderecoInformacaoViewModel, EnderecoInformacao>(v_EndeerecoViewModel);
_ClienteAppService.Add(v_Cliente);
v_CartaoCredito.ClienteID = v_Cliente.ClienteID;
_CartaoCreditoAppService.Add(v_CartaoCredito);
v_Endereco.ClienteID = v_Cliente.ClienteID;
_EnderecoAppService.Add(v_Endereco);
return(RedirectToAction("Index"));
}
ViewBag.GeneroID = new SelectList(Util.Util.ListGenero(), "Value", "Text", p_ClienteViewModel.Cliente.GeneroID);
ViewBag.ComoSerTratadoID = new SelectList(Util.Util.ListComoTratar(), "Value", "Text", p_ClienteViewModel.Cliente.ComoSerTratadoID);
ViewBag.ComplementoID = new SelectList(Util.Util.ListComplemento(), "Value", "Text", p_ClienteViewModel.Cliente.ComplementoID);
ViewBag.CidadeID = new SelectList(_CidadeAppService.GetAll(), "CidadeID", "Descricao", p_ClienteViewModel.Cliente.CidadeID);
ViewBag.EstadoID = new SelectList(_EstadoAppService.GetAll(), "EstadoID", "Descricao", p_ClienteViewModel.Cliente.EstadoID);
return(View(p_ClienteViewModel));
}
catch (Exception ex)
{
return(View());
}
}
public ActionResult Create(ClienteViewModel cliente)
{
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(cliente);
var result = _clienteApp.Add(clienteDomain);
if (result.Success)
{
return(RedirectToAction("Index"));
}
foreach (var error in result.ErrorsMessage)
{
ModelState.AddModelError("", error);
}
}
return(View(cliente));
}
public async Task <IActionResult> Create(CreateClienteViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
await _clienteAppService.Add(_mapper.Map <Cliente>(model));
if (!OperacaoValida())
{
return(View(model));
}
TempData["Sucesso"] = "Cliente cadastrado com sucesso!";
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create(ClienteViewModel clienteVM)
{
if (ModelState.IsValid)
{
var clienteObj = _mapper.Map <Cliente>(clienteVM);
if (await _clienteAppService.Add(clienteObj))
{
return(RedirectToAction(nameof(Index)));
}
else
{
ModelState.AddModelError("", $"Something went wrong when saving the record {clienteVM.Nome}");
}
}
return(View(clienteVM));
}
public ActionResult Insert([FromBody] Cliente cliente)
{
try
{
if (cliente == null)
{
return(NoContent());
}
_clienteAppService.Add(cliente);
return(Ok());
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Create(ClienteViewModel cliente)
{
try
{
if (ModelState.IsValid)
{
var clienteDomain = Mapper.Map <ClienteViewModel, Cliente>(cliente);
_clienteAppService.Add(clienteDomain);
return(RedirectToAction("Index"));
}
return(View(cliente));
}
catch
{
return(View());
}
}
async private void AdicionarCliente()
{
var cliente = new ClienteViewModel
{
Id = 0,
NomeFantasia = tbxNome.Text,
RazaoSocial = tbxRazSoc.Text,
Cnpj = tbxCpfCnpj.Text,
RamoAtividade = tbxRamAtiv.Text,
Endereco = tbxEndereco.Text,
Numero = int.Parse(tbxNumero.Text),
Bairro = tbxBairro.Text,
Cidade = tbxCidade.Text,
Estado = cbxEnderecoEstado.Text,
Cep = tbxCep.Text
};
_clienteApp.Add(cliente);
}
public ActionResult Create(ClienteViewModel cliente)
{
var clienteCreate = Mapper.Map <ClienteViewModel, Cliente>(cliente);
if (_clienteApp.CadastroRepetido(clienteCreate) == true)
{
return(View());
}
else
if (_clienteApp.ClienteNaoAtivo(clienteCreate) == true)
{
return(View());
}
else
{
_clienteApp.Add(clienteCreate);
}
return(RedirectToAction("Index"));
}
public HttpResponseMessage Post(ClienteHorarioViewModel clienteHorario)
{
if (ModelState.IsValid)
{
if (clienteHorario.IsAtivo)
{
if (clienteHorario.HSegunda == null && clienteHorario.HTerca == null && clienteHorario.HQuarta == null &&
clienteHorario.HQuinta == null && clienteHorario.HSexta == null)
{
ModelState.AddModelError(string.Empty, "Informe o horário de treino");
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
var result = _clienteApp.Add(clienteHorario);
if (!result.IsValid)
{
foreach (var validationAppError in result.Erros)
{
ModelState.AddModelError(string.Empty, validationAppError.Message);
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
if (clienteHorario.Foto != null)
{
//Convert and Upload image
ConvertAndSave(clienteHorario.Foto, clienteHorario.ClienteId);
clienteHorario.Path = "/assets/images/fotos/" + clienteHorario.ClienteId + ".jpg";
_clienteApp.Update(clienteHorario);
}
return(Request.CreateResponse(HttpStatusCode.Created, clienteHorario.ClienteId));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
