protected void Insert(AlumnoCurso curso)
{
try
{
this.OpenConnection();
SqlCommand cmdSave = new SqlCommand(
"INSERT INTO alumnos_cursos (id_curso, id_usuario, condicion, nota)" +
"values(@idcurso, @idusuario, @condicion, @nota)" +
"select @@identity", SqlConn);
cmdSave.Parameters.Add("@idcurso", SqlDbType.Int).Value = curso.IdCurso;
cmdSave.Parameters.Add("@idusuario", SqlDbType.Int).Value = curso.IdUsuario;
cmdSave.Parameters.Add("@condicion", SqlDbType.VarChar, 50).Value = curso.Condicion;
cmdSave.Parameters.Add("@nota", SqlDbType.Int).Value = curso.Nota;
curso.ID = Decimal.ToInt32((decimal)cmdSave.ExecuteScalar());
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al crear curso", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
}
protected void Update(AlumnoCurso curso)
{
try
{
this.OpenConnection();
SqlCommand cmdSave = new SqlCommand(
"Update alumnos_cursos SET id_curso = @idcurso, id_usuario = @idusuario, condicion = @condicion, " +
"nota = @nota " +
"WHERE id_inscripcion=@idinscripcion", SqlConn);
cmdSave.Parameters.Add("@idinscripcion", SqlDbType.Int).Value = curso.IdInscripcion;
cmdSave.Parameters.Add("@idcurso", SqlDbType.Int).Value = curso.IdCurso;
cmdSave.Parameters.Add("@idusuario", SqlDbType.Int).Value = curso.IdUsuario;
cmdSave.Parameters.Add("@condicion", SqlDbType.VarChar, 50).Value = curso.Condicion;
cmdSave.Parameters.Add("@nota", SqlDbType.Int).Value = curso.Nota;
cmdSave.ExecuteNonQuery();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al modificar datos del curso", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
}
public static ResponseModel SaveCurso3(this DbSet <AlumnoCurso> dbset, AlumnoCurso model, int id)
{
var rm = new ResponseModel();
try
{
using (var ctx = new Model1())
{
if (id > 0)
{
//Actualizar
ctx.Entry(model).State = EntityState.Modified;
}
else
{
//Agregar
ctx.Entry(model).State = EntityState.Added;
}
rm.SetResponse(true);
ctx.SaveChanges();
}
}
catch (Exception e)
{
throw;
}
return(rm);
}
public AlumnoCurso GetOneDictado(int idUsuario, int idCurso)
{
AlumnoCurso cur = new AlumnoCurso();
try
{
this.OpenConnection();
SqlCommand cmdCursos = new SqlCommand("select * from alumnos_cursos where id_usuario = @idUsuario and id_curso = @idCurso", SqlConn);
cmdCursos.Parameters.Add("@idUsuario", SqlDbType.Int).Value = idUsuario;
cmdCursos.Parameters.Add("@idCurso", SqlDbType.Int).Value = idCurso;
SqlDataReader drCursos = cmdCursos.ExecuteReader();
if (drCursos.Read())
{
cur.IdInscripcion = (int)drCursos["id_inscripcion"];
cur.IdUsuario = (int)drCursos["id_usuario"];
cur.IdCurso = (int)drCursos["id_curso"];
cur.Condicion = (string)drCursos["condicion"];
cur.Nota = (int)drCursos["nota"];
}
drCursos.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar datos del curso", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(cur);
}
public bool Save(AlumnoCurso cur)
{
try
{
if (cur.State == BusinessEntity.States.Modified)
{
AlumnoCursoData.Save(cur);
return(true);
}
else
{
var curso = AlumnoCursoData.GetOneDictado(cur.IdUsuario, cur.IdCurso);
if (curso.IdCurso == 0)
{
AlumnoCursoData.Save(cur);
return(true);
}
return(false);
}
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error de conexión con la base de datos. Consulte a su proveedor de servicios.", Ex);
throw ExcepcionManejada;
}
}
public ModificarEstadoAlumno(int idInsc, string alumno)
{
InitializeComponent();
AluCur = new AlumnoCursoLogic().GetOne(idInsc);
AluCur.State = BusinessEntity.States.Modified;
this.MapearDatos(alumno);
}
public ActionResult Edit([Bind(Include = "id,Alumno_id,Curso_id,Nota")] AlumnoCurso alumnoCurso)
{
if (ModelState.IsValid)
{
db.Entry(alumnoCurso).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Alumno_id = new SelectList(CombosHelpers.GetAlumnos(), "id", "Nombre", alumnoCurso.Alumno_id);
ViewBag.Curso_id = new SelectList(CombosHelpers.GetCursos(), "id", "Nombre", alumnoCurso.Curso_id);
return(View(alumnoCurso));
}
public void Delete(AlumnoCurso cur, BusinessEntity.States est)
{
try
{
AlumnoCursoData.Delete(cur, est);
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error de conexión con la base de datos. Consulte a su proveedor de servicios.", Ex);
throw ExcepcionManejada;
}
}
public JsonResult GuardarCurso(AlumnoCurso model)
{
var rm = new ResponseModel();
if (ModelState.IsValid)
{
rm = model.Guardar();
if (rm.response)
{
rm.function = "CargarCursos()";
}
}
return(Json(rm));
}
// GET: AlumnoCursoes/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AlumnoCurso alumnoCurso = db.AlumnoCurso.Find(id);
if (alumnoCurso == null)
{
return(HttpNotFound());
}
return(View(alumnoCurso));
}
public JsonResult EliminarAlumnoCurso(AlumnoCurso model)
{
var rm = new ResponseModel();
//if (ModelState.IsValid)
//{
rm = model.Eliminar();
if (rm.response)
{
rm.function = "CargarCursos();";
}
//}
return(Json(rm, JsonRequestBehavior.AllowGet));
}
public bool Guardar(EntidadAlumnoCurso dat)
{
//instancia de tabla, tabla que contiene el modelo
AlumnoCurso tablaAlumnoCurso = new AlumnoCurso();
//VERIFICACION, comparacion de los registros que vinen de la capa presentancion
tablaAlumnoCurso.Id_Alumno = dat.Id_Alumno;
tablaAlumnoCurso.id_Curso = dat.id_Curso;
tablaAlumnoCurso.Observaciones = dat.Observaciones;
tablaAlumnoCurso.Profesor = dat.Profesor;
tablaAlumnoCurso.Fecha = dat.Fecha;
//retorna un valor de tipo AlumnoCurso, contenida por tablaAlumno
return(metodos.Guardar(tablaAlumnoCurso));
}
public JsonResult GuardarCurso(AlumnoCurso model)
{
var rm = new ResponseModel();
if (ModelState.IsValid)
{
rm = model.Guardar();
if (rm.response)
{
rm.function = "CargarCursos()"; //esto invoca las funciones js que tengamos del lado de la vista
}
}
return(Json(rm));
}
private void SaveAlumnoCursoEntity(AlumnoCurso alumnoCursoActual)
{
bool codigo = this.AlumnoCurso.Save(alumnoCursoActual);
if (codigo)
{
//Response.Write("\n\nAlumno inscripto con éxito!");
this.limpiarVariables();
Response.Redirect("Home.aspx");
}
else
{
Response.Write("\n\nEl alumno ya está inscripto en este curso.");
}
}
public JsonResult GuardarCurso(AlumnoCurso curso)
{
var rm = new ResponseModel();
if (ModelState.IsValid)
{
int id = curso.id;
rm = ctx.AlumnoCurso.SaveCurso3(curso, id);
if (rm.response)
{
rm.function = "CargarCursos()";
}
}
return(Json(rm));
}
// GET: AlumnoCursoes/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AlumnoCurso alumnoCurso = db.AlumnoCurso.Find(id);
if (alumnoCurso == null)
{
return(HttpNotFound());
}
ViewBag.Alumno_id = new SelectList(CombosHelpers.GetAlumnos(), "id", "Nombre", alumnoCurso.Alumno_id);
ViewBag.Curso_id = new SelectList(CombosHelpers.GetCursos(), "id", "Nombre", alumnoCurso.Curso_id);
return(View(alumnoCurso));
}
// GET: AlumnoCursoes/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
AlumnoCurso alumnoCurso = db.AlumnoCurso.Find(id);
if (alumnoCurso == null)
{
return(HttpNotFound());
}
db.AlumnoCurso.Remove(alumnoCurso);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public JsonResult GuardarCurso(AlumnoCurso model)
{
var rm = new ResponseModel();
if (ModelState.IsValid)
{
rm = model.Guardar();
if (rm.response)
{
rm.function = "CargarCursos()";
}
}
return(Json(rm)); //Usando la clase JSON , serializa lo que le pasemos en automatico
}
////////////////////////// Inscripcion Alumno //////////////////////////
private void LoadAlumnoCursoEntity(AlumnoCurso alumnoCursoActual)
{
this.EntityCurso = this.Curso.BuscarCursoPorMateriaComision(SelectedIdMateria, SelectedIdComision); //Obtenemos el objeto curso para usar el id
alumnoCursoActual.IdCurso = this.EntityCurso.IdCurso;
alumnoCursoActual.Nota = 0;
alumnoCursoActual.Condicion = "Inscripto";
if (Session["tipoUsu"].ToString() == "1")
{
alumnoCursoActual.IdUsuario = this.SelectedIdUsuario;
}
else
{
alumnoCursoActual.IdUsuario = Convert.ToInt32(Session["idUsuario"]);
}
}
public void Save(AlumnoCurso curso)
{
if ((curso.State == BusinessEntity.States.Deleted) || (curso.State == BusinessEntity.States.Undeleted))
{
this.Delete(curso, curso.State);
}
else if (curso.State == BusinessEntity.States.New)
{
this.Insert(curso);
}
else if (curso.State == BusinessEntity.States.Modified)
{
this.Update(curso);
}
else
{
curso.State = BusinessEntity.States.Unmodified;
}
}
public JsonResult GuardarCursos(AlumnoCurso model)
{
var rm = new ResponseModel();
if (ModelState.IsValid)
{
rm = model.GuardarCurso();
if (rm.response)
{
rm.function = "CargarCursos()";
}
}
else
{
rm.SetResponse(false, "Debe llenar el campo nota");
}
return(Json(rm));
}
public static void EliminarAlumnoCurso2(this DbSet <AlumnoCurso> dbset, int id)
{
try
{
using (var ctx = new Model1())
{
AlumnoCurso alumnocurso = new AlumnoCurso();
alumnocurso = ctx.AlumnoCurso.Where(x => x.id == id).FirstOrDefault();
if (alumnocurso != null)
{
ctx.Entry(alumnocurso).State = EntityState.Deleted;
ctx.SaveChanges();
}
}
}
catch (Exception e)
{
throw;
}
}
public void Delete(AlumnoCurso curso, BusinessEntity.States estado)
{
try
{
this.OpenConnection();
SqlCommand cmdSave = new SqlCommand(
"DELETE from alumnos_cursos WHERE id_inscripcion = @idinscripcion", SqlConn);
cmdSave.Parameters.Add("@idinscripcion", SqlDbType.Int).Value = curso.IdInscripcion;
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al eliminar curso", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
}
public List <AlumnoCurso> GetAll()
{
List <AlumnoCurso> cursos = new List <AlumnoCurso>();
try
{
this.OpenConnection();
SqlCommand cmdCursos = new SqlCommand("select * from alumnos_cursos", SqlConn);
SqlDataReader drCursos = cmdCursos.ExecuteReader();
while (drCursos.Read())
{
AlumnoCurso cur = new AlumnoCurso();
cur.IdInscripcion = (int)drCursos["id_inscripcion"];
cur.IdUsuario = (int)drCursos["id_usuario"];
cur.IdCurso = (int)drCursos["id_curso"];
cur.Condicion = (string)drCursos["Condicion"];
cur.Nota = (int)drCursos["Nota"];
cursos.Add(cur);
}
drCursos.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar lista de cursos", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(cursos);
}
public ActionResult Create([Bind(Include = "id,Alumno_id,Curso_id,Nota")] AlumnoCurso alumnoCurso)
{
if (ModelState.IsValid)
{
db.AlumnoCurso.Add(alumnoCurso);
try
{
db.SaveChanges();
}
catch (Exception ex)
{
ex.ToString();
ModelState.AddModelError(string.Empty, "Error");
}
return(RedirectToAction("Index"));
}
ViewBag.Alumno_id = new SelectList(CombosHelpers.GetAlumnos(), "id", "Nombre", alumnoCurso.Alumno_id);
ViewBag.Curso_id = new SelectList(CombosHelpers.GetCursos(), "id", "Nombre", alumnoCurso.Curso_id);
return(View(alumnoCurso));
}
public static ResponseModel EliminarAlumnoCurso(this DbSet <AlumnoCurso> dbset, int id)
{
var rm = new ResponseModel();
try
{
using (var ctx = new Model1())
{
AlumnoCurso alumnocurso = new AlumnoCurso();
alumnocurso = ctx.AlumnoCurso.Where(x => x.id == id).FirstOrDefault();
if (alumnocurso != null)
{
ctx.Entry(alumnocurso).State = EntityState.Deleted;
rm.SetResponse(true);
ctx.SaveChanges();
}
}
return(rm);
}
catch (Exception e)
{
throw;
}
}
private void btnAgregarAlumno_Click(object sender, EventArgs e)
{
alumnoId = Convert.ToInt32(cmbAlumnos.SelectedValue);
cursoId = Convert.ToInt32(cmbCursos.SelectedValue);
using ApplicationDbContext db = new ApplicationDbContext();
var alumnoOk = db.AlumnoCursos.Where(x => x.AlumnoId == alumnoId && x.CursoId == cursoId).FirstOrDefault();
int estadoCursoId = db.Cursos.Where(x => x.Id == cursoId).Select(x => x.EstadoCursoId).FirstOrDefault();
if (alumnoOk == null)
{
AlumnoCurso alumnoCurso = new AlumnoCurso()
{
AlumnoId = alumnoId,
CursoId = cursoId
};
db.AlumnoCursos.Add(alumnoCurso);
db.SaveChanges();
LoadAlumnosxCurso();
}
}
//Retorno de vista parcial
public ActionResult Cursos(AlumnoCurso alumnoCurso)
{
//Listamos los cursos de un alumno
ViewBag.CursosElegidos = alumnoCurso.Listar(alumnoCurso.Alumno_id);
//Listamos todos los cursos DISPONIBLES
ViewBag.Cursos = curso.Todos(alumnoCurso);
if (Request.IsAjaxRequest())
{
var rm = new ResponseModel();
rm.SetResponse(true);
rm.message = RenderPartialViewToString("Cursos", alumnoCurso);
//Retorna la vista parcial en application/json
return(Json(rm));
}
else
{
//Retorna la vista parcial en text/html
return(PartialView(alumnoCurso));
}
}
private void btnInscribirme_Click(object sender, EventArgs e)
{
if (this.dgvCursosInscrip.SelectedRows.Count > 0)
{
int sri = dgvCursosInscrip.SelectedCells[0].RowIndex;
DataGridViewRow sr = dgvCursosInscrip.Rows[sri];
int idCur = Convert.ToInt32(sr.Cells["ID"].Value.ToString());
int idCom = Convert.ToInt32(sr.Cells["IdComision"].Value.ToString());
string nomCom;
try
{
Comision com = new ComisionLogic().GetOne(idCom);
nomCom = com.Descripcion;
}
catch
{
nomCom = "¿?";
}
string msj = "¿Está seguro que desea inscribirse a " + Mate.Descripcion + " en la comisión " + nomCom + "?";
DialogResult resultado = MessageBox.Show(msj, "Atención", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (resultado == DialogResult.Yes)
{
CursoLogic cur = new CursoLogic();
int cupo = cur.GetOne(idCur).Cupo;
bool hayCupo = true;
if (Usu.IdTipoUsuario == 2)
{
AlumnoCurso alCur = new AlumnoCurso();
alCur.IdCurso = idCur;
alCur.IdUsuario = Usu.ID;
alCur.Condicion = "inscripto";
AlumnoCursoLogic acl = new AlumnoCursoLogic();
if (acl.getCantAlumnos(idCur) < cupo)
{
acl.Save(alCur);
}
else
{
hayCupo = false;
}
}
else if (Usu.IdTipoUsuario == 3)
{
DocenteCurso doCur = new DocenteCurso();
doCur.IdCurso = idCur;
doCur.IdUsuario = Usu.ID;
doCur.Cargos = 1;
DocenteCursoLogic dcl = new DocenteCursoLogic();
dcl.Save(doCur);
}
if (!hayCupo)
{
MessageBox.Show("El cupo está lleno, intente en otra comisión", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
MessageBox.Show("Inscripción realizada con éxito", "Ok", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Close();
}
this.Listar();
}
}
}
