//Se debe poder sumar los dos depósitos(con la sobrecarga de un operador en la clase Depósito) retornando
//una nueva lista con la suma de los Productos, (recordar que, si un producto está en las dos listas,
//se debe sumar el stock y no agregar dos veces al mismo producto).
public static List <Producto> operator +(Deposito d1, Deposito d2)
{
Deposito aux = new Deposito("", d1.capacidad + d2.capacidad);
foreach (Producto p1 in d1.productos)
{
aux.Add(new Producto(p1.Nombre, p1.Stock));
}
foreach (Producto p2 in d2.productos)
{
bool existe = false;
foreach (Producto aux1 in aux.productos)
{
if (aux1 == p2)
{
aux1.Stock += p2.Stock;
existe = true;
}
}
if (existe == false)
{
aux.Add(new Producto(p2.Nombre, p2.Stock));
}
}
return(aux.productos);
}
public static Deposito operator +(Deposito d1, Deposito d2)
{
Deposito d3 = new Deposito();
bool respuesta;
foreach (Producto item in d1.productos)
{
respuesta = BuscarProducto(d3, item, out int indice);
if (respuesta)
{
d3.productos[indice].stock += item.stock;
}
else
{
d3.productos.Add(new Producto(item.nombre, item.stock));
}
}
foreach (Producto item in d2.productos)
{
respuesta = BuscarProducto(d3, item, out int indice);
if (respuesta)
{
d3.productos[indice].stock += item.stock;
}
else
{
d3.productos.Add(new Producto(item.nombre, item.stock));
}
}
return(d3);
}
public string GuardarInfoClass(Deposito <Articulo> midepo)
{
try
{
if (midepo.Cantidad == 0)
{
Console.WriteLine("No hay datos para guardar");
}
else
{
Random random = new Random();
string rutaArchivo = AppDomain.CurrentDomain.BaseDirectory + "Historial del dia " + DateTime.Now.ToString("dd-M-hh_mm_ss ") + ".xml";
using (XmlTextWriter auxArchivo = new XmlTextWriter(rutaArchivo, Encoding.UTF8))
{
XmlSerializer auxEscritor = new XmlSerializer(typeof(Deposito <Articulo>));
auxEscritor.Serialize(auxArchivo, midepo);
Console.WriteLine("Guardado con exito");
}
}
}
catch (Exception error)
{
Console.WriteLine(error.Message);
}
return(midepo.ToString());
}
public string CargarInfoClass(Deposito <Articulo> midepo)
{
try
{
string rutaArchivo = string.Empty;
if (File.Exists(rutaArchivo))
{
using (XmlTextReader auxArchivoAleer = new XmlTextReader(rutaArchivo))
{
XmlSerializer auxLector = new XmlSerializer(typeof(Deposito <Articulo>));
midepo = (Deposito <Articulo>)auxLector.Deserialize(auxArchivoAleer);
}
}
else
{
Console.WriteLine("No hay datos en el sistema");
}
}
catch (Exception error)
{
Console.WriteLine(error.Message);
throw;
}
return(midepo.ToString());
}
public static bool Verifica(Deposito <T> t, T p)
{
for (int i = 0; i < t.productos.Length; i++)
{
if (!(object.ReferenceEquals(t.productos[i], null)) && !(object.ReferenceEquals(p, null)))
{
if (t.productos[i] == p)
{
t.productos[i].Stock += p.Stock;
return(true);
}
}
}
return(false);
}
private static bool BuscarProducto(Deposito d, Producto p, out int indice)
{
bool retorno = false;
indice = -1;
for (int i = 0; i < d.productos.Count; i++)
{
if (d.productos[i] == p)
{
indice = i;
retorno = true;
break;
}
}
return(retorno);
}
public static Deposito <T> operator +(Deposito <T> d1, Deposito <T> d2)
{
Deposito <T> depo = new Deposito <T>();
foreach (T aux in d2.productos)
{
if (!ReferenceEquals(aux, null))
{
if (!Verifica(d1, aux))
{
d1 += aux;
}
}
}
return(d1);
}
public static string Mostrar(Deposito d)
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat($"Capacidad: {d.capacidad}\n");
sb.AppendFormat($"Total por tablets: {d.PrecioDeTablets}\n");
sb.AppendFormat($"Total por celulares: {d.PrecioDeCelulares}\n");
sb.AppendFormat($"Total: {d.PrecioTotal}\n");
sb.AppendLine("*********************************************");
sb.AppendLine("Lista de productos");
sb.AppendLine("*********************************************");
foreach (Producto item in d.productos)
{
sb.AppendFormat($"{item.ToString()}\n");
}
return(sb.ToString());
}
bool IDeserializar.Xml(string xml, out Deposito d)
{
XmlSerializer serialize = new XmlSerializer(typeof(Deposito));
XmlTextReader read = new XmlTextReader(xml);
bool rta = false;
d = null;
try
{
d = (Deposito)serialize.Deserialize(read);
read.Close();
rta = true;
}
catch
{
}
return(rta);
}
public static Producto[] operator +(Deposito d1, Deposito d2)
{
int cantidad = d1._cantidad + d2._cantidad;
int stock, count = 0, posicion;
bool flag = false;
Producto p;
Producto[] aux = new Producto[cantidad];
foreach (Producto item in d1.productos)
{
if (Deposito.ExisteProducto(aux, item, out posicion))
{
stock = aux[posicion].stock + item.stock;
p = new Producto(aux[posicion].nombre, stock);
aux[posicion] = p;
}
else
{
p = new Producto(item.nombre, item.stock);
aux[count] = p;
count++;
}
}
foreach (Producto item in d2.productos)
{
if (Deposito.ExisteProducto(aux, item, out posicion))
{
stock = aux[posicion].stock + item.stock;
p = new Producto(aux[posicion].nombre, stock);
aux[posicion] = p;
}
else
{
p = new Producto(item.nombre, item.stock);
aux[count] = p;
count++;
}
}
return(aux);
}
private Deposito GetDeposito()
{
int id = 0;
Entidades.Deposito depositos = new Entidades.Deposito();
if (Id_DropDownList.SelectedValue != condicion)
{
id = Convert.ToInt32(Id_DropDownList.SelectedValue);
}
if (id != 0)
{
depositos.DepositoId = id;
}
else
{
depositos.DepositoId = 0;
}
depositos.CuentaId = Convert.ToInt32(Cuenta_Id_DropDownList.SelectedValue);
depositos.Concepto = ConceptoTextBox.Text;
depositos.Fecha = Convert.ToDateTime(FechaDateTime.Text);
depositos.Monto = Convert.ToInt32(MontoTextBox.Text);
return(depositos);
}
/// <summary>
/// Metodo para ordenar de forma ascendente.
/// </summary>
/// <param name="d1"></param>
public static void OrdenarAscendente(Deposito d1)
{
d1.productos.Sort((p, q) => p.stock.CompareTo(q.stock));
}
/// <summary>
/// Metodo para ordenar en orden alfabetico.
/// </summary>
/// <param name="d1"></param>
public static void OrdenarAlfabetico(Deposito d1)
{
d1.productos.Sort((p, q) => string.Compare(p.nombre, q.nombre));
}
public static void OrdenarAscendente(Deposito d1)
{
d1.productos.Sort((p1, p2) => p1.stock.CompareTo(p2.stock));
}
