public IActionResult Form([FromQuery] AccionesCRUD accionCRUD, int?Id)
{
try
{
if (accionCRUD.Equals(AccionesCRUD.AGREGAR) || accionCRUD.Equals(AccionesCRUD.MODIFICAR))
{
ViewData["accionCRUD"] = accionCRUD;
if (accionCRUD.Equals(AccionesCRUD.AGREGAR))
{
return(View());
}
if (accionCRUD.Equals(AccionesCRUD.MODIFICAR))
{
ModeloDTO modeloDTO = this._modeloService.getModelo((int)Id);
ModeloViewModel modeloViewModel = this._mapper.Map <ModeloViewModel>(modeloDTO);
return(View(modeloViewModel));
}
}
throw new Exception("Ocurrio un error inesperado.");
}
catch (Exception ex)
{
ViewBag.error = ex.Message;
return(View());
}
}
public List <ModeloViewModel> GetModelByIdMake(int id)
{
try
{
var modelos = _anuncioServices.GetModelByIdMake(id);
var listaModelos = new List <ModeloViewModel>();
foreach (var item in modelos)
{
var modelo = new ModeloViewModel()
{
ID = item.ID,
Nome = item.Name,
};
listaModelos.Add(modelo);
}
return(listaModelos);
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult Modificar(ModeloViewModel p_modeloVM)
{
try
{
if (!ModelState.IsValid)
{
throw new Exception("Error al validar datos.");
}
else
{
ModeloDTO modeloDTO = this._mapper.Map <ModeloViewModel, ModeloDTO>(p_modeloVM);
int result = this._modeloService.ModificarModelo(modeloDTO);
ViewBag.result = "Accion realizada con exito.";
List <ModeloViewModel> listmodeloViewModel = this._modeloService.getModelos()
.Select(x => this._mapper.Map <ModeloDTO, ModeloViewModel>(x))
.ToList();
return(View("index", listmodeloViewModel));
}
}
catch (Exception ex)
{
ViewBag.error = ex.InnerException.Message;
ViewData["accionCRUD"] = AccionesCRUD.MODIFICAR;
return(View("form", p_modeloVM));
}
}
/// <summary>
/// Chama o metodo responsavel para deletar um modelo
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BtnDeletar_Click(object sender, RoutedEventArgs e)
{
if (dataModelos.SelectedItems.Count > 1)
{
IList <Modelo> listaDeletar = new List <Modelo>();
foreach (Modelo modelo in dataModelos.SelectedItems)
{
listaDeletar.Add(modelo);
}
if (MessageBox.Show("Deseja deletar os " + listaDeletar.Count + " modelos selecionados?", "Confirmar deletar.", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
foreach (Modelo modelo in listaDeletar)
{
ModeloViewModel.ModeloSelecionado = modelo;
ModeloViewModel.DeletarComando(true);
}
}
}
else
{
if (ModeloViewModel.ModeloSelecionado.IdModelo > 0)
{
if (MessageBox.Show("Deseja deletar este modelo?", "Confirmar deletar.", MessageBoxButton.YesNo) == MessageBoxResult.Yes)
{
ModeloViewModel.DeletarComando();
}
}
}
LimparModelo();
}
public ActionResult Importar(ModeloViewModel viewModel)
{
if (viewModel.Id == 0)
{
ModelState.AddModelError(string.Empty, "Nenhum modelo selecionado");
}
var modeloBusca = _modeloRepositorio.ObterModeloPorId(viewModel.Id);
if (modeloBusca == null)
{
RegistroNaoEncontrado();
}
var modelo = new Modelo(
modeloBusca.TipoOperacao,
viewModel.Descricao,
modeloBusca.Status,
modeloBusca.FormaPagamento,
modeloBusca.DiasFreeTime,
modeloBusca.QtdeDias,
modeloBusca.Validade,
modeloBusca.TipoValidade,
modeloBusca.TipoServico,
modeloBusca.VendedorId,
modeloBusca.ImpostoId,
modeloBusca.Acordo,
modeloBusca.Escalonado,
modeloBusca.ParametroLote,
modeloBusca.ParametroBL,
modeloBusca.ParametroConteiner,
modeloBusca.ParametroIdTabela,
modeloBusca.HubPort,
modeloBusca.CobrancaEspecial,
modeloBusca.IntegraChronos,
modeloBusca.Simular,
modeloBusca.DesovaParcial,
modeloBusca.FatorCP,
modeloBusca.PosicIsento);
Validar(modelo);
if (modelo.Valido)
{
var id = _modeloRepositorio.Cadastrar(modelo);
_layoutRepositorio.ImportarLayout(id, modeloBusca.Id);
TempData["Sucesso"] = true;
}
var modelos = _modeloRepositorio.ObterModelos();
ViewBag.Modelos = modelos.Select(c => new Modelo
{
Id = c.Id,
Descricao = c.Descricao
});
return(View(viewModel));
}
public ActionResult GuardarModelo(Modelo modelo)
{
if (!ModelState.IsValid)
{
var viewModel = new ModeloViewModel(modelo)
{
Marcas = _context.Marcas.ToList()
};
return(View("ModeloFormulario", viewModel));
}
if (modelo.Id == 0)
{
_context.Modelos.Add(modelo);
}
else
{
var modeloBD = _context.Modelos.Single(m => m.Id == modelo.Id);
Mapper.Map <Modelo, Modelo>(modelo, modeloBD);
}
_context.SaveChanges();
return(RedirectToAction("Index"));
}
// GET: Modelo/Create
public ActionResult Create()
{
ModeloViewModel modeloVM = new ModeloViewModel();
modeloVM.ListaFabricantes = new SelectList(service.ListarFabricantes(), "FabricanteID", null, modeloVM.Fabricante);
return(View(modeloVM));
}
private HttpResponseMessage ValidarDados(ModeloViewModel modelo)
{
if (!ModelState.IsValid)
{
JsonResult.Message = String.Join(" ", ModelState.Values.SelectMany(value => value.Errors).Select(x => x.ErrorMessage));
return(Request.CreateResponse(HttpStatusCode.PreconditionFailed, JsonResult));
}
var modeloDM = _modeloAplicacao.BuscarPor(x => x.Descricao.ToLower() == modelo.Descricao.ToLower()).FirstOrDefault();
if (modeloDM != null)
{
var modeloVM = AutoMapper.Mapper.Map <Modelo, ModeloViewModel>(modeloDM);
JsonResult.Message = "Modelo ja Cadastrado!";
JsonResult.Object = modeloVM;
return(Request.CreateResponse(HttpStatusCode.PreconditionFailed, JsonResult));
}
var marcaDM = _marcaoAplicacao.BuscarPorId(modelo.Marca.Id);
if (marcaDM == null)
{
JsonResult.Message = "Marca não existe em nosso sistema, inserir Id correto!";
return(Request.CreateResponse(HttpStatusCode.PreconditionFailed, JsonResult));
}
return(null);
}
public ActionResult Edit(ModeloViewModel modeloVM)
{
if (ModelState.IsValid)
{
Modelo modelo = Mapper.Map <ModeloViewModel, Modelo>(modeloVM);
service.Editar(modelo);
return(RedirectToAction("Index"));
}
modeloVM.ListaFabricantes = new SelectList(service.ListarFabricantes(), "FabricanteID", "Nome", modeloVM.ModeloID);
return(View(modeloVM));
}
public ActionResult NuevoModelo()
{
var marcas = _context.Marcas.ToList();
var viewModel = new ModeloViewModel
{
Marcas = marcas
};
return(View("ModeloFormulario", viewModel));
}
public ActionResult Create(ModeloViewModel modeloVM)
{
if (ModelState.IsValid)
{
Modelo modelo = Mapper.Map <ModeloViewModel, Modelo>(modeloVM);
service.Adicionar(modelo);
return(RedirectToAction("Index"));
}
//deu ruim
modeloVM.ListaFabricantes = new SelectList(service.ListarFabricantes(), "FabricanteID", null);
return(View(modeloVM));
}
public ActionResult Edit(ModeloViewModel modelo)
{
if (ModelState.IsValid)
{
var modeloDomain = _mapper.Map <ModeloViewModel, Modelo>(modelo);
_modeloApp.Update(modeloDomain);
return(RedirectToAction("Index"));
}
return(View(modelo));
}
public ItemDePlanoComercialViewModel AdicionaItem(ModeloViewModel modelo)
{
var model = planoComercial.model.AdicionaItem(modelo.GetModel());
var viewModel = ItemDePlanoComercialViewModel.From(model, repositorioDePlanosComerciais, repositorioDeModelos);
viewModel.itemDePlanoComercial = model;
Add(viewModel);
return(viewModel);
}
public ActionResult Cadastrar(ModeloViewModel model)
{
var mod = new ModeloMOD()
{
MarcaId = model.Modelo.MarcaId,
Nome = model.Modelo.Nome
};
_repModelo.Cadastrar(mod);
TempData["msg"] = "Cadastrado com sucesso!";
return(RedirectToAction("Index", new { id = mod.MarcaId }));
}
public ActionResult Cadastrar()
{
var viewModel = new ModeloViewModel
{
Status = Status.ATIVO,
TipoValidade = TipoValidade.ANOS
};
PopularVendedores(viewModel);
PopularImpostos(viewModel);
return(View(viewModel));
}
public ActionResult Cadastrar(ModeloViewModel model)
{
if (!ModelState.IsValid)
{
return(Index(model.Modelo.Id));
}
var mod = ModeloModel_To_ModeloMOD(model.Modelo);
_modeloRepository.Cadastrar(mod);
TempData["msg"] = "Modelo cadastrado com sucesso";
return(RedirectToAction("Index", new { marcaId = model.Modelo.MarcaId }));
}
public ActionResult Cadastrar([Bind(Include = "TipoOperacao, Descricao, Status, FormaPagamento, DiasFreeTime, QtdeDias, Validade, TipoValidade, VendedorId, ImpostoId, Acordo, Escalonado, ParametroBL, ParametroLote, ParametroConteiner, ParametroIdTabela, HubPort, CobrancaEspecial, DesovaParcial, FatorCP, PosicIsento, TipoServico")] ModeloViewModel viewModel)
{
var modeloBusca = _modeloRepositorio.ObterModeloPorDescricao(viewModel.Descricao);
if (modeloBusca != null)
{
ModelState.AddModelError(string.Empty, "Já existe um modelo cadastrado com a mesma descrição.");
}
if (ModelState.IsValid)
{
var modelo = new Modelo(
viewModel.TipoOperacao,
viewModel.Descricao,
viewModel.Status,
viewModel.FormaPagamento,
viewModel.DiasFreeTime,
viewModel.QtdeDias,
viewModel.Validade,
viewModel.TipoValidade,
viewModel.TipoServico,
viewModel.VendedorId,
viewModel.ImpostoId,
viewModel.Acordo,
viewModel.Escalonado,
viewModel.ParametroLote,
viewModel.ParametroBL,
viewModel.ParametroConteiner,
viewModel.ParametroIdTabela,
viewModel.HubPort,
viewModel.CobrancaEspecial,
viewModel.IntegraChronos,
viewModel.Simular,
viewModel.DesovaParcial,
viewModel.FatorCP,
viewModel.PosicIsento);
if (Validar(modelo))
{
modelo.Id = _modeloRepositorio.Cadastrar(modelo);
TempData["Sucesso"] = true;
GravarLogAuditoria(TipoLogAuditoria.INSERT, modelo);
}
}
PopularVendedores(viewModel);
PopularImpostos(viewModel);
return(View(viewModel));
}
public ActionResult Atualizar(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var modelo = _modeloRepositorio.ObterModeloPorId(id.Value);
if (modelo == null)
{
RegistroNaoEncontrado();
}
var viewModel = new ModeloViewModel
{
Id = modelo.Id,
Descricao = modelo.Descricao,
DiasFreeTime = modelo.DiasFreeTime,
QtdeDias = modelo.QtdeDias,
Status = modelo.Status,
TipoOperacao = modelo.TipoOperacao,
Validade = modelo.Validade,
TipoValidade = modelo.TipoValidade,
FormaPagamento = modelo.FormaPagamento,
ImpostoId = modelo.ImpostoId,
VendedorId = modelo.VendedorId,
Acordo = modelo.Acordo,
Escalonado = modelo.Escalonado,
ParametroBL = modelo.ParametroBL,
ParametroLote = modelo.ParametroLote,
ParametroIdTabela = modelo.ParametroIdTabela,
ParametroConteiner = modelo.ParametroConteiner,
HubPort = modelo.HubPort,
CobrancaEspecial = modelo.CobrancaEspecial,
DesovaParcial = modelo.DesovaParcial,
FatorCP = modelo.FatorCP,
PosicIsento = modelo.PosicIsento,
TipoServico = modelo.TipoServico,
IntegraChronos = modelo.IntegraChronos,
Simular = modelo.Simular
};
PopularVendedores(viewModel);
PopularImpostos(viewModel);
PopularModelosSimulador(viewModel);
PopularVinculosModelosSimulador(viewModel);
return(View(viewModel));
}
/// <summary>
/// Chama os metodos responsaveis por salvar o cliente e
/// editar os modelos de cada venda deste cliente
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void BtnSalvarCliente_Click(object sender, RoutedEventArgs e)
{
foreach (Venda venda in PessoaViewModel.ClienteSelecionado.Compras)
{
if (venda.IdVenda == 0)
{
ModeloViewModel.ModeloSelecionado = venda.Modelo;
ModeloViewModel.SalvarComando(true);
}
}
PessoaViewModel.SalvarComando();
VendaViewModel.CarregarComando();
LimparCliente();
}
public ActionResult NuevoModelo()
{
var marcas = _context.Marcas.ToList();
var cilindradas = _context.Cilindradas.ToList();
var tipoMotores = _context.TiposMotores.ToList();
var viewModel = new ModeloViewModel
{
Marcas = marcas,
Cilindradas = cilindradas,
TiposMotores = tipoMotores
};
return(View("ModeloFormulario", viewModel));
}
public ActionResult EditarModelo(int id)
{
var modeloBD = _context.Modelos.SingleOrDefault(c => c.Id == id);
if (modeloBD == null)
{
return(HttpNotFound());
}
var modelo = new ModeloViewModel(modeloBD)
{
Marcas = _context.Marcas.ToList()
};
return(View("ModeloFormulario", modelo));
}
// GET: Modelo/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
Modelo modelo = service.Buscar(id);
ModeloViewModel modeloVM = Mapper.Map <Modelo, ModeloViewModel>(modelo);
return(View(modeloVM));
}
catch (BusinessException ex)
{
return(HttpNotFound(ex.Message));
}
}
public async Task <IActionResult> Edit(Guid id, ModeloViewModel modeloViewModel)
{
if (id != modeloViewModel.Id)
{
return(NotFound());
}
if (ModelState.IsValid == false)
{
return(View(modeloViewModel));
}
var modelo = _mapper.Map <Modelo>(modeloViewModel);
await _modeloService.Update(modelo);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(ModeloViewModel modeloViewModel)
{
if (ModelState.IsValid == false)
{
return(View(modeloViewModel));
}
var modelo = _mapper.Map <Modelo>(modeloViewModel);
await _modeloService.Insert(modelo);
if (OperacaoValida() == false)
{
return(View(modeloViewModel));
}
return(RedirectToAction("Index"));
}
public ActionResult Index(int id)
{
//pesquisa a marca
var marca = new MarcaModel(_repMarca.Buscar(id));
//instancia a view model com as informações para a tela
var viewModel = new ModeloViewModel()
{
NomeMarca = marca.Nome,
Lista = _repModelo.Listar(id).Select(c => new ModeloModel(c)).ToList(),
Modelo = new ModeloModel()
{
MarcaId = marca.Id
}
};
//envia o view model para a tela
return(View(viewModel));
}
// GET: Modelo/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
try
{
Modelo modelo = service.Buscar(id);
ModeloViewModel modeloVM = Mapper.Map <Modelo, ModeloViewModel>(modelo);
modeloVM.ListaFabricantes = new SelectList(service.ListarFabricantes(), "FabricanteID", "Nome", modeloVM.ModeloID);
return(View(modeloVM));
}
catch (BusinessException)
{
return(HttpNotFound());
}
}
public ActionResult Index(int marcaId)
{
var marca = _marcaRepository.Buscar(marcaId);
var listaModeloModel = new List <ModeloModel>();
var listaModeloMOD = _modeloRepository.Listar(marcaId);
listaModeloMOD.ToList().ForEach(m => listaModeloModel.Add(new ModeloModel(m)));
var modeloViewModel = new ModeloViewModel()
{
NomeMarca = marca.Nome,
Lista = listaModeloModel,
Modelo = new ModeloModel()
{
MarcaId = marca.Id
}
};
return(View(modeloViewModel));
}
public static ItemDePlanoComercialViewModel From(ItemDePlanoComercial itemDePlanoComercial, IRepositorioDePlanosComerciais repositorioDePlanosComerciais, IRepositorioDeModelos repositorioDeModelos)
{
var modeloViewModel = ModeloViewModel.From(itemDePlanoComercial.Modelo);
var viewModel = new ItemDePlanoComercialViewModel
{
itemDePlanoComercial = itemDePlanoComercial,
repositorioDePlanosComerciais = repositorioDePlanosComerciais,
//PlanoComercialId = itemDePlanoComercial.PlanoComercial.Id,
modeloViewModel = modeloViewModel,
//ModeloCodigo = itemDePlanoComercial.Modelo.Codigo,
//ModeloNome = itemDePlanoComercial.Modelo.Nome,
//CustoDeProducaoSugerido = itemDePlanoComercial.CustoDeProducaoSugerido.ToString(),
Margem = itemDePlanoComercial.Margem,
margemPercentual = itemDePlanoComercial.MargemPercentual.ToString(),
taxaDeMarcacaoSugerida = (itemDePlanoComercial.TaxaDeMarcacaoSugerida.HasValue ? itemDePlanoComercial.TaxaDeMarcacaoSugerida.Value.ToString() : null),
precoDeVendaDesejado = (itemDePlanoComercial.PrecoDeVendaDesejado.HasValue ? itemDePlanoComercial.PrecoDeVendaDesejado.Value.ToString() : null),
};
return(viewModel);
}
public IActionResult Detalle(int Id)
{
try
{
ModeloDTO modeloDTO = this._modeloService.getModelo((int)Id);
if (modeloDTO != null)
{
ModeloViewModel modeloViewModel = this._mapper.Map <ModeloDTO, ModeloViewModel>(modeloDTO);
return(View(modeloViewModel));
}
else
{
ViewBag.error = "Ocurrio un erro al intentar obtener el registro solicitado.";
return(View("index")); //deberia mostrar un msg de notificacion
}
}
catch (Exception ex)
{
ViewBag.error = ex.Message;
return(View("index"));
}
}
public HttpResponseMessage Models([FromBody] ModeloViewModel modelo)
{
try
{
var dadoValidado = ValidarDados(modelo);
if (dadoValidado != null)
{
return(dadoValidado);
}
JsonResult.Status = true;
modelo.Id = 0;
modelo.DataInsercao = DateTime.Now;
_modeloAplicacao.Salvar(modelo.ToEntity());
return(Request.CreateResponse(HttpStatusCode.Created, JsonResult.Message = "Modelo Cadastrado!"));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, JsonResult.Message = ex.InnerException.Message));
}
}
