private void InsertarEnHoja(NodoSucursal_Producto Padre, int Index, Sucursal_Producto _Dato)
{
if (Padre.Hijos[Index].estaCapacidadMax)
{
if (Padre.Hijos[Index + 1] != null)
{
if (Padre.Hijos[Index + 1] != null)
{
PartirEnDosTres(Padre, Index, _Dato, false);
}
else
{
RotacionDerecha(Padre, Index, _Dato);
}
}
else if (Padre.Hijos[Index - 1] != null)
{
if (Padre.Hijos[Index - 1].estaCapacidadMax)
{
PartirEnDosTres(Padre, Index, _Dato, false);
}
else
{
RotacionIzquierda(Padre, Index, _Dato);
}
}
}
else
{
InsertarNoLleno(Padre.Hijos[Index], _Dato);
}
}
private void InsertarNodoSucursal_Producto(NodoSucursal_Producto Padre, Sucursal_Producto _NDato)
{
int Index = Padre.Tamano - 1;
if (Padre.Tamano > 0)
{
while (Index >= 0 && _NDato.IdSucursal < Padre.LlavesNodos[Index].IdSucursal)
{
Index--;
}
}
if (NodoRaiz.estaCapacidadMax)
{
PartirRaiz(Padre);
InsertarNodoSucursal_Producto(NodoRaiz, _NDato);
}
else if (NodoRaiz.esNodoHoja)
{
InsertarNoLleno(Padre, _NDato);
Contador++;
if (Contador == TamanoMaximo)
{
Contador = 0;
NodoRaiz.estaCapacidadMax = true;
}
}
else if (Padre.Hijos[Index] != null && Padre.Hijos[Index].esNodoHoja)
{
InsertarEnHoja(Padre, Index, _NDato);
}
else
{
InsertarNodoSucursal_Producto(Padre.Hijos[Index], _NDato);
}
}
/// <summary>
/// Actualizar los datos de inventario del Sucursal_Producto
/// </summary>
/// <param name="_SucursalProductoActualizada">Nuevos datos de invetario de la Sucursal_Producto</param>
public void ActualizarSucursal_Producto(Sucursal_Producto _SucursalProductoActualizada)
{
string Contenido = string.Empty;
File.Delete(Ruta2);
ArbolSucursal_Producto NuevoArbolSucursal_Producto = new ArbolSucursal_Producto(9);
var Archivo = new FileStream(Ruta2, FileMode.OpenOrCreate);
Archivo.Close();
foreach (var item in LSucursal_Producto)
{
if ((item.IdSucursal == _SucursalProductoActualizada.IdSucursal) && (item.IDProducto == _SucursalProductoActualizada.IDProducto))
{
item.CantidadInvetariado = item.CantidadInvetariado + _SucursalProductoActualizada.CantidadInvetariado;
}
using (StreamReader Lector = new StreamReader(Ruta2))
{
Contenido = Lector.ReadToEnd();
}
using (StreamWriter Escritor = new StreamWriter(Ruta2))
{
Escritor.WriteLine(Contenido + item.IdSucursal.ToString() + "," + item.IDProducto.ToString() + "," + item.CantidadInvetariado.ToString());
}
NuevoArbolSucursal_Producto.InsertarSucursal_Producto(item);
}
Sucursal_Producto.NodoRaiz = NuevoArbolSucursal_Producto.NodoRaiz;
}
public ActionResult <Sucursal_Producto> Post(Sucursal_Producto item)
{
_context.Sucursales_Productos.Add(item);
_context.SaveChanges();
return(CreatedAtAction(nameof(GetById), new { id = item.Id }, item));
}
public ActionResult Create([Bind(Include = "IDSucursal,IDProducto,Stock")] Sucursal_Producto relacion)
{
if (ModelState.IsValid)
{
Data.Instance.scTree.Add(relacion);
return(RedirectToAction("Index"));
}
return(View(relacion));
}
public bool BusquedaNodo(int Id_NodoSucursal, int Id_NodoProducto)
{
Sucursal_Producto NodoResultante = BusquedaNodoComparar(NodoRaiz, Id_NodoSucursal, Id_NodoProducto);
if (NodoResultante != null)
{
return(true);
}
return(false);
}
public ActionResult <Sucursal_Producto> Put(int id, Sucursal_Producto item)
{
if (id != item.Id)
{
return(BadRequest());
}
_context.Entry(item).State = EntityState.Modified;
_context.SaveChanges();
return(Ok());
}
private void RotacionDerecha(NodoSucursal_Producto Padre, int Id_Hijo, Sucursal_Producto _NDato)
{
int llaveDelId_Padre;
int TamanoNodoSucursal_Producto = Padre.Hijos[Id_Hijo].Tamano;
if (Id_Hijo == 0)
{
llaveDelId_Padre = 0;
}
else if (Id_Hijo == TamanoNodoSucursal_Producto)
{
llaveDelId_Padre = TamanoNodoSucursal_Producto - 1;
}
else
{
llaveDelId_Padre = Id_Hijo;
}
int TamanoNodoSucursal_ProductoHermano = Padre.Hijos[Id_Hijo + 1].Tamano;
for (int j = TamanoNodoSucursal_ProductoHermano - 1; j >= 0; j--)
{
Padre.Hijos[Id_Hijo + 1].LlavesNodos[j + 1] = Padre.Hijos[Id_Hijo + 1].LlavesNodos[j];
}
if (!Padre.Hijos[Id_Hijo].esNodoHoja)
{
for (int j = TamanoNodoSucursal_ProductoHermano; j >= 0; j--)
{
Padre.Hijos[Id_Hijo + 1].Hijos[0] = Padre.Hijos[Id_Hijo + 1].Hijos[j];
Padre.Hijos[Id_Hijo + 1].Hijos[0] = Padre.Hijos[Id_Hijo].Hijos[TamanoNodoSucursal_ProductoHermano];
Padre.Hijos[Id_Hijo].Hijos[TamanoNodoSucursal_ProductoHermano] = null;
}
}
Padre.Hijos[Id_Hijo + 1].LlavesNodos[0] = Padre.LlavesNodos[llaveDelId_Padre];
Padre.Hijos[Id_Hijo + 1].Tamano++;
if (Padre.Hijos[Id_Hijo].esNodoHoja && _NDato.IdSucursal <Padre.LlavesNodos[llaveDelId_Padre].IdSucursal && _NDato.IdSucursal> Padre.Hijos[Id_Hijo].LlavesNodos[TamanoNodoSucursal_Producto - 1].IdSucursal)
{
Padre.LlavesNodos[llaveDelId_Padre] = _NDato;
}
else
{
Padre.LlavesNodos[llaveDelId_Padre] = Padre.Hijos[Id_Hijo].LlavesNodos[TamanoNodoSucursal_Producto - 1];
Padre.Hijos[Id_Hijo].LlavesNodos[TamanoNodoSucursal_Producto - 1] = null;
Padre.Hijos[Id_Hijo].Tamano--;
InsertarNoLleno(Padre.Hijos[Id_Hijo], _NDato);
}
if (Padre.Hijos[Id_Hijo + 1].Tamano == TamanoNodoSucursal_Producto)
{
Padre.Hijos[Id_Hijo + 1].estaCapacidadMax = true;
}
}
private void RotacionIzquierda(NodoSucursal_Producto Padre, int IndiceHijo, Sucursal_Producto _NDato)
{
int llaveIndexPadre;
if (IndiceHijo == 0)
{
llaveIndexPadre = 0;
}
else if (IndiceHijo == TamanoMaximo)
{
llaveIndexPadre = TamanoMaximo - 1;
}
else
{
llaveIndexPadre = IndiceHijo - 1;
}
InsertarNoLleno(Padre.Hijos[IndiceHijo - 1], Padre.LlavesNodos[llaveIndexPadre]);
if (Padre.Hijos[IndiceHijo].esNodoHoja && _NDato.IdSucursal > Padre.LlavesNodos[llaveIndexPadre].IdSucursal && _NDato.IdSucursal < Padre.Hijos[IndiceHijo].LlavesNodos[0].IdSucursal)
{
Padre.LlavesNodos[llaveIndexPadre] = _NDato;
}
else
{
Padre.LlavesNodos[llaveIndexPadre] = Padre.Hijos[IndiceHijo].LlavesNodos[0];
int tamañoNodoP = Padre.Hijos[IndiceHijo].Tamano;
for (int i = 0; i < tamañoNodoP - 1; i++)
{
Padre.Hijos[IndiceHijo].LlavesNodos[i] = Padre.Hijos[IndiceHijo].LlavesNodos[i + 1];
}
if (!Padre.Hijos[IndiceHijo].esNodoHoja)
{
Padre.Hijos[IndiceHijo].Hijos[tamañoNodoP] = Padre.Hijos[IndiceHijo].Hijos[0];
for (int i = 0; i < tamañoNodoP - 1; i++)
{
Padre.Hijos[IndiceHijo].Hijos[i] = Padre.Hijos[IndiceHijo].Hijos[i + 1];
}
}
Padre.Hijos[IndiceHijo].LlavesNodos[tamañoNodoP - 1] = null;
Padre.Hijos[IndiceHijo].Tamano--;
Padre.Hijos[IndiceHijo].estaCapacidadMax = false;
InsertarNoLleno(Padre.Hijos[IndiceHijo], _NDato);
}
}
// GET: Administrar/Edit/5
/// <summary>
/// Devuelve los datos originales del objeto a modificar
/// </summary>
/// <param name="id">ID del objeto Sucursal-Producto a modificar</param>
/// <returns></returns>
public ActionResult Edit(int?id)
{
Sucursal_Producto producto = new Sucursal_Producto();
List <Sucursal_Producto> elements = Data.Instance.scTree.ToList();
for (int i = 0; i < elements.Count; i++)
{
if (elements[i].IDSucursal == id)
{
producto = elements[i];
}
}
return(View(producto));
}
/// <summary>
/// Lectura de la Sucursal_Producto del .csv
/// </summary>
public void LecturaSucursal_Producto()
{
using (StreamReader Lector = new StreamReader(Ruta2))
{
string NuevaLinea = "";
while ((NuevaLinea = Lector.ReadLine()) != null)
{
string[] LecturaSucursal_Producto = NuevaLinea.Split(',');
Sucursal_Producto NuevaSucursal_Producto = new Sucursal_Producto();
NuevaSucursal_Producto.IdSucursal = Convert.ToInt32(LecturaSucursal_Producto[0]);
NuevaSucursal_Producto.IDProducto = Convert.ToInt32(LecturaSucursal_Producto[1]);
NuevaSucursal_Producto.CantidadInvetariado = Convert.ToInt32(LecturaSucursal_Producto[2]);
Sucursal_Producto.InsertarSucursal_Producto(NuevaSucursal_Producto);
LSucursal_Producto.Add(NuevaSucursal_Producto);
}
}
}
public string AgregarSucursalProducto([FromForm] Sucursal_Producto _NSucursalProducto)
{
if (_NSucursalProducto.IdSucursal >= 0 && _NSucursalProducto.IDProducto >= 0 && _NSucursalProducto.CantidadInvetariado >= 0)
{
var ExistenciaSucursal = MetodosNecesarios.Sucursales.BusquedaNodo(_NSucursalProducto.IdSucursal);
var ExistenciaProducto = MetodosNecesarios.Producto.BusquedaNodo(_NSucursalProducto.IDProducto);
if ((ExistenciaSucursal == true) && (ExistenciaProducto == true))
{
MetodosNecesarios.InsertarSucursal_Producto(_NSucursalProducto);
return("Se ha agregado Correctamente la nueva Sucursal_Producto");
}
return("Se ha agregado nuevo Sucursal_Producto");
}
else
{
return("Nuevo Sucursal_Producto Vacio o No existe (Sucursal o Producto)");
}
}
public ActionResult Edit([Bind(Include = "IDSucursal,IDProducto,Stock")] Sucursal_Producto relacion)
{
if (ModelState.IsValid)
{
Sucursal_Producto auxiliar = new Sucursal_Producto();
List <Sucursal_Producto> elements = Data.Instance.scTree.ToList();
for (int i = 0; i < elements.Count; i++)
{
if (elements[i].IDSucursal == relacion.IDSucursal)
{
auxiliar = elements[i];
}
}
Data.Instance.scTree.UpDate(auxiliar, relacion);
return(RedirectToAction("Index"));
}
return(View(relacion));
}
public string ActualizarSucursalProducto([FromForm] Sucursal_Producto _SucursalProductoActualizada)
{
if (_SucursalProductoActualizada.IdSucursal >= 0 && _SucursalProductoActualizada.IDProducto >= 0 && _SucursalProductoActualizada.CantidadInvetariado >= 0)
{
var ExistenciaSucursalProducto = MetodosNecesarios.Sucursal_Producto.BusquedaNodo(_SucursalProductoActualizada.IdSucursal, _SucursalProductoActualizada.IDProducto);
if (ExistenciaSucursalProducto == true)
{
MetodosNecesarios.ActualizarSucursal_Producto(_SucursalProductoActualizada);
return("El Id_Sucursal: (" + _SucursalProductoActualizada.IdSucursal + ") y el Id_Producto (" + _SucursalProductoActualizada.IDProducto + ") Ha sido actualizada en su inventario");
}
else
{
return("La Sucursal_Producto que se requiere actualizar no existe en el recuento de Sucursal_Producto");
}
}
else
{
return("Se ha enviado una modificacion de Sucursal_Producto erronea");
}
}
/// <summary>
/// Metodo para agregar una nueva Sucursal_Producto dentro del arbol de Sucursal_Producto
/// </summary>
/// <param name="_NuevaSucursal_Producto">Nueva Sucursal_Producto a ser agregado</param>
public void InsertarSucursal_Producto(Sucursal_Producto _NuevaSucursal_Producto)
{
if (_NuevaSucursal_Producto.IdSucursal >= 0 && _NuevaSucursal_Producto.IDProducto >= 0 && _NuevaSucursal_Producto.CantidadInvetariado >= 0)
{
string Contenido = string.Empty;
using (StreamReader Lector = new StreamReader(Ruta2))
{
Contenido = Lector.ReadToEnd();
}
string NuevoDato = _NuevaSucursal_Producto.IdSucursal + "," + _NuevaSucursal_Producto.IDProducto + "," + _NuevaSucursal_Producto.CantidadInvetariado;
using (StreamWriter Escritor = new StreamWriter(Ruta2))
{
Escritor.WriteLine(Contenido + NuevoDato);
}
Sucursal_Producto.InsertarSucursal_Producto(_NuevaSucursal_Producto);
LSucursal_Producto.Add(_NuevaSucursal_Producto);
}
else
{
throw new Exception("El nuevo valor es vacio o se encuentra incompleto");
}
}
public NodoSucursal_Producto(int GradoArbol)
{
GradoMaximo = GradoArbol;
LlavesNodos = new Sucursal_Producto[GradoArbol - 1];
Hijos = new NodoSucursal_Producto[GradoArbol];
}
public ActionResult Transfer(int id, int id2, int idproducto, int qty)
{
if (ModelState.IsValid)
{
Sucursal_Producto origen = new Sucursal_Producto();
Sucursal_Producto destino = new Sucursal_Producto();
List <Sucursal_Producto> elements = Data.Instance.scTree.ToList();
for (int i = 0; i < elements.Count; i++)
{
if (elements[i].IDSucursal == id)
{
origen = elements[i];
}
if (elements[i].IDSucursal == id2)
{
destino = elements[i];
}
}
//comprobar si la sucursal destino tiene el producto
if (destino.IDProducto == idproducto) //transferir
{
Sucursal_Producto origenModified = new Sucursal_Producto
{
IDSucursal = origen.IDSucursal,
IDProducto = origen.IDProducto,
Stock = origen.Stock - qty
};
Sucursal_Producto destinoModified = new Sucursal_Producto
{
IDSucursal = destino.IDSucursal,
IDProducto = destino.IDProducto,
Stock = destino.Stock + qty
};
Data.Instance.scTree.UpDate(origen, origenModified);
Data.Instance.scTree.UpDate(destino, destinoModified);
}
else //crear nueva relacion
{
Sucursal_Producto origenModified = new Sucursal_Producto
{
IDSucursal = origen.IDSucursal,
IDProducto = origen.IDProducto,
Stock = origen.Stock - qty
};
Sucursal_Producto nueva = new Sucursal_Producto
{
IDSucursal = id2,
IDProducto = idproducto,
Stock = qty
};
Data.Instance.scTree.UpDate(origen, origenModified);
Data.Instance.scTree.Add(nueva);
}
//Data.Instance.scTree.UpDate(auxiliar, producto);
return(RedirectToAction("Index"));
}
return(View());
}
private void InsertarNoLleno(NodoSucursal_Producto NodoActual, Sucursal_Producto _Dato)
{
var i = NodoActual.Tamano - 1;
var m = NodoActual.Tamano;
if (!NodoActual.esNodoHoja)
{
while (i >= 0 && _Dato.IdSucursal < NodoActual.LlavesNodos[i].IdSucursal)
{
NodoActual.LlavesNodos[i + 1] = NodoActual.LlavesNodos[i];
NodoActual.Hijos[i + 2] = NodoActual.Hijos[i + 1];
i--;
}
}
else
{
while (i >= 0 && _Dato.IdSucursal < NodoActual.LlavesNodos[i].IdSucursal)
{
NodoActual.LlavesNodos[i + 1] = NodoActual.LlavesNodos[i];
i--;
}
}
NodoActual.LlavesNodos[i + 1] = _Dato;
NodoActual.Tamano++;
if (!NodoActual.esNodoHoja)
{
var _x = i + 1;
var _c = i + 2;
NodoActual.Hijos[_c] = NodoActual.Hijos[_x];
NodoActual.Hijos[_x] = new NodoSucursal_Producto(TamanoMaximo);
int j = 0;
for (; NodoActual.Hijos[_c].LlavesNodos[j].IdSucursal < _Dato.IdSucursal; j++)
{
NodoActual.Hijos[_x].LlavesNodos[j] = NodoActual.Hijos[_c].LlavesNodos[j];
if (!NodoActual.Hijos[_c].esNodoHoja)
{
NodoActual.Hijos[_x].Hijos[j] = NodoActual.Hijos[_c].Hijos[j];
}
NodoActual.Hijos[_c].Tamano--;
NodoActual.Hijos[_x].Tamano++;
}
int _k;
for (_k = j; _k < m; _k++)
{
NodoActual.Hijos[_c].LlavesNodos[_k - j] = NodoActual.Hijos[_c].LlavesNodos[_k];
NodoActual.Hijos[_c].LlavesNodos[_k] = null;
if (!NodoActual.Hijos[_c].esNodoHoja)
{
NodoActual.Hijos[_c].Hijos[_k - j] = NodoActual.Hijos[_c].Hijos[_k];
NodoActual.Hijos[_c].Hijos[_k] = null;
}
}
if (!NodoActual.Hijos[_c].esNodoHoja)
{
NodoActual.Hijos[_c].Hijos[NodoActual.Hijos[_c].Tamano] = NodoActual.Hijos[_c].Hijos[_k - 1];
}
if (NodoActual.Tamano == TamanoMaximo - 1)
{
NodoActual.estaCapacidadMax = true;
}
}
}
public void InsertarSucursal_Producto(Sucursal_Producto _NSucursal_Producto)
{
InsertarNodoSucursal_Producto(NodoRaiz, _NSucursal_Producto);
}
private void PartirEnDosTres(NodoSucursal_Producto Padre, int IndiceHijoCapacidadMaxima, Sucursal_Producto _NDato, bool EsHermanoIzq)
{
int IndiceLadoIzquierdo = EsHermanoIzq ? (IndiceHijoCapacidadMaxima - 1) : IndiceHijoCapacidadMaxima;
int IndiceLadoDerecho = EsHermanoIzq ? (IndiceHijoCapacidadMaxima) : IndiceHijoCapacidadMaxima + 1;
int TamanoDivision = (TamanoMaximo * 2) / 3;
int IndiceLlavePadre = EsHermanoIzq ? (IndiceHijoCapacidadMaxima - 1) : (IndiceHijoCapacidadMaxima);
int TamanoMaximoNodoSucursal_Producto = TamanoMaximo - 1;
bool esNodoHoja = Padre.Hijos[IndiceHijoCapacidadMaxima].esNodoHoja;
int _j = 0;
var arregloP = new Sucursal_Producto[TamanoMaximo * 2];
var hijosP = new NodoSucursal_Producto[TamanoMaximo * 2];
for (int i = 0; i < TamanoMaximoNodoSucursal_Producto; i++)
{
arregloP[_j++] = Padre.Hijos[IndiceLadoIzquierdo].LlavesNodos[i];
arregloP[_j++] = Padre.Hijos[IndiceLadoDerecho].LlavesNodos[i];
}
arregloP[_j++] = _NDato;
arregloP[_j++] = Padre.LlavesNodos[IndiceLlavePadre];
if (!esNodoHoja)
{
int _x = 0;
for (int i = 0; i < TamanoMaximo; i++)
{
hijosP[_x++] = Padre.Hijos[IndiceLadoIzquierdo].Hijos[i];
}
for (int i = 0; i < TamanoMaximo; i++)
{
hijosP[_x++] = Padre.Hijos[IndiceLadoDerecho].Hijos[i];
}
}
_j = 0;
int k;
for (k = 0; k < TamanoDivision; k++)
{
Padre.Hijos[IndiceLadoIzquierdo].LlavesNodos[k] = arregloP[_j++];
}
while (k < TamanoMaximoNodoSucursal_Producto)
{
Padre.Hijos[IndiceLadoIzquierdo].LlavesNodos[k++] = null;
Padre.Hijos[IndiceLadoIzquierdo].Tamano--;
}
Padre.Hijos[IndiceLadoIzquierdo].estaCapacidadMax = false;
Sucursal_Producto PadreN = arregloP[_j++];
Padre.LlavesNodos[IndiceLlavePadre] = PadreN;
for (k = 0; k < TamanoDivision; k++)
{
Padre.Hijos[IndiceLadoDerecho].LlavesNodos[k] = arregloP[_j++];
}
while (k < TamanoMaximoNodoSucursal_Producto)
{
Padre.Hijos[IndiceLadoDerecho].LlavesNodos[k++] = null;
Padre.Hijos[IndiceLadoDerecho].Tamano--;
}
Padre.Hijos[IndiceLadoDerecho].estaCapacidadMax = false;
Sucursal_Producto Padre2N = arregloP[_j++];
var NodoNuevoSucursal_Producto = new NodoSucursal_Producto(TamanoMaximo);
for (k = 0; _j < TamanoMaximo * 2; k++)
{
NodoNuevoSucursal_Producto.LlavesNodos[k] = arregloP[_j++];
NodoNuevoSucursal_Producto.Tamano++;
}
var NuevoNodoDerecho = Padre.Hijos[IndiceLadoDerecho];
if (Padre.estaCapacidadMax)
{
if (Padre.Padre == null)
{
PartirRaiz(Padre);
}
else
{
InsertarEnHoja(Padre.Padre, Padre.IndiceHijoPadre, Padre2N);
}
}
else
{
int m = NuevoNodoDerecho.Padre.Tamano - 1;
for (; m < IndiceLlavePadre; m--)
{
NuevoNodoDerecho.Padre.Hijos[m + 1] = NuevoNodoDerecho.Padre.Hijos[m + 1];
}
NuevoNodoDerecho.Padre.LlavesNodos[m + 1] = Padre2N;
NuevoNodoDerecho.Padre.Hijos[m + 2] = NodoNuevoSucursal_Producto;
NuevoNodoDerecho.Padre.Tamano++;
NodoNuevoSucursal_Producto.Padre = NuevoNodoDerecho.Padre;
NodoNuevoSucursal_Producto.esNodoHoja = esNodoHoja;
}
if (NuevoNodoDerecho.Padre.Tamano == TamanoMaximo - 1)
{
NuevoNodoDerecho.Padre.estaCapacidadMax = true;
}
}
