示例#1
0
        public void AddAlumnoTestWrongFormat()
        {
            AlumnoDAO alumnoDAO = new AlumnoDAO();
            Alumno    alumno    = new Alumno("BADD990524I55", "1", "*****@*****.**", "5", "David Bárcenas Duran", "Ingeniería de Software", "No Asignado", "Visible");

            Assert.AreEqual(AddResult.SQLFail, alumnoDAO.AddAlumno(alumno));
        }
示例#2
0
        /// <summary>
        /// Llena la tabla con los datos obtenidos a través de la
        /// consulta.
        /// </summary>
        private void cargarDatos()
        {
            dgvLista.DataSource = null;
            List <ResidenciaPOJO> residencias = ResidenciaDAO.ObtenerResidencias();

            if (residencias.Count > 0)
            {
                btnExportar.Enabled = true;
                for (int i = 0; i < residencias.Count; i++)
                {
                    // Crea un objeto de tipo ListaPOJO con los datos correspondientes.
                    ListaPOJO elemento = new ListaPOJO();
                    elemento.Matricula       = residencias[i].IdAlumno;
                    elemento.NombreAlumno    = AlumnoDAO.ObtenerAlumno(residencias[i].IdAlumno).NombreCompleto;
                    elemento.AsesorExt       = residencias[i].AsesorExt;
                    elemento.Empresa         = EmpresaDAO.ObtenerEmpresa(residencias[i].IdEmpresa).Nombre;
                    elemento.TelEmpresa      = EmpresaDAO.ObtenerEmpresa(residencias[i].IdEmpresa).Telefono;
                    elemento.TelAlumno       = AlumnoDAO.ObtenerAlumno(residencias[i].IdAlumno).Telefono;
                    elemento.CorreoAlumno    = AlumnoDAO.ObtenerAlumno(residencias[i].IdAlumno).Correo;
                    elemento.AsesorInt       = DocenteDAO.ObtenerDocenteXMatricula(residencias[i].IdAlumno).NombreCompleto;
                    elemento.CorreoAsesorInt = DocenteDAO.ObtenerDocenteXMatricula(residencias[i].IdAlumno).Correo;
                    elemento.Proyecto        = residencias[i].NombreProyec;
                    lista.Add(elemento);
                }
                dgvLista.DataSource = lista;
            }
        }
示例#3
0
        public void GetAlumnoTest()
        {
            AlumnoDAO     alumnoDAO  = new AlumnoDAO();
            List <Alumno> alumnoList = alumnoDAO.GetAlumno();

            Assert.AreEqual(false, alumnoList.Any());
        }
示例#4
0
        public void AddAlumnoTest()
        {
            AlumnoDAO alumnoDAO = new AlumnoDAO();
            Alumno    alumno    = new Alumno("S17012959", "1", "*****@*****.**", "5", "David Bárcenas Duran", "Ingeniería de Software", "No Asignado", "Visible");

            Assert.AreEqual(AddResult.Success, alumnoDAO.AddAlumno(alumno));
        }
        public List <Alumno> GetAlumno()
        {
            AlumnoDAO     alumnoDAO = new AlumnoDAO();
            List <Alumno> list      = alumnoDAO.GetAlumno();

            return(list);
        }
示例#6
0
        public void AddAlumnoTestEmpty()
        {
            AlumnoDAO alumnoDAO = new AlumnoDAO();
            Alumno    alumno    = new Alumno("", "1", "*****@*****.**", "5", "David Bárcenas Duran", "Ingeniería de Software", "No Asignado", "Visible");

            alumnoDAO.AddAlumno(alumno);
        }
示例#7
0
        public void AddAlumnoTestNull()
        {
            AlumnoDAO alumnoDAO = new AlumnoDAO();
            Alumno    alumno    = new Alumno();

            Assert.AreEqual(AddResult.NullObject, alumnoDAO.AddAlumno(alumno));
        }
        public Alumno obtenerAlumno()
        {
            Alumno    al  = new Alumno();
            AlumnoDAO dao = new AlumnoDAO();

            al = dao.getAlumnoByUsuario(usuario);
            return(al);
        }
        /// <summary>
        /// Revisa si es posible asignar el docente seleccionado al alumno en
        /// cuestion, de ser así se almacena la asignación en la base de datos,
        /// de lo contrario muestra un mensaje sobre el problema.
        /// </summary>
        private void btnAceptar_Click(object sender, EventArgs e)
        {
            if (listaDocentes[cbxAsesor.SelectedIndex].Estatus == "Inactivo")
            {
                MessageBox.Show("El docente seleccionado está actualmente inactivo\npor lo tanto no puede ser su asesor",
                                "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return;
            }

            if (btnAceptar.Text == "Aceptar")
            {
                DialogResult dr = MessageBox.Show("Asignar el asesor:\n" +
                                                  listaDocentes[cbxAsesor.SelectedIndex].NombreCompleto +
                                                  "\nal alumno:\n" +
                                                  AlumnoDAO.ObtenerAlumno(matricula).NombreCompleto, "Info",
                                                  MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                if (dr == DialogResult.No)
                {
                    return;
                }

                DocenteDAO.AsignarAsesorado(matricula, listaDocentes[cbxAsesor.SelectedIndex].ID);
                EntregaDAO.InsertarDocumentosPendientes(matricula);
            }
            else
            {
                DocentePOJO docenteAnterior = DocenteDAO.ObtenerDocenteXMatricula(matricula);
                if (docenteAnterior.ID == listaDocentes[cbxAsesor.SelectedIndex].ID)
                {
                    MessageBox.Show("El docente seleccionado, actualmente es el asesor del alumno:\n" +
                                    AlumnoDAO.ObtenerAlumno(matricula).NombreCompleto +
                                    "\nsi desea cambiar de asesor, pruebe con otro", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                DialogResult dr = MessageBox.Show("Asignar el asesor:\n" +
                                                  listaDocentes[cbxAsesor.SelectedIndex].NombreCompleto +
                                                  "\nal alumno:\n" +
                                                  AlumnoDAO.ObtenerAlumno(matricula).NombreCompleto, "Info",
                                                  MessageBoxButtons.YesNo, MessageBoxIcon.Question);
                if (dr == DialogResult.No)
                {
                    return;
                }

                DocenteDAO.CambiarAsesor(listaDocentes[cbxAsesor.SelectedIndex].ID, matricula, docenteAnterior.ID);
                if (docenteAnterior.ID == DocenteDAO.ObtenerDocenteXMatricula(matricula).ID)
                {
                    MessageBox.Show("El docente seleccionado ya cumple un rol con el alumno:\n" +
                                    AlumnoDAO.ObtenerAlumno(matricula).NombreCompleto + "\npor lo tanto no puede ser su asesor",
                                    "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }
            }
            MessageBox.Show("El docente fue asignado como asesor correctamente", "Info", MessageBoxButtons.OK, MessageBoxIcon.Information);
            this.Close();
        }
示例#10
0
        /// <summary>
        /// Llena los componentes encargados de mostrar los datos del alumno.
        /// </summary>
        private void CargarDatosAlumno()
        {
            var alumno = AlumnoDAO.ObtenerAlumno(Matricula);

            txtNoControl.Text = alumno.Matricula;
            txtNombre.Text    = string.Format("{0} {1}, {2}", alumno.ApellidoP, alumno.ApellidoM, alumno.Nombre);
            txtCarrera.Text   = CarreraDAO.ObtenerUno(alumno.Carrera).Nombre;
            txtSemestre.Text  = alumno.Semestre.ToString();
        }
示例#11
0
        /// <summary>
        /// Llena los componentes encargados de mostrar los datos del alumno.
        /// </summary>
        private void CargarDatosAlumno()
        {
            var alumno = AlumnoDAO.ObtenerAlumno(Matricula);

            txtNoControl.Text = alumno.Matricula;
            txtNombre.Text    = alumno.NombreCompleto;
            txtCarrera.Text   = CarreraDAO.ObtenerUno(alumno.Carrera).Nombre;
            txtSemestre.Text  = alumno.Semestre.ToString();
        }
 public bool RegistrarAlumno(Alumno objAlumno)
 {
     try
     {
         return(AlumnoDAO.getInstance().RegistrarAlumno(objAlumno));
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
 public List <Alumno> listarAlumnos()
 {
     try
     {
         return(AlumnoDAO.getInstance().listarAlumnos());
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
示例#14
0
        /// <summary>
        /// Llena la tabla con las listas previamente cargadas.
        /// </summary>
        public void llenarTablaAlumno()
        {
            tablaCalificaciones.Rows.Clear();
            alumnos    = AlumnoDAO.ObtenerAlumnosConLiberacionAsesor(idDocente);
            dictamenes = DictamenDAO.ObtenerLiberacionesAsesor(idDocente);

            for (int i = 0; i < alumnos.Count; i++)
            {
                tablaCalificaciones.Rows.Add(alumnos[i].Matricula, alumnos[i].NombreCompleto, dictamenes[i].Estatus, dictamenes[i].Calificacion);
            }
        }
示例#15
0
 public bool ModificarAlumno(Alumno alumno)
 {
     try
     {
         alumnoDAO = new AlumnoDAO();
         return(alumnoDAO.ModificarAlumno(alumno));
     }
     catch (Exception)
     {
         return(false);
     }
 }
示例#16
0
 public Alumno ConsultarAlumno(int idAlumno)
 {
     try
     {
         alumnoDAO = new AlumnoDAO();
         return(alumnoDAO.ConsultarAlumno(idAlumno));
     }
     catch (Exception)
     {
         return(null);
     }
 }
        /// <summary>
        /// Llena los componentes encargados de mostrar los datos
        /// necesarios para la liberación final.
        /// </summary>
        /// <param name="res"></param>
        /// Residencias previamente seleccionada.
        /// <param name="idDocente"></param>
        /// Identificador del docente.
        public FrmLiberacionFinalDetalle(ResidenciaPOJO res, String idDocente)
        {
            InitializeComponent();
            resi = res;
            doce = DocenteDAO.ObtenerDocente(idDocente);
            AlumnoPOJO al = AlumnoDAO.ObtenerAlumno(res.IdAlumno);

            txtCarrera.Text   = CarreraDAO.ObtenerUno(al.Carrera).Nombre;
            txtNoControl.Text = al.Matricula;
            txtNombre.Text    = al.NombreCompleto;
            txtSemestre.Text  = al.Semestre + "";
        }
        /// <summary>
        /// Actualiza las tablas después de cada modificación.
        /// </summary>
        public void llenarTablaAlumno()
        {
            tablaAlumnos.Rows.Clear();
            alumnosConAsesor = AlumnoDAO.ObtenerAlumnosConAsesorSinLiberarlo(idDocente);
            DocentePOJO asesor;

            for (int i = 0; i < alumnosConAsesor.Count; i++)
            {
                asesor = DocenteDAO.ObtenerDocenteXMatricula(alumnosConAsesor[i].Matricula);
                tablaAlumnos.Rows.Add(alumnosConAsesor[i].Matricula, alumnosConAsesor[i].NombreCompleto, asesor.NombreCompleto);
            }
        }
示例#19
0
        private void Carga()
        {
            AlumnoDAO DaoAlu = new AlumnoDAO();
            Alumno    Alu    = new Alumno();

            Alu = DaoAlu.obtenerAlumno(idA);
            txtNoControlR.Text      = Alu.idAlumno;
            txtNombreResidente.Text = Alu.NombreCompleto;
            nombre           = Alu.nombre;
            apellidoP        = Alu.apellido1;
            apellidoM        = Alu.apellido2;
            txtCarreraR.Text = Alu.Carrera;
        }
示例#20
0
        /// <summary>
        /// Llena los componentes encargados de mostrar los datos del docente
        /// y del alumno seleccionado.
        /// </summary>
        private void llenarDatos()
        {
            NoControl = lista[indice].NoControl;
            AlumnoPOJO aP = AlumnoDAO.ObtenerAlumno(NoControl);

            lbNoControl.Text = aP.Matricula;
            lbNombre.Text    = aP.NombreCompleto;
            lbCarrera.Text   = aP.Carrera + "";
            lbSemestre.Text  = aP.Semestre + "";
            Asesor asesor = new AsesorDAO().ObtenerAsesor(lista[indice].IdAsesor);

            lbCarreraAS.Text = asesor.Carrera;
            lbNombreAS.Text  = asesor.NombreCompleto;
        }
        public Dominio.Alumno registarAlumno(int cd_padre, string ds_nombre, int cd_grado, string ds_apellido)
        {
            Padre          padreExistente   = PadreDAO.Obtener(cd_padre);
            ObligacionPago obligacionPago   = ObligacionPagoDAO.Obtener(cd_grado);
            Alumno         alumnoAregistrar = new Alumno()
            {
                cd_padre    = "",
                ds_nombre   = ds_nombre,
                ds_apellido = ds_apellido,
                cd_pago     = 1
            };

            return(AlumnoDAO.Crear(alumnoAregistrar));
        }
示例#22
0
        /// <summary>
        /// Llena la tabla con las residencias obtenidos a través
        /// de la consulta a la base de datos.
        /// </summary>
        private void cargarDatos()
        {
            List <ResidenciaPOJO>      residencias            = ResidenciaDAO.ObtenerResidenciaLiberacion();
            List <LiberacionFinalPOJO> liberacionesPendientes = new List <LiberacionFinalPOJO>();

            for (int i = 0; i < residencias.Count; i++)
            {
                AlumnoPOJO  al  = AlumnoDAO.ObtenerAlumno(residencias[i].IdAlumno);
                EmpresaPOJO emp = EmpresaDAO.ObtenerEmpresa(residencias[i].IdEmpresa);
                liberacionesPendientes.Add(new LiberacionFinalPOJO(al.Matricula, al.NombreCompleto,
                                                                   residencias[i].NombreProyec, emp.Nombre, residencias[i].IdEmpresa));
            }

            dgvLista.DataSource = null;
            dgvLista.DataSource = liberacionesPendientes;
        }
示例#23
0
        /// <summary>
        /// Llena la tabla con las solicitudes obtenidas a través
        /// de la consulta a la base de datos.
        /// </summary>
        private void cargarDatos(object sender, FormClosedEventArgs e)
        {
            List <SolicitudPOJO>    solicitudes = SolicitudDAO.ObtenerSolicitudesPendientes();
            List <TablaSolicitudes> listaTabla  = new List <TablaSolicitudes>();

            for (int i = 0; i < solicitudes.Count; i++)
            {
                AlumnoPOJO     objAlum       = AlumnoDAO.ObtenerAlumno(solicitudes[i].IdAlumno);
                ResidenciaPOJO objResidencia = ResidenciaDAO.ObtenerResidencia(solicitudes[i].IdResidencia);
                EmpresaPOJO    objEmpresa    = EmpresaDAO.ObtenerEmpresa(objResidencia.IdEmpresa);
                listaTabla.Add(new TablaSolicitudes(objAlum.Matricula, objAlum.NombreCompleto, objAlum.Semestre, objResidencia.NombreProyec,
                                                    objResidencia.Modalidad, objResidencia.Periodo, objEmpresa.Nombre));
            }
            dgvLista.DataSource = null;
            dgvLista.DataSource = listaTabla;
        }
        /// <summary>
        /// Llena la tabla con los datos obtenidos a través de la
        /// consulta.
        /// </summary>
        private void cargarDatos()
        {
            dgvLista.DataSource = null;
            List <DictamenPOJO> dictamenes = DictamenDAO.ObtenerProyectosTerminados();

            for (int i = 0; i < dictamenes.Count; i++)
            {
                TablaResumenPOJO    elemento  = new TablaResumenPOJO();
                DictamenPOJO        dic       = new DictamenPOJO();
                ResidenciaPOJO      res       = ResidenciaDAO.ObtenerResidencia(dictamenes[i].IdResidencia);
                List <DictamenPOJO> revisores = DictamenDAO.ObtenerDictamenesRevisores(res.ID);

                elemento.DictamenFinal = dictamenes[i].Estatus;
                elemento.Calificacion  = dictamenes[i].Calificacion;

                elemento.Proyecto = res.NombreProyec;
                elemento.Empresa  = EmpresaDAO.ObtenerEmpresa(res.IdEmpresa).Nombre;

                elemento.NombreAlumno = AlumnoDAO.ObtenerAlumno(res.IdAlumno).NombreCompleto;
                elemento.Matricula    = res.IdAlumno;

                dic                       = DictamenDAO.ObtenerDictamenAsesor(res.ID);
                elemento.Asesor           = DocenteDAO.ObtenerDocente(dic.IdDocente).NombreCompleto;
                elemento.DictamenAsesor   = dic.Estatus;
                elemento.ComentarioAsesor = dic.Comentario;

                for (int j = 0; j < revisores.Count; j++)
                {
                    if (j == 0)
                    {
                        elemento.Revisor1           = DocenteDAO.ObtenerDocente(revisores[j].IdDocente).NombreCompleto;
                        elemento.DictamenRevisor1   = revisores[j].Estatus;
                        elemento.ComentarioRevisor1 = revisores[j].Comentario;
                    }
                    else
                    {
                        elemento.Revisor2           = DocenteDAO.ObtenerDocente(revisores[j].IdDocente).NombreCompleto;
                        elemento.DictamenRevisor2   = revisores[j].Estatus;
                        elemento.ComentarioRevisor2 = revisores[j].Comentario;
                    }
                }

                tabla.Add(elemento);
            }
            dgvLista.DataSource = tabla;
        }
示例#25
0
 private void BtnCrear_Click(object sender, EventArgs e)
 {
     if (Comprobar())
     {
         AlumnoDAO DaoAlu = new AlumnoDAO();
         Alumno    Alu    = new Alumno();
         Alu = DaoAlu.Obtener(Txtid.Text);
         if (Alu.idAlumno == null)
         {
             MessageBox.Show("El codigo de control no existe", "Aviso", MessageBoxButtons.OK, MessageBoxIcon.Information);
         }
         else
         {
             this.Visible = false;
             new FrmSRP(x, Txtid.Text, TxtContrasenia.Text).Show();
         }
     }
 }
示例#26
0
        /// <summary>
        /// Revisa si la solicitud será realizada por primera vez o no
        /// para que se actue según corresponda.
        /// </summary>
        /// <param name="matricula">Matricula del alumno en cuestión.</param>
        public FrmSolicitud(string matricula)
        {
            InitializeComponent();
            cmbResCarrera.DataSource    = CarreraDAO.ObtenerTodas();
            cmbResCarrera.DisplayMember = "Nombre";
            cmbResCarrera.ValueMember   = "ID";

            alumno = AlumnoDAO.ObtenerAlumno(matricula);
            var solicitud = SolicitudDAO.ObtenerSolicitud(matricula);

            CargarDatosAlumno(alumno);

            if (solicitud != null)
            {
                CargarDatosSolicitud(solicitud);
                esEdicion = true;
            }
        }
示例#27
0
        /// <summary>
        /// Actualiza las tablas después de cada modificación.
        /// </summary>
        public void ActualizarTablas()
        {
            tablaAsignarAsesor.Rows.Clear();
            tablaModificarAsesor.Rows.Clear();
            // Lista donde se guardaran todos los alumnos sin y con asesor.
            alumnosSinAsesor = AlumnoDAO.ObtenerAlumnosSinAsesorSolicitudAprobada();
            alumnosConAsesor = AlumnoDAO.ObtenerAlumnosConAsesorSinLiberarResidencias();
            DocentePOJO asesor;

            // Ciclo para llenar la tabla.
            for (int i = 0; i < alumnosSinAsesor.Count; i++)
            {
                tablaAsignarAsesor.Rows.Add(alumnosSinAsesor[i].Matricula, alumnosSinAsesor[i].NombreCompleto);
            }
            for (int i = 0; i < alumnosConAsesor.Count; i++)
            {
                asesor = DocenteDAO.ObtenerDocenteXMatricula(alumnosConAsesor[i].Matricula);
                tablaModificarAsesor.Rows.Add(alumnosConAsesor[i].Matricula, alumnosConAsesor[i].NombreCompleto, asesor.NombreCompleto);
            }
        }
        public void llenarDatos()

        {
            Alumno    al  = new Alumno();
            AlumnoDAO dao = new AlumnoDAO();

            al = dao.getAlumnoByUsuario(usuario);
            a  = new Alumno();
            a  = al;
            nombreResidente = a.nombre + " " + a.apellidoPaterno + " " + a.apellidoMaterno;
            noControlR      = a.noControl;
            carreraStr      = a.carrera;
            domicilioStr    = a.domicilio;
            emailStr        = a.email;
            ciudad          = a.ciudad;
            seguro          = a.servicioSalud;
            nSeguro         = a.numeroServicioSalud;
            telefonoStr     = a.telefono;

            this.nombreAlumno.Value = nombreResidente;
            this.noControl.Value    = noControlR;
            this.carrera.Value      = carreraStr;
            this.domicilioAlu.Value = domicilioStr;
            this.email.Value        = emailStr;
            this.ciudadAlu.Value    = ciudad;
            this.noSeguro.Value     = nSeguro;
            this.teleAlu.Value      = telefonoStr;

            if (a.servicioSalud.Equals("IMSS"))
            {
                this.rbImss.Checked = true;
            }
            if (a.servicioSalud.Equals("ISSSTE"))
            {
                this.rbIssste.Checked = true;
            }
            if (a.servicioSalud.Equals("Otros"))
            {
                this.rbOtrosS.Checked = true;
            }
        }
        public ActionResult Registrar(String txtnombre, String txtapellido, String txtespecialidad, String txtprocedencia, String idalumno)
        {
            Boolean rpta      = true;
            Alumno  objalumno = new Alumno();

            objalumno.NomAlumno = txtnombre;
            objalumno.ApeAlumno = txtapellido;
            objalumno.Idesp     = txtespecialidad;
            objalumno.PROCE     = txtprocedencia;
            objalumno.IdAlumno  = idalumno;
            if (idalumno == "")
            {
                rpta = new AlumnoDAO().Registrar(objalumno);
            }
            else
            {
                rpta = new AlumnoDAO().Actualizar(objalumno);
            }

            return(RedirectToAction("Index"));
        }
        public OperationResult AddAlumno(String Matricula, String Nombre, String Seccion, String Bloque, String Carrera, String Contraseña)
        {
            OperationResult operation = OperationResult.UnknowFail;

            if (GetAlumnoByMatricula(Matricula).Matricula == null)
            {
                Alumno alumno = new Alumno();
                alumno.Matricula    = Matricula;
                alumno.NombreAlumno = Nombre;
                alumno.Seccion      = Seccion;
                alumno.Visibilidad  = "Visible";
                alumno.Bloque       = Bloque;
                alumno.Correo       = Matricula + "@estudiantes.uv.mx";
                alumno.Estado       = "No asignado";
                alumno.Carrera      = Carrera;
                AlumnoDAO alumnoDAO = new AlumnoDAO();
                if ((OperationResult)alumnoDAO.AddAlumno(alumno) == OperationResult.Success)
                {
                    if (CreateUserForAlumno(Matricula, Contraseña, Nombre) == OperationResult.Success)
                    {
                        operation = OperationResult.Success;
                    }
                    else
                    {
                        DeleteAlumno(Matricula);
                        operation = OperationResult.UnknowFail;
                    }
                }
                else
                {
                    operation = OperationResult.UnknowFail;
                }
            }
            else
            {
                operation = OperationResult.ExistingRecord;
            }
            return(operation);
        }