public async Task <IActionResult> Editar(int?id, Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await _departamentoService.FindAllAsync();
var viewModel = new VendedorFormViewModel
{
Vendedor = vendedor,
Departamentos = departamentos
};
return(View(vendedor));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Erro), new { message = "Os Ids são diferentes." }));
}
try
{
await _vendedorService.AtualizarAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (ApplicationException e)
{
return(RedirectToAction(nameof(Erro), new { message = e.Message }));
}
}
public async Task <IActionResult> Edit(int id, Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await _departamentoService.ListarTodosAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departamentos
};
return(View(viewModel));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Id informado não corrependente ao vendedor!" }));
}
try
{
await _vendedorService.UpdateAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (ApplicationException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public async Task <IActionResult> Editar(int id, Vendedor vendedor)
{
if (!ModelState.IsValid)// teste de validação form
{
var departamento = await _departamentoService.FindALLAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departamento
};
return(View(viewModel));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Error), new { Mensagem = "Id não conresponde" }));
}
try
{
await _vendedorService.AtualizarAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (NotFoundException e)
{
return(RedirectToAction(nameof(Error), new { Mensagem = e.Message }));
}
catch (DbConcurrencyException e)
{
return(RedirectToAction(nameof(Error), new { Mensagem = e.Message }));
}
}
public async Task <IActionResult> Edit(int id, Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await _departamento_service.RecuperarTodosAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departamentos
};
return(View(viewModel));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Id não corresponde!" }));
}
try
{
await _vendedoresService.UpdateAsync(vendedor);
return(RedirectToAction(nameof(Index)));
} //pode ser substituído por um application exception. Ele é um super tipo das exceções colocadas abaixo!
catch (NotFoundException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
catch (DbConcurrencyException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public async Task <IActionResult> Edit(int id, Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departmentos = await _departamentoServicos.FindAllAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departmentos
};
return(View(vendedor));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Id mismatch" }));
}
try
{
await _vendedorServices.UpdateAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (NotFoundException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
catch (DbConcurrencyException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public async Task <IActionResult> Editar(int id, Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await _departamentoService.FindAllAsync();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos, Vendedor = vendedor
};
return(View(viewModel));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Error), new { message = "id nao correspondem" }));
}
try
{
await _vendedorService.UpdateAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (ApplicationException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public async Task <IActionResult> EditarVendedor(int id, Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await _departamentoService.ListarDepartamentos();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departamentos
};
return(View(viewModel));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Ids não correspodem" }));
}
try
{
await _vendedorService.Atualizar(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (NotFoundException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
catch (DbConcurrencyException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public async Task <IActionResult> Editar(int id, Vendedor vendedor)
{
// Validação no lado do Servidor caso esteja desabilitado no Cliente (JavaScript)
if (!ModelState.IsValid)
{
var departamentos = await _departamentoService.BuscarTodosAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departamentos
};
return(View(vendedor));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Erro), new { mensagem = "Id não correspondente!" }));
}
try
{
await _vendedorService.AtualizarAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (ApplicationException e)
{
return(RedirectToAction(nameof(Erro), new { mensagem = e.Message }));
}
}
//Get
public IActionResult Create()
{
VendedorFormViewModel vendedorFormViewModel = new VendedorFormViewModel();
vendedorFormViewModel.Departamentos = _serviceDepartamento.BuscaDepartamentos();
return(View(vendedorFormViewModel));
}
public async Task <IActionResult> Edit(int id, Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await _departamentoService.FindAllAsync();
var viewModel = new VendedorFormViewModel()
{
Departamentos = departamentos, Vendedor = vendedor
};
return(View(viewModel));
}
if (id != vendedor.ID)
{
return(RedirectToAction(nameof(Error), new { message = "ID incompatível com o objeto." }));
}
try
{
await _vendedorService.UpdateAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (NotFoundException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
catch (DbConcurrencyException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public async Task <IActionResult> Edit(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Error), new { message = "ID não informado." }));
}
var vend = _vendedorService.FindByIDAsync(id.Value);
if (vend == null)
{
return(RedirectToAction(nameof(Error), new { message = "ID não encontrado." }));;
}
else
{
var departamentos = await _departamentoService.FindAllAsync();
VendedorFormViewModel viewModel = new VendedorFormViewModel()
{
Vendedor = vend.Result, Departamentos = departamentos
};
return(View(viewModel));
}
}
public async Task <IActionResult> Edit(int id, Vendedor vendedor)
{
if (!ModelState.IsValid) // Se o modelo não foi validado
{
var departs = await _departamentoService.FindAllAsync();
VendedorFormViewModel vwModel = new VendedorFormViewModel {
Departamentos = departs, Vendedor = vendedor
};
return(View(vwModel)); // retorna o create repassando minha view model para terminar de consertar
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Error), new { Mensagem = "Id diferentes" }));
}
try
{
await _vendedoresService.UpdateAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (NotFoundException e)
{
return(RedirectToAction(nameof(Error), new { Mensagem = e.Message }));
}
catch (DbConcurrencyException e)
{
return(RedirectToAction(nameof(Error), new { Mensagem = e.Message }));
}
}
public async Task <IActionResult> Edit(int id, Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departmentos = await _servicoDepartamento.AcharTodosAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departmentos
};
return(View(viewModel));
}
if (id != vendedor.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Id não corresponde" }));
}
try
{
await _servicosVendedor.AtualizarAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
catch (ApplicationException e)
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
public IActionResult Create()
{
var departments = _departmentService.FindAll();
var viewModel = new VendedorFormViewModel {
Departamentos = departments
};
return(View(viewModel));
}
public IActionResult Criar()
{
var departamentos = _servicoDepartamento.FindAll();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
};
return(View(viewModel));
}
public async Task <IActionResult> CadVendedor()
{
var departamentos = await _departamentoService.ListarDepartamentos();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
};
return(View(viewModel));
}
public async Task <IActionResult> Create() //abrir o formulario com os departamentos.
{
var departamentos = await _departamentoService.FindAllAsync();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
};
return(View(viewModel));
}
public async Task <IActionResult> Criar()
{
var departamentos = await _departamentoService.BuscarTodosAsync();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
};
return(View(viewModel));
}
// GET: Vendedores/Create
public async Task <IActionResult> Create()
{
var vendedores = await _vendedorService.FindAllAsync();
var vwModel = new VendedorFormViewModel {
Vendedores = vendedores
};
return(View(vwModel));
}
public async Task <IActionResult> Create()
{
var departamentos = await _departamentoServicos.FindAllAsync();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
};
return(View(viewModel));
}
public async Task <IActionResult> Create()// metodo para criar novo Vendedor
{
var departamentos = await _departamentoService.FindALLAsync();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
};
return(View(viewModel));
}
public async Task <IActionResult> Create()
{
var departamentos = await _departamentoService.FinAllAsync(); // Chamando a função q busca todos os departamentos, p/ mostrar na tela.
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
}; // Criando um novo form de vendedor e passando como argumento a lista do metodo acima
return(View(viewModel));
}
public async Task <IActionResult> Create()
{
var departamentos = await _departamento_service.RecuperarTodosAsync();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
};
return(View(viewModel));
}
public async Task <IActionResult> Create()
{
// carregar os todos os departamentos
var departamentos = await _departamentoService.FindAllAsync();
// instanciar um objeto do nosso viewModel
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos
};
return(View(viewModel));
}
public IActionResult Create(Vendedor seller)
{
if (!ModelState.IsValid)
{
var departments = _departmentService.FindAll();
var viewModel = new VendedorFormViewModel {
Vendedor = seller, Departamentos = departments
};
return(View(viewModel));
}
_sellerService.Insert(seller);
return(RedirectToAction(nameof(Index)));
}
[ValidateAntiForgeryToken] // notacao para evitar ataques maliciosos
public async Task <IActionResult> Create(Vendedor vendedor)
{
if (!ModelState.IsValid)// teste de validação form
{
var departamento = await _departamentoService.FindALLAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departamento
};
return(View(viewModel));
}
await _vendedorService.InserirAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Criar(Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await _departamentoService.FindAllAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departamentos
};
return(View(viewModel));
}
await _vendedorService.InsertAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create(Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await _departamento_service.RecuperarTodosAsync();
var viewModel = new VendedorFormViewModel {
Vendedor = vendedor, Departamentos = departamentos
};
return(View(viewModel));
}
await _vendedoresService.InserirAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create(Vendedor vendedor)
{
if (!ModelState.IsValid)
{
var departamentos = await departamentoService.FindAllAsync();
var viewModel = new VendedorFormViewModel {
Departamentos = departamentos, Vendedor = vendedor
};
return(View(viewModel));
}
await vendedorService.AdicionarVendedorAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Create(Vendedor vendedor)
{
if (!ModelState.IsValid) // Se o modelo não foi validado
{
var departs = await _departamentoService.FindAllAsync();
VendedorFormViewModel vwModel = new VendedorFormViewModel {
Departamentos = departs, Vendedor = vendedor
};
return(View(vwModel)); // retorna o create repassando meu obj para terminar de consertar
}
await _vendedoresService.InsertAsync(vendedor);
return(RedirectToAction(nameof(Index)));
}