password recuperation scripts

README.md

@@ -19,13 +19,31 @@ Aplicación web para gestionar préstamos de herramientas y proyectos en un Make
 - 🛠️ **Sistema de préstamos** de herramientas y dispositivos
 - 📱 **Integración con Telegram** para notificaciones y aprobaciones en tiempo real
 - 📊 **Gestión de proyectos GitLab**
-- 💾 **Persistencia de datos** en archivos JSON
+- 💾 **Persistencia de datos** con Hugging Face Datasets
 
 ## 🚀 Configuración
 
-### Variables de Entorno (Repository Secrets)
+### 1. Configurar Variables de Entorno
 
-Configura las siguientes variables en **Settings → Repository secrets**:
+En **Settings → Repository secrets**, configura las siguientes variables:
+
+#### Variables Obligatorias
+
+| Variable | Descripción |
+|----------|-------------|
+| `SECRET_KEY` | Clave secreta de Flask (genera con: `python3 -c "import secrets; print(secrets.token_hex(32))"`) |
+
+#### Variables para Persistencia (Hugging Face Datasets)
+
+| Variable | Descripción |
+|----------|-------------|
+| `HF_TOKEN` | Token de Hugging Face con permisos de escritura ([crear aquí](https://huggingface.co/settings/tokens)) |
+| `HF_DATASET_USERS` | Nombre del dataset para usuarios (ej: `tu-usuario/makerpage-users`) |
+| `HF_DATASET_LOANS` | Nombre del dataset para préstamos (ej: `tu-usuario/makerpage-loans`) |
+
+> **Nota:** Los datasets deben ser **privados** (contienen contraseñas hasheadas). Se crearán automáticamente al guardar el primer registro.
+
+#### Variables Opcionales (Funcionalidades Adicionales)
 
 | Variable | Descripción |
 |----------|-------------|
@@ -36,13 +54,19 @@ Configura las siguientes variables en **Settings → Repository secrets**:
 | `GITLAB_GROUP_ID` | ID del grupo de GitLab |
 | `RESEND_API_KEY` | API key de Resend para emails |
 | `FROM_EMAIL` | Email remitente verificado en Resend |
-| `SECRET_KEY` | Clave secreta de Flask (genera con: `python3 -c "import secrets; print(secrets.token_hex(32))"`) |
 
-## ⚠️ Persistencia de Datos
+### 2. Desplegar
+
+El Space se desplegará automáticamente al hacer push al repositorio.
+
+## 💾 Persistencia de Datos
+
+La aplicación usa **Hugging Face Datasets** para almacenamiento persistente:
 
-> **Importante:** Hugging Face Spaces NO soporta volúmenes persistentes. Los datos se guardan temporalmente en `/app/data` pero se perderán al reiniciar el Space.
+- ✅ **Con HF_TOKEN configurado:** Los datos se guardan en datasets privados de HF y persisten permanentemente
+- ⚠️ **Sin HF_TOKEN:** Los datos se guardan localmente en `/app/data` (temporales, se pierden al reiniciar)
 
-Para producción, considera implementar una solución de persistencia externa. Ver [HUGGINGFACE_PERSISTENCE.md](HUGGINGFACE_PERSISTENCE.md) para opciones.
+**Recomendación:** Configura `HF_TOKEN`, `HF_DATASET_USERS` y `HF_DATASET_LOANS` para garantizar persistencia en producción.
 
 ## 🔧 Tecnologías
 
@@ -51,7 +75,7 @@ Para producción, considera implementar una solución de persistencia externa. V
 - **Notificaciones:** Telegram Bot API
 - **Email:** Resend API
 - **Integración:** GitLab API
-- **Persistencia:** JSON (temporal en HF Spaces)
+- **Persistencia:** Hugging Face Datasets (con fallback a JSON local)
 - **Despliegue:** Docker + Gunicorn + Eventlet
 
 ## 📝 Licencia

app/main.py

@@ -20,6 +20,15 @@ import markdown
 from dotenv import load_dotenv
 import resend
 
+# Importar Hugging Face Datasets para persistencia
+try:
+    from datasets import Dataset, load_dataset
+    from huggingface_hub import HfApi
+    HF_AVAILABLE = True
+except ImportError:
+    HF_AVAILABLE = False
+    print("[WARNING] huggingface_hub/datasets not available. Using local JSON storage only.")
+
 # Cargar variables de entorno desde .env
 load_dotenv()
 
@@ -35,36 +44,115 @@ login_manager.login_view = 'login'
 login_manager.login_message = "Por favor, inicia sesión para acceder."
 login_manager.login_message_category = "red"
 
+# --- GESTOR DE DATASETS DE HUGGING FACE ---
+class HFDatasetManager:
+    """Clase base para manejar persistencia con Hugging Face Datasets."""
+    
+    def __init__(self, dataset_name, data_key, local_filename):
+        self.dataset_name = os.getenv(dataset_name)
+        self.data_key = data_key
+        self.hf_token = os.getenv("HF_TOKEN")
+        self.use_hf = HF_AVAILABLE and self.dataset_name and self.hf_token
+        
+        # Configurar almacenamiento local como fallback
+        data_dir = os.getenv("DATA_DIR", "/app/data")
+        os.makedirs(data_dir, exist_ok=True)
+        self.local_file = os.path.join(data_dir, local_filename)
+        
+        print(f"[{self.__class__.__name__}] HF Datasets: {'ENABLED' if self.use_hf else 'DISABLED (using local JSON)'}")
+        if self.use_hf:
+            print(f"[{self.__class__.__name__}] Dataset: {self.dataset_name}")
+    
+    def _load_from_hf(self):
+        """Carga datos desde Hugging Face Dataset."""
+        try:
+            dataset = load_dataset(self.dataset_name, split="train", token=self.hf_token)
+            if len(dataset) > 0:
+                return dataset[0][self.data_key]
+            return []
+        except Exception as e:
+            print(f"[HF ERROR] Error loading from dataset: {e}")
+            return None
+    
+    def _load_from_local(self):
+        """Carga datos desde archivo JSON local."""
+        if os.path.exists(self.local_file):
+            try:
+                with open(self.local_file, "r") as f:
+                    return json.load(f)
+            except:
+                return []
+        return []
+    
+    def _save_to_hf(self, data):
+        """Guarda datos en Hugging Face Dataset."""
+        try:
+            dataset_dict = {self.data_key: [data]}
+            dataset = Dataset.from_dict(dataset_dict)
+            dataset.push_to_hub(
+                self.dataset_name,
+                token=self.hf_token,
+                private=True
+            )
+            print(f"[HF SUCCESS] Data saved to {self.dataset_name}")
+            return True
+        except Exception as e:
+            print(f"[HF ERROR] Error saving to dataset: {e}")
+            return False
+    
+    def _save_to_local(self, data):
+        """Guarda datos en archivo JSON local."""
+        try:
+            with open(self.local_file, "w") as f:
+                json.dump(data, f, indent=4)
+            return True
+        except Exception as e:
+            print(f"[LOCAL ERROR] Error saving to local file: {e}")
+            return False
+
 class User(UserMixin):
     """Clase de usuario compatible con Flask-Login."""
     def __init__(self, id, username):
         self.id = id
         self.username = username
 
-# --- GESTOR DE USUARIOS (Persistencia JSON) ---
-class UserManager:
-    """Clase para manejar los usuarios en un archivo JSON."""
-    def __init__(self, filename="users.json"):
-        # Usar directorio de datos configurable (para volúmenes Docker)
-        data_dir = os.getenv("DATA_DIR", "/app/data")
-        os.makedirs(data_dir, exist_ok=True)
-        self.filename = os.path.join(data_dir, filename)
+# --- GESTOR DE USUARIOS (Persistencia con HF Datasets) ---
+class UserManager(HFDatasetManager):
+    """Clase para manejar los usuarios con persistencia en HF Datasets."""
+    
+    def __init__(self):
+        super().__init__(
+            dataset_name="HF_DATASET_USERS",
+            data_key="users",
+            local_filename="users.json"
+        )
         self.users = self._load()
-
+    
     def _load(self):
-        """Carga los usuarios desde el archivo JSON."""
-        if os.path.exists(self.filename):
-            try:
-                with open(self.filename, "r") as f:
-                    return json.load(f)
-            except:
-                return []
-        return []
+        """Carga los usuarios desde HF Dataset o archivo JSON local."""
+        if self.use_hf:
+            data = self._load_from_hf()
+            if data is not None:
+                print(f"[UserManager] Loaded {len(data)} users from HF Dataset")
+                return data
+            print("[UserManager] Failed to load from HF, trying local...")
+        
+        data = self._load_from_local()
+        print(f"[UserManager] Loaded {len(data)} users from local JSON")
+        return data
 
     def save(self):
-        """Guarda la lista de usuarios en el archivo JSON."""
-        with open(self.filename, "w") as f:
-            json.dump(self.users, f, indent=4)
+        """Guarda la lista de usuarios en HF Dataset y/o archivo JSON."""
+        # Siempre guardar localmente como backup
+        self._save_to_local(self.users)
+        
+        # Intentar guardar en HF si está habilitado
+        if self.use_hf:
+            success = self._save_to_hf(self.users)
+            if success:
+                print(f"[UserManager] Saved {len(self.users)} users to HF Dataset")
+            else:
+                print("[UserManager] Failed to save to HF, data saved locally only")
 
     def add_user(self, username, password, email, status="PENDING"):
         """Registra un nuevo usuario con email, contraseña hasheada y estado pendiente."""
@@ -165,30 +253,43 @@ def load_user(user_id):
         return User(user_data['id'], user_data['username'])
     return None
 
-# --- GESTOR DE PRÉSTAMOS (Persistencia JSON) ---
-class LoanManager:
-    """Clase para manejar la persistencia de préstamos en un archivo JSON."""
-    def __init__(self, filename="prestamos.json"):
-        # Usar directorio de datos configurable (para volúmenes Docker)
-        data_dir = os.getenv("DATA_DIR", "/app/data")
-        os.makedirs(data_dir, exist_ok=True)
-        self.filename = os.path.join(data_dir, filename)
+# --- GESTOR DE PRÉSTAMOS (Persistencia con HF Datasets) ---
+class LoanManager(HFDatasetManager):
+    """Clase para manejar la persistencia de préstamos en HF Datasets."""
+    
+    def __init__(self):
+        super().__init__(
+            dataset_name="HF_DATASET_LOANS",
+            data_key="loans",
+            local_filename="prestamos.json"
+        )
         self.loans = self._load()
-
+    
     def _load(self):
-        """Carga los préstamos desde el archivo JSON."""
-        if os.path.exists(self.filename):
-            try:
-                with open(self.filename, "r") as f:
-                    return json.load(f)
-            except:
-                return []
-        return []
+        """Carga los préstamos desde HF Dataset o archivo JSON local."""
+        if self.use_hf:
+            data = self._load_from_hf()
+            if data is not None:
+                print(f"[LoanManager] Loaded {len(data)} loans from HF Dataset")
+                return data
+            print("[LoanManager] Failed to load from HF, trying local...")
+        
+        data = self._load_from_local()
+        print(f"[LoanManager] Loaded {len(data)} loans from local JSON")
+        return data
 
     def save(self):
-        """Guarda la lista actual de préstamos en el archivo JSON."""
-        with open(self.filename, "w") as f:
-            json.dump(self.loans, f, indent=4)
+        """Guarda la lista actual de préstamos en HF Dataset y/o archivo JSON."""
+        # Siempre guardar localmente como backup
+        self._save_to_local(self.loans)
+        
+        # Intentar guardar en HF si está habilitado
+        if self.use_hf:
+            success = self._save_to_hf(self.loans)
+            if success:
+                print(f"[LoanManager] Saved {len(self.loans)} loans to HF Dataset")
+            else:
+                print("[LoanManager] Failed to save to HF, data saved locally only")
 
     def add_loan(self, loan):
         """Añade un nuevo préstamo a la lista y guarda en disco."""

app/requirements.txt

@@ -9,3 +9,5 @@ gunicorn
 eventlet
 markdown
 resend
+datasets
+huggingface_hub