/// <summary>
/// Método estático que retorna la información de toda la fabrica, su facturación,
/// el total de muebles fabricados, y el gasto total
/// </summary>
/// <returns>String con toda la info de la fabrica.</returns>
public static string RetornarInformacionTotal()
{
StringBuilder sb = new StringBuilder();
try
{
if (Fabrica.Muebles.Count > 0)
{
foreach (Mueble mueble in Fabrica.listaDeMuebles)
{
sb.AppendFormat("{0}", mueble.InformacionDelMueble());
sb.AppendFormat("{0}", mueble.Facturacion());
sb.AppendLine("******************************************************************************");
}
sb.AppendFormat("\nTotal de muebles fabricados:{0} Muebles\n", Fabrica.CalcularUnidadesFabricadas());
sb.AppendFormat("\nGasto total:{0}\n", Fabrica.CalcularGastoFabrica().FormatearPrecio());
if (sb.ToString() == string.Empty)
{
throw new FabricaExcepcion("La información de la fabrica no puede estar vacia si hay cargado al menos un mueble");
}
}
else
{
sb.Append("No se ha cargado ningun producto.");
}
return(sb.ToString());
}
catch (FabricaExcepcion)
{
return(string.Empty);
}
}
/// <summary>
/// Es el metodo que llama a la clase XML para serializar esta misma clase y hacer el archivo xml
/// </summary>
/// <param name="fabrica"></param>
/// <returns>retorna true si se pudo hacer, false caso contrario</returns>
public static bool Guardar(Fabrica fabrica)
{
string path = String.Concat(AppDomain.CurrentDomain.BaseDirectory, "Fabrica.xml");
Xml <Fabrica> fabricaAux = new Xml <Fabrica>();
return(fabricaAux.Guardar(path, fabrica));
}
/// <summary>
/// Lee una cadena de caracteres de un archivo de texto
/// </summary>
/// <param name="nombreArchivo"></param>
/// <param name="datos"></param>
/// <returns></returns>
public Fabrica LeerTexto()
{
string ruta = Directory.GetCurrentDirectory() + @"\Computadoras.txt";
List <string> productos = new List <string>();
Fabrica fabrica = GetFabrica(this.AlmacenDeProductos);
ArchivosTexto <Producto> texto = new ArchivosTexto <Producto>();
texto.Leer(ruta, out productos);
foreach (string producto in productos.ToArray())
{
string[] campos = producto.Split(',');
if (campos[0] == "Computadora")
{
Computadora.TipoComputadora tipo;
Computadora.ESistemaOperativo eSistema;
bool pasoControlCalidad;
if (campos[5] == "Escritorio")
{
tipo = Computadora.TipoComputadora.Escritorio;
}
else
{
tipo = Computadora.TipoComputadora.Notebook;
}
if (campos[4] == "Pasó control de calidad")
{
pasoControlCalidad = true;
}
else
{
pasoControlCalidad = false;
}
switch (campos[6])
{
case "Windows":
eSistema = Computadora.ESistemaOperativo.Windows;
break;
case "OSX":
eSistema = Computadora.ESistemaOperativo.OSX;
break;
case "Linux":
eSistema = Computadora.ESistemaOperativo.Linux;
break;
default:
eSistema = Computadora.ESistemaOperativo.SinSistemaOperativo;
break;
}
double precio = double.Parse(campos[3].Remove(0, 1), CultureInfo.InvariantCulture);
//Para que tome el punto como una coma
Computadora computadora = new Computadora(int.Parse(campos[1]), campos[2], precio,
tipo, eSistema, pasoControlCalidad);
fabrica.Productos.Add(computadora);
}
}
return(fabrica);
}
/// <summary>
/// patron singleton para la clase
/// </summary>
/// <returns>Devuelve una fabrica</returns>
public static Fabrica GetFabrica(UInt32 capacidad)
{
if (ReferenceEquals(null, fabrica))
{
fabrica = new Fabrica(capacidad);
}
else
{
fabrica.AlmacenDeProductos = capacidad;
}
return(fabrica);
}
/// <summary>
/// Método estático que genera un .txt con la información de la fabrica.
/// El nombre del archivo es Muebles Fernández.txt ya que no hay dos fabricas,
/// siempre que se imprime sobreescribe el anterior.
///en caso de error , no guarda nada, simplemente capturo cualquiera de sus excepciones
/// y me protejo de cualquier excepcion que pueda cerrar el programa
/// </summary>
/// <param name="ubicacionArchivo">Path donde se va a guardar el archivo</param>
public static void GenerarFabricaTxt(string ubicacionArchivo)
{
try
{
ubicacionArchivo += string.Format("\\Muebles Fernández.txt");
StreamWriter archivoTxt = new StreamWriter(ubicacionArchivo);
archivoTxt.Write(Fabrica.RetornarInformacionTotal());
archivoTxt.Close();
}
catch (Exception)
{
}
}
/// <summary>
/// Lee todos los elementos que componen a la fábrica.
/// Guarda el uniqueID de modelos en la clase Modelo.
/// Lanza exception si hay error al leer los archivos.
/// </summary>
/// <returns></returns>
public static Fabrica LeerFabricaDesdeArchivos()
{
Fabrica miFabrica = new Fabrica();
List <Material> materialesDeFabrica = new List <Material>();
List <Modelo> modelosDeFabrica = new List <Modelo>();
List <Mueble> mueblesDeFabrica = new List <Mueble>();
List <Mueble> queueMueblesDeFabrica = new List <Mueble>();
try
{
Serializer <Material> .DeserializeListXML(materialesDeFabrica, Globals.pathMateriales);
foreach (Material item in materialesDeFabrica)
{
miFabrica += item;
}
Serializer <Modelo> .DeserializeListXML(modelosDeFabrica, Globals.pathModelos);
foreach (Modelo item in modelosDeFabrica)
{
miFabrica += item;
}
Serializer <Mueble> .DeserializeListXML(mueblesDeFabrica, Globals.pathStockMuebles);
foreach (Mueble item in mueblesDeFabrica)
{
miFabrica += item;
}
Serializer <Mueble> .DeserializeListXML(queueMueblesDeFabrica, Globals.pathQueueMuebles);
foreach (Mueble item in queueMueblesDeFabrica)
{
miFabrica.mueblesEnProduccion.Enqueue(item);
}
foreach (string item in Directory.GetFiles(Environment.CurrentDirectory, "*.dat"))
{
FileStream archivo = new FileStream(item, FileMode.Open);
BinaryFormatter serializador = new BinaryFormatter();
Modelo.UniqueID = (int)serializador.Deserialize(archivo);
archivo.Close();
}
} catch (Exception ex)
{
throw new ArchivoInvalidoException("Los archivos de fabrica no existen o se movieron", ex);
}
return(miFabrica);
}
/// <summary>
/// Lee una cadena de caracteres de un archivo de texto
/// </summary>
/// <param name="nombreArchivo"></param>
/// <param name="datos"></param>
/// <returns></returns>
public Fabrica LeerTexto()
{
string ruta = Directory.GetCurrentDirectory() + @"\Computadoras.txt";
List <string> productos = new List <string>();
Fabrica fabrica = GetFabrica(this.AlmacenDeProductos);
ArchivosTexto <Producto> texto = new ArchivosTexto <Producto>();
texto.Leer(ruta, out productos);
foreach (string producto in productos.ToArray())
{
string[] campos = producto.Split(',');
if (campos[0] == "Computadora")
{
Computadora.TipoComputadora tipo;
Computadora.ESistemaOperativo eSistema;
if (campos[5] == "0")
{
tipo = Computadora.TipoComputadora.Escritorio;
}
else
{
tipo = Computadora.TipoComputadora.Notebook;
}
switch (campos[6])
{
case "0":
eSistema = Computadora.ESistemaOperativo.Windows;
break;
case "1":
eSistema = Computadora.ESistemaOperativo.OSX;
break;
case "2":
eSistema = Computadora.ESistemaOperativo.Linux;
break;
default:
eSistema = Computadora.ESistemaOperativo.SinSistemaOperativo;
break;
}
Computadora computadora = new Computadora(int.Parse(campos[1]), campos[2], double.Parse(campos[3]),
tipo, eSistema, bool.Parse(campos[4]));
fabrica.Productos.Add(computadora);
}
}
return(fabrica);
}
/// <summary>
/// Propiedad que valida que haya stock suficiente segun el producto
/// </summary>
/// <param name="f"></param>
/// <returns>Retorna true si pudo descontar, false en caso contrario</returns>
public override bool EnsambladoProductos(Fabrica f)
{
bool returnAux = false;
if ((f.CantMicro - this.microprocesador) > 0 &&
(f.CantPlacaMadre - this.placaMadre) > 0 &&
(f.cantAlmacenamiento - this.almacenamiento) > 0 &&
(f.CantMemoria - this.memoriaRam) > 0)
{
f.CantMicro = -this.microprocesador;
f.CantAlmacenamiento = -this.almacenamiento;
f.CantPlacaMadre = -this.placaMadre;
f.CantMemoria = -this.memoriaRam;
returnAux = true;
}
return(returnAux);
}
/// <summary>
/// lee un archivo xml
/// </summary>
/// <returns></returns>
public Fabrica LeerXml()
{
string ruta = Directory.GetCurrentDirectory() + @"\Celulares.xml";
List <Celular> celulares = new List <Celular>();
try
{
Fabrica fabrica = GetFabrica(this.AlmacenDeProductos);
ArchivosXml <List <Celular> > archivoXml = new ArchivosXml <List <Celular> >();
archivoXml.Leer(ruta, out celulares);
}
catch (Exception)
{
throw new ArchivosException("Error al intentar leer el archivo!");
}
foreach (Celular c in celulares)
{
fabrica.Productos.Add(c);
}
return(fabrica);
}
/// <summary>
/// Método estático que retorna la información de toda la fabrica, su facturación,
/// el total de muebles fabricados, y el gasto total
/// </summary>
/// <returns>String con toda la info de la fabrica.</returns>
public static string RetornarInformacionTotal()
{
StringBuilder sb = new StringBuilder();
if (Fabrica.Muebles.Count > 0)
{
foreach (Mueble mueble in Fabrica.listaDeMuebles)
{
sb.AppendFormat("{0}", mueble.InformacionDelMueble());
sb.AppendFormat("{0}", mueble.Facturacion());
sb.AppendLine("******************************************************************************");
}
sb.AppendFormat("\nTotal de muebles fabricados:{0} Muebles\n", Fabrica.CalcularUnidadesFabricadas());
sb.AppendFormat("\nGasto total:{0:N2} $\n", Fabrica.CalcularGastoFabrica());
}
else
{
sb.Append("No se ha cargado ningun producto.");
}
return(sb.ToString());
}
public abstract bool EnsambladoProductos(Fabrica f);
/// <summary>
/// Escribe los datos de la fabrica en un archivo xml.
/// </summary>
/// <param name="f">Fabrica a escribir.</param>
/// <param name="path">Ruta del archivo.</param>
/// <returns>True si fue exitoso, false si no.</returns>
public static bool Escribir(Fabrica f, string path)
{
Xml <Fabrica> eF = new Xml <Fabrica>();
return(eF.Escribir(path, f));
}
