GestionTablets/docs/CLI_VS_WEB.md

CLI vs Web Functionality Comparison

Overview

This document compares the functionality between the CLI version (minimal_app.py) and the Web version (app.py) of the Tablet Management System.

Current State

Web Version (app.py) - Complete Feature Set

Feature	Status	Route	Template
Add Tablet	✅	/add_tablet	add_tablet.html
Add User	✅	/add_user	add_user.html
Loan Tablet	✅	/loan_tablet	loan_tablet.html
Return Tablet	✅	/return_tablet/<id>	N/A (redirects)
Show Available Tablets	✅	/ (index)	index.html
Show Active Loans	✅	/ (index)	index.html
Loan History	✅	/history	history.html
User Loans	✅	/user_loans	user_loans.html
Add Non-Loanable Device	✅	/add_non_loanable_device	add_non_loanable_device.html
Show Non-Loanable Devices	✅	/non_loanable_devices	non_loanable_devices.html
Edit Non-Loanable Device	✅	/edit_non_loanable_device/<id>	edit_non_loanable_device.html
Delete Non-Loanable Device	✅	/delete_non_loanable_device/<id>	N/A (redirects)
Project Management	✅	/project_management	project_management.html

CLI Version (minimal_app.py) - Incomplete

Feature	Status	Function
Add Tablet	✅	add_tablet()
Add User	⚠️ Partial	add_user() - Missing email/phone
Loan Tablet	✅	loan_tablet()
Return Tablet	✅	return_tablet()
Show Available Tablets	✅	show_available_tablets()
Show Active Loans	✅	show_active_loans()
Loan History	✅	show_loan_history()
Add Non-Loanable Device	✅	add_non_loanable_device()
Show Non-Loanable Devices	✅	show_non_loanable_devices()
Delete Non-Loanable Device	✅	delete_non_loanable_device()
Show Users	✅	show_users()
User Loans	❌ Missing	N/A
Edit Non-Loanable Device	❌ Missing	N/A
Project Management	❌ Missing	N/A

Missing Features in CLI

1. User Management

Web: Supports name, email, phone, identification CLI: Only supports name, identification

Missing:

• Email field
• Phone field

2. Tablet Management

Web: Supports brand, model, serial_number, notes CLI: Supports brand, model, serial_number

Missing:

• Notes field

3. Non-Loanable Devices

Web: Full CRUD (Create, Read, Update, Delete) CLI: Only Create, Read, Delete

Missing:

• Edit functionality

4. Additional Features

Web: Has these features CLI: Missing

• User Loans page (shows loans by user with search)
• Project Management (markdown notes editor)
• Flash messages (CLI uses print, which is fine)

Database Schema Comparison

Web Version Schema (app.py)

-- tablets
CREATE TABLE tablets (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    brand TEXT NOT NULL,
    model TEXT NOT NULL,
    serial_number TEXT UNIQUE NOT NULL,
    status TEXT DEFAULT 'available',
    notes TEXT
)

-- users
CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    email TEXT,
    phone TEXT,
    identification TEXT UNIQUE
)

-- loans
CREATE TABLE loans (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    tablet_id INTEGER NOT NULL,
    user_id INTEGER NOT NULL,
    loan_date TEXT NOT NULL,
    return_date TEXT,
    status TEXT DEFAULT 'active',
    FOREIGN KEY (tablet_id) REFERENCES tablets (id),
    FOREIGN KEY (user_id) REFERENCES users (id)
)

-- non_loanable_devices
CREATE TABLE non_loanable_devices (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    brand TEXT NOT NULL,
    model TEXT NOT NULL,
    serial_number TEXT UNIQUE NOT NULL,
    device_type TEXT NOT NULL,
    location TEXT,
    status TEXT DEFAULT 'available',
    notes TEXT,
    purchase_date TEXT,
    purchase_cost REAL
)

CLI Version Schema (minimal_app.py)

-- tablets
CREATE TABLE tablets (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    brand TEXT NOT NULL,
    model TEXT NOT NULL,
    serial_number TEXT UNIQUE NOT NULL,
    status TEXT DEFAULT 'available'
    -- MISSING: notes TEXT
)

