public List <estudiantes> seleccionarEstudiantesPorGrupo(grupos g)
        {
            if (g == null)
            {
                return(seleccionarEstudiantesADO());
            }

            List <estudiantes> listaEstudiantes = new List <estudiantes>();

            // Si algo sale mal, se lo notificaremos al usuario.
            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();
                g = db.grupos.Single(g1 => g1.idGrupo == g.idGrupo);

                List <grupos_estudiantes> listaGE = g.grupos_estudiantes.ToList();

                foreach (grupos_estudiantes ge in listaGE)
                {
                    listaEstudiantes.Add(ge.estudiantes);
                }
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }


            return(listaEstudiantes);
        }
        public List <docentes> seleccionarDocentes(string s)
        {
            List <docentes> listaDocentes = new List <docentes>();

            // Intentamos realizar la operación. Si hubo algún error,
            // el controlador visual mostrará el mensaje correspondiente.
            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();

                listaDocentes =
                    db.docentes.Where(
                        d => d.nombres.Contains(s) ||
                        d.apellidom.Contains(s) ||
                        d.apellidop.Contains(s) ||
                        (
                            d.nombres.Trim() + " " +
                            d.apellidop.Trim() + " " +
                            d.apellidom.Trim()
                        ).Contains(s) ||
                        d.curp.Contains(s)).ToList();
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            // Devolvemos resultado
            return(listaDocentes);
        }
        public List <Estudiante> seleccionarEstudiantesPorGrupo(Grupo g)
        {
            if (g == null)
            {
                return(seleccionarEstudiantes());
            }

            List <Estudiante> listaEstudiantes = new List <Estudiante>();

            // Si algo sale mal, se lo notificaremos al usuario.
            try
            {
                listaEstudiantes = daoEstudiantes.seleccionarEstudiantesPorGrupo(g);
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }


            return(listaEstudiantes);
        }
        public List <carreras> seleccionarCarrerasADO(int estado = 0)
        {
            // Creamos lista vacía en caso de Excepcion
            List <carreras> listaCarreras = new List <carreras>();

            // Intentamos realizar la operación. Si hubo algún error,
            // el controlador visual mostrará el mensaje correspondiente.
            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();

                listaCarreras =
                    db.carreras.Where(
                        c => c.estado == estado &&
                        c.abreviatura != "BGRAL" &&
                        c.abreviatura != "Todas").ToList();
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaCarreras);
        }
        public List <Grupo> seleccionarGrupos(Semestre s)
        {
            // Creamos lista vacía en caso de Excepcion
            List <Grupo> listaGrupos = new List <Grupo>();

            // Intentamos realizar la operación. Si hubo algún error,
            // el controlador visual mostrará el mensaje correspondiente.
            try
            {
                if (s.idSemestre == 0)
                {
                    listaGrupos = daoGrupos.seleccionarGrupos();
                }
                else if (s.idSemestre > 0)
                {
                    listaGrupos = daoGrupos.seleccionarGruposPorSemestre(s);
                }
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            // Devolvemos resultado
            return(listaGrupos);
        }
        public static List <HistorialCalificacionSemestral> seleccionarHistorial(calificaciones_semestrales calificacion_semestral)
        {
            // Código necesario para los métodos que
            // utilicen la base de datos
            CBTis123_Entities dbContext = Vinculo_DB.generarContexto();

            List <HistorialCalificacionSemestral> listaHistorial = new List <HistorialCalificacionSemestral>();

            try
            {
                historial_calificaciones_semestrales historialBruto =
                    dbContext.
                    historial_calificaciones_semestrales.
                    SingleOrDefault(
                        h =>
                        h.idCalificacion_Semestral == calificacion_semestral.idCalificacion_Semestral
                        );

                if (historialBruto != null)
                {
                    string   s1 = historialBruto.cambios;
                    string[] s2 = s1.Split(new string[] { separadorRegistro }, StringSplitOptions.RemoveEmptyEntries);

                    string[][] valoresFinales = new string[s2.Length][];

                    for (int i = 0; i < s2.Length; i++)
                    {
                        string s = s2[i];

                        valoresFinales[i] = s.Split(new string[] { separadorCampo }, StringSplitOptions.None);
                    }

                    foreach (string[] sArr in valoresFinales)
                    {
                        HistorialCalificacionSemestral h = new HistorialCalificacionSemestral();

                        int posicion = 0;

                        h.nombreDeCampo  = sArr[posicion++];
                        h.valorAnterior  = sArr[posicion++];
                        h.valorNuevo     = sArr[posicion++];
                        h.fuenteDeCambio = sArr[posicion++];
                        h.fecha          = sArr[posicion++];

                        int      idUsuario = Convert.ToInt32(sArr[posicion++]);
                        usuarios u         = dbContext.usuarios.SingleOrDefault(u1 => u1.idUsuario == idUsuario);

                        h.usuarioAutor = u;

                        listaHistorial.Add(h);
                    }
                }
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaHistorial);
        }
        // SELECTS
        public static List <grupos> seleccionarGrupos(
            semestres periodo,
            string turno,
            int semestre,
            carreras carrera
            )
        {
            // Código necesario para los métodos que
            // utilicen la base de datos
            CBTis123_Entities dbContext = Vinculo_DB.generarContexto();

            List <grupos> listaGrupos = new List <grupos>();

            try
            {
                turno = turno.ToUpper()[0].ToString();

                listaGrupos = dbContext.grupos.Where(
                    g =>
                    g.idSemestre == periodo.idSemestre &&
                    g.turno == turno &&
                    g.semestre == semestre &&
                    g.idCarrera == carrera.idCarrera
                    ).ToList();
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaGrupos);
        }
        public List <grupos> seleccionarGrupos(semestres s)
        {
            // Creamos lista vacía en caso de Excepcion
            List <grupos> listaGrupos = new List <grupos>();

            // Intentamos realizar la operación. Si hubo algún error,
            // el controlador visual mostrará el mensaje correspondiente.
            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();

                listaGrupos =
                    db.grupos.Where(g => g.idSemestre == s.idSemestre).
                    OrderBy(g => g.semestre).
                    ThenBy(g => g.turno).
                    ThenBy(g => g.especialidad).
                    ThenBy(g => g.letra).
                    ToList();
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            // Devolvemos resultado
            return(listaGrupos);
        }
Esempio n. 9
0
        public static bool?validarVersion()
        {
            bool?valor = isAplicacionActualizada();

            switch (valor)
            {
            case true:
                break;

            case false:
                ResultadoOperacion ro2 =
                    new ResultadoOperacion(
                        EstadoOperacion.NingunResultado,
                        "No es posible utilizar la aplicación ya que no cuenta con la última versión. " +
                        "(Versión actual " + versionLocal + " | Versión más reciente " + versionServidor + ")",
                        "VerAct " + versionLocal
                        );

                ControladorVisual.mostrarMensaje(ro2);
                break;

            case null:
                ResultadoOperacion ro3 =
                    new ResultadoOperacion(
                        EstadoOperacion.ErrorAplicacion,
                        "No fue posible verificar la versión de la aplicación. Verifique la conexión al servidor.",
                        "VerAct " + versionLocal
                        );

                ControladorVisual.mostrarMensaje(ro3);
                break;
            }

            return(valor);
        }
        public List <Estudiante> seleccionarEstudiantesParametros(
            string coincidencia,
            bool nombrecompleto,
            bool nombres,
            bool apellidoPaterno,
            bool apellidoMaterno,
            bool curp,
            bool nss,
            bool numeroDeControl,
            Grupo g
            )
        {
            List <Estudiante> listaEstudiantes = new List <Estudiante>();

            try
            {
                if (g == null)
                {
                    listaEstudiantes =
                        daoEstudiantes.
                        seleccionarEstudiantesCondicional(
                            numeroDeControl,
                            curp,
                            nombrecompleto,
                            nombres,
                            apellidoPaterno,
                            apellidoMaterno,
                            nss,
                            coincidencia);
                }
                else
                {
                    listaEstudiantes =
                        daoEstudiantes.
                        seleccionarEstudiantesPorGrupoCondicional(
                            g,
                            numeroDeControl,
                            curp,
                            nombrecompleto,
                            nombres,
                            apellidoPaterno,
                            apellidoMaterno,
                            nss,
                            coincidencia);
                }
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
                throw;
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
                throw;
            }

            return(listaEstudiantes);
        }
        public List <estudiantes> seleccionarEstudiantesADO()
        {
            List <estudiantes> listaEstudiantes = new List <estudiantes>();

            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();

                listaEstudiantes = db.estudiantes.ToList();
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaEstudiantes);
        }
