Example #1
0
        public static int crear(Proyecto proyecto)
        {
            try
            {
                int            idProyecto = -1;
                SqlParameter[] parametros = new SqlParameter[6];
                parametros[0] = new SqlParameter("nombre", proyecto.nombre);
                parametros[1] = new SqlParameter("descripcion", proyecto.descripcion);
                parametros[2] = new SqlParameter("urlTesting", proyecto.urlTesting);
                parametros[3] = new SqlParameter("urlProduccion", proyecto.urlProduccion);
                parametros[4] = new SqlParameter("id_usuario_creador", proyecto.usuario_creador.id_usuario);
                parametros[5] = new SqlParameter("fecha_alta", proyecto.fecha_alta);

                DataTable proyectoResult = executeQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "proyectosInsert", parametros);

                if (proyectoResult.Rows.Count > 0)
                {
                    idProyecto = Convert.ToInt32(proyectoResult.Rows[0][0].ToString());
                }

                return(idProyecto);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.Message, "Datos", "ProyectoDataProvider", "crear");
                throw ex;
            }
        }
Example #2
0
        public static Usuario getByUserNamePassword(string login_name, string password)
        {
            try
            {
                Usuario usuario = new Usuario();

                SqlParameter[] parametros = new SqlParameter[2];
                parametros[0] = new SqlParameter("login_name", login_name);
                parametros[1] = new SqlParameter("password", password);

                DataTable usuarioResult = executeQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "usuariosGetByUserNamePassword", parametros);

                if (usuarioResult.Rows.Count > 0)
                {
                    usuario = Mapear(usuarioResult.Rows[0]);
                }

                return(usuario);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.ToString(), "Datos", "UsuarioDataProvider", "getByUserNamePassword");
                throw ex;
            }
        }
        public static Sesion getByToken(string token)
        {
            try
            {
                Sesion sesion = new Sesion();

                SqlParameter[] parametros = new SqlParameter[1];
                parametros[0] = new SqlParameter("token", token);

                DataTable usuarioResult = executeQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "sesionesGetByToken", parametros);

                if (usuarioResult.Rows.Count > 0)
                {
                    sesion = Mapear(usuarioResult.Rows[0]);
                    sesion.usuario_logueado = UsuarioDataProvider.getById(sesion.usuario_logueado.id_usuario);
                }

                return(sesion);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.ToString(), "Datos", "SesionDataProvider", "getByToken");
                throw ex;
            }
        }
Example #4
0
        public static List <Proyecto_Usuario> getUsersByIdProyecto(int id_proyecto)
        {
            try
            {
                List <Proyecto_Usuario> usuarios = new List <Proyecto_Usuario>();

                SqlParameter[] parametros = new SqlParameter[1];
                parametros[0] = new SqlParameter("idProyecto", id_proyecto);

                DataTable proyectoResult = executeQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "proyectoGetUsuarioById", parametros);

                for (int i = 0; i < proyectoResult.Rows.Count; i++)
                {
                    Proyecto_Usuario usuario = Mapear(proyectoResult.Rows[i]);
                    usuarios.Add(usuario);
                }


                return(usuarios);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.Message, "Datos", "Proyecto_UsuarioDataProvider", "getUsersByIdProyecto");
                throw ex;
            }
        }
Example #5
0
        public static int crear(Usuario nuevoUsuario)
        {
            try
            {
                int            usuario    = 0;
                SqlParameter[] parametros = new SqlParameter[9];
                parametros[0] = new SqlParameter("nombre", nuevoUsuario.nombre);
                parametros[1] = new SqlParameter("apellido", nuevoUsuario.apellido);
                parametros[2] = new SqlParameter("login_name", nuevoUsuario.login_name);
                parametros[3] = new SqlParameter("password", nuevoUsuario.password);
                parametros[4] = new SqlParameter("telefono", nuevoUsuario.telefono);
                parametros[5] = new SqlParameter("email", nuevoUsuario.email);
                parametros[6] = new SqlParameter("fecha_alta", nuevoUsuario.fecha_alta);
                parametros[7] = new SqlParameter("habilitado", nuevoUsuario.habilitado);
                parametros[8] = new SqlParameter("token_clave", nuevoUsuario.token_clave);

                DataTable usuarioResult = executeQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "usuariosInsert", parametros);

                if (usuarioResult.Rows.Count > 0)
                {
                    usuario = Convert.ToInt32(usuarioResult.Rows[0][0].ToString());
                }

                return(usuario);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.ToString(), "Datos", "UsuarioDataProvider", "crear");
                throw ex;
            }
        }
