public ActionResult Editar(ProductoViewModel model)
{
try
{
if (ModelState.IsValid)
{
using (patronEntities db = new patronEntities())
{
var oProducto = db.Producto.Find(model.Id);
oProducto.nombre = model.Nombre;
oProducto.cantidad = model.Cantidad;
oProducto.precio = model.Precio;
db.Entry(oProducto).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
return(Redirect("~/Producto/"));
}
return(View(model));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
// GET: Producto
public ActionResult Listado()
{
ProductoViewModel productoViewModel = new ProductoViewModel();
List <GrupoViewModel> lstgrupoViewModel = new List <GrupoViewModel>();
List <LineaViewModel> lstlineaViewModel = new List <LineaViewModel>();
List <ProductoViewModel> lstproductoViewModel = new List <ProductoViewModel>();
lstgrupoViewModel = grupoBL.GetAllGrupos().Select(x => new GrupoViewModel()
{
CodGrup = x.CodGrup,
NomGrup = x.NomGrup
}).ToList();
lstlineaViewModel = lineaBL.GetAllLineas().Select(x => new LineaViewModel()
{
CodLin = x.CodLin,
NomLin = x.NomLin
}).ToList();
lstproductoViewModel = productoBL.GetAllProductos().Select(x => new ProductoViewModel
{
CodProd = x.CodProd,
NomProd = x.NomProd,
CodGrup = x.CodGrup,
CodLin = x.CodLin,
Marca = x.Marca,
CosPromC = x.CosPromC,
PrecioVta = x.PrecioVta
}).ToList();
productoViewModel.lstproductoViewModel = lstproductoViewModel;
productoViewModel.lstgrupoViewModel = lstgrupoViewModel;
productoViewModel.lstlineaViewModel = lstlineaViewModel;
return(View(productoViewModel));
}
public string Save(ProductoViewModel producto)
{
if (!ModelState.IsValid)
{
IEnumerable <ModelError> errores = ModelState.Values.SelectMany(v => v.Errors);
return(this.serializer.Serialize(new { success = false, errores = errores }));
}
producto product;
if (producto.id is null)
{
product = new producto();
}
else
{
product = this.access.productos.Find(producto.id);
}
product.nombre = producto.nombre;
product.valor = producto.valor.Value;
if (producto.id is null)
{
this.access.productos.Add(product);
}
this.access.SaveChanges();
return(this.serializer.Serialize(new { success = true }));
}
public ActionResult NuevoProducto(ProductoViewModel model)
{
try
{
if (ModelState.IsValid)
{
using (CrudEntities2 db = new CrudEntities2())
{
var oProducto = new Producto();
oProducto.producto1 = model.NombreProducto;
oProducto.marca = model.Marca;
oProducto.precio = model.Precio;
db.Producto.Add(oProducto);
db.SaveChanges();
}
return(Redirect("~/Producto/"));
}
return(View(model));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public IActionResult EditarDatosProducto(int id)
{
sistem14_ropa_mexicanaContext context = new sistem14_ropa_mexicanaContext();
ProductoViewModel vm = new ProductoViewModel();
ProductoRepository pr = new ProductoRepository(context);
vm.Producto = pr.Get(id);
if (vm.Producto == null)
{
return(RedirectToAction("Index"));
}
MarcaRepository mrepository = new MarcaRepository(context);
vm.MarcaAfiliadas = mrepository.GetAll();
if (System.IO.File.Exists(Environment.WebRootPath + $"/imgs_Productos/{vm.Producto.Id}_0.jpg"))
{
vm.Imagen = vm.Producto.Id + "_0.jpg";
}
else
{
vm.Imagen = "NoPhoto.jpg";
}
return(View(vm));
}
public JResult InsProducto(ProductoViewModel model)
{
try
{
FACT_PRODUCTO dbItem = new FACT_PRODUCTO
{
Id = model.Id,
Codigo = model.Codigo.ToUpper(),
Nombre = model.Nombre.ToUpper(),
Valor = model.Valor,
Estregistro = 1
};
db.FACT_PRODUCTO.Attach(dbItem);
db.Entry(dbItem).State = EntityState.Added;
db.SaveChanges();
model.Id = dbItem.Id;
model.Estregistro = 1;
jresult.Data = model;
#region Salida Generica OK
return(jresult.SetOk("Registro creado correctamente"));
#endregion
}
#region Salida generica para errores
catch (Exception ex)
{
return(jresult.SetError(ex, "Error registrando datos", this.GetType().Name));
}
#endregion
}
public ActionResult Update(int id)
{
var productos = db.Productoes.OrderBy(x => x.ProdutoId).ToList();
var producto = productos.FirstOrDefault(x => x.ProdutoId == id);
llenarCBProductos();
if (id == 0 || producto == null)
{
TempData["ErrorMessage"] = "El identificador no fue encontrado";
return(RedirectToAction("Index"));
}
var categorias = db.Categorias.OrderBy(z => z.CategoriaId).ToList();
ProductoViewModel vm = new ProductoViewModel();
vm.ProdutoId = producto.ProdutoId;
vm.NombreProducto = producto.NombreProducto;
vm.CantidadProducto = producto.CantidadProducto;
vm.PrecioCProducto = producto.PrecioCProducto;
vm.PrecioVPrdoducto = producto.PrecioVPrdoducto;
vm.CategoriaId = producto.CategoriaId;
return(View(vm));
}
public IHttpActionResult CrearProducto(ProductoViewModel productoViewModel)
{
string respuesta = "";
if (ModelState.IsValid)
{
RelojServidor relojServidor = new RelojServidor();
relojServidor.ColocarMismaFechaHoraEnCamposFechaAltaYFechaModificacion(productoViewModel);
ProductoLN p = new ProductoLN();
respuesta = p.Crear(productoViewModel);
if (respuesta.Contains("ok"))
{
return(Ok());
}
else
{
return(BadRequest(respuesta));
}
}
else
{
return(BadRequest(respuesta));
}
}
public async Task <IActionResult> Create()
{
var validateToken = await ValidatedToken(_configuration, _getHelper, "catalogo");
if (validateToken != null)
{
return(validateToken);
}
if (!await ValidateModulePermissions(_getHelper, moduloId, eTipoPermiso.PermisoEscritura))
{
return(RedirectToAction(nameof(Index)));
}
var productoViewModel = new ProductoViewModel()
{
UnidadesDDL = await _combosHelper.GetComboUnidadesAsync(),
TasasImpuestosDDL = await _combosHelper.GetComboTasaImpuestosAsync()
};
if (productoViewModel.TasasImpuestosDDL.Count() <= 1)
{
ModelState.AddModelError(string.Empty, "No existe tasa de impuestos para asignar a productos.");
return(RedirectToAction(nameof(Create), "TasasImpuestos"));
}
return(View(productoViewModel));
}
public ActionResult Crear(ProductoViewModel model)
{
int idComercio = (int)Session["comercio"];
if (!ModelState.IsValid)
{
return(View(model));
}
using (practicaprofesionalEntities db = new practicaprofesionalEntities())
{
productos oProducto = new productos();
oProducto.descripcion = model.descripcion;
oProducto.estado = "1";
oProducto.stock = model.stock;
oProducto.precio = model.precio;
oProducto.id_comercio = idComercio;
db.productos.Add(oProducto);
db.SaveChanges();
}
return(Redirect(Url.Content("~/Productos")));
}
public ActionResult Edit(KeyProducto key)
{
ProductoServicesController oServices = new ProductoServicesController();
GrupoServicesController oGrupoServices = new GrupoServicesController();
EntityProducto oEntityProducto = oServices.SelectByKey(key);
ProductoViewModel oProductoViewModel = new ProductoViewModel();
oProductoViewModel.EntityProducto = oEntityProducto;
oProductoViewModel.ListGrupo = oGrupoServices.Select
(new EntityGrupo
{
IDGrupoPadre = Constantes.UnoNegativo,
Key = new KeyGrupo {
IDGrupo = Constantes.UnoNegativo
}
}
);
oProductoViewModel.EditableCantidadinventario = Constantes.Falso;
return(PartialView(Constantes.ProductoEdit, oProductoViewModel));
}
public JsonResult GuardarProducto(ProductoViewModel oProductoViewModel)
{
List <String> resultado = new List <String>();
resultado.Add("true");
resultado.Add(Constantes.GuardadoExitoso);
ProductoServicesController oServices = new ProductoServicesController();
try
{
EntityProducto oEntityProductoExists = oServices.SelectByKey(oProductoViewModel.EntityProducto.Key);
if (Constantes.Cero != oEntityProductoExists.Key.IDProducto)
{
oServices.Update(oProductoViewModel.EntityProducto);
}
else
{
oServices.AgregarProducto(oProductoViewModel.EntityProducto);
}
}
catch (Exception)
{
resultado[0] = "false";
resultado[1] = Constantes.GuardadoNoExitoso;
}
return(Json(resultado, JsonRequestBehavior.AllowGet));
}
//Productos
/// <summary>
/// Convertir clase productoViewModel a producto (incluye clase paquete)
/// </summary>
/// <param name="productoViewModel"></param>
/// <param name="isNew"></param>
/// <returns>Producto(class)</returns>
public async Task <Producto> ToProductoAsync(ProductoViewModel productoViewModel, bool isNew)
{
var producto = new Producto()
{
Activo = productoViewModel.Activo,
Codigo = productoViewModel.Codigo.Trim().ToUpper(),
MarcaID = productoViewModel.MarcaID,
PrecioCosto = isNew ? 0 : productoViewModel.PrecioCosto,
PrecioVenta = productoViewModel.PrecioVenta,
ProductoDescripcion = productoViewModel.ProductoDescripcion.Trim().ToUpper(),
ProductoID = isNew ? Guid.NewGuid() : productoViewModel.ProductoID,
ProductoNombre = productoViewModel.ProductoNombre.Trim().ToUpper(),
TasaID = productoViewModel.TasaID,
UnidadID = productoViewModel.UnidadID,
Paquete = null
};
if (productoViewModel.Unidades.Paquete)
{
var pieza = await _getHelper.GetProductByCodeAsync(productoViewModel.CodigoPieza);
var paquete = new Paquete()
{
CantidadProductoxPaquete = (decimal)productoViewModel.CantidadProductoxPaquete,
ProductoID = producto.ProductoID,
PiezaProductoID = pieza.ProductoID
};
producto.Paquete = paquete;
}
return(producto);
}
private void ExecuteView()
{
ProductoViewModel productoViewModel = ProductoViewModel.GetInstance();
productoViewModel.SetCurrentProducto(this);
App.ProductosPage.Navigation.PushAsync(new ProductoItemPage());
}
public ActionResult GuardarProducto(Producto producto)
{
if (!ModelState.IsValid)
{
var viewModel = new ProductoViewModel(producto)
{
Proveedores = _context.Proveedores.ToList()
};
return(View("ProductoFormulario", viewModel));
}
if (producto.Id == 0)
{
_context.Productos.Add(producto);
}
else
{
var productoBD = _context.Productos.Single(a => a.Id == producto.Id);
Mapper.Map <Producto, Producto>(producto, productoBD);
}
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> Actualizar(ProductoViewModel model)
{
try
{
var item = new E_Producto();
item.Codigo = model.CodigoProducto;
item.Nombre = model.NombreProducto;
item.Descripcion = model.Descripcion;
var categoria = await categoriaServices.DevolverPorCodigo(model.CodigoCategoria);
item.IdCategoria = categoria.Id;
var result = await productoServices.Actualizar(item);
model.CodigoProducto = result.Codigo;
CategoriaViewModel categoriaViewModel = new CategoriaViewModel();
categoriaViewModel.CodigoCategoria = result.Categoria.Codigo;
categoriaViewModel.NombreCategoria = result.Categoria.Nombre;
categoriaViewModel.Descripcion = result.Categoria.Descripcion;
model.Categoria = categoriaViewModel;
return(Ok(model));
}
catch (System.Exception ex)
{
return(BadRequest(ex.Message));
}
}
public JResult UpdProducto(ProductoViewModel model)
{
try
{
var dbItem = db.FACT_PRODUCTO.Find(model.Id);
dbItem.Id = model.Id;
dbItem.Codigo = model.Codigo.ToUpper();
dbItem.Nombre = model.Nombre.ToUpper();
dbItem.Valor = model.Valor;
dbItem.Estregistro = model.Estregistro;
db.FACT_PRODUCTO.Attach(dbItem);
db.Entry(dbItem).State = EntityState.Modified;
db.SaveChanges();
#region Salida Generica OK
return(jresult.SetOk());
#endregion
}
#region Salida generica para errores
catch (Exception ex)
{
return(jresult.SetError(ex, "Error registrando datos", this.GetType().Name));
}
#endregion
}
public ActionResult EditarProducto(ProductoViewModel model)
{
try
{
if (ModelState.IsValid)
{
using (CrudEntities2 db = new CrudEntities2())
{
var oProducto = db.Producto.Find(model.IdProducto);
oProducto.producto1 = model.NombreProducto;
oProducto.marca = model.Marca;
oProducto.precio = model.Precio;
db.Entry(oProducto).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
return(Redirect("~/Producto/"));
}
return(View(model));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public ActionResult Edit(ProductoViewModel productoViewModel)
{
ProductoDALImpl productoDAL = new ProductoDALImpl();
string mensaje = "";
try
{
mensaje = "Modificado con exito";
Producto producto = new Producto()
{
id_comida = productoViewModel.id_comida,
nombre = productoViewModel.nombre,
precio = productoViewModel.precio,
cantidad = productoViewModel.cantidad,
imagen_comida = productoViewModel.imagen_comida
};
productoDAL.UpdateProducto(producto);
}
catch (Exception ex)
{
mensaje = ex.ToString();
}
TempData["mensaje"] = mensaje;
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Create(ProductoViewModel model)
{
if (ModelState.IsValid)
{
try
{
ProductoEntity producto = await _converterHelper.ToProductoAsync(model, true);
_context.Add(producto);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
catch (DbUpdateException dbUpdateException)
{
if (dbUpdateException.InnerException.Message.Contains("duplicate"))
{
ModelState.AddModelError(string.Empty, "El código del producto ya existe.");
}
else
{
ModelState.AddModelError(string.Empty, dbUpdateException.InnerException.Message);
}
}
catch (Exception exception)
{
ModelState.AddModelError(string.Empty, exception.Message);
}
}
model.Categorias = _combosHelper.GetComboCategorias();
return(View(model));
}
// GET: Comidas
public ActionResult Index()
{
ProductoDALImpl productoDAL = new ProductoDALImpl();
List <Producto> productos;
productos = productoDAL.GetProductos();
List <ProductoViewModel> productoVM = new List <ProductoViewModel>();
ProductoViewModel productoViewModel;
foreach (var item in productos)
{
productoViewModel = new ProductoViewModel()
{
id_comida = item.id_comida,
cantidad = item.cantidad,
nombre = item.nombre,
precio = item.precio,
imagen_comida = item.imagen_comida
};
productoVM.Add(productoViewModel);
}
return(View(productoVM));
}
public ProductoPage(string id_categoria)
{
int variable = Int32.Parse(id_categoria);
BindingContext = new ProductoViewModel(variable);
}
public ActionResult Create(ProductoViewModel productoViewModel)
{
ProductoDALImpl productoDAL = new ProductoDALImpl();
string mensaje = "";
try
{
mensaje = "Agregado con exito";
Producto producto = new Producto()
{
nombre = productoViewModel.nombre,
precio = productoViewModel.precio,
cantidad = productoViewModel.cantidad,
imagen_comida = productoViewModel.imagen_comida
};
producto.id_comida = productoDAL.GetProductos().Count + 1;
productoDAL.AddProducto(producto);
}
catch (Exception ex)
{
mensaje = ex.ToString();
}
TempData["mensaje"] = mensaje;
return(RedirectToAction("Index"));
}
public ActionResult Edit(ProductoViewModel model)
{
try
{
if (ModelState.IsValid) // valida los DataAnotations
{
using (wi200122_pastas_tEntities db = new wi200122_pastas_tEntities())
{
var oProducto = db.producto.Find(model.id);
oProducto.descripcion = model.Descripcion;
oProducto.fecha_alta = DateTime.Today;
db.Entry(oProducto).State = System.Data.EntityState.Modified;
db.SaveChanges();
}
}
return(Redirect("~/Producto/"));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <IActionResult> Create(ProductoViewModel producto)
{
if (ModelState.IsValid)
{
string uniqueFileName = null;
if (producto.Photo != null)
{
string uploadsFolder = Path.Combine(Hosting.WebRootPath, "images");
uniqueFileName = $"{DateTime.Now.ToString("yyyyMMddHHmmss")}{producto.Photo.FileName}"; string filePath = Path.Combine(uploadsFolder, uniqueFileName);
producto.Photo.CopyTo(new FileStream(filePath, FileMode.Create));
Producto newDetalle = new Producto
{
TipoMedicamentoID = producto.TipoMedicamentoID,
Nombre = producto.Nombre,
Laboratorio = producto.Laboratorio,
Precio = producto.Precio,
Lote = producto.Lote,
FechaVencimiento = producto.FechaVencimiento,
PathFile = uniqueFileName
};
_context.Producto.Add(newDetalle);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index), new{ id = newDetalle.ProductoID }));
}
}
ViewData["TipoMedicamentoID"] = new SelectList(_context.TipoMedicamento, "TipoMedicamentoID", "Nombre", producto.TipoMedicamentoID);
ViewData["ProductoID"] = new SelectList(_context.Set <Producto>(), "ProductoID", "Nombre", producto.ProductoID);
return(View(producto));
}
public ActionResult Crear(ProductoViewModel model)
{
llenarCBProductos();
if (ModelState.IsValid)
{
if (db.Productoes.Any(x => x.NombreProducto == model.NombreProducto))
{
ViewData["ErrorMessage"] = "El Producto ya se encuentra registrado.";
return(View(model));
}
var producto = new Producto();
producto.NombreProducto = model.NombreProducto;
producto.CantidadProducto = model.CantidadProducto;
producto.PrecioCProducto = model.PrecioCProducto;
producto.PrecioVPrdoducto = model.PrecioVPrdoducto;
producto.CategoriaId = model.CategoriaId;
db.Productoes.Add(producto);
db.SaveChanges();
TempData["SuccessMessage"] = "Producto Creado Correctamente";
return(RedirectToAction("Index", "Producto"));
}
var productos = db.Productoes.OrderBy(x => x.ProdutoId).ToList();
var categorias = db.Categorias.OrderBy(z => z.CategoriaId).ToList();
model.Productos = productos;
model.Categorias = categorias;
return(View("Index", model));
}
public ActionResult Registro(ProductoViewModel model)
{
try
{
if (ModelState.IsValid)
{
using (patronEntities db = new patronEntities())
{
var oProducto = new Producto();
oProducto.id = ContadorRegistros();
oProducto.nombre = model.Nombre;
oProducto.cantidad = model.Cantidad;
oProducto.precio = model.Precio;
db.Producto.Add(oProducto);
db.SaveChanges();
}
return(Redirect("~/Producto/"));
}
return(View(model));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public IActionResult AñadirProducto(ProductoViewModel vm)
{
sistem14_ropa_mexicanaContext context = new sistem14_ropa_mexicanaContext();
MarcaRepository Mrepository = new MarcaRepository(context);
ProductoRepository Prepository = new ProductoRepository(context);
if (vm.Archivo.ContentType != "image/jpeg" || vm.Archivo.Length > 1024 * 1024 * 2)
{
ModelState.AddModelError("", "Debe selecionar un archivo jpg de menos de 2mb");
return(View(vm));
}
try
{
var IdAfiliado = Mrepository.GetAfiliadosByMarca(vm.MarcaAfiliada.Marca).Id;
vm.Producto.IdMarcaAfi = IdAfiliado;
Prepository.Insert(vm.Producto);
System.IO.FileStream fs = new FileStream(Environment.WebRootPath + "/imgs_Productos/" + vm.Producto.Id + "_0.jpg", FileMode.Create);
vm.Archivo.CopyTo(fs);
fs.Close();
return(RedirectToAction("VerProductos"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(vm));
}
}
public ActionResult Editar(string idProducto)
{
ProductoViewModel productoViewModel = new ProductoViewModel();
List <GrupoViewModel> lstgrupoViewModel = new List <GrupoViewModel>();
List <LineaViewModel> lstlineaViewModel = new List <LineaViewModel>();
lstgrupoViewModel = grupoBL.GetAllGrupos().Select(x => new GrupoViewModel()
{
CodGrup = x.CodGrup,
NomGrup = x.NomGrup
}).ToList();
lstlineaViewModel = lineaBL.GetAllLineas().Select(x => new LineaViewModel()
{
CodLin = x.CodLin,
NomLin = x.NomLin
}).ToList();
ProductoBO productoBO = productoBL.GetProductoById(new ProductoBO()
{
CodProd = idProducto
});
productoViewModel.CodProd = productoBO.CodProd;
productoViewModel.NomProd = productoBO.NomProd;
productoViewModel.CodGrup = productoBO.CodGrup;
productoViewModel.CodLin = productoBO.CodLin;
productoViewModel.Marca = productoBO.Marca;
productoViewModel.CosPromC = productoBO.CosPromC;
productoViewModel.PrecioVta = productoBO.PrecioVta;
productoViewModel.lstgrupoViewModel = lstgrupoViewModel;
productoViewModel.lstlineaViewModel = lstlineaViewModel;
return(View(productoViewModel));
}
public async Task <IActionResult> EditarProducto(ProductoViewModel producto)
{
try
{
var usuario = HttpContext.Session.GetString("IdEstablecimiento");
LoggerBase.WriteLog("Home-EditarProducto-POST", "Usuario", "IdEstablecimiento", usuario, TypeError.Info);
if (string.IsNullOrEmpty(usuario))
{
this.TempData["Mensaje"] = $"{Mensaje.Error}|{"Su sesión ha expirado"}";
return(RedirectToAction("Login", "Account"));
}
var pedido = await zohoApis.EditarProducto(producto);
if (pedido.Equals("OK", StringComparison.InvariantCultureIgnoreCase))
{
this.TempData["Mensaje"] = $"{Mensaje.MensajeSatisfactorio}|{"El producto se actualizó correctamente"}";
return(RedirectToAction("Productos", "Home"));// RedirectToAction("Index", "Home");
}
this.TempData["Mensaje"] = $"{Mensaje.Error}|{"El producto no pudo ser editado"}";
return(View(producto));
}
catch (Exception ex)
{
this.TempData["Mensaje"] = $"{Mensaje.Error}|{ex.Message}";
return(RedirectToAction("Productos", "Home"));
}
}
public ProductoViewModel ObtenerProductos()
{
var modelo = new ProductoViewModel();
using (var db = new QueryDatabase())
{
var lista = db.Productos.ToList();
modelo.Productos = lista;
}
return modelo;
}
/*
* Metodo
* Descripcion: Especifica la implementacion del comando BuscarProductoCommand - Busca un producto en particular
* Entrada: void
* Salida: void
*/
private void BuscarProductoExecute()
{
bool productoEncontrado = false;
ProductosBL contexto = new ProductosBL();
var productosBL = contexto.ObtenerProductos(cs);
if (Producto == null)
Producto = new ProductoViewModel();
foreach (var item in productosBL)
{
if (item.Codigo == this.Codigo)
{
Producto = new ProductoViewModel(item);
productoEncontrado = true;
}
}
if (productoEncontrado == false)
MessageBox.Show("Codigo no registrado.", "Producto Invalido", MessageBoxButton.OK, MessageBoxImage.Warning);
this.Codigo = "";
}
