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 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 <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);
        }
Пример #4
0
        public static ResultadoOperacion iniciarSesion(string usuario, string contrasena)
        {
            // Si hay algún error durante la ejecución de la operación
            // se devolverá el respectivo resultado de operación.
            try
            {
                usuarioActivo =
                    daoUsuarios.
                    seleccionarUsuarioPorUsuarioContrasena(
                        usuario,
                        contrasena);
            }
            catch (MySqlException e)
            {
                return(ControladorExcepciones.crearResultadoOperacionMySqlException(e));
            }
            catch (Exception e)
            {
                return(ControladorExcepciones.crearResultadoOperacionException(e));
            }


            return
                (usuarioActivo != null ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Login")
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorCredencialesIncorrectas,
                     "Login"));
        }
        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 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);
        }
        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);
        }
        // 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 <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 <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 ResultadoOperacion eliminarGrupo(Grupo g)
        {
            // Validamos que no tenga alumnos dependientes
            if (controladorEstudiantes.seleccionarEstudiantesPorGrupo(g).Count > 0)
            {
                return
                    (new ResultadoOperacion(
                         EstadoOperacion.ErrorDependenciaDeDatos,
                         "El grupo contiene estudiantes"));
            }

            ResultadoOperacion innerRO = null;

            int eliminado = 0;

            // Si hay algún error durante la ejecución de la operación
            // se devolverá el respectivo resultado de operación.
            try
            {
                eliminado = daoGrupos.eliminarGrupo(g);
            }
            catch (MySqlException e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionMySqlException(e);
            }
            catch (Exception e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(e);
            }

            // Si no hubo problema, se devolverá el resultado correspondiente.
            return
                (eliminado == 1 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Grupo eliminado")
                :
                 eliminado > 1 ?
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Se han eliminado dos o más grupos",
                     "GrupElim " + eliminado.ToString(),
                     innerRO)
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Grupo no eliminado",
                     null,
                     innerRO));
        }
        // Eliminación
        public ResultadoOperacion eliminarEstudiante(Estudiante e)
        {
            ResultadoOperacion innerRO = null;

            int eliminado = 0;

            // Si hay algún error durante la ejecución de la operación
            // se devolverá el respectivo resultado de operación.
            try
            {
                // Validamos que no pertenezca a grupos...
                if (daoGrupo_Estudiante.seleccionarGrupos_Estudiantes(e).Count > 0)
                {
                    return
                        (new ResultadoOperacion(
                             EstadoOperacion.ErrorDependenciaDeDatos,
                             "El estudiante pertenece a uno o más grupos"));
                }

                eliminado = daoEstudiantes.eliminarEstudiante(e);
            }
            catch (MySqlException ex)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionMySqlException(ex);
            }
            catch (Exception ex)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(ex);
            }

            // Si no hubo problema, se devolverá el resultado correspondiente.
            return
                (eliminado == 1 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Estudiante eliminado")
                :
                 eliminado > 1 ?
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Se han eliminado dos o más estudiantes",
                     "SemElim " + eliminado.ToString(),
                     innerRO)
                :
                 new ResultadoOperacion(
                     EstadoOperacion.NingunResultado,
                     "Estudiante no eliminado",
                     null,
                     innerRO));
        }
        public ResultadoOperacion eliminarDocente(Docente d)
        {
            ResultadoOperacion innerRO = null;

            int eliminado = 0;

            // Si hay algún error durante la ejecución de la operación
            // se devolverá el respectivo resultado de operación.
            try
            {
                // Validamos que no tenga cátedras...
                if (daoCatedras.seleccionarCatedrasPorDocente(d).Count > 0)
                {
                    return
                        (new ResultadoOperacion(
                             EstadoOperacion.ErrorDependenciaDeDatos,
                             "El docente imparte clases a uno o más grupos"));
                }

                eliminado = daoDocentes.eliminarDocente(d);
            }
            catch (MySqlException ex)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionMySqlException(ex);
            }
            catch (Exception ex)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(ex);
            }

            // Si no hubo problema, se devolverá el resultado correspondiente.
            return
                (eliminado == 1 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Docente eliminado")
                :
                 eliminado > 1 ?
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Se han eliminado dos o más docentes",
                     "DocElim " + eliminado.ToString(),
                     innerRO)
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Docente no eliminado",
                     null,
                     innerRO));
        }
        public ResultadoOperacion eliminarSemestre(semestres s)
        {
            CBTis123_Entities db = Vinculo_DB.generarContexto();

            // Validamos que no tenga grupos dependientes
            if (db.grupos.Where(g => g.idSemestre == s.idSemestre).Count() > 0)
            {
                return
                    (new ResultadoOperacion(
                         EstadoOperacion.ErrorDependenciaDeDatos,
                         "El semestre contiene grupos"));
            }

            ResultadoOperacion innerRO = null;

            int eliminado = 0;

            // Si hay algún error durante la ejecución de la operación
            // se devolverá el respectivo resultado de operación.
            try
            {
                s = db.semestres.Single(s1 => s1.idSemestre == s.idSemestre);
                db.semestres.Remove(s);

                eliminado = db.SaveChanges();
            }
            catch (MySqlException e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionMySqlException(e);
            }
            catch (Exception e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(e);
            }

            // Si no hubo problema, se devolverá el resultado correspondiente.
            return
                (eliminado > 0 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Semestre eliminado")
                :
                 new ResultadoOperacion(
                     EstadoOperacion.NingunResultado,
                     "Semestre no eliminado",
                     null,
                     innerRO));
        }
