Beispiel #1
0
        /// <summary>
        /// Método que se encarga de crear un usuario profesor en Active Directory
        /// </summary>
        /// <param name="estudiante">
        /// Los datos del profesor por ingresar a Active Directory
        /// </param>

        public Boolean crearProfesor2(Usuario profesor)
        {
            String nombre_completo = profesor.Carnet + " " + profesor.Nombre + " " + profesor.Apellidos;

            try
            {
                PrincipalContext contextoDominio = new PrincipalContext(ContextType.Domain, Constantes.DOM, Constantes.AD_USER, Constantes.AD_PASS);
                UserPrincipal    usuario         = new UserPrincipal(contextoDominio, profesor.UID, profesor.Contrasena, true);
                usuario.SamAccountName       = profesor.UID;                      // LEGACY: Cuenta de estudiante Pre-Win2000
                usuario.UserPrincipalName    = profesor.UID + Constantes.DOMINIO; //Debe de contener el dominio
                usuario.GivenName            = profesor.Nombre;
                usuario.Surname              = profesor.Apellidos;
                usuario.DisplayName          = nombre_completo;
                usuario.Description          = "Profesor";
                usuario.HomeDirectory        = getHomeDirectoryAD(profesor);
                usuario.EmailAddress         = profesor.Correo;
                usuario.HomeDrive            = "M";
                usuario.PasswordNeverExpires = true;
                usuario.Save();
                usuario.SetPassword(profesor.Contrasena);
                usuario.Save();
                return(true);
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return(false);
            }
        }
Beispiel #2
0
 /// <summary>
 /// Método que se utiliza para obtener los datos del uso de los laboratorios
 /// </summary>
 /// <returns>Una lista de listas de objetos, la cual contiene (nombre del laboratorio, login del operador, fecha de ultima actualización, comentario,
 /// cantidad de usuarios, cantidad de laptops) </returns>
 public List<List<object>> calcularUsoActual()
 {
     List<List<object>> resultado = new List<List<object>>();
     List<object> nodo;
     SqlCommand obtener = new SqlCommand("SP_PEUL_CalcularUsoActualEnTodoLaboratorio", _conexion);
     obtener.CommandType = CommandType.StoredProcedure;
     if (_conexion.State == ConnectionState.Closed)
         _conexion.Open();
     try
     {
         SqlDataReader reader = obtener.ExecuteReader();
         while (reader.Read())
         {
             nodo = new List<object>();
             nodo.Add(reader.GetString(0));      // Obtener el nombre del Laboratorio
             nodo.Add(reader.GetString(1));      // Obtener el login del operador
             nodo.Add(reader.GetDateTime(2));    // Obtener fecha de ultima actualización
             nodo.Add(reader.GetString(3));      // Obtener el comentario
             nodo.Add(reader.GetInt32(4));       // Obtener la cantidad de usuarios
             nodo.Add(reader.GetInt32(5));       // Obtener la cantidad de laptops
             nodo.Add(reader.GetDecimal(6));     // Obtener el porcentaje de uso
             resultado.Add(nodo);
         }
         _conexion.Close();
     }
     catch (Exception ex)
     {
         if (_conexion.State == ConnectionState.Open)
             _conexion.Close();
         _BDCompartido = new ManejoBD();
         _BDCompartido.insertarBitacoraError(ex.ToString(), "");
     }
     return resultado;
 }
Beispiel #3
0
        /// <summary>
        /// Comprueba la existencia de un UID cualquiera en Active Directory
        /// </summary>
        /// <param name="usuario">Nombre del estudiante TODO solo estudiantes?</param>
        /// <returns>1 si el estudiante existe, 0 sino existe, -1 si hubo un error</returns>

        public int existe(string usuario)
        {
            try
            {
                DirectoryEntry    conexion = crearConexionActiveDirectory();
                DirectorySearcher search   = new DirectorySearcher(conexion, "(sAMAccountName=" + usuario + ")");               // LEGACY: usa sAMAccountName
                SearchResult      result   = search.FindOne();

                search.Dispose();

                conexion.Close();
                conexion.Dispose();
                if (result != null)
                {
                    return(1);                    // Si el usuario existe
                }
                else
                {
                    return(0);                    // Sino existe
                }
            }
            catch (Exception e)             // En caso de error
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return(-1);
            }
        }
Beispiel #4
0
        /// <summary>
        /// Método que se encarga de obtener el nombre de una persona a partir de su nombre de usuario (login)
        /// </summary>
        /// <param name="nombreUsuario">Nombre de usuario (login)</param>
        /// <returns>Nombre de la persona</returns>

        public String obtenerNombrePersona(string nombreUsuario)
        {
            LdapDirectoryIdentifier serverInfo = new LdapDirectoryIdentifier(Constantes.LDAP_SERVER);
            LdapConnection          openLdap   = new LdapConnection(Constantes.LDAP_SERVER);

            try
            {
                String nombrePersona;
                // Crear conexion con LDAP
                openLdap.Credential = new System.Net.NetworkCredential(Constantes.LDAP_USER, Constantes.LDAP_PASS);
                openLdap.AuthType   = AuthType.Basic;
                openLdap.SessionOptions.ProtocolVersion = 3;                  // Hay que usar LDAPv3
                openLdap.Bind();                                              //Conectar
                string[] attributesToReturn = new string[] { "displayName" }; // Atributos a retornar
                // Buscar al usuario por su login
                SearchRequest searchRequest = new SearchRequest("ou=people,dc=ic-itcr,dc=ac,dc=cr", "(uid=" + nombreUsuario + "*)",
                                                                System.DirectoryServices.Protocols.SearchScope.Subtree, attributesToReturn);
                SearchResponse     searchResponse = (SearchResponse)openLdap.SendRequest(searchRequest);             // Respuesta del servidor
                DirectoryAttribute atributo       = searchResponse.Entries[0].Attributes["displayName"];
                object[]           objeto         = atributo.GetValues(Type.GetType("System.Byte[]"));
                nombrePersona = Encoding.ASCII.GetString((byte[])objeto[0]);
                openLdap.Dispose();                 // Liberar recursos
                return(nombrePersona);
            }
            catch (Exception e)
            {
                openLdap.Dispose();
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return(null);
            }
        }
Beispiel #5
0
        /// <summary>
        /// Modifca los datos de un usuario
        /// </summary>
        /// <param name="usuario"></param>
        /// <returns></returns>
        ///

        /*
         * public Boolean modificarUsuario(Usuario usuario, Boolean passChance)
         * {
         *  try
         *  {
         *      DirectoryEntry conexion = crearConexionActiveDirectory();
         *      DirectoryEntry nuevo_usuario = conexion.Children.Add("cn=" + usuario.UID, Constantes.AD_SCHEMA_USER);
         *      String nombre_completo = usuario.Carnet + " " + usuario.Nombre + " " + usuario.Apellidos + " " + usuario.Carrera;
         *
         *      cambiarDatoUsuario(conexion, "sAMAccountName", usuario.UID);
         *      cambiarDatoUsuario(conexion, "userPrincipalName", usuario.UID);
         *      cambiarDatoUsuario(conexion, "givenName", usuario.Nombre);
         *      cambiarDatoUsuario(conexion, "sn", usuario.Apellidos);
         *      cambiarDatoUsuario(conexion, "displayName", nombre_completo);
         *      cambiarDatoUsuario(conexion, "homePhone", usuario.TelefonoCasa);
         *      cambiarDatoUsuario(conexion, "mobile", usuario.TelefonoCelular);
         *      cambiarDatoUsuario(conexion, "mail", usuario.Correo);
         *
         *      if(usuario.Grupo == "Estudiante") {
         *          cambiarDatoUsuario(conexion, "homeDirectory", Ruta.RUTAPROFESOR + usuario.UID);
         *          cambiarDatoUsuario(conexion, "info", nombre_completo +_listadaGrupos.Estudiante.NombreGrupo);
         *      }
         *      else {
         *          cambiarDatoUsuario(conexion, "homeDirectory", Ruta.RUTAESTUDIANTE + usuario.UID);
         *          cambiarDatoUsuario(conexion, "info", _listadaGrupos.Profesor.NombreGrupo);
         *      }
         *      cambiarDatoUsuario(conexion, "description", usuario.Grupo);
         *      if(passChance)
         *          cambiarContraseña(nuevo_usuario, usuario.Contrasena);
         *      conexion.Close();
         *      conexion.Dispose();
         *      return true;
         *  }
         *  catch (Exception e)
         *  {
         *      _conexionBD = new ManejoBD();
         *      _conexionBD.insertarBitacoraError(e.ToString(), "");
         *      return false;
         *  }
         * }
         */
        public Boolean modificarUsuario2(Usuario usuario, Boolean passChance)
        {
            String nombre_completo = usuario.Carnet + " " + usuario.Nombre + " " + usuario.Apellidos + " " + usuario.Carrera;

            try
            {
                PrincipalContext contextoDominio = new PrincipalContext(ContextType.Domain, Constantes.DOM, Constantes.AD_USER, Constantes.AD_PASS);
                UserPrincipal    usuarioAD       = UserPrincipal.FindByIdentity(contextoDominio, usuario.UID);

                usuarioAD.SamAccountName       = usuario.UID;                      // LEGACY: Cuenta de estudiante Pre-Win2000
                usuarioAD.UserPrincipalName    = usuario.UID + Constantes.DOMINIO; //Debe de contener el dominio
                usuarioAD.GivenName            = usuario.Nombre;
                usuarioAD.Surname              = usuario.Apellidos;
                usuarioAD.DisplayName          = nombre_completo;
                usuarioAD.Description          = "usuario";
                usuarioAD.HomeDirectory        = getHomeDirectoryAD(usuario);
                usuarioAD.EmailAddress         = usuario.Correo;
                usuarioAD.HomeDrive            = "H";
                usuarioAD.PasswordNeverExpires = true;

                usuarioAD.Save();
                usuarioAD.SetPassword(usuario.Contrasena);
                usuarioAD.Save();
                return(true);
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return(false);
            }
        }