-- users
CREATE TABLE users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    name TEXT NOT NULL,
    identification TEXT UNIQUE
    -- MISSING: email TEXT, phone TEXT
)

-- loans
CREATE TABLE loans (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    tablet_id INTEGER NOT NULL,
    user_id INTEGER NOT NULL,
    loan_date TEXT NOT NULL,
    return_date TEXT,
    status TEXT DEFAULT 'active',
    FOREIGN KEY (tablet_id) REFERENCES tablets (id),
    FOREIGN KEY (user_id) REFERENCES users (id)
)

-- non_loanable_devices
CREATE TABLE non_loanable_devices (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    brand TEXT NOT NULL,
    model TEXT NOT NULL,
    serial_number TEXT UNIQUE NOT NULL,
    device_type TEXT NOT NULL,
    location TEXT,
    status TEXT DEFAULT 'available',
    notes TEXT,
    purchase_date TEXT,
    purchase_cost REAL
)

Schema Differences:

• tablets table: CLI missing notes column
• users table: CLI missing email and phone columns

Recommendations

Option 1: Update CLI to Match Web (Recommended)

Update minimal_app.py to:

1. Add notes field to tablets
2. Add email and phone fields to users
3. Add edit functionality for non-loanable devices
4. Add user loans view
5. Add project management (optional)

Pros:

• CLI has full feature parity with web
• Same database schema
• Users can use either interface

Cons:

• More complex CLI
• May not be needed if web is primary interface

Option 2: Keep CLI Minimal (Current State)

Leave CLI as-is for basic operations only.

Pros:

• Simple, focused CLI
• Less code to maintain

Cons:

• Database schema mismatch
• Users can't access all features via CLI
• Confusing for users who expect same functionality

Option 3: Create Separate Database (Not Recommended)

Use different databases for CLI and web.

Pros:

• Each can have optimized schema

Cons:

• Data duplication
• Sync issues
• Confusing for users

Suggested Action Plan

Priority 1: Fix Database Schema Mismatch

The CLI's init_db() creates tables without notes, email, and phone columns, but the web version expects them. This can cause issues.

Solution: Update minimal_app.py init_db() to match app.py schema.

Priority 2: Add Missing Fields to CLI Functions

1. Update add_tablet() to accept and store notes
2. Update add_user() to accept and store email and phone
3. Update show_available_tablets() and show_non_loanable_devices() to display all fields

Priority 3: Add Missing Features (Optional)

1. Add edit_non_loanable_device() function
2. Add show_user_loans() function
3. Consider adding project management (lower priority)

Code Changes Required

1. Update init_db() in minimal_app.py

