Clase Horario: representa la relación entre los días de la semana y los turnos de cada actividad
Esempio n. 1
0
        // Puntuar un horario según el número de días. Puntuará de 0 a 7, añadirá uno por cada día en el que haya turnos.
        public static int puntuarDias(Horario horario)
        {
            int puntuacion = 0;
            for (int i = 0; i < 7; i++)
            {
                if (horario.ArrayTurnos[i].Count() > 0)
                    puntuacion++;
            }

            return puntuacion;
        }
        /// <summary>
        /// NO USAR, HAY UNA FUNCION EN LOS EN QUE YA HACE ESTO
        /// </summary>
        /// <param name="h"></param>
        /// <returns></returns>
        protected int getMaxHora(Horario h)
        {
            Hora maxHora =  new Hora(0, 1);
            foreach (List<Turno> turnosDia in h.ArrayTurnos) {
                foreach (Turno turno in turnosDia) {
                    if (turno.HoraFin > maxHora)
                        maxHora = turno.HoraFin;
                }
            }

            int mh = maxHora.Hor;
            if (maxHora.Min > 0)
                mh++;

            return mh;
        }
Esempio n. 3
0
        // Puntuar un horario según el número de horas de hueco. Añadirá uno por cada hora entre dos turnos.
        public static int puntuarHorasHueco(Horario horario)
        {
            int puntuacion = 0;
            for (int i = 0; i < 7; i++)
            {
                try
                {
                    // hay que sumar a puntuacion las horas de hueco entre los turnos
                    for (int j = 0; j < horario.ArrayTurnos[i].Count - 1; j++)
                    {
                        puntuacion += Hora.diff(horario.ArrayTurnos[i][j + 1].HoraInicio, horario.ArrayTurnos[i][j].HoraFin);
                    }
                }
                catch (ArgumentNullException) // el día está vacío
                { }
            }

            return puntuacion;
        }
Esempio n. 4
0
        /// <summary>
        /// Constructor de copia
        /// </summary>
        /// <param name="h">Horario que se quiere copiar</param>
        public Horario(Horario h)
        {
            id = h.id;
            nombre = h.nombre;
            usuario = h.usuario;
            publico = h.publico;

            for (int i = 0; i < 7; i++)
            {
                arrayTurnos[i] = new List<Turno>();
                foreach (Turno item in h.ArrayTurnos[i])
                {
                    ArrayTurnos[i].Add(new Turno(item));
                }
            }
        }
Esempio n. 5
0
        /// <summary>
        /// Convierte un DataSet(será un Horario) en un objeto Horario
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static Horario HorarioToObject(DataSet data)
        {
            if (data != null)
            {
                string titulo, usuario = "";
                int id = 0;
                bool publico = false;
                DataSet aux = new DataSet();
                CADUser user = new CADUser();
                DataRowCollection rows = data.Tables[0].Rows;

                if (rows.Count != 0)
                {
                    id = (int)rows[0].ItemArray[0];
                    titulo = rows[0].ItemArray[1].ToString();
                    usuario = rows[0].ItemArray[2].ToString();
                    aux = user.GetDatosUser(usuario);
                    publico = (bool)rows[0].ItemArray[3];
                    Horario hor = new Horario(id, titulo, User.UserToObject(aux), publico);
                    return hor;
                }
            }
            return null;
        }
Esempio n. 6
0
        /// <summary>
        /// Convertimos un Dataset que contiene lista de Horarios en Una lista de Horarios
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static List<Horario> HorariosToList(DataSet data, User autor)
        {
            if (data != null)
            {
                List<Horario> list = new List<Horario>();
                DataSet aux = new DataSet();
                CADUser user = new CADUser();
                string titulo, usuario = "";
                int id = 0;
                bool publico = false;
                DataRowCollection rows = data.Tables[0].Rows;

                for (int i = 0; i < rows.Count; i++)
                {

                    id = (int)rows[i].ItemArray[0];
                    titulo = rows[i].ItemArray[1].ToString();
                    usuario = rows[i].ItemArray[2].ToString();
                    publico = (bool)rows[i].ItemArray[3];
                    if (autor == null)
                    {
                        autor = User.UserToObject(user.GetDatosUser(usuario));

                    }
                    Horario nuevo = new Horario(id, titulo, autor, publico);
                    nuevo.SetTurnos();
                    list.Add(nuevo);
                }
                return list;
            }
            return null;
        }
Esempio n. 7
0
 public void setHorario(Taimer.Horario hor)
 {
     horario = hor;
     lblNombreHora.Text = hor.Nombre;
     loadHorario();
 }
Esempio n. 8
0
 /// <summary>
 /// Asigna un código un horario
 /// </summary>
 /// <param name="h">Horario al que se le quiere dar un código</param>
 private void AsignarCodigo(Horario h)
 {
     h.ID = codHorarios;
     codHorarios++;
 }
Esempio n. 9
0
 /// <summary>
 /// Borrar horario (booleano)
 /// </summary>
 /// <param name="hor">Horario que se desea borrar</param>
 /// <returns>TRUE si borra el horario, FALSE en caso contrario.</returns>
 public bool BorraHorarioBool(Horario hor)
 {
     try {
         hor.Borrar();
     }
     catch {
         return false;
     }
     return horarios.Remove(hor);
 }