Beispiel #6
0
 /// <summary>
 /// Método que se encarga de cambiar la contraseña de un usuario
 /// </summary>
 /// <param name="userName">estudiante</param>
 /// <param name="contraseña">contraseña nueva</param>
 public void cambiarContraseña(DirectoryEntry conexion, String password)
 {
     try
     {
         conexion.Invoke("SetPassword", new object[] { password });
         conexion.Properties["LockOutTime"].Value = 0;
         MarcadorUAC.desactivar(conexion, MarcadorUAC.ACCOUNT_DISABLE); // Habilitar una cuenta
         //MarcadorUAC.activar(conexion, MarcadorUAC.NORMAL_ACCOUNT);
     }
     catch (Exception e)
     {
         _conexionBD = new ManejoBD();
         _conexionBD.insertarBitacoraError(e.ToString(), "");
     }
 }
Beispiel #7
0
        /// <summary>
        /// Método que se encarga de cambiar la contraseña de un usuario
        /// </summary>
        /// <param name="userName">estudiante</param>
        /// <param name="contraseña">contraseña nueva</param>

        public void cambiarContraseña(DirectoryEntry conexion, String password)
        {
            try
            {
                conexion.Invoke("SetPassword", new object[] { password });
                conexion.Properties["LockOutTime"].Value = 0;
                MarcadorUAC.desactivar(conexion, MarcadorUAC.ACCOUNT_DISABLE); // Habilitar una cuenta
                //MarcadorUAC.activar(conexion, MarcadorUAC.NORMAL_ACCOUNT);
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
            }
        }
Beispiel #8
0
        /// <summary>
        /// Autentica a un usuario contra openLDAP y verifica su membresia en alguno de los grupos
        /// </summary>
        /// <param name="nombreUsuario">Nombre de usuario</param>
        /// <param name="password">Contraseña del usuario</param>
        /// <returns>El grupo al que pertenece el usuario o null en caso que no esté registrado.</returns>

        public GrupoLDAP autenticarUsuario(string nombreUsuario, string password)
        {
            // Valida usuario y contraseña correctos
            LdapDirectoryIdentifier serverInfo = new LdapDirectoryIdentifier(Constantes.LDAP_SERVER);
            LdapConnection          openLdap   = new LdapConnection(Constantes.LDAP_SERVER);

            openLdap.Credential = new System.Net.NetworkCredential("uid=" + nombreUsuario + ",ou=people,dc=ic-itcr,dc=ac,dc=cr", password);
            openLdap.AuthType   = AuthType.Basic;
            openLdap.SessionOptions.ProtocolVersion = 3;
            try
            {
                openLdap.Bind();
            }
            catch (Exception e)
            {
                openLdap.Dispose();
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return(null);
            }

            // Buscar grupo al que pertenezca el usuario
            foreach (GrupoLDAP grupo in _listadaGrupos.obtenerGruposLDAP())
            {
                SearchRequest searchRequest = new SearchRequest("cn=" + grupo.NombreGrupo + ",ou=group,dc=ic-itcr,dc=ac,dc=cr", "(memberUid=" + nombreUsuario + ")", System.DirectoryServices.Protocols.SearchScope.Subtree);
                try
                {
                    SearchResponse searchResponse = (SearchResponse)openLdap.SendRequest(searchRequest);
                    if (searchResponse.Entries.Count != 0)
                    {
                        openLdap.Dispose();
                        return(grupo);
                    }
                }
                catch (Exception e)// En caso que algún grupo registrado en ListadoGruposLDAP.getGroupList() no exista.
                {
                    _conexionBD = new ManejoBD();
                    _conexionBD.insertarBitacoraError(e.ToString(), "Algún grupo registrado en ListadoGruposLDAP.getGroupList() no existe.");
                    continue;
                }
            }
            openLdap.Dispose();
            return(null);
        }
Beispiel #9
0
        /// <summary>
        /// Autentica a un usuario contra openLDAP y verifica su membresia en alguno de los grupos
        /// </summary>
        /// <param name="nombreUsuario">Nombre de usuario</param>
        /// <param name="password">Contraseña del usuario</param>
        /// <returns>El grupo al que pertenece el usuario o null en caso que no esté registrado.</returns>
        public GrupoLDAP autenticarUsuario(string nombreUsuario, string password)
        {
            // Valida usuario y contraseña correctos
            LdapDirectoryIdentifier serverInfo = new LdapDirectoryIdentifier(Constantes.LDAP_SERVER);
            LdapConnection openLdap = new LdapConnection(Constantes.LDAP_SERVER);
            openLdap.Credential = new System.Net.NetworkCredential("uid=" + nombreUsuario + ",ou=people,dc=ic-itcr,dc=ac,dc=cr", password);
            openLdap.AuthType = AuthType.Basic;
            openLdap.SessionOptions.ProtocolVersion = 3;
            try
            {
                openLdap.Bind();
            }
            catch (Exception e)
            {
                openLdap.Dispose();
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return null;
            }

            // Buscar grupo al que pertenezca el usuario
            foreach (GrupoLDAP grupo in _listadaGrupos.obtenerGruposLDAP())
            {
                SearchRequest searchRequest = new SearchRequest("cn=" + grupo.NombreGrupo + ",ou=group,dc=ic-itcr,dc=ac,dc=cr", "(memberUid=" + nombreUsuario + ")", System.DirectoryServices.Protocols.SearchScope.Subtree);
                try
                {
                    SearchResponse searchResponse = (SearchResponse)openLdap.SendRequest(searchRequest);
                    if (searchResponse.Entries.Count != 0)
                    {
                        openLdap.Dispose();
                        return grupo;
                    }
                }
                catch (Exception e)// En caso que algún grupo registrado en ListadoGruposLDAP.getGroupList() no exista.
                {
                    _conexionBD = new ManejoBD();
                    _conexionBD.insertarBitacoraError(e.ToString(), "Algún grupo registrado en ListadoGruposLDAP.getGroupList() no existe.");
                    continue;
                }
            }
            openLdap.Dispose();
            return null;
        }