Пример #15
0
        // INSERTS
        public static ResultadoOperacion insertarEstudiantes(IList <estudiantes> listaEstudiantes, grupos g)
        {
            ResultadoOperacion innerRO = null;
            CBTis123_Entities  db      = Vinculo_DB.generarContexto();
            int insertadas             = 0;

            try
            {
                // Primero vemos cuáles ya tiene el grupo...
                IList <grupos_estudiantes> listaActuales = db.grupos_estudiantes.Where(ge => ge.idGrupo == g.idGrupo).ToList();

                // Iteramos sobre los estudiantes que nos pasaron
                foreach (estudiantes e in listaEstudiantes)
                {
                    // Si no existe en el grupo, lo agregamos...
                    grupos_estudiantes ge = listaActuales.FirstOrDefault(ge1 => ge1.idEstudiante == e.idEstudiante);

                    if (ge == null)
                    {
                        grupos_estudiantes geNuevo = new grupos_estudiantes();

                        geNuevo.idEstudiante = e.idEstudiante;
                        geNuevo.idGrupo      = g.idGrupo;

                        db.grupos_estudiantes.Add(geNuevo);
                    }
                }

                // Guardamos cambios
                insertadas = db.SaveChanges();
            }
            catch (Exception e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(e);
            }

            return
                (insertadas > 0 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Estudiantes del grupo modificados")
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Estudiantes del grupo no modificados",
                     null,
                     innerRO));
        }
        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);
        }
Пример #17
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;
        }
        public ResultadoOperacion modificarListaDeCatedras(List <Catedra> listaCatedras)
        {
            ResultadoOperacion innerRO = null;
            int modificadas            = 0;

            // Realizamos la operación, y si hay algún error, se mostrará al usuario.
            try
            {
                foreach (Catedra c in listaCatedras)
                {
                    modificadas += daoCatedras.modificarCatedra(c);
                }
            }
            catch (MySqlException e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionMySqlException(e);
            }
            catch (Exception e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(e);
            }

            // Devolvemos los resultados.
            return
                (modificadas == listaCatedras.Count
                ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Catedras guardadas")
                :
                 modificadas > listaCatedras.Count
                ?
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Se han modificado " + (listaCatedras.Count + 1) + " o más cátedras",
                     "CatMod " + modificadas,
                     innerRO)
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Error al modificar una o todas las cátedras",
                     "CatMod " + modificadas,
                     innerRO));
        }
        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);
        }
        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);
        }
Пример #21
0
        //  UPDATES
        public static ResultadoOperacion actualizarGrupos_Estudiantes(IList <Estudiante> listaEstudiantes, Grupo g)
        {
            ResultadoOperacion innerRO = null;
            CBTis123_Entities  db      = Vinculo_DB.generarContexto();
            int actualizadas           = 0;

            try
            {
                List <grupos_estudiantes> listaPreliminar = db.grupos_estudiantes.Where(ge => ge.idGrupo == g.idGrupo).ToList();

                foreach (grupos_estudiantes ge in listaPreliminar)
                {
                    db.grupos_estudiantes.Remove(ge);
                }

                foreach (Estudiante e in listaEstudiantes)
                {
                    grupos_estudiantes ge = new grupos_estudiantes();
                    ge.idEstudiante = e.idEstudiante;
                    ge.idGrupo      = g.idGrupo;

                    db.grupos_estudiantes.Add(ge);
                }

                actualizadas = db.SaveChanges();
            }
            catch (Exception e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(e);
            }

            return
                (actualizadas > 0 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Estudiantes del grupo modificados")
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Estudiantes del grupo no modificados",
                     null,
                     innerRO));
        }
        public ResultadoOperacion registrarCatedras(List <Catedra> listaCatedras)
        {
            ResultadoOperacion innerRO = null;
            int registradas            = 0;

            // Si hay algún error durante la ejecución, se mostrará
            // resultado de la operación.
            try
            {
                foreach (Catedra c in listaCatedras)
                {
                    registradas += daoCatedras.insertarCatedra(c);
                }
            }
            catch (MySqlException e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionMySqlException(e);
            }
            catch (Exception e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(e);
            }

            // Se devolverá el estado de las materias insertadas.
            return
                (registradas == listaCatedras.Count ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Clases registradas")
                :
                 registradas > listaCatedras.Count ?
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Se han registrado " + (listaCatedras.Count + 1) + " o más clases",
                     "CateReg " + registradas.ToString(),
                     innerRO)
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Error al registrar una o más cátedras",
                     "CateReg " + registradas.ToString(),
                     innerRO));
        }
        public ResultadoOperacion modificarListaDeCatedras(List <catedras> listaCatedras)
        {
            ResultadoOperacion innerRO = null;
            int modificadas            = 0;

            // Realizamos la operación, y si hay algún error, se mostrará al usuario.
            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();

                foreach (catedras c in listaCatedras)
                {
                    catedras c1 = db.catedras.Single(c2 => c2.idCatedra == c.idCatedra);

                    c1.idDocente = c.idDocente;
                    c1.idGrupo   = c.idGrupo;
                    c1.idMateria = c.idMateria;
                }

                modificadas = db.SaveChanges();
            }
            catch (MySqlException e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionMySqlException(e);
            }
            catch (Exception e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(e);
            }

            // Devolvemos los resultados.
            return
                (modificadas > 0 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Catedras guardadas")
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Error al modificar una o todas las cátedras",
                     "CatMod " + modificadas,
                     innerRO));
        }
        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 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 <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);
        }
        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);
        }
        // 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 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);
        }