def init_db():
    """Initialize database with required tables - MATCH WEB VERSION"""
    conn = sqlite3.connect('tablets.db')
    cursor = conn.cursor()
    
    # Create tablets table - ADD NOTES COLUMN
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS tablets (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            brand TEXT NOT NULL,
            model TEXT NOT NULL,
            serial_number TEXT UNIQUE NOT NULL,
            status TEXT DEFAULT 'available',
            notes TEXT
        )
    ''')
    
    # Create users table - ADD EMAIL AND PHONE COLUMNS
    cursor.execute('''
        CREATE TABLE IF NOT EXISTS users (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            name TEXT NOT NULL,
            email TEXT,
            phone TEXT,
            identification TEXT UNIQUE
        )
    ''')
    
    # loans and non_loanable_devices are already correct
    # ... rest of init_db

2. Update add_tablet() Function

def add_tablet(brand, model, serial_number, notes=''):
    """Add a new tablet to inventory"""
    conn = sqlite3.connect('tablets.db')
    cursor = conn.cursor()
    
    try:
        cursor.execute('''
            INSERT INTO tablets (brand, model, serial_number, status, notes)
            VALUES (?, ?, ?, 'available', ?)
        ''', (brand, model, serial_number, notes))
        conn.commit()
        print(f"✓ Added tablet: {brand} {model} ({serial_number})")
        if notes:
            print(f"  Notes: {notes}")
    except sqlite3.IntegrityError:
        print(f"✗ Error: Serial number {serial_number} already exists")
    finally:
        conn.close()

3. Update add_user() Function

def add_user(name, identification, email='', phone=''):
    """Add a new user"""
    conn = sqlite3.connect('tablets.db')
    cursor = conn.cursor()
    
    try:
        cursor.execute('''
            INSERT INTO users (name, email, phone, identification)
            VALUES (?, ?, ?, ?)
        ''', (name, email, phone, identification))
        conn.commit()
        print(f"✓ Added user: {name} ({identification})")
        if email:
            print(f"  Email: {email}")
        if phone:
            print(f"  Phone: {phone}")
    except sqlite3.IntegrityError:
        print(f"✗ Error: Identification {identification} already exists")
    finally:
        conn.close()

4. Update show_available_tablets() to Display Notes

def show_available_tablets():
    """Show available tablets"""
    conn = sqlite3.connect('tablets.db')
    cursor = conn.cursor()
    
    cursor.execute("SELECT id, brand, model, serial_number, notes FROM tablets WHERE status = 'available'")
    tablets = cursor.fetchall()
    
    print("\n=== Available Tablets ===")
    if tablets:
        for tablet in tablets:
            notes = f" | Notes: {tablet[4]}" if tablet[4] else ""
            print(f"ID: {tablet[0]}, {tablet[1]} {tablet[2]} ({tablet[3]}){notes}")
    else:
        print("No available tablets")
    
    conn.close()

5. Add Missing Functions

Edit Non-Loanable Device

def edit_non_loanable_device(device_id, **kwargs):
    """Edit a non-loanable device"""
    conn = sqlite3.connect('tablets.db')
    cursor = conn.cursor()
    
    # Build update query dynamically
    updates = []
    params = []
    for key, value in kwargs.items():
        if value is not None:
            updates.append(f"{key} = ?")
            params.append(value)
    
    if not updates:
        print("✗ No fields to update")
        conn.close()
        return
    
    params.append(device_id)
    query = f"UPDATE non_loanable_devices SET {', '.join(updates)} WHERE id = ?"
    
    cursor.execute(query, params)
    conn.commit()
    
    if cursor.rowcount > 0:
        print(f"✓ Non-loanable device {device_id} updated")
    else:
        print(f"✗ Error: Device {device_id} not found")
    
    conn.close()

Show User Loans

def show_user_loans():
    """Show loans grouped by user"""
    conn = sqlite3.connect('tablets.db')
    cursor = conn.cursor()
    
    # Get all users with their loans
    cursor.execute('''
        SELECT u.id, u.name, u.identification,
               GROUP_CONCAT(l.id, ",") as loan_ids,
               COUNT(l.id) as loan_count
        FROM users u
        LEFT JOIN loans l ON u.id = l.user_id
        GROUP BY u.id, u.name, u.identification
    ''')
    users = cursor.fetchall()
    
    print("\n=== User Loans ===")
    if users:
        for user in users:
            print(f"\nUser: {user[1]} ({user[2]}) - {user[3]} loans")
            
            # Get loans for this user
            cursor.execute('''
                SELECT l.id, t.brand, t.model, t.serial_number, l.loan_date, l.return_date, l.status
                FROM loans l
                JOIN tablets t ON l.tablet_id = t.id
                WHERE l.user_id = ?
                ORDER BY l.loan_date DESC
            ''', (user[0],))
            loans = cursor.fetchall()
            
            for loan in loans:
                return_date = loan[5] or 'Not returned'
                print(f"  Loan {loan[0]}: {loan[1]} {loan[2]} ({loan[3]})")
                print(f"    Loan Date: {loan[4]}, Return Date: {return_date}, Status: {loan[6]}")
    else:
        print("No users found")
    
    conn.close()

Migration Strategy

If you want to update the CLI to match the web version:

1. Backup current database

   cp tablets.db tablets.db.backup
   

2. Update minimal_app.py with the changes above

3. Run updated CLI

   python3 minimal_app.py
   

4. Test all functionality

5. If database schema changed, you may need to:

   • Drop and recreate tables (if starting fresh)
   • Or add missing columns with ALTER TABLE (if preserving data)

Conclusion

The CLI version is lagging behind the web version in terms of:

• Database schema (missing columns)
• Feature completeness (missing functions)
• Field support (missing email, phone, notes)

Recommendation: Update the CLI to match the web version's database schema and functionality to ensure consistency and avoid confusion for users who may use both interfaces.