Beispiel #1
0
        public static void ModificarProducto(Producto producto)
        {
            try
            {
                if (string.IsNullOrEmpty(producto.nombre))
                {
                    throw new Exception("Nombre faltante");
                }

                if (producto.precio < 0)
                {
                    throw new Exception("Precio no valido");
                }

                if (producto.stock < 0)
                {
                    throw new Exception("Existencias no validas");
                }

                if (producto.id_categoria == 0)
                {
                    throw new Exception("Falta categoría");
                }


                ProductoModelo.ModificarProducto(producto);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Beispiel #2
0
 static public void CrearOrden(Orden orden, List <CarritoItem> carrito, Usuario usuario)
 {
     try
     {
         foreach (CarritoItem item in carrito)
         {
             OrdenItem o_item = new OrdenItem();
             o_item.cantidad    = item.cantidad;
             o_item.id_producto = item.id_producto;
             o_item.precio      = item.Producto.precio_real;
             orden.OrdenItem.Add(o_item);
             CarritoModelo.EliminarCarritoItem(item);
             Producto prod = ProductoModelo.ObtenerProductoPorID((int)o_item.id_producto);
             prod.stock -= o_item.cantidad;
             ProductoModelo.ModificarProducto(prod);
         }
         orden.id_usuario   = usuario.id;
         orden.fecha_compra = DateTime.Now;
         orden.costo_total  = carrito.Sum(i => i.Producto.precio_real * i.cantidad) + 50;
         OrdenModelo.InsertarOrden(orden);
         EnviarCorreo(usuario.email, orden);
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Beispiel #3
0
        /// <summary>
        /// Guarda un producto en la base de datos.
        /// </summary>
        /// <param name="producto">Producto a guardar.</param>
        public void GuardarProducto(ProductoModelo producto)
        {
            producto.ValidarProducto(verificarQueNoExista: true);

            using IDbConnection conexion = new SQLiteConnection(stringConexion);

            var q = @"insert into productos (Nombre, FechaCreacion, Descripcion)
                            values (@Nombre, strftime('%s', 'now'), @Descripcion)";

            var parametros = new { Nombre = producto.Nombre, Descripcion = producto.Descripcion };

            conexion.Execute(q, parametros);

            producto.Id = conexion.ExecuteScalar <int>("select max(Id) from Productos");

            if (producto.Categorias == null || producto.Categorias.Count < 1)
            {
                return;
            }

            producto.Categorias.ValidarCategorias();

            q = "insert into ProductoCategoria (ProductoId, CategoriaId) values (@ProductoId, @CategoriaId)";

            foreach (var categoria in producto.Categorias)
            {
                conexion.Execute(q, new { ProductoId = producto.Id, CategoriaId = categoria.Id });
            }
        }
        public async Task <ActionResult> Editar(string idServicio)
        {
            vmoServicio vServicio = new vmoServicio();

            if (Session["ListaProductos"] == null)
            {
                vServicio = await ObtenerListaProductoBase(new RespuestaComun());
            }
            else
            {
                vServicio.LstProducto = (ObservableCollection <ProductoModelo>)Session["ListaProductos"];
            }

            ProductoModelo productoModelo = new ProductoModelo();

            for (int x = 0; x < vServicio.LstProducto.Count; x++)
            {
                if (int.Parse(idServicio) == vServicio.LstProducto[x].IdServicios)
                {
                    productoModelo = vServicio.LstProducto[x];
                    break;
                }
            }
            productoModelo.TipoAccion = Constantes.ACCION_MODIFICAR;
            return(PartialView(Enumerador.NombreVista.GestionProducto.ToString(), productoModelo));
        }
        public async Task <RespuestaComun> ProcesarGestionProducto(ProductoModelo mProducto)
        {
            RespuestaComun respuestaComun = new RespuestaComun();

            //mProducto.TipoAccion = mHorario.TipoAccion == 0 ? (int)Enumerador.EnumTipoAccion.Insertar : mHorario.TipoAccion;
            mProducto.Estado = "A";
            object obj = mProducto;

            obj = _producto.ProcesarGestionProducto <object>(obj);


            //respuestaComun = EjecutarHttpRest.Deserializar<RespuestaComun>(EjecutarHttpRest.SerializarIdentado(obj));
            if (respuestaComun.Tipo == (int)Enumerador.EnumTipoRespuesta.RespuestaOk && respuestaComun.Codigo == Constantes.RESPUESTA_CODIGO_OK)
            {
                //respuestaComun.NombreBotonListar = Enumerador.NombreAccionEjecutar.ListarHorario.ObtenerDescripcion();
                //respuestaComun.NombreBotonAceptar = Enumerador.NombreAccionEjecutar.GestionHorario.ObtenerDescripcion();
                //respuestaComun.AccionEjecutarListar = Enumerador.NombreAccionEjecutar.ListarHorario.ToString();
                //respuestaComun.AccionEjecutarAceptar = Enumerador.NombreAccionEjecutar.GestionHorario.ToString();
                ViewBag.RespuestaListarAceptar = respuestaComun;
            }
            else if (respuestaComun.Tipo == (int)Enumerador.EnumTipoRespuesta.ErrorControlado)
            {
                //respuestaComun.NombreBotonAceptar = Enumerador.NombreAccionEjecutar.GestionHorario.ObtenerDescripcion();
                ViewBag.RespuestaErrorControlado = respuestaComun;
            }
            else
            {
                throw new Exception();
            }

            return(respuestaComun);
        }
Beispiel #6
0
        public ActionResult Compra(string id)
        {
            ProductoModelo prodM = new ProductoModelo();

            if (Session["carrito"] == null)
            {
                List <Item> carro = new List <Item>();
                carro.Add(new Item {
                    Producto = prodM.Get(id), Cantidad = 1
                });
                Session["carrito"] = carro;
            }
            else
            {
                List <Item> carro  = (List <Item>)Session["carrito"];
                int         indice = Existe(id);
                if (indice != -1)
                {
                    carro[indice].Cantidad++;
                }
                else
                {
                    carro.Add(new Item {
                        Producto = prodM.Get(id), Cantidad = 1
                    });
                }
                Session["carrito"] = carro;
            }
            return(RedirectToAction("Index"));
        }
Beispiel #7
0
        /// <summary>
        /// </summary>
        /// <param name="solicitante"> Form que solicita el filtro. </param>
        /// <param name="filtro"> Filtro anterior o preconfigurado a cargar. </param>
        public InventarioFiltroForm(ISolicitudFiltro solicitante, ReporteFiltroModelo filtro = null)
        {
            InitializeComponent();

            this.solicitante = solicitante;

            if (filtro == null)
            {
                return;
            }

            // Cargar filtro anterior o preconfigurado

            if (filtro.FiltroPorProducto && filtro.Producto != null)
            {
                producto = filtro.Producto;
                nombre_producto_tb.Text = filtro.Producto.Nombre;

                filtrar_por_producto_groupbox.Enabled = filtro.FiltroPorProducto;
                filtrar_por_producto_checkbox.Checked = filtro.FiltroPorProducto;
            }

            if (filtro.Categorias != null)
            {
                categoriasSeleccionadas = filtro.Categorias;
                ActualizarCategorias();
            }

            incluir_productos_sin_unidades.Checked = filtro.IncluirProductosSinUnidades;
        }
Beispiel #8
0
 public DetailPageViewModel(INavigation navigation, ProductoModelo product)
 {
     Navigation = navigation;
     DependencyService.Get <IStatusBarStyle>().ChangeTextColor(true);
     PopDetailPageCommand = new Command(async() => await ExecutePopDetailPageCommand());
     Product = product;
     Product = null;
 }
        public ActionResult ObtenerProductoXId(string IdServicio)
        {
            ObservableCollection <ProductoModelo> lstProductos = ((ObservableCollection <ProductoModelo>)HttpContext.Session["Productos"]);
            ProductoModelo productoModelo = lstProductos.FirstOrDefault(x => x.IdServicios == int.Parse(IdServicio));

            //HttpPostedFileBase file = Request.Files["ImageData"];
            //productoModelo.Imagen = ConvertToBytes(file);
            return(View(Enumerador.NombreVista.GestionProducto.ToString(), productoModelo));
        }
Beispiel #10
0
 private void LimpiarForm()
 {
     producto = null;
     nombre_producto_tb.Clear();
     nombre_producto_tb.Focus();
     nuevo_nombre_tb.Clear();
     nueva_descripcion_tb.Clear();
     ActualizarCategorias();
 }
Beispiel #11
0
 public void ProductoListo(ProductoModelo producto)
 {
     if (producto == null)
     {
         return;
     }
     this.producto           = producto;
     nombre_producto_tb.Text = producto.Nombre;
 }
Beispiel #12
0
 private void LimpiarForm()
 {
     unidades_tb.Focus();
     unidades_tb.Text             = "";
     inversion_total_tb.Text      = "";
     inversion_unidad_tb.Text     = "N/A";
     precio_venta_defecto_tb.Text = "";
     producto = null;
     nombre_producto_tb.Text = "";
 }
Beispiel #13
0
 public static List <Producto> ObtenerProductos(bool estado)
 {
     try
     {
         return(ProductoModelo.ObtenerProductos(estado));
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Beispiel #14
0
        public void EditarProducto(ProductoModelo producto)
        {
            if (producto == null)
            {
                throw new ArgumentException($"Producto nulo.");
            }
            if (producto.Id < 1)
            {
                throw new ArgumentException($"Id del producto invalido: {producto.Id}, el id no puede ser menor a 1");
            }

            producto.Nombre      = producto.Nombre.Trim();
            producto.Descripcion = producto.Descripcion.Trim();

            if (string.IsNullOrEmpty(producto.Nombre))
            {
                throw new ArgumentException("El nombre del producto no puede estar vacio.");
            }

            using (IDbConnection conexion = new SQLiteConnection(stringConexion))
            {
                var q = @"update Productos set Nombre = @Nombre, Descripcion = @Descripcion where Id = @Id";
                conexion.Execute(q, new { Nombre = producto.Nombre, Descripcion = producto.Descripcion, Id = producto.Id });

                conexion.Open();
                using (var transaccion = conexion.BeginTransaction())
                {
                    try
                    {
                        q = "delete from ProductoCategoria where ProductoId = @Id";
                        conexion.Execute(q, new { Id = producto.Id });

                        q = @"insert into ProductoCategoria (productoId, CategoriaId)
                                values (@ProductoId, @CategoriaId)";

                        if (producto.Categorias != null)
                        {
                            foreach (var categoria in producto.Categorias)
                            {
                                conexion.Execute(q, new { ProductoId = producto.Id, CategoriaId = categoria.Id });
                            }
                        }

                        transaccion.Commit();
                    }
                    catch
                    {
                        transaccion.Rollback();
                        throw;
                    }
                }
            }
        }
Beispiel #15
0
        public HistorialVentasFiltroForm(ISolicitudFiltro solicitante, ReporteFiltroModelo filtro = null)
        {
            InitializeComponent();
            this.solicitante = solicitante;

            // Cargar filtro anterior
            if (filtro != null)
            {
                if (filtro.FiltroPorFechas)
                {
                    if (filtro.FechaInicial != null)
                    {
                        fecha_inicial_dtp.Value = filtro.FechaInicial;
                    }
                    if (filtro.FechaFinal != null)
                    {
                        fecha_final_dtp.Value = filtro.FechaFinal;
                    }
                }

                filtrar_por_fechas_groupbox.Enabled = filtro.FiltroPorFechas;
                habilitar_fechas_checkbox.Checked   = filtro.FiltroPorFechas;

                if (filtro.FiltroPorCliente && filtro.Cliente != null)
                {
                    cliente         = filtro.Cliente;
                    cliente_tb.Text = cliente.NombreCompleto;
                }

                filtrar_por_cliente_groupbox.Enabled = filtro.FiltroPorCliente;
                filtrar_por_cliente_checkbox.Checked = filtro.FiltroPorCliente;

                if (filtro.FiltroPorProducto && filtro.Producto != null)
                {
                    producto = filtro.Producto;
                    nombre_producto_tb.Text = filtro.Producto.Nombre;
                }

                filtrar_por_producto_groupbox.Enabled = filtro.FiltroPorProducto;
                filtrar_por_producto_checkbox.Checked = filtro.FiltroPorProducto;

                if (filtro.FiltroPorCategoria && filtro.Categoria != null)
                {
                    categoria = filtro.Categoria;
                    categoria_nombre_tb.Text = filtro.Categoria.Nombre;
                }

                filtrar_por_categoria_groupbox.Enabled = filtro.FiltroPorCategoria;
                filtrar_por_categoria_checkbox.Checked = filtro.FiltroPorCategoria;
            }
        }
Beispiel #16
0
 static public Oferta ObtenerOfertasDeProducto(Producto prod)
 {
     try
     {
         if (prod.id < 0 || ProductoModelo.ObtenerProductoPorID((int)prod.id) == null)
         {
             throw new Exception("Producto no valido");
         }
         return(OfertaModelo.ObtenerOfertasDeProducto(prod));
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
        public async Task <ActionResult> Eliminar(string idServicio)
        {
            ProductoModelo mProducto = new ProductoModelo();

            mProducto.Estado      = Constantes.ESTADO_ACTIVO;
            mProducto.TipoAccion  = Constantes.ACCION_ELIMINAR;
            mProducto.IdServicios = int.Parse(idServicio);
            RespuestaComun respuesta = await _producto.ProcesarGestionProducto <RespuestaComun>(mProducto);

            vmoServicio servicioVistaModelo = new vmoServicio();

            servicioVistaModelo = await this.ObtenerListaProductoBase(null);

            return(PartialView("ListarProducto", servicioVistaModelo.LstProducto));
        }
Beispiel #18
0
 public static List <Producto> ObtenerProductosPorCategoria(string categoria)
 {
     try
     {
         if (CategoriaModelo.ObtenerCategoriaPorNombre(categoria) == null)
         {
             throw new Exception("Categoria no valida");
         }
         return(ProductoModelo.ObtenerProductosPorCategoria(categoria));
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Beispiel #19
0
 public static Producto ObtenerProductoPorID(int id)
 {
     try
     {
         if (id <= 0)
         {
             throw new Exception("ID no valido");
         }
         return(ProductoModelo.ObtenerProductoPorID(id));
     }
     catch (Exception ex)
     {
         throw new Exception(ex.Message);
     }
 }
Beispiel #20
0
        public static void EliminarProducto(Producto producto)
        {
            try
            {
                if (ProductoModelo.RevisarOrdenItem(producto))
                {
                    throw new Exception("Este producto ya ha sido comprado");
                }

                ProductoModelo.EliminarProducto(producto);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
        /// <summary>
        /// Obtiene la lista de Productos registrados
        /// </summary>
        /// <param name="respuestaComun"></param>
        /// <returns></returns>
        public async Task <vmoServicio> ObtenerListaProductoBase(RespuestaComun respuestaComun)
        {
            vmoServicio    servicioVistaModelo = new vmoServicio();
            ProductoModelo mProducto           = new ProductoModelo {
                Estado = "T"
            };

            servicioVistaModelo = await _producto.ObtenerListaProductoAsync <vmoServicio>(mProducto);

            if (servicioVistaModelo != null && servicioVistaModelo.Respuesta != null)
            {
                ViewBag.RespuestaErrorControlado = servicioVistaModelo.Respuesta;
            }
            Session["ListaProductos"] = servicioVistaModelo.LstProducto;
            return(servicioVistaModelo);
        }
        public async Task <ActionResult> Editar(string idSubServicio)
        {
            vmoServicio vServicio = new vmoServicio();

            if (Session["ListaSubProductos"] == null)
            {
                vServicio = await ObtenerListaSubProductoBase(new RespuestaComun());
            }
            else
            {
                vServicio.LstSubProducto = (ObservableCollection <SubProductoModelo>)Session["ListaSubProductos"];
            }
            SubProductoModelo subProductoModelo = new SubProductoModelo();

            for (int x = 0; x < vServicio.LstSubProducto.Count; x++)
            {
                if (int.Parse(idSubServicio) == vServicio.LstSubProducto[x].IdSubservicio)
                {
                    subProductoModelo = vServicio.LstSubProducto[x];
                    break;
                }
            }
            subProductoModelo.TipoAccion = Constantes.ACCION_MODIFICAR;

            if (Session["ListaProductos"] == null)
            {
                IProducto      _producto = new Servicio.Producto();
                ProductoModelo mProducto = new ProductoModelo {
                    Estado = "A"
                };
                vServicio = await _producto.ObtenerListaProductoAsync <vmoServicio>(mProducto);

                Session["ListaProductos"] = vServicio.LstProducto;
            }
            else
            {
                vServicio.LstProducto = (ObservableCollection <ProductoModelo>)Session["ListaProductos"];
            }

            subProductoModelo.LstServicios = vServicio.LstProducto.Select(elemento => new SelectListItem
            {
                Text  = string.Format("{0} - {1} ", elemento.Descripcion, elemento.Genero == "M" ? "Mujer" : "Hombre"),
                Value = elemento.IdServicios.ToString()
            }).ToList();;

            return(PartialView(Enumerador.NombreVista.GestionSubProducto.ToString(), subProductoModelo));
        }
Beispiel #23
0
        /// <summary>
        /// Guarda un producto en la base de datos.
        /// </summary>
        /// <param name="producto"> Producto a guardar. </param>
        public void GuardarProducto(ProductoModelo producto)
        {
            producto.Nombre = producto.Nombre.Trim();

            if (string.IsNullOrEmpty(producto.Nombre))
            {
                throw new ArgumentException("El nombre del producto no puede estar vacio.");
            }

            if (ProductoExiste(producto.Nombre))
            {
                throw new ArgumentException("El nombre del producto ya existe en la base de datos.");
            }

            foreach (var categoria in producto.Categorias)
            {
                if (string.IsNullOrEmpty(categoria.Nombre.Trim()))
                {
                    throw new ArgumentException("Al menos una categoria del producto no tiene nombre.");
                }
            }

            using (IDbConnection conexion = new SQLiteConnection(stringConexion))
            {
                var q = @"insert into productos (Nombre, FechaCreacion, Descripcion)
                            values (@Nombre, strftime('%s', 'now'), @Descripcion)";

                conexion.Execute(q,
                                 new
                {
                    Nombre      = producto.Nombre,
                    Descripcion = producto.Descripcion
                }
                                 );

                producto.Id = conexion.ExecuteScalar <int>("select max(Id) from Productos");

                q = "insert into ProductoCategoria (ProductoId, CategoriaId) values (@ProductoId, @CategoriaId)";
                foreach (var categoria in producto.Categorias)
                {
                    conexion.Execute(q, new { ProductoId = producto.Id, CategoriaId = categoria.Id });
                }
            }
        }
Beispiel #24
0
        /// <summary>
        /// Edita un producto en la base de datos.
        /// </summary>
        /// <param name="producto">
        ///     El producto a editar. Las propiedades de este producto se usaran
        ///     para sobreescribir las columnas correspondientes
        ///     de la fila correspondiente en la base de datos dada por la propiedad producto.Id.
        /// </param>
        public void EditarProducto(ProductoModelo producto)
        {
            producto.ValidarProducto();

            using IDbConnection conexion = new SQLiteConnection(stringConexion);
            var q = @"update Productos set Nombre = @Nombre, Descripcion = @Descripcion where Id = @Id";

            var parametros = new { Nombre = producto.Nombre, Descripcion = producto.Descripcion, Id = producto.Id };

            conexion.Execute(q, parametros);

            if (producto.Categorias == null || producto.Categorias.Count < 1)
            {
                return;
            }

            producto.Categorias.ValidarCategorias();

            conexion.Open();
            using var transaccion = conexion.BeginTransaction();

            try
            {
                q = "delete from ProductoCategoria where ProductoId = @ProductoId";
                conexion.Execute(q, new { ProductoId = producto.Id });

                q = @"insert into ProductoCategoria (productoId, CategoriaId)
                                        values (@ProductoId, @CategoriaId)";

                foreach (var categoria in producto.Categorias)
                {
                    conexion.Execute(q, new { ProductoId = producto.Id, CategoriaId = categoria.Id });
                }

                transaccion.Commit();
            }
            catch
            {
                transaccion.Rollback();
                throw;
            }
        }
Beispiel #25
0
        public static void ModificarOferta(Oferta ofMod)
        {
            try
            {
                if (ofMod.id_producto < 0 || ProductoModelo.ObtenerProductoPorID((int)ofMod.id_producto) == null)
                {
                    throw new Exception("Producto no valido");
                }

                if (ofMod.descuento <= 0 || ofMod.descuento >= 100)
                {
                    throw new Exception("Descuento no valido");
                }
                OfertaModelo.ModificarOferta(ofMod);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Beispiel #26
0
        static public void InsertarOferta(Oferta objOferta)
        {
            try
            {
                if (objOferta.id_producto < 0 || ProductoModelo.ObtenerProductoPorID((int)objOferta.id_producto) == null)
                {
                    throw new Exception("Producto no valido");
                }

                if (objOferta.descuento <= 0 || objOferta.descuento >= 1)
                {
                    throw new Exception("Descuento no valido");
                }

                OfertaModelo.InsertarOferta(objOferta);
            }
            catch (Exception ex)
            {
                throw new Exception(ex.Message);
            }
        }
Beispiel #27
0
        public ActionResult EditarProducto(int codigo = 0)
        {
            ProductoModelo   model         = new ProductoModelo();
            Productos        entidad       = new Productos();
            List <Productos> datosProducto = new List <Productos>();

            entidad.Codigo = codigo;
            ProductosQuerys pq = new ProductosQuerys();

            datosProducto = pq.ProductoPorCodigo(entidad.Codigo);

            MarcasQuerys  mq     = new MarcasQuerys();
            List <Marcas> marcas = new List <Marcas>();

            marcas        = mq.GetMarcas();
            ViewBag.Lista = marcas;

            foreach (var datos in datosProducto)
            {
                model.Codigo      = datos.Codigo;
                model.Nombre      = datos.Nombre;
                model.Descripcion = datos.Descripcion;
                model.IdMarca     = datos.IdMarca;

                ViewBag.MarcaSeleccionada = model.IdMarca;

                model.PrecioUnitario = datos.PrecioUnitario;
                model.Activo         = datos.Activo;
                if (string.IsNullOrEmpty(datos.UrlImange))
                {
                    model.UrlImange = "Este producto no tiene URL, de imagen, asociada.";
                }
                else
                {
                    model.UrlImange = datos.UrlImange;
                }
            }

            return(View(model));
        }
Beispiel #28
0
        public static void ValidarProducto(this ProductoModelo producto, bool verificarQueNoExista = false)
        {
            if (producto == null)
            {
                throw new ArgumentException("El producto fue null.");
            }

            if (string.IsNullOrEmpty(producto.Nombre))
            {
                throw new ArgumentException(@"El nombre del producto esta vacio o fue null.");
            }

            if (verificarQueNoExista == false)
            {
                return;
            }

            if (ConfigGlobal.conexion.ProductoExiste(producto.Nombre))
            {
                throw new ArgumentException("El nombre del producto ya existe en la base de datos.");
            }
        }
Beispiel #29
0
        public void ProductoListo(ProductoModelo producto)
        {
            if (producto == null)
            {
                return;
            }
            this.producto             = producto;
            nombre_producto_tb.Text   = producto.Nombre;
            nuevo_nombre_tb.Text      = producto.Nombre;
            nueva_descripcion_tb.Text = producto.Descripcion;

            try
            {
                this.producto.Categorias = ConfigGlobal.conexion.CargarCategorias_PorProductoId(producto.Id);
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }
            ActualizarCategorias();
        }
Beispiel #30
0
        private void crear_producto_button_Click(object sender, EventArgs e)
        {
            // Validar nombre del producto.

            var productoNombre = nombre_producto_tb.Text.Trim();

            if (string.IsNullOrEmpty(productoNombre))
            {
                MessageBox.Show("Nombre inválido.", "", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            // Verificar que el nombre del producto no exista en la base de datos

            bool productoExiste = false;

            try
            {
                productoExiste = ConfigGlobal.conexion.ProductoExiste(productoNombre);
            }
            catch (ArgumentException ex)
            {
                MessageBox.Show(ex.Message, "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            if (productoExiste)
            {
                MessageBox.Show("El nombre del producto ya existe en la base de datos.", "", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }

            // Crear producto y guardar en la base de datos.

            var producto = new ProductoModelo();

            producto.Nombre      = productoNombre;
            producto.Descripcion = descripcion_tb.Text.Trim();
            producto.Categorias  = categoriasSeleccionadas;

            try
            {
                ConfigGlobal.conexion.GuardarProducto(producto);
            }
            catch (ArgumentException ex)
            {
                MessageBox.Show(ex.Message, "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            // Limpiar form.
            nombre_producto_tb.Clear();
            nombre_producto_tb.Focus();
            descripcion_tb.Clear();
            categoriasSeleccionadas = new List <CategoriaModelo>();
            ActualizarCategorias();

            // Pasar el producto al form solicitante.
            if (solicitante != null)
            {
                solicitante.ProductoListo(producto);
            }

            MessageBox.Show("Tarea completada", "", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }