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));
}
/// <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;
}
}
public void GetAlumnoTest()
{
AlumnoDAO alumnoDAO = new AlumnoDAO();
List <Alumno> alumnoList = alumnoDAO.GetAlumno();
Assert.AreEqual(false, alumnoList.Any());
}
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);
}
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);
}
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();
}
/// <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();
}
/// <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;
}
}
/// <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);
}
}
public bool ModificarAlumno(Alumno alumno)
{
try
{
alumnoDAO = new AlumnoDAO();
return(alumnoDAO.ModificarAlumno(alumno));
}
catch (Exception)
{
return(false);
}
}
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);
}
}
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;
}
/// <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));
}
/// <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;
}
/// <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;
}
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();
}
}
}
/// <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;
}
}
/// <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);
}