adding features

2025-03-26 19:08:07 +01:00
parent e22c0ac855
commit dacc3ecc4c
37 changed files with 456 additions and 60 deletions
@@ -0,0 +1,71 @@
+# OxiCloud Tests
+
+This directory contains test scripts, utilities and troubleshooting tools for the OxiCloud project.
+
+## API Tests
+
+* `test-all-routes.py` - Tests all API routes to verify which ones are implemented
+* `test-api.sh` - Bash script to test basic API functionality (list, upload, download)
+* `test-api-integration.py` - Python-based integration tests for the API
+* `test-upload.py` - Dedicated upload testing script with more options
+* `test-upload.sh` - Simple shell script for testing file uploads
+* `test-delete-file.py` - Tests the file deletion functionality
+
+## Folder Tests
+
+* `test-folder.sh` - Tests folder API operations
+* `test-folder-simple.sh` - Simplified folder creation/listing tests
+* `test-create-folder.sh` - Specific test for folder creation
+* `test-folder.js` - JavaScript based folder tests
+
+## Trash Tests
+
+* `test-trash.sh` - Tests trash functionality
+* `test-trash-simple.sh` - Basic trash functionality test
+* `test-trash-api.py` - Python script for testing trash API
+* `test-trash-api-simple.py` - Simplified version of trash API tests
+* `test-trash-api.sh` - Bash scripts for trash API testing
+* `test-compile-trash.sh` - Tests compilation with trash feature enabled
+* `fix-trash-index.sh` - Utility to fix trash indexing issues
+* `check-trash-dirs.sh` - Checks trash directories structure
+* `debug-trash.py` - Debug tool for trash functionality
+* `run-trash-test.sh` - Runner for trash tests
+
+## Authentication Tests
+
+* `test-auth-api.sh` - Tests the authentication API endpoints
+* `test-auth-env.sh` - Tests authentication with environment variables
+
+## Utilities
+
+* `check-db.sh` - Database check utility
+* `simulate-id-mapping.py` - Simulates ID mapping for testing
+* `direct-upload-test.py` - Tests direct uploads bypassing certain layers
+
+## Test Files
+
+* `test-upload.txt` - Sample file for upload testing
+* `test-api-file.txt` - Sample file for API testing
+
+## Running Tests
+
+Most test scripts can be run directly from this directory. Many accept command-line arguments
+to customize their behavior. Check the script headers or run with `--help` for more information.
+
+Basic usage examples:
+
+```bash
+# Test API endpoints
+python test-all-routes.py
+
+# Test file upload
+./test-upload.sh --file sample.txt
+
+# Test trash API
+python test-trash-api.py
+
+# Run folder tests
+./test-folder.sh
+```
+
+Note that these tests expect a running OxiCloud server, typically on localhost:8086.
@@ -0,0 +1,23 @@
+#!/bin/bash
+# Script to check database state
+
+echo "=== PostgreSQL Database Info ==="
+docker exec oxicloud_postgres_1 psql -U postgres -d oxicloud -c "SELECT current_database(), current_user, current_schemas(true);"
+
+echo -e "\n=== Check auth schema exists ==="
+docker exec oxicloud_postgres_1 psql -U postgres -d oxicloud -c "SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'auth';"
+
+echo -e "\n=== Check enum type exists ==="
+docker exec oxicloud_postgres_1 psql -U postgres -d oxicloud -c "SELECT typname, typnamespace::regnamespace FROM pg_type WHERE typname = 'userrole';"
+
+echo -e "\n=== List tables in auth schema ==="
+docker exec oxicloud_postgres_1 psql -U postgres -d oxicloud -c "SELECT table_schema, table_name FROM information_schema.tables WHERE table_schema = 'auth';"
+
+echo -e "\n=== Check users table structure ==="
+docker exec oxicloud_postgres_1 psql -U postgres -d oxicloud -c "SELECT column_name, data_type, udt_name FROM information_schema.columns WHERE table_schema = 'auth' AND table_name = 'users' ORDER BY ordinal_position;"
+
+echo -e "\n=== Check users in the database ==="
+docker exec oxicloud_postgres_1 psql -U postgres -d oxicloud -c "SELECT id, username, email, role FROM auth.users;"
+
+echo -e "\n=== Check sessions in the database ==="
+docker exec oxicloud_postgres_1 psql -U postgres -d oxicloud -c "SELECT id, user_id, expires_at FROM auth.sessions;"
@@ -0,0 +1,74 @@
+#!/bin/bash
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+NC='\033[0m' # No Color
+
+echo -e "${GREEN}=== OxiCloud Trash Directory Check Script ===${NC}"
+
+# Configuration
+STORAGE_DIR="./storage"
+TRASH_DIR="$STORAGE_DIR/.trash"
+TRASH_FILES_DIR="$TRASH_DIR/files"
+
+# Check if storage directory exists
+echo -e "${YELLOW}Checking if storage directory exists: $STORAGE_DIR${NC}"
+if [ ! -d "$STORAGE_DIR" ]; then
+    echo -e "${RED}Storage directory does not exist. Creating it...${NC}"
+    mkdir -p "$STORAGE_DIR"
+    if [ $? -ne 0 ]; then
+        echo -e "${RED}Failed to create storage directory${NC}"
+        exit 1
+    fi
+    echo -e "${GREEN}Storage directory created successfully${NC}"
+else
+    echo -e "${GREEN}Storage directory exists${NC}"
+fi
+
+# Check if trash directory exists
+echo -e "${YELLOW}Checking if trash directory exists: $TRASH_DIR${NC}"
+if [ ! -d "$TRASH_DIR" ]; then
+    echo -e "${RED}Trash directory does not exist. Creating it...${NC}"
+    mkdir -p "$TRASH_DIR"
+    if [ $? -ne 0 ]; then
+        echo -e "${RED}Failed to create trash directory${NC}"
+        exit 1
+    fi
+    echo -e "${GREEN}Trash directory created successfully${NC}"
+else
+    echo -e "${GREEN}Trash directory exists${NC}"
+fi
+
+# Check if trash files directory exists
+echo -e "${YELLOW}Checking if trash files directory exists: $TRASH_FILES_DIR${NC}"
+if [ ! -d "$TRASH_FILES_DIR" ]; then
+    echo -e "${RED}Trash files directory does not exist. Creating it...${NC}"
+    mkdir -p "$TRASH_FILES_DIR"
+    if [ $? -ne 0 ]; then
+        echo -e "${RED}Failed to create trash files directory${NC}"
+        exit 1
+    fi
+    echo -e "${GREEN}Trash files directory created successfully${NC}"
+else
+    echo -e "${GREEN}Trash files directory exists${NC}"
+fi
+
+# Check if trash index file exists
+echo -e "${YELLOW}Checking if trash index file exists: $TRASH_DIR/trash_index.json${NC}"
+if [ ! -f "$TRASH_DIR/trash_index.json" ]; then
+    echo -e "${RED}Trash index file does not exist. Creating it...${NC}"
+    echo "[]" > "$TRASH_DIR/trash_index.json"
+    if [ $? -ne 0 ]; then
+        echo -e "${RED}Failed to create trash index file${NC}"
+        exit 1
+    fi
+    echo -e "${GREEN}Trash index file created successfully${NC}"
+else
+    echo -e "${GREEN}Trash index file exists${NC}"
+    echo -e "${YELLOW}Current trash index file content:${NC}"
+    cat "$TRASH_DIR/trash_index.json"
+fi
+
+echo -e "\n${GREEN}All trash directories and files are ready!${NC}"
@@ -0,0 +1,216 @@
+#!/usr/bin/env python3
+import requests
+import json
+import time
+import sys
+import os
+
+# Configuration
+BASE_URL = "http://localhost:8085/api"
+DEFAULT_USER_ID = "00000000-0000-0000-0000-000000000000"
+DEBUG = True
+
+# Save the current directory
+CURRENT_DIR = os.getcwd()
+
+def log(message):
+    if DEBUG:
+        print(f"[DEBUG] {message}")
+
+def create_test_file():
+    """Create a test file and return its ID"""
+    url = f"{BASE_URL}/files/upload"
+    
+    # Create a unique filename
+    filename = f"test-file-{int(time.time())}.txt"
+    file_content = f"Test content created at {time.time()}"
+    
+    files = {'file': (filename, file_content.encode(), 'text/plain')}
+    log(f"Uploading file: {filename}")
+    
+    response = requests.post(url, files=files)
+    log(f"Upload response: {response.status_code}")
+    
+    if response.status_code in [200, 201]:
+        data = response.json()
+        file_id = data.get('id')
+        log(f"File created with ID: {file_id}")
+        return file_id
+    else:
+        log(f"Failed to create file: {response.text}")
+        return None
+
+def delete_file_to_trash(file_id):
+    """Delete a file (should move to trash)"""
+    url = f"{BASE_URL}/files/{file_id}"
+    log(f"Deleting file: {file_id} (should move to trash)")
+    
+    response = requests.delete(url)
+    log(f"Delete response: {response.status_code}")
+    
+    if response.status_code in [200, 201, 202, 204]:
+        return True
+    else:
+        log(f"Failed to delete file: {response.text}")
+        return False
+
+def list_trash_items():
+    """List all items in the trash"""
+    url = f"{BASE_URL}/trash?userId={DEFAULT_USER_ID}"
+    log("Listing trash items")
+    
+    response = requests.get(url)
+    log(f"List trash response: {response.status_code}")
+    
+    if response.status_code == 200:
+        items = response.json()
+        log(f"Found {len(items)} items in trash")
+        for item in items:
+            print(f"  - {item['name']} (ID: {item['id']}, Original ID: {item['original_id']}, Type: {item['item_type']})")
+        return items
+    else:
+        log(f"Failed to list trash items: {response.text}")
+        return []
+
+def check_trash_structure():
+    """Checks the structure of the trash directory"""
+    print("\n--- Checking Trash Directory Structure ---")
+    
+    # Check storage directory
+    storage_dir = os.path.join(CURRENT_DIR, "storage")
+    if os.path.exists(storage_dir):
+        print(f"Storage directory exists: {storage_dir}")
+    else:
+        print(f"ERROR: Storage directory does not exist: {storage_dir}")
+        return False
+    
+    # Check trash directory
+    trash_dir = os.path.join(storage_dir, ".trash")
+    if os.path.exists(trash_dir):
+        print(f"Trash directory exists: {trash_dir}")
+    else:
+        print(f"ERROR: Trash directory does not exist: {trash_dir}")
+        return False
+    
+    # Check trash files directory
+    trash_files_dir = os.path.join(trash_dir, "files")
+    if os.path.exists(trash_files_dir):
+        print(f"Trash files directory exists: {trash_files_dir}")
+    else:
+        print(f"ERROR: Trash files directory does not exist: {trash_files_dir}")
+        return False
+    
+    # Check trash index file
+    trash_index_path = os.path.join(trash_dir, "trash_index.json")
+    if os.path.exists(trash_index_path):
+        print(f"Trash index file exists: {trash_index_path}")
+        try:
+            with open(trash_index_path, 'r') as f:
+                trash_index = json.load(f)
+                print(f"Trash index contains {len(trash_index)} entries")
+        except Exception as e:
+            print(f"ERROR: Could not read trash index file: {e}")
+            return False
+    else:
+        print(f"ERROR: Trash index file does not exist: {trash_index_path}")
+        return False
+    
+    return True
+
+def check_file_in_trash_fs(file_id):
+    """Checks if a file exists in the trash directory filesystem"""
+    print("\n--- Checking File In Trash Filesystem ---")
+    
+    # Check if the file exists in the trash files directory
+    trash_files_dir = os.path.join(CURRENT_DIR, "storage", ".trash", "files")
+    if os.path.exists(os.path.join(trash_files_dir, file_id)):
+        print(f"File found in trash filesystem: {file_id}")
+        return True
+    else:
+        print(f"File NOT found in trash filesystem: {file_id}")
+        
+        # List all files in the trash directory to help debugging
+        print("\nFiles in trash directory:")
+        try:
+            files = os.listdir(trash_files_dir)
+            if files:
+                for f in files:
+                    print(f"  - {f}")
+            else:
+                print("  (no files)")
+        except Exception as e:
+            print(f"Error listing trash directory: {e}")
+        
+        return False
+
+def dump_trash_index():
+    """Dumps the contents of the trash index file"""
+    trash_index_path = os.path.join(CURRENT_DIR, "storage", ".trash", "trash_index.json")
+    try:
+        with open(trash_index_path, 'r') as f:
+            trash_index = json.load(f)
+            print("\n--- Trash Index Contents ---")
+            print(json.dumps(trash_index, indent=2))
+    except Exception as e:
+        print(f"ERROR: Could not read trash index file: {e}")
+
+def main():
+    print("=== Trash Debug Tool ===")
+    
+    # First check the trash directory structure
+    if not check_trash_structure():
+        print("FAILED: Trash directory structure is not correct")
+        print("Run the check-trash-dirs.sh script to fix it")
+        sys.exit(1)
+    
+    # List current trash contents
+    print("\n--- Current Trash Contents ---")
+    list_trash_items()
+    
+    # Create a test file
+    print("\n1. Creating test file...")
+    file_id = create_test_file()
+    if not file_id:
+        print("FAILED: Could not create test file")
+        sys.exit(1)
+    
+    print(f"Created file with ID: {file_id}")
+    
+    # Delete the file (should move to trash)
+    print("\n2. Deleting file (should move to trash)...")
+    if not delete_file_to_trash(file_id):
+        print("FAILED: Could not delete file")
+        sys.exit(1)
+    
+    print("\n3. Waiting 2 seconds for trash operation to complete...")
+    time.sleep(2)
+    
+    # Check if the file appears in trash
+    print("\n4. Checking trash contents after deletion...")
+    trash_items = list_trash_items()
+    
+    file_in_trash = False
+    for item in trash_items:
+        if item.get('original_id') == file_id:
+            file_in_trash = True
+            break
+    
+    # Check if the file physically exists in the trash directory
+    file_in_trash_fs = check_file_in_trash_fs(file_id)
+    
+    # Dump the trash index file contents
+    dump_trash_index()
+    
+    # Final result
+    if file_in_trash and file_in_trash_fs:
+        print("\nSUCCESS: File was moved to trash correctly")
+    elif file_in_trash:
+        print("\nPARTIAL SUCCESS: File is in trash index but not in trash filesystem")
+    elif file_in_trash_fs:
+        print("\nPARTIAL SUCCESS: File is in trash filesystem but not in trash index")
+    else:
+        print("\nFAILURE: File was not found in trash")
+        print("This indicates the trash feature is not working properly")
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+import requests
+import os
+import json
+
+file_path = "./test-api-file.txt"
+url = "http://localhost:8086/api/files/upload"
+
+# Check file existence
+if not os.path.exists(file_path):
+    print(f"Error: File not found at {file_path}")
+    exit(1)
+
+# Create multipart form
+files = {'file': open(file_path, 'rb')}
+
+# Make request
+try:
+    response = requests.post(url, files=files)
+    print(f"Status Code: {response.status_code}")
+    print("Response Headers:")
+    for key, value in response.headers.items():
+        print(f"{key}: {value}")
+    print("\nResponse Content:")
+    try:
+        data = response.json()
+        print(json.dumps(data, indent=2))
+    except:
+        print(response.text)
+except Exception as e:
+    print(f"Error: {e}")
@@ -0,0 +1,61 @@
+#!/bin/bash
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+NC='\033[0m' # No Color
+
+echo -e "${GREEN}=== OxiCloud Trash Index Fix Script ===${NC}"
+
+# Configuration
+TRASH_INDEX_FILE="./storage/.trash/trash_index.json"
+
+# Check if the trash index file exists
+if [ ! -f "$TRASH_INDEX_FILE" ]; then
+    echo -e "${RED}Trash index file not found at: $TRASH_INDEX_FILE${NC}"
+    exit 1
+fi
+
+# Backup the trash index file
+BACKUP_FILE="${TRASH_INDEX_FILE}.bak"
+cp "$TRASH_INDEX_FILE" "$BACKUP_FILE"
+echo -e "${GREEN}Created backup at: $BACKUP_FILE${NC}"
+
+# Parse and filter out problematic entries
+echo -e "${YELLOW}Analyzing and fixing trash index...${NC}"
+TEMP_FILE=$(mktemp)
+
+# Read the current trash index
+cat "$TRASH_INDEX_FILE" | jq '.' > "$TEMP_FILE"
+
+# Check if there are any entries
+ENTRY_COUNT=$(cat "$TEMP_FILE" | jq 'length')
+echo -e "${YELLOW}Found $ENTRY_COUNT entries in trash index${NC}"
+
+if [ "$ENTRY_COUNT" -eq 0 ]; then
+    echo -e "${GREEN}Trash index is empty, nothing to fix${NC}"
+    rm "$TEMP_FILE"
+    exit 0
+fi
+
+# Problematic IDs (hardcoded based on error messages)
+PROBLEMATIC_IDS=("ee30543b-9268-4fb1-8085-9d140f756187")
+
+# Filter out problematic entries
+for ID in "${PROBLEMATIC_IDS[@]}"; do
+    echo -e "${YELLOW}Removing entries for original_id: $ID${NC}"
+    cat "$TEMP_FILE" | jq "[.[] | select(.original_id != \"$ID\")]" > "${TEMP_FILE}.new"
+    mv "${TEMP_FILE}.new" "$TEMP_FILE"
+done
+
+# Verify the new contents
+NEW_ENTRY_COUNT=$(cat "$TEMP_FILE" | jq 'length')
+echo -e "${GREEN}Trash index now contains $NEW_ENTRY_COUNT entries${NC}"
+
+# Write back the fixed index
+cat "$TEMP_FILE" > "$TRASH_INDEX_FILE"
+rm "$TEMP_FILE"
+
+echo -e "${GREEN}Trash index has been fixed!${NC}"
+echo -e "${YELLOW}Original index was backed up to: $BACKUP_FILE${NC}"
@@ -0,0 +1,47 @@
+#!/bin/bash
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+NC='\033[0m' # No Color
+
+echo -e "${GREEN}=== OxiCloud Trash Feature Debug Script ===${NC}"
+
+# 1. Ensure we have debug logging enabled for the server
+export RUST_LOG=debug
+
+# 2. Build and run the server in the background
+echo -e "${YELLOW}Building and starting the server...${NC}"
+cargo build
+if [ $? -ne 0 ]; then
+    echo -e "${RED}Failed to build the server${NC}"
+    exit 1
+fi
+
+echo -e "${YELLOW}Starting the server with debug logging...${NC}"
+cargo run > server_debug.log 2>&1 &
+SERVER_PID=$!
+
+# Wait for the server to start
+echo -e "${YELLOW}Waiting for the server to start (5 seconds)...${NC}"
+sleep 5
+
+# Verify the server is running
+if ! ps -p $SERVER_PID > /dev/null; then
+    echo -e "${RED}Server failed to start. Check server_debug.log for details.${NC}"
+    exit 1
+fi
+
+echo -e "${GREEN}Server started successfully with PID $SERVER_PID${NC}"
+
+# 3. Run the debug script
+echo -e "${YELLOW}Running the trash debug script...${NC}"
+python3 debug-trash.py
+
+# 4. Shutdown the server
+echo -e "${YELLOW}Shutting down the server...${NC}"
+kill $SERVER_PID
+wait $SERVER_PID 2>/dev/null
+
+echo -e "${GREEN}Debug run completed. Check server_debug.log for server output.${NC}"
@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+import os
+import json
+import uuid
+from pathlib import Path
+
+def ensure_directory(path):
+    if isinstance(path, str):
+        path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+def create_test_file(path, content="This is a test file content"):
+    # Make sure parent directories exist
+    ensure_directory(path)
+    
+    with open(path, 'w') as f:
+        f.write(content)
+    print(f"Created test file: {path}")
+
+def update_id_mapping(file_path, storage_path):
+    # Create a mapping file to simulate what the server would do
+    file_ids_path = "/home/torrefacto/OxiCloud/storage/file_ids.json"
+    folder_ids_path = "/home/torrefacto/OxiCloud/storage/folder_ids.json"
+    
+    # Make sure directory exists
+    ensure_directory(Path(file_ids_path).parent)
+    
+    # Generate a UUID for the file
+    file_id = str(uuid.uuid4())
+    
+    # Load existing file mapping if it exists
+    file_mapping = {"path_to_id": {}, "id_to_path": {}, "version": 1}
+    if os.path.exists(file_ids_path):
+        try:
+            with open(file_ids_path, 'r') as f:
+                file_mapping = json.load(f)
+        except json.JSONDecodeError:
+            print(f"Warning: Could not parse {file_ids_path}, creating new mapping")
+    
+    # Add the new mapping
+    file_mapping["path_to_id"][storage_path] = file_id
+    file_mapping["id_to_path"][file_id] = storage_path
+    file_mapping["version"] += 1
+    
+    # Save the updated mapping
+    with open(file_ids_path, 'w') as f:
+        json.dump(file_mapping, f, indent=2, sort_keys=True)
+    
+    print(f"Updated file ID mapping: {storage_path} -> {file_id}")
+    
+    # Check folder mapping too and update it for parent folders
+    folder_mapping = {"path_to_id": {}, "id_to_path": {}, "version": 1}
+    if os.path.exists(folder_ids_path):
+        try:
+            with open(folder_ids_path, 'r') as f:
+                folder_mapping = json.load(f)
+        except json.JSONDecodeError:
+            print(f"Warning: Could not parse {folder_ids_path}, creating new mapping")
+    
+    # Get parent folders and add them to the mapping
+    storage_path_parts = storage_path.split('/')
+    if len(storage_path_parts) > 1:  # Has parent folder(s)
+        current_path = ""
+        for i in range(len(storage_path_parts) - 1):  # All but the last part (file name)
+            if i > 0:
+                current_path += "/"
+            current_path += storage_path_parts[i]
+            
+            # Check if folder already has an ID
+            if current_path not in folder_mapping["path_to_id"]:
+                folder_id = str(uuid.uuid4())
+                folder_mapping["path_to_id"][current_path] = folder_id
+                folder_mapping["id_to_path"][folder_id] = current_path
+                print(f"Added folder mapping: {current_path} -> {folder_id}")
+    
+    # Save the folder mapping
+    folder_mapping["version"] += 1
+    with open(folder_ids_path, 'w') as f:
+        json.dump(folder_mapping, f, indent=2, sort_keys=True)
+        
+    print(f"Folder mapping now has {len(folder_mapping['path_to_id'])} entries")
+    
+    return file_id
+
+def main():
+    # Create multiple test files in different folders
+    test_files = [
+        # Basic file in root
+        ("/home/torrefacto/OxiCloud/storage/test-simulation-file.txt", "test-simulation-file.txt"),
+        
+        # File in a subfolder
+        ("/home/torrefacto/OxiCloud/storage/documents/important-doc.txt", "documents/important-doc.txt"),
+        
+        # File in a deeper subfolder
+        ("/home/torrefacto/OxiCloud/storage/projects/2023/notes.txt", "projects/2023/notes.txt"),
+        
+        # File with spaces in name
+        ("/home/torrefacto/OxiCloud/storage/My Documents/report with spaces.pdf", "My Documents/report with spaces.pdf")
+    ]
+    
+    # Create and map each file
+    for file_path, storage_path in test_files:
+        create_test_file(file_path)
+        file_id = update_id_mapping(file_path, storage_path)
+        print(f"Created file with ID: {file_id}")
+    
+    print(f"Simulation complete. Created {len(test_files)} files with proper ID mappings.")
+    print(f"You can now test accessing these files through the web interface using their IDs.")
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+import requests
+import time
+
+def test_route(url, method="GET", data=None, files=None):
+    """Test a route and return the response"""
+    print(f"Testing {method} {url}")
+    try:
+        if method == "GET":
+            response = requests.get(url)
+        elif method == "POST":
+            response = requests.post(url, data=data, files=files)
+        elif method == "PUT":
+            response = requests.put(url, json=data)
+        elif method == "DELETE":
+            response = requests.delete(url)
+        else:
+            print(f"Unsupported method: {method}")
+            return None
+        
+        print(f"  Status: {response.status_code}")
+        if response.status_code < 400:
+            content_type = response.headers.get('Content-Type', '')
+            if 'json' in content_type:
+                try:
+                    print(f"  Response: {response.json()}")
+                except:
+                    print(f"  Response: {response.text[:100]}...")
+            else:
+                print(f"  Response: {response.text[:100]}...")
+        else:
+            print(f"  Error: {response.text}")
+        
+        return response
+    except Exception as e:
+        print(f"  Error: {e}")
+        return None
+
+# Base URL
+SERVER_URL = "http://localhost:8086"
+
+print("Testing all routes to identify which ones are implemented in the custom server")
+print("================================================================================")
+
+# Test routes
+routes = [
+    # Base
+    "/",
+    
+    # API endpoints
+    "/api/folders",
+    "/api/files",
+    "/api/files?folder_id=folder-storage:1",
+    "/api/files/upload",
+    
+    # Static files
+    "/css/style.css",
+    "/js/app.js",
+    "/locales/en.json",
+    
+    # Auth routes
+    "/login",
+    "/api/auth/login",
+]
+
+# Run GET tests
+for route in routes:
+    if route == "/api/files/upload":
+        continue  # Skip for now, will test POST later
+    test_route(f"{SERVER_URL}{route}")
+    time.sleep(0.5)  # Small delay between requests
+
+# Test POST upload
+print("\nTesting file upload...")
+with open(__file__, "rb") as f:  # Use __file__ to reference the current script regardless of location
+    files = {"file": f}
+    data = {"folder_id": "folder-storage:1"}
+    test_route(f"{SERVER_URL}/api/files/upload", method="POST", data=data, files=files)
+
+print("\nTests completed")
@@ -0,0 +1 @@
+This is a test file for OxiCloud API
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+import requests
+import os
+import time
+import json
+
+print("Testing API integration with OxiCloud API...")
+
+SERVER_URL = "http://localhost:8086"
+TEST_FILE = "api-test-file.txt"
+
+# Create a test file
+with open(TEST_FILE, "w") as f:
+    f.write("This is a test file for API integration testing\n")
+    f.write("We'll check if the ID mapping system works correctly\n")
+    f.write("The file should be retrievable after upload\n")
+
+print(f"Created test file: {TEST_FILE}")
+
+try:
+    # 1. Upload file
+    print("\n1. Uploading file...")
+    files = {'file': open(TEST_FILE, 'rb')}
+    data = {'folder_id': 'folder-storage:1'}
+    
+    upload_response = requests.post(f"{SERVER_URL}/api/files/upload", files=files, data=data)
+    files['file'].close()
+    
+    print(f"Upload status: {upload_response.status_code}")
+    
+    if upload_response.status_code == 201:
+        upload_data = upload_response.json()
+        file_id = upload_data.get('id')
+        file_name = upload_data.get('name')
+        
+        print(f"File uploaded successfully with ID: {file_id}")
+        print(f"Response data: {json.dumps(upload_data, indent=2)}")
+        
+        # 2. List files to see if our file appears
+        print("\n2. Listing files...")
+        time.sleep(1)  # Small delay to allow server processing
+        
+        list_response = requests.get(f"{SERVER_URL}/api/files?folder_id=folder-storage:1")
+        print(f"List files status: {list_response.status_code}")
+        
+        if list_response.status_code == 200:
+            files_list = list_response.json()
+            print(f"Found {len(files_list)} files")
+            
+            # Look for our file
+            found = False
+            for file in files_list:
+                if file.get('id') == file_id:
+                    found = True
+                    print(f"Found our file in the list! ID: {file.get('id')}, Name: {file.get('name')}")
+                    print(f"File details: {json.dumps(file, indent=2)}")
+            
+            if not found:
+                print(f"ERROR: Our file with ID {file_id} was not found in the list")
+                print(f"Files in list: {json.dumps(files_list, indent=2)}")
+        else:
+            print(f"Error listing files: {list_response.text}")
+        
+        # 3. Try to download the file
+        print("\n3. Downloading file...")
+        download_response = requests.get(f"{SERVER_URL}/api/files/{file_id}")
+        print(f"Download status: {download_response.status_code}")
+        
+        if download_response.status_code == 200:
+            print("File downloaded successfully")
+            print(f"Downloaded content length: {len(download_response.content)} bytes")
+            print(f"Content preview: {download_response.content[:50]}...")
+        else:
+            print(f"Error downloading file: {download_response.text}")
+        
+    else:
+        print(f"Upload failed: {upload_response.text}")
+
+except Exception as e:
+    print(f"Error during test: {e}")
+
+# Clean up
+if os.path.exists(TEST_FILE):
+    os.remove(TEST_FILE)
+    print(f"\nRemoved test file: {TEST_FILE}")
+
+print("\nAPI integration test completed.")
@@ -0,0 +1,121 @@
+#!/bin/bash
+
+# Set the server URL
+SERVER_URL="http://localhost:8086"
+
+# Display help
+function show_help {
+    echo "OxiCloud API Testing Script"
+    echo "Usage: $0 [options]"
+    echo "Options:"
+    echo "  -h, --help     Show this help"
+    echo "  --list         List files in a folder (use --folder <folder_id> or root if not specified)"
+    echo "  --upload       Upload a file (requires --file and optionally --folder)"
+    echo "  --download     Download a file (requires --id)"
+    echo "  --file <path>  Path to file for upload"
+    echo "  --folder <id>  Folder ID (for upload or list operations)"
+    echo "  --id <id>      File ID for download operation"
+}
+
+# Parse arguments
+OPERATION=""
+FILE_PATH=""
+FOLDER_ID=""
+FILE_ID=""
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -h|--help)
+            show_help
+            exit 0
+            ;;
+        --list)
+            OPERATION="list"
+            shift
+            ;;
+        --upload)
+            OPERATION="upload"
+            shift
+            ;;
+        --download)
+            OPERATION="download"
+            shift
+            ;;
+        --file)
+            FILE_PATH="$2"
+            shift 2
+            ;;
+        --folder)
+            FOLDER_ID="$2"
+            shift 2
+            ;;
+        --id)
+            FILE_ID="$2"
+            shift 2
+            ;;
+        *)
+            echo "Unknown option: $1"
+            show_help
+            exit 1
+            ;;
+    esac
+done
+
+# Validate arguments
+if [[ -z "$OPERATION" ]]; then
+    echo "Error: No operation specified."
+    show_help
+    exit 1
+fi
+
+# Execute requested operation
+case $OPERATION in
+    "list")
+        echo "Listing files..."
+        if [[ -n "$FOLDER_ID" ]]; then
+            echo "Folder ID: $FOLDER_ID"
+            curl -s "$SERVER_URL/api/files?folder_id=$FOLDER_ID" | jq .
+        else
+            echo "Root folder"
+            curl -s "$SERVER_URL/api/files" | jq .
+        fi
+        ;;
+    "upload")
+        if [[ -z "$FILE_PATH" ]]; then
+            echo "Error: File path required for upload."
+            exit 1
+        fi
+        
+        if [[ ! -f "$FILE_PATH" ]]; then
+            echo "Error: File not found: $FILE_PATH"
+            exit 1
+        fi
+        
+        echo "Uploading file: $FILE_PATH"
+        if [[ -n "$FOLDER_ID" ]]; then
+            echo "To folder: $FOLDER_ID"
+            curl -s -X POST \
+                -F "file=@$FILE_PATH" \
+                -F "folder_id=$FOLDER_ID" \
+                "$SERVER_URL/api/files/upload" | jq .
+        else
+            echo "To root folder"
+            curl -s -X POST \
+                -F "file=@$FILE_PATH" \
+                "$SERVER_URL/api/files/upload" | jq .
+        fi
+        ;;
+    "download")
+        if [[ -z "$FILE_ID" ]]; then
+            echo "Error: File ID required for download."
+            exit 1
+        fi
+        
+        echo "Downloading file: $FILE_ID"
+        FILENAME=$(basename "$FILE_ID")
+        curl -s -o "$FILENAME" "$SERVER_URL/api/files/$FILE_ID"
+        echo "Downloaded to: $FILENAME"
+        ;;
+esac
+
+echo "Operation completed."
@@ -0,0 +1,262 @@
+#!/bin/bash
+set -e
+
+# Colors for prettier output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+BASE_URL="http://localhost:8085/api/auth"
+TOKEN_FILE=".auth_tokens.json"
+USER_ID=""
+
+echo -e "${BLUE}=== OxiCloud Authentication Test Script ===${NC}"
+echo -e "${BLUE}This script will test the authentication endpoints${NC}"
+echo
+
+cleanup() {
+  echo -e "\n${BLUE}Cleaning up test files...${NC}"
+  rm -f "$TOKEN_FILE"
+  echo "Done."
+}
+
+trap cleanup EXIT
+
+# Function to check if server is running
+check_server() {
+  echo -e "${BLUE}Checking if OxiCloud server is running...${NC}"
+  if ! curl -s "http://localhost:8085/api/health" > /dev/null; then
+    echo -e "${RED}Error: Server is not running. Please start the server first with 'cargo run'${NC}"
+    exit 1
+  fi
+  echo -e "${GREEN}Server is running!${NC}"
+}
+
+# 1. Test registration
+test_registration() {
+  echo -e "\n${BLUE}1. Testing user registration...${NC}"
+  
+  USERNAME="testuser"
+  EMAIL="test@example.com"
+  PASSWORD="Test123!"
+  
+  RESPONSE=$(curl -s -X POST "$BASE_URL/register" \
+    -H "Content-Type: application/json" \
+    -d "{\"username\":\"$USERNAME\",\"email\":\"$EMAIL\",\"password\":\"$PASSWORD\"}")
+  
+  # Check if registration was successful
+  if [[ "$RESPONSE" == *"userId"* ]]; then
+    echo -e "${GREEN}✓ Registration successful${NC}"
+    USER_ID=$(echo $RESPONSE | jq -r '.userId')
+    echo "User created with ID: $USER_ID"
+  else
+    echo -e "${RED}✗ Registration failed${NC}"
+    echo "$RESPONSE"
+    exit 1
+  fi
+}
+
+# 2. Test login
+test_login() {
+  echo -e "\n${BLUE}2. Testing user login...${NC}"
+  
+  USERNAME="testuser"
+  PASSWORD="Test123!"
+  
+  RESPONSE=$(curl -s -X POST "$BASE_URL/login" \
+    -H "Content-Type: application/json" \
+    -d "{\"username\":\"$USERNAME\",\"password\":\"$PASSWORD\"}")
+  
+  # Check if login was successful
+  if [[ "$RESPONSE" == *"accessToken"* ]]; then
+    echo -e "${GREEN}✓ Login successful${NC}"
+    # Save tokens to file for future requests
+    echo "$RESPONSE" > "$TOKEN_FILE"
+    # Extract token for logging
+    ACCESS_TOKEN=$(echo "$RESPONSE" | jq -r '.accessToken')
+    echo "Access token: ${ACCESS_TOKEN:0:20}...${ACCESS_TOKEN: -10}"
+  else
+    echo -e "${RED}✗ Login failed${NC}"
+    echo "$RESPONSE"
+    exit 1
+  fi
+}
+
+# 3. Test getting current user
+test_get_user() {
+  echo -e "\n${BLUE}3. Testing get current user...${NC}"
+  
+  if [ ! -f "$TOKEN_FILE" ]; then
+    echo -e "${RED}✗ No authentication token found. Login first.${NC}"
+    exit 1
+  fi
+  
+  ACCESS_TOKEN=$(jq -r '.accessToken' "$TOKEN_FILE")
+  
+  RESPONSE=$(curl -s -X GET "$BASE_URL/me" \
+    -H "Authorization: Bearer $ACCESS_TOKEN")
+  
+  # Check if getting user was successful
+  if [[ "$RESPONSE" == *"username"* ]]; then
+    echo -e "${GREEN}✓ Got user details successfully${NC}"
+    echo "Username: $(echo "$RESPONSE" | jq -r '.username')"
+    echo "Email: $(echo "$RESPONSE" | jq -r '.email')"
+    echo "Role: $(echo "$RESPONSE" | jq -r '.role')"
+  else
+    echo -e "${RED}✗ Getting user details failed${NC}"
+    echo "$RESPONSE"
+    exit 1
+  fi
+}
+
+# 4. Test token refresh
+test_refresh_token() {
+  echo -e "\n${BLUE}4. Testing token refresh...${NC}"
+  
+  if [ ! -f "$TOKEN_FILE" ]; then
+    echo -e "${RED}✗ No authentication token found. Login first.${NC}"
+    exit 1
+  fi
+  
+  REFRESH_TOKEN=$(jq -r '.refreshToken' "$TOKEN_FILE")
+  
+  RESPONSE=$(curl -s -X POST "$BASE_URL/refresh" \
+    -H "Content-Type: application/json" \
+    -d "{\"refreshToken\":\"$REFRESH_TOKEN\"}")
+  
+  # Check if refresh was successful
+  if [[ "$RESPONSE" == *"accessToken"* ]]; then
+    echo -e "${GREEN}✓ Token refresh successful${NC}"
+    # Update tokens
+    echo "$RESPONSE" > "$TOKEN_FILE"
+    ACCESS_TOKEN=$(echo "$RESPONSE" | jq -r '.accessToken')
+    echo "New access token: ${ACCESS_TOKEN:0:20}...${ACCESS_TOKEN: -10}"
+  else
+    echo -e "${RED}✗ Token refresh failed${NC}"
+    echo "$RESPONSE"
+    exit 1
+  fi
+}
+
+# 5. Test change password
+test_change_password() {
+  echo -e "\n${BLUE}5. Testing password change...${NC}"
+  
+  if [ ! -f "$TOKEN_FILE" ]; then
+    echo -e "${RED}✗ No authentication token found. Login first.${NC}"
+    exit 1
+  fi
+  
+  ACCESS_TOKEN=$(jq -r '.accessToken' "$TOKEN_FILE")
+  OLD_PASSWORD="Test123!"
+  NEW_PASSWORD="NewTest456!"
+  
+  RESPONSE=$(curl -s -X PUT "$BASE_URL/change-password" \
+    -H "Content-Type: application/json" \
+    -H "Authorization: Bearer $ACCESS_TOKEN" \
+    -d "{\"oldPassword\":\"$OLD_PASSWORD\",\"newPassword\":\"$NEW_PASSWORD\"}")
+  
+  # Check response code
+  if [ -z "$RESPONSE" ]; then
+    echo -e "${GREEN}✓ Password changed successfully${NC}"
+    
+    # Test login with new password
+    echo -e "${BLUE}   Testing login with new password...${NC}"
+    LOGIN_RESPONSE=$(curl -s -X POST "$BASE_URL/login" \
+      -H "Content-Type: application/json" \
+      -d "{\"username\":\"testuser\",\"password\":\"$NEW_PASSWORD\"}")
+    
+    if [[ "$LOGIN_RESPONSE" == *"accessToken"* ]]; then
+      echo -e "${GREEN}   ✓ Login with new password successful${NC}"
+      echo "$LOGIN_RESPONSE" > "$TOKEN_FILE"
+    else
+      echo -e "${RED}   ✗ Login with new password failed${NC}"
+      echo "$LOGIN_RESPONSE"
+    fi
+  else
+    echo -e "${RED}✗ Password change failed${NC}"
+    echo "$RESPONSE"
+  fi
+}
+
+# 6. Test logout
+test_logout() {
+  echo -e "\n${BLUE}6. Testing logout...${NC}"
+  
+  if [ ! -f "$TOKEN_FILE" ]; then
+    echo -e "${RED}✗ No authentication token found. Login first.${NC}"
+    exit 1
+  fi
+  
+  ACCESS_TOKEN=$(jq -r '.accessToken' "$TOKEN_FILE")
+  REFRESH_TOKEN=$(jq -r '.refreshToken' "$TOKEN_FILE")
+  
+  RESPONSE=$(curl -s -X POST "$BASE_URL/logout" \
+    -H "Authorization: Bearer $REFRESH_TOKEN")
+  
+  # Check response
+  if [ -z "$RESPONSE" ]; then
+    echo -e "${GREEN}✓ Logout successful${NC}"
+    
+    # Verify token is invalidated by trying to use it
+    echo -e "${BLUE}   Verifying token invalidation...${NC}"
+    VERIFY_RESPONSE=$(curl -s -X GET "$BASE_URL/me" \
+      -H "Authorization: Bearer $ACCESS_TOKEN")
+    
+    if [[ "$VERIFY_RESPONSE" == *"error"* ]]; then
+      echo -e "${GREEN}   ✓ Token successfully invalidated${NC}"
+    else
+      echo -e "${RED}   ✗ Token still valid after logout${NC}"
+      echo "$VERIFY_RESPONSE"
+    fi
+  else
+    echo -e "${RED}✗ Logout failed${NC}"
+    echo "$RESPONSE"
+  fi
+}
+
+# 7. Test protected resource access
+test_protected_resource() {
+  echo -e "\n${BLUE}7. Testing protected resource access...${NC}"
+  
+  # Login first to get a fresh token
+  USERNAME="testuser"
+  PASSWORD="NewTest456!"  # Use the new password
+  
+  LOGIN_RESPONSE=$(curl -s -X POST "$BASE_URL/login" \
+    -H "Content-Type: application/json" \
+    -d "{\"username\":\"$USERNAME\",\"password\":\"$PASSWORD\"}")
+  
+  if [[ "$LOGIN_RESPONSE" == *"accessToken"* ]]; then
+    echo "$LOGIN_RESPONSE" > "$TOKEN_FILE"
+    ACCESS_TOKEN=$(jq -r '.accessToken' "$TOKEN_FILE")
+    
+    echo -e "${BLUE}   Accessing a protected resource (folders list)...${NC}"
+    RESOURCE_RESPONSE=$(curl -s -X GET "http://localhost:8085/api/folders" \
+      -H "Authorization: Bearer $ACCESS_TOKEN")
+    
+    if [[ "$RESOURCE_RESPONSE" != *"error"* ]]; then
+      echo -e "${GREEN}   ✓ Successfully accessed protected resource${NC}"
+    else
+      echo -e "${RED}   ✗ Failed to access protected resource${NC}"
+      echo "$RESOURCE_RESPONSE"
+    fi
+  else
+    echo -e "${RED}✗ Login for resource test failed${NC}"
+    echo "$LOGIN_RESPONSE"
+  fi
+}
+
+# Main test execution
+check_server
+test_registration
+test_login
+test_get_user
+test_refresh_token
+test_change_password
+test_logout
+test_protected_resource
+
+echo -e "\n${GREEN}All authentication tests completed successfully!${NC}"
+echo -e "${BLUE}Your authentication system appears to be working correctly.${NC}"
@@ -0,0 +1,10 @@
+#!/bin/bash
+# Environment variables for OxiCloud authentication testing
+export OXICLOUD_ENABLE_AUTH=true
+export OXICLOUD_JWT_SECRET="testing-secret-key-for-development-only"
+export OXICLOUD_ACCESS_TOKEN_EXPIRY_SECS=3600
+export OXICLOUD_REFRESH_TOKEN_EXPIRY_SECS=86400
+export OXICLOUD_DB_CONNECTION_STRING="postgres://postgres:postgres@localhost/oxicloud"
+
+# Run with: source test-auth-env.sh && cargo run
+echo "Authentication environment variables set. Run 'cargo run' to start OxiCloud with auth enabled."
@@ -0,0 +1,47 @@
+#!/bin/bash
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+NC='\033[0m' # No Color
+
+echo -e "${GREEN}=== OxiCloud Trash Feature Compilation Test ===${NC}"
+
+# Set working directory
+cd /home/torrefacto/OxiCloud
+
+# 1. Check if storage and trash directories exist
+echo -e "${YELLOW}Checking trash directories...${NC}"
+./check-trash-dirs.sh
+
+# 2. Build the project to verify our changes
+echo -e "\n${YELLOW}Building project to verify changes...${NC}"
+cargo build
+
+if [ $? -ne 0 ]; then
+    echo -e "${RED}Build failed, please check the errors above${NC}"
+    exit 1
+fi
+
+echo -e "${GREEN}Build successful!${NC}"
+
+# 3. Run a simple test to verify that the trash feature works
+echo -e "\n${YELLOW}Running trash feature test...${NC}"
+RUST_LOG=debug cargo run &
+SERVER_PID=$!
+
+# Wait for the server to start
+echo -e "${YELLOW}Waiting for the server to start (5 seconds)...${NC}"
+sleep 5
+
+# Run our debug script
+echo -e "${YELLOW}Running trash debug script...${NC}"
+python3 debug-trash.py
+
+# Shutdown the server
+echo -e "${YELLOW}Shutting down the server...${NC}"
+kill $SERVER_PID
+wait $SERVER_PID 2>/dev/null
+
+echo -e "${GREEN}Test completed!${NC}"
@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Define JSON data (respetando el formato exacto)
+JSON_DATA='{"name":"test_api_folder_new","parent_id":null}'
+CONTENT_LENGTH=$(echo -n "$JSON_DATA" | wc -c)
+
+# Crear carpeta mediante API
+echo "Creando carpeta 'test_api_folder_new'..."
+(echo -e "POST /api/folders HTTP/1.1\r
+Host: localhost\r
+Content-Type: application/json\r
+Content-Length: $CONTENT_LENGTH\r
+Connection: close\r
+\r
+$JSON_DATA" | nc localhost 8085) > /tmp/folder_response.txt
+
+cat /tmp/folder_response.txt
+echo ""
+
+# Verificar si la carpeta se creó
+sleep 1
+echo "Verificando directorio..."
+ls -la /home/torrefacto/OxiCloud/storage/
@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+import requests
+import json
+import os
+import time
+
+# Configuration
+BASE_URL = "http://localhost:8086/api"
+DEFAULT_USER_ID = "00000000-0000-0000-0000-000000000000"
+
+# Create a test file and get its ID
+def create_test_file():
+    # Create temp file
+    filename = f"test-file-{int(time.time())}.txt"
+    with open(filename, 'w') as f:
+        f.write(f"Test content {time.time()}")
+    
+    # Upload file
+    files = {'file': open(filename, 'rb')}
+    response = requests.post(f"{BASE_URL}/files/upload?userId={DEFAULT_USER_ID}", files=files)
+    
+    # Clean up
+    os.remove(filename)
+    
+    if response.status_code in [200, 201, 202]:
+        data = response.json()
+        file_id = data.get('id')
+        print(f"Created file with ID: {file_id}")
+        return file_id
+    else:
+        print(f"Failed to create test file: {response.status_code} - {response.text}")
+        return None
+
+# Delete the file
+def delete_file(file_id):
+    print(f"Deleting file with ID: {file_id}")
+    
+    # Delete the file
+    response = requests.delete(f"{BASE_URL}/files/{file_id}?userId={DEFAULT_USER_ID}")
+    
+    if response.status_code in [200, 201, 202, 204]:
+        print(f"File deleted successfully with status code: {response.status_code}")
+        return True
+    else:
+        print(f"Failed to delete file: {response.status_code} - {response.text}")
+        return False
+
+# List items in trash
+def list_trash():
+    print("Listing trash items...")
+    
+    response = requests.get(f"{BASE_URL}/trash?userId={DEFAULT_USER_ID}")
+    
+    if response.status_code in [200, 201]:
+        items = response.json()
+        print(f"Found {len(items)} items in trash:")
+        for item in items:
+            print(f"- {item['id']} ({item['item_type']}): {item['name']} (original ID: {item['original_id']})")
+        return items
+    else:
+        print(f"Failed to list trash: {response.status_code} - {response.text}")
+        return []
+
+def main():
+    # Create a test file
+    file_id = create_test_file()
+    if not file_id:
+        print("Could not create test file")
+        return
+    
+    # Delete the file
+    if not delete_file(file_id):
+        print("Could not delete file")
+        return
+    
+    # Wait for trash operation to complete
+    print("Waiting 2 seconds for trash operation to complete...")
+    time.sleep(2)
+    
+    # List trash items
+    trash_items = list_trash()
+    
+    # Check if file is in trash
+    file_in_trash = next((item for item in trash_items if item['original_id'] == file_id), None)
+    
+    if file_in_trash:
+        print(f"File found in trash with trash ID: {file_in_trash['id']}")
+    else:
+        print(f"File not found in trash! Debug the trash implementation.")
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,19 @@
+#!/bin/bash
+
+# Crear la carpeta directamente
+echo "Creando carpeta de prueba directamente..."
+mkdir -p /home/torrefacto/OxiCloud/storage/prueba123
+
+# Verificar las carpetas
+echo "Verificando carpetas existentes..."
+ls -la /home/torrefacto/OxiCloud/storage/
+
+# Reiniciar el servidor
+echo "Reiniciando el servidor..."
+pkill -9 -f "oxicloud"
+sleep 2
+cd /home/torrefacto/OxiCloud && cargo run > /tmp/oxicloud.log 2>&1 &
+sleep 3
+
+# Comprobación de interfaz web
+echo "Reinicio completado. Intenta ahora en tu navegador crear una carpeta y ver si aparece."
@@ -0,0 +1,48 @@
+// Función para crear carpeta
+async function createFolder() {
+    try {
+        const response = await fetch('http://localhost:8085/api/folders', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                name: 'test_folder_js',
+                parent_id: null
+            })
+        });
+        
+        const data = await response.json();
+        console.log('Respuesta de creación de carpeta:', data);
+        
+        return data;
+    } catch (error) {
+        console.error('Error al crear carpeta:', error);
+        return null;
+    }
+}
+
+// Función para listar carpetas
+async function listFolders() {
+    try {
+        const response = await fetch('http://localhost:8085/api/folders');
+        const data = await response.json();
+        console.log('Listado de carpetas:', data);
+        
+        return data;
+    } catch (error) {
+        console.error('Error al listar carpetas:', error);
+        return [];
+    }
+}
+
+// Ejecutar las funciones
+async function runTest() {
+    console.log('Creando carpeta nueva...');
+    await createFolder();
+    
+    console.log('Listando carpetas...');
+    await listFolders();
+}
+
+runTest();
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+# Crear una carpeta nueva
+echo "Creando carpeta nueva..."
+curl -v -X POST -H "Content-Type: application/json" -d '{"name":"test_folder_script","parent_id":null}' http://localhost:8085/api/folders
+
+# Listar las carpetas
+echo -e "\nListando carpetas..."
+curl -v http://localhost:8085/api/folders
@@ -0,0 +1,181 @@
+#!/usr/bin/env python3
+import requests
+import json
+import os
+import time
+import random
+import string
+
+# Configuration
+BASE_URL = "http://localhost:8086/api"
+DEFAULT_USER_ID = "00000000-0000-0000-0000-000000000000"
+
+def create_test_file():
+    """Create a test file and upload it"""
+    print("Creating test file...")
+    
+    # Create temp file
+    filename = f"test-file-{int(time.time())}.txt"
+    with open(filename, 'w') as f:
+        f.write(f"Test content {time.time()}")
+    
+    # Upload file
+    files = {'file': open(filename, 'rb')}
+    response = requests.post(f"{BASE_URL}/files/upload?userId={DEFAULT_USER_ID}", files=files)
+    
+    # Clean up
+    os.remove(filename)
+    
+    if response.status_code in [200, 201]:
+        # The response is already a file object with ID
+        data = response.json()
+        file_id = data.get('id')
+        print(f"Created file with ID: {file_id}")
+        return file_id
+    else:
+        print(f"Failed to create test file: {response.status_code} - {response.text}")
+        return None
+
+def create_test_folder():
+    """Create a test folder"""
+    print("Creating test folder...")
+    
+    folder_name = f"test-folder-{int(time.time())}"
+    payload = {
+        "name": folder_name
+    }
+    
+    response = requests.post(f"{BASE_URL}/folders?userId={DEFAULT_USER_ID}", json=payload)
+    
+    if response.status_code in [200, 201]:
+        # The response is a folder object with ID
+        data = response.json()
+        folder_id = data.get('id')
+        print(f"Created folder with ID: {folder_id}")
+        return folder_id
+    else:
+        print(f"Failed to create test folder: {response.status_code} - {response.text}")
+        return None
+
+def move_to_trash(item_id, item_type):
+    """Move an item to trash"""
+    print(f"Moving {item_type} {item_id} to trash...")
+    
+    if item_type == 'file':
+        url = f"{BASE_URL}/files/{item_id}?userId={DEFAULT_USER_ID}"
+    else:
+        url = f"{BASE_URL}/folders/{item_id}?userId={DEFAULT_USER_ID}"
+    
+    response = requests.delete(url)
+    
+    if response.status_code in [200, 201, 202, 204]:
+        print(f"Successfully moved {item_type} to trash")
+        return True
+    else:
+        print(f"Failed to move {item_type} to trash: {response.status_code} - {response.text}")
+        return False
+
+def list_trash():
+    """List all items in trash"""
+    print("Listing trash items...")
+    
+    response = requests.get(f"{BASE_URL}/trash?userId={DEFAULT_USER_ID}")
+    
+    if response.status_code in [200, 201]:
+        items = response.json()
+        print(f"Found {len(items)} items in trash:")
+        for item in items:
+            print(f"- {item['id']} ({item['item_type']}): {item['name']} (original ID: {item['original_id']})")
+        return items
+    else:
+        print(f"Failed to list trash: {response.status_code} - {response.text}")
+        return []
+
+def restore_from_trash(trash_id):
+    """Restore an item from trash"""
+    print(f"Restoring item {trash_id} from trash...")
+    
+    response = requests.post(f"{BASE_URL}/trash/{trash_id}/restore?userId={DEFAULT_USER_ID}", json={})
+    
+    if response.status_code in [200, 201, 202, 204]:
+        print("Successfully restored item from trash")
+        return True
+    else:
+        print(f"Failed to restore item: {response.status_code} - {response.text}")
+        return False
+
+def delete_permanently(trash_id):
+    """Delete an item permanently"""
+    print(f"Permanently deleting item {trash_id}...")
+    
+    response = requests.delete(f"{BASE_URL}/trash/{trash_id}?userId={DEFAULT_USER_ID}")
+    
+    if response.status_code in [200, 201, 202, 204]:
+        print("Successfully deleted item permanently")
+        return True
+    else:
+        print(f"Failed to delete item: {response.status_code} - {response.text}")
+        return False
+
+def main():
+    """Main test function"""
+    print("=== Starting Trash API Tests ===")
+    
+    # Create test file
+    file_id = create_test_file()
+    if not file_id:
+        print("Test failed: Could not create test file")
+        return
+    
+    # Move file to trash
+    if not move_to_trash(file_id, 'file'):
+        print("Test failed: Could not move file to trash")
+        return
+    
+    # Wait a moment for the trash operation to complete
+    print("Waiting 5 seconds for trash operation to complete...")
+    time.sleep(5)
+    
+    # List trash items
+    trash_items = list_trash()
+    
+    # Find our file in trash
+    file_trash_item = next((item for item in trash_items if item['original_id'] == file_id and item['item_type'] == 'file'), None)
+    if not file_trash_item:
+        print("Test failed: File not found in trash")
+        return
+    
+    # Restore file from trash
+    if not restore_from_trash(file_trash_item['id']):
+        print("Test failed: Could not restore file from trash")
+        return
+    
+    # Create test folder
+    folder_id = create_test_folder()
+    if not folder_id:
+        print("Test failed: Could not create test folder")
+        return
+    
+    # Move folder to trash
+    if not move_to_trash(folder_id, 'folder'):
+        print("Test failed: Could not move folder to trash")
+        return
+    
+    # List trash items again
+    trash_items = list_trash()
+    
+    # Find our folder in trash
+    folder_trash_item = next((item for item in trash_items if item['original_id'] == folder_id and item['item_type'] == 'folder'), None)
+    if not folder_trash_item:
+        print("Test failed: Folder not found in trash")
+        return
+    
+    # Delete folder permanently
+    if not delete_permanently(folder_trash_item['id']):
+        print("Test failed: Could not delete folder permanently")
+        return
+    
+    print("=== All Trash API Tests Passed! ===")
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,325 @@
+#!/usr/bin/env python3
+import requests
+import json
+import time
+import uuid
+import sys
+import os
+
+# Configuration
+BASE_URL = "http://localhost:8085/api"
+DEBUG = True
+
+# Functions for testing
+def log(message):
+    if DEBUG:
+        print(f"[DEBUG] {message}")
+
+def get_auth_token():
+    """Get authentication token for testing"""
+    auth_url = f"{BASE_URL}/auth/login"
+    payload = {
+        "username": "test",
+        "password": "test123"
+    }
+    
+    response = requests.post(auth_url, json=payload)
+    if response.status_code != 200:
+        print(f"Failed to get auth token: {response.text}")
+        sys.exit(1)
+    
+    return response.json()["token"]
+
+def create_test_file(token, folder_id=None):
+    """Create a test file and return its ID"""
+    url = f"{BASE_URL}/files/upload"
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    # Generate unique filename
+    filename = f"test-file-{uuid.uuid4()}.txt"
+    
+    # Create test file content
+    file_content = f"This is a test file content for trash testing: {uuid.uuid4()}"
+    
+    files = {
+        'file': (filename, file_content.encode(), 'text/plain')
+    }
+    
+    data = {}
+    if folder_id:
+        data['folder_id'] = folder_id
+    
+    response = requests.post(url, headers=headers, files=files, data=data)
+    
+    if response.status_code != 201:
+        print(f"Failed to create test file: {response.text}")
+        return None
+    
+    log(f"Created test file: {response.json()}")
+    return response.json()["id"]
+
+def create_test_folder(token, parent_id=None):
+    """Create a test folder and return its ID"""
+    url = f"{BASE_URL}/folders"
+    
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    # Generate unique folder name
+    folder_name = f"test-folder-{uuid.uuid4()}"
+    
+    payload = {
+        "name": folder_name
+    }
+    
+    if parent_id:
+        payload["parent_id"] = parent_id
+    
+    response = requests.post(url, headers=headers, json=payload)
+    
+    if response.status_code != 201:
+        print(f"Failed to create test folder: {response.text}")
+        return None
+    
+    log(f"Created test folder: {response.json()}")
+    return response.json()["id"]
+
+def move_file_to_trash(token, file_id):
+    """Move a file to trash"""
+    url = f"{BASE_URL}/files/trash/{file_id}"
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    response = requests.delete(url, headers=headers)
+    log(f"Move file to trash response: {response.status_code} - {response.text}")
+    
+    return response.status_code == 200
+
+def move_folder_to_trash(token, folder_id):
+    """Move a folder to trash"""
+    url = f"{BASE_URL}/folders/trash/{folder_id}"
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    response = requests.delete(url, headers=headers)
+    log(f"Move folder to trash response: {response.status_code} - {response.text}")
+    
+    return response.status_code == 200
+
+def list_trash_items(token):
+    """List all items in trash"""
+    url = f"{BASE_URL}/trash"
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    response = requests.get(url, headers=headers)
+    log(f"List trash items response: {response.status_code}")
+    
+    if response.status_code != 200:
+        print(f"Failed to list trash items: {response.text}")
+        return []
+    
+    items = response.json()
+    log(f"Trash items: {items}")
+    return items
+
+def restore_from_trash(token, trash_id):
+    """Restore an item from trash"""
+    url = f"{BASE_URL}/trash/{trash_id}/restore"
+    
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json"
+    }
+    
+    response = requests.post(url, headers=headers, json={})
+    log(f"Restore from trash response: {response.status_code} - {response.text}")
+    
+    return response.status_code == 200
+
+def delete_permanently(token, trash_id):
+    """Delete an item permanently from trash"""
+    url = f"{BASE_URL}/trash/{trash_id}"
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    response = requests.delete(url, headers=headers)
+    log(f"Delete permanently response: {response.status_code} - {response.text}")
+    
+    return response.status_code == 200
+
+def empty_trash(token):
+    """Empty the trash (delete all items)"""
+    url = f"{BASE_URL}/trash/empty"
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    response = requests.delete(url, headers=headers)
+    log(f"Empty trash response: {response.status_code} - {response.text}")
+    
+    return response.status_code == 200
+
+def check_file_exists(token, file_id):
+    """Check if a file exists"""
+    url = f"{BASE_URL}/files/{file_id}"
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    response = requests.get(url, headers=headers)
+    exists = response.status_code == 200
+    log(f"File {file_id} exists: {exists}")
+    return exists
+
+def check_folder_exists(token, folder_id):
+    """Check if a folder exists"""
+    url = f"{BASE_URL}/folders/{folder_id}"
+    
+    headers = {
+        "Authorization": f"Bearer {token}"
+    }
+    
+    response = requests.get(url, headers=headers)
+    exists = response.status_code == 200
+    log(f"Folder {folder_id} exists: {exists}")
+    return exists
+
+def run_tests():
+    print("=== Starting Trash API Tests ===")
+    
+    # Get auth token
+    token = get_auth_token()
+    print(f"Auth token: {token[:10]}...")
+    
+    # Test 1: Create a file and move it to trash
+    print("\n=== Test 1: File to Trash ===")
+    file_id = create_test_file(token)
+    assert file_id, "Failed to create test file"
+    print(f"Created test file with ID: {file_id}")
+    
+    # Check file exists before trashing
+    assert check_file_exists(token, file_id), "File should exist before moving to trash"
+    
+    # Move file to trash
+    assert move_file_to_trash(token, file_id), "Failed to move file to trash"
+    print("Moved file to trash successfully")
+    
+    # Verify file is no longer accessible in main interface
+    assert not check_file_exists(token, file_id), "File should not be accessible after moving to trash"
+    
+    # Verify file appears in trash
+    trash_items = list_trash_items(token)
+    file_in_trash = any(item["original_id"] == file_id and item["item_type"] == "file" for item in trash_items)
+    assert file_in_trash, "File should appear in trash listing"
+    print("File correctly appears in trash")
+    
+    # Get the trash item ID
+    file_trash_id = next(item["id"] for item in trash_items if item["original_id"] == file_id)
+    
+    # Test 2: Create a folder and move it to trash
+    print("\n=== Test 2: Folder to Trash ===")
+    folder_id = create_test_folder(token)
+    assert folder_id, "Failed to create test folder"
+    print(f"Created test folder with ID: {folder_id}")
+    
+    # Check folder exists before trashing
+    assert check_folder_exists(token, folder_id), "Folder should exist before moving to trash"
+    
+    # Move folder to trash
+    assert move_folder_to_trash(token, folder_id), "Failed to move folder to trash"
+    print("Moved folder to trash successfully")
+    
+    # Verify folder is no longer accessible
+    assert not check_folder_exists(token, folder_id), "Folder should not be accessible after moving to trash"
+    
+    # Verify folder appears in trash
+    trash_items = list_trash_items(token)
+    folder_in_trash = any(item["original_id"] == folder_id and item["item_type"] == "folder" for item in trash_items)
+    assert folder_in_trash, "Folder should appear in trash listing"
+    print("Folder correctly appears in trash")
+    
+    # Get the trash item ID
+    folder_trash_id = next(item["id"] for item in trash_items if item["original_id"] == folder_id)
+    
+    # Test 3: Restore file from trash
+    print("\n=== Test 3: Restore File from Trash ===")
+    assert restore_from_trash(token, file_trash_id), "Failed to restore file from trash"
+    print("Restored file from trash successfully")
+    
+    # Verify file is now accessible again
+    assert check_file_exists(token, file_id), "File should be accessible after restoring from trash"
+    
+    # Verify file no longer appears in trash
+    trash_items = list_trash_items(token)
+    file_in_trash = any(item["id"] == file_trash_id for item in trash_items)
+    assert not file_in_trash, "File should not appear in trash after restoration"
+    print("File no longer appears in trash")
+    
+    # Test 4: Permanently delete folder from trash
+    print("\n=== Test 4: Permanently Delete Folder from Trash ===")
+    assert delete_permanently(token, folder_trash_id), "Failed to permanently delete folder"
+    print("Permanently deleted folder successfully")
+    
+    # Verify folder is still not accessible
+    assert not check_folder_exists(token, folder_id), "Folder should not be accessible after permanent deletion"
+    
+    # Verify folder no longer appears in trash
+    trash_items = list_trash_items(token)
+    folder_in_trash = any(item["id"] == folder_trash_id for item in trash_items)
+    assert not folder_in_trash, "Folder should not appear in trash after permanent deletion"
+    print("Folder no longer appears in trash")
+    
+    # Test 5: Test Empty Trash functionality
+    print("\n=== Test 5: Empty Trash ===")
+    
+    # Create multiple files and folders and move them to trash
+    print("Creating multiple test items...")
+    test_files = [create_test_file(token) for _ in range(3)]
+    test_folders = [create_test_folder(token) for _ in range(2)]
+    
+    # Move all to trash
+    for file_id in test_files:
+        move_file_to_trash(token, file_id)
+    
+    for folder_id in test_folders:
+        move_folder_to_trash(token, folder_id)
+    
+    # Verify items are in trash
+    trash_items = list_trash_items(token)
+    assert len(trash_items) >= 5, "All test items should be in trash"
+    print(f"Trash contains {len(trash_items)} items")
+    
+    # Empty trash
+    assert empty_trash(token), "Failed to empty trash"
+    print("Emptied trash successfully")
+    
+    # Verify trash is empty
+    trash_items = list_trash_items(token)
+    assert len(trash_items) == 0, "Trash should be empty"
+    print("Trash is empty as expected")
+    
+    print("\n=== All Trash API Tests Passed! ===")
+    return True
+
+if __name__ == "__main__":
+    try:
+        run_tests()
+    except Exception as e:
+        print(f"Test failed: {e}")
+        sys.exit(1)
@@ -0,0 +1,416 @@
+#!/bin/bash
+
+# Configuration
+BASE_URL="http://localhost:8085/api"
+AUTH_TOKEN=""
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+NC='\033[0m' # No Color
+
+# Get auth token
+get_auth_token() {
+  echo -e "${YELLOW}Getting auth token...${NC}"
+  
+  response=$(curl -s -X POST "$BASE_URL/auth/login" \
+    -H "Content-Type: application/json" \
+    -d '{"username":"test","password":"test123"}')
+  
+  AUTH_TOKEN=$(echo "$response" | grep -o '"token":"[^"]*' | cut -d'"' -f4)
+  
+  if [ -z "$AUTH_TOKEN" ]; then
+    echo -e "${RED}Failed to get auth token${NC}"
+    exit 1
+  else
+    echo -e "${GREEN}Auth token: ${AUTH_TOKEN:0:10}...${NC}"
+  fi
+}
+
+# Create a test file
+create_test_file() {
+  echo -e "${YELLOW}Creating test file...${NC}"
+  
+  local content="Test file content $(date)"
+  local filename="test-file-$(date +%s).txt"
+  
+  echo "$content" > "$filename"
+  
+  response=$(curl -s -X POST "$BASE_URL/files/upload" \
+    -H "Authorization: Bearer $AUTH_TOKEN" \
+    -F "file=@$filename")
+  
+  file_id=$(echo "$response" | grep -o '"id":"[^"]*' | cut -d'"' -f4)
+  
+  rm "$filename"
+  
+  if [ -z "$file_id" ]; then
+    echo -e "${RED}Failed to create test file${NC}"
+    return 1
+  else
+    echo -e "${GREEN}Created file with ID: $file_id${NC}"
+    echo "$file_id"
+    return 0
+  fi
+}
+
+# Create a test folder
+create_test_folder() {
+  echo -e "${YELLOW}Creating test folder...${NC}"
+  
+  local folder_name="test-folder-$(date +%s)"
+  
+  response=$(curl -s -X POST "$BASE_URL/folders" \
+    -H "Authorization: Bearer $AUTH_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d "{\"name\":\"$folder_name\"}")
+  
+  folder_id=$(echo "$response" | grep -o '"id":"[^"]*' | cut -d'"' -f4)
+  
+  if [ -z "$folder_id" ]; then
+    echo -e "${RED}Failed to create test folder${NC}"
+    return 1
+  else
+    echo -e "${GREEN}Created folder with ID: $folder_id${NC}"
+    echo "$folder_id"
+    return 0
+  fi
+}
+
+# Move a file to trash
+move_file_to_trash() {
+  local file_id=$1
+  echo -e "${YELLOW}Moving file $file_id to trash...${NC}"
+  
+  response=$(curl -s -X DELETE "$BASE_URL/files/trash/$file_id" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  if echo "$response" | grep -q "success"; then
+    echo -e "${GREEN}Successfully moved file to trash${NC}"
+    return 0
+  else
+    echo -e "${RED}Failed to move file to trash: $response${NC}"
+    return 1
+  fi
+}
+
+# Move a folder to trash
+move_folder_to_trash() {
+  local folder_id=$1
+  echo -e "${YELLOW}Moving folder $folder_id to trash...${NC}"
+  
+  response=$(curl -s -X DELETE "$BASE_URL/folders/trash/$folder_id" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  if echo "$response" | grep -q "success"; then
+    echo -e "${GREEN}Successfully moved folder to trash${NC}"
+    return 0
+  else
+    echo -e "${RED}Failed to move folder to trash: $response${NC}"
+    return 1
+  fi
+}
+
+# List trash items
+list_trash_items() {
+  echo -e "${YELLOW}Listing trash items...${NC}"
+  
+  response=$(curl -s -X GET "$BASE_URL/trash" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  echo "$response" | jq
+  return 0
+}
+
+# Restore an item from trash
+restore_from_trash() {
+  local trash_id=$1
+  echo -e "${YELLOW}Restoring item $trash_id from trash...${NC}"
+  
+  response=$(curl -s -X POST "$BASE_URL/trash/$trash_id/restore" \
+    -H "Authorization: Bearer $AUTH_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d "{}")
+  
+  if echo "$response" | grep -q "success"; then
+    echo -e "${GREEN}Successfully restored item from trash${NC}"
+    return 0
+  else
+    echo -e "${RED}Failed to restore item from trash: $response${NC}"
+    return 1
+  fi
+}
+
+# Delete an item permanently
+delete_permanently() {
+  local trash_id=$1
+  echo -e "${YELLOW}Permanently deleting item $trash_id...${NC}"
+  
+  response=$(curl -s -X DELETE "$BASE_URL/trash/$trash_id" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  if echo "$response" | grep -q "success"; then
+    echo -e "${GREEN}Successfully deleted item permanently${NC}"
+    return 0
+  else
+    echo -e "${RED}Failed to delete item permanently: $response${NC}"
+    return 1
+  fi
+}
+
+# Empty the trash
+empty_trash() {
+  echo -e "${YELLOW}Emptying trash...${NC}"
+  
+  response=$(curl -s -X DELETE "$BASE_URL/trash/empty" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  if echo "$response" | grep -q "success"; then
+    echo -e "${GREEN}Successfully emptied trash${NC}"
+    return 0
+  else
+    echo -e "${RED}Failed to empty trash: $response${NC}"
+    return 1
+  fi
+}
+
+# Check if a file exists
+check_file_exists() {
+  local file_id=$1
+  echo -e "${YELLOW}Checking if file $file_id exists...${NC}"
+  
+  response=$(curl -s -o /dev/null -w "%{http_code}" -X GET "$BASE_URL/files/$file_id" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  if [ "$response" == "200" ]; then
+    echo -e "${GREEN}File exists${NC}"
+    return 0
+  else
+    echo -e "${RED}File does not exist (HTTP $response)${NC}"
+    return 1
+  fi
+}
+
+# Check if a folder exists
+check_folder_exists() {
+  local folder_id=$1
+  echo -e "${YELLOW}Checking if folder $folder_id exists...${NC}"
+  
+  response=$(curl -s -o /dev/null -w "%{http_code}" -X GET "$BASE_URL/folders/$folder_id" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  if [ "$response" == "200" ]; then
+    echo -e "${GREEN}Folder exists${NC}"
+    return 0
+  else
+    echo -e "${RED}Folder does not exist (HTTP $response)${NC}"
+    return 1
+  fi
+}
+
+# Run tests
+run_tests() {
+  echo -e "${GREEN}=== Starting Trash API Tests ===${NC}"
+  
+  # Get auth token
+  get_auth_token
+  
+  # Test 1: Create a file and move it to trash
+  echo -e "${GREEN}\n=== Test 1: File to Trash ===${NC}"
+  file_id=$(create_test_file)
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 1 failed: Could not create test file${NC}"
+    exit 1
+  fi
+  
+  # Check file exists before trashing
+  check_file_exists "$file_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 1 failed: File should exist before moving to trash${NC}"
+    exit 1
+  fi
+  
+  # Move file to trash
+  move_file_to_trash "$file_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 1 failed: Could not move file to trash${NC}"
+    exit 1
+  fi
+  
+  # Verify file is no longer accessible in main interface
+  check_file_exists "$file_id"
+  if [ $? -eq 0 ]; then
+    echo -e "${RED}Test 1 failed: File should not be accessible after moving to trash${NC}"
+    exit 1
+  else
+    echo -e "${GREEN}File correctly inaccessible after moving to trash${NC}"
+  fi
+  
+  # Verify file appears in trash
+  response=$(curl -s -X GET "$BASE_URL/trash" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  file_trash_id=$(echo "$response" | jq -r ".[] | select(.original_id == \"$file_id\" and .item_type == \"file\") | .id")
+  
+  if [ -z "$file_trash_id" ]; then
+    echo -e "${RED}Test 1 failed: File should appear in trash listing${NC}"
+    exit 1
+  else
+    echo -e "${GREEN}File correctly appears in trash with trash ID: $file_trash_id${NC}"
+  fi
+  
+  # Test 2: Create a folder and move it to trash
+  echo -e "${GREEN}\n=== Test 2: Folder to Trash ===${NC}"
+  folder_id=$(create_test_folder)
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 2 failed: Could not create test folder${NC}"
+    exit 1
+  fi
+  
+  # Check folder exists before trashing
+  check_folder_exists "$folder_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 2 failed: Folder should exist before moving to trash${NC}"
+    exit 1
+  fi
+  
+  # Move folder to trash
+  move_folder_to_trash "$folder_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 2 failed: Could not move folder to trash${NC}"
+    exit 1
+  fi
+  
+  # Verify folder is no longer accessible
+  check_folder_exists "$folder_id"
+  if [ $? -eq 0 ]; then
+    echo -e "${RED}Test 2 failed: Folder should not be accessible after moving to trash${NC}"
+    exit 1
+  else
+    echo -e "${GREEN}Folder correctly inaccessible after moving to trash${NC}"
+  fi
+  
+  # Verify folder appears in trash
+  response=$(curl -s -X GET "$BASE_URL/trash" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  folder_trash_id=$(echo "$response" | jq -r ".[] | select(.original_id == \"$folder_id\" and .item_type == \"folder\") | .id")
+  
+  if [ -z "$folder_trash_id" ]; then
+    echo -e "${RED}Test 2 failed: Folder should appear in trash listing${NC}"
+    exit 1
+  else
+    echo -e "${GREEN}Folder correctly appears in trash with trash ID: $folder_trash_id${NC}"
+  fi
+  
+  # Test 3: Restore file from trash
+  echo -e "${GREEN}\n=== Test 3: Restore File from Trash ===${NC}"
+  restore_from_trash "$file_trash_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 3 failed: Could not restore file from trash${NC}"
+    exit 1
+  fi
+  
+  # Verify file is now accessible again
+  check_file_exists "$file_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 3 failed: File should be accessible after restoring from trash${NC}"
+    exit 1
+  fi
+  
+  # Verify file no longer appears in trash
+  response=$(curl -s -X GET "$BASE_URL/trash" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  file_still_in_trash=$(echo "$response" | jq -r ".[] | select(.id == \"$file_trash_id\") | .id")
+  
+  if [ ! -z "$file_still_in_trash" ]; then
+    echo -e "${RED}Test 3 failed: File should not appear in trash after restoration${NC}"
+    exit 1
+  else
+    echo -e "${GREEN}File no longer appears in trash${NC}"
+  fi
+  
+  # Test 4: Permanently delete folder from trash
+  echo -e "${GREEN}\n=== Test 4: Permanently Delete Folder from Trash ===${NC}"
+  delete_permanently "$folder_trash_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 4 failed: Could not permanently delete folder${NC}"
+    exit 1
+  fi
+  
+  # Verify folder is still not accessible
+  check_folder_exists "$folder_id"
+  if [ $? -eq 0 ]; then
+    echo -e "${RED}Test 4 failed: Folder should not be accessible after permanent deletion${NC}"
+    exit 1
+  fi
+  
+  # Verify folder no longer appears in trash
+  response=$(curl -s -X GET "$BASE_URL/trash" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  folder_still_in_trash=$(echo "$response" | jq -r ".[] | select(.id == \"$folder_trash_id\") | .id")
+  
+  if [ ! -z "$folder_still_in_trash" ]; then
+    echo -e "${RED}Test 4 failed: Folder should not appear in trash after permanent deletion${NC}"
+    exit 1
+  else
+    echo -e "${GREEN}Folder no longer appears in trash${NC}"
+  fi
+  
+  # Test 5: Test Empty Trash functionality
+  echo -e "${GREEN}\n=== Test 5: Empty Trash ===${NC}"
+  
+  # Create multiple files and folders and move them to trash
+  echo -e "${YELLOW}Creating multiple test items...${NC}"
+  file_ids=()
+  folder_ids=()
+  
+  for i in {1..3}; do
+    file_id=$(create_test_file)
+    file_ids+=("$file_id")
+    move_file_to_trash "$file_id"
+  done
+  
+  for i in {1..2}; do
+    folder_id=$(create_test_folder)
+    folder_ids+=("$folder_id")
+    move_folder_to_trash "$folder_id"
+  done
+  
+  # Verify items are in trash
+  response=$(curl -s -X GET "$BASE_URL/trash" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  trash_count=$(echo "$response" | jq '. | length')
+  echo -e "${GREEN}Trash contains $trash_count items${NC}"
+  
+  # Empty trash
+  empty_trash
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test 5 failed: Could not empty trash${NC}"
+    exit 1
+  fi
+  
+  # Verify trash is empty
+  response=$(curl -s -X GET "$BASE_URL/trash" \
+    -H "Authorization: Bearer $AUTH_TOKEN")
+  
+  trash_count=$(echo "$response" | jq '. | length')
+  
+  if [ "$trash_count" -ne 0 ]; then
+    echo -e "${RED}Test 5 failed: Trash should be empty, but contains $trash_count items${NC}"
+    exit 1
+  else
+    echo -e "${GREEN}Trash is empty as expected${NC}"
+  fi
+  
+  echo -e "${GREEN}\n=== All Trash API Tests Passed! ===${NC}"
+  return 0
+}
+
+# Run the tests
+run_tests
+exit $?
@@ -0,0 +1,152 @@
+#!/bin/bash
+
+# Configuration 
+BASE_URL="http://localhost:8086/api"
+USER_ID="00000000-0000-0000-0000-000000000000"
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[0;33m'
+NC='\033[0m' # No Color
+
+# Create a test file directly (no authentication)
+create_test_file() {
+  echo -e "${YELLOW}Creating test file...${NC}"
+  
+  local content="Test file content $(date)"
+  local filename="test-file-$(date +%s).txt"
+  
+  echo "$content" > "$filename"
+  
+  response=$(curl -s -X POST "$BASE_URL/files/upload" \
+    -F "file=@$filename" \
+    -F "userId=$USER_ID")
+  
+  file_id=$(echo "$response" | grep -o '"id":"[^"]*' | cut -d'"' -f4)
+  
+  rm "$filename"
+  
+  if [ -z "$file_id" ]; then
+    echo -e "${RED}Failed to create test file${NC}"
+    return 1
+  else
+    echo -e "${GREEN}Created file with ID: $file_id${NC}"
+    echo "$file_id"
+    return 0
+  fi
+}
+
+# Create a test folder
+create_test_folder() {
+  echo -e "${YELLOW}Creating test folder...${NC}"
+  
+  local folder_name="test-folder-$(date +%s)"
+  
+  response=$(curl -s -X POST "$BASE_URL/folders" \
+    -H "Content-Type: application/json" \
+    -d "{\"name\":\"$folder_name\", \"userId\":\"$USER_ID\"}")
+  
+  folder_id=$(echo "$response" | grep -o '"id":"[^"]*' | cut -d'"' -f4)
+  
+  if [ -z "$folder_id" ]; then
+    echo -e "${RED}Failed to create test folder${NC}"
+    return 1
+  else
+    echo -e "${GREEN}Created folder with ID: $folder_id${NC}"
+    echo "$folder_id"
+    return 0
+  fi
+}
+
+# Move a file to trash
+move_file_to_trash() {
+  local file_id=$1
+  echo -e "${YELLOW}Moving file $file_id to trash...${NC}"
+  
+  response=$(curl -s -X DELETE "$BASE_URL/files/trash/$file_id")
+  
+  if echo "$response" | grep -q "success"; then
+    echo -e "${GREEN}Successfully moved file to trash${NC}"
+    return 0
+  else
+    echo -e "${RED}Failed to move file to trash: $response${NC}"
+    return 1
+  fi
+}
+
+# Move a folder to trash
+move_folder_to_trash() {
+  local folder_id=$1
+  echo -e "${YELLOW}Moving folder $folder_id to trash...${NC}"
+  
+  response=$(curl -s -X DELETE "$BASE_URL/folders/trash/$folder_id")
+  
+  if echo "$response" | grep -q "success"; then
+    echo -e "${GREEN}Successfully moved folder to trash${NC}"
+    return 0
+  else
+    echo -e "${RED}Failed to move folder to trash: $response${NC}"
+    return 1
+  fi
+}
+
+# List trash items
+list_trash_items() {
+  echo -e "${YELLOW}Listing trash items...${NC}"
+  
+  response=$(curl -s -X GET "$BASE_URL/trash?userId=$USER_ID")
+  
+  echo "$response"
+  return 0
+}
+
+# Run simple trash test
+run_test() {
+  echo -e "${GREEN}=== Starting Simple Trash Test ===${NC}"
+  
+  # Test: Create a file and move it to trash
+  echo -e "${GREEN}\n=== Test: File to Trash ===${NC}"
+  file_id=$(create_test_file)
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test failed: Could not create test file${NC}"
+    exit 1
+  fi
+  
+  # Move file to trash
+  move_file_to_trash "$file_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test failed: Could not move file to trash${NC}"
+    exit 1
+  fi
+  
+  # List trash items to confirm
+  echo -e "${GREEN}Listing trash items after file deletion:${NC}"
+  list_trash_items
+  
+  # Test: Create a folder and move it to trash
+  echo -e "${GREEN}\n=== Test: Folder to Trash ===${NC}"
+  folder_id=$(create_test_folder)
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test failed: Could not create test folder${NC}"
+    exit 1
+  fi
+  
+  # Move folder to trash
+  move_folder_to_trash "$folder_id"
+  if [ $? -ne 0 ]; then
+    echo -e "${RED}Test failed: Could not move folder to trash${NC}"
+    exit 1
+  fi
+  
+  # List trash items to confirm
+  echo -e "${GREEN}Listing trash items after folder deletion:${NC}"
+  list_trash_items
+  
+  echo -e "${GREEN}\n=== Test Completed ===${NC}"
+  return 0
+}
+
+# Run the test
+run_test
+exit $?
@@ -0,0 +1,72 @@
+#!/bin/bash
+
+BASE_URL="http://127.0.0.1:8085/api"
+
+# Get the login token
+echo "Logging in..."
+TOKEN=$(curl -s -X POST "${BASE_URL}/auth/login" \
+  -H "Content-Type: application/json" \
+  -d '{"username":"admin", "password":"admin123"}' | jq -r '.access_token')
+
+if [ -z "$TOKEN" ] || [ "$TOKEN" == "null" ]; then
+  echo "Failed to get token"
+  exit 1
+fi
+
+echo "Token: ${TOKEN:0:15}..."
+
+# Create a test folder
+echo -e "\nCreating test folder..."
+FOLDER_ID=$(curl -s -X POST "${BASE_URL}/folders" \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer $TOKEN" \
+  -d '{"name":"Trash Test Folder", "parent_id":null}' | jq -r '.id')
+
+echo "Created folder with ID: $FOLDER_ID"
+
+# Create a test file in the folder
+echo -e "\nCreating test file..."
+FILE_CONTENT="This is a test file that will be moved to trash."
+TEST_FILE_PATH="/tmp/trash_test_file.txt"
+echo "$FILE_CONTENT" > "$TEST_FILE_PATH"
+
+FILE_ID=$(curl -s -X POST "${BASE_URL}/files/upload" \
+  -H "Authorization: Bearer $TOKEN" \
+  -F "file=@$TEST_FILE_PATH" \
+  -F "folder_id=$FOLDER_ID" | jq -r '.id')
+
+echo "Created file with ID: $FILE_ID"
+
+# Try the trash operations (these will use the frontend code we modified)
+echo -e "\nTesting trash operations through the frontend using direct delete (which uses trash)..."
+echo "Moving file to trash..."
+curl -s -X DELETE "${BASE_URL}/files/$FILE_ID" \
+  -H "Authorization: Bearer $TOKEN"
+
+# Check if file is still accessible (should return 404 if moved to trash)
+echo -e "\nChecking if file is still accessible..."
+STATUS=$(curl -s -o /dev/null -w "%{http_code}" "${BASE_URL}/files/$FILE_ID" \
+  -H "Authorization: Bearer $TOKEN")
+
+if [ "$STATUS" == "404" ]; then
+  echo "File moved to trash successfully (returns 404)"
+else
+  echo "File still accessible, move to trash failed (status: $STATUS)"
+fi
+
+echo -e "\nMoving folder to trash..."
+curl -s -X DELETE "${BASE_URL}/folders/$FOLDER_ID" \
+  -H "Authorization: Bearer $TOKEN"
+
+# Check if folder is still accessible
+echo -e "\nChecking if folder is still accessible..."
+STATUS=$(curl -s -o /dev/null -w "%{http_code}" "${BASE_URL}/folders/$FOLDER_ID" \
+  -H "Authorization: Bearer $TOKEN")
+
+if [ "$STATUS" == "404" ]; then
+  echo "Folder moved to trash successfully (returns 404)"
+else
+  echo "Folder still accessible, move to trash failed (status: $STATUS)"
+fi
+
+echo -e "\nTest complete."
@@ -0,0 +1,98 @@
+#!/usr/bin/env python3
+import requests
+import argparse
+import os
+import json
+
+def upload_file(url, file_path, folder_id=None):
+    """Upload a file to the server"""
+    if not os.path.exists(file_path):
+        print(f"Error: File not found: {file_path}")
+        return
+
+    # Create the multipart form data
+    files = {'file': open(file_path, 'rb')}
+    data = {}
+    
+    if folder_id:
+        data['folder_id'] = folder_id
+    
+    # Send the request
+    try:
+        response = requests.post(f"{url}/api/files/upload", files=files, data=data)
+        return response.json()
+    except Exception as e:
+        print(f"Error during upload: {e}")
+        return None
+
+def list_files(url, folder_id=None):
+    """List files in a folder"""
+    params = {}
+    if folder_id:
+        params['folder_id'] = folder_id
+    
+    try:
+        response = requests.get(f"{url}/api/files", params=params)
+        return response.json()
+    except Exception as e:
+        print(f"Error listing files: {e}")
+        return None
+
+def download_file(url, file_id, output_path=None):
+    """Download a file by its ID"""
+    try:
+        response = requests.get(f"{url}/api/files/{file_id}")
+        
+        if output_path is None:
+            output_path = file_id.split('/')[-1]  # Use the last part of the path as filename
+        
+        # Save the file
+        with open(output_path, 'wb') as f:
+            f.write(response.content)
+        
+        return output_path
+    except Exception as e:
+        print(f"Error downloading file: {e}")
+        return None
+
+def main():
+    parser = argparse.ArgumentParser(description='Test OxiCloud API')
+    parser.add_argument('--url', type=str, default="http://localhost:8086", help='Server URL')
+    parser.add_argument('--action', type=str, required=True, choices=['upload', 'list', 'download'], help='Action to perform')
+    parser.add_argument('--file', type=str, help='Path to file for upload or output path for download')
+    parser.add_argument('--folder', type=str, help='Folder ID for upload or list actions')
+    parser.add_argument('--id', type=str, help='File ID for download action')
+    
+    args = parser.parse_args()
+    
+    if args.action == 'upload':
+        if not args.file:
+            print("Error: --file is required for upload action")
+            return
+        
+        result = upload_file(args.url, args.file, args.folder)
+        if result:
+            if isinstance(result, dict):
+                print(json.dumps(result, indent=2))
+                print(f"File uploaded successfully with ID: {result.get('id', 'unknown')}")
+            else:
+                print(json.dumps(result, indent=2))
+                print("Received unexpected response format")
+    
+    elif args.action == 'list':
+        result = list_files(args.url, args.folder)
+        if result:
+            print(json.dumps(result, indent=2))
+            print(f"Found {len(result)} files")
+    
+    elif args.action == 'download':
+        if not args.id:
+            print("Error: --id is required for download action")
+            return
+        
+        output_path = download_file(args.url, args.id, args.file)
+        if output_path:
+            print(f"File downloaded successfully to {output_path}")
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,13 @@
+#!/bin/bash
+
+# Test file upload to the server
+echo "Testing file upload to OxiCloud server..."
+
+# Build the form data
+curl -X POST \
+     -F "file=@test-upload.txt" \
+     -F "folder_id=folder-storage:1" \
+     http://localhost:8086/api/files/upload
+
+echo ""
+echo "Upload test completed."
@@ -0,0 +1 @@
+This is a test file for upload