public void crearNuevoModelo(ModeloModel ModeloModel)
{
var modelo = MapearModelo(ModeloModel);
modelo.Validar();
_repositorio.agregarModelo(modelo);
}
public IActionResult RegistrarEntrada(IFormCollection form)
{
RegistroModel registro = new RegistroModel();
registro.Nome = form["nome"];
ModeloModel modelo = new ModeloModel();
modelo.Nome = form["modelo"];
registro.Modelo = modelo;
MarcaModel marca = new MarcaModel();
marca.Nome = form["marca"];
registro.Marca = marca;
registro.Placa = form["placa"];
registroRepositorio.RegistrarNoCSV(registro);
return(RedirectToAction("Index", "Home"));
}
public IActionResult Registrar(IFormCollection form)
{
System.Console.WriteLine(form["nome"]);
System.Console.WriteLine(form["modelo"]);
System.Console.WriteLine(form["marca"]);
System.Console.WriteLine(form["placa"]);
System.Console.WriteLine(form["dataDeEntrada"]);
var registro = new RegistroModel();
registro.Nome = form["nome"];
registro.Placa = form["placa"];
registro.DataDeEntrada = DateTime.Parse(form["dataDeEntrada"]);
MarcaModel marca = new MarcaModel();
marca.Nome = form["marca"];
ModeloModel modelo = new ModeloModel();
modelo.Nome = form["modelo"];
registro.Marca = marca;
registro.Modelo = modelo;
// registro.Modelo.Nome = form["modelo"];
// registro.Marca.Nome = form["marca"];
registroRepositorio.Inserir(registro);
return(RedirectToAction("Index", "Cadastro"));
}
public IActionResult Post([FromBody] ModeloModel modeloInsersao)
{
try
{
Modelo modeloRequisicaoPost = _mapper.Map <ModeloModel, Modelo>(modeloInsersao);
if (modeloRequisicaoPost.Invalid)
{
return(StatusCode(StatusCodes.Status400BadRequest, new ErrorModel(modeloRequisicaoPost.Notifications)));
}
var modeloExistente = _modeloRepositorio.Obter(modeloRequisicaoPost.IdModelo);
if (modeloExistente != null)
{
return(StatusCode(StatusCodes.Status422UnprocessableEntity, Constantes.Mensagens.IdUtilizadoPorModeloExistente));
}
else
{
_modeloRepositorio.Inserir(modeloRequisicaoPost);
}
return(Ok());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, Constantes.Mensagens.ServicoIndisponivel)); throw;
}
}
/// <summary>
/// Ejecuta la acción del command
/// </summary>
/// <param name="catalogItemStatusViewModel"></param>
public ModifyModeloViewModel(CatalogModeloViewModel catalogModeloViewModel, ModeloModel selectedModeloModel)
{
this._modelo = new ModeloModel(new ModeloDataMapper(), catalogModeloViewModel.ActualUser);
this._catalogModeloViewModel = catalogModeloViewModel;
this._modelo.UnidModelo = selectedModeloModel.UnidModelo;
this._modelo.ModeloName = selectedModeloModel.ModeloName;
}
public async Task <Modelo> Salvar(Guid?id, ModeloModel model)
{
Modelo modelo;
if (id.HasValue)
{
modelo = await _modeloRepository.BuscarModelo(id.Value);
if (modelo != null && modelo.Id != Guid.Empty)
{
modelo.DefinirOuAlterarNome(model.Nome);
modelo.ValidarMarca(await _marcaService.Obter(model.MarcaId));
if (modelo.Valido)
{
await _modeloRepository.AtualizarModelo(modelo);
}
}
}
else
{
modelo = _mapper.Map <Modelo>(model);
modelo.ValidarMarca(await _marcaService.Obter(model.MarcaId));
if (modelo.Valido)
{
await _modeloRepository.SalvarModelo(modelo);
}
}
return(modelo);
}
public IActionResult Put([FromBody] ModeloModel modeloAtualizacao)
{
try
{
Modelo modeloRequisicaoPut = _mapper.Map <ModeloModel, Modelo>(modeloAtualizacao);
if (modeloRequisicaoPut.Invalid)
{
return(StatusCode(StatusCodes.Status400BadRequest, new ErrorModel(modeloRequisicaoPut.Notifications)));
}
var modeloExistente = _modeloRepositorio.Obter(modeloRequisicaoPut.IdModelo);
if (modeloExistente != null)
{
_modeloRepositorio.Atualizar(modeloRequisicaoPut);
}
else
{
return(StatusCode(StatusCodes.Status404NotFound, Constantes.Mensagens.ModeloNaoEncontrado));
}
return(Ok());
}
catch (Exception)
{
return(StatusCode(StatusCodes.Status500InternalServerError, Constantes.Mensagens.ServicoIndisponivel)); throw;
}
}
public HttpResponseMessage Create(ModeloModel area)
{
Modelo acu = new Modelo();
try
{
if (area != null)
{
acu.IdMarca = area.IdMarca;
acu.Descripcion = area.Descripcion;
db.Modelo.Add(acu);
db.SaveChanges();
return(new HttpResponseMessage(System.Net.HttpStatusCode.OK)
{
Content = null
});
}
else
{
return(new HttpResponseMessage(System.Net.HttpStatusCode.NoContent)
{
Content = null
});
}
}
catch (Exception ex)
{
return(Request.CreateResponse <string>(HttpStatusCode.InternalServerError, ex.Message + Environment.NewLine + "Area"));
}
}
public async Task <HttpResponseMessage> PutEventosGuiaInspeccion(ModeloModel evento)
{
using (db = new DBConnection())
{
try
{
Modelo tipo = new Modelo();
tipo = await db.Modelo.Where(x => x.IdModelo == evento.IdModelo).FirstOrDefaultAsync().ConfigureAwait(false);
if (tipo == null)
{
return(new HttpResponseMessage(HttpStatusCode.NoContent));
}
else
{
tipo.IdMarca = evento.IdMarca;
tipo.Descripcion = evento.Descripcion;
await db.SaveChangesAsync();
return(new HttpResponseMessage(HttpStatusCode.OK));
}
}
catch (Exception ex)
{
return(new HttpResponseMessage(HttpStatusCode.InternalServerError)
{
Content = new StringContent(ex.Message)
});
}
}
}
public List <RegistroModel> Listar()
{
var listaDeRegistros = new List <RegistroModel>();
string[] linhas = File.ReadAllLines(Path);
RegistroModel registro;
foreach (var item in linhas)
{
if (item != null)
{
string[] linha = item.Split(";");
registro = new RegistroModel();
registro.Nome = linha[0];
registro.Placa = linha[3];
registro.DataDeEntrada = DateTime.Parse(linha[4]);
MarcaModel marca = new MarcaModel();
marca.Nome = linha[1];
ModeloModel modelo = new ModeloModel();
modelo.Nome = linha[2];
registro.Marca = marca;
registro.Modelo = modelo;
listaDeRegistros.Add(registro);
}
}
return(listaDeRegistros);
}
public void modificarModelo(ModeloModel modeloModel)
{
var modelo = MapearModelo(modeloModel);
modelo.Validar();
_repositorio.modificarModelo(modelo);
}
public async Task <ActionResult <ModeloModel> > CreateModelo(ModeloModel modelo)
{
var _modelo = new Modelo(Guid.NewGuid(), new Guid(modelo.IDMARCA), modelo.NOME, modelo.MARCA, modelo.IMAGEM);
_service.post(_modelo);
return(await Task.FromResult(CreatedAtAction(nameof(GetModeloById), new { id = _modelo.ID }, _modelo)));
}
private Entidades.Modelo MapearModelo(ModeloModel modeloModel)
{
return(new Entidades.Modelo()
{
SKU = modeloModel.SKU,
descripcion = modeloModel.descripcion,
objetivo = modeloModel.objetivo
});
}
private ModeloMOD ModeloModel_To_ModeloMOD(ModeloModel model)
{
var mod = new ModeloMOD()
{
Id = model.Id,
Nome = model.Nome,
MarcaId = model.MarcaId
};
return(mod);
}
/// <summary>
/// Crea una nueva instancia de ModifyItemStatus y se pasa asi mismo como parámetro y el item seleccionado
/// </summary>
/// <returns></returns>
public ModifyModeloViewModel CreateModifyModeloViewModel()
{
ModeloModel modeloModel = new ModeloModel(new ModeloDataMapper(), this.ActualUser);
if (this._catalogModeloModel != null && this._catalogModeloModel.SelectedModelo != null)
{
modeloModel.ModeloName = this._catalogModeloModel.SelectedModelo.MODELO_NAME;
modeloModel.UnidModelo = this._catalogModeloModel.SelectedModelo.UNID_MODELO;
}
return(new ModifyModeloViewModel(this, modeloModel));
}
public ActionResult Editar(ModeloModel item, FormCollection form)
{
Guid marcaID = Guid.Empty;
if (Guid.TryParse(form["Marcas"], out marcaID))
{
item.MarcaID = marcaID;
}
ContextHelper.AlterarModelo(ConverterHelper <ModeloModel, Modelo> .ConvertAParaB(item));
return(RedirectToAction("Index"));
}
public ActionResult Novo(ModeloModel item, FormCollection form)
{
Guid marcaID = Guid.Empty;
//todo: o que vem ñ é o guid
if (Guid.TryParse(form["Marcas"], out marcaID))
{
item.MarcaID = marcaID;
}
ContextHelper.InsertModelo(ConverterHelper <ModeloModel, Modelo> .ConvertAParaB(item));
return(RedirectToAction("Index"));
}
public ActionResult Cadastrar(ModeloModel modelo)
{
//tranformar de model para mod
var mod = new ModeloMOD()
{
MarcaId = modelo.MarcaId,
Nome = modelo.Nome
};
_modeloRepository.Cadastrar(mod);
TempData["msg"] = "Cadastrado com Sucesso";
return(RedirectToAction("Index", new { id = modelo.MarcaId }));
}
public static List <ModeloModel> Listar()
{
string[] linhas = File.ReadAllLines(Path);
foreach (var item in linhas)
{
ModeloModel modelo = new ModeloModel();
modelo.Nome = item;
Modelos.Add(modelo);
}
return(Modelos);
}
public List <ModeloModel> Listar()
{
var registros = File.ReadAllLines(PATH);
foreach (var item in registros)
{
var valores = item.Split(";");
ModeloModel carro = new ModeloModel();
carro.Id = int.Parse(valores[0]);
carro.Modelo = valores[1];
this.Carros.Add(carro);
}
return(this.Carros);
}
public ActionResult SalvarModelo(ModeloModel model)
{
var aplicativo = new ModeloAplicativo();
Modelo modelo = new Modelo()
{
IDModelo = model.IDModelo.HasValue ? model.IDModelo.Value : 0,
Nome = model.Nome,
Sigla = model.Sigla,
Descricao = model.Descricao
};
aplicativo.Salvar(modelo);
return(RedirectToAction("Index"));
}
public OrdenDeProduccionModel crearOrden(int numeroOrden, ModeloModel modelo, ColorModel color)
{
var ldt = _repositorio.BuscarLineaEmpleado(GestorSesion.Instance.buscarEmpleado());
if (ldt != null)
{
var b = ldt.ValidarOrden();
if (b)
{
var op = CrearOrdenProduccion(numeroOrden, modelo.SKU, color.codigo, ldt);
return(MapearOrden(op));
}
}
return(null);
}
private List <ModeloModel> MapearModelos(List <Entidades.Modelo> modelos)
{
List <ModeloModel> modelosModel = new List <ModeloModel>();
for (int i = 0; i < modelos.Count; i++)
{
var modeloModel = new ModeloModel()
{
SKU = modelos[i].SKU,
descripcion = modelos[i].descripcion,
objetivo = modelos[i].objetivo
};
modelosModel.Add(modeloModel);
}
return(modelosModel);
}
public List <ModeloModel> ListarModelos()
{
string[] modelos = File.ReadAllLines(PATH);
foreach (var item in modelos)
{
if (item != null)
{
string[] dados = item.Split(";");
var modelo = new ModeloModel();
modelo.Id = int.Parse(dados[0]);
modelo.Nome = dados[1];
listaDeModelos.Add(modelo);
} //fim if
} //fim foreach
return(listaDeModelos);
}
/// <summary>
/// Estado = False (Significa que se encuentra activo)
/// Estado = true (Significa que se encuentra inactivo)
/// </summary>
/// <param name="Operacion"></param>
/// <param name="Nuevo"></param>
public void ABM(int Operacion, Vista.Modelo.Nuevo Nuevo, Vista.Modelo.Editar Editar, string Sku, DataGridView Grilla)
{
ModeloModel modelo = new ModeloModel();
if (!string.IsNullOrEmpty(Sku) || Operacion != 3)
{
switch (Operacion)
{
case 1:
modelo.Id = ObtenerUltimoIdModelo();
modelo.Sku = Nuevo.txtSku.Text;
modelo.Denominación = Nuevo.txtDenominacion.Text;
modelo.Objetivo = Convert.ToInt32(Nuevo.txtObjetivo.Text);
modelo.Estado = false;
ListaModelos.Add(modelo);
MessageBox.Show("Modelo Agregado", "", MessageBoxButtons.OK, MessageBoxIcon.Information);
Nuevo.txtSku.Text = string.Empty;
Nuevo.txtDenominacion.Text = string.Empty;
Nuevo.txtObjetivo.Text = string.Empty;
break;
case 2:
modelo = ObtenerModelo(Sku);
modelo.Sku = Editar.txtSku.Text;
modelo.Denominación = Editar.txtDenominacion.Text;
modelo.Objetivo = Convert.ToInt32(Editar.txtObjetivo.Text);
MessageBox.Show("Modelo Editado", "", MessageBoxButtons.OK, MessageBoxIcon.Information);
Editar.Close();
break;
case 3:
modelo = ObtenerModelo(Sku);
modelo.Estado = true;
MessageBox.Show("Modelo Eliminado", "", MessageBoxButtons.OK, MessageBoxIcon.Information);
break;
}
Guardar();
Grilla.DataSource = Listado();
}
else
{
MessageBox.Show("Debe seleccionar un modelo", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public IActionResult RegistrarEntrada(IFormCollection form)
{
RegistroModel registro = new RegistroModel();
registro.Nome = form["nome"];
var modelo = new ModeloModel();// preciso instanciar meus objetos não nativos
modelo.Nome = form["modelo"];
registro.Modelo = modelo;
var marca = new MarcaModel();
marca.Nome = form["marca"];
registro.Marca = marca;
registro.Placa = form["placa"];
registroRepositorio.RegistrarNoCSV(registro);
return(RedirectToAction("Index"));
}
public List <Models.ModeloModel> Listar()
{
List <ModeloModel> listaDeModelos = new List <ModeloModel>();
string[] linhas = File.ReadAllLines("Database/ModelosCarro.csv");
ModeloModel modelo;
foreach (var item in linhas)
{
if (string.IsNullOrEmpty(item))
{
continue;
}
string[] linha = item.Split(";");
modelo = new ModeloModel(
id: int.Parse(linha[0]),
nome: linha[1]
);
listaDeModelos.Add(modelo);
}
return(listaDeModelos);
}// fim listar
internal void crearOrden(int numeroOrden, Modelo modelo, Color color)
{
var ColorModel = new ColorModel()
{
codigo = color.codigo,
descripcion = color.descripcion
};
var ModeloModel = new ModeloModel()
{
SKU = modelo.SKU,
descripcion = modelo.descripcion,
objetivo = modelo.objetivo
};
var opModel = _controlador.crearOrden(numeroOrden, ModeloModel, ColorModel);
if (opModel != null)
{
Vista.MostrarOrden(MapearOrden(opModel));
}
else
{
Vista.MostrarMensaje("Hay una orden activa", false);
}
}
public async Task <ActionResult <ModeloModel> > UpdateModelo(ModeloModel modelo)
{
_service.put(_mapper.Map <Modelo>(modelo));
return(await Task.FromResult(CreatedAtAction(nameof(GetModeloById), new { id = modelo.ID }, modelo)));
}
// GET: Modelo
public ActionResult Index()
{
ModeloModel listaModelo = new ModeloModel();
return(View(listaModelo.ListarModelo()));
}
