/// <summary>
/// Agrega una nueva jornada con la clase ingresada
/// </summary>
/// <param name="g">Universidad donde se agrega la clase</param>
/// <param name="clase">Clase a agregar </param>
/// <returns> Retorna universidad con la clase y los alumnos de la clase</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada nuevaJornada = new Jornada(clase, g == clase);
foreach (Alumno alumnoAux in g.alumnos)
{
if (alumnoAux == clase)
{
nuevaJornada.Alumnos.Add(alumnoAux);
}
}
g.jornada.Add(nuevaJornada);
return(g);
}
/// <summary>
/// Guarda los datos en el archivo txt, sino lanza un error controlado
/// </summary>
/// <param name="jornada"></param>
/// <returns></returns>
public static bool Guardar(Jornada jornada)
{
Texto texto = new Texto();
string fileName = Environment.GetFolderPath(Environment.SpecialFolder.Desktop)
+ "\\jornada.txt";
try
{
texto.Guardar(fileName, jornada.ToString());
return(true);
}
catch (Exception e)
{
throw new ArchivosException("Error al guardar Jornada.txt", e);
}
}
/// <summary>
/// Asigna una clase a la universidads
/// </summary>
/// <param name="u"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad u, EClases clase)
{
Profesor profeAsignado = (u == clase);
Jornada nuevaJornada = new Jornada(clase, profeAsignado);
foreach (Alumno a in u.Alumnos)
{
if (a == clase)
{
nuevaJornada = nuevaJornada + a;
}
}
u.jornadas.Add(nuevaJornada);
return(u);
}
/// <summary>
/// Si un alumno toma la clase recibida por parámetro, se agrega el alumno a una jornada
/// </summary>
/// <param name="g">Universidad</param>
/// <param name="clase">Clase</param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada jor = new Jornada(clase, g == clase);
g.jornada.Add(jor);
foreach (Alumno alumno in g.alumnos)
{
if (alumno == clase)
{
jor += alumno;
}
}
return g;
}
/// <summary>
/// Agregar una clase a una universidad, creara una nueva jornada con los instructores y alumnos que esten en esa clase.
/// Caso contrario, se lanzaran las excepciones correspondientes.
/// </summary>
/// <param name="g"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor unProfesor = (g == clase);
Jornada nuevaJornada = new Jornada(clase, unProfesor);
foreach (Alumno item in g.alumnos)
{
if (item == clase)
{
nuevaJornada.Alumnos.Add(item);
}
}
g.Jornadas.Add(nuevaJornada);
return(g);
}
/// <summary>
/// genera y agrega una nueva Jornada indicando la clase, un Profesor que pueda darla y la lista de alumnos que la toman.
/// </summary>
/// <param name="g"></param>
/// <param name="clase"></param>
/// <returns>El objeto de tipo Universidad con la Jornada cargada</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada auxJornada = new Jornada(clase, (g == clase));
foreach (Alumno item in g.alumnos)
{
if (item == clase)
{
auxJornada += item;
}
}
g.jornada.Add(auxJornada);
return(g);
}
/// <summary>
/// Al agregar una clase a un Universidad se deberá generar y agregar una nueva Jornada
/// indicando la lase, 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"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada jornadaAux = new Jornada(clase, g == clase);
foreach (Alumno item in g.alumnos)
{
if (item == clase)
{
jornadaAux += item;
}
}
g.jornada.Add(jornadaAux);
return(g);
}
public static Universidad operator +(Universidad uni, EClases clases)
{
Jornada jornadaNueva = new Jornada(clases, (uni == clases));
foreach (Alumno a in uni.alumnos)
{
if (a == clases)
{
jornadaNueva.Alumnos.Add(a);
}
}
uni.jordanas.Add(jornadaNueva);
return(uni);
}
/// <summary>
/// Agrega una nueva Clase, generando una nueva Jornada
/// (con su respectivo Profesor y Alumnos que tomen esa clase)
/// </summary>
/// <param name="g">Universidad a cargar</param>
/// <param name="clase">Clase deseada</param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada jornada;
Profesor profesor = g == clase;
jornada = new Jornada(clase, profesor);
foreach (Alumno aux in g.Alumnos)
{
if (aux == clase)
{
jornada = jornada + aux;
}
}
g.Jornadas.Add(jornada);
return(g);
}
/// <summary>
/// Agrega una nueva jornada de clase. Asigna un profesor a la misma
/// y a los alumnos que tomen esa clase.
/// </summary>
/// <param name="g"></param>Universidad a la cual se le agregara una clase
/// <param name="clase"></param>Clase a ser agregada
/// <returns></returns>La universidad con la nueva jornada de clase cargada
public static Universidad operator +(Universidad u, EClase clase)
{
Jornada jornadaAux = new Jornada(clase, u == clase);
foreach (Alumno a in u.Alumnos)
{
if (a == clase)
{
jornadaAux.Alumnos.Add(a);
}
}
u.Jornadas.Add(jornadaAux);
return(u);
}
public static Universidad operator +(Universidad g, EClases clase)
{
if (!object.ReferenceEquals(g, null))
{
Jornada j = new Jornada(clase, g == clase);
foreach (Alumno alumno in g.Alumnos)
{
if (!object.ReferenceEquals(alumno, null) && alumno == clase) // acá evaluo los alumnos que toman esa clase para agregarlos (en caso afirmativo) a la jornada
{
j += alumno;
}
}
g.Jornadas.Add(j);
}
return(g);
}
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada jornada = new Jornada(clase, (g == clase));
foreach (Alumno alumno in g.Alumnos)
{
if (alumno == clase)
{
jornada += alumno;
}
}
g.Jornadas.Add(jornada);
return(g);
}
public static bool Leer(Jornada jornada)
{
try
{
Texto t = new Archivos.Texto();
string datos;
string archivo = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\Jornada.txt";
bool s = t.Leer(archivo, out datos);;
Console.WriteLine(datos);
return(s);
}
catch (Exception e)
{
throw new ArchivosException(e);
}
}
public static Universidad operator +(Universidad u, EClases clase)
{
Jornada nuevaJornada = new Jornada(clase, u == clase);
foreach (Alumno item in u.alumnos)
{
if (item == clase)
{
nuevaJornada.Alumnos.Add(item);
}
}
u.jornada.Add(nuevaJornada);
return(u);
}
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada auxJornada = new Jornada(clase, g == clase);
foreach (Alumno alumno in g.alumnos)
{
if (alumno == clase)
{
auxJornada.Alumnos.Add(alumno);
}
}
g.jornada.Add(auxJornada);
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="uni"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad uni, EClases clase)
{
Profesor miProfesor;
miProfesor = uni == clase;
Jornada miJornada = new Jornada(clase, miProfesor);
foreach (Alumno miAlumno in uni.Alumnos)
{
if (miAlumno == clase)
{
miJornada.Alumnos.Add(miAlumno);
}
}
uni.Jornadas.Add(miJornada);
return(uni);
}
/// <summary>
/// Guarda en un archivo de texto los datos de la jornada
/// </summary>
/// <param name="jornada"></param>
/// <returns></returns>
public static bool Guardar(Jornada jornada)
{
string ruta = AppDomain.CurrentDomain.BaseDirectory + "\\Jornada.txt";
Texto text = new Texto();
if (text.Guardar(ruta, jornada.ToString()))
{
return(true);
}
else
{
return(false);
}
}
public static bool Guardar(Jornada jornada)
{
Texto guardar = new Texto();
string archivo = AppDomain.CurrentDomain.BaseDirectory + "texto.txt";
bool rtnVal;
try
{
rtnVal = guardar.Guardar(archivo, jornada.ToString());
}
catch (Excepciones.ArchivosException)
{
rtnVal = false;
}
return(rtnVal);
}
/// <summary>
/// Guardar de clase guardará los datos de la Jornada en un archivo de texto.
/// </summary>
/// <param name="jornada"></param>
/// <returns></returns>
public static bool Guardar(Jornada jornada)
{
bool retorno = false;
Texto texto = new Texto();
try
{
texto.Guardar("Jornada.txt", jornada.ToString());
retorno = true;
}
catch (ArchivosException e)
{
throw new ArchivosException(e);
}
return(retorno);
}
/// <summary>
/// Agregar una Clase a la Universidad, creando una nuva Jornada
/// </summary>
/// <param name="u">Universidad</param>
/// <param name="clase">Clase</param>
/// <returns>Devuelvo la universidad modificada</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>
/// 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"></param>
/// <param name="clases"></param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clases)
{
Profesor profesorAsignado = (g == clases);
Jornada nuevaJornada = new Jornada(clases, profesorAsignado);
foreach (Alumno aux in g.Alumnos)
{
if (aux == clases)
{
nuevaJornada = nuevaJornada + aux;
}
}
g.Jornadas.Add(nuevaJornada);
return(g);
}
/// <summary>
/// Se encarga de generar una jornada y a su vez, determinar que profesor la da y
/// que alumonos la toman
/// </summary>
/// <param name="g"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada nuevaJornada = new Jornada(clase, g == clase);
for (int i = 0; i < g.alumnos.Count; i++)
{
if (g.alumnos[i] == clase)
{
nuevaJornada += g.alumnos[i];
}
}
g.jornada.Add(nuevaJornada);
return(g);
}
/// <summary>
/// Crea una jornada en la universidad de la clase indicada, con un profesor y los alumnos que tomen esa clase.
/// </summary>
/// <param name="u">la universidad</param>
/// <param name="clase">la clase a dictar</param>
/// <returns>la misma universidad con la jornada ya añadida</returns>
public static Universidad operator +(Universidad u, EClases clase)
{
Profesor profesor = u == clase;
Jornada jornada = new Jornada(clase, profesor);
foreach (Alumno alumno in u.alumnos)
{
if (alumno == clase)
{
jornada += alumno;
}
}
u.jornadas.Add(jornada);
return(u);
}
public static bool Guardar(Jornada jornada)
{
if (!(jornada is null))
{
Texto texto = new Texto();
try
{
texto.Guardar("Jornada.txt", jornada.ToString());
}
catch (Exception e)
{
throw new ArchivosException(e);
}
}
return(true);
}
/// <summary>
/// Guarda todos los datos de la jornada en un archivo txt,siempre y cuando cumpla con la condicion
/// </summary>
/// <param name="j"></param>
/// <returns></returns>
public static bool Guardar(Jornada j)
{
Texto textoJornada = new Texto();
try
{
if (textoJornada.Guardar(string.Format(AppDomain.CurrentDomain.BaseDirectory + "Jornada.txt"), j.ToString()))
{
return(true);
}
}
catch (ArchivosException e)
{
throw new ArchivosException(e);
}
return(false);
}
public static Universidad operator +(Universidad g, EClases clases)
{
Profesor profesor = g == clases;
Jornada jornada = new Jornada(clases, profesor);
foreach (Alumno a in g.alumnos)
{
if (jornada == a)
{
jornada += a;
}
}
if (!object.Equals(jornada.Instructor, null))
{
g.jornada.Add(jornada);
}
return(g);
}
/// <summary>
/// Agrega a la universidad una nueva jornada con la clase pasada como parametro, un profesor que pueda la dicha clase y la lista de alumnos que la toman
/// </summary>
/// <param name="g">La universidad.</param>
/// <param name="clase">La clase</param>
/// <returns>Devuelve la universidad pasada como parametro</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada nuevaJornada = new Jornada(clase, g == clase);
foreach (Alumno alumno in g.Alumnos)
{
if (alumno == clase)
{
nuevaJornada.Alumnos.Add(alumno);
}
}
if (nuevaJornada.Alumnos.Count > 0)
{
g.Jornadas.Add(nuevaJornada);
}
return(g);
}
/// <summary>
/// Sobreescritura del operator +, recibe una universidad y una clase, crea una jornada para la clase y le asigna un profesor
/// y la agrega a la universidad
/// </summary>
/// <param name="uni"></param>
/// <param name="clase"></param>
/// <returns>retorna la universidad con la jornada agregada en caso de que halla profesor, sino retorna la misma universidad</returns>
public static Universidad operator +(Universidad uni, EClases clase)
{
Profesor auxProfe = (uni == clase);
if (auxProfe != null)
{
Jornada auxJor = new Jornada(clase, auxProfe);
foreach (Alumno a in uni.Alumnos)
{
if (a == clase)
{
auxJor += a;
}
}
uni.jornada.Add(auxJor);
}
return(uni);
}
/// <summary>
/// Operador que agrega una clase a la universidad con un profesor que la dicte
/// </summary>
/// <param name="g"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor p = (g == clase);
if (!Equals(p, null))
{
Jornada j = new Jornada(clase, p);
foreach (Alumno a in g.Alumnos)
{
if (a == clase)
{
j += a;
}
}
g.jornada.Add(j);
}
return(g);
}
public static Universidad operator +(Universidad uni, EClases clase)
{
Profesor p = uni == clase;
if (p == clase)
{
Jornada j = new Jornada(clase, p);
foreach (Alumno a in uni.Alumnos)
{
if (j == a)
{
j += a;
}
}
uni.Jornadas.Add(j);
}
return(uni);
}
