Esempio n. 1
0
        public void ActualizarSubCategoria(string strID, string strCategoria, byte bOrden, string strDescripcion)
        {
            Subcategoria uSubcategoria = new Subcategoria();
            uSubcategoria.Id = strID;
            uSubcategoria.Orden = bOrden;
            uSubcategoria.Descripcion = strDescripcion;
            uSubcategoria.CategoriaIdRaw = strCategoria;

            SubCategoriaBusiness.Actualizar(uSubcategoria);
        }
Esempio n. 2
0
        // GET: Subcategorias/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Subcategoria subcategoria = db.Subcategorias.Find(id);

            if (subcategoria == null)
            {
                return(HttpNotFound());
            }
            return(View(subcategoria));
        }
Esempio n. 3
0
        public IHttpActionResult PostSubcategoria([FromBody] Subcategoria datos)
        {
            try
            {
                ServiciosTipos servicio = new ServiciosTipos();
                servicio.SubcategoriaGrabar(datos);

                return(Ok());
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
Esempio n. 4
0
 //Ingresar
 public bool Ingresar(Subcategoria subcat)
 {
     try
     {
         MenajesbdEntities6 ctx = new MenajesbdEntities6();
         ctx.Subcategoria.Add(subcat);
         ctx.SaveChanges();
         return(true);
     }
     catch (Exception)
     {
         return(false);
     }
 }
Esempio n. 5
0
    public List <Subcategoria> obtenerPsubcategorias()
    {
        List <Subcategoria> x = new List <Subcategoria>();
        Subcategoria        y = new Subcategoria();

        y.Id          = 0;
        y.Descripcion = "--Seleccione--";
        using (var db = new Mapeo())
        {
            x = db.subcategoria.ToList();
        }
        x.Add(y);
        return(x.OrderBy(z => z.Id).ToList());
    }
        private void preencherCampos(Produto p)
        {
            inpNomeProduto.Value = p.NomeProduto;
            inpPesoVolume.Value  = Convert.ToString(Convert.ToInt32(p.PesoVolumeProduto));
            inpEstoque.Value     = Convert.ToString(p.EstoqueProduto);
            inpEstoque.Disabled  = true;
            inpPreco.Value       = Convert.ToString(Convert.ToInt32(p.PrecoProduto));

            Subcategoria scat = Subcategoria.ObterSubcategorias().FirstOrDefault(sc => sc.NomeSubcategoria == p.GetNomeSubcategoria);

            popularDdlSubcategorias(Subcategoria.ObterSubcategorias(), scat);

            btnCadastrarProduto.Text = "Alterar";
        }
Esempio n. 7
0
        public void SubcategoriaGrabar(Subcategoria datoGraba)
        {
            RepositoryGenerico <Subcategoria> repository = new RepositoryGenerico <Subcategoria>();
            Subcategoria dato = null;

            Categoria categoria = this.ObtenerObjeto <Categoria>(datoGraba.IdCategoria);

            if (datoGraba.Id == -1)
            {
                dato = new Subcategoria();
                datoGraba.Vigente = true;
                if (categoria != null &&
                    categoria.Subcategorias.ToList <Subcategoria>().Find(item => item.Descripcion == datoGraba.Descripcion) != null)
                {
                    throw new ApplicationException(string.Format("La Subcategoría ya existe para la Categoría: {0}", categoria.Descripcion));
                }
            }
            else
            {
                dato = repository.Obtener(datoGraba.Id);
                if (dato == null)
                {
                    throw new ApplicationException("No existe el Subcategoria");
                }
            }

            dato.Descripcion = datoGraba.Descripcion;
            dato.Vigente     = datoGraba.Vigente;
            dato.Carpeta     = datoGraba.Carpeta;
            dato.Orden       = datoGraba.Orden;
            dato.Visible     = datoGraba.Visible;
            dato.Categoria   = categoria;

            dato.Validar();

            repository.Actualizar(dato);

            if (datoGraba.Medidas != null)
            {
                dato.Medidas.Clear();
                datoGraba.Medidas.ToList <SubcategoriaMedida>()
                .ForEach(delegate(SubcategoriaMedida item)
                {
                    dato.Medidas.Add(item);
                });
            }
            this.SubcategoriaMedidaGrabar(dato);
            CacheManager.RemoveToCache(gobalKeyCache);
        }
Esempio n. 8
0
        // GET: Subcategorias/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Subcategoria subcategoria = db.Subcategorias.Find(id);

            if (subcategoria == null)
            {
                return(HttpNotFound());
            }
            ViewBag.categoriaID = new SelectList(db.Categorias, "categoriaID", "titulo", subcategoria.categoriaID);
            return(View(subcategoria));
        }
Esempio n. 9
0
 public string InsertarSubCategoria(byte bOrden, string strCategoria)
 {
     string strResultado;
     if (SubCategoriaBusiness.ObtenerSubCategoriaPorOrden(bOrden) == null)
     {
         Subcategoria iSubcategoria = new Subcategoria();
         iSubcategoria.Orden = bOrden;
         iSubcategoria.Descripcion = string.Empty;
         iSubcategoria.CategoriaIdRaw = strCategoria;
         iSubcategoria.Id = SubCategoriaBusiness.Insertar(iSubcategoria);
         strResultado = "false|" + iSubcategoria.Id;
         return strResultado;
     }
     else
         return "true";
 }
Esempio n. 10
0
 public string Excluir(Subcategoria subcategoria)
 {
     try
     {
         //limpar antes de usar
         acessoDadosSqlServer.LimparParametros();
         //adicionar parametros
         acessoDadosSqlServer.AdicionarParametros("idProduto", subcategoria.idSubcategoria);
         //chamar a procedure para manipulação
         string idSubcategoria = acessoDadosSqlServer.ExecutarManipulacao(CommandType.Text, "").ToString();
         return(idSubcategoria);
     }
     catch (Exception exception)
     {
         return(exception.Message);
     }
 }
    public List <Subcategoria> obtenerPsubcategorias()
    {
        List <Subcategoria> x = new List <Subcategoria>();

        using (var db = new Mapeo())
        {
            x = db.subcategoria.ToList();
        }
        Subcategoria y = new Subcategoria();

        y.Id            = 0;
        y.Descripcion   = "seleccione";
        y.Id_categoria  = 0;
        y.Subcategorias = "seleccione";
        x.Add(y);
        return(x);
    }
Esempio n. 12
0
        public ActionResult SalvarSubCategoria(Subcategoria model)
        {
            using (GENPsCEntities1 ent = new GENPsCEntities1())
            {
                if (model.ID > 0)//edit
                {
                    Subcategoria subcat = ent.Subcategoria.SingleOrDefault(x => x.ID == model.ID);
                    subcat.Nome         = model.Nome;
                    subcat.ID_CATEGORIA = model.ID_CATEGORIA;
                }
                else //insert
                {
                    ent.Subcategoria.Add(model);
                }
                ent.SaveChanges();
            }

            return(RedirectToAction("SubCategoria"));
        }
Esempio n. 13
0
        public string InsertarSubCategoria(byte bOrden, string strCategoria)
        {
            string strResultado;

            if (SubcategoriaBusiness.ObtenerSubCategoriaPorOrden(bOrden) == null)
            {
                Subcategoria iSubcategoria = new Subcategoria();
                iSubcategoria.Orden       = bOrden;
                iSubcategoria.Descripcion = string.Empty;
                iSubcategoria.Categoria   = strCategoria;
                iSubcategoria.ID          = SubcategoriaBusiness.Insertar(iSubcategoria);
                strResultado = "false|" + iSubcategoria.ID;
                return(strResultado);
            }
            else
            {
                return("true");
            }
        }
Esempio n. 14
0
 protected void Page_Init(object sender, EventArgs e)
 {
     // it gets an appropiate context (LainsaSciCTX -> web.config)
     ctx = new LainsaSci("LainsaSciCTX");
     // verify if a Usuario is logged
     usuario = CntWinWeb.IsSomeoneLogged(this, ctx);
     if (usuario == null)
     {
         Response.Redirect("Default.aspx");
     }
     else
     {
         Session["UsuarioId"] = usuario.UsuarioId;
     }
     //
     permiso = CntLainsaSci.GetPermiso(usuario.GrupoUsuario, "Subcategoriagrid", ctx);
     if (permiso == null)
     {
         RadNotification1.Text = String.Format("<b>{0}</b><br/>{1}",
                                               (string)GetGlobalResourceObject("ResourceLainsaSci", "Warning"),
                                               (string)GetGlobalResourceObject("ResourceLainsaSci", "NoPermissionsAssigned"));
         RadNotification1.Show();
         RadAjaxManager1.ResponseScripts.Add("closeWindow();");
     }
     btnAccept.Visible = permiso.Modificar;
     // load the combo
     // Is it a new record or not?
     if (Request.QueryString["SubcategoriaId"] != null)
     {
         Subcategoria = CntLainsaSci.GetSubcategoria(int.Parse(Request.QueryString["SubcategoriaId"]), ctx);
         LoadData(Subcategoria);
         newRecord = false;
     }
     if (Request.QueryString["Caller"] != null)
     {
         caller = Request.QueryString["Caller"];
     }
     // control de skin
     if (Session["Skin"] != null)
     {
         RadSkinManager1.Skin = Session["Skin"].ToString();
     }
 }
Esempio n. 15
0
        public Subcategoria SubcategoriaObtenerCache(int id)
        {
            Subcategoria subcateReturn = null;

            this.TipoObtenerVigentesCache().ForEach(delegate(Tipo tipo)
            {
                tipo.Categorias.ToList <Categoria>().ForEach(delegate(Categoria catego)
                {
                    catego.Subcategorias.ToList <Subcategoria>().ForEach(delegate(Subcategoria subcate)
                    {
                        if (subcate.Id == id)
                        {
                            subcateReturn = subcate;
                            return;
                        }
                    });
                });
            });
            return(subcateReturn);
        }
Esempio n. 16
0
        public string Alterar(Subcategoria subcategoria)
        {
            try
            {
                //limpar antes de usar
                acessoDadosSqlServer.LimparParametros();
                //adicionar parametros
                acessoDadosSqlServer.AdicionarParametros("@idSubcategoria", subcategoria.idSubcategoria);
                acessoDadosSqlServer.AdicionarParametros("@nome", subcategoria.nome);
                acessoDadosSqlServer.AdicionarParametros("@idCategoria", subcategoria.idCategoria);

                //executa e manipula
                string idSubcategoria = acessoDadosSqlServer.ExecutarManipulacao(CommandType.Text, "").ToString();
                return(idSubcategoria);
            }
            catch (Exception exception)
            {
                return(exception.Message);
            }
        }
 protected void btn_añadir_Click(object sender, EventArgs e)
 {
     if (txt_categoria.Text != "")
     {
         Subcategoria user = new Subcategoria();
         user.Subcategorias = txt_categoria.Text;
         user.Id            = int.Parse(txt_codigo.Text);
         user.Id_categoria  = int.Parse(lista_categoria.SelectedValue);
         new DAOSubcategoria().InsertarSubcategoria(user);
         DCategorias.DataBind();
         lb_mensaje.ForeColor = Color.Green;
         lb_mensaje.Text      = "Registro Exitoso";
         txt_categoria.Text   = string.Empty;
     }
     else
     {
         lb_mensaje.ForeColor = Color.Red;
         lb_mensaje.Text      = "Dato No Registrado";
     }
 }
Esempio n. 18
0
        /// <summary>
        /// Obtener un registro de SubCategoria por su ID
        /// </summary>
        /// <param name="strID"></param>
        /// <returns></returns>
        public static Subcategoria ObtenerSubCategoriaPorID(string strID)
        {
            try
            {
                //1. Configurar la conexión y el tipo de comando
                SqlConnection sqlcConectar = new SqlConnection(ConfigurationManager.ConnectionStrings["OSEF"].ConnectionString);
                SqlCommand    sqlcComando  = new SqlCommand();
                sqlcComando.Connection  = sqlcConectar;
                sqlcComando.CommandType = CommandType.StoredProcedure;
                sqlcComando.CommandText = "web_spS_ObtenerSubCategoriaPorID";

                //2. Declarar los parametros
                SqlParameter sqlpID = new SqlParameter();
                sqlpID.ParameterName = "@ID";
                sqlpID.SqlDbType     = SqlDbType.Char;
                sqlpID.Size          = 6;
                sqlpID.Value         = strID;

                //3. Agregar los parametros al comando
                sqlcComando.Parameters.Add(sqlpID);

                //4. Abrir la conexión
                sqlcComando.Connection.Open();

                //5. Ejecutar la instrucción SELECT que regresa filas
                SqlDataReader reader = sqlcComando.ExecuteReader();

                //6. Asignar la lista de Clientes
                Subcategoria result = LibraryGenerics <Subcategoria> .ConvertDataSetToList(reader).FirstOrDefault();

                //7. Cerrar la conexión
                sqlcComando.Connection.Close();

                //8. Regresar el resultado
                return(result);
            }
            catch (Exception ex)
            {
                throw new Exception("Error capa de datos (public static Subcategoria ObtenerSubCategoriaPorID(string " + strID + ")): " + ex.Message);
            }
        }
    protected void grDatos_RowCommand(object sender, GridViewCommandEventArgs e)
    {
        DataRow row = dt.Rows[int.Parse(e.CommandArgument.ToString())];
        int id = int.Parse(row["idsubcategorias"].ToString());

        if (e.CommandName.Equals("btnEditar"))
        {
            Subcategoria cat = new Subcategoria(id);
            if (DAOSubcategoria.sqlLeer(cat))
            {
                btnCancelar.Visible = true;
                hdnId.Value = id.ToString();
                hdnAccion.Value = "u";
                btnAgregar.Text = "Editar";
                btnAgregar.CssClass = "btn btn-success";

                txtNombre.Text = cat.Nombre;
            }

        }

        if (e.CommandName.Equals("btnEliminar"))
        {
            if (DAOSubcategoria.sqlDelete(new Subcategoria(id)))
            {
                hdnAccion.Value = "d";
                panelMensajesCorrectos.Visible = true;
                lblMensajes.Text = "Categoria <b>" + txtNombre.Text + "</b> eliminada con éxito.";
                hdnAccion.Value = "i";
                btnAgregar.Text = "Agregar";
                btnAgregar.CssClass = "btn btn-primary";
            }
            else
            {
                panelMensajesErrores.Visible = true;
                lblErrores.Text = "No se ha podido eliminar la categoría. Intente de nuevo.";
            }

            cargarGrilla();
        }
    }
Esempio n. 20
0
    protected void RadGrid1_ItemCommand(object sender, GridCommandEventArgs e)
    {
        // we only process commands with a datasource (our image buttons)
        if (e.CommandSource == null)
        {
            return;
        }
        string typeOfControl = e.CommandSource.GetType().ToString();

        if (typeOfControl.Equals("System.Web.UI.WebControls.ImageButton"))
        {
            int         id   = 0;
            ImageButton imgb = (ImageButton)e.CommandSource;
            if (imgb.ID != "New" && imgb.ID != "Exit")
            {
                id = int.Parse(e.Item.OwnerTableView.DataKeyValues[e.Item.ItemIndex][e.Item.OwnerTableView.DataKeyNames[0]].ToString());
            }
            switch (imgb.ID)
            {
            case "Select":
                break;

            case "Edit":
                break;

            case "Delete":
                try
                {
                    Subcategoria sc = CntLainsaSci.GetSubcategoria(id, ctx);
                    CntLainsaSci.CTXEliminar(sc, ctx);
                    CntLainsaSci.CTXGuardar(ctx);
                    RefreshGrid(true);
                }
                catch (Exception ex)
                {
                    ControlDeError(ex);
                }
                break;
            }
        }
    }
Esempio n. 21
0
        /// <summary>
        /// Funcion que permite modificar el nombre de la SubCategoria pasada por parametro
        /// </summary>
        /// <param name="subcategoria"></param>
        /// <returns>Retorna un mensaje ("" si todo ha ido bien)</returns>
        public String ModificarSubCategoria(Subcategoria subcategoria)
        {
            try
            {
                using (var con = GetInstance())
                {
                    var           query = "UPDATE subcategoria Set NombreSubCategoria = @NombreSubCategoria WHERE CodigoSubCategoria = @CodigoSubCategoria";
                    SQLiteCommand cmd   = new SQLiteCommand(query, con);
                    cmd.Parameters.AddWithValue("@NombreSubCategoria", subcategoria.nombreSubCategoria);
                    cmd.Parameters.AddWithValue("@CodigoSubCategoria", subcategoria.codSubCategoria);

                    cmd.ExecuteNonQuery();
                    con.Close();
                }
            }
            catch (Exception e)
            {
                return(e.Message);
            }
            return("");
        }
Esempio n. 22
0
        public List <Subcategoria> ListadoSubcategorias()
        {
            List <Subcategoria> lista = new List <Subcategoria>();

            con.Open();
            SqlCommand    cmd    = new SqlCommand("select ID_SUB,DES_SUB from SUBCATEGORIAS", con);
            SqlDataReader reader = cmd.ExecuteReader();

            while (reader.Read())
            {
                Subcategoria c = new Subcategoria();
                c.id          = reader.GetInt32(0);
                c.descripcion = reader.GetString(1);

                lista.Add(c);
            }
            reader.Close();
            con.Close();

            return(lista);
        }
Esempio n. 23
0
        public List <Subcategoria> CargarSubcategoria(out string msg)
        {
            List <Subcategoria> subcategorias = new List <Subcategoria>();

            try
            {
                using (var con = GetInstance())
                {
                    string           SelectSubcategoria = "SELECT * FROM subcategoria;";
                    SQLiteCommand    cmd    = new SQLiteCommand(SelectSubcategoria, con);
                    SQLiteDataReader lector = cmd.ExecuteReader();

                    if (!lector.HasRows)
                    {
                        msg = "No hay Subcategorias";
                        con.Close();
                        return(subcategorias);
                    }

                    while (lector.Read())
                    {
                        Subcategoria newSubcategoria = new Subcategoria();
                        newSubcategoria.codSubCategoria    = int.Parse(lector["CodigoSubcategoria"].ToString());
                        newSubcategoria.nombreSubCategoria = lector["NombreSubcategoria"].ToString();

                        subcategorias.Add(newSubcategoria);
                    }

                    con.Close();
                    lector.Close();
                    msg = "";
                    return(subcategorias);
                }
            }
            catch (Exception)
            {
                msg = "Error al cargar las Subcategorias ";
                return(subcategorias);
            }
        }
Esempio n. 24
0
        public SubcategoriaColecao ConsultarNome(string nome)
        {
            try
            {
                //Cria uma coleção nova de cliente(aqui ela está vazia)
                SubcategoriaColecao subcategoriaColecao = new SubcategoriaColecao();
                //limpar antes de usar
                acessoDadosSqlServer.LimparParametros();
                //adicionar parametros
                acessoDadosSqlServer.AdicionarParametros("@nome", nome);
                //manipulando dados e coloca dentro de um DataTable
                DataTable dataTableSubcategoria = acessoDadosSqlServer.ExecutarConsulta(CommandType.Text, "");

                //percorrer o DataTable e transformar em uma coleção de clientes
                //cada linha do DataTable é uma cliente
                //o foreach vai percorrer cada linha(DataRow) pegando os dados que estiverem lá
                foreach (DataRow linha in dataTableSubcategoria.Rows)
                {
                    //criar um cliente vazio e colocar os dados da linha nele e depois adiciona ele na colecao
                    Subcategoria subcategoria = new Subcategoria();
                    //
                    subcategoria.idSubcategoria = Convert.ToInt32(linha["IdSubcategoria"]);
                    subcategoria.nome           = Convert.ToString(linha["nome"]);
                    subcategoria.idCategoria    = Convert.ToInt32(linha["idCategoria"]);


                    //adiciona os dados de cliente na clienteColecao
                    subcategoriaColecao.Add(subcategoria);
                }

                //retorna a coleção de crientes que foi encotrada no banco
                return(subcategoriaColecao);
            }
            catch (Exception exception)
            {
                //exibindo message caso de um erro na consuta(cria nova exeção)
                throw new Exception("Não foi possivel consultar o Produto por nome. \nDetalhes: " + exception.Message);
            }
        }
        public IList <Subcategoria> CarregarSubcategorias()
        {
            Subcategoria subcategoria;
            SqlCommand   cmd = new SqlCommand("select * from subcategoria", Conexao.connection);

            Conexao.Open();
            SqlDataReader       dr = cmd.ExecuteReader();
            List <Subcategoria> listaSubcategorias = new List <Subcategoria>();

            if (dr.HasRows)
            {
                while (dr.Read())
                {
                    subcategoria              = new Subcategoria();
                    subcategoria.Id           = (int)(dr[0]);
                    subcategoria.Nome         = (dr[1]).ToString();
                    subcategoria.Id_categoria = (int)(dr[2]);
                    listaSubcategorias.Add(subcategoria);
                }
            }
            Conexao.Close();
            return(listaSubcategorias);
        }
Esempio n. 26
0
        public string Inserir(Subcategoria subcategoria)
        {
            try
            {
                //limpar antes de usar
                acessoDadosSqlServer.LimparParametros();
                //adiciona
                acessoDadosSqlServer.AdicionarParametros("@nome", subcategoria.nome);
                acessoDadosSqlServer.AdicionarParametros("@idCategoria", subcategoria.idCategoria);

                //executa a manipulção
                string idSubcategoria = acessoDadosSqlServer.ExecutarManipulacao(CommandType.Text, "").ToString();
                return(idSubcategoria);
            }
            catch (Exception exception)
            {
                //exibi o erro que vc quiser
                //throw new Exception(exception.message);

                //retorna o erro que deu
                return(exception.Message);
            }
        }
        protected void btnCadastrarProduto_Click(object sender, EventArgs e)
        {
            Produto p = new Produto();

            var codAlt = Page.Request.QueryString["codalt"];
            var pAlt   = Produto.ObterProdutoByCodigo(Convert.ToInt32(codAlt));

            if (codAlt != null)
            {
                if (pAlt != null)
                {
                    p.NomeProduto            = inpNomeProduto.Value;
                    p.PesoVolumeProduto      = Convert.ToDecimal(inpPesoVolume.Value);
                    p.PrecoProduto           = Convert.ToDecimal(inpPreco.Value);
                    p.Produto_IdSubcategoria = Subcategoria
                                               .ObterSubcategorias()
                                               .FirstOrDefault(s => s.IdSubcategoria == Convert.ToInt32(ddlSubcategorias.SelectedValue))
                                               .IdSubcategoria;

                    alterarDadosProduto(Convert.ToInt32(codAlt), p);
                }
            }
            else
            {
                p.NomeProduto            = inpNomeProduto.Value;
                p.PesoVolumeProduto      = Convert.ToDecimal(inpPesoVolume.Value);
                p.PrecoProduto           = Convert.ToDecimal(inpPreco.Value);
                p.EstoqueProduto         = 0;
                p.Produto_IdSubcategoria = Subcategoria
                                           .ObterSubcategorias()
                                           .FirstOrDefault(s => s.IdSubcategoria == Convert.ToInt32(ddlSubcategorias.SelectedValue))
                                           .IdSubcategoria;
                var qtdEstoque = Convert.ToInt32(inpEstoque.Value);

                Produto.CadastrarProduto(p, qtdEstoque);
            }
        }
Esempio n. 28
0
    public Subcategoria SelectSubUsuario(int sub_codigo)
    {
        Subcategoria sub = null;

        System.Data.IDbConnection objConexao;
        System.Data.IDbCommand    objCommand;
        System.Data.IDataReader   objDataReader;
        objConexao = Mapped.Connection();
        objCommand = Mapped.Command("SELECT * FROM sub_subcategorias WHERE sub_codigo = ?sub_codigo", objConexao);
        objCommand.Parameters.Add(Mapped.Parameter("?sub_codigo", sub_codigo));
        objDataReader = objCommand.ExecuteReader();
        while (objDataReader.Read())
        {
            sub            = new Subcategoria();
            sub.Sub_codigo = Convert.ToInt32(objDataReader["sub_codigo"]);
            sub.Sub_nome   = Convert.ToString(objDataReader["sub_nome"]);
        }
        objDataReader.Close();
        objConexao.Close();
        objCommand.Dispose();
        objConexao.Dispose();
        objDataReader.Dispose();
        return(sub);
    }
Esempio n. 29
0
 protected void Page_Init(object sender, EventArgs e)
 {
     // it gets an appropiate context (LainsaSciCTX -> web.config)
     ctx = new LainsaSci("LainsaSciCTX");
     // verify if a Usuario is logged
     uex = CntLainsaSci.GetUsuarioExtranet((int)Session["UsuarioExtranetId"], ctx);
     if (uex == null)
     {
         Response.Redirect("Default.aspx");
     }
     // si llega aquí está autorizado
     if (Request.QueryString["EmpresaId"] != null)
     {
         empresaId = int.Parse(Request.QueryString["EmpresaId"]);
         empresa   = CntLainsaSci.GetEmpresa(empresaId, ctx);
     }
     if (Request.QueryString["CategoriaId"] != null)
     {
         categoriaId = int.Parse(Request.QueryString["CategoriaId"]);
         categoria   = CntLainsaSci.GetCategoria(categoriaId, ctx);
     }
     if (Request.QueryString["InstalacionId"] != null)
     {
         instalacionId = int.Parse(Request.QueryString["InstalacionId"]);
         instalacion   = CntLainsaSci.GetInstalacion(instalacionId, ctx);
     }
     if (Request.QueryString["SubCategoriaId"] != null)
     {
         subCategoriaId = int.Parse(Request.QueryString["SubCategoriaId"]);
         subCategoria   = CntLainsaSci.GetSubcategoria(subCategoriaId, ctx);
     }
     if (Request.QueryString["REVISION"] != null)
     {
         revisables = true;
     }
 }
 private void btnAñadirSubCategoria_Click(object sender, EventArgs e)
 {
     {
         try
         {
             Subcategoria nuevaSubCategoria = new Subcategoria(txtAñadirSubCategoria.Text);
             mensaje = Program.Gestor.AñadirSubCategoria(nuevaSubCategoria, (Categoria)cboCatAñadirSubCategoria.SelectedItem);
             if (mensaje != "")
             {
                 MessageBox.Show(mensaje);
             }
             else
             {
                 cboCatAñadirSubCategoria.SelectedItem = null;
                 txtAñadirCategoria.Text = "";
                 cargarCBOs();
             }
         }
         catch (Exception ex)
         {
             MessageBox.Show(ex.Message);
         }
     }
 }
Esempio n. 31
0
        public List <Subcategoria> ListadoSubcategorias(int idCat)
        {
            List <Subcategoria> lista = new List <Subcategoria>();

            con.Open();
            SqlCommand cmd = new SqlCommand("USP_OBTENER_SUBCATEGORIAS", con);

            cmd.CommandType = System.Data.CommandType.StoredProcedure;
            cmd.Parameters.AddWithValue("@IDCAT", idCat);
            SqlDataReader reader = cmd.ExecuteReader();

            while (reader.Read())
            {
                Subcategoria c = new Subcategoria();
                c.id          = reader.GetInt32(0);
                c.descripcion = reader.GetString(1);

                lista.Add(c);
            }
            reader.Close();
            con.Close();

            return(lista);
        }
Esempio n. 32
0
 /// <summary>
 /// Método que actualiza un nuevo registro a la tabla de SubCategorias
 /// </summary>
 /// <param name="uSubCategoria"></param>
 /// <returns></returns>
 public static int Actualizar(Subcategoria uSubCategoria)
 {
     return SubCategoriaDataAccess.Actualizar(uSubCategoria);
 }
Esempio n. 33
0
 protected void LoadData(Subcategoria Subcategoria)
 {
     CargaCategoria(Subcategoria.Categoria);
     txtNombre.Text = Subcategoria.Nombre;
 }
Esempio n. 34
0
 /// <summary>
 /// Método que inserta un nuevo registro a la tabla de SubCategorias
 /// </summary>
 /// <param name="iSubcategoria"></param>
 public static string Insertar(Subcategoria iSubcategoria)
 {
     return SubCategoriaDataAccess.Insertar(iSubcategoria);
 }
Esempio n. 35
0
 protected void UnloadData(Subcategoria Subcategoria)
 {
     Subcategoria.Nombre    = txtNombre.Text;
     Subcategoria.Categoria = CntLainsaSci.GetCategoria(int.Parse(rdcCategoria.SelectedValue), ctx);
 }