quantum-framework 0.18.0__py3-none-any.whl

quantum_admin/assets/quantum-source-highlight.js

@@ -0,0 +1,106 @@
+(function(){
+  var code = document.getElementById('sourceCode');
+  var gutter = document.getElementById('sourceGutter');
+  if(!code || !gutter) return;
+
+  var html = code.innerHTML;
+  var lines = html.split('\n');
+
+  // Build gutter line numbers
+  var g = '';
+  for(var i = 1; i <= lines.length; i++) g += '<div>' + i + '</div>';
+  gutter.innerHTML = g;
+
+  // Detect file type from page title (format: "Source: path/file.ext - Quantum Admin")
+  var ext = '';
+  var title = document.title || '';
+  var m = title.match(/\.(\w+)\s/);
+  if(m) ext = m[1].toLowerCase();
+
+  // Escaped entities in rendered HTML
+  var LT = '&lt;';
+  var GT = '&gt;';
+  var QUOT = '&quot;';
+  var AMP = '&amp;';
+  var APOS = '&#x27;';
+
+  function s(cls, content) {
+    return '<span class="' + cls + '">' + content + '</span>';
+  }
+
+  var h = html;
+
+  if(ext === 'q' || ext === 'html' || ext === 'xml') {
+    // Comments: &lt;!-- ... --&gt;
+    h = h.replace(new RegExp(LT + '!--[\\s\\S]*?--' + GT, 'g'), function(m){ return s('hl-cmt', m); });
+    // Tags: &lt;tagname and &lt;/tagname
+    h = h.replace(new RegExp('(' + LT + '\\/?)((?:[a-zA-Z][\\w:.-]*))', 'g'), function(m, pre, tag){
+      return s('hl-punct', pre) + s('hl-tag', tag);
+    });
+    // Closing &gt;
+    h = h.replace(new RegExp('(\\/?\\s*)' + GT, 'g'), function(m, pre){
+      return pre + s('hl-punct', GT);
+    });
+    // Attributes: name="value"
+    h = h.replace(new RegExp('([a-zA-Z][\\w:-]*)=' + QUOT + '([^]*?)' + QUOT, 'g'), function(m, attr, val){
+      return s('hl-attr', attr) + '=' + s('hl-str', QUOT + val + QUOT);
+    });
+    // SQL keywords (for q:query content)
+    h = h.replace(/\b(SELECT|FROM|WHERE|INSERT|UPDATE|DELETE|JOIN|LEFT|RIGHT|INNER|OUTER|ON|AND|OR|NOT|ORDER\s+BY|GROUP\s+BY|HAVING|LIMIT|OFFSET|AS|INTO|VALUES|SET|CREATE|DROP|ALTER|TABLE|INDEX|DISTINCT|COUNT|SUM|AVG|MAX|MIN|FILTER|TRUE|FALSE|DESC|ASC|LIKE|IN|IS|NULL|BETWEEN|EXISTS|UNION|CASE|WHEN|THEN|ELSE|END)\b/g, function(m){ return s('hl-sql', m); });
+    // Databinding expressions {var}
+    h = h.replace(/(\{[^}<\n]+?\})/g, function(m){ return s('hl-var', m); });
+  } else if(ext === 'py') {
+    // Comments (careful not to match inside strings)
+    h = h.replace(/(#[^\n]*)/g, function(m){ return s('hl-cmt', m); });
+    // Strings
+    h = h.replace(new RegExp('(f?' + QUOT + '[^' + AMP + ']*?' + QUOT + ')', 'g'), function(m){ return s('hl-str', m); });
+    h = h.replace(new RegExp("(f?'[^'\\n]*')", 'g'), function(m){ return s('hl-str', m); });
+    // Keywords
+    h = h.replace(/\b(def|class|import|from|return|if|elif|else|for|while|try|except|finally|with|as|raise|pass|break|continue|yield|lambda|in|not|and|or|is|True|False|None|self|async|await|global|nonlocal)\b/g, function(m){ return s('hl-kw', m); });
+    // Decorators
+    h = h.replace(/(@\w+)/g, function(m){ return s('hl-dec', m); });
+    // Numbers
+    h = h.replace(/\b(\d+\.?\d*)\b/g, function(m){ return s('hl-num', m); });
+    // Built-in functions
+    h = h.replace(/\b(print|len|range|str|int|float|list|dict|set|tuple|open|type|isinstance|getattr|setattr|hasattr|enumerate|zip|map|filter|sorted|reversed|super|property|staticmethod|classmethod)\b(?=\s*\()/g, function(m){ return s('hl-fn', m); });
+  } else if(ext === 'yaml' || ext === 'yml') {
+    h = h.replace(/(#[^\n]*)/g, function(m){ return s('hl-cmt', m); });
+    h = h.replace(/^(\s*)([\w][\w.-]*)(:)/gm, function(m, sp, key, colon){
+      return sp + s('hl-attr', key) + s('hl-punct', colon);
+    });
+    h = h.replace(/\b(true|false|null|yes|no)\b/gi, function(m){ return s('hl-kw', m); });
+    h = h.replace(/\b(\d+\.?\d*)\b/g, function(m){ return s('hl-num', m); });
+  } else if(ext === 'json') {
+    h = h.replace(new RegExp('(' + QUOT + '[^' + AMP + ']*?' + QUOT + ')\\s*:', 'g'), function(m, key){
+      return s('hl-attr', key) + ':';
+    });
+    h = h.replace(new RegExp(':\\s*(' + QUOT + '[^' + AMP + ']*?' + QUOT + ')', 'g'), function(m, val){
+      return ': ' + s('hl-str', val);
+    });
+    h = h.replace(/\b(true|false|null)\b/g, function(m){ return s('hl-kw', m); });
+    h = h.replace(/\b(\d+\.?\d*)\b/g, function(m){ return s('hl-num', m); });
+  } else if(ext === 'css') {
+    h = h.replace(/(\/\*[\s\S]*?\*\/)/g, function(m){ return s('hl-cmt', m); });
+    h = h.replace(/([\w-]+)\s*(?=:)/g, function(m, prop){ return s('hl-attr', prop); });
+    h = h.replace(/(\d+\.?\d*)(px|em|rem|%|vh|vw|s|ms|deg)/g, function(m, num, unit){ return s('hl-num', num + unit); });
+    h = h.replace(/(#[0-9a-fA-F]{3,8})\b/g, function(m){ return s('hl-num', m); });
+  } else if(ext === 'js' || ext === 'ts') {
+    h = h.replace(/(\/\/[^\n]*)/g, function(m){ return s('hl-cmt', m); });
+    h = h.replace(/(\/\*[\s\S]*?\*\/)/g, function(m){ return s('hl-cmt', m); });
+    h = h.replace(new RegExp("('[^'\\n]*'|" + QUOT + '[^' + AMP + ']*?' + QUOT + '|`[^`]*`)', 'g'), function(m){ return s('hl-str', m); });
+    h = h.replace(/\b(function|const|let|var|return|if|else|for|while|do|switch|case|break|continue|class|new|this|import|export|from|default|async|await|try|catch|finally|throw|typeof|instanceof|in|of|true|false|null|undefined|void|delete)\b/g, function(m){ return s('hl-kw', m); });
+    h = h.replace(/\b(\d+\.?\d*)\b/g, function(m){ return s('hl-num', m); });
+  } else if(ext === 'md') {
+    // Headers
+    h = h.replace(/^(#{1,6}\s+.*)$/gm, function(m){ return s('hl-tag', m); });
+    // Bold/italic
+    h = h.replace(/(\*\*[^*]+\*\*)/g, function(m){ return s('hl-kw', m); });
+    h = h.replace(/(\*[^*]+\*)/g, function(m){ return s('hl-str', m); });
+    // Code blocks
+    h = h.replace(/(`[^`]+`)/g, function(m){ return s('hl-fn', m); });
+    // Links
+    h = h.replace(/(\[[^\]]+\]\([^)]+\))/g, function(m){ return s('hl-attr', m); });
+  }
+
+  code.innerHTML = h;
+})();

quantum_admin/backend/__init__.py

@@ -0,0 +1,4 @@
+"""
+Quantum Admin Backend
+"""
+__version__ = "1.0.0"

quantum_admin/backend/audit_service.py

@@ -0,0 +1,346 @@
+"""
+Audit Service for Quantum Admin
+Centralized audit logging for all user actions
+"""
+import json
+import logging
+from typing import Optional, List, Dict, Any
+from datetime import datetime, timedelta
+from sqlalchemy.orm import Session
+from sqlalchemy import desc
+
+logger = logging.getLogger(__name__)
+
+try:
+    from .models import AuditLog, Project
+except ImportError:
+    from models import AuditLog, Project
+
+
+# Action types
+class AuditAction:
+    # Authentication
+    LOGIN = "login"
+    LOGOUT = "logout"
+    LOGIN_FAILED = "login_failed"
+
+    # CRUD operations
+    CREATE = "create"
+    READ = "read"
+    UPDATE = "update"
+    DELETE = "delete"
+
+    # Deployment
+    DEPLOY = "deploy"
+    ROLLBACK = "rollback"
+    PROMOTE = "promote"
+
+    # Infrastructure
+    START = "start"
+    STOP = "stop"
+    RESTART = "restart"
+
+    # Configuration
+    CONFIG_CHANGE = "config_change"
+    SECRET_CHANGE = "secret_change"
+
+    # Tests
+    TEST_RUN = "test_run"
+    TEST_COMPLETE = "test_complete"
+
+
+def audit_log(
+    db: Session,
+    action: str,
+    resource_type: str = None,
+    resource_id: int = None,
+    resource_name: str = None,
+    user_id: str = None,
+    user_ip: str = None,
+    details: Dict[str, Any] = None,
+    project_id: int = None,
+    request_method: str = None,
+    request_path: str = None
+) -> AuditLog:
+    """
+    Create an audit log entry.
+
+    Args:
+        db: Database session
+        action: The action performed (use AuditAction constants)
+        resource_type: Type of resource affected (e.g., 'project', 'connector')
+        resource_id: ID of the resource
+        resource_name: Human-readable name of the resource
+        user_id: User who performed the action
+        user_ip: IP address of the user
+        details: Additional details as dictionary
+        project_id: Related project ID
+        request_method: HTTP method used
+        request_path: Request path
+
+    Returns:
+        The created AuditLog object
+    """
+    log_entry = AuditLog(
+        timestamp=datetime.utcnow(),
+        action=action,
+        resource_type=resource_type,
+        resource_id=resource_id,
+        resource_name=resource_name,
+        user_id=user_id,
+        user_ip=user_ip,
+        details=json.dumps(details) if details else None,
+        project_id=project_id,
+        request_method=request_method,
+        request_path=request_path
+    )
+
+    db.add(log_entry)
+    db.commit()
+    db.refresh(log_entry)
+
+    logger.info(f"Audit: {action} on {resource_type}:{resource_id} by {user_id}")
+    return log_entry
+
+
+def get_audit_logs(
+    db: Session,
+    project_id: int = None,
+    action: str = None,
+    resource_type: str = None,
+    user_id: str = None,
+    since: datetime = None,
+    until: datetime = None,
+    limit: int = 100,
+    offset: int = 0
+) -> List[AuditLog]:
+    """
+    Query audit logs with optional filters.
+
+    Args:
+        db: Database session
+        project_id: Filter by project
+        action: Filter by action type
+        resource_type: Filter by resource type
+        user_id: Filter by user
+        since: Filter entries after this time
+        until: Filter entries before this time
+        limit: Maximum number of entries to return
+        offset: Number of entries to skip
+
+    Returns:
+        List of AuditLog objects
+    """
+    query = db.query(AuditLog)
+
+    if project_id:
+        query = query.filter(AuditLog.project_id == project_id)
+    if action:
+        query = query.filter(AuditLog.action == action)
+    if resource_type:
+        query = query.filter(AuditLog.resource_type == resource_type)
+    if user_id:
+        query = query.filter(AuditLog.user_id == user_id)
+    if since:
+        query = query.filter(AuditLog.timestamp >= since)
+    if until:
+        query = query.filter(AuditLog.timestamp <= until)
+
+    return query.order_by(desc(AuditLog.timestamp)).offset(offset).limit(limit).all()
+
+
+def get_recent_activity(
+    db: Session,
+    limit: int = 10,
+    project_id: int = None
+) -> List[Dict]:
+    """
+    Get recent activity for dashboard display.
+
+    Returns a formatted list of recent actions.
+    """
+    query = db.query(AuditLog)
+
+    if project_id:
+        query = query.filter(AuditLog.project_id == project_id)
+
+    logs = query.order_by(desc(AuditLog.timestamp)).limit(limit).all()
+
+    activities = []
+    for log in logs:
+        # Format the activity message
+        if log.action == AuditAction.CREATE:
+            message = f"Created {log.resource_type}: {log.resource_name}"
+            icon = "plus"
+            color = "success"
+        elif log.action == AuditAction.UPDATE:
+            message = f"Updated {log.resource_type}: {log.resource_name}"
+            icon = "edit"
+            color = "info"
+        elif log.action == AuditAction.DELETE:
+            message = f"Deleted {log.resource_type}: {log.resource_name}"
+            icon = "trash"
+            color = "danger"
+        elif log.action == AuditAction.DEPLOY:
+            message = f"Deployed {log.resource_name}"
+            icon = "cloud-upload"
+            color = "primary"
+        elif log.action == AuditAction.ROLLBACK:
+            message = f"Rolled back {log.resource_name}"
+            icon = "rotate-ccw"
+            color = "warning"
+        elif log.action == AuditAction.LOGIN:
+            message = f"User {log.user_id} logged in"
+            icon = "log-in"
+            color = "success"
+        elif log.action == AuditAction.LOGOUT:
+            message = f"User {log.user_id} logged out"
+            icon = "log-out"
+            color = "muted"
+        elif log.action == AuditAction.START:
+            message = f"Started {log.resource_type}: {log.resource_name}"
+            icon = "play"
+            color = "success"
+        elif log.action == AuditAction.STOP:
+            message = f"Stopped {log.resource_type}: {log.resource_name}"
+            icon = "stop"
+            color = "warning"
+        elif log.action == AuditAction.TEST_RUN:
+            message = f"Started test run for {log.resource_name}"
+            icon = "check-circle"
+            color = "info"
+        else:
+            message = f"{log.action.title()}: {log.resource_name or log.resource_type}"
+            icon = "activity"
+            color = "muted"
+
+        activities.append({
+            "id": log.id,
+            "timestamp": log.timestamp.isoformat() if log.timestamp else None,
+            "message": message,
+            "icon": icon,
+            "color": color,
+            "user_id": log.user_id,
+            "action": log.action,
+            "resource_type": log.resource_type,
+            "resource_id": log.resource_id,
+            "project_id": log.project_id
+        })
+
+    return activities
+
+
+def get_audit_stats(
+    db: Session,
+    project_id: int = None,
+    days: int = 7
+) -> Dict:
+    """
+    Get audit statistics for a time period.
+    """
+    from sqlalchemy import func
+
+    since = datetime.utcnow() - timedelta(days=days)
+    query = db.query(AuditLog).filter(AuditLog.timestamp >= since)
+
+    if project_id:
+        query = query.filter(AuditLog.project_id == project_id)
+
+    total = query.count()
+
+    # Count by action type
+    action_counts = {}
+    for action in [AuditAction.CREATE, AuditAction.UPDATE, AuditAction.DELETE,
+                   AuditAction.DEPLOY, AuditAction.LOGIN]:
+        count = query.filter(AuditLog.action == action).count()
+        action_counts[action] = count
+
+    # Count by resource type
+    resource_counts = db.query(
+        AuditLog.resource_type,
+        func.count(AuditLog.id)
+    ).filter(AuditLog.timestamp >= since)
+
+    if project_id:
+        resource_counts = resource_counts.filter(AuditLog.project_id == project_id)
+
+    resource_counts = resource_counts.group_by(AuditLog.resource_type).all()
+
+    return {
+        "total": total,
+        "period_days": days,
+        "by_action": action_counts,
+        "by_resource": {r: c for r, c in resource_counts if r}
+    }
+
+
+class AuditService:
+    """Service class for audit operations"""
+
+    def __init__(self, db: Session):
+        self.db = db
+
+    def log(
+        self,
+        action: str,
+        resource_type: str = None,
+        resource_id: int = None,
+        resource_name: str = None,
+        user_id: str = None,
+        user_ip: str = None,
+        details: Dict = None,
+        project_id: int = None,
+        request_method: str = None,
+        request_path: str = None
+    ) -> AuditLog:
+        """Create an audit log entry"""
+        return audit_log(
+            self.db,
+            action=action,
+            resource_type=resource_type,
+            resource_id=resource_id,
+            resource_name=resource_name,
+            user_id=user_id,
+            user_ip=user_ip,
+            details=details,
+            project_id=project_id,
+            request_method=request_method,
+            request_path=request_path
+        )
+
+    def get_logs(
+        self,
+        project_id: int = None,
+        action: str = None,
+        resource_type: str = None,
+        user_id: str = None,
+        since: datetime = None,
+        until: datetime = None,
+        limit: int = 100,
+        offset: int = 0
+    ) -> List[AuditLog]:
+        """Query audit logs"""
+        return get_audit_logs(
+            self.db,
+            project_id=project_id,
+            action=action,
+            resource_type=resource_type,
+            user_id=user_id,
+            since=since,
+            until=until,
+            limit=limit,
+            offset=offset
+        )
+
+    def get_recent_activity(self, limit: int = 10, project_id: int = None) -> List[Dict]:
+        """Get recent activity for dashboard"""
+        return get_recent_activity(self.db, limit=limit, project_id=project_id)
+
+    def get_stats(self, project_id: int = None, days: int = 7) -> Dict:
+        """Get audit statistics"""
+        return get_audit_stats(self.db, project_id=project_id, days=days)
+
+
+def get_audit_service(db: Session) -> AuditService:
+    """Get audit service instance"""
+    return AuditService(db)