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);
}
// 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));
}
public IHttpActionResult PostSubcategoria([FromBody] Subcategoria datos)
{
try
{
ServiciosTipos servicio = new ServiciosTipos();
servicio.SubcategoriaGrabar(datos);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
//Ingresar
public bool Ingresar(Subcategoria subcat)
{
try
{
MenajesbdEntities6 ctx = new MenajesbdEntities6();
ctx.Subcategoria.Add(subcat);
ctx.SaveChanges();
return(true);
}
catch (Exception)
{
return(false);
}
}
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";
}
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);
}
// 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));
}
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";
}
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);
}
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"));
}
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");
}
}
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();
}
}
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);
}
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";
}
}
/// <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();
}
}
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;
}
}
}
/// <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("");
}
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);
}
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);
}
}
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);
}
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);
}
}
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);
}
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);
}
}
}
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);
}
/// <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);
}
protected void LoadData(Subcategoria Subcategoria)
{
CargaCategoria(Subcategoria.Categoria);
txtNombre.Text = Subcategoria.Nombre;
}
/// <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);
}
protected void UnloadData(Subcategoria Subcategoria)
{
Subcategoria.Nombre = txtNombre.Text;
Subcategoria.Categoria = CntLainsaSci.GetCategoria(int.Parse(rdcCategoria.SelectedValue), ctx);
}