Esempio n. 10
0
 /// <summary>
 /// Borrar horario (excepción)
 /// </summary>
 /// <param name="hor">Horario que se desea borrar</param>
 public void BorraHorario(Horario hor)
 {
     if(!horarios.Remove(hor))
         throw new MissingMemberException("No existe el horario que se desea borrar.");
     hor.Borrar();
 }
Esempio n. 11
0
 /// <summary>
 /// Añade un Horario a la lista de horarios y a la BD
 /// </summary>
 /// <param name="horario">Horaio que se desea añadir</param>
 public void AddHorario(Horario horario)
 {
     //AsignarCodigo(horario);
     horario.ID = codHorarios;
     horario.Agregar();
     codHorarios++;
     CADUser usr = new CADUser();
     usr.ModificaUser(dni, nombre, email, password, titulacion, codHorarios, imagen, frase);
     horarios.Add(horario);
 }
        protected Horario horarioPrueba()
        {
            Horario h;
            User user = new User("user", "12345678A", "*****@*****.**", "password", 1, "II");
            h = new Horario("horario", user);
            Actividad_a act = new Actividad_a("Actividad_a", "descripción", "pepe", "II");
            h.AddTurno(new Turno(new Hora(9, 0), new Hora(10, 0), dias.L, "ua", act));
            h.AddTurno(new Turno(new Hora(21, 0), new Hora(22, 0), dias.L, "ua", act));
            h.AddTurno(new Turno(new Hora(13, 30), new Hora(15, 30), dias.L, "ua", act));
            h.AddTurno(new Turno(new Hora(9, 30), new Hora(10, 45), dias.M, "ua", act));
            h.AddTurno(new Turno(new Hora(16, 30), new Hora(20, 0), dias.M, "ua", act));
            h.AddTurno(new Turno(new Hora(9, 0), new Hora(11, 20), dias.J, "ua", act));
            h.AddTurno(new Turno(new Hora(12, 30), new Hora(13, 45), dias.J, "ua", act));
            h.AddTurno(new Turno(new Hora(12, 0), new Hora(14, 30), dias.V, "ua", act));
            h.AddTurno(new Turno(new Hora(21, 0), new Hora(23, 0), dias.V, "ua", act));
            h.AddTurno(new Turno(new Hora(13, 30), new Hora(16, 0), dias.S, "ua", act));
            h.AddTurno(new Turno(new Hora(16, 0), new Hora(20, 0), dias.S, "ua", act));

            return h;
        }
        protected string setHoras(Horario h)
        {
            int minHora = h.minHora().Hor;
            int maxHora = getMaxHora(h);

            string horas = "";
            for(int i = minHora; i < maxHora; i++) {
                if(i == minHora)
                    horas += "<p class='horas' style='margin-top: 5px;'> " + i.ToString() + ":00 </p>";
                else
                    horas += "<p class='horas'> " + i.ToString() + ":00 </p>";
            }

            return horas;
        }
        protected string setColums(Horario h)
        {
            int minHora = h.minHora().Hor;
            int maxHora = getMaxHora(h);
            string columnas = "";

            int indice = 0;

            horarioDe.Text = "Horario de " + h.Usuario.Nombre;
            horarioDe.NavigateUrl = "~/TabPerfil/VerPerfil.aspx?user="******"<script language='javascript'>";
            if (Session["usuario"] != null){
                _script += "sesion = true;";
            }

            foreach(List<Turno> turnoDia in h.ArrayTurnos){
                columnas += "<div class='columnas' style='height: " + (maxHora - minHora)*40 + "px;' >";
                int antH = minHora;
                int antM = 0;

                foreach (Turno turno in turnoDia) {

                    _script += "var detalle" + indice + " = new Array();";
                    _script += "detalle" + indice + "[0]='" + turno.Actividad.Nombre + "';";
                    _script += "detalle" + indice + "[1]='" + turno.Actividad.Descripcion + "';";
                    _script += "detalle" + indice + "[2]='" + turno.Ubicacion + "';";
                    _script += "detalle" + indice + "[3]='" + turno.HoraInicio.toString() + " - " + turno.HoraFin.toString() + "';";
                    _script += "detalle" + indice + "[4]='" + turno.Actividad.Codigo.ToString() + "';";
                    _script += "detalle" + indice + "[5]='";
                    if (turno.Actividad.Codigo < 0 && ((User)Session["usuario"]) != null &&((Actividad_p)turno.Actividad).Usuario.Email == ((User)Session["usuario"]).Email)
                        _script += "1';";
                    else
                        _script += "0';";
                    _script += "turno[" + indice.ToString() + "]=detalle" + indice + ";";

                    int height = (turno.HoraFin.toMin() - turno.HoraInicio.toMin())* 40 / 60; //calculamos el tamaño del cuadro
                    int top = (turno.HoraInicio.Hor - antH)*40;   //calculo de desplazamiento (horas)
                    top += (turno.HoraInicio.Min - antM) * 40 / 60;  //calculo de desplazamiento (minutos)

                    columnas += "<div id='" + indice.ToString() + "' onclick='setDetalles(id)' onmouseover='selected(id)' onmouseout='unselected(id)' class='Asignatura' style='height: " + height + "px; margin-top: " + top + "px'>";
                        columnas += "<p class='asigText'>" + turno.Actividad.Nombre + "</p>";
                    columnas += "</div>";

                    antH = turno.HoraFin.Hor;
                    antM = turno.HoraFin.Min;
                    indice++;
                }
                columnas += "</div>";
            }

            _script += "</script>";

            return columnas;
        }