Beispiel #10
0
        /// <summary>
        /// Modifca los datos de un usuario
        /// </summary>
        /// <param name="usuario"></param>
        /// <returns></returns>
        /// 
        /*
        public Boolean modificarUsuario(Usuario usuario, Boolean passChance)
        {
            try
            {
                DirectoryEntry conexion = crearConexionActiveDirectory();
                DirectoryEntry nuevo_usuario = conexion.Children.Add("cn=" + usuario.UID, Constantes.AD_SCHEMA_USER);
                String nombre_completo = usuario.Carnet + " " + usuario.Nombre + " " + usuario.Apellidos + " " + usuario.Carrera;

                cambiarDatoUsuario(conexion, "sAMAccountName", usuario.UID);
                cambiarDatoUsuario(conexion, "userPrincipalName", usuario.UID);
                cambiarDatoUsuario(conexion, "givenName", usuario.Nombre);
                cambiarDatoUsuario(conexion, "sn", usuario.Apellidos);
                cambiarDatoUsuario(conexion, "displayName", nombre_completo);
                cambiarDatoUsuario(conexion, "homePhone", usuario.TelefonoCasa);
                cambiarDatoUsuario(conexion, "mobile", usuario.TelefonoCelular);
                cambiarDatoUsuario(conexion, "mail", usuario.Correo);

                if(usuario.Grupo == "Estudiante") {
                    cambiarDatoUsuario(conexion, "homeDirectory", Ruta.RUTAPROFESOR + usuario.UID);
                    cambiarDatoUsuario(conexion, "info", nombre_completo +_listadaGrupos.Estudiante.NombreGrupo);
                }
                else {
                    cambiarDatoUsuario(conexion, "homeDirectory", Ruta.RUTAESTUDIANTE + usuario.UID);
                    cambiarDatoUsuario(conexion, "info", _listadaGrupos.Profesor.NombreGrupo);
                }
                cambiarDatoUsuario(conexion, "description", usuario.Grupo);
                if(passChance)
                    cambiarContraseña(nuevo_usuario, usuario.Contrasena);
                conexion.Close();
                conexion.Dispose();
                return true;
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return false;
            }
        }
        */
        public Boolean modificarUsuario2(Usuario usuario, Boolean passChance)
        {
            String nombre_completo = usuario.Carnet + " " + usuario.Nombre + " " + usuario.Apellidos + " " + usuario.Carrera;
            try
            {
                PrincipalContext contextoDominio = new PrincipalContext(ContextType.Domain, Constantes.DOM, Constantes.AD_USER, Constantes.AD_PASS);
                UserPrincipal usuarioAD = UserPrincipal.FindByIdentity(contextoDominio, usuario.UID);

                usuarioAD.SamAccountName = usuario.UID;// LEGACY: Cuenta de estudiante Pre-Win2000
                usuarioAD.UserPrincipalName = usuario.UID + Constantes.DOMINIO;//Debe de contener el dominio
                usuarioAD.GivenName = usuario.Nombre;
                usuarioAD.Surname = usuario.Apellidos;
                usuarioAD.DisplayName = nombre_completo;
                usuarioAD.Description = "usuario";
                usuarioAD.HomeDirectory = getHomeDirectoryAD(usuario);
                usuarioAD.EmailAddress = usuario.Correo;
                usuarioAD.HomeDrive = "H";
                usuarioAD.PasswordNeverExpires = true;

                usuarioAD.Save();
                usuarioAD.SetPassword(usuario.Contrasena);
                usuarioAD.Save();
                return true;
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return false;
            }
        }
Beispiel #11
0
        /// <summary>
        /// Comprueba la existencia de un UID cualquiera en Active Directory
        /// </summary>
        /// <param name="usuario">Nombre del estudiante TODO solo estudiantes?</param>
        /// <returns>1 si el estudiante existe, 0 sino existe, -1 si hubo un error</returns>
        public int existe(string usuario)
        {
            try
            {
                DirectoryEntry conexion = crearConexionActiveDirectory();
                DirectorySearcher search = new DirectorySearcher(conexion, "(sAMAccountName=" + usuario + ")"); // LEGACY: usa sAMAccountName
                SearchResult result = search.FindOne();

                search.Dispose();

                conexion.Close();
                conexion.Dispose();
                if (result != null)
                    return 1; // Si el usuario existe
                else
                    return 0; // Sino existe
            }
            catch (Exception e) // En caso de error
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return -1;
            }
        }
Beispiel #12
0
 public ControladorBitacora()
 {
     _conexionBD = new ManejoBD();
     _conexionBitacoraBD = new ManejoBDBitacora();
 }
Beispiel #13
0
        /// <summary>
        /// Método que se encarga de modificar un usuario profesor en el LDAP
        /// </summary>
        /// <param name="estudiante">
        /// Los datos del profesor (en un tipo Usuario) por modificar en el LDAP
        /// </param>
        public Boolean modificarUsuario(Usuario usuario, Boolean changePass)
        {
            String udi = usuario.UID;
            LdapDirectoryIdentifier serverInfo = new LdapDirectoryIdentifier(Constantes.LDAP_SERVER);
            LdapConnection          openLdap   = new LdapConnection(Constantes.LDAP_SERVER);

            openLdap.Credential = new System.Net.NetworkCredential(Constantes.LDAP_USER, Constantes.LDAP_PASS);
            openLdap.AuthType   = AuthType.Basic;
            openLdap.SessionOptions.ProtocolVersion = 3; // Hay que usar LDAPv3
            openLdap.Bind();                             // Conectar

            // Limpiar caracteres ESTO HAY QUE CAMBIARLO POR VALIDACIONES EN INTERFAZ
            char[] badChars  = { 'á', 'é', 'í', 'ó', 'ú', 'ñ' };
            char[] goodChars = { 'a', 'e', 'i', 'o', 'u', 'n' };

            for (int i = 0; i < badChars.Length; i++)                                     // Limpiar caracteres
            {
                usuario.Nombre    = usuario.Nombre.Replace(badChars[i], goodChars[i]);    // Quitar tildes u caracteres especiales del nombre
                usuario.Apellidos = usuario.Apellidos.Replace(badChars[i], goodChars[i]); // Quitar tildes u caracteres especiales de los apellidos
            }

            try
            {
                // Agregar las atributos del usuario para LDAP

                ModifyRequest increment1 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                             , DirectoryAttributeOperation.Replace, "cn", usuario.Nombre);
                openLdap.SendRequest(increment1);

                ModifyRequest increment2 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                             , DirectoryAttributeOperation.Replace, "sn", usuario.Apellidos);
                openLdap.SendRequest(increment2);

                ModifyRequest increment3 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                             , DirectoryAttributeOperation.Replace, "gecos", usuario.Carnet + ' ' + usuario.Nombre + ' ' + usuario.Apellidos + ' ' + usuario.Carrera);
                openLdap.SendRequest(increment3);


                if (usuario.TelefonoCasa.Replace(" ", "") != "")
                { // Teléfono de la casa en caso de que haya
                    ModifyRequest increment4 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                                 , DirectoryAttributeOperation.Replace, "homePhone", usuario.TelefonoCasa);
                    openLdap.SendRequest(increment4);
                }
                if (usuario.TelefonoCelular.Replace(" ", "") != "")
                {// Teléfono celular en caso de que haya
                    ModifyRequest increment5 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                                 , DirectoryAttributeOperation.Replace, "mobile", usuario.TelefonoCelular);
                    openLdap.SendRequest(increment5);
                }
                if (usuario.Correo.Replace(" ", "") != "")
                {// Correo electrónico del usuario
                    ModifyRequest increment5 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                                 , DirectoryAttributeOperation.Replace, "mail", usuario.Correo);
                    openLdap.SendRequest(increment5);
                }

                ModifyRequest increment6 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                             , DirectoryAttributeOperation.Replace, "displayName", usuario.Nombre + ' ' + usuario.Apellidos);
                openLdap.SendRequest(increment6);

                ModifyRequest increment7 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                             , DirectoryAttributeOperation.Replace, "description", usuario.Grupo);
                openLdap.SendRequest(increment7);



                //nuevoUsuario.Dispose(); // No hacer esto

                /*
                 * if(usuario.Grupo == "Estudiante") {
                 *  agregarGruposGenerales(usuario.UID); // Agrega a los grupos generales de LDAP
                 *  agregarGrupo(usuario.UID, _listadaGrupos.Estudiante.NombreGrupo); // Agregar el usuario al grupo de estudiantes
                 * }
                 * else {
                 * agregarGruposGenerales(usuario.UID); // Agrega a los grupos generales de LDAP
                 *  agregarGrupo(usuario.UID, _listadaGrupos.Profesor.NombreGrupo); // Agregar el usuario al grupo de profesores
                 * }
                 */
                if (changePass)
                {
                    ModifyRequest increment9 = new ModifyRequest("uid=" + udi + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                                                                 , DirectoryAttributeOperation.Replace, "userPassword", usuario.Contrasena);
                    openLdap.SendRequest(increment9);
                }

                return(true);
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return(false);
            }
        }
