Example #1
0
        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(viewModel));
            }
            if (id != vendedor.Id)
            {
                return(RedirectToAction(nameof(Error), new { message = "Id não corresponde" }));
            }
            try
            {
                await _vendedorService.AtualizarAsync(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 }));
            }
        }
        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 }));
            }
        }
Example #4
0
        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(viewModel));
            }

            if (id != vendedor.Id)
            {
                return(RedirectToAction(nameof(Erro), new { mensagem = "Id não correspondente" }));;
            }
            try
            {
                await _vendedorService.AtualizarAsync(vendedor);

                return(RedirectToAction(nameof(Index)));
            }
            //Utilizando a superclasse para evitar a mesma mensagem de erro dos dois catchs abaixo comentado
            catch (ApplicationException e)
            {
                return(RedirectToAction(nameof(Erro), new { mensagem = e.Message }));
            }

            /*
             * catch (NotFoundException e)
             * {
             *  return RedirectToAction(nameof(Erro), new { mensagem = e.Message });
             * }
             * catch (DbConcurrencyException e)
             * {
             *  return RedirectToAction(nameof(Erro), new { mensagem = e.Message }); ;
             * }*/
        }
        public async Task <IActionResult> Edit(int id, VendedorFormViewModel obj)
        {
            if (!ModelState.IsValid)
            {
                return(View(obj));
            }

            if (id != obj.Vendedor.Id)
            {
                return(RedirectToAction(nameof(Error), new { message = "Id não correspondem" }));
            }

            try
            {
                await vendedorService.AtualizarAsync(obj.Vendedor);

                return(RedirectToAction(nameof(Index)));
            }
            catch (ApplicationException e)
            {
                return(RedirectToAction(nameof(Error), new { message = e.Message }));
            }
        }