private void InsertarEnHoja(NodoSP padre, int index, SucursalPrecio dato)
{
if (padre.hijos[index].estaLleno) //NodoSP lleno en el cual quiero insertar
{
if (padre.hijos[index + 1] != null) // ¿Es el hermano correcto?
{
if (padre.hijos[index + 1] != null) //Lleno, entonces partimos el nodo derecho
{
PartirEn23(padre, index, dato, false);
}
else //No esta lleno, entonces hago rotacion a la derecha
{
RotarDerecha(padre, index, dato);
}
}
else if (padre.hijos[index - 1] != null) //no hay hermano derecho, ¿Es el hijo izquierdo?
{
if (padre.hijos[index - 1].estaLleno) //Lleno, entonces partimos el nodo izquierdo
{
PartirEn23(padre, index, dato, false);
}
else//No esta lleno, entonces hago rotacion a la derecha
{
RotarIzquierda(padre, index, dato);
}
}
}
else
{
InsertarNoLleno(padre.hijos[index], dato);
}
}
private void InsertarNodoSP(NodoSP padre, SucursalPrecio dato)
{
int index = padre.tamaño - 1;
if (padre.tamaño > 0)
{
while (index >= 0 && dato.idSucursal < padre.Llaves[index].idSucursal)
{
index--;
}
}
index++;
if (raiz.estaLleno)
{
partirRaiz(padre);
InsertarNodoSP(raiz, dato);
}
else if (raiz.esHoja)
{
InsertarNoLleno(padre, dato);
}
else if (padre.hijos[index] != null && padre.hijos[index].esHoja)
{
InsertarEnHoja(padre, index, dato);
}
else
{
InsertarNodoSP(padre.hijos[index], dato);
}
}
private void RotarDerecha(NodoSP padre, int indexhijo, SucursalPrecio dato)
{
int llaveDelIndexPadre;
int tamañoNodoSP = padre.hijos[indexhijo].tamaño;
if (indexhijo == 0)
{
llaveDelIndexPadre = 0;
}
else if (indexhijo == tamañoNodoSP)
{
llaveDelIndexPadre = tamañoNodoSP - 1;
}
else
{
llaveDelIndexPadre = indexhijo;
}
int tamañoNodoSPHermano = padre.hijos[indexhijo + 1].tamaño;
//Mover elementos a la hermano derech, entonces hacemos el index 0
for (int j = tamañoNodoSPHermano - 1; j >= 0; j--)
{
padre.hijos[indexhijo + 1].Llaves[j + 1] = padre.hijos[indexhijo + 1].Llaves[j];
}
//Si el no es hoja, tengo que moverlo a los hijos
if (!padre.hijos[indexhijo].esHoja)
{
for (int j = tamañoNodoSPHermano; j >= 0; j--)
{
padre.hijos[indexhijo + 1].hijos[0] = padre.hijos[indexhijo + 1].hijos[j];
//Ulitmo hijo del nodo esta lleno y enviamos el primero al nodo derecho
padre.hijos[indexhijo + 1].hijos[0] = padre.hijos[indexhijo].hijos[tamañoNodoSPHermano];
padre.hijos[indexhijo].hijos[tamañoNodoSPHermano] = null;
}
}
padre.hijos[indexhijo + 1].Llaves[0] = padre.Llaves[llaveDelIndexPadre];
padre.hijos[indexhijo + 1].tamaño++;
if (padre.hijos[indexhijo].esHoja && dato.idSucursal <padre.Llaves[llaveDelIndexPadre].idSucursal &&
dato.idSucursal> padre.hijos[indexhijo].Llaves[tamañoNodoSP - 1].idSucursal)
{
padre.Llaves[llaveDelIndexPadre] = dato;
}
else
{
padre.Llaves[llaveDelIndexPadre] = padre.hijos[indexhijo].Llaves[tamañoNodoSP - 1];
padre.hijos[indexhijo].Llaves[tamañoNodoSP - 1] = null;
padre.hijos[indexhijo].tamaño--;
InsertarNoLleno(padre.hijos[indexhijo], dato);
}
if (padre.hijos[indexhijo + 1].tamaño == tamañoNodoSP)
{
padre.hijos[indexhijo + 1].estaLleno = true;
}
}
private void RotarIzquierda(NodoSP padre, int indexhijo, SucursalPrecio dato)
{
int llaveIndexPadre;
if (indexhijo == 0)
{
llaveIndexPadre = 0;
}
else if (indexhijo == tamanioMax)
{
llaveIndexPadre = tamanioMax - 1;
}
else
{
llaveIndexPadre = indexhijo - 1;
}
//Elemento de padre para hijo izquierdo
InsertarNoLleno(padre.hijos[indexhijo - 1], padre.Llaves[llaveIndexPadre]);
if (padre.hijos[indexhijo].esHoja &&
dato.idSucursal > padre.Llaves[llaveIndexPadre].idSucursal && dato.idSucursal < padre.hijos[indexhijo].Llaves[0].idSucursal)
{
//Meter dato si padre es mayor que dato y dato es mayor que el hermano derecho
padre.Llaves[llaveIndexPadre] = dato;
}
else
{
//De estar el nodo lleno, a hacerlo mas pequeño
padre.Llaves[llaveIndexPadre] = padre.hijos[indexhijo].Llaves[0];
//Mover los elementos del nodo lleno al izquierdo
int tamañoNodoSP = padre.hijos[indexhijo].tamaño;
for (int i = 0; i < tamañoNodoSP - 1; i++)
{
padre.hijos[indexhijo].Llaves[i] = padre.hijos[indexhijo].Llaves[i + 1];
}
//Si no es hoja, tengo que mover al hijo
//mover hijo a la izquierdo en campo 1
if (!padre.hijos[indexhijo].esHoja)
{
padre.hijos[indexhijo].hijos[tamañoNodoSP] = padre.hijos[indexhijo].hijos[0];
for (int i = 0; i < tamañoNodoSP - 1; i++)
{
padre.hijos[indexhijo].hijos[i] = padre.hijos[indexhijo].hijos[i + 1];
}
}
//Eliminar ultimo elemento del nodo lleno
padre.hijos[indexhijo].Llaves[tamañoNodoSP - 1] = null;
//Cambiar tamaño
padre.hijos[indexhijo].tamaño--;
padre.hijos[indexhijo].estaLleno = false;
InsertarNoLleno(padre.hijos[indexhijo], dato);
}
}
public void insertarSyP(SucursalPrecio nueva)
{
string escribir = nueva.idSucursal.ToString() + "," + nueva.idProducto.ToString() + "," + nueva.cantidadInv;
using (StreamWriter sw = new StreamWriter(d2))
{
sw.WriteLine(escribir);
}
inventario.Insertar(nueva);
}
public bool Busqueda(int idSucursal, int idProcuto)
{
SucursalPrecio resultado = BuscarCompa(raiz, idSucursal, idProcuto);
if (resultado != null)
{
return(true);
}
return(false);
}
public void PostSucProdu([FromBody] object value)
{
var val = Newtonsoft.Json.JsonConvert.SerializeObject(value);
SucursalPrecio datos = Newtonsoft.Json.JsonConvert.DeserializeObject <SucursalPrecio>(val);
var existeSucursal = Metadata.sucursales.Busqueda(datos.idSucursal);
var existeProducto = Metadata.productos.Busqueda(datos.idProducto);
if (existeProducto && existeSucursal)
{
Metadata.insertarSyP(datos);
}
}
public string PostSucPrecio([FromBody] SucursalPrecio value)
{
var existe = Metadata.inventario.Busqueda(value.idSucursal, value.idProducto);
if (existe)
{
Metadata.actualizarInventarioQty(value);
return("Sucursal: " + value.idSucursal + " IDproducto: " + value.idProducto + " actualizada");
}
else
{
return("no se encontro la sucursal ingresada");
}
}
public void leerInventario()
{
using (StreamReader sr = new StreamReader(d2))
{
string linea = "";
while ((linea = sr.ReadLine()) != null)
{
string[] sucursal = linea.Split(',');
SucursalPrecio creado = new SucursalPrecio();
creado.idSucursal = Convert.ToInt32(sucursal[0]);
creado.idProducto = Convert.ToInt32(sucursal[1]);
creado.cantidadInv = Convert.ToInt32(sucursal[2]);
inventario.Insertar(creado);
rInventario.Add(creado);
}
}
}
public async Task <string> Post([FromBody] SucursalPrecio sucursalPrecio, string x)
{
try
{
//verificar si ese producto con esa sucursal existen
if (sucursalPrecio.Id_producto == "1" && sucursalPrecio.Id_sucursal == "1")
{
//add producto in sucursal
SDataBase.UpdateProductoSucursal(sucursalPrecio);
return("Update quantily Producto in sucursal Successful");
}
else
{
return("The product does not match the sucursal.");
}
}
catch (Exception ex)
{
return(ex.Message.ToString());
}
}
public void actualizarInventarioQty(SucursalPrecio actualizar)
{
File.Delete(d2);
ArbolSP nuevo = new ArbolSP(9);
var arch = new FileStream(d2, FileMode.OpenOrCreate);
arch.Close();
foreach (var item in rInventario)
{
if ((item.idSucursal == actualizar.idSucursal) && (item.idProducto == item.idProducto))
{
item.cantidadInv += actualizar.cantidadInv;
}
using (StreamWriter sw = new StreamWriter(d2))
{
sw.WriteLine(item.idSucursal.ToString() + "," + item.idProducto.ToString() + "," + item.cantidadInv.ToString());
}
nuevo.Insertar(item);
}
inventario.raiz = nuevo.raiz;
}
public async Task <string> Post([FromBody] SucursalPrecio sucursalPrecio)
{
try
{
//verificar si ese producto ya se agrego a esa sucursal
if (sucursalPrecio.Id_producto == "1" && sucursalPrecio.Id_sucursal == "1")
{
//add producto in sucursal
SDataBase.AddProductoSucursal(sucursalPrecio);
return("Add Producto in sucursal Successful");
}
else
{
return("This producto has already been added to that sucursal.");
}
}
catch (Exception ex)
{
return(ex.Message.ToString());
}
}
private void PartirEn23(NodoSP padre, int indexHijoLleno, SucursalPrecio dato, bool hermanoIzquierdo)
{
//Si el tiene un padre, el no es raiz
int indexLadoIzquierdo = hermanoIzquierdo ? (indexHijoLleno - 1) : indexHijoLleno;
int indexLadoDerecho = hermanoIzquierdo ? (indexHijoLleno) : indexHijoLleno + 1;
int dosTercios = (tamanioMax * 2) / 3;
int indexLlavePadre = hermanoIzquierdo ? (indexHijoLleno - 1) : (indexHijoLleno);
int tamañoMaxNodoSP = tamanioMax - 1;
bool esHoja = padre.hijos[indexHijoLleno].esHoja;
int j = 0;
var arr = new SucursalPrecio[tamanioMax * 2];
var hijos = new NodoSP[tamanioMax * 2];
for (int i = 0; i < tamañoMaxNodoSP; i++)
{
arr[j++] = padre.hijos[indexLadoIzquierdo].Llaves[i];
arr[j++] = padre.hijos[indexLadoDerecho].Llaves[i];
}
arr[j++] = dato;
arr[j++] = padre.Llaves[indexLlavePadre];
if (!esHoja)
{
int x = 0;
for (int i = 0; i < tamanioMax; i++)
{
hijos[x++] = padre.hijos[indexLadoIzquierdo].hijos[i];
}
for (int i = 0; i < tamanioMax; i++)
{
hijos[x++] = padre.hijos[indexLadoDerecho].hijos[i];
}
}
j = 0;
int k;
for (k = 0; k < dosTercios; k++)
{
padre.hijos[indexLadoIzquierdo].Llaves[k] = arr[j++];
}
while (k < tamañoMaxNodoSP)
{
padre.hijos[indexLadoIzquierdo].Llaves[k++] = null;
padre.hijos[indexLadoIzquierdo].tamaño--;
}
padre.hijos[indexLadoIzquierdo].estaLleno = false;
SucursalPrecio padre1 = arr[j++];
padre.Llaves[indexLlavePadre] = padre1;
for (k = 0; k < dosTercios; k++)
{
padre.hijos[indexLadoDerecho].Llaves[k] = arr[j++];
}
while (k < tamañoMaxNodoSP)
{
padre.hijos[indexLadoDerecho].Llaves[k++] = null;
padre.hijos[indexLadoDerecho].tamaño--;
}
padre.hijos[indexLadoDerecho].estaLleno = false;
SucursalPrecio padre2 = arr[j++];
var nuevoNodoSP = new NodoSP(tamanioMax);
for (k = 0; j < tamanioMax * 2; k++)
{
nuevoNodoSP.Llaves[k] = arr[j++];
nuevoNodoSP.tamaño++;
}
var nodoDerecho = padre.hijos[indexLadoDerecho];
if (padre.estaLleno)
{
if (padre.Padre == null)
{
partirRaiz(padre);
}
else
{
InsertarEnHoja(padre.Padre, padre.indiceHijoDePadre, padre2);
}
}
else
{
int m = nodoDerecho.Padre.tamaño - 1;
for (; m > indexLlavePadre; m--)
{
nodoDerecho.Padre.hijos[m + 1] = nodoDerecho.Padre.hijos[m + 1];
}
nodoDerecho.Padre.Llaves[m + 1] = padre2;
nodoDerecho.Padre.hijos[m + 2] = nuevoNodoSP;
nodoDerecho.Padre.tamaño++;
nuevoNodoSP.Padre = nodoDerecho.Padre;
nuevoNodoSP.esHoja = esHoja;
}
if (nodoDerecho.Padre.tamaño == tamanioMax - 1)
{
nodoDerecho.Padre.estaLleno = true;
}
}
//method for update producto in sucursal
public void UpdateProductoSucursal(SucursalPrecio sucursalPrecio)
{
//code update producto in sucursal at the tree B
}
//method for add new producto in sucursal
public void AddProductoSucursal(SucursalPrecio sucursalPrecio)
{
//code add producto in sucursal at the tree B
}
private void InsertarNoLleno(NodoSP actual, SucursalPrecio dato)
{
var i = actual.tamaño - 1;
var m = actual.tamaño;
//Cuando inserto en rama y si tiene hijos
if (!actual.esHoja)
{
while (i >= 0 && dato.idSucursal < actual.Llaves[i].idSucursal)
{
actual.Llaves[i + 1] = actual.Llaves[i];
actual.hijos[i + 2] = actual.hijos[i + 1];
i--;
}
}
else
{
while (i >= 0 && dato.idSucursal < actual.Llaves[i].idSucursal)
{
actual.Llaves[i + 1] = actual.Llaves[i];
i--;
}
}
actual.Llaves[i + 1] = dato;
actual.tamaño++;
//Mover hijo si no es hoja
if (!actual.esHoja)
{
var x = i + 1;
var c = i + 2;
actual.hijos[c] = actual.hijos[x];
actual.hijos[x] = new NodoSP(tamanioMax);
int j = 0;
for (; actual.hijos[c].Llaves[j].idSucursal < dato.idSucursal; j++)
{
actual.hijos[x].Llaves[j] = actual.hijos[c].Llaves[j];
if (!actual.hijos[c].esHoja)
{
actual.hijos[x].hijos[j] = actual.hijos[c].hijos[j];
}
actual.hijos[c].tamaño--;
actual.hijos[x].tamaño++;
}
int k;
for (k = j; k < m; k++)
{
actual.hijos[c].Llaves[k - j] = actual.hijos[c].Llaves[k];
actual.hijos[c].Llaves[k] = null;
if (!actual.hijos[c].esHoja)
{
actual.hijos[c].hijos[k - j] = actual.hijos[c].hijos[k];
actual.hijos[c].hijos[k] = null;
}
}
if (!actual.hijos[c].esHoja)
{
actual.hijos[c].hijos[actual.hijos[c].tamaño] = actual.hijos[c].hijos[k - j];
}
if (actual.tamaño == tamanioMax - 1)
{
actual.estaLleno = true;
}
}
}
public NodoSP(int grado)
{
gradoMaximo = grado;
Llaves = new SucursalPrecio[grado - 1];
hijos = new NodoSP[grado];
}
public void Insertar(SucursalPrecio dato)
{
InsertarNodoSP(raiz, dato);
}