Beispiel #14
0
 /// <summary>
 /// Método que se encarga de llamar al stored procedure que retorna los reportes de registros de uso hechos en el laboratorio especificado según el rango
 /// </summary>
 /// <param name="pkLugar">Identificador del lugar sobrel el cual se realizará la búsqueda</param>
 /// <param name="fechaInicio">Fecha de inicio del rango para la búsqueda</param>
 /// <param name="fechaFinal">Fecha final del rango para la búsqueda</param>
 /// <returns>Retorna un DataTable con los reportes de uso encontrados</returns>
 public DataTable consultarRegistroUso(int pkLugar, string fechaInicio, string fechaFinal)
 {
     SqlCommand consultar = new SqlCommand("SP_PEUL_ConsultarReportesUso", _conexion);
     consultar.CommandType = CommandType.StoredProcedure;
     SqlParameter[] parametros = new SqlParameter[3];
     parametros[0] = new SqlParameter("@fkHistorialLugar", SqlDbType.Int);
     parametros[0].Value = pkLugar;
     parametros[1] = new SqlParameter("@fechaInicio", SqlDbType.Date);
     parametros[1].Value = fechaInicio;
     parametros[2] = new SqlParameter("@fechaFinal", SqlDbType.Date);
     parametros[2].Value = fechaFinal;
     consultar.Parameters.AddRange(parametros);
     DataTable _tablaReportes;
     _tablaReportes = new DataTable("Datos");
     _tablaReportes.Columns.Add(new DataColumn("Fecha"));
     _tablaReportes.Columns.Add(new DataColumn("Estado"));
     _tablaReportes.Columns.Add(new DataColumn("Operador"));
     _tablaReportes.Columns.Add(new DataColumn("Porcentaje"));
     _tablaReportes.Columns.Add(new DataColumn("Usuarios"));
     _tablaReportes.Columns.Add(new DataColumn("Portatiles"));
     _tablaReportes.Columns.Add(new DataColumn("Comentario"));
     if (_conexion.State == ConnectionState.Closed)
         _conexion.Open();
     try
     {
         SqlDataReader reader = consultar.ExecuteReader();
         while (reader.Read()) // Obtener todos los lugares del sistema
             _tablaReportes.Rows.Add(reader.GetDateTime(0), reader.GetString(1), reader.GetString(2), Convert.ToInt32(reader.GetDecimal(3)), reader.GetInt32(4), reader.GetInt32(5), reader.GetString(6));
         _conexion.Close();
         return _tablaReportes;
     }
     catch (Exception ex)
     {
         if (_conexion.State == ConnectionState.Open)
             _conexion.Close();
         _BDCompartido = new ManejoBD();
         _BDCompartido.insertarBitacoraError(ex.ToString(), "");
         return null;
     }
 }
Beispiel #15
0
        /// <summary>
        /// Método que se encarga de llamar al stored procedure que consulta los eventos de la bitácora en una fecha
        /// </summary>
        /// <param name="idLugar">Lugar en donde se registraron los eventos</param>
        /// <param name="fecha">Fecha que se desea consultar</param>
        /// <returns>Retorna una DataTable con las entradas registradas en la bitácora</returns>
        public DataTable ConsultarEntradaPorDia(int idLugar, DateTime fecha)
        {
            var tablaEventos = new DataTable();
            tablaEventos.Columns.Add("PK_Entrada");
            tablaEventos.Columns.Add("Fecha");
            tablaEventos.Columns.Add("Operador");
            tablaEventos.Columns.Add("Evento");
            var consultar = new SqlCommand("SP_BIT_ConsultarEntradaPorDia", _conexion)
                                {CommandType = CommandType.StoredProcedure};
            var parametros = new SqlParameter[2];
            parametros[0] = new SqlParameter("@idLugar", SqlDbType.Int) {Value = idLugar};
            parametros[1] = new SqlParameter("@fecha", SqlDbType.DateTime) {Value = fecha};
            consultar.Parameters.AddRange(parametros);
            try
            {
                if (_conexion.State == ConnectionState.Closed)
                    _conexion.Open();

                    SqlDataReader reader = consultar.ExecuteReader();
                    while (reader.Read()) //Obtiene todos lo eventos, resultado de la busqueda
                    {
                        tablaEventos.Rows.Add(reader.GetInt32(0), reader.GetDateTime(1), reader.GetString(2), reader.GetString(3));
                    }
                    _conexion.Close();
                    return tablaEventos;
            }
            catch (Exception ex)
            {
                if (_conexion.State == ConnectionState.Open)
                    _conexion.Close();
                _BDCompartido = new ManejoBD();
                _BDCompartido.insertarBitacoraError(ex.ToString(), "");
                return null;
            }
        }
Beispiel #16
0
        //BASARSE EN ESTO PARA ARREGLAR TODO LO QUE SEA CON EL AD
        //Una mejor manera de hacerlo http://johnbarquin.wordpress.com/2008/06/12/servicios-de-directorio-en-net-35/
        /// <summary>
        /// Método que se encarga de crear un usuario estudiante en Active Directory
        /// </summary>
        /// <param name="estudiante">
        /// Los datos del estudiante (en un tipo Usuario) por ingresar a Active Directory
        /// </param>
        public Boolean crearEstudiante2(Usuario estudiante)
        {
            String nombre_completo = estudiante.Carnet + " " + estudiante.Nombre + " " + estudiante.Apellidos + " " + estudiante.Carrera;
            try	{

            PrincipalContext contextoDominio = new PrincipalContext(ContextType.Domain, Constantes.DOM, Constantes.AD_USER, Constantes.AD_PASS);
            UserPrincipal usuario = new UserPrincipal(contextoDominio, estudiante.UID, estudiante.Contrasena, true);
            usuario.SamAccountName = estudiante.UID;// LEGACY: Cuenta de estudiante Pre-Win2000
            usuario.UserPrincipalName = estudiante.UID + Constantes.DOMINIO;//Debe de contener el dominio
            usuario.GivenName = estudiante.Nombre;
            usuario.Surname = estudiante.Apellidos;
            usuario.DisplayName = nombre_completo;
            usuario.Description = "Estudiante";
            usuario.HomeDirectory = getHomeDirectoryAD(estudiante);
            usuario.EmailAddress = estudiante.Correo;
            usuario.HomeDrive = "M";
            usuario.PasswordNeverExpires = true;
            usuario.Save();
            usuario.SetPassword(estudiante.Contrasena);
            usuario.Save();
            return true;
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return false;
            }
        }
Beispiel #17
0
        /// <summary>
        /// Método que se encarga de crear un usuario profesor en el LDAP
        /// </summary>
        /// <param name="estudiante">
        /// Los datos del profesor (en un tipo Usuario) por ingresar al LDAP
        /// </param>
        public Boolean crearProfesor(Usuario profesor)
        {
            try
            {
                DirectoryEntry conexion = crearConexion(Constantes.LDAP_BASEDN, Constantes.LDAP_USER, Constantes.LDAP_PASS);
                DirectoryEntry nuevoUsuario = conexion.Children.Add("uid=" + profesor.UID, "uidObject");

                conexion.Close(); // Cerrar la conexion
                conexion.Dispose(); // Liberar

                // Limpiar caracteres ESTO HAY QUE CAMBIARLO POR VALIDACIONES EN INTERFAZ
                char[] badChars = { 'á', 'é', 'í', 'ó', 'ú', 'ñ' };
                char[] goodChars = { 'a', 'e', 'i', 'o', 'u', 'n' };

                for (int i = 0; i < badChars.Length; i++) // Limpiar caracteres
                {

                    profesor.Nombre = profesor.Nombre.Replace(badChars[i], goodChars[i]); // Quitar tildes u caracteres especiales del nombre
                    profesor.Apellidos = profesor.Apellidos.Replace(badChars[i], goodChars[i]); // Quitar tildes u caracteres especiales de los apellidos
                }
                // Agregar las atributos del usuario para LDAP
                nuevoUsuario.Properties["cn"].Add(profesor.Nombre); // Nombre de la persona
                nuevoUsuario.Properties["objectClass"].Value = Constantes.OBJECTCLASSES;
                nuevoUsuario.Properties["uid"].Add(profesor.UID); // Nombre de usuario
                nuevoUsuario.Properties["sn"].Add(profesor.Apellidos); // Apellidos
                nuevoUsuario.Properties["gecos"].Add(profesor.Carnet + ' ' + profesor.Nombre + ' ' + profesor.Apellidos); // El carnet corresponde a la cédula si el profesor no fue estudiante de la Escuela

                if (profesor.TelefonoCasa.Replace(" ", "") != "") // Teléfono de la casa en caso de que haya
                    nuevoUsuario.Properties["homePhone"].Add(profesor.TelefonoCasa);
                if (profesor.TelefonoCelular.Replace(" ", "") != "") // Teléfono celular en caso de que haya
                    nuevoUsuario.Properties["mobile"].Add(profesor.TelefonoCelular);
                if (profesor.Correo.Replace(" ", "") != "") // Correo electrónico del usuario
                    nuevoUsuario.Properties["mail"].Add(profesor.Correo);

                nuevoUsuario.Properties["displayName"].Add(profesor.Nombre + ' ' + profesor.Apellidos);
                nuevoUsuario.Properties["loginShell"].Add(Constantes.SHELL_POR_DEFECTO); // /bin/bash
                nuevoUsuario.Properties["mailLocalAddress"].Add(profesor.UID + "@ic-itcr.ac.cr"); // Correo con ic-itcr
                nuevoUsuario.Properties["uidNumber"].Add(obtenerNumeroUid()); // Número de UID
                nuevoUsuario.Properties["userPassword"].Add(generarClaveSha(profesor.Contrasena));//Contraseña
                nuevoUsuario.Properties["homeDirectory"].Add(Ruta.RUTAPROFESOR + profesor.UID);
                nuevoUsuario.Properties["gidNumber"].Add(Constantes.GID_PROFESOR);
                nuevoUsuario.Properties["description"].Add("Profesor");

                nuevoUsuario.CommitChanges(); // Guardar cambios
                nuevoUsuario.Close();
                //nuevoUsuario.Dispose(); // No hacer esto
                agregarGruposGenerales(profesor.UID); // Agrega a los grupos generales de LDAP
                agregarGrupo(profesor.UID, _listadaGrupos.Profesor.NombreGrupo); // Agregar el usuario al grupo de profesores
                return true;
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return false;
            }
        }