Esempio n. 12
0
        private static void seleccionarVersionMasReciente()
        {
            CBTis123_Entities db      = Vinculo_DB.generarContexto();
            datos_varios      version = null;

            try
            {
                version = db.datos_varios.Single(dv => dv.nombre == "version");
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
                version       = new datos_varios();
                version.valor = null;
            }

            versionServidor = version.valor;
        }
        private List <Materia> seleccionarMateriasPorGrupo(Grupo g)
        {
            List <Materia> listaMaterias = new List <Materia>();

            try
            {
                listaMaterias = daoMaterias.seleccionarMateriasPorGrupo(g);
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaMaterias);
        }
        public Docente seleccionarDocente(int idDocente)
        {
            Docente d = null;

            try
            {
                d = daoDocentes.seleccionarDocente(idDocente);
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(d);
        }
        public static List <calificaciones_semestrales> seleccionarCalificaciones(catedras asignatura)
        {
            // Código necesario para los métodos que
            // utilicen la base de datos
            CBTis123_Entities dbContext = Vinculo_DB.generarContexto();

            List <calificaciones_semestrales> listaCalificaciones = new List <calificaciones_semestrales>();

            try
            {
                inicializarCalificaciones(asignatura);
                listaCalificaciones = dbContext.calificaciones_semestrales.Where(c => c.idCatedra == asignatura.idCatedra).ToList();
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaCalificaciones);
        }
        public List <catedras> seleccionarCatedrasPorGrupo(grupos g)
        {
            List <catedras> listaCatedras = new List <catedras>();

            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();

                listaCatedras = db.catedras.Where(c => c.idGrupo == g.idGrupo).ToList();
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaCatedras);
        }
        // Métodos de manipulación del modelo.
        // Selección
        public List <semestres> seleccionarSemestres()
        {
            CBTis123_Entities dbContext      = Vinculo_DB.generarContexto();
            List <semestres>  listaSemestres = new List <semestres>();

            // Si hay algún error durante la ejecución de la operación
            // se mostrará el respectivo resultado de operación.
            try
            {
                listaSemestres = dbContext.semestres.ToList();
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaSemestres);
        }
        // Métodos misceláneos
        public static void inicializarCatedras(grupos grupo)
        {
            // Código necesario para los métodos que
            // utilicen la base de datos
            CBTis123_Entities dbContext = Vinculo_DB.generarContexto();

            try
            {
                List <catedras> listaCatedras = dbContext.catedras.Where(
                    c =>
                    c.idGrupo == grupo.idGrupo
                    ).ToList();

                if (listaCatedras.Count == 0)
                {
                    Grupo g1 = ControladorSingleton.controladorGrupos.seleccionarGrupo(grupo.idGrupo);

                    ControladorSingleton.controladorGrupos.
                    registrarCatedras(
                        ControladorSingleton.controladorGrupos.
                        crearListaCatedrasGrupo(g1));

                    dbContext     = Vinculo_DB.generarContexto();
                    listaCatedras = dbContext.catedras.Where(
                        c =>
                        c.idGrupo == grupo.idGrupo
                        ).ToList();

                    foreach (catedras c in listaCatedras)
                    {
                        inicializarCalificaciones(c);
                    }
                }
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }
        }
        public List <Carrera> seleccionarCarreras(string acuerdo = "2013")
        {
            // Creamos lista vacía en caso de Excepcion
            List <Carrera> listaCarreras = new List <Carrera>();

            // Intentamos realizar la operación. Si hubo algún error,
            // el controlador visual mostrará el mensaje correspondiente.
            try
            {
                listaCarreras = daoCarreras.seleccionarCarrerasPorAcuerdo(acuerdo);
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            return(listaCarreras);
        }
        public List <Semestre> seleccionarSemestresLista()
        {
            List <Semestre> listaSemestres = new List <Semestre>();

            // Creamos el semestre de ningún semestre
            Semestre s = new Semestre();

            s.idSemestre   = -1;
            s.nombre       = "Ningún semestre";
            s.nombreCorto2 = "-";

            // Si hay algún error durante la ejecución de la operación
            // se mostrará el respectivo resultado de operación.
            try
            {
                listaSemestres = daoSemestres.seleccionarSemestres();
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            if (listaSemestres.Count > 0)
            {
                s              = new Semestre();
                s.idSemestre   = 0;
                s.nombre       = "Todos";
                s.nombreCorto2 = "*";
            }

            // Agregamos el semestre comodín
            listaSemestres.Add(s);

            return(listaSemestres);
        }
        // Métodos misceláneos
        public List <Catedra> crearListaCatedrasGrupo(Grupo g)
        {
            List <Catedra> listaCatedras = new List <Catedra>();

            // Intentamos llevar a cabo la operación.
            // Si algo sale mal, se le notificará al usuario.
            try
            {
                List <Materia> listaMaterias = daoMaterias.seleccionarMateriasPorGrupo(g);

                foreach (Materia m in listaMaterias)
                {
                    Catedra c =
                        DAOCatedras.
                        crearCatedra(
                            -1,
                            100,
                            m.idMateria,
                            g.idGrupo,
                            null,
                            m,
                            g);

                    listaCatedras.Add(c);
                }
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            // Devolvemos resultados
            return(listaCatedras);
        }
        public Grupo seleccionarGrupo(int idGrupo)
        {
            // Creamos un grupo nulo para devolverlo luego
            Grupo g = null;

            // Intentamos realizar la operación. Si hubo algún error,
            // el controlador visual mostrará el mensaje correspondiente.
            try
            {
                g = daoGrupos.seleccionarGrupo(idGrupo);
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            // Devolvemos resultado
            return(g);
        }
        // Métodos de manipulación del modelo
        // Selección
        public List <docentes> seleccionarDocentes()
        {
            List <docentes> listaDocentes = new List <docentes>();

            // Intentamos realizar la operación. Si hubo algún error,
            // el controlador visual mostrará el mensaje correspondiente.
            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();

                listaDocentes = db.docentes.ToList();
            }
            catch (MySqlException e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }

            // Devolvemos resultado
            return(listaDocentes);
        }
        public static void inicializarCalificaciones(catedras catedra)
        {
            // Código necesario para los métodos que
            // utilicen la base de datos
            CBTis123_Entities dbContext = Vinculo_DB.generarContexto();

            try
            {
                // Primero, obtenemos todos los estudiantes
                // que pertenecen al grupo de la cátedra
                List <grupos_estudiantes> listaEstudiantesFK =
                    dbContext.
                    grupos_estudiantes.
                    Where(
                        ge =>
                        ge.idGrupo == catedra.idGrupo
                        ).ToList();

                List <estudiantes> listaEstudiantes = new List <estudiantes>();

                foreach (grupos_estudiantes ge in listaEstudiantesFK)
                {
                    listaEstudiantes.Add(ge.estudiantes);
                }


                // Ahora, obtendremos todas las calificaciones
                // que ya existen en la base de datos.
                List <calificaciones_semestrales> listaCalificaciones = new List <calificaciones_semestrales>();

                listaCalificaciones = dbContext.calificaciones_semestrales.Where(c => c.idCatedra == catedra.idCatedra).ToList();


                // Ya que tenemos las calificaciones, iteramos
                // sobre la lista para saber qué alumnos tienen
                // ya un registro. Si no tienen registro, lo agregamos

                // Eliminación de los alumnos que ya tienen calificación
                foreach (calificaciones_semestrales c in listaCalificaciones)
                {
                    listaEstudiantes.RemoveAll(e => e.idEstudiante == c.idEstudiante);
                }

                // De los estudiantes que restan, agregamos una calificación por default
                foreach (estudiantes e in listaEstudiantes)
                {
                    calificaciones_semestrales c = new calificaciones_semestrales
                    {
                        firmado       = false,
                        idCatedra     = catedra.idCatedra,
                        idEstudiante  = e.idEstudiante,
                        recursamiento = false,
                        verificado    = true
                    };

                    dbContext.calificaciones_semestrales.Add(c);
                }

                // Si hubo estudiantes sin calificación, guardamos los cambios
                if (listaEstudiantes.Count > 0)
                {
                    dbContext.SaveChanges();
                }
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(ControladorExcepciones.crearResultadoOperacionException(e));
            }
        }
Esempio n. 25
0
        public static string[][] matricularSemestre(semestres s)
        {
            // Preparamos el contexto
            CBTis123_Entities db = Vinculo_DB.generarContexto();

            // Lista que contendrá todos los grupos.
            List <grupos> listaGruposOriginal = new List <grupos>();

            // Arreglo de listas que contendrán
            // los grupos clasificados por grado
            List <grupos>[] arrGruposPorGrado = new List <grupos> [8];

            for (int i = 0; i < arrGruposPorGrado.Length; i++)
            {
                arrGruposPorGrado[i] = new List <grupos>();
            }

            // Arreglo de la matrícula de todos los grupos.
            string[][] matriculaSemestral = null;

            int totalHombresM = 0;
            int totalHombresV = 0;

            int totalMujeresM = 0;
            int totalMujeresV = 0;

            int totalGruposM = 0;
            int totalGruposV = 0;

            try
            {
                // Obtenemos todos los grupos
                listaGruposOriginal = db.grupos.Where(
                    g => g.idSemestre == s.idSemestre
                    ).ToList();

                // El 13 es por los 4 posibles grados que puede
                // haber simultáneamente en un semestre.
                // Uno es una línea de espacio. El otro es una
                // línea para información general del grado
                // También, por las 4 líneas finales de totales.
                matriculaSemestral = new string[listaGruposOriginal.Count + 13][];

                // Los clasificamos según el grado, a la posición del arreglo
                foreach (grupos g in listaGruposOriginal)
                {
                    arrGruposPorGrado[g.semestre - 1].Add(g);
                }

                // Contador de posición en la matrícula [i][]
                int i = 0;

                // Iteramos sobre todos los grados.
                foreach (List <grupos> lista in arrGruposPorGrado)
                {
                    if (lista.Count == 0)
                    {
                        continue;
                    }

                    // Primero, los ordenamos según la matrícula oficial
                    List <grupos> listaAux = lista.OrderBy(
                        g => g.especialidad
                        ).ThenBy(
                        g => g.turno
                        ).ThenBy(
                        g => g.letra
                        ).ToList();

                    // Luego declaramos los datos extra
                    int gruposM = 0;
                    int gruposV = 0;

                    int hombresM = 0;
                    int hombresV = 0;

                    int mujeresM = 0;
                    int mujeresV = 0;

                    int totalM = 0;
                    int totalV = 0;

                    // Iteramos sobre todos los grupos de un grado específico.
                    // El resultado de la matriculación de ese grupo será añadido
                    // al arreglo de la matrícula semestral.
                    foreach (grupos g in listaAux)
                    {
                        string[] matriculaGrupo = matricularGrupo(g);
                        matriculaSemestral[i] = matriculaGrupo;
                        i++;

                        // Se realizan cálculos extra para los datos extra
                        if (g.turno.ToUpper() == "M")
                        {
                            gruposM++;
                            hombresM += Convert.ToInt32(matriculaGrupo[4]);
                            mujeresM += Convert.ToInt32(matriculaGrupo[5]);
                            totalM   += Convert.ToInt32(matriculaGrupo[6]);
                        }

                        if (g.turno.ToUpper() == "V")
                        {
                            gruposV++;
                            hombresV += Convert.ToInt32(matriculaGrupo[4]);
                            mujeresV += Convert.ToInt32(matriculaGrupo[5]);
                            totalV   += Convert.ToInt32(matriculaGrupo[6]);
                        }
                    }

                    // Se deja un espacio al final de todos los grupos de tal grado.
                    // Se rellena con datos extras.

                    matriculaSemestral[i] = new string[7];

                    matriculaSemestral[i][2] = listaAux.Count.ToString() + " grupos";
                    matriculaSemestral[i][3] = gruposM.ToString();
                    matriculaSemestral[i][4] = hombresM.ToString();
                    matriculaSemestral[i][5] = mujeresM.ToString();
                    matriculaSemestral[i][6] = totalM.ToString();

                    i++;


                    matriculaSemestral[i] = new string[8];

                    matriculaSemestral[i][3] = gruposV.ToString();
                    matriculaSemestral[i][4] = hombresV.ToString();
                    matriculaSemestral[i][5] = mujeresV.ToString();
                    matriculaSemestral[i][6] = totalV.ToString();
                    matriculaSemestral[i][7] = (totalM + totalV).ToString();

                    i++;

                    matriculaSemestral[i] = new string[1];
                    i++;

                    totalHombresM += hombresM;
                    totalHombresV += hombresV;

                    totalMujeresM += mujeresM;
                    totalMujeresV += mujeresV;

                    totalGruposM += gruposM;
                    totalGruposV += gruposV;
                }

                int totalAlumnosM = totalHombresM + totalMujeresM;
                int totalAlumnosV = totalHombresV + totalMujeresV;

                string[] lineaTotal1 = new string[8];
                string[] lineaTotal2 = new string[8];
                string[] lineaTotal3 = new string[8];

                lineaTotal1[1] = "Totales";
                lineaTotal1[2] = "TM";
                lineaTotal1[3] = totalGruposM.ToString();
                lineaTotal1[4] = totalHombresM.ToString();
                lineaTotal1[5] = totalMujeresM.ToString();
                lineaTotal1[6] = totalAlumnosM.ToString();
                lineaTotal2[7] = (totalAlumnosM + totalAlumnosV).ToString();

                lineaTotal2[2] = "TV";
                lineaTotal2[3] = totalGruposV.ToString();
                lineaTotal2[4] = totalHombresV.ToString();
                lineaTotal2[5] = totalMujeresV.ToString();
                lineaTotal2[6] = totalAlumnosV.ToString();

                lineaTotal3[3] = (totalGruposM + totalGruposV).ToString();
                lineaTotal3[4] = (totalHombresM + totalHombresV).ToString();
                lineaTotal3[5] = (totalMujeresM + totalMujeresV).ToString();
                lineaTotal3[6] = (totalAlumnosM + totalAlumnosV).ToString();

                int pos = matriculaSemestral.Length - 1;

                matriculaSemestral[pos - 3] = new string[0];
                matriculaSemestral[pos - 2] = lineaTotal1;
                matriculaSemestral[pos - 1] = lineaTotal2;
                matriculaSemestral[pos]     = lineaTotal3;
            }
            catch (Exception e)
            {
                ControladorVisual.mostrarMensaje(
                    ControladorExcepciones.crearResultadoOperacionException(e)
                    );
            }

            return(matriculaSemestral);
        }