/// <summary>
/// Genera una nueva jornada en el gimnasio con la clase dada.
/// </summary>
/// <param name="g">Gimnasio donde se genera la jornada.</param>
/// <param name="clase">Clase de la jornada.</param>
/// <returns>Gimnasio con la jornada generada.</returns>
public static Gimnasio operator +(Gimnasio g, Gimnasio.EClases clase)
{
Jornada jornada = new Jornada(clase, (g == clase));
foreach (Alumno alumno in g._alumnos)
{
if (alumno == clase)
{
jornada += alumno;
}
}
g._jornada.Add(jornada);
return(g);
}
/// <summary>
/// Sobrecarga + en el cual se agrega una clase a una universidad
/// </summary>
/// <param name="g">Universidad </param>
/// <param name="clase">clase a agregar en la universidad</param>
/// <returns>Universidad con la clase agregada</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor p = (g == clase);
Jornada j = new Jornada(clase, p);
foreach (Alumno item in g.alumnos)
{
if (item == clase)
{
j += item;
}
}
g.Jornadas.Add(j);
return(g);
}
/// <summary>
/// Al agregar una clase a un Universidad se deberá generar y agregar una nueva Jornada indicando la
///clase, un Profesor que pueda darla(según su atributo ClasesDelDia) y la lista de alumnos que la
///toman(todos los que coincidan en su campo ClaseQueToma).
/// </summary>
/// <param name="g">Universidad</param>
/// <param name="clase">EClases</param>
/// <returns>Universidad con la clase agregada</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor profesor = (g == clase);
Jornada jornada = new Jornada(clase, profesor);
foreach (Alumno unAlumno in g.alumnos)
{
if (unAlumno == clase)
{
jornada += unAlumno;
}
}
g.jornada.Add(jornada);
return(g);
}
public static Gimnasio operator +(Gimnasio g, EClases clase)
{
Instructor i = g == clase;
Jornada j = new Jornada(clase, i);
foreach (Alumno a in g._alumnos)
{
if (a == clase)
{
j += a;
}
}
g._jornada.Add(j);
return(g);
}
/// <summary>
/// Sobrecarga del operador + "Crea una jornada de la clase y la agrega al gimnasio"
/// </summary>
/// <param name="g">Gimnasio</param>
/// <param name="clase">EClase</param>
/// <returns>Gimnasio con la nueva clase cargada</returns>
public static Gimnasio operator +(Gimnasio g, EClases clase)
{
if (!object.Equals(g, null))
{
Jornada j = new Jornada(clase, (g == clase));
for (int i = 0; i < g._alumnos.Count; i++)
{
if (g._alumnos[i] == clase)
{
j = j + g._alumnos[i];
g._jornadas.Add(j);
}
}
}
return(g);
}
/// <summary>
/// Método static
/// encargado de configurar el path y el nombre de archivo donde se
/// guardaran los datos de una jornada
/// </summary>
/// <param name="jornada"></param> Tipo Jornada
/// <returns> bool, si se guardaro el archivo retorna true, de lo contrario false </returns>
public static bool Guardar(Jornada jornada)
{
string miPath = string.Format("{0}{1}",
Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
"\\jornada.txt");
if (!(jornada is null))
{
Texto texto = new Texto();
if (texto.Guardar(miPath, jornada.ToString()))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Agrega una jornada a la universidad
/// </summary>
/// <param name="g">Universidad</param>
/// <param name="clase">Clase</param>
/// <returns>Universidad con nueva jornada</returns>
public static Universidad operator +(Universidad g, Universidad.EClases clase)
{
Profesor profesorDisponible = (g == clase);
Jornada jornada = new Jornada(clase, profesorDisponible);
foreach (Alumno a in g.alumnos)
{
if (a == clase)
{
jornada.Alumnos.Add(a);
}
}
g.jornada.Add(jornada);
return(g);
}
/// <summary>
/// Agrega una Jornada a la lista de jornadas de la Universidad si, y solo si, hay un profesor disponible para la Jornada
/// </summary>
/// <param name="g">Universidad a la que se agrega la Jornada</param>
/// <param name="clase">EClase que indica la materia de la jornada que se agrega</param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada j = new Jornada(clase, (g == clase));
foreach (Alumno a in g.alumnos)
{
if (a == clase)
{
j.Alumnos.Add(a);
}
}
g.jornadas.Add(j);
return(g);
}
/*Al agregar una clase a un Gimnasio se deberá generar y agregar
* una nueva jornada indicando la clase, un instructor que pueda darla
* (según su atributo ClasesDelDia) y la lista de Alumnos que la toman
* (todos los que coincidadn en su campo ClaseQueToma)
*/
public static Gimnasio operator +(Gimnasio g, EClases clase)
{
//Creo y agrego la nuevaJornada a la lista _jornadas
Jornada nuevaJornada = new Jornada(clase, g == clase);
g._jornadas.Add(nuevaJornada);
foreach (Alumno item in g._alumnos)
{
if (item == clase)
{
nuevaJornada += item;
}
}
return(g);
}
/// <summary>
/// Guarda los datos de una jornada en un archivo de texto.
/// </summary>
/// <param name="jornada">Jornada a guarda.</param>
/// <returns></returns>
public static bool Guardar(Jornada jornada)
{
try
{
Texto txt = new Texto();
return(txt.guardar(FILE_NAME, jornada.ToString()));
}
catch (ArchivosException e)
{
throw e;
}
catch (Exception e)
{
throw new ArchivosException(e);
}
}
/// <summary>
/// sobrecarga del operador + entre una universidad y una clase
/// </summary>
/// <param name="g">univercidad</param>
/// <param name="clase">clase</param>
/// <returns>retorna la univercidad con la clase agregada</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor profesor = g == clase;
Jornada jornada = new Jornada(clase, profesor);
foreach (Alumno alumnosEnUnivercidad in g.Alumnos)
{
if (alumnosEnUnivercidad == clase)
{
jornada += alumnosEnUnivercidad;
}
}
g.Jornadas.Add(jornada);
return(g);
}
/// <summary>
/// Guarda una jornada en un archivo de texto
/// </summary>
/// <param name="jornada"></param>
/// <returns>True si puede guardar la jornada</returns>
public static bool Guardar(Jornada jornada)
{
bool retorno = false;
IArchivo <string> archivosTexto = new Texto();
string ruta = AppDomain.CurrentDomain.BaseDirectory + "Jornada.txt";
try
{
retorno = archivosTexto.Guardar(ruta, jornada.ToString());
}
catch (ArchivosException e)
{
throw e;
}
return(retorno);
}
public static bool Guardar(Jornada j)
{
Texto guardado = new Texto();
bool retorno = false;
string path = AppDomain.CurrentDomain.BaseDirectory;
if (guardado.Guardar(AppDomain.CurrentDomain.BaseDirectory + "jornada.txt", j.ToString()))
{
retorno = true;
}
else
{
retorno = false;
}
return(retorno);
}
/// <summary>
/// Sobrecarga del operador +. Se creara un objeto del tipo Jornada, se le asignara un profesor capaz de dar la clase y los
/// inscriptos en la misma
/// </summary>
/// <param name="u">Objeto del tipo Universidad</param>
/// <param name="clase">Objeto del tipo Universidad.EClases</param>
/// <returns>retorna u</returns>
public static Universidad operator +(Universidad u, Universidad.EClases clase)
{
Profesor p = u == clase;
Jornada j = new Jornada(clase, p);
foreach (Alumno item in u.Alumnos)
{
if (item == clase)
{
j += item;
}
}
u.Jornada.Add(j);
return(u);
}
/// <summary>
/// Metodo que guarda los datos de la Jornada en un archivo de texto
/// </summary>
/// <param name="jornada"></param>
/// <returns>true si pudo guarda , false si no pudo</returns>
public static bool Guardar(Jornada jornada)
{
bool retorno = false;
try
{
StreamWriter text = new StreamWriter(@"C:\Users\Mariano\Downloads\jornada.txt");
text.Write(jornada.ToString());
text.Close();
retorno = true;
}
catch (Exception)
{
throw new ArchivosException("Error al guardar el archivo");
}
return(retorno);
}
/// <summary>
/// Operador
/// </summary>
/// <param name="u"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad u, Universidad.EClases clase)
{
Profesor profesor = (u == clase);
Jornada jornada = new Jornada(clase, profesor);
foreach (Alumno item in u.Alumnos)
{
if (item == clase)
{
jornada = jornada + item;
}
}
u.Jornadas.Add(jornada);
return(u);
}
/// <summary>
/// Guardar de clase guardará los datos de la Jornada en un archivo de texto.
/// Archivo se crea en el escritorio de la pc que lo ejecuta
/// </summary>
/// <param name="jornada"></param>
/// <returns></returns>
public static bool Guardar(Jornada jornada)
{
bool banderita = false;
try
{
Texto t = new Archivo.Texto();
banderita = t.Guardar(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\Jornada.txt", jornada.ToString());
}
catch (Exception e)
{
throw new ArchivosException(e);
}
return(banderita);
}
/// <summary>
/// Agrega una nueva jornada a la universidad con un nuevo profesor y añade los alumnos que toman esa clase.
/// </summary>
/// <param name="g">universidad recibida</param>
/// <param name="clase">clase recibida</param>
/// <returns>Retorna la universidad.</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
if (!(g is null))
{
Profesor profe = (g == clase);
Jornada jornada = new Jornada(clase, profe);
foreach (Alumno alumno in g.alumnos)
{
if (alumno == clase)
{
jornada.Alumnos.Add(alumno);
}
}
g.jornada.Add(jornada);
}
return(g);
}
/// <summary>
/// Sobrecarga método "+" entre universidad y clase. Agrega una clase nueva a la universidad
/// asignandole un profesor y al menos un alumno.
/// </summary>
/// <param name="g"></param>
/// <param name="clase"></param>
/// <returns>Retorna la universidad.</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor p = new Profesor();
bool flagProfesor = false;
bool flagAlumno = false;
//Recorrer lista de profesores para obtener uno que pueda dictar esa clase.
foreach (Profesor auxProfesor in g.profesores)
{
//Sobrecarga == obtiene un profesor que pueda dictar dicha clase.
if (auxProfesor == clase)
{
//Asigno en variable "p" el profesor que va a ser titular en la jornada.
p = auxProfesor;
flagProfesor = true;
break;
}
}
//Nueva jornada con profesor y clase.
Jornada j = new Jornada(clase, p);
//Recorrer lista de alumnos para obetener los que matcheen entre clase
// y el atributo claseQueToma de alumno.
foreach (Alumno auxAlumno in g.alumnos)
{
if (auxAlumno == j.Clase)
{
flagAlumno = true;
//Agregar al alumno a la jornada.
j += auxAlumno;
}
}
//Si fue asignado algun profesor y fue agregado al menos un alumno, agrego la jornada.
if (flagAlumno && flagProfesor)
{
g.jornada.Add(j);
}
else
{
throw new SinProfesorException();
}
return(g);
}
/// <summary>
/// Agrega una clase a una nueva jornada, la cual es agregada a la lista de jornadas de una universidad.
/// </summary>
/// <param name="gim">Universidad donse se agregará la clase.</param>
/// <param name="clase">Clase a agregar.</param>
/// <returns>Universidad con la nueva jornada que contiene la clase agregada.</returns>
public static Universidad operator +(Universidad gim, EClases clase)
{
Universidad auxUniversidad;
auxUniversidad = gim;
Jornada jornada = new Jornada(clase, auxUniversidad == clase);
for (int i = 0; i < auxUniversidad._alumnos.Count; i++)
{
if (auxUniversidad._alumnos[i] == clase)
{
jornada += auxUniversidad._alumnos[i];
}
}
auxUniversidad._jornada.Add(jornada);
return(auxUniversidad);
}
/// <summary>
/// Sobrecarga del operador + (Universidad / Enumerado EClases)
/// </summary>
/// <param name="g"></param> Tipo Universidad
/// <param name="clase"></param> Tipo Enumerado EClases
/// <returns> Universidad que contendra una nueva jornada si existen profesores
/// para una clase determinada (EClases)
/// de lo contrario devolvera la misma Universidad pasada como parámetro </returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor auxProfesor = (g == clase);
if (!(auxProfesor is null))
{
Jornada auxJornada = new Jornada(clase, auxProfesor);
foreach (Alumno item in g.Alumnos)
{
if (item == clase)
{
auxJornada += item;
}
}
g.Jornadas.Add(auxJornada);
}
return(g);
}
/// <summary>
/// Leer de clase retornará los datos de la Jornada como texto
/// </summary>
/// <param name="jornada"></param>
/// <returns></returns>
public static string Leer(Jornada jornada)
{
string datos;
string archivo;
bool s = false;
try
{
Texto t = new Archivo.Texto();
archivo = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\Jornada.txt";
s = t.Leer(archivo, out datos);;
}
catch (Exception e)
{
throw new ArchivosException(e);
}
return(datos);
}
/// <summary>
/// Sobrecarga del operador + "Crea una jornada de la clase y la agrega al gimnasio"
/// </summary>
/// <param name="g">Gimnasio</param>
/// <param name="clase">EClase</param>
/// <returns>Gimnasio con la nueva clase cargada</returns>
public static Gimnasio operator +(Gimnasio g, EClases clase)
{
if (!object.Equals(g, null))
{
Instructor instructor = (g == clase);
if (instructor != null)
{
Jornada jornadaAgregar = new Jornada(clase, instructor);
for (int i = 0; i < g._alumnos.Count; i++)
{
if (g._alumnos[i] == clase)
{
jornadaAgregar += g._alumnos[i];
}
}
g._jornadas.Add(jornadaAgregar);
}
}
return(g);
}
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor profAux = (g == clase);
Jornada jornada = new Jornada(clase, profAux);
bool flag = false;
for (int i = 0; i < g.alumnos.Count; i++)
{
if (g.alumnos[i] == clase)
{
jornada += g.alumnos[i];
flag = true;
}
}
if (flag == true)
{
g.jornada.Add(jornada);
}
return(g);
}
public static Universidad operator +(Universidad g, EClases clase)
{
try
{
Jornada j = new Jornada(clase, g == clase);
g.Jornadas.Add(j);
foreach (Alumno a in g.Alumnos)
{
if (a == clase)
{
j.Alumnos.Add(a);
}
}
return(g);
}
catch (Exception e)
{
throw e;
}
}
public static Gimnasio operator +(Gimnasio g, EClases clase)
{
//foreach (Instructor item in g._instructores)
//{
// if ( item == clase)
// Jornada j = new Jornada(clase,item);
//}
Jornada j = new Jornada(clase, (g == clase));
foreach (Alumno item in g._alumnos)
{
if (item == clase)
{
j = j + item;//sobrecargas jornada + alumno
}
}
g._jornada.Add(j);//agrego la jornada
return(g);
}
/// <summary>
/// Guarda en el archivo Jornada.txt los datos de la Jornada como texto.
/// El archivo se encontrara en EntidadesInstanciables/bin/Debug/
/// </summary>
/// <param name="jornada">Jornada que se desea guardar.</param>
/// <returns>
/// true si se pudo guardar. Si no puede guardar lanzara una excepcion ArchivosException.
/// false si no.
/// </returns>
public static bool Guardar(Jornada jornada)
{
/*
* Sigo pensando que tiene errores el TP, por ej esta funcion nunca va a devolver false, por lo tanto
* no tiene sentido que devuelva un bool. Sin embargo Es la forma en la que mas sentido le encontre
* segun el constructor de la clase ArchivosException y segun los metodos de las clases Texto y Xml que devuelven bool.
*/
bool b = false;
try
{
Archivos.Texto objTexto = new Archivos.Texto();
b = objTexto.guardar("Jornada.txt", jornada.ToString());
}
catch (Exception e)
{
throw new ArchivosException(e);
}
return(b);
}
// METODOS GUARDAR Y LEER
/// <summary>
/// Guarda los datos de la jornada dentro de un archivo.
/// </summary>
/// <param name="jornada"></param>
/// <returns></returns>
public static bool Guardar(Jornada jornada)
{
bool retorno = false;
try
{
Texto t = new Texto();
if (t.Guardar("jornada.txt", jornada.ToString()))
{
retorno = true;
}
}
catch (ArchivosException e)
{
Console.WriteLine(e.Message.ToString());
}
return(retorno);
}
/// <summary>
/// Agrega una jornada al gimnasio si hay un instructor que pueda dar la clase
/// </summary>
/// <param name="g">Gimnasio</param>
/// <param name="clase">Clase a agregar a la jornada</param>
/// <returns></returns>
public static Gimnasio operator +(Gimnasio g, EClases clase)
{
try
{
Jornada j = new Jornada(clase, g == clase);
foreach (Alumno item in g._alumnos)
{
if (item == clase)
{
j += item;
}
}
g._jornada.Add(j);
return(g);
}
catch (SinInstructorException e)
{
throw e;
}
}
/// <summary>
/// agrega una nueva jornada a la universidad validando que halla un profesor que puedar dar dicha clase y agregando alumnos a la jornada que esten anotados en dicha clase
/// </summary>
/// <returns>retorna una universidad con la jornada cargada si estuvo todo bien o la universidad sin la jornada por no haber un profesor que de dicha clase</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
int bandera = 0;
Profesor aux = (g == clase);
Jornada jornada = new Jornada(clase, aux);
for (int i = 0; i < g.alumnos.Count; i++)
{
if (g.alumnos[i] == clase)
{
jornada += g.alumnos[i];
bandera = 1;
}
}
if (bandera == 1)
{
g.Jornadas.Add(jornada);
}
return(g);
}