Beispiel #18
0
 /// <summary>
 /// Método que se encarga de obtener el nombre de una persona a partir de su nombre de usuario (login)
 /// </summary>
 /// <param name="nombreUsuario">Nombre de usuario (login)</param>
 /// <returns>Nombre de la persona</returns>
 public String obtenerNombrePersona(string nombreUsuario)
 {
     LdapDirectoryIdentifier serverInfo = new LdapDirectoryIdentifier(Constantes.LDAP_SERVER);
     LdapConnection openLdap = new LdapConnection(Constantes.LDAP_SERVER);
     try
     {
         String nombrePersona;
         // Crear conexion con LDAP
         openLdap.Credential = new System.Net.NetworkCredential(Constantes.LDAP_USER, Constantes.LDAP_PASS);
         openLdap.AuthType = AuthType.Basic;
         openLdap.SessionOptions.ProtocolVersion = 3; // Hay que usar LDAPv3
         openLdap.Bind(); //Conectar
         string[] attributesToReturn = new string[] { "displayName" }; // Atributos a retornar
         // Buscar al usuario por su login
         SearchRequest searchRequest = new SearchRequest("ou=people,dc=ic-itcr,dc=ac,dc=cr", "(uid=" + nombreUsuario + "*)",
             System.DirectoryServices.Protocols.SearchScope.Subtree, attributesToReturn);
         SearchResponse searchResponse = (SearchResponse)openLdap.SendRequest(searchRequest); // Respuesta del servidor
         DirectoryAttribute atributo = searchResponse.Entries[0].Attributes["displayName"];
         object[] objeto = atributo.GetValues(Type.GetType("System.Byte[]"));
         nombrePersona = Encoding.ASCII.GetString((byte[])objeto[0]);
         openLdap.Dispose(); // Liberar recursos
         return nombrePersona;
     }
     catch (Exception e)
     {
         openLdap.Dispose();
         _conexionBD = new ManejoBD();
         _conexionBD.insertarBitacoraError(e.ToString(), "");
         return null;
     }
 }
Beispiel #19
0
        /// <summary>
        /// Método que recupera del LDAP el nombre, login y correo de los miembros de la Oficina de TI.
        /// </summary>
        /// <returns>Lista de Usuarios</returns>
        public List<Usuario> obtenerListaSoporte()
        {
            List<Usuario> _resultado = new List<Usuario>();     //Lista de usuarios con los datos de los miembros de la Oficina de TI
            List<String> _logins = new List<String>();          //Lista con los logins de los miembros de la Oficina de TI

            #region buscar login

            //Busca los memberUid del grupo soporte
            int _conta = 0;
            // Crear conexion con LDAP
            LdapDirectoryIdentifier serverInfo = new LdapDirectoryIdentifier(Constantes.LDAP_SERVER);
            LdapConnection openLdap = new LdapConnection(Constantes.LDAP_SERVER);
            openLdap.Credential = new System.Net.NetworkCredential(Constantes.LDAP_USER, Constantes.LDAP_PASS);
            openLdap.AuthType = AuthType.Basic;
            openLdap.SessionOptions.ProtocolVersion = 3; // Hay que usar LDAPv3
            openLdap.Bind(); //Conectar
            string[] attributesToReturn = new string[] { "memberUid" }; // Atributos a retornar
            SearchRequest searchRequest = new SearchRequest("ou=group,dc=ic-itcr,dc=ac,dc=cr", "(cn=soporte)",
                System.DirectoryServices.Protocols.SearchScope.Subtree, attributesToReturn);     //Filtro de busqueda.
            SearchResponse searchResponse = (SearchResponse)openLdap.SendRequest(searchRequest); // Respuesta del servidor
            DirectoryAttribute atributo = searchResponse.Entries[0].Attributes["memberUid"];
            object[] objeto = atributo.GetValues(Type.GetType("System.Byte[]"));

            foreach (object ob in objeto)
            {

                String _login = Encoding.ASCII.GetString((byte[])objeto[_conta]);
                _logins.Add(_login);
                _conta++;
            }

            #endregion

            #region buscar nombre y correo

            //Busca el displayName y el mail de cada soportista según el login en el LDAP
            foreach (String login in _logins)
            {

                try
                {
                    Usuario _usuario = new Usuario();
                    _usuario.UID = login;

                    string[] _datos = new string[] { "displayName", "mail" }; // Atributos a retornar
                    // Buscar al usuario por su login
                    SearchRequest _buqueda = new SearchRequest("ou=people,dc=ic-itcr,dc=ac,dc=cr", "(uid=" + login + "*)",
                        System.DirectoryServices.Protocols.SearchScope.Subtree, _datos);
                    SearchResponse _respuesta = (SearchResponse)openLdap.SendRequest(_buqueda); // Respuesta del servidor
                    DirectoryAttribute _atributo = _respuesta.Entries[0].Attributes["displayName"];
                    object[] _objeto = _atributo.GetValues(Type.GetType("System.Byte[]"));
                    _usuario.Nombre = Encoding.ASCII.GetString((byte[])_objeto[0]);

                    _atributo = _respuesta.Entries[0].Attributes["mail"];
                    _objeto = _atributo.GetValues(Type.GetType("System.Byte[]"));
                    _usuario.Correo = Encoding.ASCII.GetString((byte[])_objeto[0]);

                    _resultado.Add(_usuario);
                }
                catch (Exception e)
                {
                    _conexionBD = new ManejoBD();
                    _conexionBD.insertarBitacoraError(e.ToString(), "");
                    //throw e;
                }

            }

            #endregion

            openLdap.Dispose(); // Liberar recursos
            return _resultado;
        }
