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 <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);
        }
        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 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));
        }
Ejemplo n.º 8
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);
        }
Ejemplo n.º 10
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;
        }
Ejemplo n.º 11
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 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));
            }
        }
        // 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 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);
        }
        private void FrmPruebas_Load(object sender, EventArgs e)
        {
            CBTis123_Entities dbContext = ControladorSingleton.dbContext;

            dataGridView1.DataSource = dbContext.catedras.ToList();
        }
        public static List <calificaciones_semestrales> crearListaCalificaciones(string[][] tabla, int idCatedra = -1, catedras catedra = null)
        {
            // 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>();

            foreach (string[] row in tabla)
            {
                if (row.Length < 13)
                {
                    continue;
                }

                calificaciones_semestrales c = new calificaciones_semestrales();

                string ncontrol = row[1];
                string nombres  = row[2];

                // ASISTENCIAS
                if (row[6] != null && row[6] != "")
                {
                    c.asistenciasParcial1 = Convert.ToInt32(row[6]);
                }
                else
                {
                    c.asistenciasParcial1 = null;
                }

                if (row[7] != null && row[7] != "")
                {
                    c.asistenciasParcial2 = Convert.ToInt32(row[7]);
                }
                else
                {
                    c.asistenciasParcial2 = null;
                }

                if (row[8] != null && row[8] != "")
                {
                    c.asistenciasParcial3 = Convert.ToInt32(row[8]);
                }
                else
                {
                    c.asistenciasParcial3 = null;
                }


                // CALIFICACIONES PARCIALES
                if (row[3] != null && row[3] != "")
                {
                    c.calificacionParcial1 = Convert.ToDouble(row[3]);
                }
                else
                {
                    c.calificacionParcial1 = null;
                }

                if (row[4] != null && row[4] != "")
                {
                    c.calificacionParcial2 = Convert.ToDouble(row[4]);
                }
                else
                {
                    c.calificacionParcial2 = null;
                }

                if (row[5] != null && row[5] != "")
                {
                    c.calificacionParcial3 = Convert.ToDouble(row[5]);
                }
                else
                {
                    c.calificacionParcial3 = null;
                }

                estudiantes estudianteDeCalificacion = dbContext.estudiantes.SingleOrDefault(e => e.ncontrol == ncontrol);

                if (estudianteDeCalificacion == null)
                {
                    estudianteDeCalificacion = new estudiantes()
                    {
                        idEstudiante = -1, nombrecompleto = nombres, nombres = nombres, ncontrol = ncontrol
                    };
                }

                c.estudiantes = estudianteDeCalificacion;


                c.idEstudiante             = c.estudiantes.idEstudiante;
                c.firmado                  = Convert.ToBoolean(row[12]);
                c.idCalificacion_Semestral = -1;
                c.recursamiento            = false;
                c.tipoDeAcreditacion       = row[11];
                c.catedras                 = catedra;
                c.idCatedra                = idCatedra;


                listaCalificaciones.Add(c);
            }

            return(listaCalificaciones);
        }
        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));
            }
        }
        public static ResultadoOperacion actualizarCalificacionesDesdeSiseems(IList <calificaciones_semestrales> listaCalificaciones, string clase = "Desconocida")
        {
            // Código necesario para los métodos que
            // utilicen la base de datos
            CBTis123_Entities dbContext = Vinculo_DB.generarContexto();
            bool cambios = false;

            try
            {
                // Iteramos sobre las calificaciones que nos pasaron para registrar a los estudiantes
                foreach (calificaciones_semestrales c in listaCalificaciones)
                {
                    // Si su estudiante no existe, lo agregamos a la base de datos
                    if (c.idEstudiante == -1)
                    {
                        estudiantes estudianteC = c.estudiantes;

                        estudianteC.idEstudiante = 0;
                        //estudianteC.ncontrol = estudianteC.ncontrol.Substring(0, 18);
                        //estudianteC.nombrecompleto = estudianteC.nombrecompleto.Substring(0, 60);
                        //estudianteC.nombres = estudianteC.nombres.Substring(0, 30);
                        estudianteC.curp       = "";
                        estudianteC.apellido1  = "";
                        estudianteC.apellido2  = "";
                        estudianteC.nss        = "";
                        estudianteC.verificado = false;

                        c.estudiantes = dbContext.estudiantes.Add(estudianteC);
                        cambios       = true;
                    }
                }

                // Si hubo cambios en la base de datos los guardamos
                if (cambios)
                {
                    dbContext.SaveChanges();
                }

                cambios = false;

                // Iteramos sobre las calificaciones que nos pasaron
                // y si no existe alguna, creamos una temporal antes de
                // que registremos los verdaderos valores
                foreach (calificaciones_semestrales c in listaCalificaciones)
                {
                    calificaciones_semestrales cUpdated = dbContext.calificaciones_semestrales.SingleOrDefault(
                        c1 => c1.idCatedra == c.idCatedra && c1.idEstudiante == c.idEstudiante
                        );

                    if (cUpdated == null)
                    {
                        cUpdated = new calificaciones_semestrales()
                        {
                            firmado       = false,
                            idCatedra     = c.idCatedra,
                            idEstudiante  = c.idEstudiante,
                            recursamiento = true
                        };

                        dbContext.calificaciones_semestrales.Add(cUpdated);
                        cambios = true;
                    }
                }

                if (cambios)
                {
                    dbContext.SaveChanges();
                }

                // Finalmente registramos el bonche de calificaciones
                return(actualizarCalificaciones(listaCalificaciones, "Importación de SISEEMS"));
            }
            catch (Exception e)
            {
                return(ControladorExcepciones.crearResultadoOperacionException(e));
            }
        }
        // UPDATES
        public static ResultadoOperacion actualizarCalificaciones(IList <calificaciones_semestrales> listaCalificaciones, string razon)
        {
            // Código necesario para los métodos que
            // utilicen la base de datos
            CBTis123_Entities dbContext = Vinculo_DB.generarContexto();

            // Setteamos variables necesarias para el método
            int calificacionesModificadas = 0;
            ResultadoOperacion innerRO    = null;

            bool cambios = false;

            try
            {
                // Iteramos sobre la lista que nos pasaron
                foreach (calificaciones_semestrales c in listaCalificaciones)
                {
                    // Creamos un StringBuilder para guardar cualquier cambio
                    StringBuilder logCambios = new StringBuilder();

                    // Obtenemos las calificaciones que hay en la DB
                    calificaciones_semestrales cUpdated = dbContext.calificaciones_semestrales.SingleOrDefault(
                        c1 => c1.idCatedra == c.idCatedra && c1.idEstudiante == c.idEstudiante
                        );

                    // Si hay algún cambio en cualquiera de los campos,
                    // se agregará el registro al StringBuilder, y se
                    // encenderá la bandera de que hubo cambio

                    // PRIMERO, las asistencias
                    if (ControladorMiscelaneo.compararNullableDouble(cUpdated.asistenciasParcial1, c.asistenciasParcial1) != 0)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Asistencias parcial 1",
                                cUpdated.asistenciasParcial1.ToString(),
                                c.asistenciasParcial1.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.asistenciasParcial1 = c.asistenciasParcial1;
                        cambios = true;
                    }

                    if (ControladorMiscelaneo.compararNullableDouble(cUpdated.asistenciasParcial2, c.asistenciasParcial2) != 0)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Asistencias parcial 2",
                                cUpdated.asistenciasParcial2.ToString(),
                                c.asistenciasParcial2.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.asistenciasParcial2 = c.asistenciasParcial2;
                        cambios = true;
                    }

                    if (ControladorMiscelaneo.compararNullableDouble(cUpdated.asistenciasParcial3, c.asistenciasParcial3) != 0)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Asistencias parcial 3",
                                cUpdated.asistenciasParcial3.ToString(),
                                c.asistenciasParcial3.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.asistenciasParcial3 = c.asistenciasParcial3;
                        cambios = true;
                    }


                    // SEGUNDO, las calificaciones
                    if (ControladorMiscelaneo.compararNullableDouble(cUpdated.calificacionParcial1, c.calificacionParcial1) != 0)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Calificación parcial 1",
                                cUpdated.calificacionParcial1.ToString(),
                                c.calificacionParcial1.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.calificacionParcial1 = c.calificacionParcial1;
                        cambios = true;
                    }

                    if (ControladorMiscelaneo.compararNullableDouble(cUpdated.calificacionParcial2, c.calificacionParcial2) != 0)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Calificación parcial 2",
                                cUpdated.calificacionParcial2.ToString(),
                                c.calificacionParcial2.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.calificacionParcial2 = c.calificacionParcial2;
                        cambios = true;
                    }

                    if (ControladorMiscelaneo.compararNullableDouble(cUpdated.calificacionParcial3, c.calificacionParcial3) != 0)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Calificación parcial 3",
                                cUpdated.calificacionParcial3.ToString(),
                                c.calificacionParcial3.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.calificacionParcial3 = c.calificacionParcial3;
                        cambios = true;
                    }


                    //TERCERO, otros datos que se pueden modificar en el DGV
                    if (cUpdated.firmado != c.firmado)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Firmado",
                                cUpdated.firmado.ToString(),
                                c.firmado.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.firmado = c.firmado;
                        cambios          = true;
                    }

                    if (cUpdated.tipoDeAcreditacion != c.tipoDeAcreditacion)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Tipo de acreditación",
                                cUpdated.tipoDeAcreditacion,
                                c.tipoDeAcreditacion,
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.tipoDeAcreditacion = c.tipoDeAcreditacion;
                        cambios = true;
                    }

                    if (cUpdated.recursamiento != c.recursamiento)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Firmado",
                                cUpdated.recursamiento.ToString(),
                                c.recursamiento.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.recursamiento = c.recursamiento;
                        cambios = true;
                    }

                    if (cUpdated.verificado != c.verificado)
                    {
                        logCambios.Append(
                            crearLogCambios(
                                "Tipo de acreditación",
                                cUpdated.verificado.ToString(),
                                c.verificado.ToString(),
                                razon,
                                ControladorSesion.usuarioActivo.idUsuario
                                )
                            );

                        cUpdated.verificado = c.verificado;
                        cambios             = true;
                    }

                    // Ahora, para guardar en el historial,
                    // comprobamos que exista. Si no existe,
                    // lo creamos y agregmos los cambios del StringBuilder.
                    // Si ya existe, simplemente agregamos los
                    // cambios al final de la cadena.
                    historial_calificaciones_semestrales historial = dbContext.historial_calificaciones_semestrales.SingleOrDefault(h => h.idCalificacion_Semestral == cUpdated.idCalificacion_Semestral);

                    if (historial == null)
                    {
                        historial = new historial_calificaciones_semestrales()
                        {
                            idCalificacion_Semestral = cUpdated.idCalificacion_Semestral,
                            cambios = logCambios.ToString()
                        };

                        dbContext.historial_calificaciones_semestrales.Add(historial);
                    }
                    else
                    {
                        historial.cambios += logCambios.ToString();
                    }
                }

                // Si hubo cambios, se guardan
                if (cambios)
                {
                    calificacionesModificadas = dbContext.SaveChanges();
                }
            }
            catch (Exception e)
            {
                innerRO = ControladorExcepciones.crearResultadoOperacionException(e);
            }

            int listaCalificacionesCount = listaCalificaciones.Count;

            return
                (!cambios
                ?
                 new ResultadoOperacion(
                     EstadoOperacion.NingunResultado,
                     "No se guardó ninguna calificación - " + razon,
                     null,
                     innerRO)
                :
                 calificacionesModificadas > 0
                ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Calificaciones actualizadas - " + razon,
                     null,
                     innerRO)
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "No se han actualizado las calificaciones - " + razon,
                     "CalAct " + calificacionesModificadas.ToString(),
                     innerRO));
        }
        public ResultadoOperacion modificarGrupo(
            int idGrupo,
            int idSemestre,
            int semestre,
            string letra,
            string turno,
            string especialidad,
            semestres semestreObj,
            carreras especialidadObj
            )
        {
            // Verificamos que los datos introducidos
            // sean válidos para la base de datos.
            if (
                !ValidadorDeTexto.esValido(letra) ||
                !ValidadorDeTexto.esValido(turno) ||
                !ValidadorDeTexto.esValido(especialidad)
                )
            {
                // Devolvemos un error si es que no son válidos.
                return(new ResultadoOperacion(
                           EstadoOperacion.ErrorDatosIncorrectos,
                           "No utilice caracteres especiales o inválidos"));
            }

            ResultadoOperacion innerRO = null;

            int modificado = 0;

            // Si hay algún error durante la ejecución de la operación
            // se devolverá el respectivo resultado de operación.
            try
            {
                CBTis123_Entities db = Vinculo_DB.generarContexto();

                grupos g = db.grupos.Single(g1 => g1.idGrupo == idGrupo);

                g.especialidad = especialidadObj.abreviatura;
                g.idCarrera    = especialidadObj.idCarrera;
                g.idSemestre   = semestreObj.idSemestre;
                g.letra        = letra;
                g.semestre     = semestre;
                g.turno        = turno[0].ToString().ToUpper();

                modificado = 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
                (modificado > 0 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Grupo modificado")
                :
                 new ResultadoOperacion(
                     EstadoOperacion.ErrorAplicacion,
                     "Grupo no modificado",
                     null,
                     innerRO));
        }
Ejemplo n.º 24
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);
        }
        // Modificación
        public ResultadoOperacion modificarSemestre(
            int idSemestre,
            string nombre,
            string nombreCorto,
            string nombreCorto2,
            string nombreCorto3,
            DateTime fechai_p1,
            DateTime fechaf_p1,
            DateTime fechai_p2,
            DateTime fechaf_p2,
            DateTime fechai_p3,
            DateTime fechaf_p3
            )
        {
            // Verificamos que los datos introducidos
            // sean válidos para la base de datos.
            if (
                !ValidadorDeTexto.esValido(nombre) ||
                !ValidadorDeTexto.esValido(nombreCorto) ||
                !ValidadorDeTexto.esValido(nombreCorto2) ||
                !ValidadorDeTexto.esValido(nombreCorto3) ||
                fechaf_p1 < fechai_p1 ||
                fechai_p2 <= fechaf_p1 ||
                fechaf_p2 < fechai_p2 ||
                fechai_p3 <= fechaf_p2 ||
                fechaf_p3 < fechai_p3
                )
            {
                // Devolvemos un error si es que no son válidos.
                return(new ResultadoOperacion(
                           EstadoOperacion.ErrorDatosIncorrectos,
                           "No utilice caracteres especiales o inválidos. Verifique sus fechas."));
            }

            CBTis123_Entities  dbContext = Vinculo_DB.generarContexto();
            ResultadoOperacion innerRO   = null;

            int modificado = 0;

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

                s.nombre       = nombre;
                s.nombrecorto  = nombreCorto;
                s.nombrecorto2 = nombreCorto2;
                s.nombrecorto3 = nombreCorto3;
                s.fechaf_p1    = fechaf_p1;
                s.fechaf_p2    = fechaf_p2;
                s.fechaf_p3    = fechaf_p3;
                s.fechai_p1    = fechai_p1;
                s.fechai_p2    = fechai_p2;
                s.fechai_p3    = fechai_p3;

                modificado = dbContext.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
                (modificado > 0 ?
                 new ResultadoOperacion(
                     EstadoOperacion.Correcto,
                     "Semestre modificado")
                :
                 new ResultadoOperacion(
                     EstadoOperacion.NingunResultado,
                     "Semestre no modificado",
                     null,
                     innerRO));
        }