예제 #1
0
        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);
        }
예제 #2
0
        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);
        }
예제 #3
0
        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);
        }
예제 #4
0
        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();
            }
        }
예제 #5
0
 /*
 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;
     }
 }
예제 #6
0
 public bool ExisteLegajo(int legajo)
 {
     PersonaAdapter PersonaData = new PersonaAdapter();
     try
     {
         return PersonaData.ExisteLegajo(legajo);
     }
     finally
     {
         PersonaData = null;
     }
 }
예제 #7
0
        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);
        }
예제 #8
0
        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();
            }
        }
예제 #9
0
        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);
        }
예제 #10
0
        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);
        }
예제 #12
0
        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);
        }
예제 #14
0
        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);
        }
예제 #15
0
        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);
        }
예제 #16
0
        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);
        }
예제 #18
0
        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);
        }
예제 #19
0
        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);
        }
예제 #20
0
        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);
        }
예제 #21
0
 public Personas GetOne(int ID, int tipo)
 {
     PersonaAdapter PersonaData = new PersonaAdapter();
     try
     {
         return PersonaData.GetOne(ID, tipo);
     }
     finally
     {
         PersonaData = null;
     }
 }
예제 #22
0
 public Personas GetAll(int tipo)
 {
     try
     {
         return PersonaData.GetAll(tipo);
     }
     finally
     {
         PersonaData = null;
     }
 }
예제 #23
0
 public PersonaLogic()
 {
     this.pData = new PersonaAdapter();
 }
예제 #24
0
 public PersonaLogic()
 {
     PersonasData = new Data.Database.PersonaAdapter();
 }
예제 #25
0
 public void Insert(Persona persona)
 {
     try
     {
         PersonaData.Insert(persona);
     }
     finally
     {
         PersonaData = null;
     }
 }
예제 #26
0
 public Personas GetOnePorLegajo(int legajo)
 {
     PersonaAdapter PersonaData = new PersonaAdapter();
     try
     {
         return PersonaData.GetOnePorLegajo(legajo);
     }
     finally
     {
         PersonaData = null;
     }
 }
예제 #27
0
 public LogicaPersona()
 {
     _personaData = new PersonaAdapter();
 }
예제 #28
0
        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;
                    }
                }
            }
        }
예제 #29
0
 public PersonaLogic()
 {
     _PersonaData = new PersonaAdapter();
 }
예제 #30
0
 public void Update(Persona persona)
 {
     try
     {
         PersonaData.Update(persona);
     }
     finally
     {
         PersonaData = null;
     }
 }
예제 #31
0
파일: PersonaLogic.cs 프로젝트: serasio/TP2
 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);
        }
예제 #33
0
 public PersonaLogic()
 {
     _PersonaData = new PersonaAdapter();
 }
예제 #34
0
        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;
                    }
                }
            }
        }