Beispiel #20
0
        /// <summary>
        /// Método que se encarga de modificar un usuario profesor en el LDAP
        /// </summary>
        /// <param name="estudiante">
        /// Los datos del profesor (en un tipo Usuario) por modificar en el LDAP
        /// </param>
        public Boolean modificarUsuario(Usuario usuario, Boolean changePass)
        {
            String udi = usuario.UID;
            LdapDirectoryIdentifier serverInfo = new LdapDirectoryIdentifier(Constantes.LDAP_SERVER);
            LdapConnection openLdap = new LdapConnection(Constantes.LDAP_SERVER);
            openLdap.Credential = new System.Net.NetworkCredential(Constantes.LDAP_USER, Constantes.LDAP_PASS);
            openLdap.AuthType = AuthType.Basic;
            openLdap.SessionOptions.ProtocolVersion = 3; // Hay que usar LDAPv3
            openLdap.Bind(); // Conectar

            // Limpiar caracteres ESTO HAY QUE CAMBIARLO POR VALIDACIONES EN INTERFAZ
            char[] badChars = { 'á', 'é', 'í', 'ó', 'ú', 'ñ' };
            char[] goodChars = { 'a', 'e', 'i', 'o', 'u', 'n' };

            for (int i = 0; i < badChars.Length; i++) // Limpiar caracteres
            {

                usuario.Nombre = usuario.Nombre.Replace(badChars[i], goodChars[i]); // Quitar tildes u caracteres especiales del nombre
                usuario.Apellidos = usuario.Apellidos.Replace(badChars[i], goodChars[i]); // Quitar tildes u caracteres especiales de los apellidos
            }

            try
            {

                // Agregar las atributos del usuario para LDAP

                ModifyRequest increment1 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                , DirectoryAttributeOperation.Replace, "cn", usuario.Nombre );
                openLdap.SendRequest(increment1);

                ModifyRequest increment2 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                , DirectoryAttributeOperation.Replace, "sn", usuario.Apellidos);
                openLdap.SendRequest(increment2);

                ModifyRequest increment3 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                , DirectoryAttributeOperation.Replace, "gecos", usuario.Carnet + ' ' + usuario.Nombre + ' ' + usuario.Apellidos + ' ' + usuario.Carrera);
                openLdap.SendRequest(increment3);

                if (usuario.TelefonoCasa.Replace(" ", "") != "")
                { // Teléfono de la casa en caso de que haya
                    ModifyRequest increment4 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                   , DirectoryAttributeOperation.Replace, "homePhone",usuario.TelefonoCasa);
                    openLdap.SendRequest(increment4);
                }
                if (usuario.TelefonoCelular.Replace(" ", "") != "")
                {// Teléfono celular en caso de que haya
                    ModifyRequest increment5 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                   , DirectoryAttributeOperation.Replace, "mobile", usuario.TelefonoCelular);
                    openLdap.SendRequest(increment5);

                }
                if (usuario.Correo.Replace(" ", "") != "")
                {// Correo electrónico del usuario
                    ModifyRequest increment5 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
                  , DirectoryAttributeOperation.Replace, "mail", usuario.Correo);
                    openLdap.SendRequest(increment5);

                }

                ModifyRequest increment6 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
              , DirectoryAttributeOperation.Replace, "displayName", usuario.Nombre + ' ' + usuario.Apellidos);
                openLdap.SendRequest(increment6);

                ModifyRequest increment7 = new ModifyRequest("uid=" + usuario.UID + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
              , DirectoryAttributeOperation.Replace, "description", usuario.Grupo);
                openLdap.SendRequest(increment7);

                //nuevoUsuario.Dispose(); // No hacer esto
                /*
                if(usuario.Grupo == "Estudiante") {
                    agregarGruposGenerales(usuario.UID); // Agrega a los grupos generales de LDAP
                    agregarGrupo(usuario.UID, _listadaGrupos.Estudiante.NombreGrupo); // Agregar el usuario al grupo de estudiantes
                }
                else {
                agregarGruposGenerales(usuario.UID); // Agrega a los grupos generales de LDAP
                    agregarGrupo(usuario.UID, _listadaGrupos.Profesor.NombreGrupo); // Agregar el usuario al grupo de profesores
                }
                */
                if (changePass)
                {
                    ModifyRequest increment9 = new ModifyRequest("uid=" + udi + ",ou=people,dc=ic-itcr,dc=ac,dc=cr"
              , DirectoryAttributeOperation.Replace, "userPassword", usuario.Contrasena);
                    openLdap.SendRequest(increment9);
                }

                return true;

            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return false;
            }
        }
Beispiel #21
0
        /***********************************/
        /// <summary>
        /// Método que se encarga de buscar las reservaciones en un periodo especifico
        /// </summary>
        /// <param name="idLugar">Id del laboratorio que se desea consultar</param>
        /// <param name="fechaInicio">Fecha de Inicio del periodo a consultar</param>
        /// <param name="fechaFin">Fecha Fin del periodo a consultar</param>
        /// <returns>Retorna un arreglo de arreglos de string con las reservaciones realizadas en ese periodo</returns>
        public DataTable consultarReservacion(string idLugar, string fechaInicio, string fechaFin)
        {
            SqlCommand consultar = new SqlCommand("SP_RES_ConsultarHorarioReservacion", _conexion);
            consultar.CommandType = CommandType.StoredProcedure;
            SqlParameter[] parametros = new SqlParameter[3];
            parametros[0] = new SqlParameter("@idLugar", SqlDbType.Int);
            parametros[0].Value = idLugar;
            parametros[1] = new SqlParameter("@fechaInicio", SqlDbType.Date);
            parametros[1].Value = fechaInicio;
            parametros[2] = new SqlParameter("@fechaFin", SqlDbType.Date);
            parametros[2].Value = fechaFin;
            consultar.Parameters.AddRange(parametros);
            DataTable _tablaReportes;
            _tablaReportes = new DataTable("Datos");
            _tablaReportes.Columns.Add(new DataColumn("Dias"));
            _tablaReportes.Columns.Add(new DataColumn("Hora Inicio"));
            _tablaReportes.Columns.Add(new DataColumn("Hora Final"));
            _tablaReportes.Columns.Add(new DataColumn("Fecha Inicio"));
            _tablaReportes.Columns.Add(new DataColumn("Fecha Final"));
            _tablaReportes.Columns.Add(new DataColumn("Solicitante"));
            _tablaReportes.Columns.Add(new DataColumn("Curso"));
            _tablaReportes.Columns.Add(new DataColumn("Descripcion"));
            if (_conexion.State == ConnectionState.Closed)
                _conexion.Open();
            try
            {
                SqlDataReader reader = consultar.ExecuteReader();
                string dias = "";
                int idReserv = 0; //guarda el id de la reservacion
                List<List<object>> reservaciones = new List<List<object>>();
                List<object> reserva;
                while (reader.Read()) // Obtener todos los lugares del sistema
                {
                    reserva = new List<object>();
                    reserva.Add(reader.GetInt32(0));
                    reserva.Add(reader.GetString(1));
                    reserva.Add(reader.GetString(2));
                    reserva.Add(reader.GetString(3));
                    reserva.Add(reader.GetString(4));
                    reserva.Add(reader.GetString(5));
                    reserva.Add(reader.GetString(6));
                    reserva.Add(reader.GetString(7));
                    reserva.Add(reader.GetString(8));
                    reservaciones.Add(reserva);
               }
                idReserv=(int)reservaciones.ElementAt(0).ElementAt(0);
                int i = 0;
                for (i=0; i < reservaciones.Count; i++)
                {

                    if ((!(idReserv == (int)reservaciones.ElementAt(i).ElementAt(0))))
                    {

                        _tablaReportes.Rows.Add(dias, (string)reservaciones.ElementAt(i-1).ElementAt(1), (string)reservaciones.ElementAt(i-1).ElementAt(2), (string)reservaciones.ElementAt(i-1).ElementAt(3), (string)reservaciones.ElementAt(i-1).ElementAt(4), (string)reservaciones.ElementAt(i-1).ElementAt(5), (string)reservaciones.ElementAt(i-1).ElementAt(6), (string)reservaciones.ElementAt(i-1).ElementAt(7));//, dias);
                        dias = "";
                        dias += (String)reservaciones.ElementAt(i).ElementAt(8)+",";
                    }
                    else
                    {
                        dias += (String)reservaciones.ElementAt(i).ElementAt(8) + ",";
                    }
                    idReserv = (int)reservaciones.ElementAt(i).ElementAt(0);

                }
                i = reservaciones.Count-1;
                _tablaReportes.Rows.Add(dias, (string)reservaciones.ElementAt(i).ElementAt(1), (string)reservaciones.ElementAt(i).ElementAt(2), (string)reservaciones.ElementAt(i).ElementAt(3), (string)reservaciones.ElementAt(i).ElementAt(4), (string)reservaciones.ElementAt(i).ElementAt(5), (string)reservaciones.ElementAt(i).ElementAt(6), (string)reservaciones.ElementAt(i).ElementAt(7));//, dias);

                    _conexion.Close();
                return _tablaReportes;
            }
            catch (Exception ex)
            {
                if (_conexion.State == ConnectionState.Open)
                    _conexion.Close();
                _conexionCompartido = new ManejoBD();
                _conexionCompartido.insertarBitacoraError(ex.ToString(), "");
                return null;
            }
        }
