/// <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 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);
}
public static bool Guardar(Jornada jornada)
{
bool resultado;
try
{
Texto archivo = new Texto();
resultado = archivo.Guardar("Jornada.txt", jornada.ToString());
}
catch (Exception e)
{
throw new ArchivosException(e);
}
return(resultado);
}
/// <summary>
/// Guarda en un archivo de texto los datos de la jornada.
/// </summary>
/// <param name="jornada">Una jornada cuyos datos se desean guardar.</param>
/// <returns>True si no se produjo ninguna excepcion.</returns>
public static bool Guardar(Jornada jornada)
{
try
{
using (StreamWriter escritor = new StreamWriter("Jornada.txt"))
{
escritor.WriteLine(jornada.ToString());
}
}
catch (Exception ex)
{
throw new ArchivosException(ex);
}
return(true);
}
/// <summary>
/// Genera y Agrega un objeto del tipo Jornada con: el tipo EClase pasado por parametro, un objeto del tipo
/// Profesor que tenga esa EClase y los objetos del tipo Alumno que tengan esa EClase.
/// </summary>
/// <param name="g">Objeto del tipo Universidad</param>
/// <param name="clase">Enum de EClase</param>
/// <returns>
/// Retorna la Universidad con la Jornada agregada. Caso contrario lanzara
/// una excepcion.
/// </returns>
/// <exception cref="SinProfesorException"></exception>
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.jornada.Add(jornada);
return(g);
}
/// <summary>
/// agrega a la universidad una nueva jornada con la clase pasada como parametro, un profesor que pueda dar dicha clase y la lista de alumnos que la toman.
/// </summary>
/// <param name="g"></param>
/// <param name="clase"></param>
/// <returns></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.Alumnos.Add(item);
}
}
g.jornada.Add(auxJornada);
return(g);
}
public static bool Guardar(Jornada jornada)
{
bool retorno = false;
Texto writing = new Texto();
try
{
writing.Guardar("Jornada.txt", jornada.ToString());
retorno = true;
}
catch (ArchivosException e)
{
throw new ArchivosException(e);
}
return(retorno);
}
/// <summary>
/// Guarda los datos de la Jornada en un archivo de texto.
/// </summary>
/// <param name="jornada">La jornada a guardar.</param>
/// <returns>Retorna True si pudo guardar. Caso contrario, lanza una excepcion.</returns>
public static bool Guardar(Jornada jornada)
{
try
{
string path = System.IO.Directory.GetCurrentDirectory()
+ @"\ArchivosGuardados";
System.IO.Directory.CreateDirectory(path);
Texto archivoTexto = new Texto();
archivoTexto.Guardar((path + @"\Jornada.txt"), jornada.ToString());
return(true);
}
catch (Exception e)
{
throw new ArchivosException(e);
}
}
public static Universidad operator +(Universidad u, EClases clase)
{
Profesor p = (u == clase);
Jornada j = new Jornada(clase, p);
foreach (Alumno alumno in u.Alumnos)
{
if (j != alumno && alumno == clase)
{
j.Alumnos.Add(alumno);
}
}
u.Jornadas.Add(j);
return(u);
}
/// <summary>
/// Al agregar una clase a una Universidad se deberá generar y agregar 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>La misma universidad, con la clase agregada en una jornada</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor profesor = (g == clase);
Jornada jornada = new Jornada(clase, profesor);
foreach (Alumno alumno in g.alumnos)
{
if (alumno == clase)
{
jornada.Alumnos.Add(alumno);
}
}
g.Jornadas.Add(jornada);
return(g);
}
/// <summary>
/// Al agregar una clase a una 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="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada nuevaJornada = new Jornada(clase, (g == clase));
g.jornadas.Add(nuevaJornada);
foreach (Alumno item in g.Alumnos)
{
if (item == clase)
{
nuevaJornada.Alumnos.Add(item);
}
}
return(g);
}
public static Universidad operator +(Universidad g, EClases clase)
{
if (!(g is null))
{
Profesor unProfesor = (g == clase);
Jornada nuevaJornada = new Jornada(clase, unProfesor);
foreach (Alumno alumno in g.Alumnos)
{
if (alumno == clase)
{
nuevaJornada += alumno;
}
}
g.Jornadas.Add(nuevaJornada);
}
return(g);
}
/// <summary>
/// Agrega una jornada a universidad con la clase, un profesor que pueda darla, y los alumnos que la toman.
/// </summary>
/// <param name="universidad">universidad</param>
/// <param name="clase">clase a verificar</param>
/// <returns>Retorna la universidad</returns>
public static Universidad operator +(Universidad universidad, EClases clase)
{
Jornada jornadaAAgregar;
Profesor profesorQueDeLaClase = (universidad == clase);
jornadaAAgregar = new Jornada(clase, profesorQueDeLaClase);
foreach (Alumno alumno in universidad.alumnos)
{
if (alumno == clase)
{
jornadaAAgregar += alumno;
}
}
universidad.Jornadas.Add(jornadaAAgregar);
return(universidad);
}
/// <summary>
/// Retorna una Universidad, donde asigna todos los alumnos que cursen esa clase y los agrega a la jornada correspondiente
/// </summary>
/// <param name="g"> Universidad </param>
/// <param name="clase"> Programacion, Laboratorio, Legislacion, SPD </param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor p = g == clase;
Jornada j = new Jornada(clase, p);
foreach (Alumno a in g.alumnos)
{
if (a == clase)
{
j += a;
}
}
g.jornadas.Add(j);
return(g);
}
/// <summary>
/// metodo que guarda en un archivo de texto la jornada de la clase.
/// </summary>
/// <param name="jornada">la jornada a guardar en el archivo</param>
/// <returns></returns>
public static bool Guardar(Jornada jornada)
{
bool retorno = false;
Texto archivoTextoHelper = new Texto();
try
{
archivoTextoHelper.Guardar(GetRutaArchivo(), jornada.ToString());
retorno = true;
}
catch (ArchivosException e)
{
Console.WriteLine(e.Message);
}
return(retorno);
}
/// <summary>
/// Metodo de adicion.
/// Agregara una clase a una universidad.
/// </summary>
/// <param name="u"></param>
/// <param name="clase"></param>
/// <returns> retornara la universidad con la clase agragada. </returns>
public static Universidad operator +(Universidad u, EClases clase)
{
Profesor aux = null;
aux = (u == clase);
Jornada j = new Jornada(clase, aux);
foreach (Alumno item in u.Alumnos)
{
if (item == clase)
{
j += item;
}
}
u.jornada.Add(j);
return(u);
}
/// <summary>
/// Al agregar una clase a un Universidad se 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="u"></param>
/// <param name="c"></param>
/// <returns></returns>
public static Universidad operator +(Universidad u, EClases c)
{
Profesor p = u == c;
Jornada j = new Jornada(c, p);
foreach (Alumno a in u.Alumnos)
{
if (a == c)
{
j += a;
}
}
u.Jornadas.Add(j);
return(u);
}
/// <summary>
/// Metodo que guarda una jornada en un archivo con extension .txt
/// </summary>
/// <param name="jornada">jornada a guardad</param>
/// <returns>true si se guardó correctamente, caso contrario devuelve false</returns>
public static bool Guardar(Jornada jornada)
{
Texto texto = null;
try
{
texto = new Texto();
texto.Guardar("Jornada", jornada.ToString());
}
catch (Exception)
{
throw;
}
return(true);
}
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada j = new Jornada(clase, g == clase);
Alumno a;
for (int i = 0; i < g.Alumnos.Count; i++)
{
a = g.Alumnos[i];
if (a == clase)
{
j.Alumnos.Add(a);
}
}
g.Jornadas.Add(j);
return(g);
}
public static Universidad operator +(Universidad g, EClases clase)
{
Profesor profesor = new Profesor();
profesor = (g == clase);
Jornada nuevaJornada = new Jornada(clase, profesor);
foreach (Alumno aux in g.alumnos)
{
if (aux == clase)
{
nuevaJornada.Alumnos.Add(aux);
}
}
g.jornada.Add(nuevaJornada);
return(g);
}
/// <summary>
/// Guarda los datos de la jornada en Texto.
/// </summary>
/// <param name="jornada"></param>
/// <returns>Retorna true si pudo guardarlos, de lo contrario false.</returns>
public static bool Guardar(Jornada jornada)
{
bool rta = false;
Texto texto = new Texto();
try
{
texto.Guardar("JornadaTxt.txt", jornada.ToString());
rta = true;
}
catch (Exception e)
{
throw e;
}
return(rta);
}
public static bool Guardar(Jornada jornada)
{
try
{
if (!File.Exists("Jornada"))
{
Texto texto = new Texto();
texto.Guardar("Jornada.txt", jornada.ToString());
return(true);
}
}
catch (Exception exception)
{
throw (new ArchivosException(exception));
}
return(false);
}
/// <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 gim, EClases clase)
{
Profesor aux = (gim == clase);
if (aux.DNI != 0)
{
Jornada jornada = new Jornada(clase, aux);
for (int i = 0; i < gim.alumnos.Count; i++)
{
if (gim.alumnos[i] == clase)
{
jornada += gim.alumnos[i];
}
}
gim.jornada.Add(jornada);
}
return(gim);
}
public static bool Guardar(Jornada jornada)
{
Texto texto = new Texto();
return(texto.Guardar("Jornada.txt", jornada.ToString()));
//string archivo = "nuevaJornada";
//Texto<Jornada> aux = new Texto<Jornada>();
//((IArchivo<Jornada>)aux).Guardar(archivo, jornada);
////GuardarTexto<string, int> aux = new GuardarTexto<string, int>();
//bool palabra = ((IGuardar<string, int>)aux).Guardar("");
//int nro = ((IGuardar<string, int>)aux).Leer();
}
/// <summary>
/// revisar si es necesario validar de no crer jornadas que ya existen
/// </summary>
/// <param name="u"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad u, EClases clase)
{
Jornada jornada = new Jornada(clase, u == clase);
foreach (Alumno alumno in u.Alumnos)
{
if (alumno == clase)
{
jornada += alumno;
}
}
u.Jornada.Add(jornada);
return(u);
}
public static Universidad operator +(Universidad u, EClases clase)
{
if (!(u is null))
{
Profesor p = (u == clase);
Jornada j = new Jornada(clase, p);
foreach (Alumno a in u.Alumnos)
{
if (a == clase)
{
j.Alumnos.Add(a);
}
}
u.jornadas.Add(j);
//u.profesores.Add(p);
}
return(u);
}
public static Universidad operator +(Universidad u, EClases clase)
{
Profesor auxInstructor = (u == clase);
Jornada nuevaJornada = new Jornada(clase, auxInstructor);
foreach (Alumno item in u.alumnos)
{
if (item == clase)
{
nuevaJornada += item;
}
}
u.jornada.Add(nuevaJornada);
return(u);
}
/// <summary>
/// Guarda los datos de la jornada.ToString en un archivo de tipo txt en el directorio bin/debug del proyecto
/// </summary>
/// <param name="jornada">jornada a guardar</param>
/// <returns>true si se pudo, sino lanza una excepcion de tipo ArchivosException()</returns>
public static bool Guardar(Jornada jornada)
{
bool rtn = false;
Texto texto = new Texto();
try
{
texto.Guardar("Jornada.txt", jornada.ToString());
rtn = true;
}
catch (Excepciones.ArchivosException e)
{
throw new Excepciones.ArchivosException(e);
}
return(rtn);
}
/// <summary>
/// Agrega una nueva jornada a la universidad con el profesor y alumnos de misma clase
/// </summary>
/// <param name="u"></param>
/// <param name="clase"></param>
/// <returns>Retorna la universidad</returns>
public static Universidad operator +(Universidad u, EClases clase)
{
Profesor profe;
profe = u == clase;
Jornada nueva = new Jornada(clase, profe);
foreach (Alumno alumno in u.Alumnos)
{
if (alumno == clase)
{
nueva.Alumnos.Add(alumno);
}
}
u.Jornadas.Add(nueva);
return(u);
}
/// <summary>
/// Sobrecarga del operador "+",agrega una clase a la universidad
/// </summary>
/// <param name="g">Universidad donde se va a agregar la clase</param>
/// <param name="clase">Clase a agregar</param>
/// <returns>Retorna la Universidad</returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada aux = new Jornada(clase, g == clase);
foreach (Alumno item in g.Alumnos)
{
if (item == clase)
{
aux += item;
}
}
if (aux.Alumnos.Count > 0)
{
g.Jornadas.Add(aux);
}
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"></param>
/// <param name="clase"></param>
/// <returns></returns>
public static Universidad operator +(Universidad g, EClases clase)
{
Jornada jornada = new Jornada(clase, g == clase);
// Agrego la nueva jornada a la lista de jornadas.
g.Jornadas.Add(jornada);
// Recorro todos los alumnos de la universidad y si toman esa clase, los ingreso a la nueva jornada.
foreach (Alumno item in g.Alumnos)
{
if (item == clase)
{
jornada.Alumnos.Add(item);
}
}
return(g);
}
