shopfloor-dashboard/app.py

from flask import Flask, jsonify, send_from_directory
import mysql.connector
from datetime import datetime, timedelta
import os
import sys

app = Flask(__name__, static_folder='public')

# Enable debug mode via environment variable
DEBUG_MODE = os.environ.get('DEBUG', 'false').lower() == 'true'

# Database configuration
DB_CONFIG = {
    'host': os.environ.get('DB_HOST', 'localhost'),
    'port': int(os.environ.get('DB_PORT', 3306)),
    'user': os.environ.get('DB_USER', '570005354'),
    'password': os.environ.get('DB_PASS', '570005354'),
    'database': os.environ.get('DB_NAME', 'shopdb')
}

def debug_log(message):
    """Print debug messages to console/PM2 logs"""
    print(f"[DEBUG] {message}", file=sys.stderr, flush=True)

# Get database connection
def get_db_connection():
    if DEBUG_MODE:
        debug_log(f"Attempting database connection to {DB_CONFIG['host']}:{DB_CONFIG['port']}")
        debug_log(f"Database: {DB_CONFIG['database']}, User: {DB_CONFIG['user']}")

    try:
        conn = mysql.connector.connect(**DB_CONFIG)
        if DEBUG_MODE:
            debug_log(f"Database connection successful! MySQL version: {conn.get_server_info()}")
        return conn
    except mysql.connector.Error as err:
        debug_log(f"Database connection FAILED: {err}")
        debug_log(f"Error code: {err.errno}")
        debug_log(f"SQL state: {err.sqlstate if hasattr(err, 'sqlstate') else 'N/A'}")
        raise

# Serve static files (index.html, logo, etc)
@app.route('/')
def index():
    return send_from_directory('public', 'index.html')

@app.route('/<path:path>')
def static_files(path):
    return send_from_directory('public', path)

# API endpoint to get notifications
@app.route('/api/notifications')
def get_notifications():
    try:
        if DEBUG_MODE:
            debug_log("=== API /api/notifications called ===")

        now = datetime.now()
        future = now + timedelta(hours=72)  # 72 hours from now

        if DEBUG_MODE:
            debug_log(f"Time window: {now} to {future}")

        # Connect to database
        if DEBUG_MODE:
            debug_log("Connecting to database...")
        conn = get_db_connection()
        cursor = conn.cursor(dictionary=True)

        if DEBUG_MODE:
            debug_log("Database cursor created")

        # Query with isshopfloor filter and 72-hour window
        query = """
            SELECT n.notificationid, n.notification, n.starttime, n.endtime, n.ticketnumber, n.link,
                   n.isactive, n.isshopfloor, nt.typename, nt.typecolor
            FROM notifications n
            LEFT JOIN notificationtypes nt ON n.notificationtypeid = nt.notificationtypeid
            WHERE n.isactive = 1
            AND n.isshopfloor = 1
            AND (
                (n.starttime <= %s AND (n.endtime IS NULL OR n.endtime >= %s))
                OR (n.starttime BETWEEN %s AND %s)
            )
            ORDER BY n.starttime ASC
        """

        if DEBUG_MODE:
            debug_log("Executing query...")

        cursor.execute(query, (future, now, now, future))

        if DEBUG_MODE:
            debug_log("Query executed, fetching results...")

        rows = cursor.fetchall()

        if DEBUG_MODE:
            debug_log(f"Fetched {len(rows)} rows from database")

        cursor.close()
        conn.close()

        # Convert bit fields to boolean and datetime to ISO strings
        if DEBUG_MODE:
            debug_log("Converting data types...")

        for row in rows:
            row['isactive'] = bool(row['isactive'])
            row['isshopfloor'] = bool(row['isshopfloor'])
            if row['starttime']:
                row['starttime'] = row['starttime'].isoformat()
            if row['endtime']:
                row['endtime'] = row['endtime'].isoformat()

        if DEBUG_MODE:
            debug_log("Data conversion complete")

        # Categorize notifications
        current_events = []
        upcoming_events = []

        for notification in rows:
            start = datetime.fromisoformat(notification['starttime'])
            end = datetime.fromisoformat(notification['endtime']) if notification['endtime'] else None

            if start <= now and (end is None or end >= now):
                current_events.append(notification)
            else:
                upcoming_events.append(notification)

        if DEBUG_MODE:
            debug_log(f"Categorized: {len(current_events)} current, {len(upcoming_events)} upcoming")

        # Sort current events by severity priority, then by starttime
        # Priority: Incident (danger) > Change (warning) > Awareness/TBD (success)
        severity_priority = {
            'danger': 1,   # Incident - highest priority
            'warning': 2,  # Change
            'success': 3,  # Awareness/TBD - lowest priority
            'secondary': 4 # Fallback
        }

        current_events.sort(key=lambda x: (
            severity_priority.get(x['typecolor'], 4),
            datetime.fromisoformat(x['starttime'])
        ))

        # Upcoming events stay sorted by starttime only
        upcoming_events.sort(key=lambda x: datetime.fromisoformat(x['starttime']))

        return jsonify({
            'success': True,
            'timestamp': datetime.now().isoformat(),
            'current': current_events,
            'upcoming': upcoming_events
        })

    except mysql.connector.Error as err:
        import traceback
        error_details = {
            'success': False,
            'error': f'Database error: {str(err)}',
            'error_code': err.errno if hasattr(err, 'errno') else None,
            'error_msg': err.msg if hasattr(err, 'msg') else str(err),
            'traceback': traceback.format_exc()
        }
        print(f"DATABASE ERROR: {error_details}")  # Log to console/PM2
        return jsonify(error_details), 500
    except Exception as e:
        import traceback
        error_details = {
            'success': False,
            'error': f'Server error: {str(e)}',
            'type': type(e).__name__,
            'traceback': traceback.format_exc()
        }
        print(f"SERVER ERROR: {error_details}")  # Log to console/PM2
        return jsonify(error_details), 500

# Health check endpoint
@app.route('/health')
def health():
    return jsonify({
        'status': 'ok',
        'timestamp': datetime.now().isoformat()
    })

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 3001))
    print(f'Shopfloor Dashboard running on port {port}')
    print(f'Access at: http://localhost:{port}')
    print(f'DEBUG MODE: {"ENABLED" if DEBUG_MODE else "DISABLED"}')
    print(f'Database: {DB_CONFIG["host"]}:{DB_CONFIG["port"]}/{DB_CONFIG["database"]}')
    print(f'To enable debug logging: set DEBUG=true environment variable')
    app.run(host='0.0.0.0', port=port, debug=False)