public Business.Entities.Usuario GetOne(int ID)
{
Usuario usr = new Usuario();
try
{
this.OpenConnection();
SqlCommand cmdUsuarios = new SqlCommand("select * from usuarios where id_usuario=@id", sqlConn);
cmdUsuarios.Parameters.Add("@id", SqlDbType.Int).Value = ID;
SqlDataReader drUsuarios = cmdUsuarios.ExecuteReader();
if (drUsuarios.Read())
{
usr.ID = (int)drUsuarios["id_usuario"];
usr.NombreUsuario = (string)drUsuarios["nombre_usuario"];
usr.Clave = (string)drUsuarios["clave"];
usr.Habilitado = (bool)drUsuarios["habilitado"];
usr.Persona = new Persona();
usr.Persona.ID = (int)drUsuarios["id_persona"];
}
drUsuarios.Close();
PersonaAdapter PersonaData = new PersonaAdapter();
usr.Persona = PersonaData.GetOne(usr.Persona.ID);
}
catch (Exception Ex)
{
Exception ExcepcionManejada =
new Exception("Error al recuperar usuario", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(usr);
}
public List <Curso> GetInscribibleAlumno(int alumnoid)
{
List <Curso> cursos = new List <Curso>();
try
{
this.OpenConnection();
SqlCommand cmdUsuarios = new SqlCommand("select * from cursos, materias where " +
"cursos.id_materia = materias.id_materia AND materias.id_plan = @idpl and cursos.deleted is null and cupo>0", sqlConn);
PersonaAdapter pa = new PersonaAdapter();
cmdUsuarios.Parameters.Add("@idpl", SqlDbType.Int).Value = pa.GetOne(alumnoid).IDPlan;
SqlDataReader drCursos = cmdUsuarios.ExecuteReader();
while (drCursos.Read())
{
Curso csr = new Curso();
csr.ID = (int)drCursos["id_curso"];
csr.AnioCalendario = (int)drCursos["anio_calendario"];
csr.Cupo = (int)drCursos["cupo"];
csr.Descripcion = (string)drCursos["descripcion"];
csr.IDComision = (int)drCursos["id_comision"];
csr.IDMateria = (int)drCursos["id_materia"];
cursos.Add(csr);
}
drCursos.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar lista de cursos", Ex);
throw ExcepcionManejada;
}
this.CloseConnection();
return(cursos);
}
public List <Docente_Curso> GetAll()
{
List <Docente_Curso> listado = new List <Docente_Curso>();
try
{
this.OpenConnection();
SqlCommand consulta = new SqlCommand("SELECT id_docente, id_curso,cargo,id_dictado FROM docentes_cursos", SqlConn);
SqlDataReader dr = consulta.ExecuteReader();
while (dr.Read())
{
Docente_Curso docCurso = new Docente_Curso();
PersonaAdapter perAda = new PersonaAdapter();
CursoAdapter curAda = new CursoAdapter();
docCurso.ID = Convert.ToInt32(dr["id_dictado"]);
docCurso.Docente = dr.IsDBNull(0) ? null : perAda.GetOne(Convert.ToInt32(dr[0]));
docCurso.Curso = dr.IsDBNull(1) ? null : curAda.GetOne(Convert.ToInt32(dr[1]));
docCurso.Cargo = (Docente_Curso.TipoCargo)dr["cargo"];
listado.Add(docCurso);
}
}
catch (Exception e)
{
Exception ExcepcionManejada = new Exception("Error al tratar de abrir la conexion", e);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(listado);
}
public Docente_Curso GetOne(int idDictado)
{
try
{
this.OpenConnection();
SqlCommand consulta = new SqlCommand("SELECT id_docente,id_curso,cargo,id_dictado FROM docentes_cursos WHERE id_dictado=@id_dictado", SqlConn);
consulta.Parameters.AddWithValue("@id_dictado", idDictado);
SqlDataReader dr = consulta.ExecuteReader();
Docente_Curso docCurso = new Docente_Curso();
if (dr.Read())
{
PersonaAdapter perAda = new PersonaAdapter();
CursoAdapter curAda = new CursoAdapter();
docCurso.ID = Convert.ToInt32(dr["id_dictado"]);
docCurso.Docente = dr.IsDBNull(0) ? null : perAda.GetOne(Convert.ToInt32(dr[0]));
docCurso.Curso = dr.IsDBNull(1) ? null : curAda.GetOne(Convert.ToInt32(dr[1]));
docCurso.Cargo = (Docente_Curso.TipoCargo)dr["cargo"];
}
return(docCurso);
}
catch (Exception e)
{
Exception ExcepcionManejada = new Exception("Error al tratar de abrir la conexion", e);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
}
/*
public int GetId(string nombre, string apellido)
{
PersonaAdapter PersonaData = new PersonaAdapter();
try
{
return PersonaData.GetId(nombre, apellido);
}
finally
{
PersonaData = null;
}
}
*/
public void Delete(int ID)
{
try
{
PersonaData.Delete(ID);
}
finally
{
PersonaData = null;
}
}
public bool ExisteLegajo(int legajo)
{
PersonaAdapter PersonaData = new PersonaAdapter();
try
{
return PersonaData.ExisteLegajo(legajo);
}
finally
{
PersonaData = null;
}
}
public List <AlumnoInscripcion> GetInscripcionesDelCurso(Curso cur)
{
List <AlumnoInscripcion> cursoInscripciones = new List <AlumnoInscripcion>();
PersonaAdapter PersonaData = new PersonaAdapter();
try
{
this.OpenConnection();
SqlCommand cmd = new SqlCommand("SELECT * FROM alumnos_inscripciones WHERE id_curso=@curso", SqlConn);
cmd.Parameters.Add("@curso", System.Data.SqlDbType.Int).Value = cur.ID;
SqlDataReader dr = cmd.ExecuteReader();
while (dr != null && dr.Read())
{
AlumnoInscripcion alumnoInscripcion = new AlumnoInscripcion();
alumnoInscripcion.ID = (int)dr["id_inscripcion"];
alumnoInscripcion.Condicion = (AlumnoInscripcion.Condiciones)dr["condicion"];
try
{
int nota = (int)dr["nota"];
alumnoInscripcion.Nota = nota;
}
catch (Exception) { }
alumnoInscripcion.Alumno = PersonaData.GetOne((int)dr["id_alumno"]);
alumnoInscripcion.LegajoAlumno = alumnoInscripcion.Alumno.Legajo;
alumnoInscripcion.NombreAlumno = alumnoInscripcion.Alumno.Nombre;
alumnoInscripcion.ApellidoAlumno = alumnoInscripcion.Alumno.Apellido;
cursoInscripciones.Add(alumnoInscripcion);
}
if (dr != null)
{
dr.Close();
}
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar lista de inscripciones", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(cursoInscripciones);
}
protected void Update(Usuario usuario, Persona persona)
{
PersonaAdapter personaData = new PersonaAdapter();
try
{
OpenConnection();
SqlTransaction transaction = SqlConn.BeginTransaction();
SqlCommand cmdUpdate;
try
{
cmdUpdate = new SqlCommand(
"UPDATE personas SET nombre=@nombre, apellido=@apellido, direccion=@direccion, email=@email, " +
"telefono=@telefono, fecha_nac=@fecha_nac, legajo=@legajo, tipo_persona=@tipo_persona, id_plan=@id_plan " +
"WHERE id_persona=@id",
SqlConn, transaction);
cmdUpdate.Parameters.Add("@id", SqlDbType.Int).Value = persona.ID;
personaData.CargarParametrosSql(cmdUpdate, persona);
cmdUpdate.ExecuteNonQuery();
cmdUpdate = new SqlCommand(
"UPDATE usuarios SET nombre_usuario=@nombre_usuario, clave=@clave, habilitado=@habilitado, " +
"nombre=@nombre, apellido=@apellido, email=@email, id_persona=@id_persona " +
"WHERE id_usuario=@id",
SqlConn, transaction);
cmdUpdate.Parameters.Add("@id", SqlDbType.Int).Value = usuario.ID;
CargarParametrosSql(cmdUpdate, usuario);
cmdUpdate.ExecuteNonQuery();
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
Exception ExcepcionManejada = new Exception("Error al actualizar usuario y persona", ex);
throw ExcepcionManejada;
}
}
catch (Exception)
{
throw;
}
finally
{
CloseConnection();
}
}
public List <DocenteCurso> GetAll(Curso cur)
{
//Devuelve todas las instancias de DocenteCurso dado un curso
List <DocenteCurso> docentesCurso = new List <DocenteCurso>();
try
{
OpenConnection();
SqlCommand cmdSELECT = new SqlCommand("select * from docentes_cursos where id_curso=@id", sqlConn);
cmdSELECT.Parameters.Add("@id", SqlDbType.Int).Value = cur.ID;
SqlDataReader reader = cmdSELECT.ExecuteReader();
while (reader.Read())
{
DocenteCurso dc = new DocenteCurso();
dc.ID = (int)reader["id_dictado"];
switch (reader["cargo"])
{
case (0):
dc.Cargo = DocenteCurso.TipoCargos.Profesor;
break;
case (1):
dc.Cargo = DocenteCurso.TipoCargos.Auxiliar;
break;
}
dc.Docente = new Persona();
dc.Docente.ID = (int)reader["id_docente"];
docentesCurso.Add(dc);
}
reader.Close();
foreach (DocenteCurso dc in docentesCurso)
{
PersonaAdapter pl = new PersonaAdapter();
dc.Docente = pl.GetOne(dc.Docente.ID);
}
}
catch
{
throw new Exception("Error al recuperar docentes");
}
finally
{
CloseConnection();
}
return(docentesCurso);
}
protected void Insert(Usuario usuario, Persona persona)
{
PersonaAdapter personaData = new PersonaAdapter();
try
{
OpenConnection();
SqlTransaction transaction = SqlConn.BeginTransaction();
SqlCommand cmdInsert;
try
{
cmdInsert = new SqlCommand(
"INSERT INTO personas(nombre, apellido, direccion, email, telefono, fecha_nac, legajo, tipo_persona, id_plan)" +
"VALUES (@nombre, @apellido, @direccion, @email, @telefono, @fecha_nac, @legajo, @tipo_persona, @id_plan)" +
"SELECT @@identity",
SqlConn, transaction);
personaData.CargarParametrosSql(cmdInsert, persona);
persona.ID = decimal.ToInt32((decimal)cmdInsert.ExecuteScalar());
usuario.IdPersona = persona.ID;
cmdInsert = new SqlCommand(
"INSERT INTO usuarios(nombre_usuario, clave, habilitado, nombre, apellido, email, id_persona)" +
"VALUES (@nombre_usuario, @clave, @habilitado, @nombre, @apellido, @email, @id_persona)" +
"SELECT @@identity",
SqlConn, transaction);
CargarParametrosSql(cmdInsert, usuario);
usuario.ID = decimal.ToInt32((decimal)cmdInsert.ExecuteScalar());
transaction.Commit();
}
catch (Exception ex)
{
transaction.Rollback();
Exception ExcepcionManejada = new Exception("Error al insertar usuario y persona", ex);
throw ExcepcionManejada;
}
}
catch (Exception)
{
throw;
}
finally
{
CloseConnection();
}
}
public Usuario BuscarPorUsuarioYContrasenia(Usuario user)
{
try
{
this.OpenConnection();
SqlCommand cmd = new SqlCommand("SELECT * FROM usuarios WHERE nombre_usuario=@nombre_usuario COLLATE SQL_Latin1_General_CP1_CS_AS " +
"and clave=@clave COLLATE SQL_Latin1_General_CP1_CS_AS", SqlConn);
cmd.Parameters.Add("@nombre_usuario", System.Data.SqlDbType.VarChar).Value = user.NombreUsuario;
cmd.Parameters.Add("@clave", System.Data.SqlDbType.VarChar).Value = user.Clave;
SqlDataReader dr = cmd.ExecuteReader();
if (dr != null && dr.Read())
{
PersonaAdapter PersonaData = new PersonaAdapter();
user.ID = (int)dr["id_usuario"];
user.NombreUsuario = (string)dr["nombre_usuario"];
user.Clave = (string)dr["clave"];
user.Habilitado = (bool)dr["habilitado"];
user.CambiaClave = (bool)dr["cambia_clave"];
user.Persona = PersonaData.GetOne((int)dr["id_persona"]);
}
else
{
user = null;
}
if (dr != null)
{
dr.Close();
}
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar datos del usuario", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(user);
}
public List <AlumnoInscripcion> GetInscripcionesCurso(int IDCurso)
{
List <AlumnoInscripcion> inscripcionesCursos = new List <AlumnoInscripcion>();
try
{
this.OpenConnection();
SqlCommand cmdDatosCurso = new SqlCommand("SELECT id_inscripcion,id_alumno,id_curso,condicion,nota FROM alumnos_inscripciones WHERE id_curso = @id_curso", SqlConn);
cmdDatosCurso.Parameters.Add("@id_curso", SqlDbType.Int).Value = IDCurso;
SqlDataReader drDatosCurso = cmdDatosCurso.ExecuteReader();
while (drDatosCurso.Read())
{
AlumnoInscripcion aluCurso = new AlumnoInscripcion();
Persona per = new Persona();
Curso cur = new Curso();
PersonaAdapter perAda = new PersonaAdapter();
CursoAdapter curAda = new CursoAdapter();
per = perAda.GetOne(Convert.ToInt32(drDatosCurso["id_alumno"]));
cur = curAda.GetOne(Convert.ToInt32(drDatosCurso["id_curso"]));
aluCurso.ID = (int)drDatosCurso["id_inscripcion"];
aluCurso.Alumno = drDatosCurso.IsDBNull(1) ? null : per;
aluCurso.Curso = drDatosCurso.IsDBNull(2) ? null : cur;
//aluCurso.Condicion = (string)drDatosCurso["condicion"];
aluCurso.Nota = (int)drDatosCurso["nota"];
inscripcionesCursos.Add(aluCurso);
}
drDatosCurso.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar datos de inscripciones curso", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(inscripcionesCursos);
}
public Usuario BuscarPorLegajo(int legajo)
{
Usuario user = null;
try
{
this.OpenConnection();
SqlCommand cmd = new SqlCommand("SELECT * FROM usuarios u INNER JOIN personas p " +
"ON u.id_persona=p.id_persona WHERE legajo=@legajo", SqlConn);
cmd.Parameters.Add("@legajo", System.Data.SqlDbType.Int).Value = legajo;
SqlDataReader dr = cmd.ExecuteReader();
if (dr != null && dr.Read())
{
user = new Usuario();
PersonaAdapter PersonaData = new PersonaAdapter();
user.ID = (int)dr["id_usuario"];
user.NombreUsuario = (string)dr["nombre_usuario"];
user.Clave = (string)dr["clave"];
user.Habilitado = (bool)dr["habilitado"];
user.CambiaClave = (bool)dr["cambia_clave"];
user.Persona = PersonaData.GetOne((int)dr["id_persona"]);
}
if (dr != null)
{
dr.Close();
}
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar datos del usuario", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(user);
}
public List <AlumnoInscripcion> GetAll()
{
List <AlumnoInscripcion> alumnos = new List <AlumnoInscripcion>();
try
{
this.OpenConnection();
SqlCommand cmdAlumnoInscripciones = new SqlCommand("SELECT id_inscripcion,id_alumno,id_curso,condicion,nota FROM alumnos_inscripciones", SqlConn);
SqlDataReader drAlumnoInscripciones = cmdAlumnoInscripciones.ExecuteReader();
while (drAlumnoInscripciones.Read())
{
AlumnoInscripcion aluIns = new AlumnoInscripcion();
Persona per = new Persona();
Curso cur = new Curso();
PersonaAdapter perAda = new PersonaAdapter();
CursoAdapter curAda = new CursoAdapter();
per = perAda.GetOne(Convert.ToInt32(drAlumnoInscripciones["id_alumno"]));
cur = curAda.GetOne(Convert.ToInt32(drAlumnoInscripciones["id_curso"]));
aluIns.ID = (int)drAlumnoInscripciones["id_inscripcion"];
aluIns.Alumno = drAlumnoInscripciones.IsDBNull(1) ? null : per;
aluIns.Curso = drAlumnoInscripciones.IsDBNull(2) ? null : cur;
//aluIns.Condicion = (string)drAlumnoInscripciones["condicion"];
aluIns.Nota = (int)drAlumnoInscripciones["nota"];
alumnos.Add(aluIns);
}
drAlumnoInscripciones.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar lista de alumnos inscriptos", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(alumnos);
}
public List <Usuario> GetAll()
{
List <Usuario> usuarios = new List <Usuario>();
try
{
this.OpenConnection();
SqlCommand cmdUsuarios = new SqlCommand("SELECT * FROM usuarios", sqlConn);
SqlDataReader drUsuarios = cmdUsuarios.ExecuteReader();
while (drUsuarios.Read())
{
Usuario usr = new Usuario();
usr.ID = (int)drUsuarios["id_usuario"];
usr.NombreUsuario = (string)drUsuarios["nombre_usuario"];
usr.Clave = (string)drUsuarios["clave"];
usr.Habilitado = (bool)drUsuarios["habilitado"];
usr.Nombre = (string)drUsuarios["nombre"];
usr.Apellido = (string)drUsuarios["apellido"];
usr.EMail = (string)drUsuarios["email"];
Personas persona = new PersonaAdapter().GetOne((int)drUsuarios["id_persona"]);
usr.Per = persona;
usuarios.Add(usr);
}
drUsuarios.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada =
new Exception("Error al recuperar lista de usuarios", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(usuarios);
}
public Usuario GetOneByUsuario(string nombreUsr)
{
Usuario usr = null;
try
{
this.OpenConnection();
SqlCommand cmdUsuario = new SqlCommand("SELECT * FROM usuarios WHERE nombre_usuario=@usuario", sqlConn);
cmdUsuario.Parameters.Add("@usuario", SqlDbType.VarChar, 50).Value = nombreUsr;
SqlDataReader drUsuarios = cmdUsuario.ExecuteReader();
if (drUsuarios.Read())
{
usr = new Usuario();
usr.ID = (int)drUsuarios["id_usuario"];
usr.NombreUsuario = (string)drUsuarios["nombre_usuario"];
usr.Clave = (string)drUsuarios["clave"];
usr.Habilitado = (bool)drUsuarios["habilitado"];
usr.Nombre = (string)drUsuarios["nombre"];
usr.Apellido = (string)drUsuarios["apellido"];
usr.EMail = (string)drUsuarios["email"];
Personas persona = new PersonaAdapter().GetOne((int)drUsuarios["id_persona"]);
usr.Per = persona;
}
drUsuarios.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada =
new Exception("Error al recuperar datos de usuario", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(usr);
}
public List <Usuario> GetAll()
{
PersonaAdapter PersonaData = new PersonaAdapter();
List <Usuario> usuarios = new List <Usuario>();
try
{
this.OpenConnection();
SqlCommand cmd = new SqlCommand("SELECT * FROM usuarios", SqlConn);
SqlDataReader dr = cmd.ExecuteReader();
while (dr != null && dr.Read())
{
Usuario user = new Usuario();
user.ID = (int)dr["id_usuario"];
user.NombreUsuario = (string)dr["nombre_usuario"];
user.Clave = (string)dr["clave"];
user.Habilitado = (bool)dr["habilitado"];
user.CambiaClave = (bool)dr["cambia_clave"];
user.Persona = PersonaData.GetOne((int)dr["id_persona"]);
usuarios.Add(user);
}
if (dr != null)
{
dr.Close();
}
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar lista de usuarios", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(usuarios);
}
public List <Usuario> GetAll()
{
List <Usuario> usuarios = new List <Usuario>();
try
{
this.OpenConnection();
SqlCommand cmdUsuarios = new SqlCommand("SELECT id_usuario,nombre_usuario,clave,habilitado,email,id_persona FROM usuarios", SqlConn);
SqlDataReader drUsuarios = cmdUsuarios.ExecuteReader();
while (drUsuarios.Read())
{
Usuario usr = new Usuario();
Entidades.Persona persona = new Entidades.Persona();
PersonaAdapter perAda = new PersonaAdapter();
persona = perAda.GetOne(Convert.ToInt32(drUsuarios["id_persona"].ToString()));
usr.ID = (int)drUsuarios["id_usuario"];
usr.NombreUsuario = (string)drUsuarios["nombre_usuario"];
usr.Clave = (string)drUsuarios["clave"];
usr.Habilitado = (bool)drUsuarios["habilitado"];
//usr.Nombre = (string)drUsuarios["nombre"];
//usr.Apellido = (string)drUsuarios["apellido"];
usr.Email = (string)drUsuarios["email"];
usr.Persona = drUsuarios.IsDBNull(5) ? null : persona;
usuarios.Add(usr);
}
drUsuarios.Close();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al recuperar lista de usuarios", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(usuarios);
}
public Business.Entities.Usuario GetOne(string usuario, string clave)
{
Usuario usr = new Usuario();
try
{
this.OpenConnection();
SqlCommand cmdUsuarios = new SqlCommand("select id_usuario, id_persona, nombre_usuario, clave " +
"from usuarios where nombre_usuario=@nombre_usuario and clave=@clave and habilitado=1", sqlConn);
cmdUsuarios.Parameters.Add("@nombre_usuario", SqlDbType.VarChar, 50).Value = usuario;
cmdUsuarios.Parameters.Add("@clave", SqlDbType.VarChar, 50).Value = clave;
SqlDataReader drUsuarios = cmdUsuarios.ExecuteReader();
if (drUsuarios.Read())
{
usr.ID = (int)drUsuarios["id_usuario"];
usr.NombreUsuario = (string)drUsuarios["nombre_usuario"];
usr.Clave = (string)drUsuarios["clave"];
usr.Persona = new Persona();
usr.Persona.ID = (int)drUsuarios["id_persona"];
}
else
{
return(new Usuario());
}
drUsuarios.Close();
PersonaAdapter PersonaData = new PersonaAdapter();
usr.Persona = PersonaData.GetOne(usr.Persona.ID);
}
catch (Exception Ex)
{
Exception ExcepcionManejada =
new Exception("Error al recuperar usuario", Ex);
throw ExcepcionManejada;
}
finally
{
this.CloseConnection();
}
return(usr);
}
public List <Usuario> GetAll()
{
List <Usuario> usuarios = new List <Usuario>();
try
{
this.OpenConnection();
SqlCommand cmdUsuarios = new SqlCommand("select * from usuarios", sqlConn);
SqlDataReader drUsuarios = cmdUsuarios.ExecuteReader();
while (drUsuarios.Read())
{
Usuario usr = new Usuario();
usr.ID = (int)drUsuarios["id_usuario"];
usr.NombreUsuario = (string)drUsuarios["nombre_usuario"];
usr.Clave = (string)drUsuarios["clave"];
usr.Habilitado = (bool)drUsuarios["habilitado"];
usr.Persona = new Persona();
usr.Persona.ID = (int)drUsuarios["id_persona"];
usuarios.Add(usr);
}
drUsuarios.Close();
PersonaAdapter PersonaData = new PersonaAdapter();
foreach (Usuario usr in usuarios)
{
usr.Persona = PersonaData.GetOne(usr.Persona.ID);
}
}
catch (Exception e)
{
throw new Exception("Error al recuperar la lista de usuarios", e);
}
finally
{
this.CloseConnection();
}
return(usuarios);
}
public Personas GetOne(int ID, int tipo)
{
PersonaAdapter PersonaData = new PersonaAdapter();
try
{
return PersonaData.GetOne(ID, tipo);
}
finally
{
PersonaData = null;
}
}
public Personas GetAll(int tipo)
{
try
{
return PersonaData.GetAll(tipo);
}
finally
{
PersonaData = null;
}
}
public PersonaLogic()
{
this.pData = new PersonaAdapter();
}
public PersonaLogic()
{
PersonasData = new Data.Database.PersonaAdapter();
}
public void Insert(Persona persona)
{
try
{
PersonaData.Insert(persona);
}
finally
{
PersonaData = null;
}
}
public Personas GetOnePorLegajo(int legajo)
{
PersonaAdapter PersonaData = new PersonaAdapter();
try
{
return PersonaData.GetOnePorLegajo(legajo);
}
finally
{
PersonaData = null;
}
}
public LogicaPersona()
{
_personaData = new PersonaAdapter();
}
public void Update(Usuario usuario)
{
SqlConnection oCnn = this.CreateConnection();// Data.Database.Adapter.CreateConnection();
using (oCnn)
{
oCnn.Open();
SqlCommand oCmd = new SqlCommand();
using (oCmd)
{
//Buscamos el ID de la persona
PersonaAdapter PersonaData = new PersonaAdapter();
int id = PersonaData.GetId(usuario.Nombre, usuario.Apellido);
oCmd.Connection = oCnn;
oCmd.CommandType = CommandType.StoredProcedure;
oCmd.CommandText = "usuariosUpdate";
/*
oCmd.Parameters.Add("@id", SqlDbType.Int).Value = usuario.ID;
oCmd.Parameters.Add("@nombre_usuario", SqlDbType.VarChar, 50).Value = usuario.NombreUsuario;
oCmd.Parameters.Add("@clave", SqlDbType.VarChar, 50).Value = usuario.Clave;
oCmd.Parameters.Add("@habilitado", SqlDbType.Bit).Value = usuario.Habilitado;
oCmd.Parameters.Add("@nombre", SqlDbType.VarChar, 50).Value = usuario.Nombre;
oCmd.Parameters.Add("@apellido", SqlDbType.VarChar, 50).Value = usuario.Apellido;
oCmd.Parameters.Add("@email", SqlDbType.VarChar, 50).Value = usuario.EMail;
*/
try
{
oCmd.Parameters.AddWithValue("@id_usuario", usuario.ID);
oCmd.Parameters.AddWithValue("@nombre_usuario", usuario.NombreUsuario);
oCmd.Parameters.AddWithValue("@clave", Util.General.MD5Hash(usuario.Clave));
oCmd.Parameters.AddWithValue("@habilitado", usuario.Habilitado);
oCmd.Parameters.AddWithValue("@nombre", usuario.Nombre);
oCmd.Parameters.AddWithValue("@apellido", usuario.Apellido);
oCmd.Parameters.AddWithValue("@email", usuario.EMail);
oCmd.Parameters.AddWithValue("@cambia_clave", true);
oCmd.Parameters.AddWithValue("@id_persona", id);
oCmd.ExecuteNonQuery();
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al actualizar datos del usuario", Ex);
throw ExcepcionManejada;
}
}
}
}
public PersonaLogic()
{
_PersonaData = new PersonaAdapter();
}
public void Update(Persona persona)
{
try
{
PersonaData.Update(persona);
}
finally
{
PersonaData = null;
}
}
public PersonaLogic()
{
PersonaDatos = new PersonaAdapter();
}
public List <AlumnoInscripcion> getInscripcionesCurso(Curso cu)
{
List <AlumnoInscripcion> inscripciones = new List <AlumnoInscripcion>();
try
{
OpenConnection();
SqlCommand cmdSELECT = new SqlCommand("SELECT id_curso, id_alumno, id_inscripcion, condicion, nota " +
"FROM alumnos_inscripciones where id_curso = @id", sqlConn);
cmdSELECT.Parameters.Add("@id", SqlDbType.Int).Value = cu.ID;
SqlDataReader reader = cmdSELECT.ExecuteReader();
while (reader.Read())
{
AlumnoInscripcion insc = new AlumnoInscripcion();
switch ((string)reader["condicion"])
{
case ("Libre"):
insc.Condicion = AlumnoInscripcion.Condiciones.Libre;
break;
case ("Inscripto"):
insc.Condicion = AlumnoInscripcion.Condiciones.Inscripto;
break;
case ("Cursando"):
insc.Condicion = AlumnoInscripcion.Condiciones.Cursando;
break;
case ("Aprobado"):
insc.Condicion = AlumnoInscripcion.Condiciones.Aprobado;
insc.Nota = (int)reader["nota"];
break;
case ("Regular"):
insc.Condicion = AlumnoInscripcion.Condiciones.Regular;
break;
}
insc.ID = (int)reader["id_inscripcion"];
insc.Curso = new Curso();
insc.Curso.ID = (int)reader["id_curso"];
insc.Alumno = new Persona();
insc.Alumno.ID = (int)reader["id_alumno"];
inscripciones.Add(insc);
}
reader.Close();
foreach (AlumnoInscripcion insc in inscripciones)
{
PersonaAdapter pa = new PersonaAdapter();
insc.Alumno = pa.GetOne(insc.Alumno.ID);
CursoAdapter ca = new CursoAdapter();
insc.Curso = ca.GetOne(insc.Curso.ID);
}
}
catch (Exception e)
{
throw new Exception("No se han podido recuperar las inscripciones", e);
}
finally
{
CloseConnection();
}
return(inscripciones);
}
public PersonaLogic()
{
_PersonaData = new PersonaAdapter();
}
public void Insert(Usuario usuario)
{
//Creamos la conexión a utilizar.
SqlConnection oCnn = this.CreateConnection();// Data.Database.Adapter.CreateConnection();
using (oCnn)
{
//abrimos conexion
oCnn.Open();
//Creamos un commando para realizar el alta en la base de datos
SqlCommand oCmd = new SqlCommand();
using (oCmd)
{
//Buscamos el ID de la persona
PersonaAdapter PersonaData = new PersonaAdapter();
int id = PersonaData.GetId(usuario.Nombre, usuario.Apellido);
//asignamos la conexion que habiamos creado
oCmd.Connection = oCnn;
//Indicamos que stored procedure vamos a usar
oCmd.CommandType = CommandType.StoredProcedure;
oCmd.CommandText = "usuariosAdd";
//le asignamos los parámetros para el stored procedure
try
{
/*
oCmd.Parameters.AddWithValue("@nombre_usuario", usuario.NombreUsuario);
oCmd.Parameters.AddWithValue("@clave", usuario.Clave);
oCmd.Parameters.AddWithValue("@habilitado", usuario.Habilitado);
oCmd.Parameters.AddWithValue("@nombre", usuario.Nombre);
oCmd.Parameters.AddWithValue("@apellido", usuario.Apellido);
oCmd.Parameters.AddWithValue("@email", usuario.EMail);
*/
oCmd.Parameters.Add("@nombre_usuario", SqlDbType.VarChar, 50).Value = usuario.NombreUsuario;
oCmd.Parameters.Add("@clave", SqlDbType.VarChar, 50).Value = Util.General.MD5Hash(usuario.Clave);
oCmd.Parameters.Add("@habilitado", SqlDbType.Bit).Value = usuario.Habilitado;
oCmd.Parameters.Add("@nombre", SqlDbType.VarChar, 50).Value = usuario.Nombre;
oCmd.Parameters.Add("@apellido", SqlDbType.VarChar, 50).Value = usuario.Apellido;
oCmd.Parameters.Add("@email", SqlDbType.VarChar, 50).Value = usuario.EMail;
oCmd.Parameters.Add("@cambia_clave", SqlDbType.Bit).Value = true;
oCmd.Parameters.Add("@id_persona", SqlDbType.Int).Value = id;
usuario.ID = Decimal.ToInt32((decimal)oCmd.ExecuteScalar());
}
catch (Exception Ex)
{
Exception ExcepcionManejada = new Exception("Error al crear usuario", Ex);
throw ExcepcionManejada;
}
}
}
}