// GET: Carro/Create
public ActionResult Create()
{
CarroViewModel carroVM = new CarroViewModel();
carroVM.ListaModelos = new SelectList(service.ListarModelosCarro(), "ModeloID", null, carroVM.ModeloCarro);
return(View(carroVM));
}
public IActionResult Editar(int id, CarroViewModel carro)
{
var carroEditar = new Carro(id, carro.Placa, carro.Tipo, carro.Marca, carro.Modelo, carro.Combustivel, carro.Cor, carro.Ano);
if (id != carroEditar.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Editar(carroEditar);
}
catch (DbUpdateConcurrencyException)
{
if (carro == null)
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(carro));
}
public void Execute(CarroViewModel carroViewModel)
{
var carro = mapper.Map <CarroViewModel, CarroModel>(carroViewModel);
carroRepository.Atualizar(carro);
carroRepository.SalvarAlteracoes();
}
public IActionResult Criar(CarroViewModel carro)
{
var carroInsert = new Carro(carro.IDCarro, carro.Placa, carro.Tipo, carro.Marca, carro.Modelo, carro.Combustivel, carro.Cor, carro.Ano);
_context.Inserir(carroInsert);
return(RedirectToAction("Index"));
}
public void Execute(CarroViewModel carroViewModel)
{
var carro = mapper.Map <CarroViewModel, Domain.Models.Carro>(carroViewModel);
carroRepository.Adicionar(carro);
carroRepository.SalvarAlteracoes();
}
/// <summary>
/// Mapeia uma view-model de carro para uma entidade existente
/// </summary>
/// <param name="ent">Entidade existente</param>
/// <param name="model">View-model do carro</param>
public static Carro Map(this Carro ent, CarroViewModel model)
{
ent.Marca = model.Marca;
ent.Modelo = model.Modelo;
ent.Placa = model.Placa;
return(ent);
}
public ActionResult Edit(CarroViewModel dados)
{
try
{
if (ModelState.IsValid)
{
Carro carro = _mapper.Map <CarroViewModel, Carro>(dados);
carroBLL.Atualizar(carro);
_toastNotification.AddSuccessToastMessage();
return(RedirectToAction("Index", "Carro"));
}
PreencheViewBag();
_toastNotification.AddWarningToastMessage("Verifique se todos os campos estão preenchidos corretamente.");
return(View(dados));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
_toastNotification.AddErrorToastMessage();
return(RedirectToAction("Index", "Carro"));
}
}
public void TesteCarroPostEdit()
{
Modelo mod = new Modelo("HILUXDAVOLKSWAGEN", 4, "V9", Categorias.Compacto, TipoCombustivel.Diesel, TipoCambio.Automatico, new Fabricante("VOLKSWAGEN", "Alema"));
Carro c = new Carro {
CarroID = 1, Placa = "ASD1010", Ano = 1990, ModeloCarro = mod, Cor = Cores.Azul
};
CarroViewModel carroVM = Mapper.Map <CarroViewModel>(c);
var mockCtx = new Mock <IContext>();
mockCtx.Setup(x => x.Carros).Returns(new FakeSET <Carro> {
c
});
mockCtx.Setup(x => x.Modelos).Returns(new FakeSET <Modelo> {
mod
});
var mockDAO = new Mock <ICarroDAO>();
var mockDAOMODELO = new Mock <IDAO <Modelo> >();
var carroService = new CarroService(mockDAO.Object, null);
var controller = new CarroController(carroService);
RedirectToRouteResult result = controller.Edit(carroVM) as RedirectToRouteResult;
Assert.AreEqual("Index", result.RouteValues["action"]);
Assert.AreEqual(null, result.RouteValues["controller"]);
}
public async Task <IActionResult> Edit(Guid id, CarroViewModel carroViewModel)
{
if (id != carroViewModel.Id)
{
return(NotFound());
}
var carroAtualizacao = await ObterCarro(id);
if (!ModelState.IsValid)
{
return(View(carroViewModel));
}
carroAtualizacao.Marca = carroViewModel.Marca;
carroAtualizacao.Modelo = carroViewModel.Modelo;
carroAtualizacao.Placa = carroViewModel.Placa.Remove(3, 1);
await _carroService.Atualizar(_mapper.Map <Carro>(carroAtualizacao));
if (!OperacaoValida())
{
return(View(carroViewModel));
}
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> Edit(Guid?id, [Bind("Id,Marca,Modelo,Placa")] CarroViewModel model)
{
if (id != model.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
Carro ent = (await _domain.GetByIdAsync(id.Value));
if (ent == null)
{
return(NotFound());
}
ent = ent.Map(model);
_domain.Update(ent);
await _work.SaveChangesAsync();
}
catch (Exception)
{
if (!CarroViewModelExists(model.Id))
{
return(NotFound());
}
throw;
}
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
public async Task <ActionResult <CarroViewModel> > Post([FromBody] CarroViewModel vm)
{
var item = _mapper.Map <Carro>(vm);
await _carroServico.AdicionarAsync(item);
return(Ok(_mapper.Map <CarroViewModel>(item)));
}
public async Task <IActionResult> Carros()
{
var model = new CarroViewModel {
Carros = await db.Carros.ToListAsync()
};
return(View(model));
}
// GET: Carroes/Create
public ActionResult Create()
{
CarroViewModel cvm = new CarroViewModel();
cvm.marcas = db.Marcas.ToList();
cvm.modelos = db.Modelos.ToList();
return(View(cvm));
}
// GET: Carroes
public ActionResult Index()
{
CarroViewModel cvm = new CarroViewModel();
cvm.carros = db.Carros.Where(c => c.Dono != User.Identity.Name).Where(c => c.Disponivel == true);
cvm.marcas = db.Marcas.ToList();
cvm.modelos = db.Modelos.ToList();
return(View(cvm));
}
/// <summary>
/// Mapeia uma view-model de carro para uma entidade nova
/// </summary>
/// <param name="model">Instância da view-model de carros</param>
public static Carro Map(this CarroViewModel model)
{
return(new Carro()
{
Marca = model.Marca,
Modelo = model.Modelo,
Placa = model.Placa
});
}
public ActionResult Edit([Bind(Include = "IdCarro,NomeCarro,Cor,Tamanho,idFabricante,Ano")] CarroViewModel viewModel)
{
if (ModelState.IsValid)
{
Carro Carro = Mapper.Map <CarroViewModel, Carro>(viewModel);
repositorioCarros.Alterar(Carro);
return(RedirectToAction("Index"));
}
//ViewBag.idFabricante = new SelectList(db.Fabricantes, "Id", "Tipo", Carro.idFabricante);
return(View(viewModel));
}
public ActionResult Create(CarroViewModel carroVM)
{
if (ModelState.IsValid)
{
Carro carro = Mapper.Map <CarroViewModel, Carro>(carroVM);
service.Adicionar(carro);
return(RedirectToAction("Index"));
}
//deu ruim
carroVM.ListaModelos = new SelectList(service.ListarModelosCarro(), "ModeloID", null);
return(View(carroVM));
}
public ActionResult Edit(CarroViewModel carroVM)
{
if (ModelState.IsValid)
{
Carro carro = Mapper.Map <CarroViewModel, Carro>(carroVM);
service.Editar(carro);
return(RedirectToAction("Index"));
}
carroVM.ListaModelos = new SelectList(service.ListarModelosCarro(), "ModeloID", "Nome", carroVM.ModeloID);
//ViewBag.ModeloID = new SelectList(db.Modelos, "ModeloID", "Nome", carro.ModeloID);
return(View(carroVM));
}
public IActionResult Index()
{
var marcas = marcaRepositorio.Listar();
var modelos = modeloRepositorio.Listar();
CarroViewModel carro = new CarroViewModel();
carro.Marcas = marcas;
carro.Modelos = modelos;
return(View(carro));
}
public async Task <IActionResult> Create([Bind("Id,Marca,Modelo,Placa")] CarroViewModel model)
{
if (ModelState.IsValid)
{
await _domain.AddAsync(model.Map());
await _work.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(model));
}
// PUT api/values/5
public async Task <ActionResult <CarroViewModel> > Put([FromBody] CarroViewModel vm)
{
if (await _carroServico.ExisteAsync(vm.Id))
{
var item = _mapper.Map <Carro>(vm);
await _carroServico.AtualizarAsync(item);
return(Ok(_mapper.Map <CarroViewModel>(item)));
}
else
{
return(NotFound(new JsonResult("Id não encontrado")));
}
}
public IActionResult Editar(int id)
{
var carro = _context.ConsultarPorID(id);
if (carro == null)
{
return(NotFound());
}
var carroViewModel = new CarroViewModel {
IDCarro = carro.Id, Placa = carro.Placa, Tipo = carro.Tipo, Marca = carro.Marca, Modelo = carro.Modelo, Combustivel = carro.Combustivel, Cor = carro.Cor, Ano = carro.Ano
};
return(View(carroViewModel));
}
//[CustomRoleProvider.AccessDeniedAuthorize(Roles = "UsuarioIncluir")]
public ActionResult Create()
{
try
{
CarroViewModel dados = new CarroViewModel();
return(View(dados));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
_toastNotification.AddErrorToastMessage();
return(RedirectToAction("Index", "Carro"));
}
}
public async Task <IActionResult> Create(CarroViewModel carroViewModel)
{
if (!ModelState.IsValid)
{
return(View(carroViewModel));
}
var carro = _mapper.Map <Carro>(carroViewModel);
await _carroService.Adicionar(carro);
if (!OperacaoValida())
{
return(View(carroViewModel));
}
return(RedirectToAction(nameof(Index)));
}
// GET: Carro/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
Carro carro = service.Buscar(id);
CarroViewModel carroVM = Mapper.Map <Carro, CarroViewModel>(carro);
return(View(carroVM));
}
catch (BusinessException ex)
{
return(HttpNotFound(ex.Message));
}
}
/// <summary>
/// Mapeia uma entidade para uma view-model de listagem
/// </summary>
/// <param name="entity">Instância da entidade</param>
public static ManobraViewModel Map(this Manobra entity)
{
CarroViewModel carroModel = entity.Carro.Map();
ManobristaViewModel manobristaModel = entity.Manobrista.Map();
ManobraViewModel manobraModel = new ManobraViewModel()
{
Id = entity.Id,
Entrada = entity.Entrada,
Saida = entity.Saida,
CarroId = entity.CarroId,
ManobristaId = entity.ManobristaId,
Carro = carroModel,
Manobrista = manobristaModel
};
return(manobraModel);
}
public async Task <ActionResult <CarroViewModel> > AdicionarCarro(CarroViewModel carroViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var carro = await _carroRepository.ObterPorId(carroViewModel.Id);
if (carro != null)
{
return(BadRequest("Carro já existente. Informar ID único, por favor"));
}
await _carroRepository.Adicionar(_mapper.Map <Carro>(carroViewModel));
return(Ok(carroViewModel));
}
// GET: Carro/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
Carro carro = service.Buscar(id);
CarroViewModel carroVM = Mapper.Map <Carro, CarroViewModel>(carro);
carroVM.ListaModelos = new SelectList(service.ListarModelosCarro(), "ModeloID", "Nome", carroVM.ModeloID);
return(View(carroVM));
}
catch (BusinessException)
{
return(HttpNotFound());
}
}
public ActionResult Edit(int id)
{
try
{
Carro carro = carroBLL.ObterPorId(id);
CarroViewModel dados = _mapper.Map <Carro, CarroViewModel>(carro);
PreencheViewBag();
return(View(dados));
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
_toastNotification.AddErrorToastMessage();
return(RedirectToAction("Index", "Carro"));
}
}
public async Task <ActionResult <CarroViewModel> > AtualizarCarro(Guid id, CarroViewModel carroViewModel)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (id != carroViewModel.Id)
{
return(BadRequest("ID da URL está diferente do Body"));
}
await _carroRepository.Atualizar(_mapper.Map <Carro>(carroViewModel));
return(Ok(new
{
success = true,
mensagem = "Carro atualizado com sucesso",
data = carroViewModel
}));
}