Example #6
0
        public static void updateRoles(Usuario user)
        {
            try
            {
                SqlParameter[] parametrosDelete = new SqlParameter[1];

                parametrosDelete[0] = new SqlParameter("id_usuario", user.id_usuario);

                executeNonQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "rolesUsuarioDelete", parametrosDelete);

                SqlParameter[] parametrosInsert = new SqlParameter[2];
                for (int i = 0; i < user.roles.Count; i++)
                {
                    parametrosInsert[0] = new SqlParameter("id_usuario", user.id_usuario);
                    parametrosInsert[1] = new SqlParameter("id_rol", user.roles[i].id_rol);

                    executeNonQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "rolesUsuarioInsert", parametrosInsert);
                }
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.ToString(), "Datos", "UsuarioDataProvider", "crear");
                throw ex;
            }
        }
Example #7
0
        public static DataTable executeQuery(string cadenaConexion, string comandoSql)
        {
            SqlCommand comando = new SqlCommand();
            DataTable  result  = new DataTable();

            try
            {
                if (conectar(cadenaConexion))
                {
                    //comando = new SqlCommand();
                    comando.Connection  = conexion;
                    comando.CommandType = CommandType.Text;
                    comando.CommandText = comandoSql;

                    result.Load(comando.ExecuteReader());

                    desconectar();
                }
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.ToString(), "Datos", "Conexion", "executeQuery");
                throw ex;
            }
            finally
            {
                desconectar();
            }


            return(result);
        }
        public static void delete(Sesion sesion)
        {
            try
            {
                SqlParameter[] parametros = new SqlParameter[1];
                parametros[0] = new SqlParameter("id_usuario", sesion.usuario_logueado.id_usuario);

                executeNonQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "sesionesDelete", parametros);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.ToString(), "Datos", "SesionDataProvider", "sesionesInsert");
                throw ex;
            }
        }
Example #9
0
 private static void desconectar()
 {
     try
     {
         //SqlConnection conexion = new SqlConnection(cadenaConexion);
         if (conexion.State == ConnectionState.Open)
         {
             conexion.Close();
         }
     }
     catch (Exception ex)
     {
         LogueadorService.loguear(ex.ToString(), "Datos", "Conexion", "desconectar");
         throw ex;
     }
 }
Example #10
0
        public static void eliminarUsuarioAProyecto(int id_proyecto, int id_usuario, int id_rol)
        {
            try
            {
                SqlParameter[] parametros = new SqlParameter[3];
                parametros[0] = new SqlParameter("id_proyecto", id_proyecto);
                parametros[1] = new SqlParameter("id_usuario", id_usuario);
                parametros[2] = new SqlParameter("id_rol", id_rol);

                executeNonQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), "proyectosQuitarUsuario", parametros);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.Message, "Datos", "Proyecto_UsuarioDataProvider", "agregarUsuarioAProyecto");
                throw ex;
            }
        }
Example #11
0
        public static bool probarConexion(string cadenaConexion)
        {
            try
            {
                conexion = new SqlConnection(cadenaConexion);

                conexion.Open();

                conexion.Close();

                return(true);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.ToString(), "Datos", "Conexion", "probarConexion");
                return(false);
            }
        }
Example #12
0
        private static bool conectar(string cadenaConexion)
        {
            try
            {
                conexion = new SqlConnection(cadenaConexion);

                conexion.Open();

                return(true);
            }
            catch (Exception ex)
            {
                //TODO Loguear la excepcion
                LogueadorService.loguear(ex.ToString(), "Datos", "Conexion", "conectar");
                return(false);

                //return false;
                throw ex;
            }
        }
Example #13
0
        public static DataTable executeQueryProc(string cadenaConexion, string storedProcedure, SqlParameter[] parametros)
        {
            SqlCommand comando = new SqlCommand();
            DataTable  result  = new DataTable();

            try
            {
                if (conectar(cadenaConexion))
                {
                    //comando = new SqlCommand();
                    comando.Connection  = conexion;
                    comando.CommandType = CommandType.StoredProcedure;
                    comando.CommandText = storedProcedure;
                    if (parametros != null)
                    {
                        for (int i = 0; i < parametros.Length; i++)
                        {
                            comando.Parameters.Add(parametros[i]);
                        }
                    }
                    result.Load(comando.ExecuteReader());

                    desconectar();
                }
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.ToString(), "Datos", "Conexion", "executeQueryProc");
                throw ex;
            }
            finally
            {
                desconectar();
            }


            return(result);
        }
        public static Sesion getByIdUser(int id_usuario)
        {
            try
            {
                Sesion         sesionExistente = null;
                string         storedProcedure = "sesionesGetByIdUser";
                SqlParameter[] parametros      = new SqlParameter[1];
                parametros[0] = new SqlParameter("id_usuario", id_usuario);

                DataTable sesion = executeQueryProc(ConfiguracionDataProvider.obtenerCadenaConexion(), storedProcedure, parametros);

                if (sesion.Rows.Count > 0)
                {
                    sesionExistente = Mapear(sesion.Rows[0]);
                }

                return(sesionExistente);
            }
            catch (Exception ex)
            {
                LogueadorService.loguear(ex.Message, "Datos", "SesionDataProvider", "getByIdUser");
                throw ex;
            }
        }