Beispiel #22
0
 /// <summary>
 /// Método que se encarga de obtener los estados en los que puede estar un laboratorio
 /// </summary>
 /// <returns>Lista de listas de objetos, la cual posee los PK del estado y la descripción de este</returns>
 public List<List<object>> obtenerEstadoLaboratorio()
 {
     List<List<object>> resultado = new List<List<object>>();
     List<object> nodo;
     SqlCommand obtener = new SqlCommand("SP_PEUL_ObtenerEstadoLaboratorio", _conexion);
     obtener.CommandType = CommandType.StoredProcedure;
     if (_conexion.State == ConnectionState.Closed)
         _conexion.Open();
     try
     {
         SqlDataReader reader = obtener.ExecuteReader();
         while (reader.Read())
         {
             nodo = new List<object>();
             nodo.Add(reader.GetInt32(0));  // Obtener el ID
             nodo.Add(reader.GetString(1)); // Obtener la descripción
             resultado.Add(nodo);
         }
         _conexion.Close();
     }
     catch (Exception ex)
     {
         if (_conexion.State == ConnectionState.Open)
             _conexion.Close();
         _BDCompartido = new ManejoBD();
         _BDCompartido.insertarBitacoraError(ex.ToString(), "");
     }
     return resultado;
 }
Beispiel #23
0
 public ControladorActivo()
 {
     _conexionBD = new ManejoBD();
     _conexionActivoBD = new ManejoBDActivo();
     _conexionLDAP = new ConexionLDAP();
 }
Beispiel #24
0
 /// <summary>
 /// Método que se encarga de obtener el porcentaje de uso de actual de cada laboratorio y registrar un uso de laboratorio
 /// </summary>
 /// /// <param name="lugar">Objeto Registro que indica los datos del registro</param>
 /// <returns>Lista de objetos que contiene sublistas con la información de uso de cada laboratorio
 ///			 (Laboratorio-Operador-Fecha última actualización-Cantidad de usuarios-Cantidad de portatiles-Porcentaje de uso</returns
 public List<List<object>> registrarPeul(Registro registro)
 {
     List<List<object>> resultado = new List<List<object>>();
     List<object> nodo;
     SqlCommand insertar = new SqlCommand("SP_PEUL_IngresarRegistroUtilizacion", _conexion);
     insertar.CommandType = CommandType.StoredProcedure;
     SqlParameter[] parametros = new SqlParameter[6];
     parametros[0] = new SqlParameter("@idLugar", SqlDbType.Int);
     parametros[0].Value = registro.IdLugar;
     parametros[1] = new SqlParameter("@idEstadoLaboratorio", SqlDbType.Int);
     parametros[1].Value = registro.IdEstadoLaboratorio;
     parametros[2] = new SqlParameter("@cantUsuarios", SqlDbType.Int);
     parametros[2].Value = registro.CantidadUsuarios;
     parametros[3] = new SqlParameter("@cantPortatiles", SqlDbType.Int);
     parametros[3].Value = registro.CantidadPortatiles;
     parametros[4] = new SqlParameter("@comentario", SqlDbType.NText);
     parametros[4].Value = registro.Comentario;
     parametros[5] = new SqlParameter("@login", SqlDbType.VarChar);
     parametros[5].Value = registro.Login;
     insertar.Parameters.AddRange(parametros);
     if (_conexion.State == ConnectionState.Closed)
         _conexion.Open();
     try
     {
         SqlDataReader reader = insertar.ExecuteReader();
         while (reader.Read())
         {
             nodo = new List<object>();
             nodo.Add(reader.GetString(0)); // Nombre del Laboratorio
             nodo.Add(reader.GetString(1)); // Operador
             nodo.Add(reader.GetDateTime(2)); // Fecha última actualización
             nodo.Add(reader.GetString(3)); // Comentario
             nodo.Add(reader.GetInt32(4)); // Cantidad de usuarios
             nodo.Add(reader.GetInt32(5)); // Cantidad de portatiles
             nodo.Add(reader.GetDecimal(6)); // Porcentaje de uso
             resultado.Add(nodo);
         }
         _conexion.Close();
     }
     catch (Exception ex)
     {
         if (_conexion.State == ConnectionState.Open)
             _conexion.Close();
         resultado = null;
         _BDCompartido = new ManejoBD();
         _BDCompartido.insertarBitacoraError(ex.ToString(), "");
     }
     return resultado;
 }
Beispiel #25
0
 /// <summary>
 /// Método que se encarga de llamar al stored procedure que modifica un estado de laboratorio
 /// </summary>
 /// <param name="idEstado">id del estado a modificar</param>
 /// <param name="descripcion">Descripción del estado</param>
 /// <returns>Retorna un valor booleano que indica true si la inserción fue exitosa o false en caso contrario</returns>
 public bool modificarEstadoLaboratorio(int idEstado, String descripcion)
 {
     Boolean resultado = false;
     SqlCommand modificar = new SqlCommand("SP_PEUL_ModificarEstadoLaboratorio", _conexion);
     modificar.CommandType = CommandType.StoredProcedure;
     SqlParameter[] parametros = new SqlParameter[2];
     parametros[0] = new SqlParameter("idEstadoLaboratorio", SqlDbType.Int);
     parametros[0].Value = idEstado;
     parametros[1] = new SqlParameter("@descripcion", SqlDbType.NText);
     parametros[1].Value = descripcion;
     modificar.Parameters.AddRange(parametros);
     if (_conexion.State == ConnectionState.Closed)
         _conexion.Open();
     try
     {
         SqlDataReader reader = modificar.ExecuteReader();
         reader.Read();
         resultado = !(reader.HasRows);
         _conexion.Close();
     }
     catch (Exception ex)
     {
         if (_conexion.State == ConnectionState.Open)
             _conexion.Close();
         _BDCompartido = new ManejoBD();
         _BDCompartido.insertarBitacoraError(ex.ToString(), "");
     }
     return resultado;
 }
Beispiel #26
0
        /// <summary>
        /// Método que se encarga de crear un usuario profesor en el LDAP
        /// </summary>
        /// <param name="estudiante">
        /// Los datos del profesor (en un tipo Usuario) por ingresar al LDAP
        /// </param>

        public Boolean crearProfesor(Usuario profesor)
        {
            try
            {
                DirectoryEntry conexion     = crearConexion(Constantes.LDAP_BASEDN, Constantes.LDAP_USER, Constantes.LDAP_PASS);
                DirectoryEntry nuevoUsuario = conexion.Children.Add("uid=" + profesor.UID, "uidObject");

                conexion.Close();                 // Cerrar la conexion
                conexion.Dispose();               // Liberar

                // Limpiar caracteres ESTO HAY QUE CAMBIARLO POR VALIDACIONES EN INTERFAZ
                char[] badChars  = { 'á', 'é', 'í', 'ó', 'ú', 'ñ' };
                char[] goodChars = { 'a', 'e', 'i', 'o', 'u', 'n' };

                for (int i = 0; i < badChars.Length; i++)                                       // Limpiar caracteres
                {
                    profesor.Nombre    = profesor.Nombre.Replace(badChars[i], goodChars[i]);    // Quitar tildes u caracteres especiales del nombre
                    profesor.Apellidos = profesor.Apellidos.Replace(badChars[i], goodChars[i]); // Quitar tildes u caracteres especiales de los apellidos
                }
                // Agregar las atributos del usuario para LDAP
                nuevoUsuario.Properties["cn"].Add(profesor.Nombre);                                                       // Nombre de la persona
                nuevoUsuario.Properties["objectClass"].Value = Constantes.OBJECTCLASSES;
                nuevoUsuario.Properties["uid"].Add(profesor.UID);                                                         // Nombre de usuario
                nuevoUsuario.Properties["sn"].Add(profesor.Apellidos);                                                    // Apellidos
                nuevoUsuario.Properties["gecos"].Add(profesor.Carnet + ' ' + profesor.Nombre + ' ' + profesor.Apellidos); // El carnet corresponde a la cédula si el profesor no fue estudiante de la Escuela

                if (profesor.TelefonoCasa.Replace(" ", "") != "")                                                         // Teléfono de la casa en caso de que haya
                {
                    nuevoUsuario.Properties["homePhone"].Add(profesor.TelefonoCasa);
                }
                if (profesor.TelefonoCelular.Replace(" ", "") != "")                 // Teléfono celular en caso de que haya
                {
                    nuevoUsuario.Properties["mobile"].Add(profesor.TelefonoCelular);
                }
                if (profesor.Correo.Replace(" ", "") != "")                 // Correo electrónico del usuario
                {
                    nuevoUsuario.Properties["mail"].Add(profesor.Correo);
                }

                nuevoUsuario.Properties["displayName"].Add(profesor.Nombre + ' ' + profesor.Apellidos);
                nuevoUsuario.Properties["loginShell"].Add(Constantes.SHELL_POR_DEFECTO);           // /bin/bash
                nuevoUsuario.Properties["mailLocalAddress"].Add(profesor.UID + "@ic-itcr.ac.cr");  // Correo con ic-itcr
                nuevoUsuario.Properties["uidNumber"].Add(obtenerNumeroUid());                      // Número de UID
                nuevoUsuario.Properties["userPassword"].Add(generarClaveSha(profesor.Contrasena)); //Contraseña
                nuevoUsuario.Properties["homeDirectory"].Add(Ruta.RUTAPROFESOR + profesor.UID);
                nuevoUsuario.Properties["gidNumber"].Add(Constantes.GID_PROFESOR);
                nuevoUsuario.Properties["description"].Add("Profesor");

                nuevoUsuario.CommitChanges();                 // Guardar cambios
                nuevoUsuario.Close();
                //nuevoUsuario.Dispose(); // No hacer esto
                agregarGruposGenerales(profesor.UID);                            // Agrega a los grupos generales de LDAP
                agregarGrupo(profesor.UID, _listadaGrupos.Profesor.NombreGrupo); // Agregar el usuario al grupo de profesores
                return(true);
            }
            catch (Exception e)
            {
                _conexionBD = new ManejoBD();
                _conexionBD.insertarBitacoraError(e.ToString(), "");
                return(false);
            }
        }