Esempio n. 15
0
        public Horario generarHorarioBT(string nombre, bool minDias, bool[] listaDias)
        {
            Queue<Horario> nodos_vivos = new Queue<Horario>();
            Queue<Horario> nodos_vivos_aux = new Queue<Horario>();
            Queue<Horario> soluciones = new Queue<Horario>();

            Horario optimo = new Horario(nombre, usuario);

            int cant_p = 0;

            // como las personales siempre tienen que estar, se meten directamente en el óptimo
            foreach (Actividad_p personal in seleccionadas_p)
            {
                foreach (Turno item in personal.Turnos)
                {
                    try
                    {
                        if(!listaDias[TaimerLibrary.convertToInt(item.Dia)])
                            throw new NotSupportedException();
                        optimo.AddTurno(item);
                        cant_p++;
                    }
                    catch (NotSupportedException)
                    {
                        throw new NotSupportedException("Con las restricciones actuales, la actividad \"" + personal.Nombre + "\" no se puede insertar");
                    }
                }
            }

            nodos_vivos.Enqueue(optimo);
            Horario temp;

            // como las académicas tienen que tener un único turno, se mete cada vez en un horario distinto
            bool asignado = false;

            try
            {
                foreach (Actividad_a academica in seleccionadas_a)
                {
                    asignado = false;
                    while (nodos_vivos.Count > 0)
                    {
                        optimo = nodos_vivos.Dequeue();
                        foreach (Turno item in academica.Turnos)
                        {
                            temp = new Horario(optimo);
                            try
                            {
                                if (!listaDias[TaimerLibrary.convertToInt(item.Dia)])
                                    throw new NotSupportedException();
                                temp.AddTurno(item);
                                if (temp.Count - cant_p < seleccionadas_a.Count)
                                    nodos_vivos_aux.Enqueue(temp);
                                else
                                    soluciones.Enqueue(temp);
                                asignado = true;
                            }
                            catch (NotSupportedException)
                            { }

                        }
                    }

                    nodos_vivos = new Queue<Horario>(nodos_vivos_aux);
                    nodos_vivos_aux.Clear();

                    if (!asignado)
                        throw new NotSupportedException("Con las restricciones actuales, la asignatura \"" + academica.Nombre + "\" no se puede insertar");

                }
                if (seleccionadas_a.Count != 0)
                {
                    posibles = new List<Horario>(soluciones.ToList());
                    optimo = null;
                }
                else
                    posibles = new List<Horario>(nodos_vivos.ToList());

                int puntuacion = int.MaxValue;
                if (minDias)
                {
                    foreach (Horario sol in posibles)
                    {
                        if (puntuarDias(sol) < puntuacion)
                        {
                            optimo = sol;
                            puntuacion = puntuarDias(sol);
                        }
                    }

                }
                else // suponemos que o es minDias o es minHuecos
                {
                    foreach (Horario sol in posibles)
                    {
                        if (puntuarHorasHueco(sol) < puntuacion)
                        {
                            optimo = sol;
                            puntuacion = puntuarHorasHueco(sol);
                        }
                    }
                }

            }
            catch (NotSupportedException)
            {
                if (posibles != null)
                {
                    posibles.Clear();
                    posibles = null;
                }
                throw;
            }

            return optimo;
        }
Esempio n. 16
0
        //Generación de un Horario de forma Voraz
        public Horario generarHorarioVoraz(string nombre)
        {
            // el user será el 1er elemento de la lista de users de Program
            //User usertest = new User("Aitor Tilla", "12345678X", "*****@*****.**", "password", 1, "Ingeniería de Magisterio");
            Horario h = new Horario(nombre, usuario);
            foreach (Actividad_p personal in seleccionadas_p)
            {
                foreach (Turno item in personal.Turnos)
                {
                    try
                    {
                        h.AddTurno(item);
                    }
                    catch (NotSupportedException)
                    {
                        throw new NotSupportedException("La actividad " + personal.Nombre + " no se puede insertar");
                    }
                }

            }
            bool asignado;
            foreach (Actividad_a asig in seleccionadas_a)
            {
                asignado = false;
                foreach (Turno item in asig.Turnos)
                {
                    if (asignado)
                        break;
                    try
                    {
                        h.AddTurno(item);
                        asignado = true;
                    }
                    catch (NotSupportedException)
                    {
                        asignado = false;
                    }
                }
                if (!asignado)
                    throw new NotSupportedException("La asignatura " + asig.Nombre + " no se puede insertar");
            }

            return h;
        }