Beispiel #27
0
 public ControladorHorario()
 {
     _conexionBDHorario = new ManejoBDHorario();
     _conexionBD = new ManejoBD();
 }
Beispiel #28
0
 public ControladorSistema()
 {
     _conexionBD = new ManejoBD();
     _sistemaBD = new ManejoBDSistema();
 }
Beispiel #29
0
        /// <summary>
        /// Método que se encarga de llamar al stored procedure que retorna el porcentaje de uso de 
        /// un laboratorio en un rango de fechas
        /// </summary>
        /// <param name="pkLugar">Identificador del lugar sobrel el cual se realizará la búsqueda</param>
        /// <param name="fechaInicio">Fecha de inicio del rango para la búsqueda</param>
        /// <param name="fechaFinal">Fecha final del rango para la búsqueda</param>
        /// <returns>Retorna un DataTable con los reportes de uso encontrados</returns>
        public DataTable consultarPorcentajeUsoAnos(int pkLugar, string fechaInicio, string fechaFinal)
        {
            SqlCommand consultar = new SqlCommand("SP_PEUL_CalcularUsoEnAnos", _conexion);
            consultar.CommandType = CommandType.StoredProcedure;
            SqlParameter[] parametros = new SqlParameter[3];

            parametros[0] = new SqlParameter("@fechaInicio", SqlDbType.Date);
            parametros[0].Value = fechaInicio;
            parametros[1] = new SqlParameter("@fechaFinal", SqlDbType.Date);
            parametros[1].Value = fechaFinal;
            parametros[2] = new SqlParameter("@lugar", SqlDbType.Int);
            parametros[2].Value = pkLugar;

            consultar.Parameters.AddRange(parametros);
            DataTable _tablaReportes;
            _tablaReportes = new DataTable("Datos");
            _tablaReportes.Columns.Add(new DataColumn("Periodos"));
            _tablaReportes.Columns.Add(new DataColumn("Usos"));
            _tablaReportes.Columns.Add(new DataColumn("Laptops"));

            try
            {
            if (_conexion.State == ConnectionState.Closed)
                _conexion.Open();

                SqlDataReader reader = consultar.ExecuteReader();
                while (reader.Read()) // Obtener todos los lugares del sistema
                {
                    _tablaReportes.Rows.Add(reader.GetInt32(0), reader.GetDecimal(1), reader.GetDecimal(2));
                }

                _conexion.Close();
                return _tablaReportes;
            }
            catch (Exception ex)
            {
                if (_conexion.State == ConnectionState.Open)
                    _conexion.Close();
                _BDCompartido = new ManejoBD();
                _BDCompartido.insertarBitacoraError(ex.ToString(), "");
                return null;
            }
        }
Beispiel #30
0
 public ControladorPEUL()
 {
     _conexionBD = new ManejoBD();
     _conexionLDAP = new ConexionLDAP();
     _conexionPEULBD = new ManejoBDPEUL();
 }
Beispiel #31
0
 /// <summary>
 /// Constructor de la clase ManejoBD
 /// Este constructor indica los terminos de la conexión con la Base da Datos
 /// </summary>
 public ManejoBDSGC()
 {
     ConnectionStringSettings _settings = ConfigurationManager.ConnectionStrings["ModulosTI"]; // Propiedas del string de conexión almacenado en el .config
     _conexion = new SqlConnection(_settings.ConnectionString);
     _conexionBD = new ManejoBD();
 }
Beispiel #32
0
        /// <summary>
        /// Método que recupera del LDAP el nombre, login y correo de los miembros de la Oficina de TI.
        /// </summary>
        /// <returns>Lista de Usuarios</returns>

        public List <Usuario> obtenerListaSoporte()
        {
            List <Usuario> _resultado = new List <Usuario>();   //Lista de usuarios con los datos de los miembros de la Oficina de TI
            List <String>  _logins    = new List <String>();    //Lista con los logins de los miembros de la Oficina de TI

            #region buscar login

            //Busca los memberUid del grupo soporte
            int _conta = 0;
            // Crear conexion con LDAP
            LdapDirectoryIdentifier serverInfo = new LdapDirectoryIdentifier(Constantes.LDAP_SERVER);
            LdapConnection          openLdap   = new LdapConnection(Constantes.LDAP_SERVER);
            openLdap.Credential = new System.Net.NetworkCredential(Constantes.LDAP_USER, Constantes.LDAP_PASS);
            openLdap.AuthType   = AuthType.Basic;
            openLdap.SessionOptions.ProtocolVersion = 3;                                                                                      // Hay que usar LDAPv3
            openLdap.Bind();                                                                                                                  //Conectar
            string[]      attributesToReturn = new string[] { "memberUid" };                                                                  // Atributos a retornar
            SearchRequest searchRequest      = new SearchRequest("ou=group,dc=ic-itcr,dc=ac,dc=cr", "(cn=soporte)",
                                                                 System.DirectoryServices.Protocols.SearchScope.Subtree, attributesToReturn); //Filtro de busqueda.
            SearchResponse     searchResponse = (SearchResponse)openLdap.SendRequest(searchRequest);                                          // Respuesta del servidor
            DirectoryAttribute atributo       = searchResponse.Entries[0].Attributes["memberUid"];
            object[]           objeto         = atributo.GetValues(Type.GetType("System.Byte[]"));

            foreach (object ob in objeto)
            {
                String _login = Encoding.ASCII.GetString((byte[])objeto[_conta]);
                _logins.Add(_login);
                _conta++;
            }

            #endregion

            #region buscar nombre y correo

            //Busca el displayName y el mail de cada soportista según el login en el LDAP
            foreach (String login in _logins)
            {
                try
                {
                    Usuario _usuario = new Usuario();
                    _usuario.UID = login;

                    string[] _datos = new string[] { "displayName", "mail" }; // Atributos a retornar
                    // Buscar al usuario por su login
                    SearchRequest _buqueda = new SearchRequest("ou=people,dc=ic-itcr,dc=ac,dc=cr", "(uid=" + login + "*)",
                                                               System.DirectoryServices.Protocols.SearchScope.Subtree, _datos);
                    SearchResponse     _respuesta = (SearchResponse)openLdap.SendRequest(_buqueda); // Respuesta del servidor
                    DirectoryAttribute _atributo  = _respuesta.Entries[0].Attributes["displayName"];
                    object[]           _objeto    = _atributo.GetValues(Type.GetType("System.Byte[]"));
                    _usuario.Nombre = Encoding.ASCII.GetString((byte[])_objeto[0]);

                    _atributo       = _respuesta.Entries[0].Attributes["mail"];
                    _objeto         = _atributo.GetValues(Type.GetType("System.Byte[]"));
                    _usuario.Correo = Encoding.ASCII.GetString((byte[])_objeto[0]);

                    _resultado.Add(_usuario);
                }
                catch (Exception e)
                {
                    _conexionBD = new ManejoBD();
                    _conexionBD.insertarBitacoraError(e.ToString(), "");
                    //throw e;
                }
            }

            #endregion

            openLdap.Dispose(); // Liberar recursos
            return(_resultado);
        }