diff --git a/.coveragerc b/.coveragerc new file mode 100644 index 0000000..b4a41f1 --- /dev/null +++ b/.coveragerc @@ -0,0 +1,27 @@ +[run] +source = scidk +omit = + */tests/* + */test_*.py + */__pycache__/* + */migrations/* + scidk/__main__.py + # Exclude services not part of production MVP + scidk/services/commit_service.py + scidk/services/query_service.py + scidk/services/scan_index_service.py + scidk/services/link_migration.py + scidk/services/config.py + scidk/services/graphrag_examples.py + scidk/services/graphrag_llm.py + # Exclude experimental/optional features + scidk/interpreters/* + scidk/core/graphrag/* + +[report] +precision = 2 +show_missing = True +skip_covered = False + +[html] +directory = htmlcov diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 38fcb76..19d2f50 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -20,9 +20,19 @@ jobs: run: | python -m pip install --upgrade pip pip install -e .[dev] - - name: Run pytest (exclude E2E) + - name: Run pytest with coverage (exclude E2E) run: | - python -m pytest -q -m "not e2e" + python -m coverage run -m pytest -q -m "not e2e" + python -m coverage report + python -m coverage xml + - name: Upload coverage to Codecov + uses: codecov/codecov-action@v4 + with: + file: ./coverage.xml + fail_ci_if_error: false + - name: Check coverage threshold (50%) + run: | + python -m coverage report --fail-under=50 # E2E tests temporarily disabled in CI (Feb 2026) # The test suite has stability issues (auth conflicts, timing, cleanup) that need dedicated attention. diff --git a/.gitignore b/.gitignore index da78a8c..4e0731e 100644 --- a/.gitignore +++ b/.gitignore @@ -66,3 +66,4 @@ sqlite:/tmp # Added here as safety net to prevent leaking into main repo dev/code-imports/nc3rsEDA/ !dev/code-imports/nc3rsEDA/README.md +/logs/ diff --git a/DEMO_PROGRESS_INDICATORS.md b/DEMO_PROGRESS_INDICATORS.md new file mode 100644 index 0000000..79138a2 --- /dev/null +++ b/DEMO_PROGRESS_INDICATORS.md @@ -0,0 +1,208 @@ +# Demo: Progress Indicators for Long Operations + +This document provides demo steps for showcasing the progress indicators feature in SciDK. + +## Feature Overview + +**What it does**: Provides real-time visual feedback during long-running operations (scans, commits, reconciliations) including: +- Progress bars with percentage completion +- Real-time status updates (e.g., "Processing file 50/200...") +- Estimated time remaining +- Cancel button to abort operations +- Responsive UI that doesn't block during operations + +## Prerequisites + +1. SciDK application running (default: http://localhost:5000) +2. A directory with multiple files for scanning (20+ files recommended for visible progress) + +## Demo Steps + +### 1. Demonstrate Background Scan with Progress Tracking + +**Goal**: Show progress bar, status updates, and ETA during a scan operation. + +**Steps**: +1. Navigate to the Files page (`/datasets`) +2. In the "Provider Browser" section: + - Select "Filesystem" as the provider + - Select or enter a directory path with 20+ files + - Click "🔍 Scan This Folder" +3. Observe the "Scans Summary" section below: + - **Progress bar appears** showing completion percentage + - **Status message updates** in real-time (e.g., "Processing 50/200 files... (25/s)") + - **ETA displays** time remaining (e.g., "~2m remaining") + - Progress bar color: blue (running) → green (completed) + +**Expected Output**: +``` +scan running — /path/to/data — 50/200 (25%) — Processing 50/200 files... (25/s) — ~1m remaining [Cancel] +[Progress bar: ████████░░░░░░░░ 25%] +``` + +### 2. Demonstrate Real-Time Status Updates + +**Goal**: Show different status messages as the scan progresses. + +**Steps**: +1. Start a scan on a large directory (100+ files) +2. Watch the status message change through different phases: + - "Initializing scan..." + - "Counting files..." + - "Processing 500 files..." + - "Processing 150/500 files... (50/s)" + +**What to highlight**: +- Status messages provide context about what's happening +- Messages update automatically without page refresh +- Processing rate (files/second) is calculated and displayed + +### 3. Demonstrate Commit Progress + +**Goal**: Show progress tracking for Neo4j commit operations. + +**Steps**: +1. Complete a scan first (or use an existing scan) +2. In the "Scans Summary" section, find your scan +3. Click "Commit to Graph" button +4. Observe progress updates: + - "Preparing commit..." + - "Committing to in-memory graph..." + - "Building commit rows..." + - "Built commit rows: 200 files, 50 folders" + - "Writing to Neo4j..." + +**Expected Output**: +``` +commit running — /path/to/data — 200/201 (99%) — Writing to Neo4j... +[Progress bar: ███████████████░ 99%] +``` + +### 4. Demonstrate Cancel Functionality + +**Goal**: Show that long-running operations can be canceled. + +**Steps**: +1. Start a scan on a large directory (500+ files) +2. While the scan is running, locate the "Cancel" button next to the task +3. Click "Cancel" +4. Observe: + - Task status changes to "canceled" + - Progress bar stops updating + - Operation terminates gracefully + +**What to highlight**: +- Cancel button only appears for running tasks +- Canceled tasks are marked clearly +- System remains stable after cancellation + +### 5. Demonstrate UI Responsiveness + +**Goal**: Show that the UI remains interactive during long operations. + +**Steps**: +1. Start a long-running scan (100+ files) +2. While scan is in progress, try these interactions: + - Click the "Refresh" button → Works immediately + - Browse to a different folder → Navigation works + - Click through tabs → UI remains responsive + - Start another scan (up to 2 concurrent tasks) → Works + +**What to highlight**: +- Page doesn't freeze or become unresponsive +- Background tasks run independently +- User can continue working while operations complete + +### 6. Demonstrate Multiple Concurrent Tasks + +**Goal**: Show that multiple operations can run simultaneously with individual progress tracking. + +**Steps**: +1. Start a scan on directory A +2. Immediately start a scan on directory B +3. Observe: + - Both scans show independent progress bars + - Each has its own status message and ETA + - Both complete successfully + +**System Limits**: +- Default: Maximum 2 concurrent background tasks +- Configurable via `SCIDK_MAX_BG_TASKS` environment variable + +### 7. Demonstrate Progress History + +**Goal**: Show completed tasks remain visible for reference. + +**Steps**: +1. Complete several scan/commit operations +2. Observe the "Scans Summary" section: + - Completed tasks show "completed" status + - Progress bars are green + - All metadata preserved (file count, duration, path) + - Click scan ID or path to view details + +## Key Features Demonstrated + +✅ **Progress bars** - Visual indication of completion percentage +✅ **Real-time status updates** - "Processing file 50/200..." +✅ **Estimated time remaining** - "~2m remaining" +✅ **UI remains responsive** - No blocking during operations +✅ **Cancel button** - Ability to abort long operations +✅ **Processing rate** - Shows files/second throughput +✅ **Multiple concurrent tasks** - Up to 2 operations simultaneously +✅ **Graceful completion** - Green progress bar when done + +## Technical Details + +### Architecture +- **Backend**: Python threading for background tasks in `/api/tasks` endpoint +- **Frontend**: JavaScript polling (1-second interval) to fetch task status +- **Progress Calculation**: `processed / total` for percentage, rate-based ETA + +### API Endpoints +- `POST /api/tasks` - Create background task (scan or commit) +- `GET /api/tasks` - List all tasks with progress +- `GET /api/tasks/` - Get specific task details +- `POST /api/tasks//cancel` - Cancel running task + +### Progress Fields +```json +{ + "id": "task_id_here", + "type": "scan", + "status": "running", + "progress": 0.5, + "processed": 100, + "total": 200, + "eta_seconds": 120, + "status_message": "Processing 100/200 files... (50/s)", + "started": 1234567890.0, + "ended": null +} +``` + +## Troubleshooting + +**Progress not updating**: +- Check browser console for errors +- Verify polling is active (1-second interval) +- Check backend logs for task worker errors + +**ETA not shown**: +- ETA calculated after processing >10 files +- Very fast operations may complete before ETA displays +- This is normal behavior + +**Tasks stuck at "running"**: +- Check backend process isn't hung +- Verify file permissions for scan directory +- Check system resources (CPU, memory) + +## Future Enhancements (Not in This Release) + +- Server-Sent Events (SSE) for more efficient real-time updates +- WebSocket support for instant progress streaming +- Estimated time remaining for commit operations +- Detailed operation logs accessible from UI +- Resume capability for canceled operations +- Priority queue for task scheduling diff --git a/DEMO_SETUP.md b/DEMO_SETUP.md index 70e9815..3aad845 100644 --- a/DEMO_SETUP.md +++ b/DEMO_SETUP.md @@ -58,13 +58,16 @@ Open your browser and navigate to: **http://127.0.0.1:5000** | Page | URL | Purpose | |------|-----|---------| -| **Home** | `/` | Landing page, search, filters | -| **Chat** | `/chat` | Chat interface | -| **Files** | `/datasets` | Browse files, scans, snapshots | -| **Map** | `/map` | Graph visualization | -| **Labels** | `/labels` | Graph schema management | +| **Home** | `/` | Landing page, search, filters, quick chat | +| **Chat** | `/chat` | Full chat interface (multi-user) | +| **Files** | `/datasets` | Browse files, scans, snapshots, data cleaning | +| **Map** | `/map` | Graph visualization (Neo4j + local schema) | +| **Labels** | `/labels` | Graph schema management (3-column layout) | | **Links** | `/links` | Link definition wizard | -| **Settings** | `/settings` | Neo4j, interpreters, rclone | +| **Extensions** | `/extensions` | Plugin/extension management | +| **Integrations** | `/integrations` | External service integrations | +| **Settings** | `/settings` | Neo4j, interpreters, rclone, chat, plugins | +| **Login** | `/login` | User authentication | ## Creating Test Data @@ -176,9 +179,17 @@ The test suite creates temporary test data. You can reference `tests/conftest.py 5. Import file (File → Import → From JSON) 6. View/edit schema in Arrows -### Workflow 4: Link Creation +### Workflow 4: Integration & Link Creation -1. **Navigate** to Links page +**Option A: Configure External API Integration** +1. **Navigate** to Integrations page (`/integrations`) +2. **Configure** external service (API endpoint, auth) +3. **Test** connection to verify it works +4. **Save** integration configuration +5. **Navigate** to Links page to use the integration + +**Option B: Direct Link Creation** +1. **Navigate** to Links page (`/links`) 2. **Create** new link definition 3. **Choose** data source (CSV, API, or Cypher) 4. **Configure** source and target labels @@ -188,70 +199,123 @@ The test suite creates temporary test data. You can reference `tests/conftest.py ### Workflow 5: Search & Chat -1. **Home page**: Enter search query +**Quick Chat (from Home):** +1. **Home page**: Enter search query OR use quick chat input 2. **View** results filtered by type -3. **Navigate** to Chat page -4. **Ask** about indexed files -5. **Get** responses with file references +3. **Get** inline responses without leaving home + +**Full Chat Interface:** +1. **Navigate** to Chat page (`/chat`) +2. **Login** if using multi-user mode +3. **Ask** questions about indexed files +4. **Get** context-aware responses with file references +5. **View** conversation history (persisted per user) + +### Workflow 6: Data Cleaning + +1. **Navigate** to Files page (`/datasets`) +2. **Browse** snapshot or search for files +3. **Select** files to delete (individual or bulk) +4. **Click** delete button +5. **Confirm** deletion +6. **System** automatically cleans up: + - File nodes from graph + - Associated relationships + - Orphaned link records +7. **View** updated file list ## Configuration for Demo +### First-Time Setup: User Authentication + +1. **Navigate** to Login page (`/login`) - or you'll be redirected on first visit +2. **Create** an account (if no users exist, first user becomes admin) +3. **Login** with username/password +4. **Note**: Multi-user mode supports: + - Role-based access control (Admin/User) + - Per-user chat history + - Session management with auto-lock after inactivity + ### Neo4j Connection -1. Navigate to **Settings** page -2. Enter Neo4j details: +1. Navigate to **Settings** page (`/settings`) +2. Click **"Neo4j"** tab in settings +3. Enter Neo4j details: - URI: `bolt://localhost:7687` - Username: `neo4j` - Database: `neo4j` - Password: `[your password]` -3. Click **"Save Settings"** -4. Click **"Connect"** to test +4. Click **"Save Settings"** +5. Click **"Connect"** to test connection +6. Success message confirms connection ### Interpreter Configuration -1. On **Settings** page, scroll to "Interpreters" +1. On **Settings** page, click **"Interpreters"** tab 2. Enable desired interpreters: - CSV, JSON, YAML (common formats) - Python, Jupyter (code files) - Excel (workbooks) -3. Changes save automatically +3. Configure advanced settings: + - Suggest threshold + - Batch size +4. Click **"Save"** to apply changes ### Rclone Mounts (Optional) -1. On **Settings** page, scroll to "Rclone Mounts" +1. On **Settings** page, click **"Rclone"** tab 2. Configure remote: - Remote: `myremote:` - Subpath: `/folder/path` - Name: `MyRemote` - Read-only: checked (recommended for demo) 3. Click **"Create Mount"** +4. Click **"Refresh Mounts"** to see updated list -### API Endpoints (for Links Integration) +### Chat Backend Configuration -1. Navigate to **Settings** > **Links** section +1. On **Settings** page, click **"Chat"** tab +2. Configure chat backend: + - LLM service endpoint + - API key (if required) + - Context settings +3. Click **"Save Settings"** +4. Test by sending a message from Home or Chat page + +### External Service Integrations + +1. Navigate to **Integrations** page (`/integrations`) +2. Select an integration to configure +3. Enter service-specific settings: + - API endpoint URL + - Authentication credentials (encrypted at rest) + - JSONPath extraction (optional) + - Target label mapping (optional) +4. Click **"Test Connection"** to verify +5. Click **"Save"** to enable integration + +**OR** configure in Settings: +1. On **Settings** page, click **"Integrations"** tab 2. Scroll to "API Endpoint Mappings" -3. Configure a new endpoint: +3. Configure endpoint: - **Name**: Descriptive name (e.g., "Users API") - - **URL**: Full API endpoint URL (e.g., `https://api.example.com/users`) - - **Auth Method**: Select authentication type: - - `None`: No authentication - - `Bearer Token`: OAuth/JWT bearer token - - `API Key`: API key in X-API-Key header - - **Auth Value**: Enter token/key if authentication is required - - **JSONPath** (optional): Extract specific data (e.g., `$.data[*]`) - - **Maps to Label** (optional): Target Label for imported data -4. Click **"Test Connection"** to verify the endpoint -5. Click **"Save Endpoint"** to register it - -**Using API Endpoints in Links:** -- Registered endpoints appear in the Links wizard -- Select an endpoint as a data source when creating links -- Field mappings automatically populate from endpoint configuration + - **URL**: Full API endpoint (e.g., `https://api.example.com/users`) + - **Auth Method**: None, Bearer Token, or API Key + - **Auth Value**: Token/key if authentication required + - **JSONPath**: Extract specific data (e.g., `$.data[*]`) + - **Maps to Label**: Target label for imported data +4. Click **"Test Connection"** to verify +5. Click **"Save Endpoint"** to register + +**Using Integrations in Links:** +- Registered endpoints appear in Links wizard +- Select an endpoint as a data source +- Field mappings auto-populate from endpoint config **Security Notes:** -- Auth tokens are encrypted at rest in the settings database -- For production, set `SCIDK_API_ENCRYPTION_KEY` environment variable -- Without this variable, an ephemeral key is generated (not persistent across restarts) +- Auth tokens encrypted at rest in settings database +- Set `SCIDK_API_ENCRYPTION_KEY` environment variable for production +- Without this variable, ephemeral key is generated (not persistent across restarts) **Example: JSONPlaceholder Test API** ``` @@ -262,6 +326,19 @@ JSONPath: $[*] Maps to Label: User ``` +### Configuration Backup & Restore + +1. On **Settings** page, click **"General"** tab +2. Scroll to "Configuration Management" +3. **Export** settings: + - Click **"Export Settings"** + - Download JSON backup file +4. **Import** settings: + - Click **"Import Settings"** + - Select JSON backup file + - Confirm import + - Application restores all configurations + ## Troubleshooting ### Application Won't Start @@ -321,20 +398,50 @@ SCIDK_PORT=5001 scidk-serve ### During the Demo -- **Start at Home**: Show search and summary cards -- **Show Files workflow**: Browse → Detail → Interpretation -- **Demonstrate Graph**: Map visualization with filters -- **Highlight Schema**: Show Labels and relationships -- **Show Link Creation**: Quick wizard walkthrough -- **End with Chat**: Ask questions about the data +**Suggested Demo Flow:** +1. **Login**: Show authentication (multi-user support) +2. **Home Page**: + - Demonstrate search with filters + - Show summary cards (file count, scan count, extensions) + - Try quick chat input (inline responses) +3. **Files Workflow**: + - Browse → Scan → Snapshot → File Detail → Interpretation + - Show data cleaning (delete files, auto-cleanup relationships) +4. **Labels Page**: + - Show 3-column layout (list, editor, instance browser) + - Create/edit label with properties + - Define relationships + - Show keyboard navigation (arrow keys, Enter, Escape) + - Push schema to Neo4j +5. **Map Visualization**: + - Show combined view (in-memory + local labels + Neo4j schema) + - Demonstrate filters (labels, relationships) + - Show color-coding (blue/red/green for different sources) + - Adjust layout and appearance controls +6. **Integrations**: + - Configure external API endpoint + - Test connection + - Show encrypted credential storage +7. **Links Creation**: + - Quick wizard walkthrough + - Use configured integration as data source + - Preview and execute to create relationships +8. **Chat Interface**: + - Ask context-aware questions about indexed files + - Show conversation history (persisted per user) + - Demonstrate file references in responses +9. **Settings**: + - Show modular settings tabs (Neo4j, Interpreters, Rclone, Chat, etc.) + - Demonstrate configuration backup/restore ### Known Limitations (to mention if asked) - Scans are synchronous (page waits for completion) - Very large files (>10MB) may have limited preview -- Chat requires external LLM service (if not configured) +- Chat requires external LLM service configuration - Map rendering slows with 1000+ nodes -- Rclone features require rclone installed +- Rclone features require rclone installed on system +- Session auto-locks after inactivity (configurable timeout) ## Testing the Application @@ -418,6 +525,7 @@ python -m scidk.app ## Additional Resources +- **Feature Index**: `FEATURE_INDEX.md` (comprehensive feature list by page) - **Development Protocols**: `dev/README-planning.md` - **UX Testing Checklist**: `dev/ux-testing-checklist.md` - **E2E Testing Guide**: `docs/e2e-testing.md` diff --git a/FEATURE_INDEX.md b/FEATURE_INDEX.md new file mode 100644 index 0000000..51e78ec --- /dev/null +++ b/FEATURE_INDEX.md @@ -0,0 +1,647 @@ +# SciDK Feature Index + +**Purpose**: Current application layout and feature inventory for product planning and demo preparation. + +**Last Updated**: 2026-02-09 + +--- + +## Application Structure + +### Navigation & Pages + +| Page | Route | Primary Purpose | +|------|-------|----------------| +| Home | `/` | Landing page with search, filters, quick chat | +| Chat | `/chat` | Full chat interface (multi-user, database-persisted) | +| Files/Datasets | `/datasets` | Browse scans, manage file data, commit to Neo4j | +| File Detail | `/datasets/` | View file metadata and interpretations | +| Workbook Viewer | `/datasets//workbook` | Excel sheet preview with navigation | +| Map | `/map` | Interactive graph visualization (Neo4j + local schema) | +| Labels | `/labels` | Graph schema management (properties, relationships) | +| Links | `/links` | Link definition wizard (create relationships) | +| Extensions | `/extensions` | Plugin/extension management | +| Integrations | `/integrations` | External service integrations | +| Settings | `/settings` | Neo4j, interpreters, rclone, chat, plugins, integrations | +| Login | `/login` | User authentication (multi-user with RBAC) | + +--- + +## Feature Groups by Page + +### 1. Home Page (`/`) + +**Search & Discovery** +- Full-text file search with query input +- Filter by file extension +- Filter by interpreter type +- Provider/path-based filtering +- Recursive path toggle +- Reset filters option + +**Dashboard & Summary** +- File count display +- Scan count summary +- Extension breakdown +- Interpreter type summary +- Recent scans list + +**Quick Actions** +- Inline chat input (quick queries without leaving home) +- Direct navigation to all main pages + +--- + +### 2. Chat Page (`/chat`) + +**Conversation Interface** +- Full-featured chat UI with message history +- Context-aware responses (references indexed files/graph) +- Markdown rendering in responses +- Timestamped messages +- Scrollable history + +**Multi-User & Security** (Recent: PR #40) +- User authentication system +- Role-based access control (RBAC) +- Database-persisted chat history +- Per-user conversation isolation +- Admin role for system management + +**Session Management** (Recent: PR #44) +- Auto-lock after inactivity timeout +- Configurable timeout settings +- Session expiration handling + +--- + +### 3. Files/Datasets Page (`/datasets`) + +**Provider Browser Tab** +- Provider dropdown (filesystem, rclone remotes) +- Path selection and manual entry +- Recursive scan toggle +- Fast list mode (skip detailed metadata) +- Max depth control +- Browse before scan (preview file tree) +- Initiate scan with progress tracking + +**Snapshot Browser Tab** +- Scan dropdown (view historical scans) +- Snapshot file list with pagination +- Path prefix filter +- Extension/type filter +- Custom extension input +- Page size controls +- Previous/Next pagination +- "Use Live" switch (latest data) + +**Snapshot Search** +- Query input for snapshot data +- Extension-based search +- Prefix-based search +- Clear and reset options + +**Data Management** +- Commit snapshot to Neo4j +- Commit progress/status indicators +- Recent scans management +- Refresh scans list + +**RO-Crate Integration** +- Open RO-Crate viewer modal +- Display RO-Crate metadata +- Export capability + +**Data Cleaning Workflow** (Recent: PR #46) +- Delete individual files from dataset +- Bulk delete multiple files +- Bidirectional relationship cleanup (removes orphaned links) +- Confirmation prompts for destructive actions +- Real-time UI updates after deletion + +--- + +### 4. File Detail Page (`/datasets/`) + +**Metadata Display** +- Filename, full path +- File size, last modified +- Checksum/ID +- Provider information + +**Interpretation Viewer** +- Multiple interpretation tabs (CSV, JSON, YAML, Python, etc.) +- CSV: Table preview +- JSON: Formatted/collapsible tree +- Python: Syntax-highlighted code +- YAML: Structured display +- Excel: Sheet selector (links to workbook viewer) + +**Actions** +- Back navigation +- Copy path/ID to clipboard +- View raw content +- Navigate to related files + +--- + +### 5. Workbook Viewer (`/datasets//workbook`) + +**Sheet Navigation** +- Sheet selector dropdown +- Switch between sheets +- Active sheet indicator + +**Table Preview** +- Rendered table with headers +- Formatted cell values +- Horizontal/vertical scrolling +- Row/column count display +- Preview limit indicator (first N rows) + +**Navigation** +- Back to file detail +- Back to files list +- Breadcrumb navigation + +--- + +### 6. Map/Graph Visualization (`/map`) + +**Graph Display** +- Interactive node/edge rendering +- Auto-layout on load +- Node labels and colors +- Relationship edges +- Color-coded sources: + - Blue: In-memory graph (scanned data) + - Red: Local labels (definitions only) + - Green: Neo4j schema (pulled from database) + - Mixed colors: Combined sources + +**Data Source Selection** +- "All Sources" (combined view, default) +- "In-Memory Graph" (scanned files only) +- "Local Labels" (schema definitions) +- "Neo4j Schema" (pulled from database) + +**Filtering** +- Label type filter dropdown +- Relationship type filter +- Multiple filter combinations +- Clear filters option + +**Layout Controls** +- Layout mode selector (force-directed, circular, etc.) +- Save positions button +- Load saved positions +- Re-layout on demand + +**Appearance Controls** +- Node size slider +- Edge width slider +- Font size slider +- High contrast toggle +- Immediate visual updates + +**Interaction** +- Click and drag nodes +- Pan graph canvas +- Zoom in/out (mousewheel) +- Click nodes for details +- Click edges for relationship info + +**Export & Instance Preview** +- Download CSV (graph data export) +- Instance preview selector +- "Preview Instances" button +- Formatted instance data display + +--- + +### 7. Labels Page (`/labels`) + +**Schema Definition** (Recent: PR #38 - Three-column layout with instance browser) +- Three-column layout: + - Left: Label list sidebar (resizable, 200px-50% width) + - Center: Label editor/wizard + - Right: Instance browser (shows actual nodes for selected label) +- Create new labels +- Edit existing labels +- Define label properties (name, type: string/int/float/etc.) +- Add/remove properties +- Property type dropdown + +**Relationship Management** +- Add relationships to labels +- Define relationship name +- Select target label +- Define relationship properties (optional) +- Remove relationships + +**Neo4j Synchronization** +- Push to Neo4j (local → database) +- Pull from Neo4j (database → local) +- Success/failure feedback +- Sync status indicators + +**Arrows.app Integration** +- Import schema from Arrows.app (JSON) +- Export schema to Arrows.app +- Paste JSON or upload file +- Bidirectional workflow support + +**Label Operations** +- Delete label (with confirmation) +- Save label changes +- Validation feedback + +**Keyboard Navigation** (Recent: PR #37) +- Arrow Up/Down: Navigate label list +- Home/End: Jump to first/last +- PageUp/PageDown: Navigate 10 items at a time +- Enter: Open selected label in editor +- Escape: Return focus to sidebar +- Visual focus indicators +- Auto-scroll to focused item + +**Instance Browser** (Recent: PR #38) +- View actual nodes for selected label +- Instance count display +- Property values preview +- Pagination for large instance sets +- Link to node details + +**Resizable Layout** (Recent: PR #38) +- Draggable divider between sidebar and editor +- Min/max width constraints (200px - 50%) +- Resize cursor indicator +- Persistent layout preferences + +--- + +### 8. Links Page (`/links`) + +**Link Definition Wizard** +- Multi-step wizard interface +- Link name input +- Data source selection: + - CSV data source (paste CSV) + - API endpoint source (URL + JSONPath) + - Cypher query source (direct Neo4j query) +- Target label configuration +- Field mapping (source → target properties) +- Relationship type definition +- Relationship property mapping +- Preview sample links +- Save definition + +**Link Management** +- List of saved definitions +- Select/view/edit definitions +- Delete definition (with confirmation) +- Duplicate definition names prevented + +**Execution** +- Execute link button (per definition) +- Execution progress indicator +- Success message (# relationships created) +- Error handling and feedback + +**Jobs & History** +- Link execution jobs list +- Job status (pending, running, completed, failed) +- View job details (logs, errors) +- Re-run failed jobs (if supported) + +**Keyboard Navigation** +- Arrow Up/Down: Navigate link definitions +- Home/End: Jump to first/last +- PageUp/PageDown: Navigate 10 items at a time +- Enter: Open selected link in wizard +- Escape: Return focus to sidebar +- Visual focus indicators +- Auto-scroll to focused item + +**Resizable Layout** +- Draggable divider between sidebar and wizard +- Min/max width constraints (200px - 50%) +- Matches Labels page structure +- Resize cursor indicator +- Highlight during resize + +--- + +### 9. Extensions Page (`/extensions`) + +**Plugin Management** +- View installed extensions +- Enable/disable extensions +- Extension metadata display +- Configuration options (per extension) + +--- + +### 10. Integrations Page (`/integrations`) + +**External Service Configuration** +- List of available integrations +- Configure integration settings +- Test connections +- Enable/disable integrations + +--- + +### 11. Settings Page (`/settings`) + +**Modular Settings Structure** (Recent: PR #43 - Template partials) +Settings organized into separate template files for maintainability: + +**General Settings** (`_general.html`) +- Application-wide configurations +- Session timeout settings +- UI preferences + +**Neo4j Configuration** (`_neo4j.html`) +- URI input (default: bolt://localhost:7687) +- Username input (default: neo4j) +- Database name input (default: neo4j) +- Password input with show/hide toggle +- Save settings button +- Connect/disconnect buttons +- Connection test with feedback +- Test graph operations button + +**Interpreter Configuration** (`_interpreters.html`) +- List of available interpreters +- Enable/disable toggle per interpreter +- File extension associations display +- Advanced settings: + - Suggest threshold input + - Batch size input +- Save button for interpreter settings + +**Rclone Mounts Configuration** (`_rclone.html`) +- Remote input field +- Subpath input field +- Mount name input +- Read-only checkbox +- Create mount button +- Mount list display +- Refresh mounts button +- Remove mount option + +**Chat Settings** (`_chat.html`) +- Chat backend configuration +- LLM service settings +- Context settings + +**Plugin Settings** (`_plugins.html`) +- Plugin-specific configurations +- Plugin enable/disable controls + +**Integrations Settings** (`_integrations.html`) +- Integration service configurations +- API endpoint mappings: + - Name, URL, Auth Method (None/Bearer/API Key) + - Auth value (encrypted at rest) + - JSONPath extraction + - Maps to Label (optional) + - Test connection button + - Save endpoint button +- Encrypted credential storage +- Test endpoint connections + +**Alerts Settings** (`_alerts.html`) (Recent: task:ops/monitoring/alert-system) +- Alert/notification system for critical events +- SMTP Configuration: + - Host, port, username, password (encrypted) + - From address, TLS toggle + - Test email button + - Save configuration +- Alert Definitions: + - Pre-configured alerts: + - Import Failed + - High Discrepancies (threshold: 50) + - Backup Failed + - Neo4j Connection Lost + - Disk Space Critical (threshold: 95%) + - Enable/disable toggles + - Recipient configuration (comma-separated emails) + - Threshold adjustment (where applicable) + - Test alert button (sends test notification) + - Update button +- Alert History: + - Recent alert trigger history + - Success/failure status + - Condition details + - Timestamp tracking +- Backend integration: + - Backup manager triggers backup_failed alerts + - Extensible for scan/import, reconciliation, health checks + - Alert trigger logging and tracking + +**Configuration Backup/Restore** (Recent: PR #41) +- Export all settings to JSON +- Import settings from JSON backup +- Secure authentication for backup operations +- Validation on import +- Success/error feedback + +--- + +### 12. Login Page (`/login`) + +**Authentication** (Recent: PR #40) +- Username/password form +- Session creation +- Redirect to home after login +- Error handling + +**Security Features** +- Password hashing (bcrypt) +- Session management +- CSRF protection +- Role-based permissions check + +--- + +## Cross-Cutting Features + +### Security & Access Control (Recent: PR #40) +- Multi-user authentication system +- Role-based access control (RBAC): + - Admin: Full system access + - User: Standard access to features +- Session-based authentication +- Password encryption (bcrypt) +- Database-persisted user accounts +- Permissions checks on endpoints +- Auto-lock after inactivity (PR #44) + +### Data Cleaning (Recent: PR #46) +- Delete files from datasets (individual or bulk) +- Bidirectional relationship cleanup: + - Remove File nodes + - Remove associated relationships + - Clean up orphaned link records +- Confirmation prompts +- Real-time UI updates +- Error handling and rollback + +### Configuration Management (Recent: PR #41) +- Export/import all settings (JSON format) +- Backup and restore workflows +- Secure credential handling (encrypted at rest) +- Validation on import +- Test authentication before backup operations + +### Session Management (Recent: PR #44) +- Configurable inactivity timeout +- Auto-lock and redirect to login +- Session expiration handling +- Persistent session state + +### Template Modularization (Recent: PR #43) +- Settings page broken into template partials: + - `_general.html`, `_neo4j.html`, `_interpreters.html` + - `_rclone.html`, `_chat.html`, `_plugins.html`, `_integrations.html` +- Improved maintainability +- Easier to add new settings sections + +--- + +## Technical Capabilities + +### Data Sources +- Local filesystem scanning +- Rclone remote providers +- API endpoints (with auth: Bearer, API Key) +- CSV/JSON data import +- Direct Neo4j Cypher queries + +### File Interpretation +- CSV (table preview) +- JSON (formatted tree) +- YAML (structured display) +- Python (syntax-highlighted) +- Jupyter notebooks +- Excel workbooks (multi-sheet) +- Generic text files +- Binary file handling (hex preview) + +### Graph Database Integration +- Neo4j connection (Bolt protocol) +- Schema push/pull synchronization +- Node and relationship creation +- Cypher query execution +- Graph visualization +- Instance browsing + +### Search & Indexing +- Full-text search (SQLite FTS) +- Extension-based filtering +- Interpreter-based filtering +- Path-based filtering +- Provider-based filtering +- Recursive/non-recursive scans + +### Export & Integration +- CSV export (graph data) +- RO-Crate metadata export +- Arrows.app schema import/export +- Configuration backup/restore (JSON) +- API endpoint integration + +--- + +## Architecture Notes + +### Database Stack +- **SQLite**: File index, scan history, settings, chat history, user accounts +- **Neo4j**: Graph database (optional, for visualization and relationships) + +### Frontend +- **Flask**: Python web framework +- **Jinja2**: Template engine (modular partials) +- **JavaScript**: Interactive UI (graph rendering, drag/drop, keyboard nav) + +### Authentication +- **Flask-Login**: Session management +- **Bcrypt**: Password hashing +- **RBAC**: Role-based permissions + +### Testing +- **Playwright E2E**: TypeScript tests (`e2e/*.spec.ts`) +- **Pytest**: Python unit/integration tests +- **98.3% interactive element coverage** (117/119 elements) + +--- + +## Demo-Ready Features + +### Critical Path Working +✅ Scan a folder (local filesystem) +✅ Browse scanned files +✅ View file interpretations +✅ Commit to Neo4j +✅ Visualize graph in Map +✅ Search files +✅ Chat interface (with multi-user support) + +### Recent Improvements (Feb 2026) +✅ Multi-user authentication with RBAC (PR #40) +✅ Configuration backup/restore (PR #41) +✅ Modular settings templates (PR #43) +✅ Auto-lock after inactivity (PR #44) +✅ Data cleaning with bidirectional relationship management (PR #46) +✅ Three-column Labels layout with instance browser (PR #38) +✅ Comprehensive keyboard navigation (PR #37) + +--- + +## Usage Patterns + +### Common Workflows + +**1. File Discovery & Interpretation** +Home → Files → Scan → Browse Snapshot → File Detail → View Interpretations + +**2. Graph Visualization** +Settings → Connect Neo4j → Labels → Define Schema → Push to Neo4j → Files → Commit → Map → Visualize + +**3. Schema Design with Arrows.app** +Arrows.app → Export JSON → Labels → Import → Edit/Refine → Push to Neo4j → Map + +**4. Link Creation** +Labels → Define Labels → Links → Create Definition → Configure Source/Target → Preview → Execute → Map + +**5. Search & Chat** +Home → Search Query → View Results → Chat → Ask Questions → Get Context-Aware Responses + +**6. Data Cleaning** +Files → Browse Snapshot → Select Files → Delete (individual or bulk) → Confirm → Refresh + +**7. Configuration Management** +Settings → Configure All Services → Export Settings → (Later) Import Settings to Restore + +--- + +## Known Limitations + +- Scans are synchronous (page waits for completion) +- Very large files (>10MB) may have limited preview +- Chat requires external LLM service (if not configured) +- Map rendering slows with 1000+ nodes +- Rclone features require rclone installed on system + +--- + +## References + +- **UX Testing Checklist**: `dev/ux-testing-checklist.md` +- **Demo Setup Guide**: `DEMO_SETUP.md` +- **Dev Protocols**: `dev/README-planning.md` +- **E2E Testing Guide**: `docs/e2e-testing.md` +- **Test Coverage Index**: `dev/test-coverage-index.md` diff --git a/backups/scidk-backup-20260208_175156-3a9edd69.zip b/backups/scidk-backup-20260208_175156-3a9edd69.zip deleted file mode 100644 index 2da208d..0000000 Binary files a/backups/scidk-backup-20260208_175156-3a9edd69.zip and /dev/null differ diff --git a/backups/scidk-backup-20260210_031853-85217c23.zip b/backups/scidk-backup-20260210_031853-85217c23.zip new file mode 100644 index 0000000..159e4e0 Binary files /dev/null and b/backups/scidk-backup-20260210_031853-85217c23.zip differ diff --git a/backups/scidk-backup-20260210_070000-17137b43.zip b/backups/scidk-backup-20260210_070000-17137b43.zip new file mode 100644 index 0000000..0ed2742 Binary files /dev/null and b/backups/scidk-backup-20260210_070000-17137b43.zip differ diff --git a/backups/scidk-backup-20260210_070000-40a80893.zip b/backups/scidk-backup-20260210_070000-40a80893.zip new file mode 100644 index 0000000..1afa66a Binary files /dev/null and b/backups/scidk-backup-20260210_070000-40a80893.zip differ diff --git a/dev b/dev index fa3e22d..012c053 160000 --- a/dev +++ b/dev @@ -1 +1 @@ -Subproject commit fa3e22d6a59b334aa36ff5596161bf0a87fe6f69 +Subproject commit 012c05337dbeb5ca6dc0b56a05ac91fe17eb62e0 diff --git a/docs/API.md b/docs/API.md new file mode 100644 index 0000000..3f37934 --- /dev/null +++ b/docs/API.md @@ -0,0 +1,745 @@ +# SciDK API Reference + +This document provides a comprehensive guide to the SciDK REST API, including authentication, common operations, and endpoint reference. + +## Base URL + +``` +http://localhost:5000 +``` + +For production deployments, replace with your domain: +``` +https://your-domain.com +``` + +## API Documentation (Swagger/OpenAPI) + +Interactive API documentation is available at: +``` +http://localhost:5000/api/docs +``` + +This provides a complete, interactive reference with the ability to test endpoints directly from your browser. + +## Authentication + +SciDK supports multiple authentication methods depending on your configuration. + +### Session-Based Authentication + +For web UI access, log in through the login page: + +**Endpoint**: `POST /api/auth/login` + +**Request**: +```json +{ + "username": "admin", + "password": "your_password" +} +``` + +**Response**: +```json +{ + "status": "success", + "user": { + "username": "admin", + "role": "admin" + } +} +``` + +The session cookie is automatically set and used for subsequent requests. + +### Bearer Token Authentication + +For API access, use Bearer tokens: + +**Request Header**: +``` +Authorization: Bearer YOUR_TOKEN_HERE +``` + +**Example**: +```bash +curl -H "Authorization: Bearer abc123..." \ + http://localhost:5000/api/health +``` + +### No Authentication (Development) + +For development or testing, authentication can be disabled (not recommended for production): +```bash +export SCIDK_AUTH_DISABLED=true +``` + +## Common API Operations + +### Health Check + +Check application and database status: + +```bash +curl http://localhost:5000/api/health +``` + +**Response**: +```json +{ + "status": "healthy", + "sqlite": { + "path": "/home/user/.scidk/db/files.db", + "exists": true, + "journal_mode": "wal", + "wal_mode": true, + "schema_version": 5, + "select1": true + } +} +``` + +### Graph Health + +Check Neo4j connection and graph statistics: + +```bash +curl http://localhost:5000/api/health/graph +``` + +**Response**: +```json +{ + "status": "connected", + "nodes": { + "File": 1245, + "Folder": 89, + "Scan": 12 + }, + "relationships": { + "CONTAINS": 1334, + "SCANNED_IN": 1245 + } +} +``` + +## File and Dataset Operations + +### List Scans + +```bash +curl http://localhost:5000/api/scans +``` + +**Response**: +```json +{ + "scans": [ + { + "id": "scan_123", + "path": "/data/project", + "recursive": true, + "timestamp": "2024-01-15T10:30:00Z", + "file_count": 1245, + "status": "completed" + } + ] +} +``` + +### Create New Scan + +```bash +curl -X POST http://localhost:5000/api/scans \ + -H "Content-Type: application/json" \ + -d '{ + "provider_id": "local_fs", + "path": "/data/project", + "recursive": true + }' +``` + +**Response**: +```json +{ + "status": "success", + "scan_id": "scan_456", + "message": "Scan started" +} +``` + +### Get Scan Status + +```bash +curl http://localhost:5000/api/scans/scan_456/status +``` + +**Response**: +```json +{ + "scan_id": "scan_456", + "status": "in_progress", + "file_count": 523, + "progress": 42 +} +``` + +### List Files in Scan + +```bash +curl http://localhost:5000/api/scans/scan_456/files?page=1&limit=50 +``` + +**Response**: +```json +{ + "files": [ + { + "id": "file_123", + "name": "data.csv", + "path": "/data/project/data.csv", + "size": 1024000, + "modified": "2024-01-15T09:00:00Z", + "extension": ".csv" + } + ], + "total": 1245, + "page": 1, + "per_page": 50 +} +``` + +### Get File Details + +```bash +curl http://localhost:5000/api/datasets/file_123 +``` + +**Response**: +```json +{ + "id": "file_123", + "name": "data.csv", + "path": "/data/project/data.csv", + "size": 1024000, + "modified": "2024-01-15T09:00:00Z", + "interpretations": [ + { + "type": "csv", + "rows": 100, + "columns": 5, + "preview": [...] + } + ] +} +``` + +### Delete File(s) + +Delete single file: +```bash +curl -X DELETE http://localhost:5000/api/datasets/file_123 +``` + +Bulk delete: +```bash +curl -X POST http://localhost:5000/api/datasets/bulk-delete \ + -H "Content-Type: application/json" \ + -d '{"file_ids": ["file_123", "file_456"]}' +``` + +## Graph and Label Operations + +### List Labels + +```bash +curl http://localhost:5000/api/labels +``` + +**Response**: +```json +{ + "labels": [ + { + "name": "File", + "properties": [ + {"name": "path", "type": "string"}, + {"name": "size", "type": "integer"} + ], + "relationships": [ + { + "name": "SCANNED_IN", + "target": "Scan" + } + ] + } + ] +} +``` + +### Create Label + +```bash +curl -X POST http://localhost:5000/api/labels \ + -H "Content-Type: application/json" \ + -d '{ + "name": "Dataset", + "properties": [ + {"name": "name", "type": "string"}, + {"name": "created", "type": "datetime"} + ] + }' +``` + +### Get Label Instances + +```bash +curl http://localhost:5000/api/labels/File/instances?page=1&limit=10 +``` + +**Response**: +```json +{ + "label": "File", + "instances": [ + { + "id": "file_123", + "properties": { + "path": "/data/project/data.csv", + "size": 1024000 + } + } + ], + "total": 1245, + "page": 1 +} +``` + +### Push Labels to Neo4j + +```bash +curl -X POST http://localhost:5000/api/labels/File/push +``` + +### Pull Labels from Neo4j + +```bash +curl -X POST http://localhost:5000/api/labels/pull +``` + +### Import Schema from Arrows.app + +```bash +curl -X POST http://localhost:5000/api/labels/import/arrows \ + -H "Content-Type: application/json" \ + -d '{"schema": {...}}' +``` + +### Export Schema to Arrows.app + +```bash +curl http://localhost:5000/api/labels/export/arrows +``` + +## Link Operations + +### List Link Definitions + +```bash +curl http://localhost:5000/api/links +``` + +**Response**: +```json +{ + "links": [ + { + "id": "link_123", + "name": "File to Dataset", + "source_type": "csv", + "target_label": "Dataset" + } + ] +} +``` + +### Create Link Definition + +```bash +curl -X POST http://localhost:5000/api/links \ + -H "Content-Type: application/json" \ + -d '{ + "name": "File to Dataset", + "source": { + "type": "csv", + "data": "...", + "mapping": {...} + }, + "target": { + "label": "Dataset", + "mapping": {...} + } + }' +``` + +### Execute Link + +```bash +curl -X POST http://localhost:5000/api/links/link_123/execute +``` + +**Response**: +```json +{ + "status": "success", + "job_id": "job_789", + "message": "Link execution started" +} +``` + +### Get Link Execution Job Status + +```bash +curl http://localhost:5000/api/integrations/jobs/job_789 +``` + +**Response**: +```json +{ + "job_id": "job_789", + "status": "completed", + "relationships_created": 145, + "started_at": "2024-01-15T10:00:00Z", + "completed_at": "2024-01-15T10:05:00Z" +} +``` + +## Integration Operations + +### List API Endpoints + +```bash +curl http://localhost:5000/api/integrations +``` + +**Response**: +```json +{ + "endpoints": [ + { + "id": "ep_123", + "name": "External API", + "url": "https://api.example.com/data", + "auth_method": "bearer", + "target_label": "ExternalData" + } + ] +} +``` + +### Create API Endpoint + +```bash +curl -X POST http://localhost:5000/api/integrations \ + -H "Content-Type: application/json" \ + -d '{ + "name": "External API", + "url": "https://api.example.com/data", + "auth_method": "bearer", + "auth_value": "token_here", + "jsonpath": "$.data[*]", + "target_label": "ExternalData" + }' +``` + +### Test Endpoint Connection + +```bash +curl -X POST http://localhost:5000/api/integrations/ep_123/preview +``` + +## Settings Operations + +### Export Configuration + +```bash +curl -X GET http://localhost:5000/api/settings/export \ + -H "Authorization: Bearer YOUR_TOKEN" \ + -o scidk-config.json +``` + +### Import Configuration + +```bash +curl -X POST http://localhost:5000/api/settings/import \ + -H "Content-Type: application/json" \ + -d @scidk-config.json +``` + +### Get Neo4j Settings + +```bash +curl http://localhost:5000/api/settings/neo4j +``` + +**Response**: +```json +{ + "uri": "bolt://localhost:7687", + "user": "neo4j", + "database": "neo4j", + "connected": true +} +``` + +### Update Neo4j Settings + +```bash +curl -X POST http://localhost:5000/api/settings/neo4j \ + -H "Content-Type: application/json" \ + -d '{ + "uri": "bolt://localhost:7687", + "user": "neo4j", + "password": "password", + "database": "neo4j" + }' +``` + +## Alert Operations + +### List Alerts + +```bash +curl http://localhost:5000/api/settings/alerts +``` + +**Response**: +```json +{ + "alerts": [ + { + "id": "alert_import_failed", + "name": "Import Failed", + "enabled": true, + "recipients": "admin@example.com", + "threshold": null + } + ] +} +``` + +### Update Alert Configuration + +```bash +curl -X PUT http://localhost:5000/api/settings/alerts/alert_import_failed \ + -H "Content-Type: application/json" \ + -d '{ + "enabled": true, + "recipients": "admin@example.com,ops@example.com" + }' +``` + +### Test Alert + +```bash +curl -X POST http://localhost:5000/api/settings/alerts/alert_import_failed/test +``` + +### Get Alert History + +```bash +curl http://localhost:5000/api/settings/alerts/history?limit=50 +``` + +**Response**: +```json +{ + "history": [ + { + "alert_id": "alert_import_failed", + "triggered_at": "2024-01-15T12:30:00Z", + "condition": "Import failed for scan_456", + "sent": true + } + ] +} +``` + +## Chat Operations + +### Send Chat Message + +```bash +curl -X POST http://localhost:5000/api/chat/message \ + -H "Content-Type: application/json" \ + -d '{ + "message": "What files are in /data/project?", + "context": true + }' +``` + +**Response**: +```json +{ + "response": "I found 1,245 files in /data/project...", + "sources": [ + {"scan_id": "scan_123", "file_count": 1245} + ] +} +``` + +### Get Chat History + +```bash +curl http://localhost:5000/api/chat/history?limit=50 +``` + +## Error Response Format + +All API errors follow a consistent format: + +```json +{ + "status": "error", + "error": "Error message", + "code": "ERROR_CODE", + "details": {} +} +``` + +### Common Error Codes + +| HTTP Code | Meaning | Example | +|-----------|---------|---------| +| 400 | Bad Request | Invalid JSON or missing required fields | +| 401 | Unauthorized | Missing or invalid authentication | +| 403 | Forbidden | Insufficient permissions | +| 404 | Not Found | Resource doesn't exist | +| 409 | Conflict | Duplicate resource or constraint violation | +| 500 | Internal Server Error | Unexpected server error | +| 502 | Bad Gateway | Neo4j connection failed | +| 503 | Service Unavailable | Service temporarily unavailable | + +### Example Error Response + +```json +{ + "status": "error", + "error": "File not found", + "code": "FILE_NOT_FOUND", + "details": { + "file_id": "file_999" + } +} +``` + +## Rate Limiting + +API rate limiting may be configured in production deployments. Check response headers: + +``` +X-RateLimit-Limit: 1000 +X-RateLimit-Remaining: 999 +X-RateLimit-Reset: 1673798400 +``` + +## Pagination + +List endpoints support pagination: + +**Query Parameters**: +- `page`: Page number (default: 1) +- `limit`: Items per page (default: 50, max: 1000) + +**Response Headers**: +``` +X-Total-Count: 1245 +X-Page: 1 +X-Per-Page: 50 +``` + +## Filtering and Sorting + +Many list endpoints support filtering and sorting: + +**Query Parameters**: +- `filter[field]`: Filter by field value +- `sort`: Sort field (prefix with `-` for descending) + +**Example**: +```bash +curl "http://localhost:5000/api/scans?filter[status]=completed&sort=-timestamp" +``` + +## WebSocket Support (Future) + +WebSocket support for real-time updates is planned for future releases. + +## SDK and Client Libraries + +Official client libraries: +- **Python**: `pip install scidk-client` (planned) +- **JavaScript**: `npm install @scidk/client` (planned) + +## Examples + +### Complete Workflow Example + +```bash +# 1. Check health +curl http://localhost:5000/api/health + +# 2. Start a scan +SCAN_ID=$(curl -X POST http://localhost:5000/api/scans \ + -H "Content-Type: application/json" \ + -d '{"path": "/data", "recursive": true}' \ + | jq -r '.scan_id') + +# 3. Check scan status +curl http://localhost:5000/api/scans/$SCAN_ID/status + +# 4. List files from scan +curl http://localhost:5000/api/scans/$SCAN_ID/files + +# 5. Commit to Neo4j +curl -X POST http://localhost:5000/api/scans/$SCAN_ID/commit + +# 6. Query graph +curl http://localhost:5000/api/health/graph +``` + +### Python Example + +```python +import requests + +base_url = "http://localhost:5000" + +# Start scan +response = requests.post(f"{base_url}/api/scans", json={ + "path": "/data/project", + "recursive": True +}) +scan_id = response.json()["scan_id"] + +# Wait for completion (polling) +import time +while True: + status = requests.get(f"{base_url}/api/scans/{scan_id}/status").json() + if status["status"] == "completed": + break + time.sleep(5) + +# Get files +files = requests.get(f"{base_url}/api/scans/{scan_id}/files").json() +print(f"Found {len(files['files'])} files") +``` + +## Additional Resources + +- **Interactive API Docs**: http://localhost:5000/api/docs +- **Deployment Guide**: [DEPLOYMENT.md](DEPLOYMENT.md) +- **Operations Manual**: [OPERATIONS.md](OPERATIONS.md) +- **Troubleshooting**: [TROUBLESHOOTING.md](TROUBLESHOOTING.md) +- **Security**: [SECURITY.md](SECURITY.md) diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md new file mode 100644 index 0000000..9f78199 --- /dev/null +++ b/docs/ARCHITECTURE.md @@ -0,0 +1,684 @@ +# SciDK Architecture Documentation + +This document provides a comprehensive overview of SciDK's system design, technology choices, component interactions, data flow, and scalability considerations. + +## System Overview + +SciDK is a scientific data knowledge management system that bridges filesystem data with graph-based knowledge representation. The architecture is designed for: + +- **Flexibility**: Support multiple data sources (local, cloud, API) +- **Extensibility**: Plugin-based interpreter system +- **Scalability**: Efficient indexing and querying of large datasets +- **Maintainability**: Clean separation of concerns with modular design + +### High-Level Architecture + +``` +┌─────────────────────────────────────────────────────────────┐ +│ Web Browser │ +│ (User Interface Layer) │ +└────────────────────────┬────────────────────────────────────┘ + │ HTTPS +┌────────────────────────▼────────────────────────────────────┐ +│ Flask Web Server │ +│ ┌─────────────┐ ┌──────────────┐ ┌──────────────────┐ │ +│ │ UI Routes │ │ API Routes │ │ Authentication │ │ +│ │ (Jinja2) │ │ (REST/JSON) │ │ & Authorization │ │ +│ └─────────────┘ └──────────────┘ └──────────────────┘ │ +└────────────────────────┬────────────────────────────────────┘ + │ +┌────────────────────────▼────────────────────────────────────┐ +│ Core Services Layer │ +│ ┌──────────────┐ ┌───────────────┐ ┌─────────────────┐ │ +│ │ Filesystem │ │ Interpreter │ │ Config │ │ +│ │ Manager │ │ Registry │ │ Manager │ │ +│ └──────────────┘ └───────────────┘ └─────────────────┘ │ +│ ┌──────────────┐ ┌───────────────┐ ┌─────────────────┐ │ +│ │ Backup │ │ Alert │ │ Plugin │ │ +│ │ Manager │ │ Manager │ │ Loader │ │ +│ └──────────────┘ └───────────────┘ └─────────────────┘ │ +└────────────────────────┬────────────────────────────────────┘ + │ +┌────────────────────────▼────────────────────────────────────┐ +│ Data Layer │ +│ ┌──────────────┐ ┌──────────────────┐ │ +│ │ SQLite │ │ Neo4j │ │ +│ │ Database │ │ Graph Database │ │ +│ │ │ │ (Optional) │ │ +│ │ • Files │ │ • Nodes │ │ +│ │ • Scans │ │ • Relationships │ │ +│ │ • Settings │ │ • Schema │ │ +│ │ • Users │ │ • Instances │ │ +│ │ • Audit Log │ │ │ │ +│ └──────────────┘ └──────────────────┘ │ +└─────────────────────────────────────────────────────────────┘ +``` + +## Technology Stack + +### Core Technologies + +**Backend Framework**: Flask 3.0+ +- **Why Flask**: Lightweight, flexible, extensive ecosystem +- **Advantages**: Easy to extend, well-documented, Python ecosystem integration +- **Alternatives Considered**: FastAPI (async support), Django (too heavyweight) + +**Primary Database**: SQLite 3 +- **Why SQLite**: + - Zero-configuration, embedded database + - ACID compliant + - WAL mode for concurrent access + - Single-file portability +- **Use Cases**: + - File index and metadata + - Scan history + - User accounts and settings + - Audit logs + - Configuration storage +- **Limitations**: + - Not ideal for high-concurrency writes (mitigated with WAL mode) + - No built-in graph queries (use Neo4j for this) + +**Graph Database**: Neo4j 5.x (Optional) +- **Why Neo4j**: + - Industry-leading graph database + - Cypher query language + - ACID transactions + - Built-in graph algorithms +- **Use Cases**: + - Knowledge graph storage + - Relationship queries + - Graph visualization + - Schema management +- **Deployment**: Docker container or standalone instance + +### Supporting Technologies + +**Python Libraries**: +- **ijson**: Streaming JSON parsing for large files +- **openpyxl**: Excel file interpretation +- **PyYAML**: YAML file parsing +- **pandas**: Data analysis and CSV handling +- **bcrypt**: Password hashing +- **cryptography**: Symmetric encryption for sensitive data +- **APScheduler**: Background job scheduling +- **flasgger**: OpenAPI/Swagger documentation + +**Frontend**: +- **Jinja2**: Server-side templating +- **JavaScript**: Interactive UI components +- **Cytoscape.js**: Graph visualization (alternative: vis.js) +- **Bootstrap**: UI framework (responsive design) + +**External Tools** (Optional): +- **ncdu/gdu**: Fast filesystem enumeration +- **rclone**: Cloud storage integration +- **nginx**: Reverse proxy and SSL termination + +## Component Architecture + +### Web Layer + +**Blueprint Structure** (9 blueprints, 91+ routes): + +```python +scidk/web/routes/ +├── ui.py # User interface routes +├── api_files.py # File and dataset operations +├── api_graph.py # Graph queries and visualization +├── api_labels.py # Schema/label management +├── api_links.py # Link definitions and execution +├── api_integrations.py # External API integrations +├── api_settings.py # Settings and configuration +├── api_auth.py # Authentication endpoints +└── api_chat.py # Chat interface +``` + +**Advantages**: +- Clean separation of concerns +- Easy to add new features +- Improved testability +- Reduced file size (app.py reduced from 5,781 to 645 lines) + +### Core Services + +**FilesystemManager**: +- Orchestrates file scanning and indexing +- Manages multiple provider backends (local, mounted, rclone) +- Coordinates with interpreter registry +- Handles batch processing + +**InterpreterRegistry**: +- Plugin-based system for file interpretation +- Extensible architecture for new file types +- Built-in interpreters: + - CSV (tabular data) + - JSON (structured data) + - YAML (configuration files) + - Python (code analysis: imports, functions, classes) + - Excel (multi-sheet workbooks) + - Jupyter notebooks (.ipynb) + - Generic text + +**GraphBackend**: +- Abstract interface for graph operations +- Implementations: + - InMemoryGraph (default, no external dependencies) + - Neo4jGraph (persistent, production-ready) +- Supports: + - Node and relationship creation + - Schema management + - Cypher query execution + - Commit operations with verification + +**ConfigManager**: +- Centralized configuration management +- Export/import functionality +- Encrypted credential storage +- Version tracking +- Automatic backups before changes + +**BackupManager**: +- Scheduled backup operations +- Configurable retention policies +- Backup verification +- Alert integration on failure + +**AlertManager**: +- Event-driven notification system +- SMTP email delivery +- Alert history tracking +- Configurable thresholds +- Pre-configured alerts: + - Import failures + - High discrepancies + - Backup failures + - Neo4j connection loss + - Disk space critical + +### Data Flow + +#### File Scanning Flow + +``` +User Initiates Scan + │ + ▼ +┌───────────────────┐ +│ API: POST /scans │ +└────────┬──────────┘ + │ + ▼ +┌──────────────────────────┐ +│ FilesystemManager │ +│ • Validate path │ +│ • Select provider │ +│ • Create scan record │ +└────────┬─────────────────┘ + │ + ▼ +┌──────────────────────────┐ +│ Provider Backend │ +│ (LocalFS/Rclone) │ +│ • Enumerate files │ +│ • Collect metadata │ +└────────┬─────────────────┘ + │ + ▼ +┌──────────────────────────┐ +│ InterpreterRegistry │ +│ • Match file types │ +│ • Run interpreters │ +│ • Generate metadata │ +└────────┬─────────────────┘ + │ + ▼ +┌──────────────────────────┐ +│ SQLite: Batch Insert │ +│ • Store file metadata │ +│ • Store interpretations │ +│ • Update scan status │ +└────────┬─────────────────┘ + │ + ▼ + Scan Complete +``` + +#### Commit to Graph Flow + +``` +User Commits Scan + │ + ▼ +┌──────────────────────────┐ +│ API: POST /scans/commit │ +└────────┬─────────────────┘ + │ + ▼ +┌──────────────────────────┐ +│ Load Scan Data from DB │ +│ • Fetch files │ +│ • Fetch folders │ +│ • Build hierarchy │ +└────────┬─────────────────┘ + │ + ▼ +┌──────────────────────────┐ +│ GraphBackend │ +│ • Create/merge nodes │ +│ • Create relationships │ +│ • Set properties │ +└────────┬─────────────────┘ + │ + ▼ +┌──────────────────────────┐ +│ Post-Commit Verification │ +│ • Count expected records │ +│ • Query actual records │ +│ • Report discrepancies │ +└────────┬─────────────────┘ + │ + ▼ + Commit Verified +``` + +#### Label Management Flow + +``` +User Defines Label + │ + ▼ +┌──────────────────────────┐ +│ API: POST /labels │ +│ • Name, properties │ +│ • Relationships │ +└────────┬─────────────────┘ + │ + ▼ +┌──────────────────────────┐ +│ Local Label Storage │ +│ (SQLite) │ +└────────┬─────────────────┘ + │ + ▼ +User Pushes to Neo4j + │ + ▼ +┌──────────────────────────┐ +│ GraphBackend.push_schema │ +│ • Create constraints │ +│ • Create indexes │ +│ • Define relationships │ +└────────┬─────────────────┘ + │ + ▼ + Schema in Neo4j +``` + +## Database Schema + +### SQLite Tables + +**files**: +```sql +CREATE TABLE files ( + id TEXT PRIMARY KEY, + scan_id TEXT, + path TEXT NOT NULL, + name TEXT, + size INTEGER, + modified REAL, + extension TEXT, + provider_id TEXT, + checksum TEXT, + FOREIGN KEY (scan_id) REFERENCES scans(id) +); +CREATE INDEX idx_files_scan ON files(scan_id); +CREATE INDEX idx_files_path ON files(path); +CREATE INDEX idx_files_extension ON files(extension); +``` + +**scans**: +```sql +CREATE TABLE scans ( + id TEXT PRIMARY KEY, + path TEXT NOT NULL, + recursive INTEGER, + timestamp REAL, + status TEXT, + file_count INTEGER, + provider_id TEXT +); +``` + +**users**: +```sql +CREATE TABLE users ( + id INTEGER PRIMARY KEY, + username TEXT UNIQUE NOT NULL, + password_hash TEXT NOT NULL, + role TEXT NOT NULL, + created_at REAL, + last_login REAL +); +``` + +**settings**: +```sql +CREATE TABLE settings ( + key TEXT PRIMARY KEY, + value TEXT, + updated_at TEXT +); +``` + +**audit_log**: +```sql +CREATE TABLE audit_log ( + id INTEGER PRIMARY KEY, + timestamp REAL NOT NULL, + event_type TEXT NOT NULL, + user TEXT, + ip_address TEXT, + details TEXT +); +``` + +### Neo4j Schema + +**Node Labels**: +- **File**: Individual files with properties (path, size, modified, extension) +- **Folder**: Directory nodes with properties (path, name) +- **Scan**: Scan session metadata (timestamp, path, recursive) +- **Custom Labels**: User-defined via Labels page + +**Relationships**: +- **(File)-[:SCANNED_IN]->(Scan)**: Files belong to scans +- **(Folder)-[:SCANNED_IN]->(Scan)**: Folders belong to scans +- **(File)-[:CONTAINED_IN]->(Folder)**: File hierarchy +- **(Folder)-[:CONTAINED_IN]->(Folder)**: Folder hierarchy +- **Custom Relationships**: User-defined via Links page + +## Scalability Considerations + +### Current Limitations + +1. **File Count**: Tested with datasets up to 100,000 files + - SQLite handles this well with proper indexing + - Graph visualization limited to ~1,000 nodes for UI performance + +2. **Concurrent Users**: Designed for 10-50 concurrent users + - WAL mode supports concurrent reads + - Single-writer model for SQLite + +3. **Data Size**: Individual file size limits: + - Preview generation: 10MB + - Full interpretation: 100MB + - Streaming for larger files + +### Scaling Strategies + +**Horizontal Scaling** (Future): +- Multiple app servers behind load balancer +- Shared PostgreSQL database (replace SQLite) +- Neo4j cluster for graph operations + +**Vertical Scaling** (Current): +- Increase server resources (RAM, CPU) +- SSD for database storage +- Optimize indexes and queries + +**Performance Optimization**: + +1. **Database Optimizations**: + ```sql + -- Enable WAL mode (done automatically) + PRAGMA journal_mode=WAL; + + -- Optimize query planner + ANALYZE; + + -- Reclaim space + VACUUM; + ``` + +2. **Caching**: + - In-memory caching for frequently accessed data + - Redis for distributed caching (future) + +3. **Batch Processing**: + - Process files in batches (default: 10,000) + - Commit to graph in batches + - Background job processing + +4. **Index Optimization**: + - Composite indexes for common queries + - Full-text search indexes + - Neo4j relationship indexes + +### Monitoring and Metrics + +**Application Metrics**: +- Request rate and latency +- Error rates by endpoint +- Active user sessions +- Background job queue depth + +**Database Metrics**: +- Query execution time +- Connection pool usage +- Database size and growth rate +- Index efficiency + +**System Metrics**: +- CPU and memory usage +- Disk I/O +- Network bandwidth +- Disk space available + +## Security Architecture + +See [SECURITY.md](SECURITY.md) for detailed security architecture. + +**Key Security Features**: +- Multi-user authentication with RBAC +- Session management with auto-lock +- Encrypted credential storage +- Comprehensive audit logging +- CSRF protection +- Input validation and sanitization + +## Extensibility + +### Plugin System + +**Interpreter Plugins**: +```python +# Example custom interpreter +from scidk.core.registry import Interpreter + +class MyInterpreter(Interpreter): + name = "my_format" + extensions = [".myext"] + + def interpret(self, file_path): + # Custom interpretation logic + return { + "type": "my_format", + "data": {...} + } + +# Register +registry.register(MyInterpreter()) +``` + +**Provider Plugins**: +```python +# Example custom provider +class MyProvider: + provider_id = "my_provider" + + def list_files(self, path): + # Custom file listing logic + return [...] + + def read_file(self, file_id): + # Custom file reading logic + return bytes +``` + +### API Extensibility + +**Custom Endpoints**: +```python +from flask import Blueprint + +custom_bp = Blueprint('custom', __name__, url_prefix='/api/custom') + +@custom_bp.route('/my-endpoint', methods=['GET']) +def my_endpoint(): + return {"message": "Custom endpoint"} + +# Register blueprint +app.register_blueprint(custom_bp) +``` + +## Design Decisions and Trade-offs + +### Why SQLite? + +**Advantages**: +- Zero configuration +- Single-file portability +- ACID compliance +- Built-in full-text search +- Python standard library support + +**Trade-offs**: +- Limited concurrency for writes (mitigated with WAL) +- No network access (local or mounted filesystem) +- Not ideal for distributed systems + +**When to Switch**: Consider PostgreSQL when: +- Need for multiple app servers +- High concurrent write load (>100 writes/sec) +- Distributed deployment required + +### Why Neo4j (Optional)? + +**Advantages**: +- Native graph queries (relationships are first-class) +- Cypher query language (declarative, powerful) +- Built-in graph algorithms +- Excellent visualization support + +**Trade-offs**: +- Additional infrastructure requirement +- Memory-intensive for large graphs +- Commercial licensing for enterprise features + +**When to Use**: +- Complex relationship queries +- Knowledge graph workflows +- Graph analytics requirements + +### Why Flask over FastAPI? + +**Flask Advantages**: +- Mature ecosystem +- Extensive documentation +- Synchronous model (simpler for most operations) +- Jinja2 integration for server-side rendering + +**FastAPI Advantages** (not chosen): +- Async/await support +- Automatic OpenAPI generation +- Better performance for I/O-bound operations + +**Decision**: Flask chosen for: +- Simpler synchronous model fits use case +- Rich plugin ecosystem +- Team expertise + +## Future Architecture Considerations + +### Planned Enhancements + +1. **Microservices Architecture** (Long-term): + - Separate scan service + - Separate graph service + - API gateway + +2. **Event-Driven Architecture**: + - Event bus (RabbitMQ, Kafka) + - Async processing + - Real-time updates via WebSockets + +3. **Containerization**: + - Docker images for all components + - Kubernetes orchestration + - Helm charts for deployment + +4. **Distributed Caching**: + - Redis for session storage + - Cached query results + - Distributed lock management + +5. **Advanced Analytics**: + - Machine learning integration + - Anomaly detection + - Predictive modeling + +## Deployment Architectures + +### Single Server (Current) + +``` +┌─────────────────────────────┐ +│ Single Server │ +│ ┌──────────────────────┐ │ +│ │ nginx (reverse │ │ +│ │ proxy) │ │ +│ └──────────┬───────────┘ │ +│ │ │ +│ ┌──────────▼───────────┐ │ +│ │ SciDK Flask App │ │ +│ │ (systemd service) │ │ +│ └──────────┬───────────┘ │ +│ │ │ +│ ┌──────────▼───────────┐ │ +│ │ SQLite + Neo4j │ │ +│ │ (local) │ │ +│ └──────────────────────┘ │ +└─────────────────────────────┘ +``` + +### High-Availability (Future) + +``` +┌──────────────┐ +│ Load Balancer│ +└──────┬───────┘ + │ + ┌───┴────┬────────┐ + │ │ │ +┌──▼──┐ ┌──▼──┐ ┌──▼──┐ +│App 1│ │App 2│ │App 3│ +└──┬──┘ └──┬──┘ └──┬──┘ + │ │ │ + └───┬───┴───┬───┘ + │ │ + ┌────▼───┐ ┌▼──────────┐ + │ Postgres│ │Neo4j │ + │ Cluster │ │Cluster │ + └─────────┘ └───────────┘ +``` + +## Additional Resources + +- **Deployment Guide**: [DEPLOYMENT.md](DEPLOYMENT.md) +- **Operations Manual**: [OPERATIONS.md](OPERATIONS.md) +- **API Reference**: [API.md](API.md) +- **Security Guide**: [SECURITY.md](SECURITY.md) +- **Feature Index**: [FEATURE_INDEX.md](../FEATURE_INDEX.md) +- **Testing Documentation**: [testing.md](testing.md) diff --git a/docs/DEMO_SETUP.md b/docs/DEMO_SETUP.md new file mode 100644 index 0000000..13996b1 --- /dev/null +++ b/docs/DEMO_SETUP.md @@ -0,0 +1,344 @@ +# Demo Setup Guide + +This guide explains how to set up and manage demo data for SciDK demonstrations and testing. + +## Overview + +SciDK includes a demo data seeding script (`scripts/seed_demo_data.py`) that creates a consistent set of sample data for demos and testing. This ensures every demo starts with the same baseline data. + +## Quick Start + +### Basic Demo Setup + +```bash +# Seed demo data (preserves existing data) +python scripts/seed_demo_data.py + +# Clean and reseed all data +python scripts/seed_demo_data.py --reset +``` + +### With Neo4j Graph Sync + +```bash +# Seed with Neo4j labels and relationships +python scripts/seed_demo_data.py --neo4j --reset +``` + +## What Gets Created + +### 👥 Demo Users + +Three demo users are created with password `demo123`: + +| Username | Password | Role | Use Case | +|----------|----------|------|----------| +| `admin` | `demo123` | Admin | Full system access, user management | +| `facility_staff` | `demo123` | User | Core facility operations | +| `billing_team` | `demo123` | User | Billing reconciliation workflows | + +### 📁 Sample Files + +Sample files are created in the `demo_data/` directory: + +``` +demo_data/ +├── Project_A_Cancer_Research/ +│ ├── experiments/ +│ │ ├── exp001_cell_culture.xlsx +│ │ └── exp002_drug_treatment.xlsx +│ ├── results/ +│ │ ├── microscopy/ +│ │ │ ├── sample_001.tif +│ │ │ └── sample_002.tif +│ │ └── flow_cytometry/ +│ │ └── analysis_20240115.fcs +│ ├── protocols/ +│ │ └── cell_culture_protocol.pdf +│ └── README.md +├── Project_B_Proteomics/ +│ ├── raw_data/ +│ │ ├── mass_spec_run001.raw +│ │ └── mass_spec_run002.raw +│ ├── analysis/ +│ │ ├── protein_identification.xlsx +│ │ └── go_enrichment.csv +│ ├── figures/ +│ │ └── volcano_plot.png +│ └── README.md +└── Core_Facility_Equipment/ + ├── equipment_logs/ + │ ├── confocal_microscope_2024.xlsx + │ └── flow_cytometer_2024.xlsx + ├── maintenance/ + │ └── service_records.pdf + ├── training/ + │ └── microscopy_training_slides.pdf + └── README.md +``` + +### 🏷️ Sample Labels (Neo4j) + +When run with `--neo4j` flag, the following labels are created: + +**Projects**: +- Cancer Research - Project A (PI: Dr. Alice Smith) +- Proteomics Study - Project B (PI: Dr. Bob Jones) +- Core Facility Operations (PI: Dr. Carol Williams) + +**Researchers**: +- Dr. Alice Smith (Oncology) +- Dr. Bob Jones (Biochemistry) +- Dr. Carol Williams (Core Facilities) + +**Equipment**: +- Confocal Microscope LSM 880 (Microscopy Core) +- Flow Cytometer BD FACS Aria III (Flow Cytometry Core) +- Mass Spectrometer Orbitrap Fusion (Proteomics Core) + +### 🔗 Sample Relationships + +- Dr. Alice Smith → LEADS → Cancer Research - Project A +- Dr. Bob Jones → LEADS → Proteomics Study - Project B +- Dr. Carol Williams → MANAGES → Core Facility Operations + +### 🧪 iLab Data (if plugin installed) + +If the iLab Data Importer plugin is installed, sample iLab export files are copied to `demo_data/iLab_Exports/`: +- `ilab_equipment_sample.csv` +- `ilab_services_sample.csv` +- `ilab_pi_directory_sample.csv` + +## Usage Scenarios + +### Scenario 1: Fresh Demo Environment + +Use this when setting up a new demo instance: + +```bash +# Clean everything and start fresh +python scripts/seed_demo_data.py --reset --neo4j + +# Start SciDK +python start.sh + +# Login as admin / demo123 +``` + +### Scenario 2: Preserving Existing Work + +Use this to add demo data without deleting existing work: + +```bash +# Add demo data alongside existing data +python scripts/seed_demo_data.py +``` + +### Scenario 3: Resetting After a Demo + +Use this to clean up after a demo and prepare for the next one: + +```bash +# Clean and reseed +python scripts/seed_demo_data.py --reset --neo4j +``` + +### Scenario 4: Testing Without Neo4j + +Use this for quick testing without Neo4j graph sync: + +```bash +# Seed users and files only +python scripts/seed_demo_data.py --reset +``` + +## Command-Line Options + +### `--reset` + +Cleans all existing demo data before seeding: +- Deletes demo users (admin, facility_staff, billing_team) +- Clears active sessions +- Removes demo labels from Neo4j (if `--neo4j` is used) +- Deletes `demo_data/` directory + +**Use with caution**: This will delete data! + +### `--neo4j` + +Enables Neo4j graph database seeding: +- Creates sample labels (Projects, Researchers, Equipment) +- Creates sample relationships between entities +- All demo entities are tagged with `source: 'demo'` for easy cleanup + +Requires Neo4j to be configured and running. + +### `--db-path TEXT` + +Specify custom path to settings database (default: `scidk_settings.db`). + +### `--pix-path TEXT` + +Specify custom path to path index database (default: `data/path_index.db`). + +## Idempotency + +The seeding script is designed to be idempotent: +- **Users**: Existing users are not overwritten +- **Files**: Existing files are not overwritten +- **Labels**: When using `--reset`, labels are cleaned first + +Run the script multiple times without `--reset` to safely add demo data without affecting existing work. + +## Demo Workflow + +### Before a Demo + +1. Clean and reseed data: + ```bash + python scripts/seed_demo_data.py --reset --neo4j + ``` + +2. Start SciDK: + ```bash + python start.sh + ``` + +3. Verify demo users work: + - Login as `admin / demo123` + - Verify `demo_data/` directory exists + +4. (Optional) Run a file scan: + ```bash + # In SciDK UI: Files > Scan Directory > demo_data/ + ``` + +### During a Demo + +Use the demo users to showcase different workflows: + +- **Admin user**: Show user management, settings, backups +- **Facility staff**: Show equipment logging, file scanning +- **Billing team**: Show iLab reconciliation (if plugin installed) + +### After a Demo + +Clean up for the next demo: +```bash +python scripts/seed_demo_data.py --reset --neo4j +``` + +## Customizing Demo Data + +### Adding Custom Files + +1. Create files in `demo_data/` directory +2. Modify `seed_sample_files()` function in `scripts/seed_demo_data.py` +3. Re-run the script + +### Adding Custom Labels + +1. Modify `seed_labels()` function in `scripts/seed_demo_data.py` +2. Add your custom Cypher queries +3. Re-run with `--neo4j` flag + +### Adding Custom Users + +1. Modify `seed_users()` function in `scripts/seed_demo_data.py` +2. Add user tuples: `(username, password, role)` +3. Re-run the script + +## Troubleshooting + +### Problem: Users already exist + +**Solution**: This is expected behavior. Existing users are not overwritten unless you use `--reset`. + +### Problem: Neo4j connection fails + +**Solution**: +1. Check Neo4j is running: `systemctl status neo4j` or check Docker +2. Verify connection settings in `scidk.config.yml` +3. Try without `--neo4j` flag for file/user seeding only + +### Problem: Permission denied on demo_data/ + +**Solution**: Ensure you have write permissions in the SciDK directory. + +### Problem: iLab files not created + +**Solution**: The iLab plugin must be installed at `plugins/ilab_table_loader/`. If not installed, iLab seeding is skipped automatically. + +### Problem: Script fails with import error + +**Solution**: Make sure you're running from the SciDK root directory and all dependencies are installed: +```bash +pip install -r requirements.txt +``` + +## Integration with Testing + +The demo data script can be used in automated tests: + +```python +import subprocess + +def setup_test_environment(): + """Set up test environment with demo data.""" + subprocess.run(['python', 'scripts/seed_demo_data.py', '--reset']) + +def test_demo_users_exist(): + """Test that demo users were created.""" + from scidk.core.auth import AuthManager + auth = AuthManager() + admin = auth.get_user_by_username('admin') + assert admin is not None + assert admin['role'] == 'admin' +``` + +## Data Structure Reference + +### User Roles + +| Role | Permissions | +|------|-------------| +| `admin` | Full access: user management, settings, backups, all features | +| `user` | Standard access: file scanning, labels, integrations (no user management) | + +### Demo Data Tagging + +All demo entities in Neo4j are tagged with `source: 'demo'` for easy identification and cleanup: + +```cypher +// Find all demo nodes +MATCH (n {source: 'demo'}) RETURN n + +// Delete all demo data +MATCH (n {source: 'demo'}) DETACH DELETE n +``` + +### File Organization + +Demo files follow a consistent structure: +- **Project directories**: Top-level organization by project +- **Subdirectories**: Organized by data type (raw_data, analysis, results, etc.) +- **README files**: Every project has a README describing its purpose + +## See Also + +- [Authentication Documentation](AUTHENTICATION.md) +- [Plugin System](plugins/README.md) +- [iLab Importer Plugin](plugins/ILAB_IMPORTER.md) +- [Neo4j Integration](GRAPH_INTEGRATION.md) + +## Support + +For issues with demo data seeding: +1. Check the troubleshooting section above +2. Review script output for error messages +3. Check SciDK logs for detailed error information +4. File an issue on the project repository + +--- + +**Last Updated**: 2026-02-10 diff --git a/docs/DEPLOYMENT.md b/docs/DEPLOYMENT.md new file mode 100644 index 0000000..ac04798 --- /dev/null +++ b/docs/DEPLOYMENT.md @@ -0,0 +1,473 @@ +# SciDK Deployment Guide + +This guide covers production deployment of SciDK, including installation, configuration, and common deployment scenarios. + +## Prerequisites + +### System Requirements + +- **OS**: Linux (Ubuntu 20.04+, RHEL 8+, or compatible), macOS 11+, or Windows 10+ with WSL2 +- **Python**: 3.10 or higher +- **Memory**: Minimum 2GB RAM, 4GB+ recommended for large datasets +- **Disk**: 10GB+ free space for application and data storage +- **Neo4j** (optional): 5.x or higher for graph database functionality + +### Required Software + +1. **Python 3.10+** with pip and venv +2. **Neo4j** (optional but recommended): For persistent graph storage +3. **rclone** (optional): For cloud storage provider integration +4. **ncdu or gdu** (optional): For faster filesystem scanning + +### Network Requirements + +- Default port: 5000 (Flask application) +- Neo4j Bolt: 7687 (if using Neo4j) +- Neo4j HTTP: 7474 (Neo4j Browser UI) + +## Installation + +### Standard Installation + +1. **Clone the repository**: + ```bash + git clone https://github.com/your-org/scidk.git + cd scidk + ``` + +2. **Create virtual environment**: + ```bash + python3 -m venv .venv + + # Activate (bash/zsh): + source .venv/bin/activate + + # Activate (fish): + source .venv/bin/activate.fish + ``` + +3. **Install dependencies**: + ```bash + # Production installation: + pip install -e . + + # Or with development dependencies: + pip install -e .[dev] + ``` + +4. **Initialize environment**: + ```bash + # bash/zsh: + source scripts/init_env.sh + + # Optional: create .env file + source scripts/init_env.sh --write-dotenv + ``` + +5. **Verify installation**: + ```bash + scidk-serve --help + ``` + +### Docker Deployment (Neo4j) + +SciDK includes Docker Compose configuration for Neo4j: + +1. **Set Neo4j password** (recommended): + ```bash + export NEO4J_AUTH=neo4j/your_secure_password + ``` + +2. **Start Neo4j**: + ```bash + docker compose -f docker-compose.neo4j.yml up -d + ``` + +3. **Verify Neo4j is running**: + ```bash + docker compose -f docker-compose.neo4j.yml ps + ``` + + Access Neo4j Browser at http://localhost:7474 + +## Configuration + +### Environment Variables + +Create a `.env` file in the project root or set environment variables: + +```bash +# Application +SCIDK_HOST=0.0.0.0 +SCIDK_PORT=5000 +SCIDK_CHANNEL=stable # stable, beta, or dev + +# Database +SCIDK_DB_PATH=~/.scidk/db/files.db +SCIDK_STATE_BACKEND=sqlite # sqlite or memory + +# Neo4j Configuration +NEO4J_URI=bolt://localhost:7687 +NEO4J_AUTH=neo4j/your_password +SCIDK_NEO4J_DATABASE=neo4j + +# Providers +SCIDK_PROVIDERS=local_fs,mounted_fs,rclone + +# Logging +SCIDK_LOG_LEVEL=INFO # DEBUG, INFO, WARNING, ERROR +``` + +### Neo4j Setup + +1. **Using Docker** (recommended): + ```bash + export NEO4J_AUTH=neo4j/neo4jiscool + docker compose -f docker-compose.neo4j.yml up -d + ``` + +2. **Using existing Neo4j instance**: + - Set `NEO4J_URI` to your Neo4j Bolt endpoint + - Set `NEO4J_AUTH` to `username/password` + - Ensure firewall allows connection to port 7687 + +3. **Configure in SciDK**: + - Start SciDK: `scidk-serve` + - Navigate to Settings → Neo4j + - Enter URI, username, password, and database name + - Click "Test Connection" to verify + - Click "Save" to persist settings + +### Rclone Configuration (Optional) + +For cloud storage integration: + +1. **Install rclone**: + ```bash + # Ubuntu/Debian: + sudo apt-get install rclone + + # macOS: + brew install rclone + ``` + +2. **Configure remote**: + ```bash + rclone config + ``` + +3. **Verify remote**: + ```bash + rclone listremotes + ``` + +4. **Enable in SciDK**: + ```bash + export SCIDK_PROVIDERS=local_fs,mounted_fs,rclone + ``` + +## systemd Service Setup (Linux) + +For production deployments, run SciDK as a systemd service: + +1. **Create service file** `/etc/systemd/system/scidk.service`: + ```ini + [Unit] + Description=SciDK Scientific Data Knowledge System + After=network.target neo4j.service + Wants=neo4j.service + + [Service] + Type=simple + User=scidk + Group=scidk + WorkingDirectory=/opt/scidk + Environment="PATH=/opt/scidk/.venv/bin" + Environment="SCIDK_HOST=0.0.0.0" + Environment="SCIDK_PORT=5000" + Environment="NEO4J_URI=bolt://localhost:7687" + Environment="NEO4J_AUTH=neo4j/your_password" + ExecStart=/opt/scidk/.venv/bin/scidk-serve + Restart=on-failure + RestartSec=10 + StandardOutput=journal + StandardError=journal + + [Install] + WantedBy=multi-user.target + ``` + +2. **Create dedicated user**: + ```bash + sudo useradd -r -s /bin/false -d /opt/scidk scidk + ``` + +3. **Set permissions**: + ```bash + sudo chown -R scidk:scidk /opt/scidk + sudo chmod 750 /opt/scidk + ``` + +4. **Enable and start service**: + ```bash + sudo systemctl daemon-reload + sudo systemctl enable scidk + sudo systemctl start scidk + ``` + +5. **Check status**: + ```bash + sudo systemctl status scidk + sudo journalctl -u scidk -f + ``` + +## Reverse Proxy Setup (nginx) + +For production, use nginx as a reverse proxy: + +1. **Install nginx**: + ```bash + sudo apt-get install nginx + ``` + +2. **Create nginx configuration** `/etc/nginx/sites-available/scidk`: + ```nginx + server { + listen 80; + server_name your-domain.com; + + # Redirect HTTP to HTTPS + return 301 https://$server_name$request_uri; + } + + server { + listen 443 ssl http2; + server_name your-domain.com; + + ssl_certificate /etc/ssl/certs/scidk.crt; + ssl_certificate_key /etc/ssl/private/scidk.key; + + client_max_body_size 100M; + + location / { + proxy_pass http://127.0.0.1:5000; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + + # WebSocket support (if needed) + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection "upgrade"; + } + } + ``` + +3. **Enable site**: + ```bash + sudo ln -s /etc/nginx/sites-available/scidk /etc/nginx/sites-enabled/ + sudo nginx -t + sudo systemctl reload nginx + ``` + +## SSL/TLS Configuration + +For HTTPS support using Let's Encrypt: + +1. **Install certbot**: + ```bash + sudo apt-get install certbot python3-certbot-nginx + ``` + +2. **Obtain certificate**: + ```bash + sudo certbot --nginx -d your-domain.com + ``` + +3. **Auto-renewal** (certbot sets this up automatically): + ```bash + sudo systemctl status certbot.timer + ``` + +## Port Configuration + +### Changing Default Port + +1. **Via environment variable**: + ```bash + export SCIDK_PORT=8080 + scidk-serve + ``` + +2. **Via .env file**: + ```bash + echo "SCIDK_PORT=8080" >> .env + ``` + +3. **Via systemd** (edit `/etc/systemd/system/scidk.service`): + ```ini + Environment="SCIDK_PORT=8080" + ``` + +## Common Deployment Issues + +### Port Already in Use + +**Symptom**: Error "Address already in use" when starting SciDK + +**Solution**: +```bash +# Find process using port 5000 +sudo lsof -i :5000 +# or +sudo netstat -tlnp | grep 5000 + +# Kill the process or change SCIDK_PORT +export SCIDK_PORT=5001 +scidk-serve +``` + +### Neo4j Connection Failed + +**Symptom**: "Failed to connect to Neo4j" in logs or UI + +**Diagnosis**: +```bash +# Check Neo4j is running +docker compose -f docker-compose.neo4j.yml ps + +# Check Neo4j logs +docker compose -f docker-compose.neo4j.yml logs neo4j + +# Test connection manually +curl http://localhost:7474 +``` + +**Solutions**: +- Verify Neo4j is running: `docker compose -f docker-compose.neo4j.yml up -d` +- Check credentials match in Settings → Neo4j +- Verify firewall allows port 7687 +- Check NEO4J_AUTH environment variable + +### Permission Denied Errors + +**Symptom**: Permission errors when accessing data directories + +**Solution**: +```bash +# Ensure correct ownership +sudo chown -R scidk:scidk /opt/scidk +sudo chown -R scidk:scidk ~/.scidk + +# Check directory permissions +ls -la /opt/scidk +chmod 750 /opt/scidk +``` + +### Out of Memory Errors + +**Symptom**: Application crashes with memory errors on large scans + +**Solutions**: +- Increase available RAM (4GB+ recommended) +- Use pagination for large datasets +- Enable batch processing in settings +- Use selective scanning instead of full recursive scans + +### Database Locked Errors + +**Symptom**: "Database is locked" errors in SQLite + +**Solutions**: +```bash +# Check WAL mode is enabled (should happen automatically) +sqlite3 ~/.scidk/db/files.db "PRAGMA journal_mode;" + +# Should return: wal +# If not, enable it: +sqlite3 ~/.scidk/db/files.db "PRAGMA journal_mode=WAL;" +``` + +## Upgrading SciDK + +### Standard Upgrade + +1. **Backup configuration**: + ```bash + # Via UI: Settings → Export Settings + # Or manually: + cp ~/.scidk/db/files.db ~/.scidk/db/files.db.backup + ``` + +2. **Pull latest code**: + ```bash + cd /opt/scidk + git pull origin main + ``` + +3. **Update dependencies**: + ```bash + source .venv/bin/activate + pip install -e . --upgrade + ``` + +4. **Restart service**: + ```bash + sudo systemctl restart scidk + ``` + +5. **Verify**: + ```bash + curl http://localhost:5000/api/health + ``` + +### Database Migrations + +SciDK automatically runs database migrations on startup. Check migration status: + +```bash +curl http://localhost:5000/api/health | jq '.sqlite' +``` + +## Health Checks + +### Application Health + +```bash +curl http://localhost:5000/api/health +``` + +Expected response includes: +- SQLite connection status +- Journal mode (should be "wal") +- Schema version +- Neo4j connection status (if configured) + +### Graph Health + +```bash +curl http://localhost:5000/api/health/graph +``` + +Returns Neo4j connection status and node/relationship counts. + +## Backup and Restore + +See [OPERATIONS.md](OPERATIONS.md) for detailed backup and restore procedures. + +## Security Considerations + +See [SECURITY.md](SECURITY.md) for comprehensive security best practices. + +## Support + +- **Documentation**: Check docs/ directory for detailed guides +- **Issues**: Report bugs on GitHub issue tracker +- **Logs**: Check systemd journal or application logs for errors + +## Next Steps + +- Review [OPERATIONS.md](OPERATIONS.md) for day-to-day operational procedures +- Review [SECURITY.md](SECURITY.md) for security hardening +- Review [TROUBLESHOOTING.md](TROUBLESHOOTING.md) for common issues and solutions diff --git a/docs/OPERATIONS.md b/docs/OPERATIONS.md new file mode 100644 index 0000000..3b00b40 --- /dev/null +++ b/docs/OPERATIONS.md @@ -0,0 +1,555 @@ +# SciDK Operations Manual + +This manual covers day-to-day operations, monitoring, maintenance, and operational workflows for production SciDK deployments. + +## Daily Operations + +### Starting the Application + +**Via systemd** (production): +```bash +sudo systemctl start scidk +sudo systemctl status scidk +``` + +**Via command line** (development): +```bash +cd /opt/scidk +source .venv/bin/activate +scidk-serve +``` + +**Verify startup**: +```bash +curl http://localhost:5000/api/health +``` + +### Stopping the Application + +**Via systemd**: +```bash +sudo systemctl stop scidk +``` + +**Via command line**: +- Press `Ctrl+C` in the terminal running scidk-serve + +### Restarting After Configuration Changes + +```bash +sudo systemctl restart scidk +sudo journalctl -u scidk -f # Monitor logs +``` + +## Monitoring System Health + +### Health Check Endpoints + +**Application Health**: +```bash +curl http://localhost:5000/api/health +``` + +Returns: +- SQLite database status and configuration +- Journal mode (should be "wal") +- Schema version +- Database connectivity + +**Graph Health**: +```bash +curl http://localhost:5000/api/health/graph +``` + +Returns: +- Neo4j connection status +- Node counts by label +- Relationship counts by type +- Database statistics + +### Key Metrics to Monitor + +1. **Disk Space**: + ```bash + df -h ~/.scidk/db/ + df -h /var/lib/neo4j/ # Or your Neo4j data directory + ``` + +2. **Memory Usage**: + ```bash + # Application memory + ps aux | grep scidk-serve + + # Neo4j memory (if using Docker) + docker stats scidk-neo4j + ``` + +3. **Database Size**: + ```bash + du -sh ~/.scidk/db/files.db* + ``` + +4. **Log File Size**: + ```bash + sudo journalctl --disk-usage + du -sh /var/log/nginx/ # If using nginx + ``` + +### Viewing Logs + +**Application logs** (systemd): +```bash +# Real-time logs +sudo journalctl -u scidk -f + +# Last 100 lines +sudo journalctl -u scidk -n 100 + +# Logs from specific time +sudo journalctl -u scidk --since "2024-01-01 00:00:00" + +# Errors only +sudo journalctl -u scidk -p err +``` + +**Neo4j logs** (Docker): +```bash +docker compose -f docker-compose.neo4j.yml logs -f neo4j +``` + +**nginx logs**: +```bash +sudo tail -f /var/log/nginx/access.log +sudo tail -f /var/log/nginx/error.log +``` + +## Backup and Restore Procedures + +### Configuration Backup + +**Via Web UI** (recommended): +1. Navigate to Settings +2. Scroll to Configuration Backup/Restore section +3. Click "Export Settings" +4. Save the JSON file to a secure location + +**Via API**: +```bash +curl -X GET http://localhost:5000/api/settings/export \ + -H "Authorization: Bearer YOUR_TOKEN" \ + -o scidk-config-backup.json +``` + +### Database Backup + +**Automated backup** (recommended): + +SciDK includes a backup scheduler. Configure in Settings → Backup: +- Enable automatic backups +- Set schedule (daily, weekly, etc.) +- Set retention policy +- Configure backup location + +**Manual SQLite backup**: +```bash +# Stop the application first (important!) +sudo systemctl stop scidk + +# Create backup +sqlite3 ~/.scidk/db/files.db ".backup ~/.scidk/db/files.db.backup" + +# Or use cp (ensure no active connections) +cp ~/.scidk/db/files.db ~/.scidk/db/files.db.$(date +%Y%m%d_%H%M%S) + +# Restart application +sudo systemctl start scidk +``` + +**Online backup** (using WAL mode): +```bash +# WAL mode allows backups while running +sqlite3 ~/.scidk/db/files.db ".backup /backups/files.db.$(date +%Y%m%d)" +``` + +### Neo4j Backup + +**Via Neo4j dump** (recommended): +```bash +# Stop Neo4j +docker compose -f docker-compose.neo4j.yml stop neo4j + +# Create dump +docker compose -f docker-compose.neo4j.yml run --rm neo4j \ + neo4j-admin database dump neo4j \ + --to-path=/backups/neo4j-dump-$(date +%Y%m%d).dump + +# Restart Neo4j +docker compose -f docker-compose.neo4j.yml start neo4j +``` + +**Via Docker volume backup**: +```bash +# Backup Neo4j data directory +sudo tar -czf neo4j-data-$(date +%Y%m%d).tar.gz \ + ./data/neo4j/data +``` + +### Restore Procedures + +**Restore SQLite database**: +```bash +# Stop application +sudo systemctl stop scidk + +# Restore from backup +cp ~/.scidk/db/files.db.backup ~/.scidk/db/files.db + +# Restart application +sudo systemctl start scidk + +# Verify health +curl http://localhost:5000/api/health +``` + +**Restore configuration**: +1. Navigate to Settings → Configuration Backup/Restore +2. Click "Import Settings" +3. Select your backup JSON file +4. Click "Import" +5. Restart application if prompted + +**Restore Neo4j**: +```bash +# Stop Neo4j +docker compose -f docker-compose.neo4j.yml stop neo4j + +# Restore dump +docker compose -f docker-compose.neo4j.yml run --rm neo4j \ + neo4j-admin database load neo4j \ + --from-path=/backups/neo4j-dump-20240101.dump + +# Start Neo4j +docker compose -f docker-compose.neo4j.yml start neo4j +``` + +## User Management + +### Creating Users + +**Via Web UI**: +1. Log in as admin +2. Navigate to Settings → Users (if available) +3. Click "Add User" +4. Enter username, password, and role +5. Click "Create" + +**Via SQLite** (if UI not available): +```python +import bcrypt +import sqlite3 + +# Connect to database +conn = sqlite3.connect('/path/to/files.db') +cursor = conn.cursor() + +# Hash password +password = b'secure_password' +hashed = bcrypt.hashpw(password, bcrypt.gensalt()) + +# Insert user +cursor.execute( + "INSERT INTO users (username, password_hash, role) VALUES (?, ?, ?)", + ('newuser', hashed, 'user') +) +conn.commit() +conn.close() +``` + +### Managing User Roles + +SciDK supports two primary roles: +- **admin**: Full system access, can manage users and settings +- **user**: Standard access to features, cannot manage users + +## Monthly Reconciliation Workflow + +This example workflow ensures data integrity and identifies discrepancies between indexed files and the graph database. + +### Week 1: Health Check and Cleanup + +1. **Check system health**: + ```bash + curl http://localhost:5000/api/health | jq '.' + curl http://localhost:5000/api/health/graph | jq '.' + ``` + +2. **Review logs for errors**: + ```bash + sudo journalctl -u scidk --since "30 days ago" -p err | less + ``` + +3. **Check disk space** (should be <80% full): + ```bash + df -h ~/.scidk/db/ + df -h ./data/neo4j/ + ``` + +4. **Clean up old logs** (if needed): + ```bash + sudo journalctl --vacuum-time=30d + ``` + +### Week 2: Backup Verification + +1. **Verify automated backups are running**: + - Check backup schedule in Settings → Backup + - Review backup logs for failures + - Verify backup files exist and are recent + +2. **Test a backup restore** (in test environment): + ```bash + # Copy production backup to test + # Restore and verify functionality + ``` + +3. **Document backup verification** in operations log + +### Week 3: Data Integrity Check + +1. **Run scan reconciliation**: + - Navigate to Files/Datasets + - Review scan history + - Identify scans with errors or incomplete status + +2. **Check for orphaned data**: + ```bash + # Query for files not linked to scans + curl http://localhost:5000/api/graph/query \ + -X POST \ + -H "Content-Type: application/json" \ + -d '{"query": "MATCH (f:File) WHERE NOT (f)-[:SCANNED_IN]->() RETURN count(f)"}' + ``` + +3. **Clean up orphaned relationships**: + - Use data cleaning features in UI (Files page) + - Or run Cypher queries to remove orphans + +### Week 4: Performance Review + +1. **Review scan performance metrics**: + - Average scan time for common directories + - Identify slow scans + - Review progress indicators + +2. **Check database performance**: + ```bash + # SQLite integrity check + sqlite3 ~/.scidk/db/files.db "PRAGMA integrity_check;" + + # Optimize if needed + sqlite3 ~/.scidk/db/files.db "VACUUM;" + ``` + +3. **Update documentation**: + - Document any issues encountered + - Update runbooks if procedures changed + - Record performance baselines + +### Monthly Report Template + +```markdown +# SciDK Monthly Operations Report - [Month Year] + +## System Health +- Uptime: [X days/hours] +- Health check status: [Pass/Fail] +- Critical errors: [Count] + +## Backups +- Automated backups: [Success count / Total] +- Manual backups: [Count] +- Restore test: [Date] - [Pass/Fail] + +## Data Integrity +- Total scans: [Count] +- Failed scans: [Count] +- Orphaned files cleaned: [Count] + +## Performance +- Average scan time: [X seconds/minutes] +- Database size: [X GB] +- Largest scan: [X files, Y GB] + +## Issues and Resolutions +- [Issue 1]: [Resolution] +- [Issue 2]: [Resolution] + +## Action Items +- [ ] Action item 1 +- [ ] Action item 2 +``` + +## Alert Management + +SciDK includes an alert system for critical events. Configure in Settings → Alerts. + +### Alert Types + +1. **Import Failed**: Triggered when file import fails +2. **High Discrepancies**: Triggered when scan reconciliation finds mismatches +3. **Backup Failed**: Triggered when automated backup fails +4. **Neo4j Connection Lost**: Triggered when Neo4j becomes unavailable +5. **Disk Space Critical**: Triggered when disk usage exceeds threshold (default 95%) + +### Configuring Alerts + +1. Navigate to Settings → Alerts +2. Configure SMTP settings for email notifications +3. Enable/disable specific alerts +4. Set recipients for each alert type +5. Adjust thresholds (e.g., disk space warning level) +6. Test alerts using "Test Alert" button + +### Responding to Alerts + +**Import Failed**: +- Check logs for error details +- Verify file permissions and disk space +- Re-run import after resolving issue + +**High Discrepancies**: +- Review scan and graph data +- Run data integrity check +- Use reconciliation tools to fix mismatches + +**Backup Failed**: +- Check backup destination is accessible +- Verify disk space is available +- Check backup service logs +- Run manual backup + +**Neo4j Connection Lost**: +- Check Neo4j is running: `docker compose -f docker-compose.neo4j.yml ps` +- Review Neo4j logs +- Verify network connectivity +- Restart Neo4j if needed + +**Disk Space Critical**: +- Identify large files: `du -sh ~/.scidk/db/* | sort -h` +- Clean up old scans or backups +- Expand storage if persistently full + +## Maintenance Tasks + +### Weekly Tasks + +- [ ] Review application logs for errors +- [ ] Check disk space +- [ ] Verify backups completed successfully +- [ ] Check system health endpoints + +### Monthly Tasks + +- [ ] Run database integrity check +- [ ] Test backup restore procedure +- [ ] Review and clean up old scans +- [ ] Update documentation +- [ ] Review security audit logs +- [ ] Check for application updates + +### Quarterly Tasks + +- [ ] Review and update user access +- [ ] Performance tuning and optimization +- [ ] Review and update disaster recovery plan +- [ ] Security audit and vulnerability assessment +- [ ] Capacity planning review + +## When to Contact Support + +Contact your system administrator or SciDK support when: + +1. **Critical system failure**: Application won't start or repeatedly crashes +2. **Data loss**: Cannot restore from backups or data corruption detected +3. **Security incident**: Unauthorized access or suspicious activity +4. **Performance degradation**: Persistent slow performance not resolved by standard procedures +5. **Upgrade issues**: Problems during version upgrade +6. **Neo4j issues**: Cannot connect or restore graph database + +### Information to Gather Before Contacting Support + +- Application version: Check README.md or git tag +- Error messages: From logs (journalctl output) +- Health check output: From `/api/health` endpoint +- Recent changes: Configuration, upgrades, or operational changes +- Reproduction steps: How to reproduce the issue +- Impact: Number of users affected, criticality + +## Performance Optimization + +### Database Optimization + +**SQLite maintenance**: +```bash +# Run VACUUM to reclaim space and optimize +sqlite3 ~/.scidk/db/files.db "VACUUM;" + +# Analyze for query optimization +sqlite3 ~/.scidk/db/files.db "ANALYZE;" +``` + +**Neo4j maintenance**: +1. Navigate to Neo4j Browser (http://localhost:7474) +2. Run: `CALL db.stats.retrieve('NODE COUNTS');` +3. Run: `CALL db.stats.retrieve('RELATIONSHIP COUNTS');` +4. Consider creating indexes for frequently queried properties + +### Scan Performance + +- Use **ncdu** or **gdu** for faster filesystem enumeration +- Enable **fast_list** mode for rclone scans (if supported by remote) +- Use **non-recursive** scans for large directory trees +- Adjust **batch size** in Settings → Interpreters + +### Application Performance + +- Increase allocated memory if frequently encountering OOM errors +- Use **pagination** when browsing large datasets +- Enable **WAL mode** for SQLite (should be default) +- Monitor and limit concurrent scans + +## Disaster Recovery + +### Recovery Time Objectives (RTO) + +- **Configuration**: < 1 hour (restore from settings backup) +- **Database**: < 2 hours (restore SQLite from backup) +- **Graph Database**: < 4 hours (restore Neo4j from dump) + +### Recovery Point Objectives (RPO) + +- **Configuration**: < 24 hours (daily exports) +- **Database**: < 24 hours (daily backups) +- **Graph Database**: < 24 hours (daily Neo4j backups) + +### Disaster Recovery Procedures + +See disaster recovery runbook in `dev/ops/` directory for detailed procedures. + +## Troubleshooting Quick Reference + +For detailed troubleshooting, see [TROUBLESHOOTING.md](TROUBLESHOOTING.md). + +**Quick fixes**: + +- **Can't connect to app**: Check if running (`systemctl status scidk`), check port (`netstat -tlnp | grep 5000`) +- **Can't connect to Neo4j**: Check if running (`docker compose ps`), verify credentials in Settings +- **Slow performance**: Check disk space, run VACUUM, restart application +- **Database locked**: Check for multiple processes, verify WAL mode enabled + +## Additional Resources + +- [DEPLOYMENT.md](DEPLOYMENT.md) - Installation and deployment +- [TROUBLESHOOTING.md](TROUBLESHOOTING.md) - Common problems and solutions +- [SECURITY.md](SECURITY.md) - Security best practices +- [API.md](API.md) - API reference and usage diff --git a/docs/PLUGIN_INSTANCES.md b/docs/PLUGIN_INSTANCES.md new file mode 100644 index 0000000..012254c --- /dev/null +++ b/docs/PLUGIN_INSTANCES.md @@ -0,0 +1,430 @@ +# Plugin Instance Framework + +## Overview + +The Plugin Instance Framework allows users to create multiple instances of plugin templates via the UI. This separates plugin code (templates) from user configuration (instances). + +**Analogy**: Plugin templates are like application classes, while plugin instances are like object instances with specific configurations. + +## Architecture + +### Components + +1. **PluginTemplateRegistry** (`scidk/core/plugin_template_registry.py`) + - Manages plugin templates (code-based) + - Templates define capabilities, config schema, and execution handler + - Examples: `table_loader`, `api_fetcher`, `file_importer` + +2. **PluginInstanceManager** (`scidk/core/plugin_instance_manager.py`) + - Manages user-created instances (stored in SQLite) + - Each instance has: ID, name, template_id, config, status, timestamps + - Tracks execution history and results + +3. **API Endpoints** (`scidk/web/routes/api_plugins.py`) + - `GET /api/plugins/templates` - List templates + - `GET /api/plugins/instances` - List instances + - `POST /api/plugins/instances` - Create instance + - `PUT /api/plugins/instances/` - Update instance + - `DELETE /api/plugins/instances/` - Delete instance + - `POST /api/plugins/instances//execute` - Execute instance + +## Template Registration + +Plugin templates register themselves during plugin loading: + +```python +# plugins/table_loader/__init__.py +def register_plugin(app): + """Register table loader template.""" + + registry = app.extensions['scidk']['plugin_templates'] + + registry.register({ + 'id': 'table_loader', + 'name': 'Table Loader', + 'description': 'Import spreadsheets into SQLite tables', + 'category': 'data_import', + 'supports_multiple_instances': True, # Users can create many instances + 'graph_behavior': { + 'can_create_label': True, + 'label_source': 'table_columns', + 'sync_strategy': 'on_demand', + 'supports_preview': True + }, + 'config_schema': { + 'type': 'object', + 'properties': { + 'instance_name': {'type': 'string', 'required': True}, + 'file_path': {'type': 'string'}, + 'table_name': {'type': 'string', 'required': True}, + } + }, + 'handler': handle_table_import # Function to execute + }) + + return { + 'name': 'Table Loader', + 'version': '1.0.0' + } + +def handle_table_import(instance_config): + """Execute the template logic with instance config.""" + file_path = instance_config['file_path'] + table_name = instance_config['table_name'] + + # Import logic here + # ... + + return { + 'status': 'success', + 'rows_imported': 45, + 'columns': ['name', 'location'] + } +``` + +## Instance Management + +### Creating an Instance via API + +```bash +curl -X POST http://localhost:5000/api/plugins/instances \ + -H "Content-Type: application/json" \ + -d '{ + "template_id": "table_loader", + "name": "iLab Equipment 2024", + "config": { + "file_path": "/data/equipment.xlsx", + "table_name": "ilab_equipment_2024" + } + }' +``` + +### Executing an Instance + +```bash +curl -X POST http://localhost:5000/api/plugins/instances//execute +``` + +This calls the template's handler function with the instance configuration and records the result. + +## Database Schema + +```sql +CREATE TABLE plugin_instances ( + id TEXT PRIMARY KEY, + name TEXT NOT NULL, + template_id TEXT NOT NULL, + config TEXT NOT NULL, -- JSON + enabled INTEGER DEFAULT 1, + status TEXT, -- 'pending', 'active', 'inactive', 'error' + last_run REAL, + last_result TEXT, -- JSON + created_at REAL NOT NULL, + updated_at REAL NOT NULL +); +``` + +## Use Cases + +### Use Case 1: Multiple Data Imports + +A lab admin wants to track multiple data sources: +- Instance 1: "iLab Equipment 2024" (table_loader template) +- Instance 2: "PI Directory" (table_loader template) +- Instance 3: "Lab Resources Q1" (table_loader template) + +Each instance has its own file, table name, and sync schedule. + +### Use Case 2: API Integrations + +Researcher wants to pull data from multiple APIs: +- Instance 1: "PubMed Latest Papers" (api_fetcher template) +- Instance 2: "GitHub Repositories" (api_fetcher template) +- Instance 3: "Slack Notifications" (api_fetcher template) + +Each instance has different API credentials, endpoints, and sync intervals. + +## Plugin Categories + +Plugin templates must specify a `category` field that determines how they interact with the graph layer. Valid categories: + +### data_import +- **Purpose**: Import tabular data to SQLite, can publish schemas as Labels +- **Graph Behavior**: Creates label definitions from table schemas +- **Examples**: table_loader, csv_importer, api_fetcher +- **Required Config**: `graph_behavior` block with: + - `can_create_label`: Boolean (true for most data importers) + - `label_source`: String ('table_columns' for table-based imports) + - `sync_strategy`: 'on_demand' or 'automatic' + - `supports_preview`: Boolean (true if preview supported) + +### graph_inject +- **Purpose**: Directly create nodes + relationships in Neo4j +- **Graph Behavior**: Bypasses SQLite, writes directly to graph +- **Examples**: ontology_loader, knowledge_base_importer +- **Use Case**: Pre-structured graph data (OWL, RDF, knowledge bases) + +### enrichment +- **Purpose**: Add properties to existing nodes without creating new labels +- **Graph Behavior**: Updates existing nodes, no schema changes +- **Examples**: metadata_enricher, annotation_engine +- **Use Case**: Add computed properties, external metadata + +### exporter +- **Purpose**: Read from graph/database, no graph writes (default) +- **Graph Behavior**: None (read-only) +- **Examples**: report_generator, backup_exporter +- **Use Case**: Export data, generate reports + +**Default**: If no category specified, defaults to `exporter` for backward compatibility. + +**Validation**: PluginTemplateRegistry validates categories on registration and logs warnings for data_import plugins missing recommended `graph_behavior` config. + +## Best Practices + +### For Template Developers + +1. **Idempotent handlers**: Handlers should be safe to re-execute +2. **Clear error messages**: Return descriptive errors in results +3. **Config validation**: Validate config before execution +4. **Progress tracking**: Return row counts, statistics in results +5. **Resource cleanup**: Clean up temp files, connections + +### For Instance Configurations + +1. **Descriptive names**: "iLab Equipment 2024" not "Import 1" +2. **Version in name**: Include year/quarter for time-series data +3. **Enable/disable**: Use enabled flag instead of deleting instances +4. **Test before production**: Test with small datasets first + +## Graph Integration + +### Plugin → Label → Integration Architecture + +Plugin instances can publish their data schemas to the **Labels page**, creating a clean path from data import to graph relationships: + +``` +Plugin Instance → Publishes Schema → Label Definition → Used in Integrations +``` + +### Publishing Labels from Plugin Instances + +**For `data_import` category plugins** (e.g., table_loader): + +1. **During Instance Creation**: Optionally configure graph integration in wizard + + The plugin instance creation wizard includes an optional **Step 3: Graph Integration** for `data_import` plugins: + + - **Step 1**: Select template (e.g., "Table Loader") + - **Step 2**: Configure instance (name, file path, table name, etc.) + - **Step 3**: Graph Integration (optional) + - ☑ Enable "Create Label from this data" + - **Label Name**: Auto-generated from table name (e.g., `lab_equipment_2024` → `LabEquipment2024`) + - **Primary Key**: Select from dropdown (e.g., `id`, `uuid`, `serial_number`) + - **Sync Strategy**: + - On-demand - Manual sync via Labels page + - Automatic - Sync to Neo4j when plugin runs + - **Properties**: All columns included by default (configurable later) + - **Step 4**: Preview & Confirm + + Non-`data_import` plugins skip Step 3 entirely. + +2. **Label Registration**: Instance publishes schema to Labels page + ```bash + POST /api/plugins/instances/{id}/publish-label + { + "label_name": "LabEquipment", + "primary_key": "serial_number", + "sync_config": { + "strategy": "on_demand" + } + } + ``` + +3. **Schema Auto-Detection**: Properties inferred from SQLite table structure + - Column names → property names + - Column types → property types (string, integer, boolean, etc.) + - NOT NULL constraints → required properties + +4. **Label Appears**: Labels page shows new label with plugin source badge: + - 📦 Plugin: iLab Equipment 2024 + - 45 rows in SQLite, 0 nodes in graph + +5. **Sync to Neo4j**: User clicks [Sync to Neo4j] button + - Reads data from SQLite table + - Creates/updates nodes in Neo4j + - Records sync timestamp and node count + +6. **Available in Integrations**: Label automatically discovered by Integrations page + - Can create relationships with other labels + - Example: LabEquipment → USED_BY → Researcher + +### Plugin Categories + +**data_import**: Imports tabular data, can publish labels +- Examples: table_loader, csv_importer, api_fetcher +- Graph behavior: Creates label from table schema + +**graph_inject**: Directly injects graph (nodes + relationships) +- Examples: ontology_loader, knowledge_base_importer +- Graph behavior: Registers labels it creates (read-only) + +**enrichment**: Adds properties to existing nodes +- Examples: metadata_enricher, annotation_engine +- Graph behavior: No new labels + +**exporter**: Reads data, no graph writes +- Examples: report_generator, backup_exporter +- Graph behavior: None + +### Example: Table Loader with Graph Integration + +```python +# 1. Create instance with graph config +instance_config = { + "template_id": "table_loader", + "name": "iLab Equipment 2024", + "config": { + "file_path": "/data/equipment.xlsx", + "table_name": "ilab_equipment_2024" + }, + "graph_config": { + "create_label": True, + "label_name": "LabEquipment", + "primary_key": "serial_number", + "sync_strategy": "on_demand" + } +} + +# 2. Instance automatically publishes label +# Label "LabEquipment" now appears on Labels page + +# 3. User syncs to Neo4j +POST /api/labels/LabEquipment/sync +# → Creates 45 nodes in Neo4j + +# 4. User creates integration +Integration: + Source: LabEquipment + Target: Researcher + Relationship: USED_BY + Match: equipment.user_id = researcher.id +``` + +### Database Schema + +**label_definitions** (extended): +```sql +CREATE TABLE label_definitions ( + name TEXT PRIMARY KEY, + properties TEXT, -- JSON: property schema + source_type TEXT DEFAULT 'manual', -- 'manual', 'plugin_instance', 'system' + source_id TEXT, -- Plugin instance ID if source_type='plugin_instance' + sync_config TEXT, -- JSON: {primary_key, sync_strategy, last_sync_at, last_sync_count} + created_at REAL, + updated_at REAL +); +``` + +**plugin_instances** (extended): +```sql +ALTER TABLE plugin_instances ADD COLUMN published_label TEXT; +ALTER TABLE plugin_instances ADD COLUMN graph_config TEXT; +``` + +### API Endpoints + +**Plugin Label Publishing:** +- `POST /api/plugins/instances/{id}/publish-label` - Publish label schema from plugin instance + - Request body: `{"label_name": "LabEquipment", "primary_key": "serial_number", "sync_strategy": "on_demand"}` + - Auto-generates property mapping from SQLite table if not provided + - Returns: `{"status": "success", "message": "Label 'LabEquipment' published successfully"}` + +**Label Management:** +- `GET /api/labels` - List all labels with source info +- `GET /api/labels/{name}` - Get specific label definition +- `POST /api/labels` - Create/update label definition +- `DELETE /api/labels/{name}` - Delete label definition + +**Neo4j Sync (planned):** +- `POST /api/labels/{name}/sync` - Sync label data to Neo4j +- `GET /api/labels/{name}/preview` - Preview data (first 10 rows) + +### UI Workflows + +**Workflow 1: Create Plugin Instance → Label → Integration** +1. Settings > Plugins > "+ New Plugin Instance" +2. Select "Table Loader" +3. Configure file + table +4. Enable "Graph Integration" +5. Label name: "LabEquipment", Primary key: "serial_number" +6. Create instance +7. Navigate to Labels page → See "LabEquipment (📦 Plugin)" +8. Click [Sync to Neo4j] → 45 nodes created +9. Navigate to Integrations → Create "LabEquipment → STORED_IN → Folder" + +**Workflow 2: Update Plugin Data → Re-sync** +1. Update Excel file with new equipment +2. Navigate to Settings > Plugins +3. Click [Sync Now] on instance card +4. Navigate to Labels page +5. Click [Sync to Neo4j] +6. Updated nodes reflected in graph + +### Related Documentation + +- **Feature Design**: `dev/features/plugins/feature-plugin-label-integration.md` +- **Task List**: See `feature-plugin-label-integration.md` for implementation tasks +- **Architecture**: `docs/ARCHITECTURE.md` - Plugin system overview + +## Future Enhancements + +- **Scheduling**: Cron-based auto-execution of instances +- **Webhooks**: Trigger instances via webhook URLs +- **Dependencies**: Instance A depends on Instance B +- **Notifications**: Email/Slack alerts on execution completion/errors +- **Versioning**: Track instance config changes over time +- **Rollback**: Revert to previous instance configuration +- **Multi-Label Plugins**: graph_inject plugins publish multiple labels +- **Schema Migrations**: Handle schema changes in plugin data +- **Automatic Sync**: Trigger sync on plugin execution completion + +## Migration from Code-based Plugins + +Existing plugins can be gradually migrated to use templates: + +**Before** (single-instance plugin): +```python +def register_plugin(app): + # Hard-coded configuration + api_url = "https://api.example.com" + + @app.route('/my-plugin/sync') + def sync(): + # ... sync logic ... + pass +``` + +**After** (multi-instance template): +```python +def register_plugin(app): + registry = app.extensions['scidk']['plugin_templates'] + + registry.register({ + 'id': 'my_plugin', + 'name': 'My Plugin', + 'supports_multiple_instances': True, + 'config_schema': { + 'properties': { + 'api_url': {'type': 'string'} + } + }, + 'handler': sync_handler + }) + +def sync_handler(instance_config): + api_url = instance_config['api_url'] + # ... sync logic using api_url from instance ... +``` + +Now users can create multiple instances with different API URLs! diff --git a/docs/PLUGIN_LABEL_ENDPOINTS.md b/docs/PLUGIN_LABEL_ENDPOINTS.md new file mode 100644 index 0000000..318d1db --- /dev/null +++ b/docs/PLUGIN_LABEL_ENDPOINTS.md @@ -0,0 +1,218 @@ +# Plugin Label Endpoint Registry + +## Overview + +The Label Endpoint Registry allows plugins to register API endpoints that map to Label types in the SciDK schema. This enables plugins to provide external data integrations that appear automatically in the Integrations settings page. + +## Architecture + +### Components + +1. **LabelEndpointRegistry** (`scidk/core/label_endpoint_registry.py`) + - Central registry for plugin-registered endpoints + - Initialized during app startup before plugins are loaded + - Accessible via `app.extensions['scidk']['label_endpoints']` + +2. **API Endpoints** (`scidk/web/routes/api_settings.py`) + - `GET /api/settings/plugin-endpoints` - List all plugin endpoints + - `GET /api/settings/plugin-endpoints/` - Get specific endpoint + +3. **UI Integration** (`scidk/ui/templates/settings/_integrations.html`) + - Displays plugin endpoints in Settings > Integrations page + - Shows endpoint name, path, label type, plugin, and description + - Read-only display (cannot be manually edited) + +## Plugin Registration + +### Basic Example + +```python +def register_plugin(app): + """Register the plugin with the Flask app.""" + + # Get the label endpoint registry + registry = app.extensions['scidk']['label_endpoints'] + + # Register an endpoint + registry.register({ + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabService', + 'auth_required': True, + 'test_url': '/api/integrations/ilab/test', + 'plugin': 'ilab_plugin', + 'description': 'Integration with iLab service management system' + }) + + return { + 'name': 'iLab Plugin', + 'version': '1.0.0', + 'author': 'Your Name', + 'description': 'Plugin for iLab integration' + } +``` + +### Required Fields + +| Field | Type | Description | +|-------|------|-------------| +| `name` | string | Display name shown in UI | +| `endpoint` | string | API endpoint path (must be unique) | +| `label_type` | string | Target Label type in schema | + +### Optional Fields + +| Field | Type | Default | Description | +|-------|------|---------|-------------| +| `auth_required` | boolean | `False` | Whether authentication is required | +| `test_url` | string | `None` | URL for testing connection | +| `plugin` | string | `'unknown'` | Plugin name (auto-populated) | +| `description` | string | `''` | Human-readable description | +| `config_schema` | dict | `{}` | JSON schema for configuration options | + +## Usage in Integrations + +Once registered, plugin endpoints: + +1. **Appear in Settings > Integrations** + - Listed in the "Plugin Endpoints" section + - Show badge if authentication required + - Display associated Label type + +2. **Can be used in Integration workflows** + - Select as source or target in integration definitions + - Map to Label properties automatically + - Leverage plugin-provided authentication + +3. **Support testing** + - If `test_url` provided, test connection button appears + - Plugin must implement test endpoint handler + +## Complete Example + +See `plugins/example_ilab/` for a complete working example that demonstrates: +- Registering multiple endpoints +- Different Label types +- Authentication requirements +- Descriptive metadata + +```python +# plugins/example_ilab/__init__.py +def register_plugin(app): + registry = app.extensions['scidk']['label_endpoints'] + + # Register services endpoint + registry.register({ + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab/services', + 'label_type': 'iLabService', + 'auth_required': True, + 'test_url': '/api/integrations/ilab/test', + 'plugin': 'example_ilab', + 'description': 'Integration with iLab service management system' + }) + + # Register equipment endpoint + registry.register({ + 'name': 'iLab Equipment', + 'endpoint': '/api/integrations/ilab/equipment', + 'label_type': 'Equipment', + 'auth_required': True, + 'test_url': '/api/integrations/ilab/test', + 'plugin': 'example_ilab', + 'description': 'Integration with iLab equipment inventory' + }) + + return { + 'name': 'iLab Integration', + 'version': '1.0.0', + 'author': 'SciDK Team', + 'description': 'Example plugin for iLab integration' + } +``` + +## API Reference + +### LabelEndpointRegistry Methods + +#### `register(endpoint_config: dict) -> bool` +Register a new label endpoint. + +**Returns:** `True` if successful, `False` if validation fails + +#### `unregister(endpoint_path: str) -> bool` +Unregister an endpoint by path. + +**Returns:** `True` if found and removed, `False` if not found + +#### `get_endpoint(endpoint_path: str) -> Optional[dict]` +Get endpoint configuration by path. + +**Returns:** Endpoint config dict or `None` + +#### `list_endpoints() -> List[dict]` +List all registered endpoints. + +**Returns:** List of endpoint config dicts + +#### `list_by_plugin(plugin_name: str) -> List[dict]` +List endpoints registered by specific plugin. + +**Returns:** Filtered list of endpoints + +#### `list_by_label_type(label_type: str) -> List[dict]` +List endpoints that map to a specific label type. + +**Returns:** Filtered list of endpoints + +## Testing + +The registry includes comprehensive unit tests in `tests/test_label_endpoint_registry.py`: + +```bash +pytest tests/test_label_endpoint_registry.py -v +``` + +Tests cover: +- Basic registration and retrieval +- Field validation +- Duplicate handling +- Filtering by plugin and label type +- Edge cases and error handling + +## Integration with Existing Systems + +### Relationship to API Endpoint Registry + +The Label Endpoint Registry is **separate** from the manual API Endpoint Registry (`api_endpoint_registry.py`): + +| Feature | Manual Endpoints | Plugin Endpoints | +|---------|-----------------|------------------| +| Configuration | Settings UI | Plugin code | +| Storage | SQLite database | In-memory registry | +| Editability | User-editable | Read-only | +| Lifecycle | Persistent | Reset on restart | +| Use Case | User-configured APIs | Plugin-provided integrations | + +Both types of endpoints can be used in Integration workflows. + +### Relationship to Links/Integrations + +Plugin endpoints appear as available sources/targets when creating integration definitions: +- Listed alongside manually configured endpoints +- Can be selected in integration wizard +- Map to Label types automatically + +## Future Enhancements + +Potential improvements for future iterations: + +1. **Configuration UI** - Allow users to configure plugin endpoint parameters (URL, auth tokens) through UI +2. **Persistence** - Option to persist plugin endpoint configs to database +3. **Versioning** - Track endpoint schema versions for compatibility +4. **Discovery** - Auto-discover and suggest Label mappings based on data structure +5. **Monitoring** - Track endpoint usage and performance metrics + +## Migration Notes + +If you have existing plugins, no changes are required unless you want to register label endpoints. The registry is initialized automatically and available in all plugin `register_plugin()` calls via `app.extensions['scidk']['label_endpoints']`. diff --git a/docs/SECURITY.md b/docs/SECURITY.md new file mode 100644 index 0000000..62bb18e --- /dev/null +++ b/docs/SECURITY.md @@ -0,0 +1,637 @@ +# SciDK Security Guide + +This guide covers the security architecture, best practices, compliance considerations, and incident response procedures for SciDK deployments. + +## Security Architecture Overview + +SciDK implements defense-in-depth security with multiple layers of protection: + +1. **Authentication & Authorization**: Multi-user authentication with role-based access control (RBAC) +2. **Data Encryption**: Encryption at rest and in transit +3. **Audit Logging**: Comprehensive audit trails for all system activities +4. **Session Management**: Secure session handling with timeout controls +5. **Input Validation**: Protection against injection attacks +6. **Secure Configuration**: Encrypted credential storage + +## Authentication and Authorization + +### User Authentication + +SciDK supports session-based authentication with the following features: + +**Password Security**: +- Passwords hashed using bcrypt with salt +- Minimum password complexity requirements (configurable) +- Protection against brute force attacks +- Secure password reset mechanisms + +**Session Management**: +- Session-based authentication using secure cookies +- Configurable session timeout (default: 30 minutes) +- Auto-lock after inactivity +- Session invalidation on logout +- CSRF protection enabled + +**Example: Enabling Authentication**: +```python +# In settings database or via UI +auth_config = { + "enabled": True, + "session_timeout": 1800, # 30 minutes + "password_min_length": 8, + "require_complex_password": True +} +``` + +### Role-Based Access Control (RBAC) + +SciDK implements RBAC with the following roles: + +**Admin Role**: +- Full system access +- User management capabilities +- Settings configuration +- Backup and restore operations +- Security configuration + +**User Role**: +- Standard feature access +- File browsing and searching +- Graph visualization +- Chat interface +- Data exploration + +**Permissions Enforcement**: +```python +# Example permission check (internal) +@require_role('admin') +def delete_user(user_id): + # Only admins can delete users + pass +``` + +### Creating Secure User Accounts + +**Best Practices**: +1. Use strong, unique passwords (minimum 12 characters) +2. Enable multi-factor authentication (if available) +3. Limit admin accounts to necessary personnel +4. Regular password rotation (every 90 days) +5. Disable or remove unused accounts + +**Example: Creating Admin User**: +```bash +# Via Python script +python3 -c " +from scidk.core.auth import create_user +create_user('admin', 'SecurePassword123!', role='admin') +" +``` + +## Data Encryption + +### Encryption at Rest + +**SQLite Database**: +- File-level encryption using OS filesystem encryption +- Sensitive data (passwords, API keys) encrypted using Fernet (symmetric encryption) +- Encryption keys stored securely (not in version control) + +**Neo4j Database**: +- Enterprise Edition supports transparent data encryption +- Community Edition: Use filesystem-level encryption + +**Example: Filesystem Encryption (Linux)**: +```bash +# LUKS encryption for data partition +sudo cryptsetup luksFormat /dev/sdb1 +sudo cryptsetup luksOpen /dev/sdb1 encrypted_data +sudo mkfs.ext4 /dev/mapper/encrypted_data +sudo mount /dev/mapper/encrypted_data /var/lib/scidk +``` + +**Backup Encryption**: +```bash +# Encrypt backups with GPG +gpg --symmetric --cipher-algo AES256 backup.db +``` + +### Encryption in Transit + +**HTTPS/TLS**: +All production deployments should use HTTPS: + +```nginx +# nginx configuration +server { + listen 443 ssl http2; + ssl_certificate /etc/ssl/certs/scidk.crt; + ssl_certificate_key /etc/ssl/private/scidk.key; + + # Strong SSL configuration + ssl_protocols TLSv1.2 TLSv1.3; + ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256'; + ssl_prefer_server_ciphers on; + + # HSTS + add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always; +} +``` + +**Neo4j TLS**: +Configure Neo4j to use encrypted Bolt connections: + +```bash +# neo4j.conf +dbms.connector.bolt.tls_level=REQUIRED +dbms.ssl.policy.bolt.enabled=true +dbms.ssl.policy.bolt.base_directory=certificates/bolt +``` + +**API Communication**: +- All API endpoints should be accessed via HTTPS +- Credentials never transmitted in plain text +- Bearer tokens or session cookies for authentication + +## Audit Logging + +### Audit Trail Features + +SciDK maintains comprehensive audit logs for: + +1. **User Authentication Events**: + - Login attempts (success/failure) + - Logout events + - Session expiration + - Password changes + +2. **Data Access Events**: + - File access and downloads + - Dataset queries + - Graph queries + - Export operations + +3. **Administrative Actions**: + - User creation/modification/deletion + - Settings changes + - Backup operations + - System configuration changes + +4. **Security Events**: + - Failed authentication attempts + - Permission denied errors + - Suspicious activity patterns + +### Audit Log Format + +```json +{ + "timestamp": "2024-01-15T10:30:00Z", + "event_type": "user.login", + "user": "admin", + "ip_address": "192.168.1.100", + "user_agent": "Mozilla/5.0...", + "status": "success", + "details": { + "session_id": "sess_abc123" + } +} +``` + +### Accessing Audit Logs + +**Via systemd journals**: +```bash +sudo journalctl -u scidk | grep AUDIT +``` + +**Via SQLite database**: +```sql +SELECT * FROM audit_log +WHERE timestamp > datetime('now', '-7 days') +ORDER BY timestamp DESC; +``` + +### Audit Log Retention + +**Recommended Retention Policies**: +- Security events: 1 year minimum +- Authentication logs: 90 days minimum +- Administrative actions: 1 year minimum +- Data access: 30-90 days (or per compliance requirements) + +**Configure retention**: +```bash +# systemd journal retention +sudo journalctl --vacuum-time=365d +``` + +## Security Best Practices + +### Deployment Security + +**1. Network Security**: +- Deploy behind firewall +- Use private networks for database connections +- Limit exposed ports (only 443/80 for web, 7687 for internal Neo4j) +- Implement IP allowlisting for admin access + +**Example firewall rules (ufw)**: +```bash +# Allow HTTPS +sudo ufw allow 443/tcp + +# Allow Neo4j only from app server +sudo ufw allow from 10.0.1.10 to any port 7687 + +# Deny all other incoming +sudo ufw default deny incoming +sudo ufw enable +``` + +**2. Operating System Security**: +- Keep OS and packages updated +- Use dedicated service account (non-root) +- Disable unnecessary services +- Configure SELinux/AppArmor policies + +**3. Database Security**: +- Change default passwords immediately +- Use strong authentication credentials +- Regular security patches and updates +- Database access restricted to application only + +**4. Application Security**: +- Run as non-privileged user +- Use virtual environment isolation +- Keep dependencies updated +- Regular security scanning + +### Credential Management + +**Best Practices**: +1. Never commit credentials to version control +2. Use environment variables or secret management systems +3. Rotate credentials regularly (every 90 days) +4. Use different credentials for dev/test/prod +5. Encrypt credentials at rest + +**Example: Secret Management**: +```bash +# Use environment variables +export NEO4J_PASSWORD=$(vault read -field=password secret/neo4j) + +# Or use .env file (not in git) +echo "NEO4J_AUTH=neo4j/$(openssl rand -base64 32)" >> .env +chmod 600 .env +``` + +**Credential Storage**: +- SciDK stores encrypted credentials in SQLite +- Encryption key should be stored separately +- Consider using external secret managers (HashiCorp Vault, AWS Secrets Manager) + +### Input Validation + +SciDK implements input validation to prevent: + +**SQL Injection**: +- Parameterized queries for all database access +- ORM-based database interactions +- Input sanitization + +**Command Injection**: +- No shell command construction from user input +- Subprocess calls use argument arrays (not shell=True) +- Path validation for filesystem operations + +**Cross-Site Scripting (XSS)**: +- HTML escaping in templates +- Content Security Policy headers +- Input sanitization + +**Path Traversal**: +- Path normalization +- Validation against allowed directories +- No direct user input in file paths + +### Session Security + +**Configuration**: +```python +# Flask session configuration +app.config.update( + SESSION_COOKIE_SECURE=True, # HTTPS only + SESSION_COOKIE_HTTPONLY=True, # No JavaScript access + SESSION_COOKIE_SAMESITE='Lax', # CSRF protection + PERMANENT_SESSION_LIFETIME=1800 # 30 minutes +) +``` + +**Session Management**: +- Automatic session expiration +- Session invalidation on logout +- Session regeneration after privilege escalation +- Single sign-on support (if configured) + +### Secure Headers + +**Recommended HTTP Security Headers**: +```nginx +# nginx configuration +add_header X-Frame-Options "SAMEORIGIN" always; +add_header X-Content-Type-Options "nosniff" always; +add_header X-XSS-Protection "1; mode=block" always; +add_header Referrer-Policy "strict-origin-when-cross-origin" always; +add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline';" always; +add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always; +``` + +## Compliance Considerations + +### HIPAA Compliance + +For healthcare data: + +**Required Controls**: +1. **Access Control**: RBAC with unique user accounts +2. **Audit Controls**: Comprehensive audit logging +3. **Integrity Controls**: Data validation and checksums +4. **Transmission Security**: TLS/HTTPS for all communications +5. **Authentication**: Strong password policies +6. **Encryption**: Data encryption at rest and in transit + +**BAA Requirements**: +- Ensure Business Associate Agreement with cloud providers +- Document security policies and procedures +- Regular security risk assessments +- Incident response procedures + +**PHI Handling**: +- Minimize PHI exposure +- De-identify data when possible +- Secure disposal procedures +- Access logging for all PHI + +### GDPR Compliance + +For European data: + +**Right to Access**: +- Provide user data export functionality +- API endpoints for data retrieval + +**Right to Erasure**: +- User deletion removes all associated data +- Cascade delete for related records +- Audit log of deletions (without retaining PII) + +**Right to Portability**: +- Export in machine-readable format (JSON, CSV) +- Configuration backup/export functionality + +**Data Protection**: +- Encryption at rest and in transit +- Access controls and audit logs +- Privacy by design and default +- Data minimization + +**Breach Notification**: +- 72-hour breach notification requirement +- Incident response procedures +- Contact data protection authorities + +### SOC 2 Compliance + +For service organizations: + +**Trust Services Criteria**: +1. **Security**: Access controls, encryption, monitoring +2. **Availability**: Uptime, redundancy, disaster recovery +3. **Processing Integrity**: Data validation, error handling +4. **Confidentiality**: Encryption, access controls +5. **Privacy**: Data handling, consent management + +**Implementation**: +- Document security policies +- Regular security assessments +- Vendor management +- Change management procedures +- Incident response plan + +## Vulnerability Management + +### Security Updates + +**Update Process**: +1. Monitor security advisories for dependencies +2. Test updates in staging environment +3. Schedule maintenance window +4. Apply updates and verify +5. Document changes + +**Automated Scanning**: +```bash +# Scan Python dependencies +pip install safety +safety check + +# Scan for vulnerabilities +npm audit # If using Node.js tools +``` + +### Penetration Testing + +**Recommended Schedule**: +- Annual penetration testing +- After major releases +- Before compliance audits + +**Testing Scope**: +- Web application security +- API security +- Authentication mechanisms +- Database security +- Network security + +### Responsible Disclosure + +**Security Issue Reporting**: +- Email: security@your-org.com +- PGP key available for encrypted reports +- Expected response time: 48 hours +- Coordinated disclosure policy + +## Incident Response + +### Incident Response Plan + +**Phase 1: Detection** +- Monitor audit logs for suspicious activity +- Alert system for security events +- User reports of suspicious behavior + +**Phase 2: Containment** +- Isolate affected systems +- Disable compromised accounts +- Block malicious IP addresses +- Preserve evidence + +**Phase 3: Eradication** +- Identify root cause +- Remove malicious code/access +- Patch vulnerabilities +- Reset compromised credentials + +**Phase 4: Recovery** +- Restore from clean backups +- Verify system integrity +- Monitor for recurrence +- Gradual service restoration + +**Phase 5: Lessons Learned** +- Document incident timeline +- Identify improvements +- Update procedures +- Train personnel + +### Incident Response Procedures + +**Security Breach Response**: +```bash +# 1. Isolate the system +sudo systemctl stop scidk +sudo ufw deny from suspicious_ip + +# 2. Preserve evidence +sudo journalctl -u scidk > incident_logs.txt +cp ~/.scidk/db/files.db incident_db_$(date +%Y%m%d).backup + +# 3. Reset credentials +./scripts/reset_all_passwords.sh + +# 4. Restore from known good backup +cp ~/.scidk/db/files.db.verified ~/.scidk/db/files.db + +# 5. Restart with monitoring +sudo systemctl start scidk +tail -f /var/log/syslog | grep scidk +``` + +**Data Breach Response**: +1. Determine scope: What data was accessed? +2. Notify affected parties (per regulations) +3. Document the breach +4. Report to authorities (if required) +5. Implement additional controls + +### Incident Communication + +**Internal Communication**: +- Notify security team immediately +- Escalate to management within 1 hour +- Brief technical team on containment + +**External Communication**: +- Notify affected users (if PII compromised) +- Regulatory notification (if required) +- Public disclosure (if significant breach) + +**Communication Template**: +``` +Subject: Security Incident Notification + +We are writing to inform you of a security incident that occurred on [date]. + +Incident Type: [Unauthorized access / Data breach / etc.] +Data Affected: [Description] +Actions Taken: [Containment, investigation, etc.] +User Actions Required: [Password reset, etc.] + +We take security seriously and have implemented additional measures... +``` + +## Security Monitoring + +### Real-Time Monitoring + +**Monitor for**: +- Failed login attempts (>5 in 5 minutes) +- Unusual access patterns +- Large data exports +- Configuration changes +- Database connection errors + +**Alert Configuration**: +```python +# Example alert rule +alert_rules = { + "failed_logins": { + "condition": "count > 5 in 5 minutes", + "action": "email_admin", + "severity": "high" + } +} +``` + +### Security Metrics + +**Track**: +- Authentication success/failure rate +- Average session duration +- API error rates +- Disk space usage +- Database connection pool status + +### Log Analysis + +**Regular Reviews**: +- Daily: Security event review +- Weekly: Authentication pattern analysis +- Monthly: Comprehensive security audit +- Quarterly: Access control review + +```bash +# Example log analysis +# Failed logins +sudo journalctl -u scidk | grep "LOGIN_FAILED" | wc -l + +# Unique IP addresses +sudo journalctl -u scidk | grep "LOGIN" | awk '{print $X}' | sort -u | wc -l +``` + +## Security Checklist + +### Deployment Security Checklist + +- [ ] Change all default passwords +- [ ] Enable HTTPS with valid certificates +- [ ] Configure firewall rules +- [ ] Enable authentication and RBAC +- [ ] Set strong session timeout +- [ ] Enable audit logging +- [ ] Encrypt sensitive data at rest +- [ ] Configure secure backup procedures +- [ ] Set up security monitoring and alerts +- [ ] Document incident response procedures +- [ ] Perform security assessment +- [ ] Train administrators on security procedures + +### Monthly Security Review + +- [ ] Review audit logs for anomalies +- [ ] Check for security updates +- [ ] Verify backup integrity +- [ ] Review user accounts and permissions +- [ ] Test disaster recovery procedures +- [ ] Review alert configurations +- [ ] Update documentation + +## Additional Resources + +- **Deployment Guide**: [DEPLOYMENT.md](DEPLOYMENT.md) +- **Operations Manual**: [OPERATIONS.md](OPERATIONS.md) +- **Troubleshooting**: [TROUBLESHOOTING.md](TROUBLESHOOTING.md) +- **OWASP Top 10**: https://owasp.org/www-project-top-ten/ +- **NIST Cybersecurity Framework**: https://www.nist.gov/cyberframework +- **CIS Controls**: https://www.cisecurity.org/controls/ diff --git a/docs/TROUBLESHOOTING.md b/docs/TROUBLESHOOTING.md new file mode 100644 index 0000000..49a6330 --- /dev/null +++ b/docs/TROUBLESHOOTING.md @@ -0,0 +1,862 @@ +# SciDK Troubleshooting Guide + +This guide provides solutions to common problems encountered when running SciDK. Each issue includes symptoms, diagnosis steps, and solutions. + +## Table of Contents + +- [Application Won't Start](#application-wont-start) +- [Neo4j Connection Issues](#neo4j-connection-issues) +- [Import and Scan Failures](#import-and-scan-failures) +- [Database Issues](#database-issues) +- [Performance Problems](#performance-problems) +- [Authentication and Permission Errors](#authentication-and-permission-errors) +- [Disk Space Issues](#disk-space-issues) +- [Network and Connectivity](#network-and-connectivity) + +## Application Won't Start + +### Problem: Port Already in Use + +**Symptoms**: +``` +Error: [Errno 98] Address already in use +OSError: [Errno 48] Address already in use +``` + +**Diagnosis**: +```bash +# Find what's using port 5000 +sudo lsof -i :5000 +sudo netstat -tlnp | grep 5000 +``` + +**Solutions**: + +1. **Kill the existing process**: + ```bash + # Find the PID + sudo lsof -i :5000 + # Kill it + sudo kill -9 + ``` + +2. **Use a different port**: + ```bash + export SCIDK_PORT=5001 + scidk-serve + ``` + +3. **Update systemd configuration**: + ```bash + sudo nano /etc/systemd/system/scidk.service + # Change Environment="SCIDK_PORT=5000" to desired port + sudo systemctl daemon-reload + sudo systemctl restart scidk + ``` + +### Problem: Python Module Not Found + +**Symptoms**: +``` +ModuleNotFoundError: No module named 'flask' +ModuleNotFoundError: No module named 'scidk' +``` + +**Diagnosis**: +```bash +# Check if virtual environment is activated +which python +# Should show: /path/to/.venv/bin/python + +# Check installed packages +pip list | grep flask +``` + +**Solutions**: + +1. **Activate virtual environment**: + ```bash + source .venv/bin/activate + ``` + +2. **Reinstall dependencies**: + ```bash + pip install -e . + # Or with dev dependencies: + pip install -e .[dev] + ``` + +3. **Verify installation**: + ```bash + pip show scidk + ``` + +### Problem: Permission Denied + +**Symptoms**: +``` +PermissionError: [Errno 13] Permission denied: '/opt/scidk/...' +``` + +**Diagnosis**: +```bash +# Check file ownership +ls -la /opt/scidk +ls -la ~/.scidk/db/ +``` + +**Solutions**: + +1. **Fix ownership** (if running as specific user): + ```bash + sudo chown -R scidk:scidk /opt/scidk + sudo chown -R $USER:$USER ~/.scidk + ``` + +2. **Fix permissions**: + ```bash + chmod 755 /opt/scidk + chmod 644 /opt/scidk/*.py + ``` + +3. **Run as correct user**: + ```bash + sudo -u scidk scidk-serve + ``` + +## Neo4j Connection Issues + +### Problem: Cannot Connect to Neo4j + +**Symptoms**: +- "Failed to connect to Neo4j" error in UI or logs +- Commit to Graph fails +- Map page shows no data from Neo4j + +**Diagnosis**: +```bash +# Check if Neo4j is running +docker compose -f docker-compose.neo4j.yml ps + +# Check Neo4j logs +docker compose -f docker-compose.neo4j.yml logs neo4j | tail -50 + +# Test connection manually +curl http://localhost:7474 +``` + +**Solutions**: + +1. **Start Neo4j** (if not running): + ```bash + docker compose -f docker-compose.neo4j.yml up -d + ``` + +2. **Check credentials**: + - Navigate to Settings → Neo4j + - Verify URI: `bolt://localhost:7687` + - Verify username: `neo4j` + - Enter correct password + - Click "Test Connection" + +3. **Check firewall**: + ```bash + # Allow port 7687 (Bolt) and 7474 (HTTP) + sudo ufw allow 7687 + sudo ufw allow 7474 + ``` + +4. **Verify NEO4J_AUTH environment variable**: + ```bash + echo $NEO4J_AUTH + # Should output: neo4j/your_password + ``` + +5. **Reset Neo4j password**: + ```bash + ./scripts/neo4j_set_password.sh 'NewPassword123!' \ + --container scidk-neo4j \ + --current 'neo4jiscool' + ``` + +### Problem: Authentication Failed + +**Symptoms**: +``` +The client is unauthorized due to authentication failure. +neo4j.exceptions.AuthError +``` + +**Diagnosis**: +```bash +# Check configured credentials +grep NEO4J_AUTH .env + +# Check Neo4j is ready +docker compose -f docker-compose.neo4j.yml logs neo4j | grep "Started" +``` + +**Solutions**: + +1. **Update password in Settings**: + - Settings → Neo4j + - Enter correct password + - Click "Save" + +2. **Verify password in Neo4j Browser**: + - Navigate to http://localhost:7474 + - Log in with credentials + - If login fails, password needs reset + +3. **Reset to default password**: + ```bash + # Stop Neo4j + docker compose -f docker-compose.neo4j.yml down -v + + # Set password + export NEO4J_AUTH=neo4j/neo4jiscool + + # Start Neo4j + docker compose -f docker-compose.neo4j.yml up -d + ``` + +### Problem: Neo4j Connection Timeout + +**Symptoms**: +- Long delays before connection errors +- Timeouts in logs + +**Solutions**: + +1. **Check network connectivity**: + ```bash + telnet localhost 7687 + # Or: + nc -zv localhost 7687 + ``` + +2. **Increase timeout** (in Settings → Neo4j or environment): + ```bash + export NEO4J_TIMEOUT=30 # seconds + ``` + +3. **Check Docker network**: + ```bash + docker network inspect bridge + ``` + +## Import and Scan Failures + +### Problem: Scan Fails with Permission Error + +**Symptoms**: +- Scan shows "failed" status +- Log shows permission denied for files/directories + +**Diagnosis**: +```bash +# Check directory permissions +ls -la /path/to/scan/directory + +# Try listing manually +ls /path/to/scan/directory +``` + +**Solutions**: + +1. **Fix permissions**: + ```bash + # Make directory readable + chmod -R o+r /path/to/directory + ``` + +2. **Run as correct user**: + ```bash + # If using systemd, update service user + sudo nano /etc/systemd/system/scidk.service + # Set User= to user with access + ``` + +3. **Use different path with proper permissions** + +### Problem: Large Files Cause Memory Errors + +**Symptoms**: +- Application crashes during scan +- "Out of memory" errors +- System becomes unresponsive + +**Solutions**: + +1. **Increase batch size settings**: + - Settings → Interpreters + - Increase batch size to process fewer files at once + +2. **Use selective scanning**: + - Scan specific subdirectories instead of entire tree + - Use non-recursive mode for large directories + +3. **Increase available memory**: + ```bash + # For systemd service + sudo nano /etc/systemd/system/scidk.service + # Add: LimitMEMLOCK=8G + ``` + +4. **Exclude large files**: + - Use file extension filters + - Filter by file size in UI + +### Problem: Rclone Scan Fails + +**Symptoms**: +- Rclone scans show error status +- "rclone not found" error +- Remote not configured error + +**Diagnosis**: +```bash +# Check if rclone is installed +which rclone +rclone version + +# List configured remotes +rclone listremotes + +# Test remote connection +rclone lsd remote: +``` + +**Solutions**: + +1. **Install rclone**: + ```bash + # Ubuntu/Debian: + sudo apt-get install rclone + + # macOS: + brew install rclone + ``` + +2. **Configure remote**: + ```bash + rclone config + # Follow prompts to set up your remote + ``` + +3. **Test remote access**: + ```bash + rclone ls remote:bucket + ``` + +4. **Enable rclone provider**: + ```bash + export SCIDK_PROVIDERS=local_fs,mounted_fs,rclone + ``` + +### Problem: Import Creates Duplicate Nodes + +**Symptoms**: +- Map shows duplicate File or Folder nodes +- Relationship counts don't match expected + +**Diagnosis**: +```cypher +// In Neo4j Browser +MATCH (f:File) +WITH f.path as path, count(*) as cnt +WHERE cnt > 1 +RETURN path, cnt +``` + +**Solutions**: + +1. **Clean up duplicates**: + ```cypher + // Delete duplicate nodes (keep one) + MATCH (f:File) + WITH f.path as path, collect(f) as nodes + WHERE size(nodes) > 1 + FOREACH (n IN tail(nodes) | DELETE n) + ``` + +2. **Use data cleaning UI**: + - Navigate to Files/Datasets + - Use bulk delete to remove duplicates + +3. **Re-scan and commit**: + - Delete affected scan + - Re-run scan + - Commit to graph + +## Database Issues + +### Problem: Database is Locked + +**Symptoms**: +``` +sqlite3.OperationalError: database is locked +``` + +**Diagnosis**: +```bash +# Check for multiple processes +ps aux | grep scidk + +# Check SQLite journal mode +sqlite3 ~/.scidk/db/files.db "PRAGMA journal_mode;" +``` + +**Solutions**: + +1. **Enable WAL mode** (if not already enabled): + ```bash + sqlite3 ~/.scidk/db/files.db "PRAGMA journal_mode=WAL;" + ``` + +2. **Kill duplicate processes**: + ```bash + # Find all scidk processes + ps aux | grep scidk-serve + # Kill extras (keep only one) + kill + ``` + +3. **Restart application**: + ```bash + sudo systemctl restart scidk + ``` + +### Problem: Database Corruption + +**Symptoms**: +``` +sqlite3.DatabaseError: database disk image is malformed +PRAGMA integrity_check fails +``` + +**Diagnosis**: +```bash +# Check database integrity +sqlite3 ~/.scidk/db/files.db "PRAGMA integrity_check;" +``` + +**Solutions**: + +1. **Restore from backup**: + ```bash + sudo systemctl stop scidk + cp ~/.scidk/db/files.db.backup ~/.scidk/db/files.db + sudo systemctl start scidk + ``` + +2. **Attempt recovery** (if no backup): + ```bash + # Dump and rebuild + sqlite3 ~/.scidk/db/files.db ".dump" > dump.sql + sqlite3 ~/.scidk/db/files_new.db < dump.sql + mv ~/.scidk/db/files.db ~/.scidk/db/files.db.corrupt + mv ~/.scidk/db/files_new.db ~/.scidk/db/files.db + ``` + +3. **Check disk for errors**: + ```bash + df -h + sudo fsck /dev/sda1 # Adjust device as needed + ``` + +### Problem: Migration Failures + +**Symptoms**: +- Health endpoint reports old schema_version +- Application errors on startup about missing columns/tables + +**Diagnosis**: +```bash +# Check migration status +curl http://localhost:5000/api/health | jq '.sqlite.schema_version' + +# Check logs for migration errors +sudo journalctl -u scidk -n 100 | grep migration +``` + +**Solutions**: + +1. **Manual migration** (advanced): + ```bash + # Backup first! + cp ~/.scidk/db/files.db ~/.scidk/db/files.db.pre-migration + + # Run migrations manually via Python + python3 -c "from scidk.core import migrations; migrations.migrate()" + ``` + +2. **Restore and retry**: + ```bash + # Restore from working backup + # Ensure latest code is pulled + git pull + pip install -e . --upgrade + ``` + +## Performance Problems + +### Problem: Slow Scan Performance + +**Symptoms**: +- Scans take hours for moderate-sized directories +- UI becomes unresponsive during scans + +**Diagnosis**: +```bash +# Check if ncdu/gdu is installed +which ncdu +which gdu + +# Check system load +top +htop +``` + +**Solutions**: + +1. **Install faster file enumeration tools**: + ```bash + # Ubuntu/Debian: + sudo apt-get install ncdu + + # macOS: + brew install ncdu gdu + ``` + +2. **Use non-recursive scans**: + - Uncheck "Recursive" in scan dialog + - Scan specific subdirectories + +3. **Enable fast_list mode** (for rclone): + - Check "Fast List" option in scan dialog + +4. **Adjust batch size**: + - Settings → Interpreters + - Reduce batch size for better responsiveness + +### Problem: Map Page Slow to Load + +**Symptoms**: +- Map takes minutes to render +- Browser becomes unresponsive + +**Solutions**: + +1. **Filter data**: + - Use label type filters to reduce node count + - Use relationship filters + +2. **Use different layout**: + - Try "breadthfirst" instead of "force" + - Disable physics after initial layout + +3. **Reduce node/edge styling**: + - Decrease node size slider + - Decrease edge width slider + +4. **Limit data in graph**: + - Use selective imports + - Clean up old or unnecessary data + +### Problem: Slow Database Queries + +**Symptoms**: +- File browsing is slow +- Search takes long time + +**Solutions**: + +1. **Run VACUUM**: + ```bash + sqlite3 ~/.scidk/db/files.db "VACUUM;" + ``` + +2. **Run ANALYZE**: + ```bash + sqlite3 ~/.scidk/db/files.db "ANALYZE;" + ``` + +3. **Check database size**: + ```bash + du -sh ~/.scidk/db/files.db* + # If very large, consider archiving old data + ``` + +4. **Restart application**: + ```bash + sudo systemctl restart scidk + ``` + +## Authentication and Permission Errors + +### Problem: Cannot Log In + +**Symptoms**: +- Login page shows "Invalid credentials" +- Correct password doesn't work + +**Solutions**: + +1. **Reset admin password** (via SQLite): + ```python + import bcrypt + import sqlite3 + + password = b'newpassword' + hashed = bcrypt.hashpw(password, bcrypt.gensalt()) + + conn = sqlite3.connect('/path/to/files.db') + conn.execute("UPDATE users SET password_hash=? WHERE username='admin'", (hashed,)) + conn.commit() + ``` + +2. **Check if authentication is enabled**: + ```bash + # Check Settings → Security in UI + # Or query database: + sqlite3 ~/.scidk/db/files.db "SELECT * FROM auth_config;" + ``` + +3. **Disable authentication temporarily** (troubleshooting only): + - Not recommended for production + - Consult security team first + +### Problem: Session Expires Too Quickly + +**Symptoms**: +- Repeatedly redirected to login +- Session timeout message appears frequently + +**Solutions**: + +1. **Adjust session timeout**: + - Settings → General + - Increase "Session Timeout" value + - Click "Save" + +2. **Check for auto-lock settings**: + - Settings → Security + - Adjust inactivity timeout + +### Problem: Unauthorized Access to API + +**Symptoms**: +``` +401 Unauthorized +403 Forbidden +``` + +**Solutions**: + +1. **Include authentication header**: + ```bash + curl -H "Authorization: Bearer YOUR_TOKEN" \ + http://localhost:5000/api/endpoint + ``` + +2. **Check user role**: + - Admin role required for certain endpoints + - Verify user has appropriate permissions + +3. **Regenerate token** (if expired) + +## Disk Space Issues + +### Problem: Disk Full Errors + +**Symptoms**: +``` +OSError: [Errno 28] No space left on device +Disk space critical alert +``` + +**Diagnosis**: +```bash +# Check disk usage +df -h + +# Find large files +du -sh ~/.scidk/db/* | sort -h +du -sh ./data/neo4j/* | sort -h + +# Check log size +sudo journalctl --disk-usage +``` + +**Solutions**: + +1. **Clean up old logs**: + ```bash + sudo journalctl --vacuum-time=30d + sudo journalctl --vacuum-size=500M + ``` + +2. **Remove old backups**: + ```bash + find ~/.scidk/backups -mtime +90 -delete + ``` + +3. **Clean up old scans**: + - Navigate to Files → Scans + - Delete old or unnecessary scans + +4. **VACUUM database**: + ```bash + sqlite3 ~/.scidk/db/files.db "VACUUM;" + ``` + +5. **Expand storage**: + - Add disk space to VM/server + - Move data directory to larger partition + +### Problem: Database File Growing Too Large + +**Symptoms**: +- Database file is multiple GB +- Disk space alerts + +**Diagnosis**: +```bash +du -sh ~/.scidk/db/files.db* + +# Check table sizes +sqlite3 ~/.scidk/db/files.db " +SELECT name, SUM(pgsize) as size +FROM dbstat +GROUP BY name +ORDER BY size DESC; +" +``` + +**Solutions**: + +1. **Archive old scans**: + ```bash + # Export old scans to files + # Delete from database + ``` + +2. **Run VACUUM**: + ```bash + sqlite3 ~/.scidk/db/files.db "VACUUM;" + ``` + +3. **Clean up WAL files**: + ```bash + sqlite3 ~/.scidk/db/files.db "PRAGMA wal_checkpoint(TRUNCATE);" + ``` + +## Network and Connectivity + +### Problem: Cannot Access Web UI + +**Symptoms**: +- Browser shows "Connection refused" +- "This site can't be reached" + +**Diagnosis**: +```bash +# Check if application is running +sudo systemctl status scidk + +# Check if port is open +netstat -tlnp | grep 5000 + +# Test locally +curl http://localhost:5000/api/health +``` + +**Solutions**: + +1. **Start application**: + ```bash + sudo systemctl start scidk + ``` + +2. **Check firewall**: + ```bash + sudo ufw status + sudo ufw allow 5000 + ``` + +3. **Check nginx configuration** (if using reverse proxy): + ```bash + sudo nginx -t + sudo systemctl status nginx + ``` + +4. **Check host binding**: + ```bash + # Ensure SCIDK_HOST=0.0.0.0 to accept remote connections + export SCIDK_HOST=0.0.0.0 + ``` + +### Problem: Slow Network Performance + +**Symptoms**: +- Pages take long time to load +- API requests timeout + +**Solutions**: + +1. **Check network connectivity**: + ```bash + ping your-server + traceroute your-server + ``` + +2. **Check server load**: + ```bash + top + htop + ``` + +3. **Restart nginx** (if using): + ```bash + sudo systemctl restart nginx + ``` + +4. **Check for rate limiting** (if configured) + +## Log File Locations + +- **Application logs** (systemd): `journalctl -u scidk` +- **nginx access logs**: `/var/log/nginx/access.log` +- **nginx error logs**: `/var/log/nginx/error.log` +- **Neo4j logs**: `docker compose -f docker-compose.neo4j.yml logs neo4j` +- **SQLite errors**: Application logs (journalctl) + +## Getting More Help + +If problems persist after trying these solutions: + +1. **Gather diagnostic information**: + ```bash + # Health check + curl http://localhost:5000/api/health > health.json + + # Recent logs + sudo journalctl -u scidk -n 500 > scidk.log + + # System info + uname -a > system.txt + df -h >> system.txt + free -h >> system.txt + ``` + +2. **Check documentation**: + - [DEPLOYMENT.md](DEPLOYMENT.md) + - [OPERATIONS.md](OPERATIONS.md) + - [SECURITY.md](SECURITY.md) + +3. **Report issue**: + - Include error messages + - Include diagnostic output + - Describe steps to reproduce + - Mention environment (OS, Python version, etc.) diff --git a/docs/plugins.md b/docs/plugins.md new file mode 100644 index 0000000..e23b02b --- /dev/null +++ b/docs/plugins.md @@ -0,0 +1,374 @@ +# SciDK Plugin System + +The SciDK plugin system allows you to extend the application with custom functionality, routes, labels, and integrations without modifying the core codebase. + +## Overview + +Plugins are Python packages placed in the `plugins/` directory that are automatically discovered and loaded at application startup. Each plugin can: + +- Add custom API routes and endpoints +- Register new label definitions +- Define custom settings +- Integrate with external services +- Extend existing functionality + +## Plugin Structure + +A minimal plugin consists of a directory with an `__init__.py` file: + +``` +plugins/ + my_plugin/ + __init__.py # Required: Contains register_plugin(app) function + routes.py # Optional: Flask blueprints with routes + labels.py # Optional: Label definitions + settings.html # Optional: Settings UI template + README.md # Optional: Plugin documentation + tests/ # Optional: Plugin-specific tests +``` + +## Creating a Plugin + +### 1. Create Plugin Directory + +Create a new directory under `plugins/` with a descriptive name: + +```bash +mkdir plugins/my_plugin +``` + +### 2. Implement `register_plugin()` Function + +Create `__init__.py` with a `register_plugin(app)` function that returns plugin metadata: + +```python +# plugins/my_plugin/__init__.py + +def register_plugin(app): + """Register the plugin with the Flask app. + + Args: + app: Flask application instance + + Returns: + dict: Plugin metadata with name, version, author, description + """ + # Your plugin initialization code here + + return { + 'name': 'My Plugin', + 'version': '1.0.0', + 'author': 'Your Name', + 'description': 'A brief description of what this plugin does' + } +``` + +### 3. Add Routes (Optional) + +Create a Flask blueprint for your plugin's routes: + +```python +# plugins/my_plugin/__init__.py + +from flask import Blueprint, jsonify + +bp = Blueprint('my_plugin', __name__, url_prefix='/api/my_plugin') + +@bp.get('/status') +def status(): + """Example endpoint.""" + return jsonify({'status': 'active', 'plugin': 'my_plugin'}) + +def register_plugin(app): + # Register the blueprint + app.register_blueprint(bp) + + return { + 'name': 'My Plugin', + 'version': '1.0.0', + 'author': 'Your Name', + 'description': 'Adds /api/my_plugin/status endpoint' + } +``` + +### 4. Register Labels (Optional) + +Plugins can define custom label types for the graph database: + +```python +# plugins/my_plugin/labels.py + +def register_labels(app): + """Register custom labels with the application.""" + # Access the graph backend + ext = app.extensions['scidk'] + graph = ext['graph'] + + # Define a new label + graph.add_label({ + 'name': 'MyCustomLabel', + 'properties': [ + {'name': 'custom_id', 'type': 'string'}, + {'name': 'value', 'type': 'float'} + ] + }) +``` + +Then call it from your `register_plugin()` function: + +```python +def register_plugin(app): + from . import labels + labels.register_labels(app) + + # ... rest of registration +``` + +## Plugin Management + +### Web UI + +Navigate to `/extensions` to view and manage plugins: + +- View installed plugins with metadata +- Enable/disable plugins via toggle switches +- See plugin status and version information +- View failed plugin error messages + +**Note:** Changes to plugin enabled state require an application restart to take effect. + +### API Endpoints + +#### List Plugins + +```http +GET /api/plugins +``` + +Returns a list of all discovered plugins with their status and metadata. + +Response: +```json +{ + "success": true, + "plugins": [ + { + "name": "My Plugin", + "version": "1.0.0", + "author": "Your Name", + "description": "Plugin description", + "enabled": true, + "status": "loaded", + "module_name": "my_plugin" + } + ], + "failed": {} +} +``` + +#### Toggle Plugin + +```http +POST /api/plugins//toggle +Content-Type: application/json + +{ + "enabled": true +} +``` + +Enables or disables a plugin. Requires application restart for changes to take effect. + +Response: +```json +{ + "success": true, + "plugin": "my_plugin", + "enabled": true, + "message": "Plugin state updated. Restart required for changes to take effect." +} +``` + +## Plugin States + +- **loaded**: Plugin successfully loaded and active +- **disabled**: Plugin disabled via Extensions page +- **not_loaded**: Plugin discovered but not loaded (usually disabled) +- **failed**: Plugin failed to load (check error message) + +## Error Handling + +The plugin loader handles errors gracefully: + +- Plugin load failures are logged but don't crash the application +- Failed plugins appear in the "Failed Plugins" section with error messages +- Invalid plugins (missing `register_plugin()`, incorrect return type) are caught and reported + +## Best Practices + +### 1. Return Complete Metadata + +Always return all required metadata fields: + +```python +return { + 'name': 'My Plugin', # Required + 'version': '1.0.0', # Required + 'author': 'Your Name', # Required + 'description': 'Description' # Required +} +``` + +### 2. Use Blueprints for Routes + +Organize routes in Flask blueprints to avoid naming conflicts: + +```python +bp = Blueprint('my_plugin', __name__, url_prefix='/api/my_plugin') +``` + +### 3. Handle Errors Gracefully + +Catch and log errors in your plugin code: + +```python +def register_plugin(app): + try: + # Plugin initialization + app.register_blueprint(bp) + except Exception as e: + app.logger.error(f"Failed to initialize my_plugin: {e}") + raise + + return {...} +``` + +### 4. Document Your Plugin + +Include a README.md with: +- Plugin purpose and features +- API endpoints and usage +- Configuration options +- Dependencies + +### 5. Test Your Plugin + +Create tests in `plugins/my_plugin/tests/`: + +```python +# plugins/my_plugin/tests/test_my_plugin.py + +def test_my_plugin_endpoint(client): + resp = client.get('/api/my_plugin/status') + assert resp.status_code == 200 + assert resp.get_json()['status'] == 'active' +``` + +## Example Plugin + +See `plugins/example_plugin/` for a complete working example that demonstrates: + +- Plugin registration +- Blueprint creation +- Multiple endpoints +- Proper metadata +- Documentation + +## Advanced Topics + +### Accessing Application Services + +Access core SciDK services through `app.extensions['scidk']`: + +```python +def register_plugin(app): + ext = app.extensions['scidk'] + + # Access the graph backend + graph = ext['graph'] + + # Access the interpreter registry + registry = ext['registry'] + + # Access filesystem manager + fs = ext['fs'] + + # Access settings + settings = ext['settings'] + + # ... use services +``` + +### Database Persistence + +Use the settings API for plugin configuration: + +```python +from scidk.core.settings import get_setting, set_setting + +def register_plugin(app): + # Load plugin config + api_key = get_setting('plugin.my_plugin.api_key', 'default_key') + + # Save plugin config + set_setting('plugin.my_plugin.api_key', 'new_key') +``` + +### Integration with Existing Features + +Plugins can extend existing features: + +```python +def register_plugin(app): + # Add custom interpreter + registry = app.extensions['scidk']['registry'] + from .interpreters import MyCustomInterpreter + registry.register(MyCustomInterpreter()) + + # Add custom provider + providers = app.extensions['scidk']['providers'] + from .providers import MyCustomProvider + providers['my_provider'] = MyCustomProvider() +``` + +## Troubleshooting + +### Plugin Not Appearing + +1. Check that `__init__.py` exists in plugin directory +2. Verify `register_plugin(app)` function exists +3. Check application logs for errors +4. Ensure plugin directory name doesn't start with `_` or `.` + +### Plugin Load Failures + +1. Check `/extensions` page for error messages +2. Review application logs +3. Verify `register_plugin()` returns a dict +4. Check for import errors or missing dependencies + +### Plugin Not Activating + +1. Verify plugin is enabled in Extensions page +2. Restart the application after enabling +3. Check that blueprints are registered correctly +4. Verify routes don't conflict with existing endpoints + +## Security Considerations + +- Plugins run with full application privileges +- Only install plugins from trusted sources +- Review plugin code before installation +- Plugins can access all application data and services +- Use RBAC to restrict access to plugin endpoints if needed + +## Future Enhancements + +Planned features for the plugin system: + +- Plugin marketplace +- Plugin dependencies +- Plugin permissions/sandboxing +- Hot reload (no restart required) +- Plugin versioning and updates +- Plugin configuration UI templates diff --git a/docs/plugins/ILAB_IMPORTER.md b/docs/plugins/ILAB_IMPORTER.md new file mode 100644 index 0000000..f2a9dc2 --- /dev/null +++ b/docs/plugins/ILAB_IMPORTER.md @@ -0,0 +1,272 @@ +# iLab Data Importer Plugin + +## Overview + +The **iLab Data Importer** is a specialized plugin for importing iLab core facility data into SciDK. It provides a branded user experience with preset configurations for common iLab export types, column hints, and suggested label mappings. + +## Features + +- **🧪 Branded UI**: Distinctive visual styling with iLab icon and color scheme +- **Preset Configurations**: Pre-configured templates for: + - Equipment inventory + - Services catalog + - PI Directory +- **Column Hints**: Helpful mappings showing how iLab columns map to SciDK properties +- **Suggested Labels**: Recommended label types for graph integration +- **Auto-fill Table Names**: Smart defaults with year insertion (e.g., `ilab_equipment_2024`) + +## Installation + +The iLab Data Importer plugin is included with SciDK and located in `plugins/ilab_table_loader/`. + +No additional installation steps are required - the plugin is automatically discovered on startup. + +## Usage + +### Creating an iLab Import Instance + +1. Navigate to **Settings > Plugins** +2. Scroll to the **Plugin Instances** section +3. Click **"+ New Plugin Instance"** +4. Select **"iLab Data Importer"** (identified by the 🧪 icon) +5. Choose a preset or select "Custom" for manual configuration +6. Upload your iLab export file (CSV or Excel format) +7. Configure graph integration (optional) +8. Click **"Create Instance"** + +### Available Presets + +#### Equipment Preset + +**Use for**: iLab equipment inventory exports + +**Expected columns**: +- Service Name → `name` +- Core → `core_facility` +- PI → `principal_investigator` +- Location → `location` +- Equipment ID → `equipment_id` +- Description → `description` + +**Suggested labels**: `Equipment`, `LabResource` + +**Table name hint**: `ilab_equipment_YYYY` (YYYY = current year) + +#### Services Preset + +**Use for**: iLab services catalog exports + +**Expected columns**: +- Service Name → `name` +- Core → `core_facility` +- Rate Per Hour → `hourly_rate` +- Service ID → `service_id` +- Active → `is_active` + +**Suggested labels**: `iLabService` + +**Table name hint**: `ilab_services_YYYY` + +#### PI Directory Preset + +**Use for**: Principal Investigator directory exports + +**Expected columns**: +- PI Name → `name` +- Email → `email` +- Department → `department` +- Lab → `lab_name` +- Phone → `phone` +- Office → `office_location` + +**Suggested labels**: `PrincipalInvestigator`, `Researcher` + +**Table name hint**: `ilab_pi_directory` + +## Example Workflow + +### Step 1: Export Data from iLab + +Export your data from iLab in CSV or Excel format. The iLab Data Importer supports standard iLab export formats. + +### Step 2: Create Plugin Instance + +``` +Settings > Plugins > "+ New Plugin Instance" > iLab Data Importer +``` + +Select the **Equipment** preset for equipment data. + +### Step 3: Upload File + +Browse to your iLab export file (e.g., `equipment_export_2024.xlsx`) + +The table name will auto-fill to `ilab_equipment_2024` + +### Step 4: Configure Graph Integration (Optional) + +Enable **"Create Label from this data"** to sync equipment to Neo4j: +- Label Name: `LabEquipment` +- Primary Key: `equipment_id` (or appropriate unique column) +- Sync Strategy: On-demand or Automatic + +### Step 5: Import and Sync + +Click **"Create Instance"** to import the data. + +If graph integration is enabled, data will be synced to Neo4j as nodes with the specified label. + +## File Format Requirements + +### Supported File Types +- CSV (`.csv`) +- Excel (`.xlsx`, `.xls`) +- TSV (`.tsv`) + +### Requirements +- Files must have a header row with column names +- Column names should match iLab export format (or use Custom preset) +- No special characters in table names (alphanumeric and underscores only) + +## Graph Integration + +The iLab Data Importer integrates with SciDK's knowledge graph system: + +1. **Label Creation**: Data is imported into a SQLite table +2. **Label Registration**: A Label schema is created linking to the table +3. **Neo4j Sync**: Rows are synced to Neo4j as nodes +4. **Relationship Support**: Link equipment/services to projects, samples, or other entities + +### Recommended Label Mappings + +| iLab Export Type | Recommended Label | Primary Key Column | +|------------------|-------------------|-------------------| +| Equipment | `Equipment` or `LabResource` | `Equipment ID` | +| Services | `iLabService` | `Service ID` | +| PI Directory | `PrincipalInvestigator` | `Email` | + +## Configuration Options + +### Instance Configuration + +| Field | Type | Required | Description | +|-------|------|----------|-------------| +| `instance_name` | string | Yes | Friendly name for this import | +| `preset` | enum | No | One of: equipment, services, pi_directory, custom | +| `file_path` | string | Yes | Path to iLab export file | +| `table_name` | string | No | SQLite table name (auto-filled from preset) | +| `file_type` | enum | No | csv, excel, tsv, or auto (default: auto) | +| `has_header` | boolean | No | Whether file has header row (default: true) | +| `replace_existing` | boolean | No | Replace existing table data (default: true) | + +### Graph Configuration + +| Field | Type | Required | Description | +|-------|------|----------|-------------| +| `label_name` | string | Yes* | Label name for Neo4j nodes | +| `primary_key` | string | Yes* | Column to use as unique identifier | +| `sync_strategy` | enum | No | on_demand or automatic (default: on_demand) | + +*Required if graph integration is enabled + +## Sample Data + +Sample iLab export files are available in `tests/fixtures/`: +- `ilab_equipment_sample.xlsx` - Equipment inventory sample +- `ilab_services_sample.xlsx` - Services catalog sample +- `ilab_pi_directory_sample.xlsx` - PI directory sample + +Use these files for testing or as templates for your iLab exports. + +## Troubleshooting + +### Problem: Plugin doesn't appear in template list + +**Solution**: +1. Check that the plugin is in `plugins/ilab_table_loader/` +2. Restart the SciDK application +3. Check logs for plugin loading errors + +### Problem: Column names don't match hints + +**Solution**: Use the **Custom** preset and manually configure column mappings, or rename columns in your iLab export to match expected names. + +### Problem: Table name is invalid + +**Solution**: Table names must start with a letter or underscore and contain only alphanumeric characters and underscores. The plugin validates this automatically. + +### Problem: Import fails with file error + +**Solution**: +1. Verify file path is correct +2. Check file format is CSV or Excel +3. Ensure file has a header row +4. Check for special characters or encoding issues + +## API Reference + +### Handler Function + +```python +handle_ilab_import(instance_config: dict) -> dict +``` + +**Parameters**: +- `instance_config`: Configuration dictionary with preset, file_path, table_name, etc. + +**Returns**: +- `dict` with keys: + - `status`: 'success' or 'error' + - `plugin`: 'ilab_importer' + - `preset`: Preset ID (if used) + - `preset_name`: Human-readable preset name + - `table_name`: SQLite table name + - `row_count`: Number of rows imported + - `columns`: List of column names + +### Plugin Registration + +```python +register_plugin(app) -> dict +``` + +Registers the iLab Data Importer template with the plugin system. + +**Returns**: Plugin metadata dictionary + +## Development + +### Running Tests + +```bash +pytest tests/test_ilab_plugin.py -v +``` + +### Adding New Presets + +Edit `plugins/ilab_table_loader/__init__.py` and add to `_get_preset_configs()`: + +```python +'my_preset': { + 'name': 'My Custom Preset', + 'table_name_hint': 'my_table_YYYY', + 'column_hints': { + 'iLab Column': 'scidk_property' + }, + 'suggested_labels': ['MyLabel'] +} +``` + +## See Also + +- [Plugin System Documentation](../PLUGINS.md) +- [Table Loader Plugin](./TABLE_LOADER.md) +- [Label System Documentation](../LABELS.md) +- [Graph Integration Guide](../GRAPH_INTEGRATION.md) + +## Support + +For issues or questions: +- Check the [Troubleshooting](#troubleshooting) section +- Review [SciDK Documentation](../../README.md) +- File an issue on the project repository diff --git a/e2e/alerts.spec.ts b/e2e/alerts.spec.ts new file mode 100644 index 0000000..7b95ad4 --- /dev/null +++ b/e2e/alerts.spec.ts @@ -0,0 +1,308 @@ +import { test, expect } from '@playwright/test'; + +/** + * E2E tests for Alerts configuration page. + * Tests SMTP configuration, alert management, and test notifications. + */ + +test('alerts section loads and displays configuration', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + // Navigate to Settings page + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Verify Alerts section is visible + const alertsSection = page.locator('#alerts-section'); + await expect(alertsSection).toBeVisible(); + await expect(alertsSection.locator('h1')).toHaveText('Alert Configuration'); + + // Verify SMTP configuration section exists + const smtpConfig = alertsSection.locator('.smtp-config'); + await expect(smtpConfig).toBeVisible(); + await expect(smtpConfig.locator('h2')).toHaveText('SMTP Configuration'); +}); + +test('smtp configuration form has all required inputs', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Check SMTP form inputs + const hostInput = page.locator('#smtp-host'); + const portInput = page.locator('#smtp-port'); + const usernameInput = page.locator('#smtp-username'); + const passwordInput = page.locator('#smtp-password'); + const fromInput = page.locator('#smtp-from'); + const tlsCheckbox = page.locator('#smtp-use-tls'); + + await expect(hostInput).toBeVisible(); + await expect(portInput).toBeVisible(); + await expect(usernameInput).toBeVisible(); + await expect(passwordInput).toBeVisible(); + await expect(fromInput).toBeVisible(); + await expect(tlsCheckbox).toBeVisible(); + + // Check buttons + const saveButton = page.locator('#btn-save-smtp'); + const testButton = page.locator('#btn-test-smtp'); + + await expect(saveButton).toBeVisible(); + await expect(testButton).toBeVisible(); + await expect(saveButton).toHaveText('Save SMTP Config'); + await expect(testButton).toHaveText('Test Email'); +}); + +test('default alerts are displayed', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Wait for alerts to load + await page.waitForTimeout(1000); + + // Verify default alerts exist + const alertsList = page.locator('#alerts-list'); + await expect(alertsList).toBeVisible(); + + // Check for specific default alerts + const alertCards = page.locator('.alert-card'); + const count = await alertCards.count(); + expect(count).toBeGreaterThanOrEqual(5); // 5 default alerts + + // Verify alert names + const alertText = await alertsList.textContent(); + expect(alertText).toContain('Import Failed'); + expect(alertText).toContain('High Discrepancies'); + expect(alertText).toContain('Backup Failed'); + expect(alertText).toContain('Neo4j Connection Lost'); + expect(alertText).toContain('Disk Space Critical'); +}); + +test('alert enable/disable toggle works', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Wait for alerts to load + await page.waitForTimeout(1000); + + // Find first alert's enable toggle + const firstAlertCard = page.locator('.alert-card').first(); + const enableToggle = firstAlertCard.locator('input[type="checkbox"]'); + + // Get initial state + const initialState = await enableToggle.isChecked(); + + // Toggle it + await enableToggle.click(); + await page.waitForTimeout(500); // Wait for API call + + // Verify state changed + const newState = await enableToggle.isChecked(); + expect(newState).toBe(!initialState); + + // Toggle back + await enableToggle.click(); + await page.waitForTimeout(500); + + // Verify it's back to original state + const finalState = await enableToggle.isChecked(); + expect(finalState).toBe(initialState); +}); + +test('alert recipients can be updated', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Wait for alerts to load + await page.waitForTimeout(1000); + + // Find first alert + const firstAlertCard = page.locator('.alert-card').first(); + const recipientsInput = firstAlertCard.locator('input[id^="alert-recipients-"]'); + const updateButton = firstAlertCard.locator('button:has-text("Update")'); + + // Clear and enter new recipients + await recipientsInput.clear(); + await recipientsInput.fill('test1@example.com, test2@example.com'); + + // Click update + await updateButton.click(); + await page.waitForTimeout(500); + + // Verify success message or that value persists + const updatedValue = await recipientsInput.inputValue(); + expect(updatedValue).toContain('test1@example.com'); +}); + +test('alert threshold can be updated for alerts with thresholds', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Wait for alerts to load + await page.waitForTimeout(1000); + + // Find "High Discrepancies" alert (has threshold) + const alertsList = page.locator('#alerts-list'); + const highDiscrepanciesCard = alertsList.locator('.alert-card:has-text("High Discrepancies")'); + + // Find threshold input + const thresholdInput = highDiscrepanciesCard.locator('input[id^="alert-threshold-"]'); + + // Only test if threshold input exists (it should for High Discrepancies) + if (await thresholdInput.isVisible()) { + // Update threshold + await thresholdInput.clear(); + await thresholdInput.fill('75'); + + // Click update + const updateButton = highDiscrepanciesCard.locator('button:has-text("Update")'); + await updateButton.click(); + await page.waitForTimeout(500); + + // Verify value persists + const updatedValue = await thresholdInput.inputValue(); + expect(updatedValue).toBe('75'); + } +}); + +test('smtp configuration can be saved', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Fill SMTP form + await page.locator('#smtp-host').fill('smtp.test.com'); + await page.locator('#smtp-port').fill('587'); + await page.locator('#smtp-username').fill('user@test.com'); + await page.locator('#smtp-from').fill('noreply@test.com'); + + // Save configuration + await page.locator('#btn-save-smtp').click(); + await page.waitForTimeout(500); + + // Verify success message + const messageEl = page.locator('#smtp-message'); + await expect(messageEl).toBeVisible(); + const messageText = await messageEl.textContent(); + expect(messageText).toContain('successfully'); +}); + +test('smtp test button is clickable', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Test button should be present and clickable (even if it fails due to no config) + const testButton = page.locator('#btn-test-smtp'); + await expect(testButton).toBeVisible(); + await expect(testButton).toBeEnabled(); + + // Click it (will likely fail without real SMTP, but should not crash) + await testButton.click(); + await page.waitForTimeout(500); + + // Should show some message (success or error) + const messageEl = page.locator('#smtp-message'); + await expect(messageEl).toBeVisible(); +}); + +test('alert test buttons are present and clickable', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Wait for alerts to load + await page.waitForTimeout(1000); + + // Find first alert's test button + const firstAlertCard = page.locator('.alert-card').first(); + const testButton = firstAlertCard.locator('button:has-text("Test")'); + + await expect(testButton).toBeVisible(); + await expect(testButton).toBeEnabled(); + + // Note: Actually clicking test would require SMTP config and recipients + // So we just verify the button exists +}); + +test('alert history section is present', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Find history section (details element) + const historyDetails = page.locator('details:has-text("Alert History")'); + await expect(historyDetails).toBeVisible(); + + // Expand history + await historyDetails.locator('summary').click(); + await page.waitForTimeout(500); + + // Verify history list exists + const historyList = page.locator('#alert-history-list'); + await expect(historyList).toBeVisible(); +}); + +test('alerts page handles no recipients gracefully', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Alerts section + await page.locator('.settings-sidebar-item[data-section="alerts"]').click(); + await page.waitForTimeout(200); + + // Wait for alerts to load + await page.waitForTimeout(1000); + + // Verify alerts with no recipients show "No recipients configured" + const alertsList = page.locator('#alerts-list'); + const alertText = await alertsList.textContent(); + + // Default alerts start with no recipients + expect(alertText).toContain('No recipients configured'); +}); diff --git a/e2e/integrations-label-discovery.spec.ts b/e2e/integrations-label-discovery.spec.ts new file mode 100644 index 0000000..1d70a44 --- /dev/null +++ b/e2e/integrations-label-discovery.spec.ts @@ -0,0 +1,364 @@ +import { test, expect } from '@playwright/test'; + +/** + * E2E Tests for Integrations Label Auto-Discovery + * + * Tests the automatic discovery and display of labels from all sources + * (system, manual, plugin instances) in the Integrations page dropdowns. + */ + +test.describe('Integrations Label Discovery', () => { + test.beforeEach(async ({ page }) => { + // Navigate to integrations page + await page.goto('/integrations'); + }); + + test('should load and display available labels in dropdowns', async ({ page }) => { + // Click "New Integration" button + await page.click('[data-testid="new-integration-btn"]'); + + // Wait for wizard to appear + await expect(page.locator('#link-wizard')).toBeVisible(); + + // Check that source label dropdown is populated + const sourceSelect = page.locator('#source-label-select'); + await expect(sourceSelect).toBeVisible(); + + // Get all options (excluding the placeholder) + const sourceOptions = await sourceSelect.locator('option:not([value=""])').count(); + expect(sourceOptions).toBeGreaterThan(0); + }); + + test('should display source indicators (icons) in dropdowns', async ({ page }) => { + // Create test labels with different sources via API + await page.request.post('/api/labels', { + data: { + name: 'TestManualLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + await page.request.post('/api/labels', { + data: { + name: 'TestSystemLabel', + properties: [], + relationships: [], + source_type: 'system' + } + }); + + await page.request.post('/api/labels', { + data: { + name: 'TestPluginLabel', + properties: [], + relationships: [], + source_type: 'plugin_instance', + source_id: 'test_instance_123' + } + }); + + // Reload page to fetch new labels + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Check source label dropdown contains icons + const sourceSelect = page.locator('#source-label-select'); + const sourceHtml = await sourceSelect.innerHTML(); + + // Verify icons are present (emojis) + expect(sourceHtml).toContain('✏️'); // Manual + expect(sourceHtml).toContain('🔧'); // System + expect(sourceHtml).toContain('📦'); // Plugin + + // Verify label names are present + expect(sourceHtml).toContain('TestManualLabel'); + expect(sourceHtml).toContain('TestSystemLabel'); + expect(sourceHtml).toContain('TestPluginLabel'); + }); + + test('should display node counts in dropdowns', async ({ page }) => { + // Create a test label + await page.request.post('/api/labels', { + data: { + name: 'TestLabelWithCount', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + // Reload page + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Check dropdown contains node count information + const sourceSelect = page.locator('#source-label-select'); + const sourceHtml = await sourceSelect.innerHTML(); + + // Should show either "(X nodes)" or "(empty)" + expect(sourceHtml).toMatch(/\((\d+\s+nodes|empty)\)/); + }); + + test('should display plugin instance names for plugin-sourced labels', async ({ page }) => { + // Create a plugin-sourced label + await page.request.post('/api/labels', { + data: { + name: 'PluginEquipment', + properties: [], + relationships: [], + source_type: 'plugin_instance', + source_id: 'ilab_equipment_001' + } + }); + + // Reload page + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Check dropdown shows plugin info + const sourceSelect = page.locator('#source-label-select'); + const sourceHtml = await sourceSelect.innerHTML(); + + // Should contain "Plugin:" indicator + expect(sourceHtml).toContain('Plugin:'); + expect(sourceHtml).toContain('PluginEquipment'); + }); + + test('should allow selecting labels with 0 nodes', async ({ page }) => { + // Create a label with no nodes + await page.request.post('/api/labels', { + data: { + name: 'EmptyLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + // Reload page + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Select the empty label as source + await page.selectOption('#source-label-select', 'EmptyLabel'); + + // Verify selection worked + const selectedValue = await page.locator('#source-label-select').inputValue(); + expect(selectedValue).toBe('EmptyLabel'); + + // Navigate to step 2 + await page.click('#btn-next'); + + // Navigate to step 3 + await page.click('#btn-next'); + + // Select the empty label as target + await page.selectOption('#target-label-select', 'EmptyLabel'); + + // Verify target selection worked + const targetValue = await page.locator('#target-label-select').inputValue(); + expect(targetValue).toBe('EmptyLabel'); + }); + + test('should populate both source and target dropdowns identically', async ({ page }) => { + // Create test labels + await page.request.post('/api/labels', { + data: { + name: 'LabelA', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + await page.request.post('/api/labels', { + data: { + name: 'LabelB', + properties: [], + relationships: [], + source_type: 'system' + } + }); + + // Reload page + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Get source dropdown options + const sourceSelect = page.locator('#source-label-select'); + const sourceOptions = await sourceSelect.locator('option:not([value=""])').allTextContents(); + + // Navigate to step 3 to see target dropdown + await page.click('#btn-next'); // to step 2 + await page.click('#btn-next'); // to step 3 + + // Get target dropdown options + const targetSelect = page.locator('#target-label-select'); + const targetOptions = await targetSelect.locator('option:not([value=""])').allTextContents(); + + // Both dropdowns should have the same options + expect(sourceOptions.length).toBe(targetOptions.length); + expect(sourceOptions).toEqual(targetOptions); + }); + + test('should handle API fetch errors gracefully', async ({ page }) => { + // Block the labels API endpoint + await page.route('/api/labels/list', route => route.abort()); + + // Reload page (will fail to fetch labels) + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Dropdown should still exist with just placeholder + const sourceSelect = page.locator('#source-label-select'); + await expect(sourceSelect).toBeVisible(); + + const options = await sourceSelect.locator('option').count(); + expect(options).toBe(1); // Only the placeholder option + }); + + test('should refresh labels when navigating away and back', async ({ page }) => { + // Create initial label + await page.request.post('/api/labels', { + data: { + name: 'InitialLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + // Reload page + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Verify InitialLabel is present + let sourceHtml = await page.locator('#source-label-select').innerHTML(); + expect(sourceHtml).toContain('InitialLabel'); + + // Navigate away to Files page + await page.goto('/files'); + + // Create another label while on different page + await page.request.post('/api/labels', { + data: { + name: 'NewLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + // Navigate back to Integrations + await page.goto('/integrations'); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Verify both labels are present (labels reloaded) + sourceHtml = await page.locator('#source-label-select').innerHTML(); + expect(sourceHtml).toContain('InitialLabel'); + expect(sourceHtml).toContain('NewLabel'); + }); + + test('should display correct source display text format', async ({ page }) => { + // Create labels with different sources + await page.request.post('/api/labels', { + data: { + name: 'ManualLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + await page.request.post('/api/labels', { + data: { + name: 'SystemLabel', + properties: [], + relationships: [], + source_type: 'system' + } + }); + + await page.request.post('/api/labels', { + data: { + name: 'PluginLabel', + properties: [], + relationships: [], + source_type: 'plugin_instance', + source_id: 'test_plugin' + } + }); + + // Reload page + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Check source display text + const sourceHtml = await page.locator('#source-label-select').innerHTML(); + + // Manual label should show " - Manual" + expect(sourceHtml).toContain('ManualLabel'); + expect(sourceHtml).toMatch(/ManualLabel.*Manual/); + + // System label should show " - System" + expect(sourceHtml).toContain('SystemLabel'); + expect(sourceHtml).toMatch(/SystemLabel.*System/); + + // Plugin label should show " - Plugin:" + expect(sourceHtml).toContain('PluginLabel'); + expect(sourceHtml).toMatch(/PluginLabel.*Plugin:/); + }); + + test('should include data attributes for source and count', async ({ page }) => { + // Create a test label + await page.request.post('/api/labels', { + data: { + name: 'DataAttributeTest', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + // Reload page + await page.reload(); + + // Click "New Integration" + await page.click('[data-testid="new-integration-btn"]'); + + // Find the option for our test label + const option = page.locator('#source-label-select option[value="DataAttributeTest"]'); + + // Verify data attributes exist + await expect(option).toHaveAttribute('data-source'); + await expect(option).toHaveAttribute('data-count'); + + // Verify data attribute values + const source = await option.getAttribute('data-source'); + const count = await option.getAttribute('data-count'); + + expect(source).toBe('manual'); + expect(count).toBeDefined(); + expect(parseInt(count)).toBeGreaterThanOrEqual(0); + }); +}); diff --git a/e2e/labels-source-badges.spec.ts b/e2e/labels-source-badges.spec.ts new file mode 100644 index 0000000..0d8b7ab --- /dev/null +++ b/e2e/labels-source-badges.spec.ts @@ -0,0 +1,332 @@ +import { test, expect } from '@playwright/test'; + +/** + * E2E Tests for Labels Page Source Badges + * + * Tests the display of source badges (plugin, manual, system) on the Labels page + * to indicate where each label originates from. + */ + +test.describe('Labels Source Badges', () => { + test.beforeEach(async ({ page }) => { + // Navigate to labels page + await page.goto('/labels'); + await page.waitForLoadState('networkidle'); + }); + + test('should display source badges for all labels', async ({ page }) => { + // Wait for labels to load + await page.waitForSelector('[data-testid="label-item"]', { timeout: 5000 }); + + // Count label items + const labelItems = page.locator('[data-testid="label-item"]'); + const labelCount = await labelItems.count(); + expect(labelCount).toBeGreaterThan(0); + + // Count source badges + const sourceBadges = page.locator('.source-badge'); + const badgeCount = await sourceBadges.count(); + + // Each label should have exactly one badge + expect(badgeCount).toBe(labelCount); + }); + + test('should display correct badge types with icons', async ({ page }) => { + // Create test labels with different source types + await page.request.post('/api/labels', { + data: { + name: 'TestManualLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + await page.request.post('/api/labels', { + data: { + name: 'TestSystemLabel', + properties: [], + relationships: [], + source_type: 'system' + } + }); + + await page.request.post('/api/labels', { + data: { + name: 'TestPluginLabel', + properties: [], + relationships: [], + source_type: 'plugin_instance', + source_id: 'test_plugin_instance' + } + }); + + // Reload page to see new labels + await page.reload(); + await page.waitForLoadState('networkidle'); + + // Check for badge types + const manualBadges = page.locator('.source-badge.manual'); + const systemBadges = page.locator('.source-badge.system'); + const pluginBadges = page.locator('.source-badge.plugin'); + + // Verify each type exists + await expect(manualBadges.first()).toBeVisible(); + await expect(systemBadges.first()).toBeVisible(); + await expect(pluginBadges.first()).toBeVisible(); + + // Check for emoji icons in the HTML + const pageContent = await page.content(); + expect(pageContent).toContain('✏️'); // Manual icon + expect(pageContent).toContain('🔧'); // System icon + expect(pageContent).toContain('📦'); // Plugin icon + }); + + test('should show plugin instance name in badge', async ({ page }) => { + // Create a plugin-sourced label + await page.request.post('/api/labels', { + data: { + name: 'PluginEquipmentLabel', + properties: [], + relationships: [], + source_type: 'plugin_instance', + source_id: 'ilab_equipment_2024' + } + }); + + // Reload page + await page.reload(); + await page.waitForLoadState('networkidle'); + + // Find the plugin badge + const pluginBadge = page.locator('.source-badge.plugin').filter({ hasText: 'Plugin:' }); + await expect(pluginBadge.first()).toBeVisible(); + + // Badge should contain "Plugin:" text + const badgeText = await pluginBadge.first().textContent(); + expect(badgeText).toContain('Plugin:'); + expect(badgeText).toContain('ilab_equipment_2024'); + }); + + test('should have hover tooltips with full source info', async ({ page }) => { + // Create a test label + await page.request.post('/api/labels', { + data: { + name: 'TestTooltipLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + // Reload page + await page.reload(); + await page.waitForLoadState('networkidle'); + + // Find a source badge + const sourceBadge = page.locator('.source-badge').first(); + await expect(sourceBadge).toBeVisible(); + + // Check for title attribute (tooltip) + const title = await sourceBadge.getAttribute('title'); + expect(title).toBeTruthy(); + expect(title.length).toBeGreaterThan(0); + + // Hover to trigger tooltip + await sourceBadge.hover(); + await page.waitForTimeout(200); + + // Title should contain descriptive text + expect(title).toMatch(/(Plugin Instance|Built-in System|Manually Created|Unknown Source)/); + }); + + test('should make plugin badges clickable', async ({ page }) => { + // Create a plugin-sourced label + await page.request.post('/api/labels', { + data: { + name: 'ClickablePluginLabel', + properties: [], + relationships: [], + source_type: 'plugin_instance', + source_id: 'test_instance_123' + } + }); + + // Reload page + await page.reload(); + await page.waitForLoadState('networkidle'); + + // Find the plugin badge + const pluginBadge = page.locator('.source-badge.plugin').first(); + const badgeCount = await pluginBadge.count(); + + if (badgeCount > 0) { + // Plugin badge should have cursor pointer style + const cursorStyle = await pluginBadge.evaluate(el => window.getComputedStyle(el).cursor); + expect(cursorStyle).toBe('pointer'); + + // Click the plugin badge + await pluginBadge.click(); + await page.waitForTimeout(500); + + // Should navigate to Settings > Plugins + expect(page.url()).toContain('/settings'); + } + }); + + test('should not make manual and system badges clickable', async ({ page }) => { + // Manual badges should not be clickable + const manualBadge = page.locator('.source-badge.manual').first(); + const manualCount = await manualBadge.count(); + + if (manualCount > 0) { + const onclick = await manualBadge.getAttribute('onclick'); + expect(onclick).toBeNull(); + } + + // System badges should not be clickable + const systemBadge = page.locator('.source-badge.system').first(); + const systemCount = await systemBadge.count(); + + if (systemCount > 0) { + const onclick = await systemBadge.getAttribute('onclick'); + expect(onclick).toBeNull(); + } + }); + + test('should have correct badge colors', async ({ page }) => { + // Create labels of each type + await page.request.post('/api/labels', { + data: { name: 'ColorTestManual', properties: [], relationships: [], source_type: 'manual' } + }); + await page.request.post('/api/labels', { + data: { name: 'ColorTestSystem', properties: [], relationships: [], source_type: 'system' } + }); + await page.request.post('/api/labels', { + data: { name: 'ColorTestPlugin', properties: [], relationships: [], source_type: 'plugin_instance', source_id: 'test' } + }); + + // Reload page + await page.reload(); + await page.waitForLoadState('networkidle'); + + // Check plugin badge color (blue) + const pluginBadge = page.locator('.source-badge.plugin').first(); + if (await pluginBadge.count() > 0) { + const bgColor = await pluginBadge.evaluate(el => window.getComputedStyle(el).backgroundColor); + // Should be some shade of blue (#e3f2fd) + expect(bgColor).toMatch(/rgb\(227, 242, 253\)/); // #e3f2fd in RGB + } + + // Check system badge color (green) + const systemBadge = page.locator('.source-badge.system').first(); + if (await systemBadge.count() > 0) { + const bgColor = await systemBadge.evaluate(el => window.getComputedStyle(el).backgroundColor); + // Should be some shade of green (#e8f5e9) + expect(bgColor).toMatch(/rgb\(232, 245, 233\)/); // #e8f5e9 in RGB + } + + // Check manual badge color (gray) + const manualBadge = page.locator('.source-badge.manual').first(); + if (await manualBadge.count() > 0) { + const bgColor = await manualBadge.evaluate(el => window.getComputedStyle(el).backgroundColor); + // Should be some shade of gray (#f5f5f5) + expect(bgColor).toMatch(/rgb\(245, 245, 245\)/); // #f5f5f5 in RGB + } + }); + + test('should display badges alongside label names', async ({ page }) => { + // Create a test label + await page.request.post('/api/labels', { + data: { + name: 'LayoutTestLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + // Reload page + await page.reload(); + await page.waitForLoadState('networkidle'); + + // Find the label item + const labelItem = page.locator('[data-testid="label-item"]').filter({ hasText: 'LayoutTestLabel' }); + await expect(labelItem).toBeVisible(); + + // Check that label-header div exists (contains both name and badge) + const labelHeader = labelItem.locator('.label-header'); + await expect(labelHeader).toBeVisible(); + + // Both the label name and badge should be in the header + await expect(labelHeader.locator('strong')).toHaveText('LayoutTestLabel'); + await expect(labelHeader.locator('.source-badge')).toBeVisible(); + }); + + test('should handle unknown source types gracefully', async ({ page }) => { + // Create a label with unknown source type (via direct API manipulation) + await page.request.post('/api/labels', { + data: { + name: 'UnknownSourceLabel', + properties: [], + relationships: [], + source_type: 'unknown_type' + } + }); + + // Reload page + await page.reload(); + await page.waitForLoadState('networkidle'); + + // Should still display a badge (unknown type) + const unknownBadge = page.locator('.source-badge.unknown'); + const unknownCount = await unknownBadge.count(); + + if (unknownCount > 0) { + await expect(unknownBadge.first()).toBeVisible(); + // Should have question mark icon + const badgeText = await unknownBadge.first().textContent(); + expect(badgeText).toContain('❓'); + } + }); + + test('should update badges when label source changes', async ({ page }) => { + // Create a manual label + await page.request.post('/api/labels', { + data: { + name: 'ChangingSourceLabel', + properties: [], + relationships: [], + source_type: 'manual' + } + }); + + // Reload and verify manual badge + await page.reload(); + await page.waitForLoadState('networkidle'); + + let badge = page.locator('[data-testid="label-item"]') + .filter({ hasText: 'ChangingSourceLabel' }) + .locator('.source-badge'); + await expect(badge).toHaveClass(/manual/); + + // Update label to system source + await page.request.post('/api/labels', { + data: { + name: 'ChangingSourceLabel', + properties: [], + relationships: [], + source_type: 'system' + } + }); + + // Reload and verify system badge + await page.reload(); + await page.waitForLoadState('networkidle'); + + badge = page.locator('[data-testid="label-item"]') + .filter({ hasText: 'ChangingSourceLabel' }) + .locator('.source-badge'); + await expect(badge).toHaveClass(/system/); + }); +}); diff --git a/e2e/logs-viewer.spec.ts b/e2e/logs-viewer.spec.ts new file mode 100644 index 0000000..19ed5a1 --- /dev/null +++ b/e2e/logs-viewer.spec.ts @@ -0,0 +1,311 @@ +import { test, expect } from '@playwright/test'; + +/** + * E2E tests for Live Logs Viewer. + * Tests logs page loads, filters work, export functionality. + */ + +test('logs section loads and displays log viewer', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + // Navigate to Settings page + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(200); + + // Verify Logs section is visible + const logsSection = page.locator('#logs-section'); + await expect(logsSection).toBeVisible(); + await expect(logsSection.locator('h1')).toHaveText('System Logs'); + + // Verify logs container exists + const logsContainer = page.locator('#logs-container'); + await expect(logsContainer).toBeVisible(); +}); + +test('logs viewer has all filter controls', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(200); + + // Check filter controls + const levelFilter = page.locator('#logs-level-filter'); + const sourceFilter = page.locator('#logs-source-filter'); + const searchInput = page.locator('#logs-search'); + + await expect(levelFilter).toBeVisible(); + await expect(sourceFilter).toBeVisible(); + await expect(searchInput).toBeVisible(); + + // Check buttons + const refreshButton = page.locator('#btn-logs-refresh'); + const pauseButton = page.locator('#btn-logs-pause'); + const exportButton = page.locator('#btn-logs-export'); + const clearFiltersButton = page.locator('#btn-logs-clear-filters'); + + await expect(refreshButton).toBeVisible(); + await expect(pauseButton).toBeVisible(); + await expect(exportButton).toBeVisible(); + await expect(clearFiltersButton).toBeVisible(); + + await expect(refreshButton).toHaveText('Refresh'); + await expect(pauseButton).toHaveText('Pause'); + await expect(exportButton).toHaveText('Export'); + await expect(clearFiltersButton).toHaveText('Clear Filters'); +}); + +test('logs are displayed in the container', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(500); + + // Wait for logs to load + await page.waitForTimeout(1000); + + const logsContainer = page.locator('#logs-container'); + + // Check if logs loaded or if "No log entries" message is shown + const content = await logsContainer.textContent(); + + // Either logs are present or "No log entries found" message + const hasLogs = content && ( + content.includes('[INFO]') || + content.includes('[WARNING]') || + content.includes('[ERROR]') || + content.includes('No log entries found') || + content.includes('Loading logs') + ); + + expect(hasLogs).toBeTruthy(); +}); + +test('level filter works', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(500); + + // Wait for initial logs to load + await page.waitForTimeout(1000); + + // Select ERROR level filter + const levelFilter = page.locator('#logs-level-filter'); + await levelFilter.selectOption('ERROR'); + + // Wait for filtered logs to load + await page.waitForTimeout(1000); + + const logsContainer = page.locator('#logs-container'); + const content = await logsContainer.textContent(); + + // If there are ERROR logs, verify only ERROR level is shown + if (content && content.includes('[ERROR]')) { + // Should not contain INFO or WARNING logs + expect(content.includes('[ERROR]')).toBeTruthy(); + } else { + // If no ERROR logs, should show "No log entries found" + expect(content?.includes('No log entries found')).toBeTruthy(); + } +}); + +test('source filter works', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(500); + + // Wait for initial logs to load + await page.waitForTimeout(1000); + + // Enter source filter + const sourceFilter = page.locator('#logs-source-filter'); + await sourceFilter.fill('scanner'); + + // Wait for debounce and filtered logs to load + await page.waitForTimeout(1500); + + const logsContainer = page.locator('#logs-container'); + const content = await logsContainer.textContent(); + + // Verify response (either matching logs or "No log entries found") + expect(content).toBeTruthy(); +}); + +test('search filter works', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(500); + + // Wait for initial logs to load + await page.waitForTimeout(1000); + + // Enter search query + const searchInput = page.locator('#logs-search'); + await searchInput.fill('logging'); + + // Wait for debounce and filtered logs to load + await page.waitForTimeout(1500); + + const logsContainer = page.locator('#logs-container'); + const content = await logsContainer.textContent(); + + // Verify response (either matching logs or "No log entries found") + expect(content).toBeTruthy(); +}); + +test('pause button toggles auto-refresh', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(500); + + const pauseButton = page.locator('#btn-logs-pause'); + const refreshStatus = page.locator('#logs-refresh-status'); + + // Initially should be active + await expect(refreshStatus).toHaveText('Active'); + await expect(pauseButton).toHaveText('Pause'); + + // Click pause + await pauseButton.click(); + await page.waitForTimeout(200); + + // Should be paused + await expect(refreshStatus).toHaveText('Paused'); + await expect(pauseButton).toHaveText('Resume'); + + // Click resume + await pauseButton.click(); + await page.waitForTimeout(200); + + // Should be active again + await expect(refreshStatus).toHaveText('Active'); + await expect(pauseButton).toHaveText('Pause'); +}); + +test('clear filters button resets all filters', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(500); + + // Set filters + const levelFilter = page.locator('#logs-level-filter'); + const sourceFilter = page.locator('#logs-source-filter'); + const searchInput = page.locator('#logs-search'); + + await levelFilter.selectOption('ERROR'); + await sourceFilter.fill('scanner'); + await searchInput.fill('test'); + + await page.waitForTimeout(500); + + // Click clear filters + const clearFiltersButton = page.locator('#btn-logs-clear-filters'); + await clearFiltersButton.click(); + + await page.waitForTimeout(500); + + // Verify all filters are cleared + await expect(levelFilter).toHaveValue(''); + await expect(sourceFilter).toHaveValue(''); + await expect(searchInput).toHaveValue(''); +}); + +test('refresh button manually reloads logs', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(500); + + // Wait for initial logs + await page.waitForTimeout(1000); + + // Click refresh button + const refreshButton = page.locator('#btn-logs-refresh'); + await refreshButton.click(); + + // Wait for refresh to complete + await page.waitForTimeout(1000); + + // Verify logs container is still visible and populated + const logsContainer = page.locator('#logs-container'); + await expect(logsContainer).toBeVisible(); + + const content = await logsContainer.textContent(); + expect(content).toBeTruthy(); +}); + +test('export button initiates log download', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Logs section + await page.locator('.settings-sidebar-item[data-section="logs"]').click(); + await page.waitForTimeout(500); + + // Set up download handler + const downloadPromise = page.waitForEvent('download', { timeout: 5000 }).catch(() => null); + + // Click export button + const exportButton = page.locator('#btn-logs-export'); + await exportButton.click(); + + // Wait for download (or timeout) + const download = await downloadPromise; + + // If download occurred, verify filename + if (download) { + const fileName = download.suggestedFilename(); + expect(fileName).toMatch(/scidk_logs_\d{8}_\d{6}\.log/); + } + // If no download, it might mean no logs exist, which is acceptable +}); + +test('logs page accessible via direct URL', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + // Navigate directly to logs section via hash + await page.goto(`${base}/#logs`); + await page.waitForLoadState('networkidle'); + await page.waitForTimeout(500); + + // Verify Logs section is visible and active + const logsSection = page.locator('#logs-section'); + await expect(logsSection).toBeVisible(); + + // Verify sidebar item is active + const logsSidebarItem = page.locator('.settings-sidebar-item[data-section="logs"]'); + await expect(logsSidebarItem).toHaveClass(/active/); +}); diff --git a/e2e/plugin-graph-integration.spec.ts b/e2e/plugin-graph-integration.spec.ts new file mode 100644 index 0000000..24f5bfc --- /dev/null +++ b/e2e/plugin-graph-integration.spec.ts @@ -0,0 +1,395 @@ +import { test, expect } from '@playwright/test'; + +/** + * E2E tests for Plugin Graph Integration Wizard step. + * Tests the optional graph integration step that appears for data_import plugins. + */ + +test('graph integration step appears for data_import plugins', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Select a data_import template (e.g., table_loader) + const tableLoaderCard = page.locator('.template-card').filter({ hasText: /table.*loader/i }).first(); + if (await tableLoaderCard.isVisible()) { + await tableLoaderCard.click(); + await page.waitForTimeout(200); + + // Click Next + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Fill in required config (Step 2) + await page.locator('#instance-name').fill('Test Graph Integration Instance'); + + // Check if there are other required fields + const fileInput = page.locator('input[type="file"]').first(); + if (await fileInput.isVisible()) { + // For testing, we can skip file upload as it's optional for testing + // Just make sure the form is filled enough to proceed + } + + // Click Next to go to Step 3 (Graph Integration) + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Check that Step 3 (Graph Integration) is visible + const graphStep = page.locator('#wizard-step-3'); + await expect(graphStep).toBeVisible(); + await expect(graphStep.locator('h3')).toContainText('Graph Integration'); + + // Check for graph enable checkbox + const graphEnableCheckbox = page.locator('#graph-enable'); + await expect(graphEnableCheckbox).toBeVisible(); + } +}); + +test('graph integration fields are hidden by default', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Select a data_import template + const tableLoaderCard = page.locator('.template-card').filter({ hasText: /table.*loader/i }).first(); + if (await tableLoaderCard.isVisible()) { + await tableLoaderCard.click(); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Fill minimal config + await page.locator('#instance-name').fill('Test Instance'); + + // Go to graph integration step + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Graph config fields should be hidden initially + const graphConfigFields = page.locator('#graph-config-fields'); + await expect(graphConfigFields).not.toBeVisible(); + } +}); + +test('graph integration fields appear when checkbox is enabled', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Select a data_import template + const tableLoaderCard = page.locator('.template-card').filter({ hasText: /table.*loader/i }).first(); + if (await tableLoaderCard.isVisible()) { + await tableLoaderCard.click(); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Fill config with table name + await page.locator('#instance-name').fill('Equipment Data'); + const tableNameInput = page.locator('input[name="table_name"]'); + if (await tableNameInput.isVisible()) { + await tableNameInput.fill('lab_equipment'); + } + + // Go to graph integration step + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Enable graph integration + await page.locator('#graph-enable').check(); + await page.waitForTimeout(200); + + // Fields should now be visible + const graphConfigFields = page.locator('#graph-config-fields'); + await expect(graphConfigFields).toBeVisible(); + + // Check for required fields + await expect(page.locator('#graph-label-name')).toBeVisible(); + await expect(page.locator('#graph-primary-key')).toBeVisible(); + await expect(page.locator('input[name="sync-strategy"]').first()).toBeVisible(); + } +}); + +test('label name is auto-generated from table name', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Select a data_import template + const tableLoaderCard = page.locator('.template-card').filter({ hasText: /table.*loader/i }).first(); + if (await tableLoaderCard.isVisible()) { + await tableLoaderCard.click(); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Fill config with a specific table name + await page.locator('#instance-name').fill('Equipment Data'); + const tableNameInput = page.locator('input[name="table_name"]'); + if (await tableNameInput.isVisible()) { + await tableNameInput.fill('lab_equipment_2024'); + } + + // Go to graph integration step + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Check that label name is auto-generated (e.g., "LabEquipment2024") + const labelNameInput = page.locator('#graph-label-name'); + const labelValue = await labelNameInput.inputValue(); + + // Should be in CamelCase format + expect(labelValue).toMatch(/^[A-Z][a-zA-Z0-9]*$/); + expect(labelValue).toBeTruthy(); + } +}); + +test('wizard validates graph config when enabled', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Select a data_import template + const tableLoaderCard = page.locator('.template-card').filter({ hasText: /table.*loader/i }).first(); + if (await tableLoaderCard.isVisible()) { + await tableLoaderCard.click(); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Fill minimal config + await page.locator('#instance-name').fill('Test Instance'); + + // Go to graph integration step + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Enable graph integration + await page.locator('#graph-enable').check(); + await page.waitForTimeout(200); + + // Clear label name to test validation + await page.locator('#graph-label-name').fill(''); + + // Try to proceed to next step - should fail validation + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Should still be on step 3 + await expect(page.locator('#wizard-step-3')).toBeVisible(); + } +}); + +test('full wizard flow with graph integration enabled', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Step 1: Select template + const tableLoaderCard = page.locator('.template-card').filter({ hasText: /table.*loader/i }).first(); + if (await tableLoaderCard.isVisible()) { + await tableLoaderCard.click(); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Step 2: Configure instance + await page.locator('#instance-name').fill('E2E Test Equipment Instance'); + const tableNameInput = page.locator('input[name="table_name"]'); + if (await tableNameInput.isVisible()) { + await tableNameInput.fill('test_equipment'); + } + + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Step 3: Graph Integration + await page.locator('#graph-enable').check(); + await page.waitForTimeout(200); + + // Verify label name is auto-filled + const labelName = await page.locator('#graph-label-name').inputValue(); + expect(labelName).toBeTruthy(); + + // Select primary key + await page.locator('#graph-primary-key').selectOption('id'); + + // Select sync strategy + await page.locator('input[name="sync-strategy"][value="on_demand"]').check(); + + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Step 4: Preview & Confirm + const step4 = page.locator('#wizard-step-4'); + await expect(step4).toBeVisible(); + await expect(step4.locator('h3')).toContainText('Preview'); + + // Check that Create Instance button is visible + await expect(page.locator('#wizard-create-btn')).toBeVisible(); + + // Note: We don't actually create the instance in E2E tests to avoid side effects + // In a real test environment with proper cleanup, you would: + // await page.locator('#wizard-create-btn').click(); + // await page.waitForTimeout(1000); + // await expect(page.locator('#plugin-instances-list')).toContainText('E2E Test Equipment Instance'); + } +}); + +test('wizard skips graph step for non-data_import plugins', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Try to find a non-data_import template (e.g., exporter category) + // If all templates are data_import, this test will be skipped + const allTemplateCards = page.locator('.template-card'); + const count = await allTemplateCards.count(); + + for (let i = 0; i < count; i++) { + const card = allTemplateCards.nth(i); + const text = await card.textContent(); + + // Try to identify non-data_import templates by description + if (text && !text.toLowerCase().includes('import') && !text.toLowerCase().includes('loader')) { + await card.click(); + await page.waitForTimeout(200); + + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Fill minimal config + await page.locator('#instance-name').fill('Test Non-Import Instance'); + + // Click Next - should skip to Step 4 (preview), not Step 3 (graph) + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Should see Step 4 (Preview), not Step 3 (Graph Integration) + const visibleStep = await page.locator('.wizard-step[style*="display: block"]'); + const stepText = await visibleStep.textContent(); + + expect(stepText).toContain('Preview'); + expect(stepText).not.toContain('Graph Integration'); + + break; + } + } +}); + +test('previous button works correctly with graph step', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Select data_import template + const tableLoaderCard = page.locator('.template-card').filter({ hasText: /table.*loader/i }).first(); + if (await tableLoaderCard.isVisible()) { + await tableLoaderCard.click(); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Fill config + await page.locator('#instance-name').fill('Test Instance'); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Now on Step 3 (Graph Integration) + await expect(page.locator('#wizard-step-3')).toBeVisible(); + + // Click Previous + await page.locator('#wizard-prev-btn').click(); + await page.waitForTimeout(300); + + // Should be back on Step 2 + await expect(page.locator('#wizard-step-2')).toBeVisible(); + + // Go forward again + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Should be on Step 3 again + await expect(page.locator('#wizard-step-3')).toBeVisible(); + + // Now go to Step 4 + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(500); + + // Should be on Step 4 (Preview) + await expect(page.locator('#wizard-step-4')).toBeVisible(); + + // Click Previous + await page.locator('#wizard-prev-btn').click(); + await page.waitForTimeout(300); + + // Should be back on Step 3 (Graph Integration) + await expect(page.locator('#wizard-step-3')).toBeVisible(); + } +}); diff --git a/e2e/plugin-instances.spec.ts b/e2e/plugin-instances.spec.ts new file mode 100644 index 0000000..f3b614e --- /dev/null +++ b/e2e/plugin-instances.spec.ts @@ -0,0 +1,387 @@ +import { test, expect } from '@playwright/test'; + +/** + * E2E tests for Plugin Instances management in Settings > Plugins. + * Tests creating, configuring, syncing, and deleting plugin instances. + */ + +test('plugin instances section loads correctly', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Check that Plugin Instances section is visible + const pluginInstancesSection = page.locator('#plugin-instances-list'); + await expect(pluginInstancesSection).toBeVisible(); + + // Check for "New Plugin Instance" button + const newInstanceBtn = page.locator('#btn-new-plugin-instance'); + await expect(newInstanceBtn).toBeVisible(); +}); + +test('new plugin instance wizard opens and displays templates', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Click "New Plugin Instance" button + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Check that wizard modal is visible + const wizardModal = page.locator('#plugin-instance-wizard-modal'); + await expect(wizardModal).toBeVisible(); + + // Check that Step 1 (template selection) is visible + const step1 = page.locator('#wizard-step-1'); + await expect(step1).toBeVisible(); + await expect(step1.locator('h3')).toContainText('Step 1'); + + // Check for template list container + const templateList = page.locator('#template-list'); + await expect(templateList).toBeVisible(); +}); + +test('wizard navigation works correctly', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + // Check that Next button is visible, but Previous is not (on step 1) + await expect(page.locator('#wizard-next-btn')).toBeVisible(); + await expect(page.locator('#wizard-prev-btn')).not.toBeVisible(); + await expect(page.locator('#wizard-create-btn')).not.toBeVisible(); + + // Try to click Next without selecting a template - should show error + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(200); + + // Should still be on step 1 (validation failed) + await expect(page.locator('#wizard-step-1')).toBeVisible(); +}); + +test('wizard can be cancelled', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(300); + + const wizardModal = page.locator('#plugin-instance-wizard-modal'); + await expect(wizardModal).toBeVisible(); + + // Click Cancel button + await page.locator('.modal-footer button.btn-secondary').last().click(); + await page.waitForTimeout(200); + + // Modal should be hidden + await expect(wizardModal).not.toBeVisible(); +}); + +test('plugin instance cards display correctly', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Wait for instances to load + await page.waitForTimeout(1000); + + const instancesList = page.locator('#plugin-instances-list'); + const instanceCards = instancesList.locator('.plugin-instance-card'); + + // Check if any instances exist + const count = await instanceCards.count(); + + if (count > 0) { + // If instances exist, check that first card has expected structure + const firstCard = instanceCards.first(); + await expect(firstCard.locator('.instance-header h4')).toBeVisible(); + await expect(firstCard.locator('.badge')).toBeVisible(); + await expect(firstCard.locator('.instance-meta')).toBeVisible(); + await expect(firstCard.locator('.instance-actions')).toBeVisible(); + + // Check for action buttons + await expect(firstCard.locator('button').filter({ hasText: 'Configure' })).toBeVisible(); + await expect(firstCard.locator('button').filter({ hasText: 'Sync Now' })).toBeVisible(); + await expect(firstCard.locator('button').filter({ hasText: /Enable|Disable/ })).toBeVisible(); + await expect(firstCard.locator('button').filter({ hasText: 'Delete' })).toBeVisible(); + } else { + // If no instances, should show empty state message + await expect(instancesList).toContainText('No plugin instances configured'); + } +}); + +test('instance action buttons are interactive', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Wait for instances to load + await page.waitForTimeout(1000); + + const instancesList = page.locator('#plugin-instances-list'); + const instanceCards = instancesList.locator('.plugin-instance-card'); + const count = await instanceCards.count(); + + if (count > 0) { + const firstCard = instanceCards.first(); + + // Test Configure button + const configureBtn = firstCard.locator('button').filter({ hasText: 'Configure' }); + await expect(configureBtn).toBeEnabled(); + + // Click Configure and verify alert/modal appears + page.once('dialog', dialog => { + expect(dialog.message()).toContain('Edit modal'); + dialog.accept(); + }); + await configureBtn.click(); + await page.waitForTimeout(200); + + // Test Sync Now button (with confirmation) + const syncBtn = firstCard.locator('button').filter({ hasText: 'Sync Now' }); + const isSyncDisabled = await syncBtn.isDisabled(); + + if (!isSyncDisabled) { + page.once('dialog', dialog => { + expect(dialog.message()).toContain('Sync this plugin instance'); + dialog.dismiss(); // Cancel the sync + }); + await syncBtn.click(); + await page.waitForTimeout(200); + } + + // Test Delete button (with confirmation) + const deleteBtn = firstCard.locator('button').filter({ hasText: 'Delete' }); + page.once('dialog', dialog => { + expect(dialog.message()).toContain('delete this plugin instance'); + dialog.dismiss(); // Cancel the deletion + }); + await deleteBtn.click(); + await page.waitForTimeout(200); + } +}); + +test('wizard step 2 shows configuration form', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + // This test requires that at least one template exists + // We'll mock the API response for template list + await page.route('**/api/plugins/templates', route => { + route.fulfill({ + status: 200, + contentType: 'application/json', + body: JSON.stringify({ + status: 'success', + templates: [ + { + id: 'test_template', + name: 'Test Template', + description: 'A test template for E2E testing', + config_schema: { + table_name: { + type: 'text', + label: 'Table Name', + required: true, + placeholder: 'e.g., test_table' + } + } + } + ] + }) + }); + }); + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(500); + + // Select first template + const firstTemplate = page.locator('.template-card').first(); + await firstTemplate.click(); + await page.waitForTimeout(200); + + // Check that template is selected + await expect(firstTemplate).toHaveClass(/selected/); + + // Click Next + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Should now be on Step 2 + const step2 = page.locator('#wizard-step-2'); + await expect(step2).toBeVisible(); + await expect(step2.locator('h3')).toContainText('Step 2'); + + // Check that instance name field is present + const instanceNameInput = page.locator('#instance-name'); + await expect(instanceNameInput).toBeVisible(); + await expect(instanceNameInput).toHaveAttribute('required'); + + // Check that dynamic config fields are present (based on mocked template) + const tableNameInput = page.locator('#config-table_name'); + await expect(tableNameInput).toBeVisible(); + + // Check that Previous button is now visible + await expect(page.locator('#wizard-prev-btn')).toBeVisible(); + await expect(page.locator('#wizard-next-btn')).toBeVisible(); +}); + +test('wizard validates required fields on step 2', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + // Mock template API + await page.route('**/api/plugins/templates', route => { + route.fulfill({ + status: 200, + contentType: 'application/json', + body: JSON.stringify({ + status: 'success', + templates: [ + { + id: 'test_template', + name: 'Test Template', + description: 'A test template', + config_schema: {} + } + ] + }) + }); + }); + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(500); + + // Select template and go to step 2 + await page.locator('.template-card').first().click(); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Try to proceed without filling instance name (required field) + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Should still be on step 2 (validation failed) + await expect(page.locator('#wizard-step-2')).toBeVisible(); + + // Fill in instance name + await page.locator('#instance-name').fill('Test Instance'); + + // Now click Next should work + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Should now be on Step 3 + await expect(page.locator('#wizard-step-3')).toBeVisible(); +}); + +test('wizard step 3 shows configuration summary', async ({ page, baseURL }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + + // Mock template API + await page.route('**/api/plugins/templates', route => { + route.fulfill({ + status: 200, + contentType: 'application/json', + body: JSON.stringify({ + status: 'success', + templates: [ + { + id: 'test_template', + name: 'Test Template', + description: 'A test template', + config_schema: {} + } + ] + }) + }); + }); + + await page.goto(`${base}/`); + await page.waitForLoadState('networkidle'); + + // Navigate to Plugins section + await page.locator('.settings-sidebar-item[data-section="plugins"]').click(); + await page.waitForTimeout(500); + + // Open wizard and navigate to step 3 + await page.locator('#btn-new-plugin-instance').click(); + await page.waitForTimeout(500); + + await page.locator('.template-card').first().click(); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + await page.locator('#instance-name').fill('Test Instance'); + await page.locator('#wizard-next-btn').click(); + await page.waitForTimeout(300); + + // Should be on Step 3 + const step3 = page.locator('#wizard-step-3'); + await expect(step3).toBeVisible(); + await expect(step3.locator('h3')).toContainText('Step 3'); + + // Check for configuration summary + const configSummary = page.locator('.config-summary'); + await expect(configSummary).toBeVisible(); + + const summaryDetails = page.locator('#config-summary-details'); + await expect(summaryDetails).toBeVisible(); + await expect(summaryDetails).toContainText('Test Template'); + await expect(summaryDetails).toContainText('Test Instance'); + + // Check that Create Instance button is visible + await expect(page.locator('#wizard-create-btn')).toBeVisible(); + await expect(page.locator('#wizard-next-btn')).not.toBeVisible(); +}); diff --git a/e2e/progress-indicators.spec.ts b/e2e/progress-indicators.spec.ts new file mode 100644 index 0000000..a29e1af --- /dev/null +++ b/e2e/progress-indicators.spec.ts @@ -0,0 +1,222 @@ +import { test, expect, request } from '@playwright/test'; +import os from 'os'; +import fs from 'fs'; +import path from 'path'; + +/** + * E2E tests for progress indicators feature: + * - Progress bars visible during scan/commit operations + * - Real-time status updates + * - Estimated time remaining displayed + * - UI remains responsive during long operations + * - Cancel button functionality + */ + +function makeTempDirWithFiles(fileCount: number, prefix = 'scidk-progress-'): string { + const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix)); + // Create multiple files to allow progress tracking + for (let i = 0; i < fileCount; i++) { + fs.writeFileSync(path.join(dir, `file_${i}.txt`), `content ${i}\n`); + } + return dir; +} + +test('progress bar visible during background scan', async ({ page, baseURL, request: pageRequest }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + const tempDir = makeTempDirWithFiles(20); + + // Navigate to Files page first + await page.goto(`${base}/datasets`); + await page.waitForLoadState('domcontentloaded'); + + // Start a background scan via API + const api = pageRequest || (await request.newContext()); + const resp = await api.post(`${base}/api/tasks`, { + headers: { 'Content-Type': 'application/json' }, + data: { type: 'scan', path: tempDir, recursive: true }, + }); + expect(resp.status()).toBe(202); // Background task accepted + + const taskData = await resp.json(); + expect(taskData.task_id).toBeDefined(); + + // Wait for task list to appear and show progress + const tasksList = page.locator('#tasks-list'); + await expect(tasksList).toBeVisible({ timeout: 5000 }); + + // Check for progress bar (styled div with background color) + const progressBar = tasksList.locator('div[style*="background"]').first(); + await expect(progressBar).toBeVisible({ timeout: 3000 }); + + // Verify progress text is shown (e.g., "scan running — /path — 10/20 (50%)") + const taskText = await tasksList.textContent(); + expect(taskText).toContain('scan'); + expect(taskText).toContain(tempDir); + // Should show processed/total format + expect(taskText).toMatch(/\d+\/\d+/); +}); + +test('status messages displayed during scan', async ({ page, baseURL, request: pageRequest }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + const tempDir = makeTempDirWithFiles(15); + + await page.goto(`${base}/datasets`); + await page.waitForLoadState('domcontentloaded'); + + // Start background scan + const api = pageRequest || (await request.newContext()); + await api.post(`${base}/api/tasks`, { + headers: { 'Content-Type': 'application/json' }, + data: { type: 'scan', path: tempDir, recursive: true }, + }); + + // Wait for tasks list to show content + const tasksList = page.locator('#tasks-list'); + await expect(tasksList).toBeVisible({ timeout: 5000 }); + + // Poll and check for status messages + let foundStatusMessage = false; + for (let i = 0; i < 20; i++) { + const text = await tasksList.textContent(); + // Check for status message indicators like "Processing", "files", "Counting" + if (text && (text.includes('Processing') || text.includes('files') || text.includes('Counting'))) { + foundStatusMessage = true; + break; + } + await page.waitForTimeout(200); + } + + expect(foundStatusMessage).toBeTruthy(); +}); + +test('ETA displayed for running tasks', async ({ page, baseURL, request: pageRequest }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + // Create more files to ensure task runs long enough to show ETA + const tempDir = makeTempDirWithFiles(30); + + await page.goto(`${base}/datasets`); + await page.waitForLoadState('domcontentloaded'); + + // Start background scan + const api = pageRequest || (await request.newContext()); + await api.post(`${base}/api/tasks`, { + headers: { 'Content-Type': 'application/json' }, + data: { type: 'scan', path: tempDir, recursive: true }, + }); + + const tasksList = page.locator('#tasks-list'); + await expect(tasksList).toBeVisible({ timeout: 5000 }); + + // Poll and check for ETA indicators like "~5s remaining", "~1m remaining" + let foundETA = false; + for (let i = 0; i < 20; i++) { + const text = await tasksList.textContent(); + // ETA format: "~5s remaining", "~2m remaining", etc. + if (text && text.match(/~\d+[smh]\s+remaining/)) { + foundETA = true; + break; + } + await page.waitForTimeout(200); + } + + // Note: ETA might not always appear for very fast scans, so we don't fail the test + // but we log whether it was found + console.log(`ETA display ${foundETA ? 'found' : 'not found (scan may have been too fast)'}`); +}); + +test('cancel button visible and functional for running tasks', async ({ page, baseURL, request: pageRequest }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + const tempDir = makeTempDirWithFiles(50); // More files to ensure task runs long enough + + await page.goto(`${base}/datasets`); + await page.waitForLoadState('domcontentloaded'); + + // Start background scan + const api = pageRequest || (await request.newContext()); + const resp = await api.post(`${base}/api/tasks`, { + headers: { 'Content-Type': 'application/json' }, + data: { type: 'scan', path: tempDir, recursive: true }, + }); + const taskData = await resp.json(); + const taskId = taskData.task_id; + + // Wait for cancel button to appear + const tasksList = page.locator('#tasks-list'); + await expect(tasksList).toBeVisible({ timeout: 5000 }); + + const cancelBtn = page.locator(`button[data-cancel="${taskId}"]`); + await expect(cancelBtn).toBeVisible({ timeout: 3000 }); + + // Click cancel button + await cancelBtn.click(); + + // Wait a moment and check task status changed + await page.waitForTimeout(1000); + + // Verify task shows as canceled or is no longer running + const text = await tasksList.textContent(); + // Should either say "canceled" or the task should complete/disappear + const hasStatus = text && (text.includes('canceled') || text.includes('completed') || text.includes('error')); + expect(hasStatus).toBeTruthy(); +}); + +test('progress reaches 100% on task completion', async ({ page, baseURL, request: pageRequest }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + const tempDir = makeTempDirWithFiles(5); // Small number for quick completion + + await page.goto(`${base}/datasets`); + await page.waitForLoadState('domcontentloaded'); + + // Start background scan + const api = pageRequest || (await request.newContext()); + await api.post(`${base}/api/tasks`, { + headers: { 'Content-Type': 'application/json' }, + data: { type: 'scan', path: tempDir, recursive: true }, + }); + + const tasksList = page.locator('#tasks-list'); + await expect(tasksList).toBeVisible({ timeout: 5000 }); + + // Poll until task completes + let taskCompleted = false; + for (let i = 0; i < 50; i++) { + const text = await tasksList.textContent(); + if (text && (text.includes('completed') || text.includes('100%'))) { + taskCompleted = true; + break; + } + await page.waitForTimeout(200); + } + + expect(taskCompleted).toBeTruthy(); + + // Verify progress bar shows completion color (green) + const progressBar = tasksList.locator('div[style*="#4caf50"]').first(); + await expect(progressBar).toBeVisible({ timeout: 2000 }); +}); + +test('UI remains responsive during long operation', async ({ page, baseURL, request: pageRequest }) => { + const base = baseURL || process.env.BASE_URL || 'http://127.0.0.1:5000'; + const tempDir = makeTempDirWithFiles(30); + + await page.goto(`${base}/datasets`); + await page.waitForLoadState('domcontentloaded'); + + // Start background scan + const api = pageRequest || (await request.newContext()); + await api.post(`${base}/api/tasks`, { + headers: { 'Content-Type': 'application/json' }, + data: { type: 'scan', path: tempDir, recursive: true }, + }); + + // Verify page is still interactive by clicking a button + const refreshBtn = page.locator('#refresh-scans'); + await expect(refreshBtn).toBeVisible({ timeout: 5000 }); + await expect(refreshBtn).toBeEnabled(); + await refreshBtn.click(); + + // Page should not freeze - verify we can still interact + const providerSelect = page.locator('#prov-select'); + await expect(providerSelect).toBeVisible(); + await expect(providerSelect).toBeEnabled(); +}); diff --git a/plugins/example_ilab/__init__.py b/plugins/example_ilab/__init__.py new file mode 100644 index 0000000..7d771e8 --- /dev/null +++ b/plugins/example_ilab/__init__.py @@ -0,0 +1,51 @@ +"""Example iLab plugin demonstrating label endpoint registration. + +This plugin shows how to register API endpoints that map to Label types +in the SciDK integration system. +""" + + +def register_plugin(app): + """Register the iLab plugin with the Flask app. + + This function is called during app initialization when the plugin is loaded. + It registers label endpoints that will appear in Settings > Integrations. + + Args: + app: Flask application instance + + Returns: + dict: Plugin metadata + """ + # Get the label endpoint registry from app extensions + registry = app.extensions['scidk']['label_endpoints'] + + # Register iLab Services endpoint + registry.register({ + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab/services', + 'label_type': 'iLabService', + 'auth_required': True, + 'test_url': '/api/integrations/ilab/test', + 'plugin': 'example_ilab', + 'description': 'Integration with iLab service management system for lab services' + }) + + # Register iLab Equipment endpoint + registry.register({ + 'name': 'iLab Equipment', + 'endpoint': '/api/integrations/ilab/equipment', + 'label_type': 'Equipment', + 'auth_required': True, + 'test_url': '/api/integrations/ilab/test', + 'plugin': 'example_ilab', + 'description': 'Integration with iLab equipment inventory' + }) + + # Return plugin metadata + return { + 'name': 'iLab Integration (Example)', + 'version': '1.0.0', + 'author': 'SciDK Team', + 'description': 'Example plugin demonstrating label endpoint registration for iLab services' + } diff --git a/plugins/example_plugin/README.md b/plugins/example_plugin/README.md new file mode 100644 index 0000000..b6b12ba --- /dev/null +++ b/plugins/example_plugin/README.md @@ -0,0 +1,86 @@ +# Example Plugin + +A simple demonstration plugin for SciDK that shows how to create and register plugins. + +## Features + +- Example API endpoints +- Blueprint registration +- Plugin metadata + +## API Endpoints + +### GET /api/example/hello + +Returns a hello message from the plugin. + +**Response:** +```json +{ + "message": "Hello from Example Plugin!", + "plugin": "example_plugin", + "version": "1.0.0" +} +``` + +### GET /api/example/status + +Returns the plugin status and available endpoints. + +**Response:** +```json +{ + "status": "active", + "plugin": "example_plugin", + "endpoints": [ + "/api/example/hello", + "/api/example/status" + ] +} +``` + +## Creating Your Own Plugin + +1. Create a directory under `plugins/` with your plugin name +2. Add `__init__.py` with a `register_plugin(app)` function +3. Optionally add additional modules (routes.py, labels.py, etc.) +4. Return plugin metadata from `register_plugin()` + +Example structure: +``` +plugins/ + my_plugin/ + __init__.py # Contains register_plugin(app) + routes.py # Optional: Flask blueprint with routes + labels.py # Optional: Label definitions + settings.html # Optional: Settings UI template + README.md # Plugin documentation +``` + +## Plugin Registration Pattern + +```python +def register_plugin(app): + '''Register plugin with the Flask app. + + Args: + app: Flask application instance + + Returns: + dict: Plugin metadata with name, version, author, description + ''' + # Register routes, labels, etc. + from . import routes + app.register_blueprint(routes.bp) + + return { + 'name': 'My Plugin', + 'version': '1.0.0', + 'author': 'Author Name', + 'description': 'Plugin description' + } +``` + +## Enable/Disable + +Plugins can be enabled or disabled through the Extensions page (`/extensions`) without modifying code. The plugin state is persisted in the database and takes effect after restarting the application. diff --git a/plugins/example_plugin/__init__.py b/plugins/example_plugin/__init__.py new file mode 100644 index 0000000..4aad483 --- /dev/null +++ b/plugins/example_plugin/__init__.py @@ -0,0 +1,102 @@ +"""Example SciDK Plugin. + +This plugin demonstrates the basic structure and registration pattern for SciDK plugins. + +To create your own plugin: +1. Create a directory under plugins/ +2. Add __init__.py with a register_plugin(app) function +3. Optionally add routes.py, labels.py, etc. +4. Return plugin metadata from register_plugin() +""" + +from flask import Blueprint, jsonify + +# Create a blueprint for this plugin's routes +bp = Blueprint('example_plugin', __name__, url_prefix='/api/example') + + +@bp.get('/hello') +def hello(): + """Example API endpoint.""" + return jsonify({ + 'message': 'Hello from Example Plugin!', + 'plugin': 'example_plugin', + 'version': '1.0.0' + }) + + +@bp.get('/status') +def status(): + """Example status endpoint.""" + return jsonify({ + 'status': 'active', + 'plugin': 'example_plugin', + 'endpoints': [ + '/api/example/hello', + '/api/example/status' + ] + }) + + +def get_settings_schema(): + """Define the settings schema for this plugin. + + Returns: + dict: Settings schema defining configurable options + """ + return { + 'api_key': { + 'type': 'password', + 'required': False, + 'description': 'Example API key (encrypted when saved)', + 'default': '' + }, + 'endpoint_url': { + 'type': 'text', + 'required': False, + 'description': 'Example endpoint URL', + 'default': 'https://api.example.com' + }, + 'enabled_features': { + 'type': 'text', + 'required': False, + 'description': 'Comma-separated list of enabled features', + 'default': 'feature1,feature2' + }, + 'max_retries': { + 'type': 'number', + 'required': False, + 'description': 'Maximum number of retry attempts', + 'default': 3 + }, + 'debug_mode': { + 'type': 'boolean', + 'required': False, + 'description': 'Enable debug logging', + 'default': False + } + } + + +def register_plugin(app): + """Register the example plugin with the Flask app. + + This function is called by the plugin loader during application startup. + + Args: + app: Flask application instance + + Returns: + dict: Plugin metadata with name, version, author, description + """ + # Register the blueprint with the app + app.register_blueprint(bp) + + # Return plugin metadata + return { + 'name': 'Example Plugin', + 'version': '1.0.0', + 'author': 'SciDK Team', + 'description': 'A simple example plugin demonstrating the plugin system. ' + 'Adds /api/example/hello and /api/example/status endpoints.' + } diff --git a/plugins/ilab_table_loader/__init__.py b/plugins/ilab_table_loader/__init__.py new file mode 100644 index 0000000..3f1166f --- /dev/null +++ b/plugins/ilab_table_loader/__init__.py @@ -0,0 +1,198 @@ +"""iLab Data Importer Plugin for SciDK. + +This plugin provides a branded table loader specifically designed for iLab core facility data. +It includes presets for common iLab exports (Equipment, Services, PI Directory) with +column hints and suggested label mappings. +""" + +import logging +from datetime import datetime + +logger = logging.getLogger(__name__) + + +def handle_ilab_import(instance_config: dict) -> dict: + """Execute iLab data import with preset-specific enhancements. + + Args: + instance_config: Instance configuration containing: + - preset: One of 'equipment', 'services', 'pi_directory', or 'custom' + - file_path: Path to the iLab export file + - table_name: Name of the SQLite table to create/update + - instance_name: Friendly name for this import + + Returns: + dict: Import result with status, row count, columns, and table name + + Raises: + ValueError: If required configuration is missing or invalid + FileNotFoundError: If the file doesn't exist + Exception: For other import errors + """ + from plugins.table_loader import handle_table_import + + # Get preset configuration if specified + preset = instance_config.get('preset') + preset_configs = _get_preset_configs() + + # Apply preset defaults if available + if preset and preset in preset_configs: + preset_config = preset_configs[preset] + + # Auto-fill table name if not provided + if not instance_config.get('table_name'): + table_name_hint = preset_config['table_name_hint'] + # Replace YYYY with current year + current_year = datetime.now().year + instance_config['table_name'] = table_name_hint.replace('YYYY', str(current_year)) + + # Store column hints and suggested labels for UI display + instance_config['_column_hints'] = preset_config.get('column_hints', {}) + instance_config['_suggested_labels'] = preset_config.get('suggested_labels', []) + + # Delegate to generic table loader for actual import + result = handle_table_import(instance_config) + + # Add iLab-specific metadata to result + result['plugin'] = 'ilab_importer' + if preset: + result['preset'] = preset + result['preset_name'] = preset_configs[preset]['name'] + + return result + + +def _get_preset_configs() -> dict: + """Get preset configurations for iLab data types. + + Returns: + dict: Preset configurations keyed by preset ID + """ + return { + 'equipment': { + 'name': 'iLab Equipment', + 'table_name_hint': 'ilab_equipment_YYYY', + 'column_hints': { + 'Service Name': 'name', + 'Core': 'core_facility', + 'PI': 'principal_investigator', + 'Location': 'location', + 'Equipment ID': 'equipment_id', + 'Description': 'description' + }, + 'suggested_labels': ['Equipment', 'LabResource'] + }, + 'services': { + 'name': 'iLab Services', + 'table_name_hint': 'ilab_services_YYYY', + 'column_hints': { + 'Service Name': 'name', + 'Core': 'core_facility', + 'Rate Per Hour': 'hourly_rate', + 'Service ID': 'service_id', + 'Active': 'is_active' + }, + 'suggested_labels': ['iLabService'] + }, + 'pi_directory': { + 'name': 'PI Directory', + 'table_name_hint': 'ilab_pi_directory', + 'column_hints': { + 'PI Name': 'name', + 'Email': 'email', + 'Department': 'department', + 'Lab': 'lab_name', + 'Phone': 'phone', + 'Office': 'office_location' + }, + 'suggested_labels': ['PrincipalInvestigator', 'Researcher'] + } + } + + +def register_plugin(app): + """Register the iLab Data Importer plugin template with SciDK. + + This plugin registers a specialized table loader template for iLab core facility data + with branded UI, presets, and helpful column hints. + + Args: + app: Flask application instance + + Returns: + dict: Plugin metadata + """ + # Get the plugin template registry from app extensions + registry = app.extensions['scidk']['plugin_templates'] + + # Register the iLab Data Importer template + success = registry.register({ + 'id': 'ilab_importer', + 'name': 'iLab Data Importer', + 'description': 'Upload iLab export spreadsheets (CSV or Excel format). Specialized importer with presets for Equipment, Services, and PI Directory.', + 'category': 'data_import', + 'icon': '🧪', + 'supports_multiple_instances': True, + 'version': '1.0.0', + 'branding': { + 'css_class': 'ilab-template', + 'color': '#0066cc' + }, + 'preset_configs': _get_preset_configs(), + 'config_schema': { + 'type': 'object', + 'properties': { + 'instance_name': { + 'type': 'string', + 'description': 'Friendly name for this iLab import configuration', + 'required': True + }, + 'preset': { + 'type': 'string', + 'enum': ['equipment', 'services', 'pi_directory', 'custom'], + 'default': 'equipment', + 'description': 'iLab data type preset' + }, + 'file_path': { + 'type': 'string', + 'description': 'Path to the iLab export file (CSV or Excel)', + 'required': True + }, + 'table_name': { + 'type': 'string', + 'description': 'SQLite table name (auto-filled from preset)', + 'pattern': '^[a-zA-Z_][a-zA-Z0-9_]*$' + }, + 'file_type': { + 'type': 'string', + 'enum': ['csv', 'excel', 'auto'], + 'default': 'auto', + 'description': 'File type (auto-detected if not specified)' + }, + 'has_header': { + 'type': 'boolean', + 'default': True, + 'description': 'Whether the file has a header row' + }, + 'replace_existing': { + 'type': 'boolean', + 'default': True, + 'description': 'Replace existing table data' + } + } + }, + 'handler': handle_ilab_import + }) + + if success: + logger.info("iLab Data Importer plugin template registered successfully") + else: + logger.error("Failed to register iLab Data Importer plugin template") + + # Return plugin metadata + return { + 'name': 'iLab Data Importer', + 'version': '1.0.0', + 'author': 'SciDK Team', + 'description': 'Specialized importer for iLab core facility data with branded UI and helpful presets' + } diff --git a/plugins/table_loader/__init__.py b/plugins/table_loader/__init__.py new file mode 100644 index 0000000..6520707 --- /dev/null +++ b/plugins/table_loader/__init__.py @@ -0,0 +1,159 @@ +"""Table Loader Plugin for SciDK. + +This plugin template enables importing spreadsheet files (CSV, Excel, TSV) into SQLite tables. +Users can create multiple instances of this plugin for different data sources. + +Example instances: + - "iLab Equipment 2024": Loads equipment.xlsx into ilab_equipment_2024 table + - "PI Directory": Loads pi_directory.csv into pi_directory table + - "Lab Resources Q1": Loads resources.tsv into lab_resources_q1 table +""" + +import logging +from .importer import TableImporter + +logger = logging.getLogger(__name__) + + +def handle_table_import(instance_config: dict) -> dict: + """Execute the table import based on instance configuration. + + Args: + instance_config: Instance configuration containing: + - file_path: Path to the file to import + - table_name: Name of the SQLite table to create/update + - file_type: Type of file (csv, excel, tsv) - optional, auto-detected if not provided + - has_header: Whether the file has a header row (default: True) + - replace_existing: Whether to replace existing table data (default: True) + - sheet_name: For Excel files, which sheet to import (default: 0) + + Returns: + dict: Import result with status, row count, columns, and table name + + Raises: + ValueError: If required configuration is missing or invalid + FileNotFoundError: If the file doesn't exist + Exception: For other import errors + """ + importer = TableImporter() + return importer.import_table(instance_config) + + +def register_plugin(app): + """Register the table loader plugin template with SciDK. + + This plugin registers a template that can be instantiated multiple times + by users to import different spreadsheet files into SQLite tables. + + Args: + app: Flask application instance + + Returns: + dict: Plugin metadata + """ + # Get the plugin template registry from app extensions + registry = app.extensions['scidk']['plugin_templates'] + + # Register the table loader template + success = registry.register({ + 'id': 'table_loader', + 'name': 'Table Loader', + 'description': 'Import spreadsheets (CSV, Excel, TSV) into SQLite tables for querying and analysis', + 'category': 'data_import', + 'icon': '📊', + 'supports_multiple_instances': True, + 'version': '1.0.0', + 'graph_behavior': { + 'can_create_label': True, + 'label_source': 'table_columns', + 'sync_strategy': 'on_demand', + 'supports_preview': True + }, + 'config_schema': { + 'type': 'object', + 'properties': { + 'instance_name': { + 'type': 'string', + 'description': 'Friendly name for this import configuration', + 'required': True + }, + 'file_path': { + 'type': 'string', + 'description': 'Path to the spreadsheet file to import', + 'required': True + }, + 'table_name': { + 'type': 'string', + 'description': 'Name of the SQLite table to create/update', + 'required': True, + 'pattern': '^[a-zA-Z_][a-zA-Z0-9_]*$' # Valid SQL identifier + }, + 'file_type': { + 'type': 'string', + 'enum': ['csv', 'excel', 'tsv', 'auto'], + 'default': 'auto', + 'description': 'File type (auto-detected from extension if not specified)' + }, + 'has_header': { + 'type': 'boolean', + 'default': True, + 'description': 'Whether the file has a header row with column names' + }, + 'replace_existing': { + 'type': 'boolean', + 'default': True, + 'description': 'Replace existing table data (True) or append (False)' + }, + 'sheet_name': { + 'type': 'string', + 'default': '0', + 'description': 'For Excel files: sheet name or index (0-based)' + } + } + }, + 'handler': handle_table_import, + 'preset_configs': { + 'csv_import': { + 'name': 'CSV Import', + 'description': 'Import a CSV file with headers', + 'config': { + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': True + } + }, + 'excel_import': { + 'name': 'Excel Import', + 'description': 'Import an Excel spreadsheet', + 'config': { + 'file_type': 'excel', + 'has_header': True, + 'replace_existing': True, + 'sheet_name': '0' + } + }, + 'tsv_import': { + 'name': 'TSV Import', + 'description': 'Import a tab-separated values file', + 'config': { + 'file_type': 'tsv', + 'has_header': True, + 'replace_existing': True + } + } + } + }) + + if success: + logger.info("Table Loader plugin template registered successfully") + else: + logger.error("Failed to register Table Loader plugin template") + + # Return plugin metadata + return { + 'name': 'Table Loader', + 'version': '1.0.0', + 'author': 'SciDK Team', + 'description': 'Generic spreadsheet importer for CSV, Excel, and TSV files. ' + 'Creates SQLite tables that can be queried and linked to the knowledge graph.' + } diff --git a/plugins/table_loader/importer.py b/plugins/table_loader/importer.py new file mode 100644 index 0000000..45bca7f --- /dev/null +++ b/plugins/table_loader/importer.py @@ -0,0 +1,248 @@ +"""Table import logic for the Table Loader plugin. + +This module handles the actual import of spreadsheet files into SQLite tables +using pandas for file reading and SQLite for storage. +""" + +import sqlite3 +import logging +from pathlib import Path +from typing import Dict, Optional +import pandas as pd + +logger = logging.getLogger(__name__) + + +class TableImporter: + """Handles importing spreadsheet files into SQLite tables.""" + + def __init__(self, db_path: str = 'scidk_settings.db'): + """Initialize the table importer. + + Args: + db_path: Path to SQLite database file + """ + self.db_path = db_path + + def _get_connection(self) -> sqlite3.Connection: + """Get a database connection.""" + return sqlite3.connect(self.db_path) + + def _detect_file_type(self, file_path: str, file_type: str = 'auto') -> str: + """Detect the file type from the file extension. + + Args: + file_path: Path to the file + file_type: Explicit file type or 'auto' for detection + + Returns: + str: Detected file type (csv, excel, tsv) + + Raises: + ValueError: If file type cannot be determined or is unsupported + """ + if file_type != 'auto': + return file_type + + # Auto-detect from extension + path = Path(file_path) + ext = path.suffix.lower() + + if ext in ['.csv']: + return 'csv' + elif ext in ['.xlsx', '.xls', '.xlsm']: + return 'excel' + elif ext in ['.tsv', '.tab']: + return 'tsv' + else: + raise ValueError(f"Unsupported file extension: {ext}. Use .csv, .xlsx, .xls, or .tsv") + + def _read_file(self, file_path: str, file_type: str, has_header: bool = True, + sheet_name: Optional[str] = None) -> pd.DataFrame: + """Read the file into a pandas DataFrame. + + Args: + file_path: Path to the file to read + file_type: Type of file (csv, excel, tsv) + has_header: Whether the file has a header row + sheet_name: For Excel files, sheet name or index + + Returns: + pd.DataFrame: The loaded data + + Raises: + FileNotFoundError: If the file doesn't exist + Exception: For other read errors + """ + # Check if file exists + if not Path(file_path).exists(): + raise FileNotFoundError(f"File not found: {file_path}") + + # Set header parameter for pandas + header = 0 if has_header else None + + try: + if file_type == 'csv': + df = pd.read_csv(file_path, header=header) + elif file_type == 'tsv': + df = pd.read_csv(file_path, sep='\t', header=header) + elif file_type == 'excel': + # Handle sheet_name parameter + if sheet_name: + # Try as integer first (index), then as string (name) + try: + sheet = int(sheet_name) + except ValueError: + sheet = sheet_name + else: + sheet = 0 # Default to first sheet + + df = pd.read_excel(file_path, sheet_name=sheet, header=header) + else: + raise ValueError(f"Unsupported file type: {file_type}") + + # If no header, generate column names + if not has_header: + df.columns = [f'col_{i}' for i in range(len(df.columns))] + + logger.info(f"Successfully read file: {file_path} ({len(df)} rows, {len(df.columns)} columns)") + return df + + except Exception as e: + logger.error(f"Error reading file {file_path}: {e}") + raise + + def _sanitize_table_name(self, table_name: str) -> str: + """Sanitize the table name to be a valid SQLite identifier. + + Args: + table_name: The table name to sanitize + + Returns: + str: Sanitized table name + + Raises: + ValueError: If table name is invalid + """ + # Basic validation + if not table_name: + raise ValueError("Table name cannot be empty") + + # Check for valid SQL identifier (alphanumeric + underscore, not starting with digit) + if not table_name[0].isalpha() and table_name[0] != '_': + raise ValueError(f"Table name must start with letter or underscore: {table_name}") + + for char in table_name: + if not (char.isalnum() or char == '_'): + raise ValueError(f"Table name contains invalid character: {char}") + + return table_name + + def import_table(self, config: dict) -> dict: + """Import a spreadsheet file into a SQLite table. + + Args: + config: Import configuration dict with keys: + - file_path: Path to the file (required) + - table_name: Name of the table (required) + - file_type: File type or 'auto' (default: 'auto') + - has_header: Whether file has header (default: True) + - replace_existing: Replace or append (default: True) + - sheet_name: For Excel, sheet to import (default: 0) + + Returns: + dict: Import result with keys: + - status: 'success' or 'error' + - message: Status message + - rows_imported: Number of rows imported + - columns: List of column names + - table_name: Name of the table + - file_path: Path to the imported file + + Raises: + ValueError: If required configuration is missing or invalid + """ + # Validate required fields + if 'file_path' not in config: + raise ValueError("Missing required field: file_path") + if 'table_name' not in config: + raise ValueError("Missing required field: table_name") + + file_path = config['file_path'] + file_type = config.get('file_type', 'auto') + has_header = config.get('has_header', True) + replace_existing = config.get('replace_existing', True) + sheet_name = config.get('sheet_name', '0') + + try: + # Sanitize table name (may raise ValueError) + table_name = self._sanitize_table_name(config['table_name']) + # Detect file type + detected_type = self._detect_file_type(file_path, file_type) + logger.info(f"Importing {detected_type} file: {file_path} -> table: {table_name}") + + # Read the file + df = self._read_file(file_path, detected_type, has_header, sheet_name) + + # Get database connection + conn = self._get_connection() + + # Determine if_exists behavior + if_exists = 'replace' if replace_existing else 'append' + + # Write to SQLite + df.to_sql(table_name, conn, if_exists=if_exists, index=False) + + conn.close() + + result = { + 'status': 'success', + 'message': f'Successfully imported {len(df)} rows into table {table_name}', + 'rows_imported': len(df), + 'columns': list(df.columns), + 'table_name': table_name, + 'file_path': file_path, + 'file_type': detected_type + } + + logger.info(f"Import successful: {result['message']}") + return result + + except FileNotFoundError as e: + error_msg = f"File not found: {file_path}" + logger.error(error_msg) + return { + 'status': 'error', + 'message': error_msg, + 'rows_imported': 0, + 'columns': [], + 'table_name': table_name, + 'file_path': file_path, + 'error': str(e) + } + + except ValueError as e: + error_msg = f"Invalid configuration: {str(e)}" + logger.error(error_msg) + return { + 'status': 'error', + 'message': error_msg, + 'rows_imported': 0, + 'columns': [], + 'table_name': config.get('table_name', ''), + 'file_path': file_path, + 'error': str(e) + } + + except Exception as e: + error_msg = f"Import failed: {str(e)}" + logger.error(error_msg, exc_info=True) + return { + 'status': 'error', + 'message': error_msg, + 'rows_imported': 0, + 'columns': [], + 'table_name': config.get('table_name', ''), + 'file_path': file_path, + 'error': str(e) + } diff --git a/pyproject.toml b/pyproject.toml index 760b313..01d9933 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,6 +22,8 @@ dependencies = [ "pandas>=2.0", "rapidfuzz>=3.0", "bcrypt>=4.0", + "APScheduler>=3.10", + "flasgger>=0.9.7", ] [project.optional-dependencies] diff --git a/requirements.txt b/requirements.txt index 12fdf63..eb5fb84 100644 --- a/requirements.txt +++ b/requirements.txt @@ -11,6 +11,8 @@ jsonpath-ng>=1.6 pandas>=2.0 rapidfuzz>=3.0 bcrypt>=4.0 +APScheduler>=3.10 +flasgger>=0.9.7 # Dev/test dependencies (same as pyproject.toml [project.optional-dependencies].dev) pytest>=7.4 diff --git a/scidk/app.py b/scidk/app.py index b7917f2..30ae127 100644 --- a/scidk/app.py +++ b/scidk/app.py @@ -10,10 +10,12 @@ from flask import Flask from pathlib import Path import os +from flasgger import Swagger # Core components from .core.filesystem import FilesystemManager from .core.registry import InterpreterRegistry +from .core.logging_config import setup_logging from .interpreters import register_all as register_interpreters # Initialization modules (extracted from app.py) @@ -32,11 +34,54 @@ def create_app(): Returns: Flask: Configured Flask application instance with scidk extensions """ + # Setup logging first to capture all startup activity + log_level = os.environ.get('SCIDK_LOG_LEVEL', 'INFO') + setup_logging(log_level=log_level) + # Apply channel-based defaults before reading env-driven config apply_channel_defaults() app = Flask(__name__, template_folder="ui/templates", static_folder="ui/static") + # Initialize Swagger for API documentation + swagger_template = { + 'info': { + 'title': 'SciDK API', + 'version': '1.0.0', + 'description': 'RESTful API for SciDK scientific data management and knowledge graph operations', + 'contact': { + 'name': 'SciDK Team', + 'url': 'https://github.com/scidk/scidk' + } + }, + 'securityDefinitions': { + 'Bearer': { + 'type': 'apiKey', + 'name': 'Authorization', + 'in': 'header', + 'description': 'JWT Authorization header using the Bearer scheme. Example: "Authorization: Bearer {token}"' + } + }, + 'security': [ + {'Bearer': []} + ] + } + swagger_config = { + 'headers': [], + 'specs': [ + { + 'endpoint': 'apispec', + 'route': '/apispec.json', + 'rule_filter': lambda rule: True, + 'model_filter': lambda tag: True, + } + ], + 'static_url_path': '/flasgger_static', + 'swagger_ui': True, + 'specs_route': '/api/docs' + } + Swagger(app, template=swagger_template, config=swagger_config) + # Feature: selective dry-run UI flag (dev default) try: ch = (os.environ.get('SCIDK_CHANNEL') or 'stable').strip().lower() @@ -136,6 +181,78 @@ def create_app(): from .web.auth_middleware import init_auth_middleware init_auth_middleware(app) + # Initialize label endpoint registry (for plugin-registered endpoints) + from .core.label_endpoint_registry import LabelEndpointRegistry + label_endpoint_registry = LabelEndpointRegistry() + app.extensions['scidk']['label_endpoints'] = label_endpoint_registry + + # Initialize plugin template registry (for UI-instantiable plugins) + from .core.plugin_template_registry import PluginTemplateRegistry + plugin_template_registry = PluginTemplateRegistry() + app.extensions['scidk']['plugin_templates'] = plugin_template_registry + + # Initialize plugin instance manager (for user-created instances) + from .core.plugin_instance_manager import PluginInstanceManager + settings_db = app.config.get('SCIDK_SETTINGS_DB', 'scidk_settings.db') + plugin_instance_manager = PluginInstanceManager(db_path=settings_db) + app.extensions['scidk']['plugin_instances'] = plugin_instance_manager + + # Load plugins after all core initialization is complete + from .core.plugin_loader import PluginLoader, get_all_plugin_states + plugin_loader = PluginLoader() + plugin_states = get_all_plugin_states() + + # Get list of enabled plugins from database + discovered_plugins = plugin_loader.discover_plugins() + enabled_plugins = [p for p in discovered_plugins if plugin_states.get(p, True)] + + # Load all plugins + plugin_loader.load_all_plugins(app, enabled_plugins=enabled_plugins) + + # Store plugin loader in app extensions for access in routes + app.extensions['scidk']['plugins'] = { + 'loader': plugin_loader, + 'loaded': plugin_loader.list_plugins(), + 'failed': plugin_loader.list_failed_plugins() + } + + # Initialize backup scheduler + try: + from .core.backup_manager import get_backup_manager + from .core.backup_scheduler import get_backup_scheduler + + # Get settings database path + settings_db = app.config.get('SCIDK_SETTINGS_DB', 'scidk_settings.db') + + # Get alert manager if available + alert_manager = None + try: + from .core.alert_manager import AlertManager + alert_manager = AlertManager(db_path=settings_db) + except Exception: + # Alert manager optional + pass + + # Initialize backup manager and scheduler + # Scheduler will load settings from database (schedule, retention, etc.) + backup_manager = get_backup_manager() + backup_scheduler = get_backup_scheduler( + backup_manager=backup_manager, + settings_db_path=settings_db, + alert_manager=alert_manager + ) + + # Start scheduler (will only run if schedule_enabled is True in settings) + backup_scheduler.start() + + # Store in app extensions for access in routes + app.extensions['scidk']['backup_scheduler'] = backup_scheduler + app.extensions['scidk']['backup_manager'] = backup_manager + except Exception as e: + # Backup scheduler is optional - log but don't fail startup + import logging + logging.warning(f"Failed to initialize backup scheduler: {e}") + return app diff --git a/scidk/core/alert_manager.py b/scidk/core/alert_manager.py new file mode 100644 index 0000000..c47da2d --- /dev/null +++ b/scidk/core/alert_manager.py @@ -0,0 +1,618 @@ +""" +Alert and notification management system for SciDK. + +Manages alert definitions, triggers notifications (email), and tracks alert history. +""" + +import sqlite3 +import json +import smtplib +import uuid +from datetime import datetime, timezone +from email.mime.text import MIMEText +from email.mime.multipart import MIMEMultipart +from typing import Dict, Any, List, Optional +from cryptography.fernet import Fernet + + +class AlertManager: + """Manages alert definitions and triggers notifications.""" + + def __init__(self, db_path: str, encryption_key: Optional[str] = None): + """ + Initialize AlertManager. + + Args: + db_path: Path to settings database + encryption_key: Fernet key for SMTP password encryption (base64-encoded) + """ + self.db_path = db_path + self.db = sqlite3.connect(db_path, check_same_thread=False) + self.db.execute('PRAGMA journal_mode=WAL;') + self.db.row_factory = sqlite3.Row + + # Initialize encryption for SMTP passwords + if encryption_key: + self.cipher = Fernet(encryption_key.encode()) + else: + self.cipher = Fernet(Fernet.generate_key()) + + self.init_tables() + self.bootstrap_default_alerts() + + def init_tables(self): + """Create alert-related tables if they don't exist.""" + # Alert definitions + self.db.execute( + """ + CREATE TABLE IF NOT EXISTS alerts ( + id TEXT PRIMARY KEY, + name TEXT NOT NULL, + condition_type TEXT NOT NULL, + action_type TEXT NOT NULL DEFAULT 'email', + recipients TEXT, + threshold REAL, + enabled INTEGER DEFAULT 1, + created_at REAL NOT NULL, + updated_at REAL NOT NULL, + created_by TEXT + ) + """ + ) + + # Alert history + self.db.execute( + """ + CREATE TABLE IF NOT EXISTS alert_history ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + alert_id TEXT NOT NULL, + triggered_at REAL NOT NULL, + condition_details TEXT, + success INTEGER DEFAULT 1, + error_message TEXT, + FOREIGN KEY (alert_id) REFERENCES alerts(id) + ) + """ + ) + self.db.execute("CREATE INDEX IF NOT EXISTS idx_alert_history_alert ON alert_history(alert_id);") + self.db.execute("CREATE INDEX IF NOT EXISTS idx_alert_history_triggered ON alert_history(triggered_at DESC);") + + # SMTP configuration (singleton) + self.db.execute( + """ + CREATE TABLE IF NOT EXISTS smtp_config ( + id INTEGER PRIMARY KEY CHECK (id = 1), + host TEXT, + port INTEGER DEFAULT 587, + username TEXT, + password_encrypted TEXT, + from_address TEXT, + use_tls INTEGER DEFAULT 1, + enabled INTEGER DEFAULT 0, + recipients TEXT + ) + """ + ) + + self.db.commit() + + def bootstrap_default_alerts(self): + """Create default alert definitions if they don't exist.""" + defaults = [ + { + 'name': 'Import Failed', + 'condition_type': 'import_failed', + 'action_type': 'email', + 'recipients': [], + 'threshold': None, + 'description': 'Triggered when a file import or scan operation fails' + }, + { + 'name': 'High Discrepancies', + 'condition_type': 'high_discrepancies', + 'action_type': 'email', + 'recipients': [], + 'threshold': 50.0, + 'description': 'Triggered when reconciliation finds more than 50 discrepancies' + }, + { + 'name': 'Backup Failed', + 'condition_type': 'backup_failed', + 'action_type': 'email', + 'recipients': [], + 'threshold': None, + 'description': 'Triggered when a scheduled backup operation fails' + }, + { + 'name': 'Neo4j Connection Lost', + 'condition_type': 'neo4j_down', + 'action_type': 'email', + 'recipients': [], + 'threshold': None, + 'description': 'Triggered when Neo4j database connection is lost' + }, + { + 'name': 'Disk Space Critical', + 'condition_type': 'disk_critical', + 'action_type': 'email', + 'recipients': [], + 'threshold': 95.0, + 'description': 'Triggered when disk usage exceeds 95%' + }, + ] + + for alert_def in defaults: + # Check if alert with this condition_type already exists + cur = self.db.execute( + "SELECT id FROM alerts WHERE condition_type = ?", + (alert_def['condition_type'],) + ) + existing = cur.fetchone() + + if not existing: + alert_id = str(uuid.uuid4()) + now = datetime.now(timezone.utc).timestamp() + recipients_json = json.dumps(alert_def['recipients']) + + self.db.execute( + """ + INSERT INTO alerts (id, name, condition_type, action_type, recipients, threshold, enabled, created_at, updated_at, created_by) + VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?, 'system') + """, + (alert_id, alert_def['name'], alert_def['condition_type'], alert_def['action_type'], + recipients_json, alert_def['threshold'], now, now) + ) + + self.db.commit() + + def list_alerts(self, enabled_only: bool = False) -> List[Dict[str, Any]]: + """List all alert definitions.""" + query = "SELECT * FROM alerts" + if enabled_only: + query += " WHERE enabled = 1" + query += " ORDER BY name" + + cur = self.db.execute(query) + rows = cur.fetchall() + + alerts = [] + for row in rows: + alerts.append({ + 'id': row['id'], + 'name': row['name'], + 'condition_type': row['condition_type'], + 'action_type': row['action_type'], + 'recipients': json.loads(row['recipients']) if row['recipients'] else [], + 'threshold': row['threshold'], + 'enabled': bool(row['enabled']), + 'created_at': row['created_at'], + 'updated_at': row['updated_at'], + 'created_by': row['created_by'] + }) + + return alerts + + def get_alert(self, alert_id: str) -> Optional[Dict[str, Any]]: + """Get alert by ID.""" + cur = self.db.execute("SELECT * FROM alerts WHERE id = ?", (alert_id,)) + row = cur.fetchone() + + if not row: + return None + + return { + 'id': row['id'], + 'name': row['name'], + 'condition_type': row['condition_type'], + 'action_type': row['action_type'], + 'recipients': json.loads(row['recipients']) if row['recipients'] else [], + 'threshold': row['threshold'], + 'enabled': bool(row['enabled']), + 'created_at': row['created_at'], + 'updated_at': row['updated_at'], + 'created_by': row['created_by'] + } + + def create_alert(self, name: str, condition_type: str, action_type: str, + recipients: List[str], threshold: Optional[float] = None, + created_by: str = 'system') -> str: + """Create new alert definition.""" + alert_id = str(uuid.uuid4()) + now = datetime.now(timezone.utc).timestamp() + recipients_json = json.dumps(recipients) + + self.db.execute( + """ + INSERT INTO alerts (id, name, condition_type, action_type, recipients, threshold, enabled, created_at, updated_at, created_by) + VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?) + """, + (alert_id, name, condition_type, action_type, recipients_json, threshold, now, now, created_by) + ) + self.db.commit() + + return alert_id + + def update_alert(self, alert_id: str, **kwargs) -> bool: + """Update alert definition.""" + allowed_fields = ['name', 'action_type', 'recipients', 'threshold', 'enabled'] + updates = [] + params = [] + + for field in allowed_fields: + if field in kwargs: + if field == 'recipients': + updates.append(f"{field} = ?") + params.append(json.dumps(kwargs[field])) + elif field == 'enabled': + updates.append(f"{field} = ?") + params.append(1 if kwargs[field] else 0) + else: + updates.append(f"{field} = ?") + params.append(kwargs[field]) + + if not updates: + return False + + updates.append("updated_at = ?") + params.append(datetime.now(timezone.utc).timestamp()) + params.append(alert_id) + + query = f"UPDATE alerts SET {', '.join(updates)} WHERE id = ?" + cursor = self.db.execute(query, params) + self.db.commit() + + return cursor.rowcount > 0 + + def delete_alert(self, alert_id: str) -> bool: + """Delete alert definition.""" + cursor = self.db.execute("DELETE FROM alerts WHERE id = ?", (alert_id,)) + self.db.commit() + return cursor.rowcount > 0 + + def check_alerts(self, condition_type: str, details: Dict[str, Any]) -> List[str]: + """ + Check if any alerts match this condition and trigger them. + + Args: + condition_type: Type of condition (e.g., 'import_failed') + details: Context about the condition (e.g., error message, counts) + + Returns: + List of alert IDs that were triggered + """ + alerts = self.list_alerts(enabled_only=True) + triggered = [] + + for alert in alerts: + if alert['condition_type'] != condition_type: + continue + + # Check threshold if applicable + if alert.get('threshold') is not None: + value = details.get('value') + if value is None or value < alert['threshold']: + continue + + # Trigger alert + success, error_msg = self._trigger_alert(alert, details) + self._log_alert_history(alert['id'], details, success, error_msg) + + if success: + triggered.append(alert['id']) + + return triggered + + def _trigger_alert(self, alert: Dict[str, Any], details: Dict[str, Any]) -> tuple[bool, Optional[str]]: + """ + Send notification for this alert. + + Returns: + Tuple of (success: bool, error_message: Optional[str]) + """ + action_type = alert['action_type'] + + if action_type == 'email': + return self._send_email_alert(alert, details) + elif action_type == 'webhook': + return self._send_webhook_alert(alert, details) + elif action_type == 'log': + return self._log_alert(alert, details) + else: + return False, f"Unknown action type: {action_type}" + + def _send_email_alert(self, alert: Dict[str, Any], details: Dict[str, Any]) -> tuple[bool, Optional[str]]: + """Send email notification.""" + smtp_config = self.get_smtp_config() + if not smtp_config or not smtp_config.get('enabled'): + return False, "SMTP not configured or disabled" + + # Get recipients from global SMTP config + recipients = smtp_config.get('recipients', []) + if not recipients: + return False, "No recipients configured in SMTP settings" + + # Compose email + subject = f"SciDK Alert: {alert['name']}" + body = self._format_email_body(alert, details) + + msg = MIMEMultipart() + msg['From'] = smtp_config['from_address'] + msg['To'] = ', '.join(recipients) + msg['Subject'] = subject + msg.attach(MIMEText(body, 'html')) + + try: + with smtplib.SMTP(smtp_config['host'], smtp_config['port'], timeout=10) as server: + if smtp_config.get('use_tls'): + server.starttls() + if smtp_config.get('username') and smtp_config.get('password_encrypted'): + password = self._decrypt_password(smtp_config['password_encrypted']) + server.login(smtp_config['username'], password) + server.send_message(msg) + return True, None + except Exception as e: + error_msg = f"Failed to send email: {str(e)}" + print(error_msg) + return False, error_msg + + def _format_email_body(self, alert: Dict[str, Any], details: Dict[str, Any]) -> str: + """Format email body with alert details.""" + is_test = details.get('test', False) + test_banner = '
⚠️ TEST ALERT - This is a test notification
' if is_test else '' + + details_html = '
    ' + for k, v in details.items(): + if k != 'test': # Skip the test flag in details + details_html += f'
  • {k}: {v}
    • ' + details_html += '
' + + return f""" + + + {test_banner} +

Alert: {alert['name']}

+

Condition: {alert['condition_type']}

+

Time: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}

+ +

Details:

+ {details_html} + +
+

+ Generated by SciDK Alert System
+ Configure Alerts +

+ + + """ + + def _send_webhook_alert(self, alert: Dict[str, Any], details: Dict[str, Any]) -> tuple[bool, Optional[str]]: + """Send webhook notification (placeholder for future implementation).""" + # TODO: Implement webhook notifications + return False, "Webhook notifications not yet implemented" + + def _log_alert(self, alert: Dict[str, Any], details: Dict[str, Any]) -> tuple[bool, Optional[str]]: + """Log alert to system logs.""" + log_msg = f"ALERT: {alert['name']} - {alert['condition_type']} - {json.dumps(details)}" + print(log_msg) + return True, None + + def _log_alert_history(self, alert_id: str, details: Dict[str, Any], success: bool, error_message: Optional[str] = None): + """Log alert trigger to history.""" + now = datetime.now(timezone.utc).timestamp() + condition_details_json = json.dumps(details) + + self.db.execute( + """ + INSERT INTO alert_history (alert_id, triggered_at, condition_details, success, error_message) + VALUES (?, ?, ?, ?, ?) + """, + (alert_id, now, condition_details_json, 1 if success else 0, error_message) + ) + self.db.commit() + + def test_alert(self, alert_id: str) -> tuple[bool, Optional[str]]: + """ + Send test notification for this alert. + + Returns: + Tuple of (success: bool, error_message: Optional[str]) + """ + alert = self.get_alert(alert_id) + if not alert: + return False, "Alert not found" + + test_details = { + 'test': True, + 'message': 'This is a test alert from SciDK', + 'timestamp': datetime.now(timezone.utc).isoformat() + } + + success, error_msg = self._trigger_alert(alert, test_details) + self._log_alert_history(alert['id'], test_details, success, error_msg) + + return success, error_msg + + def get_alert_history(self, alert_id: Optional[str] = None, limit: int = 100) -> List[Dict[str, Any]]: + """ + Get alert trigger history. + + Args: + alert_id: Optional alert ID to filter by + limit: Maximum number of entries to return + + Returns: + List of alert history entries + """ + if alert_id: + query = "SELECT * FROM alert_history WHERE alert_id = ? ORDER BY triggered_at DESC LIMIT ?" + params = (alert_id, limit) + else: + query = "SELECT * FROM alert_history ORDER BY triggered_at DESC LIMIT ?" + params = (limit,) + + cur = self.db.execute(query, params) + rows = cur.fetchall() + + history = [] + for row in rows: + history.append({ + 'id': row['id'], + 'alert_id': row['alert_id'], + 'triggered_at': row['triggered_at'], + 'triggered_at_iso': datetime.fromtimestamp(row['triggered_at'], tz=timezone.utc).isoformat(), + 'condition_details': json.loads(row['condition_details']) if row['condition_details'] else {}, + 'success': bool(row['success']), + 'error_message': row['error_message'] + }) + + return history + + # SMTP Configuration methods + + def get_smtp_config(self) -> Optional[Dict[str, Any]]: + """Get SMTP configuration (password redacted).""" + cur = self.db.execute("SELECT * FROM smtp_config WHERE id = 1") + row = cur.fetchone() + + if not row: + return None + + return { + 'host': row['host'], + 'port': row['port'], + 'username': row['username'], + 'password_encrypted': row['password_encrypted'], # Don't expose this directly + 'from_address': row['from_address'], + 'use_tls': bool(row['use_tls']), + 'enabled': bool(row['enabled']), + 'recipients': json.loads(row['recipients']) if row['recipients'] else [] + } + + def get_smtp_config_safe(self) -> Optional[Dict[str, Any]]: + """Get SMTP configuration with password redacted (safe for API responses).""" + config = self.get_smtp_config() + if config: + config['password'] = '••••••••' if config.get('password_encrypted') else '' + del config['password_encrypted'] + return config + + def update_smtp_config(self, host: str, port: int, username: str, password: Optional[str], + from_address: str, recipients: List[str], use_tls: bool = True, enabled: bool = True) -> bool: + """Update SMTP configuration.""" + # Encrypt password if provided + password_encrypted = None + if password: + password_encrypted = self._encrypt_password(password) + + # JSON encode recipients + recipients_json = json.dumps(recipients) + + # Check if config exists + cur = self.db.execute("SELECT id FROM smtp_config WHERE id = 1") + exists = cur.fetchone() + + if exists: + # Update existing + if password: + # Update with new password + self.db.execute( + """ + UPDATE smtp_config + SET host = ?, port = ?, username = ?, password_encrypted = ?, from_address = ?, recipients = ?, use_tls = ?, enabled = ? + WHERE id = 1 + """, + (host, port, username, password_encrypted, from_address, recipients_json, 1 if use_tls else 0, 1 if enabled else 0) + ) + else: + # Keep existing password + self.db.execute( + """ + UPDATE smtp_config + SET host = ?, port = ?, username = ?, from_address = ?, recipients = ?, use_tls = ?, enabled = ? + WHERE id = 1 + """, + (host, port, username, from_address, recipients_json, 1 if use_tls else 0, 1 if enabled else 0) + ) + else: + # Insert new + self.db.execute( + """ + INSERT INTO smtp_config (id, host, port, username, password_encrypted, from_address, recipients, use_tls, enabled) + VALUES (1, ?, ?, ?, ?, ?, ?, ?, ?) + """, + (host, port, username, password_encrypted, from_address, recipients_json, 1 if use_tls else 0, 1 if enabled else 0) + ) + + self.db.commit() + return True + + def test_smtp_config(self, test_recipient: Optional[str] = None) -> tuple[bool, Optional[str]]: + """ + Test SMTP configuration by sending a test email. + + Args: + test_recipient: Email address to send test to. If None, uses from_address + + Returns: + Tuple of (success: bool, error_message: Optional[str]) + """ + smtp_config = self.get_smtp_config() + if not smtp_config or not smtp_config.get('enabled'): + return False, "SMTP not configured or disabled" + + recipient = test_recipient or smtp_config['from_address'] + subject = "SciDK SMTP Test" + body = f""" + + +

✓ SMTP Configuration Test

+

This is a test email from SciDK to verify your SMTP configuration.

+

Time: {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M:%S UTC')}

+

SMTP Host: {smtp_config['host']}:{smtp_config['port']}

+

From Address: {smtp_config['from_address']}

+
+

+ If you received this email, your SMTP configuration is working correctly. +

+ + + """ + + msg = MIMEMultipart() + msg['From'] = smtp_config['from_address'] + msg['To'] = recipient + msg['Subject'] = subject + msg.attach(MIMEText(body, 'html')) + + try: + with smtplib.SMTP(smtp_config['host'], smtp_config['port'], timeout=10) as server: + if smtp_config.get('use_tls'): + server.starttls() + if smtp_config.get('username') and smtp_config.get('password_encrypted'): + password = self._decrypt_password(smtp_config['password_encrypted']) + server.login(smtp_config['username'], password) + server.send_message(msg) + return True, None + except Exception as e: + error_msg = f"SMTP test failed: {str(e)}" + print(error_msg) + return False, error_msg + + def _encrypt_password(self, password: str) -> str: + """Encrypt password using Fernet.""" + return self.cipher.encrypt(password.encode()).decode() + + def _decrypt_password(self, encrypted_password: str) -> str: + """Decrypt password using Fernet.""" + return self.cipher.decrypt(encrypted_password.encode()).decode() + + +def get_encryption_key() -> str: + """Get or generate encryption key for alert manager.""" + import os + key = os.environ.get('SCIDK_ENCRYPTION_KEY') + if not key: + # Generate and store key (in production, this should be persisted securely) + key = Fernet.generate_key().decode() + return key diff --git a/scidk/core/backup_manager.py b/scidk/core/backup_manager.py index 27fae69..e3d1b57 100644 --- a/scidk/core/backup_manager.py +++ b/scidk/core/backup_manager.py @@ -26,15 +26,17 @@ class BackupManager: BACKUP_VERSION = "1.0" - def __init__(self, backup_dir: str = "backups"): + def __init__(self, backup_dir: str = "backups", alert_manager=None): """ Initialize BackupManager. Args: backup_dir: Directory to store backup files (default: 'backups/') + alert_manager: Optional AlertManager instance for notifications """ self.backup_dir = Path(backup_dir) self.backup_dir.mkdir(exist_ok=True) + self.alert_manager = alert_manager def create_backup( self, @@ -130,6 +132,18 @@ def create_backup( } except Exception as e: + # Trigger backup_failed alert + if self.alert_manager: + try: + self.alert_manager.check_alerts('backup_failed', { + 'error': str(e), + 'timestamp': timestamp.isoformat(), + 'reason': reason, + 'value': 1 # Failed + }) + except Exception as alert_error: + print(f"Failed to trigger backup_failed alert: {alert_error}") + return { 'success': False, 'error': str(e) diff --git a/scidk/core/backup_scheduler.py b/scidk/core/backup_scheduler.py new file mode 100644 index 0000000..28ab07f --- /dev/null +++ b/scidk/core/backup_scheduler.py @@ -0,0 +1,482 @@ +""" +Automated backup scheduler for SciDK. + +Manages scheduled backups, verification, and retention policies. +""" + +import os +import tempfile +import zipfile +from pathlib import Path +from datetime import datetime, timedelta, timezone +from typing import Dict, Any, Optional +from apscheduler.schedulers.background import BackgroundScheduler +from apscheduler.triggers.cron import CronTrigger + +from .backup_manager import BackupManager + + +class BackupScheduler: + """Manages automated backup scheduling, verification, and retention.""" + + def __init__( + self, + backup_manager: BackupManager, + settings_db_path: str = 'scidk_settings.db', + alert_manager=None + ): + """ + Initialize BackupScheduler. + + Loads schedule and retention settings from database. + + Args: + backup_manager: BackupManager instance + settings_db_path: Path to settings database + alert_manager: Optional AlertManager for notifications + """ + self.backup_manager = backup_manager + self.settings_db_path = settings_db_path + self.alert_manager = alert_manager + self.scheduler = BackgroundScheduler() + self._running = False + + # Load settings from database (with defaults) + self.reload_settings() + + def reload_settings(self): + """Reload schedule and retention settings from database.""" + import sqlite3 + + defaults = { + 'schedule_enabled': True, + 'schedule_hour': 2, + 'schedule_minute': 0, + 'retention_days': 30, + 'verify_backups': True + } + + try: + db = sqlite3.connect(self.settings_db_path) + db.execute('PRAGMA journal_mode=WAL;') + + # Ensure settings table exists + db.execute(''' + CREATE TABLE IF NOT EXISTS backup_settings ( + key TEXT PRIMARY KEY, + value TEXT, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + ) + ''') + + # Load each setting + for key, default_value in defaults.items(): + cur = db.execute('SELECT value FROM backup_settings WHERE key = ?', (key,)) + row = cur.fetchone() + if row and row[0] is not None: + # Parse value based on type + if isinstance(default_value, bool): + value = row[0].lower() in ('true', '1', 'yes') + elif isinstance(default_value, int): + value = int(row[0]) + else: + value = row[0] + setattr(self, key, value) + else: + # Use default and save it + setattr(self, key, default_value) + db.execute( + 'INSERT OR IGNORE INTO backup_settings (key, value) VALUES (?, ?)', + (key, str(default_value)) + ) + + db.commit() + db.close() + except Exception: + # If database fails, use defaults + for key, default_value in defaults.items(): + setattr(self, key, default_value) + + def start(self): + """Start the backup scheduler.""" + if self._running: + return + + # Schedule daily backup + self.scheduler.add_job( + self._run_scheduled_backup, + CronTrigger(hour=self.schedule_hour, minute=self.schedule_minute), + id='daily_backup', + replace_existing=True, + name='Daily Backup' + ) + + self.scheduler.start() + self._running = True + + def stop(self): + """Stop the backup scheduler.""" + if self._running: + self.scheduler.shutdown(wait=False) + self._running = False + + def is_running(self) -> bool: + """Check if scheduler is running.""" + return self._running + + def _run_scheduled_backup(self): + """Execute the scheduled backup workflow.""" + try: + # Create backup + result = self.backup_manager.create_backup( + reason='auto', + created_by='system', + notes='Automated daily backup' + ) + + if not result['success']: + # Trigger backup_failed alert + if self.alert_manager: + self.alert_manager.check_alerts('backup_failed', { + 'error': result.get('error', 'Unknown error'), + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'reason': 'auto', + 'value': 1 + }) + return + + backup_id = result['backup_id'] + + # Verify backup if enabled + verification_result = None + if self.verify_backups: + verification_result = self.verify_backup(result['filename']) + + # Update backup metadata with verification status + if verification_result and 'verified' in verification_result: + self._update_backup_verification( + result['filename'], + verification_result['verified'], + verification_result.get('error') + ) + + # Cleanup old backups + self.cleanup_old_backups() + + # Trigger backup_completed alert if available + if self.alert_manager: + try: + self.alert_manager.check_alerts('backup_completed', { + 'backup_id': backup_id, + 'size': result.get('size', 0), + 'verified': verification_result.get('verified', False) if verification_result else False, + 'timestamp': result.get('timestamp'), + 'value': 1 + }) + except Exception: + # Alert might not be configured + pass + + except Exception as e: + # Log error and trigger alert + if self.alert_manager: + try: + self.alert_manager.check_alerts('backup_failed', { + 'error': str(e), + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'reason': 'auto', + 'value': 1 + }) + except Exception: + pass + + def verify_backup(self, backup_file: str) -> Dict[str, Any]: + """ + Verify a backup by attempting to read and validate its contents. + + Args: + backup_file: Backup filename or path + + Returns: + Dict with verification results + """ + try: + # Find the backup file + if not os.path.isabs(backup_file): + backup_path = self.backup_manager.backup_dir / backup_file + else: + backup_path = Path(backup_file) + + if not backup_path.exists(): + return { + 'verified': False, + 'error': f'Backup file not found: {backup_path}' + } + + # Verify zip integrity + with zipfile.ZipFile(backup_path, 'r') as zipf: + # Test zip file integrity + bad_file = zipf.testzip() + if bad_file: + return { + 'verified': False, + 'error': f'Corrupted file in backup: {bad_file}' + } + + # Verify metadata exists and is valid JSON + if 'backup_metadata.json' not in zipf.namelist(): + return { + 'verified': False, + 'error': 'Missing backup_metadata.json' + } + + metadata_str = zipf.read('backup_metadata.json').decode('utf-8') + import json + metadata = json.loads(metadata_str) + + # Verify expected fields + required_fields = ['version', 'backup_id', 'timestamp', 'files'] + for field in required_fields: + if field not in metadata: + return { + 'verified': False, + 'error': f'Missing required field: {field}' + } + + # Verify all listed files exist in zip + for file_info in metadata['files']: + file_path = file_info['path'] + if file_path not in zipf.namelist(): + return { + 'verified': False, + 'error': f'Missing file in backup: {file_path}' + } + + return { + 'verified': True, + 'backup_id': metadata['backup_id'], + 'files_count': len(metadata['files']), + 'timestamp': metadata['timestamp'] + } + + except zipfile.BadZipFile: + return { + 'verified': False, + 'error': 'Invalid or corrupted zip file' + } + except json.JSONDecodeError: + return { + 'verified': False, + 'error': 'Invalid JSON in metadata' + } + except Exception as e: + return { + 'verified': False, + 'error': str(e) + } + + def cleanup_old_backups(self) -> Dict[str, Any]: + """ + Delete backups older than retention_days. + + Returns: + Dict with cleanup results + """ + try: + cutoff_date = datetime.now(timezone.utc) - timedelta(days=self.retention_days) + deleted_count = 0 + freed_bytes = 0 + + # Get all backups + backups = self.backup_manager.list_backups(limit=1000) + + for backup in backups: + # Parse timestamp + try: + backup_time = datetime.fromisoformat(backup['timestamp']) + if backup_time < cutoff_date: + # Delete old backup + if self.backup_manager.delete_backup(backup['filename']): + deleted_count += 1 + freed_bytes += backup['size'] + except Exception: + # Skip backups with invalid timestamps + continue + + return { + 'success': True, + 'deleted_count': deleted_count, + 'freed_bytes': freed_bytes, + 'freed_human': self._human_size(freed_bytes), + 'retention_days': self.retention_days + } + + except Exception as e: + return { + 'success': False, + 'error': str(e) + } + + def _update_backup_verification(self, backup_file: str, verified: bool, error: Optional[str] = None): + """ + Update backup metadata with verification status. + + Args: + backup_file: Backup filename + verified: Whether backup was verified successfully + error: Optional error message + """ + try: + import json + + if not os.path.isabs(backup_file): + backup_path = self.backup_manager.backup_dir / backup_file + else: + backup_path = Path(backup_file) + + if not backup_path.exists(): + return + + # Read existing backup + temp_dir = tempfile.mkdtemp() + temp_zip = Path(temp_dir) / 'temp.zip' + + # Extract and update metadata + with zipfile.ZipFile(backup_path, 'r') as zipf: + metadata_str = zipf.read('backup_metadata.json').decode('utf-8') + metadata = json.loads(metadata_str) + + # Add verification info + metadata['verification'] = { + 'verified': verified, + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'error': error + } + + # Create new zip with updated metadata + with zipfile.ZipFile(temp_zip, 'w', zipfile.ZIP_DEFLATED) as new_zipf: + # Copy all files except metadata + for item in zipf.namelist(): + if item != 'backup_metadata.json': + data = zipf.read(item) + new_zipf.writestr(item, data) + + # Write updated metadata + new_zipf.writestr('backup_metadata.json', json.dumps(metadata, indent=2)) + + # Replace original with updated version + temp_zip.replace(backup_path) + + # Cleanup temp directory + import shutil + shutil.rmtree(temp_dir) + + except Exception: + # Don't fail if we can't update metadata + pass + + def _human_size(self, size_bytes: int) -> str: + """Convert bytes to human-readable size.""" + for unit in ['B', 'KB', 'MB', 'GB']: + if size_bytes < 1024.0: + return f"{size_bytes:.1f} {unit}" + size_bytes /= 1024.0 + return f"{size_bytes:.1f} TB" + + def get_next_backup_time(self) -> Optional[str]: + """Get the next scheduled backup time as ISO string.""" + if not self._running: + return None + + try: + job = self.scheduler.get_job('daily_backup') + if job and job.next_run_time: + return job.next_run_time.isoformat() + except Exception: + pass + + return None + + def update_settings(self, settings: Dict[str, Any]) -> bool: + """ + Update backup settings and reschedule if needed. + + Args: + settings: Dict of settings to update (schedule_hour, schedule_minute, retention_days, etc.) + + Returns: + True if settings were updated successfully + """ + import sqlite3 + + try: + db = sqlite3.connect(self.settings_db_path) + db.execute('PRAGMA journal_mode=WAL;') + + # Update database + for key, value in settings.items(): + db.execute( + 'INSERT OR REPLACE INTO backup_settings (key, value, updated_at) VALUES (?, ?, CURRENT_TIMESTAMP)', + (key, str(value)) + ) + + db.commit() + db.close() + + # Reload settings into memory + self.reload_settings() + + # Reschedule if scheduler is running + if self._running: + # Remove existing job + try: + self.scheduler.remove_job('daily_backup') + except Exception: + pass + + # Re-add job with new schedule + if self.schedule_enabled: + self.scheduler.add_job( + self._run_scheduled_backup, + CronTrigger(hour=self.schedule_hour, minute=self.schedule_minute), + id='daily_backup', + replace_existing=True, + name='Daily Backup' + ) + + return True + except Exception: + return False + + def get_settings(self) -> Dict[str, Any]: + """Get current backup settings.""" + return { + 'schedule_enabled': self.schedule_enabled, + 'schedule_hour': self.schedule_hour, + 'schedule_minute': self.schedule_minute, + 'retention_days': self.retention_days, + 'verify_backups': self.verify_backups + } + + +def get_backup_scheduler( + backup_manager: BackupManager, + settings_db_path: str = 'scidk_settings.db', + alert_manager=None +) -> BackupScheduler: + """ + Get or create a BackupScheduler instance. + + Args: + backup_manager: BackupManager instance + settings_db_path: Path to settings database + alert_manager: Optional AlertManager for notifications + + Returns: + BackupScheduler instance + """ + return BackupScheduler( + backup_manager=backup_manager, + settings_db_path=settings_db_path, + alert_manager=alert_manager + ) diff --git a/scidk/core/label_endpoint_registry.py b/scidk/core/label_endpoint_registry.py new file mode 100644 index 0000000..99922e4 --- /dev/null +++ b/scidk/core/label_endpoint_registry.py @@ -0,0 +1,151 @@ +"""Label Endpoint Registry for plugin-registered API endpoints. + +This registry allows plugins to register API endpoints that map to Label types. +Registered endpoints appear in the Integrations settings page and can be: +- Configured (auth, URL parameters) +- Tested (test connection button) +- Used in integration workflows + +Example plugin registration: + def register_plugin(app): + registry = app.extensions['scidk']['label_endpoints'] + registry.register({ + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabService', + 'auth_required': True, + 'test_url': '/api/integrations/ilab/test', + 'plugin': 'ilab_plugin', + 'description': 'Integration with iLab service management system' + }) +""" + +import logging +from typing import Dict, List, Optional + +logger = logging.getLogger(__name__) + + +class LabelEndpointRegistry: + """Registry for plugin-registered label endpoints.""" + + def __init__(self): + """Initialize the registry.""" + self.endpoints: Dict[str, dict] = {} + logger.info("Label endpoint registry initialized") + + def register(self, endpoint_config: dict) -> bool: + """Register a label endpoint from a plugin. + + Args: + endpoint_config: Endpoint configuration dict with required fields: + - name: Display name (e.g., "iLab Services") + - endpoint: API endpoint path (e.g., "/api/integrations/ilab") + - label_type: Target label type in schema (e.g., "iLabService") + Optional fields: + - auth_required: Whether authentication is required (default: False) + - test_url: URL for testing connection (default: None) + - plugin: Plugin name that registered this endpoint + - description: Human-readable description + - config_schema: JSON schema for configuration options + + Returns: + bool: True if registration successful, False otherwise + """ + # Validate required fields + required_fields = ['name', 'endpoint', 'label_type'] + for field in required_fields: + if field not in endpoint_config: + logger.error(f"Label endpoint registration missing required field: {field}") + return False + + endpoint_path = endpoint_config['endpoint'] + + # Check for duplicate registration + if endpoint_path in self.endpoints: + logger.warning(f"Label endpoint {endpoint_path} already registered, overwriting") + + # Store endpoint config with defaults + self.endpoints[endpoint_path] = { + 'name': endpoint_config['name'], + 'endpoint': endpoint_path, + 'label_type': endpoint_config['label_type'], + 'auth_required': endpoint_config.get('auth_required', False), + 'test_url': endpoint_config.get('test_url'), + 'plugin': endpoint_config.get('plugin', 'unknown'), + 'description': endpoint_config.get('description', ''), + 'config_schema': endpoint_config.get('config_schema', {}), + 'source': 'plugin' # Mark as plugin-registered vs manually configured + } + + logger.info(f"Registered label endpoint: {endpoint_path} ({endpoint_config['name']}) " + f"-> {endpoint_config['label_type']}") + return True + + def unregister(self, endpoint_path: str) -> bool: + """Unregister a label endpoint. + + Args: + endpoint_path: The endpoint path to unregister + + Returns: + bool: True if unregistered, False if not found + """ + if endpoint_path in self.endpoints: + endpoint_name = self.endpoints[endpoint_path]['name'] + del self.endpoints[endpoint_path] + logger.info(f"Unregistered label endpoint: {endpoint_path} ({endpoint_name})") + return True + return False + + def get_endpoint(self, endpoint_path: str) -> Optional[dict]: + """Get a registered endpoint by path. + + Args: + endpoint_path: The endpoint path + + Returns: + Endpoint config dict, or None if not found + """ + return self.endpoints.get(endpoint_path) + + def list_endpoints(self) -> List[dict]: + """List all registered label endpoints. + + Returns: + List of endpoint config dicts + """ + return list(self.endpoints.values()) + + def list_by_plugin(self, plugin_name: str) -> List[dict]: + """List endpoints registered by a specific plugin. + + Args: + plugin_name: Name of the plugin + + Returns: + List of endpoint config dicts + """ + return [ + endpoint for endpoint in self.endpoints.values() + if endpoint.get('plugin') == plugin_name + ] + + def list_by_label_type(self, label_type: str) -> List[dict]: + """List endpoints that map to a specific label type. + + Args: + label_type: Label type name + + Returns: + List of endpoint config dicts + """ + return [ + endpoint for endpoint in self.endpoints.values() + if endpoint['label_type'] == label_type + ] + + def clear(self): + """Clear all registered endpoints (useful for testing).""" + self.endpoints.clear() + logger.info("Cleared all label endpoints") diff --git a/scidk/core/logging_config.py b/scidk/core/logging_config.py new file mode 100644 index 0000000..675c00e --- /dev/null +++ b/scidk/core/logging_config.py @@ -0,0 +1,59 @@ +"""Centralized logging configuration for SciDK. + +Provides structured logging with rotation to prevent disk exhaustion. +""" +import logging +import logging.handlers +import os +from pathlib import Path + + +def setup_logging(log_dir: str = 'logs', log_level: str = 'INFO'): + """Configure structured logging for SciDK. + + Args: + log_dir: Directory to store log files (default: 'logs') + log_level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL) + + Returns: + Configured logger instance + """ + log_path = Path(log_dir) + log_path.mkdir(exist_ok=True) + + # Get configuration from environment with defaults + max_size_mb = int(os.environ.get('SCIDK_LOG_MAX_SIZE_MB', '50')) + backup_count = int(os.environ.get('SCIDK_LOG_BACKUP_COUNT', '10')) + + # Rotating file handler (prevents unbounded growth) + handler = logging.handlers.RotatingFileHandler( + log_path / 'scidk.log', + maxBytes=max_size_mb * 1024 * 1024, # Convert MB to bytes + backupCount=backup_count + ) + + # Structured format: [TIMESTAMP] [LEVEL] [SOURCE] MESSAGE + formatter = logging.Formatter( + '[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s', + datefmt='%Y-%m-%d %H:%M:%S' + ) + handler.setFormatter(formatter) + + # Configure root logger + logger = logging.getLogger() + logger.setLevel(getattr(logging, log_level.upper(), logging.INFO)) + + # Clear existing handlers to avoid duplicates + logger.handlers.clear() + + # Add file handler + logger.addHandler(handler) + + # Also log to console for development/debugging + console = logging.StreamHandler() + console.setFormatter(formatter) + logger.addHandler(console) + + logger.info(f"Logging configured: level={log_level}, dir={log_dir}, max_size={max_size_mb}MB, backups={backup_count}") + + return logger diff --git a/scidk/core/migrations.py b/scidk/core/migrations.py index 257153c..4d07385 100644 --- a/scidk/core/migrations.py +++ b/scidk/core/migrations.py @@ -409,6 +409,60 @@ def migrate(conn: Optional[sqlite3.Connection] = None) -> int: _set_version(conn, 10) version = 10 + # v11: Add plugin_settings table for per-plugin configuration + if version < 11: + cur.execute( + """ + CREATE TABLE IF NOT EXISTS plugin_settings ( + plugin_name TEXT NOT NULL, + key TEXT NOT NULL, + value TEXT, + encrypted INTEGER DEFAULT 0, + updated_at REAL NOT NULL, + PRIMARY KEY (plugin_name, key) + ); + """ + ) + cur.execute("CREATE INDEX IF NOT EXISTS idx_plugin_settings_name ON plugin_settings(plugin_name);") + + conn.commit() + _set_version(conn, 11) + version = 11 + + # v12: Add plugin-label integration columns + if version < 12: + # Extend label_definitions with source tracking + try: + cur.execute("ALTER TABLE label_definitions ADD COLUMN source_type TEXT DEFAULT 'manual'") + except sqlite3.OperationalError: + # Column may already exist + pass + + try: + cur.execute("ALTER TABLE label_definitions ADD COLUMN source_id TEXT") + except sqlite3.OperationalError: + pass + + try: + cur.execute("ALTER TABLE label_definitions ADD COLUMN sync_config TEXT") + except sqlite3.OperationalError: + pass + + # Extend plugin_instances with graph integration + try: + cur.execute("ALTER TABLE plugin_instances ADD COLUMN published_label TEXT") + except sqlite3.OperationalError: + pass + + try: + cur.execute("ALTER TABLE plugin_instances ADD COLUMN graph_config TEXT") + except sqlite3.OperationalError: + pass + + conn.commit() + _set_version(conn, 12) + version = 12 + return version finally: if own: diff --git a/scidk/core/plugin_instance_manager.py b/scidk/core/plugin_instance_manager.py new file mode 100644 index 0000000..782eadf --- /dev/null +++ b/scidk/core/plugin_instance_manager.py @@ -0,0 +1,505 @@ +"""Plugin Instance Manager for user-created plugin instances. + +Manages plugin instances (user configurations) stored in SQLite. Each instance +is based on a template and contains user-specific configuration. + +Example: + Instance: "iLab Equipment 2024" + - Template: "table_loader" + - Config: {file_path: "/data/equipment.xlsx", table_name: "ilab_equipment_2024"} + - Status: active + - Last run: 2 hours ago +""" + +import sqlite3 +import json +import logging +import time +import uuid +from typing import Dict, List, Optional +from pathlib import Path + +logger = logging.getLogger(__name__) + + +class PluginInstanceManager: + """Manages user-created plugin instances stored in SQLite.""" + + def __init__(self, db_path: str = 'scidk_settings.db'): + """Initialize the plugin instance manager. + + Args: + db_path: Path to SQLite database file + """ + self.db_path = db_path + self._init_db() + logger.info(f"Plugin instance manager initialized (db: {db_path})") + + def _init_db(self): + """Initialize database schema for plugin instances.""" + conn = sqlite3.connect(self.db_path) + cursor = conn.cursor() + + cursor.execute(''' + CREATE TABLE IF NOT EXISTS plugin_instances ( + id TEXT PRIMARY KEY, + name TEXT NOT NULL, + template_id TEXT NOT NULL, + config TEXT NOT NULL, + enabled INTEGER DEFAULT 1, + status TEXT, + last_run REAL, + last_result TEXT, + created_at REAL NOT NULL, + updated_at REAL NOT NULL + ) + ''') + + conn.commit() + conn.close() + + def _get_connection(self) -> sqlite3.Connection: + """Get a database connection.""" + conn = sqlite3.connect(self.db_path) + conn.row_factory = sqlite3.Row + return conn + + def create_instance(self, template_id: str, name: str, config: dict) -> str: + """Create a new plugin instance. + + Args: + template_id: ID of the template to instantiate + name: User-friendly name for the instance + config: Instance configuration (JSON-serializable dict) + + Returns: + str: The created instance ID + + Raises: + ValueError: If instance with same name already exists + """ + # Check for duplicate name + existing = self.get_instance_by_name(name) + if existing: + raise ValueError(f"Instance with name '{name}' already exists") + + instance_id = str(uuid.uuid4()) + now = time.time() + + conn = self._get_connection() + cursor = conn.cursor() + + cursor.execute(''' + INSERT INTO plugin_instances + (id, name, template_id, config, enabled, status, created_at, updated_at) + VALUES (?, ?, ?, ?, 1, 'pending', ?, ?) + ''', (instance_id, name, template_id, json.dumps(config), now, now)) + + conn.commit() + conn.close() + + logger.info(f"Created plugin instance: {instance_id} ({name}) using template {template_id}") + return instance_id + + def get_instance(self, instance_id: str) -> Optional[dict]: + """Get a plugin instance by ID. + + Args: + instance_id: The instance ID + + Returns: + dict: Instance data, or None if not found + """ + conn = self._get_connection() + cursor = conn.cursor() + + cursor.execute('SELECT * FROM plugin_instances WHERE id = ?', (instance_id,)) + row = cursor.fetchone() + conn.close() + + if row: + return self._row_to_dict(row) + return None + + def get_instance_by_name(self, name: str) -> Optional[dict]: + """Get a plugin instance by name. + + Args: + name: The instance name + + Returns: + dict: Instance data, or None if not found + """ + conn = self._get_connection() + cursor = conn.cursor() + + cursor.execute('SELECT * FROM plugin_instances WHERE name = ?', (name,)) + row = cursor.fetchone() + conn.close() + + if row: + return self._row_to_dict(row) + return None + + def list_instances(self, template_id: Optional[str] = None, enabled_only: bool = False) -> List[dict]: + """List all plugin instances, optionally filtered. + + Args: + template_id: Optional template ID filter + enabled_only: If True, only return enabled instances + + Returns: + List of instance dicts + """ + conn = self._get_connection() + cursor = conn.cursor() + + query = 'SELECT * FROM plugin_instances WHERE 1=1' + params = [] + + if template_id: + query += ' AND template_id = ?' + params.append(template_id) + + if enabled_only: + query += ' AND enabled = 1' + + query += ' ORDER BY created_at DESC' + + cursor.execute(query, params) + rows = cursor.fetchall() + conn.close() + + return [self._row_to_dict(row) for row in rows] + + def update_instance(self, instance_id: str, name: Optional[str] = None, + config: Optional[dict] = None, enabled: Optional[bool] = None) -> bool: + """Update a plugin instance. + + Args: + instance_id: The instance ID + name: Optional new name + config: Optional new config + enabled: Optional new enabled status + + Returns: + bool: True if updated, False if not found + """ + instance = self.get_instance(instance_id) + if not instance: + return False + + updates = [] + params = [] + + if name is not None: + updates.append('name = ?') + params.append(name) + + if config is not None: + updates.append('config = ?') + params.append(json.dumps(config)) + + if enabled is not None: + updates.append('enabled = ?') + params.append(1 if enabled else 0) + updates.append('status = ?') + params.append('active' if enabled else 'inactive') + + if not updates: + return True # Nothing to update + + updates.append('updated_at = ?') + params.append(time.time()) + + params.append(instance_id) + + conn = self._get_connection() + cursor = conn.cursor() + + query = f"UPDATE plugin_instances SET {', '.join(updates)} WHERE id = ?" + cursor.execute(query, params) + + conn.commit() + conn.close() + + logger.info(f"Updated plugin instance: {instance_id}") + return True + + def delete_instance(self, instance_id: str) -> bool: + """Delete a plugin instance. + + Args: + instance_id: The instance ID + + Returns: + bool: True if deleted, False if not found + """ + instance = self.get_instance(instance_id) + if not instance: + return False + + conn = self._get_connection() + cursor = conn.cursor() + + cursor.execute('DELETE FROM plugin_instances WHERE id = ?', (instance_id,)) + + conn.commit() + conn.close() + + logger.info(f"Deleted plugin instance: {instance_id} ({instance['name']})") + return True + + def record_execution(self, instance_id: str, result: dict, status: str = 'active') -> bool: + """Record the result of an instance execution. + + Args: + instance_id: The instance ID + result: Execution result (JSON-serializable dict) + status: New status ('active', 'error', etc.) + + Returns: + bool: True if recorded, False if instance not found + """ + instance = self.get_instance(instance_id) + if not instance: + return False + + conn = self._get_connection() + cursor = conn.cursor() + + cursor.execute(''' + UPDATE plugin_instances + SET last_run = ?, last_result = ?, status = ?, updated_at = ? + WHERE id = ? + ''', (time.time(), json.dumps(result), status, time.time(), instance_id)) + + conn.commit() + conn.close() + + logger.info(f"Recorded execution for instance: {instance_id} (status: {status})") + return True + + def _row_to_dict(self, row: sqlite3.Row) -> dict: + """Convert a database row to a dict. + + Args: + row: SQLite row object + + Returns: + dict: Instance data with parsed JSON fields + """ + result = { + 'id': row['id'], + 'name': row['name'], + 'template_id': row['template_id'], + 'config': json.loads(row['config']) if row['config'] else {}, + 'enabled': bool(row['enabled']), + 'status': row['status'], + 'last_run': row['last_run'], + 'last_result': json.loads(row['last_result']) if row['last_result'] else None, + 'created_at': row['created_at'], + 'updated_at': row['updated_at'] + } + + # Add new columns if they exist + try: + result['published_label'] = row['published_label'] + result['graph_config'] = json.loads(row['graph_config']) if row['graph_config'] else None + except (KeyError, IndexError): + # Columns don't exist yet (pre-migration) + result['published_label'] = None + result['graph_config'] = None + + return result + + def get_stats(self) -> dict: + """Get statistics about plugin instances. + + Returns: + dict: Statistics including counts by status, template, etc. + """ + conn = self._get_connection() + cursor = conn.cursor() + + # Total count + cursor.execute('SELECT COUNT(*) as total FROM plugin_instances') + total = cursor.fetchone()['total'] + + # Count by status + cursor.execute('SELECT status, COUNT(*) as count FROM plugin_instances GROUP BY status') + by_status = {row['status']: row['count'] for row in cursor.fetchall()} + + # Count by template + cursor.execute('SELECT template_id, COUNT(*) as count FROM plugin_instances GROUP BY template_id') + by_template = {row['template_id']: row['count'] for row in cursor.fetchall()} + + conn.close() + + return { + 'total': total, + 'by_status': by_status, + 'by_template': by_template + } + + def publish_label_schema(self, instance_id: str, label_config: dict, app=None) -> bool: + """Publish plugin instance schema as a Label. + + Args: + instance_id: Plugin instance ID + label_config: { + "label_name": "LabEquipment", + "primary_key": "serial_number", + "property_mapping": {...}, # Optional, auto-generated if missing + "sync_strategy": "on_demand" + } + app: Flask app instance (optional, for LabelService) + + Returns: + bool: True if published successfully + """ + instance = self.get_instance(instance_id) + if not instance: + logger.error(f"Instance {instance_id} not found") + return False + + label_name = label_config.get('label_name') + if not label_name: + logger.error("Label name is required") + return False + + primary_key = label_config.get('primary_key', 'id') + sync_strategy = label_config.get('sync_strategy', 'on_demand') + property_mapping = label_config.get('property_mapping', {}) + + # Auto-generate property schema from SQLite table if not provided + if not property_mapping: + config = instance['config'] + table_name = config.get('table_name') + if table_name: + property_mapping = self._infer_table_schema(table_name) + + # Convert property_mapping dict to properties list for label service + properties = [] + for prop_name, prop_info in property_mapping.items(): + properties.append({ + 'name': prop_name, + 'type': prop_info.get('type', 'string'), + 'required': prop_info.get('required', False) + }) + + # Create or update label definition + label_def = { + 'name': label_name, + 'properties': properties, + 'relationships': [], # No relationships initially + 'source_type': 'plugin_instance', + 'source_id': instance_id, + 'sync_config': { + 'primary_key': primary_key, + 'sync_strategy': sync_strategy, + 'auto_sync': False, + 'last_sync_at': None, + 'last_sync_count': 0 + } + } + + try: + # Use LabelService to save label + if app: + from ..services.label_service import LabelService + label_service = LabelService(app) + label_service.save_label(label_def) + else: + # Fallback: direct database save using the same database + conn = self._get_connection() + cursor = conn.cursor() + + props_json = json.dumps(properties) + sync_config_json = json.dumps(label_def['sync_config']) + now = time.time() + + # Check if label exists + cursor.execute('SELECT name FROM label_definitions WHERE name = ?', (label_name,)) + exists = cursor.fetchone() + + if exists: + cursor.execute(''' + UPDATE label_definitions + SET properties = ?, source_type = ?, source_id = ?, + sync_config = ?, updated_at = ? + WHERE name = ? + ''', (props_json, 'plugin_instance', instance_id, sync_config_json, now, label_name)) + else: + cursor.execute(''' + INSERT INTO label_definitions + (name, properties, relationships, source_type, source_id, sync_config, created_at, updated_at) + VALUES (?, ?, '[]', ?, ?, ?, ?, ?) + ''', (label_name, props_json, 'plugin_instance', instance_id, sync_config_json, now, now)) + + conn.commit() + conn.close() + + # Update instance with published label + conn = self._get_connection() + cursor = conn.cursor() + cursor.execute(''' + UPDATE plugin_instances + SET published_label = ?, graph_config = ?, updated_at = ? + WHERE id = ? + ''', (label_name, json.dumps(label_config), time.time(), instance_id)) + conn.commit() + conn.close() + + logger.info(f"Published label '{label_name}' from instance {instance_id}") + return True + + except Exception as e: + logger.error(f"Error publishing label: {e}", exc_info=True) + return False + + def _infer_table_schema(self, table_name: str) -> dict: + """Infer property schema from SQLite table structure. + + Args: + table_name: SQLite table name + + Returns: + dict: Property mapping {column_name: {type, required}} + """ + conn = self._get_connection() + cursor = conn.cursor() + + try: + # Get table schema + cursor.execute(f"PRAGMA table_info({table_name})") + columns = cursor.fetchall() + + property_mapping = {} + for col in columns: + col_name = col[1] if isinstance(col, tuple) else col['name'] + col_type = (col[2] if isinstance(col, tuple) else col['type']).lower() + not_null = col[3] if isinstance(col, tuple) else col['notnull'] + + # Map SQLite types to schema types + if 'int' in col_type: + prop_type = 'integer' + elif 'real' in col_type or 'float' in col_type or 'double' in col_type: + prop_type = 'number' + elif 'bool' in col_type: + prop_type = 'boolean' + else: + prop_type = 'string' + + property_mapping[col_name] = { + 'type': prop_type, + 'required': bool(not_null) + } + + return property_mapping + + except Exception as e: + logger.error(f"Error inferring schema for table {table_name}: {e}") + return {} + finally: + conn.close() diff --git a/scidk/core/plugin_loader.py b/scidk/core/plugin_loader.py new file mode 100644 index 0000000..9ad282f --- /dev/null +++ b/scidk/core/plugin_loader.py @@ -0,0 +1,256 @@ +"""Plugin loader for SciDK. + +Discovers and registers plugins from the plugins/ directory. +Each plugin is a Python package that implements a register_plugin(app) function. + +Plugin Structure: + plugins/ + my_plugin/ + __init__.py # Contains register_plugin(app) function + routes.py # Optional: Flask blueprint with routes + labels.py # Optional: Label definitions + settings.html # Optional: Settings UI template + +Plugin Registration: + def register_plugin(app): + '''Register plugin with the Flask app. + + Args: + app: Flask application instance + + Returns: + dict: Plugin metadata with name, version, author, description + ''' + # Register routes, labels, etc. + # Example: Register blueprint + # from . import routes + # app.register_blueprint(routes.bp) + + # Example: Register label endpoint + # registry = app.extensions['scidk']['label_endpoints'] + # registry.register({ + # 'name': 'iLab Services', + # 'endpoint': '/api/integrations/ilab', + # 'label_type': 'iLabService', + # 'auth_required': True, + # 'test_url': '/api/integrations/ilab/test', + # 'plugin': 'ilab_plugin', + # 'description': 'Integration with iLab services' + # }) + + return { + 'name': 'My Plugin', + 'version': '1.0.0', + 'author': 'Author Name', + 'description': 'Plugin description' + } +""" + +import importlib +import logging +from pathlib import Path +from typing import Dict, List, Optional + +logger = logging.getLogger(__name__) + + +class PluginLoader: + """Loads and manages plugins for the SciDK application.""" + + def __init__(self, plugins_dir: str = 'plugins'): + """Initialize the plugin loader. + + Args: + plugins_dir: Directory containing plugins (relative to project root) + """ + self.plugins_dir = Path(plugins_dir) + self.loaded_plugins: Dict[str, dict] = {} + self.failed_plugins: Dict[str, str] = {} + + def discover_plugins(self) -> List[str]: + """Find all plugins in the plugins/ directory. + + Returns: + List of plugin names (directory names) + """ + if not self.plugins_dir.exists(): + logger.info(f"Plugins directory {self.plugins_dir} does not exist") + return [] + + plugins = [] + for plugin_path in self.plugins_dir.iterdir(): + if plugin_path.is_dir() and (plugin_path / '__init__.py').exists(): + # Exclude __pycache__ and hidden directories + if not plugin_path.name.startswith('_') and not plugin_path.name.startswith('.'): + plugins.append(plugin_path.name) + + logger.info(f"Discovered {len(plugins)} plugins: {plugins}") + return plugins + + def load_plugin(self, plugin_name: str, app, enabled: bool = True) -> bool: + """Load and register a plugin. + + Args: + plugin_name: Name of the plugin (directory name) + app: Flask application instance + enabled: Whether the plugin is enabled + + Returns: + bool: True if plugin loaded successfully, False otherwise + """ + if not enabled: + logger.info(f"Plugin {plugin_name} is disabled, skipping load") + self.loaded_plugins[plugin_name] = { + 'name': plugin_name, + 'enabled': False, + 'status': 'disabled' + } + return True + + try: + # Import the plugin module + # Try to import from plugins package first, then try direct import (for testing) + try: + module = importlib.import_module(f'plugins.{plugin_name}') + except ModuleNotFoundError: + # Try direct import (for testing with custom paths in sys.path) + module = importlib.import_module(plugin_name) + + # Check if plugin has register_plugin function + if not hasattr(module, 'register_plugin'): + error_msg = f"Plugin {plugin_name} missing register_plugin() function" + logger.error(error_msg) + self.failed_plugins[plugin_name] = error_msg + return False + + # Call the registration function + metadata = module.register_plugin(app) + + # Validate metadata + if not isinstance(metadata, dict): + error_msg = f"Plugin {plugin_name} register_plugin() must return a dict" + logger.error(error_msg) + self.failed_plugins[plugin_name] = error_msg + return False + + # Store plugin info + self.loaded_plugins[plugin_name] = { + 'name': metadata.get('name', plugin_name), + 'version': metadata.get('version', '0.0.0'), + 'author': metadata.get('author', 'Unknown'), + 'description': metadata.get('description', ''), + 'enabled': True, + 'status': 'loaded', + 'module_name': plugin_name + } + + logger.info(f"Successfully loaded plugin: {plugin_name} v{metadata.get('version', '0.0.0')}") + return True + + except Exception as e: + error_msg = f"Failed to load plugin {plugin_name}: {str(e)}" + logger.error(error_msg, exc_info=True) + self.failed_plugins[plugin_name] = error_msg + return False + + def load_all_plugins(self, app, enabled_plugins: Optional[List[str]] = None): + """Discover and load all plugins. + + Args: + app: Flask application instance + enabled_plugins: Optional list of enabled plugin names. + If None, all plugins are enabled by default. + """ + plugins = self.discover_plugins() + + for plugin_name in plugins: + enabled = True + if enabled_plugins is not None: + enabled = plugin_name in enabled_plugins + + self.load_plugin(plugin_name, app, enabled=enabled) + + def get_plugin_info(self, plugin_name: str) -> Optional[dict]: + """Get information about a loaded plugin. + + Args: + plugin_name: Name of the plugin + + Returns: + Plugin metadata dict, or None if not loaded + """ + return self.loaded_plugins.get(plugin_name) + + def list_plugins(self) -> List[dict]: + """List all loaded plugins. + + Returns: + List of plugin metadata dicts + """ + return list(self.loaded_plugins.values()) + + def list_failed_plugins(self) -> Dict[str, str]: + """List plugins that failed to load. + + Returns: + Dict mapping plugin name to error message + """ + return self.failed_plugins.copy() + + +def get_plugin_enabled_state(plugin_name: str) -> bool: + """Check if a plugin is enabled in the database. + + Args: + plugin_name: Name of the plugin + + Returns: + bool: True if enabled (default), False if disabled + """ + try: + from .settings import get_setting + return get_setting(f'plugin.{plugin_name}.enabled', 'true') == 'true' + except Exception as e: + logger.warning(f"Failed to get plugin enabled state for {plugin_name}: {e}") + return True # Default to enabled + + +def set_plugin_enabled_state(plugin_name: str, enabled: bool) -> bool: + """Set whether a plugin is enabled. + + Args: + plugin_name: Name of the plugin + enabled: Whether to enable the plugin + + Returns: + bool: True if successful + """ + try: + from .settings import set_setting + set_setting(f'plugin.{plugin_name}.enabled', 'true' if enabled else 'false') + return True + except Exception as e: + logger.error(f"Failed to set plugin enabled state for {plugin_name}: {e}") + return False + + +def get_all_plugin_states() -> Dict[str, bool]: + """Get the enabled state for all plugins from database. + + Returns: + Dict mapping plugin name to enabled state + """ + plugin_states = {} + try: + from .settings import get_settings_by_prefix + settings = get_settings_by_prefix('plugin.') + + for key, value in settings.items(): + if key.endswith('.enabled'): + # Extract plugin name from key like "plugin.my_plugin.enabled" + plugin_name = key[7:-8] # Remove "plugin." and ".enabled" + plugin_states[plugin_name] = (value == 'true') + except Exception as e: + logger.warning(f"Failed to get plugin states: {e}") + + return plugin_states diff --git a/scidk/core/plugin_settings.py b/scidk/core/plugin_settings.py new file mode 100644 index 0000000..12cb502 --- /dev/null +++ b/scidk/core/plugin_settings.py @@ -0,0 +1,286 @@ +"""Plugin settings management. + +Provides functionality for plugins to define and store configuration settings. +Settings can be encrypted (for sensitive data like API keys) and are stored in the database. +""" + +import json +import sqlite3 +import logging +from typing import Dict, Any, Optional, List +from datetime import datetime +from pathlib import Path +import os + +logger = logging.getLogger(__name__) + + +def _get_db_path() -> str: + """Get path to settings database.""" + return os.environ.get('SCIDK_DB_PATH', os.path.join(os.getcwd(), 'scidk.db')) + + +def _encrypt_value(value: str) -> str: + """Encrypt a sensitive value. + + TODO: Implement proper encryption. For now, this is a placeholder. + In production, use cryptography library with a proper key management system. + + Args: + value: Plain text value to encrypt + + Returns: + Encrypted value (currently just base64 encoded as placeholder) + """ + import base64 + return base64.b64encode(value.encode()).decode() + + +def _decrypt_value(encrypted: str) -> str: + """Decrypt a sensitive value. + + TODO: Implement proper decryption matching _encrypt_value. + + Args: + encrypted: Encrypted value + + Returns: + Plain text value + """ + import base64 + return base64.b64decode(encrypted.encode()).decode() + + +def get_plugin_setting(plugin_name: str, key: str, default: Any = None) -> Any: + """Get a plugin setting value. + + Args: + plugin_name: Name of the plugin + key: Setting key + default: Default value if not found + + Returns: + Setting value (automatically decrypted if encrypted), or default if not found + """ + try: + db_path = _get_db_path() + conn = sqlite3.connect(db_path) + cur = conn.execute( + "SELECT value, encrypted FROM plugin_settings WHERE plugin_name = ? AND key = ?", + (plugin_name, key) + ) + row = cur.fetchone() + conn.close() + + if row is None: + return default + + value, encrypted = row + if encrypted: + value = _decrypt_value(value) + + # Try to parse as JSON for complex types + try: + return json.loads(value) + except (json.JSONDecodeError, TypeError): + return value + + except Exception as e: + logger.error(f"Error getting plugin setting {plugin_name}.{key}: {e}") + return default + + +def set_plugin_setting(plugin_name: str, key: str, value: Any, encrypted: bool = False): + """Set a plugin setting value. + + Args: + plugin_name: Name of the plugin + key: Setting key + value: Setting value (will be JSON serialized) + encrypted: Whether to encrypt the value (for sensitive data) + """ + try: + db_path = _get_db_path() + conn = sqlite3.connect(db_path) + + # Serialize value to JSON + if isinstance(value, (dict, list)): + value_str = json.dumps(value) + else: + value_str = str(value) + + # Encrypt if needed + if encrypted and value_str: + value_str = _encrypt_value(value_str) + + from datetime import timezone + now = datetime.now(tz=timezone.utc).timestamp() + + conn.execute( + """ + INSERT OR REPLACE INTO plugin_settings + (plugin_name, key, value, encrypted, updated_at) + VALUES (?, ?, ?, ?, ?) + """, + (plugin_name, key, value_str, 1 if encrypted else 0, now) + ) + conn.commit() + conn.close() + + except Exception as e: + logger.error(f"Error setting plugin setting {plugin_name}.{key}: {e}") + raise + + +def get_all_plugin_settings(plugin_name: str, include_encrypted: bool = True) -> Dict[str, Any]: + """Get all settings for a plugin. + + Args: + plugin_name: Name of the plugin + include_encrypted: Whether to include (decrypted) encrypted settings + + Returns: + Dict mapping setting keys to values + """ + try: + db_path = _get_db_path() + conn = sqlite3.connect(db_path) + cur = conn.execute( + "SELECT key, value, encrypted FROM plugin_settings WHERE plugin_name = ?", + (plugin_name,) + ) + + settings = {} + for key, value, encrypted in cur.fetchall(): + if not include_encrypted and encrypted: + continue + + if encrypted: + value = _decrypt_value(value) + + # Try to parse as JSON + try: + settings[key] = json.loads(value) + except (json.JSONDecodeError, TypeError): + settings[key] = value + + conn.close() + return settings + + except Exception as e: + logger.error(f"Error getting plugin settings for {plugin_name}: {e}") + return {} + + +def delete_plugin_setting(plugin_name: str, key: str): + """Delete a plugin setting. + + Args: + plugin_name: Name of the plugin + key: Setting key + """ + try: + db_path = _get_db_path() + conn = sqlite3.connect(db_path) + conn.execute( + "DELETE FROM plugin_settings WHERE plugin_name = ? AND key = ?", + (plugin_name, key) + ) + conn.commit() + conn.close() + + except Exception as e: + logger.error(f"Error deleting plugin setting {plugin_name}.{key}: {e}") + raise + + +def delete_all_plugin_settings(plugin_name: str): + """Delete all settings for a plugin. + + Args: + plugin_name: Name of the plugin + """ + try: + db_path = _get_db_path() + conn = sqlite3.connect(db_path) + conn.execute( + "DELETE FROM plugin_settings WHERE plugin_name = ?", + (plugin_name,) + ) + conn.commit() + conn.close() + + except Exception as e: + logger.error(f"Error deleting plugin settings for {plugin_name}: {e}") + raise + + +def validate_settings_against_schema(settings: Dict[str, Any], schema: Dict[str, Any]) -> tuple[bool, List[str]]: + """Validate plugin settings against a schema. + + Args: + settings: Settings dict to validate + schema: Schema dict defining expected settings + + Returns: + Tuple of (is_valid, list of error messages) + + Schema format: + { + 'api_key': { + 'type': 'password', # text, password, number, boolean, select + 'required': True, + 'description': 'API key for service' + }, + 'endpoint_url': { + 'type': 'text', + 'default': 'https://api.example.com', + 'required': False + } + } + """ + errors = [] + + # Check required fields + for key, field_schema in schema.items(): + if field_schema.get('required', False): + if key not in settings or settings[key] is None or settings[key] == '': + errors.append(f"Required field '{key}' is missing") + + # Check field types + for key, value in settings.items(): + if key not in schema: + continue + + field_type = schema[key].get('type', 'text') + + if field_type == 'number': + try: + float(value) + except (ValueError, TypeError): + errors.append(f"Field '{key}' must be a number") + + elif field_type == 'boolean': + if not isinstance(value, bool) and value not in ['true', 'false', '0', '1']: + errors.append(f"Field '{key}' must be a boolean") + + return len(errors) == 0, errors + + +def apply_schema_defaults(settings: Dict[str, Any], schema: Dict[str, Any]) -> Dict[str, Any]: + """Apply default values from schema to settings. + + Args: + settings: Current settings dict + schema: Schema dict with default values + + Returns: + Settings dict with defaults applied + """ + result = settings.copy() + + for key, field_schema in schema.items(): + if key not in result and 'default' in field_schema: + result[key] = field_schema['default'] + + return result diff --git a/scidk/core/plugin_template_registry.py b/scidk/core/plugin_template_registry.py new file mode 100644 index 0000000..7feb84b --- /dev/null +++ b/scidk/core/plugin_template_registry.py @@ -0,0 +1,176 @@ +"""Plugin Template Registry for managing plugin templates. + +This registry manages plugin templates (code-based definitions) that can be +instantiated multiple times by users via the UI. Distinct from plugin instances +(user-created configs). + +Example: + Template: "Table Loader" (code-based plugin) + Instances: "iLab Equipment 2024", "PI Directory", "Lab Resources Q1" (user configs) +""" + +import logging +from typing import Dict, List, Optional, Callable + +logger = logging.getLogger(__name__) + + +class PluginTemplateRegistry: + """Registry for plugin templates that can be instantiated by users.""" + + # Valid plugin categories + VALID_CATEGORIES = ['data_import', 'graph_inject', 'enrichment', 'exporter'] + + def __init__(self): + """Initialize the template registry.""" + self.templates: Dict[str, dict] = {} + logger.info("Plugin template registry initialized") + + def register(self, template_config: dict) -> bool: + """Register a plugin template. + + Args: + template_config: Template configuration dict with required fields: + - id: Unique template identifier (e.g., "table_loader") + - name: Display name (e.g., "Table Loader") + - description: Human-readable description + - category: Category (data_import, api_fetcher, file_importer, etc.) + - supports_multiple_instances: Boolean, if True users can create multiple instances + - config_schema: JSON schema for instance configuration + - handler: Callable that executes the template logic + Optional fields: + - icon: Emoji or icon for UI display + - preset_configs: Predefined configurations for common use cases + - version: Template version + + Returns: + bool: True if registration successful, False otherwise + """ + # Validate required fields + required_fields = ['id', 'name', 'description', 'handler'] + for field in required_fields: + if field not in template_config: + logger.error(f"Plugin template registration missing required field: {field}") + return False + + template_id = template_config['id'] + + # Check for duplicate registration + if template_id in self.templates: + logger.warning(f"Plugin template {template_id} already registered, overwriting") + + # Validate handler is callable + if not callable(template_config['handler']): + logger.error(f"Plugin template handler for {template_id} is not callable") + return False + + # Validate and set category (default to 'exporter' for backward compatibility) + category = template_config.get('category', 'exporter') + if category not in self.VALID_CATEGORIES: + logger.error(f"Invalid category '{category}' for template {template_id}. " + f"Valid categories: {', '.join(self.VALID_CATEGORIES)}") + return False + + # Validate graph_behavior for data_import category + if category == 'data_import': + graph_behavior = template_config.get('graph_behavior', {}) + required_keys = ['can_create_label', 'label_source'] + if not all(k in graph_behavior for k in required_keys): + logger.warning(f"Template {template_id} with category 'data_import' " + f"missing recommended graph_behavior config keys: {required_keys}") + + # Store template with defaults + self.templates[template_id] = { + 'id': template_id, + 'name': template_config['name'], + 'description': template_config['description'], + 'category': category, + 'supports_multiple_instances': template_config.get('supports_multiple_instances', True), + 'config_schema': template_config.get('config_schema', {}), + 'handler': template_config['handler'], + 'icon': template_config.get('icon', '📦'), + 'preset_configs': template_config.get('preset_configs', {}), + 'version': template_config.get('version', '1.0.0'), + 'graph_behavior': template_config.get('graph_behavior', {}) + } + + logger.info(f"Registered plugin template: {template_id} ({template_config['name']}) [category: {category}]") + return True + + def unregister(self, template_id: str) -> bool: + """Unregister a plugin template. + + Args: + template_id: The template ID to unregister + + Returns: + bool: True if unregistered, False if not found + """ + if template_id in self.templates: + template_name = self.templates[template_id]['name'] + del self.templates[template_id] + logger.info(f"Unregistered plugin template: {template_id} ({template_name})") + return True + return False + + def get_template(self, template_id: str) -> Optional[dict]: + """Get a registered template by ID. + + Args: + template_id: The template ID + + Returns: + Template config dict, or None if not found + """ + return self.templates.get(template_id) + + def list_templates(self, category: Optional[str] = None) -> List[dict]: + """List all registered templates, optionally filtered by category. + + Args: + category: Optional category filter + + Returns: + List of template config dicts (without handler for serialization) + """ + templates = list(self.templates.values()) + + if category: + templates = [t for t in templates if t['category'] == category] + + # Return without handler (not JSON serializable) + return [ + {k: v for k, v in t.items() if k != 'handler'} + for t in templates + ] + + def execute_template(self, template_id: str, instance_config: dict) -> dict: + """Execute a template handler with an instance configuration. + + Args: + template_id: The template ID + instance_config: The instance configuration to pass to the handler + + Returns: + dict: Execution result from the handler + + Raises: + ValueError: If template not found + """ + template = self.get_template(template_id) + if not template: + raise ValueError(f"Template '{template_id}' not found") + + handler = template['handler'] + try: + result = handler(instance_config) + logger.info(f"Executed template {template_id} successfully") + return result + except Exception as e: + logger.error(f"Error executing template {template_id}: {e}") + raise + + def clear(self): + """Clear all registered templates (useful for testing).""" + self.templates.clear() + logger.info("Cleared all plugin templates") diff --git a/scidk/core/settings.py b/scidk/core/settings.py index 9da3c35..2b36f3e 100644 --- a/scidk/core/settings.py +++ b/scidk/core/settings.py @@ -1,7 +1,8 @@ import sqlite3 import json from datetime import datetime -from typing import Set +from typing import Set, Dict, Optional +import os class InterpreterSettings: @@ -28,7 +29,8 @@ def init_tables(self): def save_enabled_interpreters(self, enabled_set: Set[str]): payload = json.dumps(sorted(list(enabled_set))) - now = datetime.utcnow().isoformat() + from datetime import timezone + now = datetime.now(tz=timezone.utc).isoformat() self.db.execute( "INSERT OR REPLACE INTO interpreter_settings(key, value, updated_at) VALUES (?, ?, ?)", ("enabled_interpreters", payload, now), @@ -47,3 +49,87 @@ def load_enabled_interpreters(self) -> Set[str]: except Exception: return set() return set() + + +# Global settings helpers (use same table as InterpreterSettings) +def _get_db_path() -> str: + """Get path to settings database.""" + return os.environ.get('SCIDK_DB_PATH', os.path.join(os.getcwd(), 'scidk.db')) + + +def get_setting(key: str, default: Optional[str] = None) -> Optional[str]: + """Get a setting value from the database. + + Args: + key: Setting key + default: Default value if key not found + + Returns: + Setting value, or default if not found + """ + try: + db_path = _get_db_path() + db = sqlite3.connect(db_path) + cur = db.execute( + "SELECT value FROM interpreter_settings WHERE key = ?", + (key,) + ) + row = cur.fetchone() + db.close() + if row and row[0] is not None: + return row[0] + except Exception: + pass + return default + + +def set_setting(key: str, value: str): + """Set a setting value in the database. + + Args: + key: Setting key + value: Setting value + """ + db_path = _get_db_path() + db = sqlite3.connect(db_path) + # Ensure table exists + db.execute( + """ + CREATE TABLE IF NOT EXISTS interpreter_settings ( + key TEXT PRIMARY KEY, + value TEXT, + updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + ) + """ + ) + from datetime import timezone + now = datetime.now(tz=timezone.utc).isoformat() + db.execute( + "INSERT OR REPLACE INTO interpreter_settings(key, value, updated_at) VALUES (?, ?, ?)", + (key, value, now), + ) + db.commit() + db.close() + + +def get_settings_by_prefix(prefix: str) -> Dict[str, str]: + """Get all settings with a given prefix. + + Args: + prefix: Key prefix to filter by + + Returns: + Dict mapping keys to values + """ + try: + db_path = _get_db_path() + db = sqlite3.connect(db_path) + cur = db.execute( + "SELECT key, value FROM interpreter_settings WHERE key LIKE ?", + (prefix + '%',) + ) + results = {row[0]: row[1] for row in cur.fetchall()} + db.close() + return results + except Exception: + return {} diff --git a/scidk/services/label_service.py b/scidk/services/label_service.py index abce1e8..b9727ee 100644 --- a/scidk/services/label_service.py +++ b/scidk/services/label_service.py @@ -29,14 +29,16 @@ def list_labels(self) -> List[Dict[str, Any]]: Get all label definitions from SQLite. Returns: - List of label definition dicts with keys: name, properties, relationships, created_at, updated_at + List of label definition dicts with keys: name, properties, relationships, created_at, updated_at, + source_type, source_id, sync_config """ conn = self._get_conn() try: cursor = conn.cursor() cursor.execute( """ - SELECT name, properties, relationships, created_at, updated_at + SELECT name, properties, relationships, created_at, updated_at, + source_type, source_id, sync_config FROM label_definitions ORDER BY name """ @@ -45,13 +47,16 @@ def list_labels(self) -> List[Dict[str, Any]]: labels = [] for row in rows: - name, props_json, rels_json, created_at, updated_at = row + name, props_json, rels_json, created_at, updated_at, source_type, source_id, sync_config_json = row labels.append({ 'name': name, 'properties': json.loads(props_json) if props_json else [], 'relationships': json.loads(rels_json) if rels_json else [], 'created_at': created_at, - 'updated_at': updated_at + 'updated_at': updated_at, + 'source_type': source_type or 'manual', + 'source_id': source_id, + 'sync_config': json.loads(sync_config_json) if sync_config_json else {} }) return labels finally: @@ -72,7 +77,8 @@ def get_label(self, name: str) -> Optional[Dict[str, Any]]: cursor = conn.cursor() cursor.execute( """ - SELECT name, properties, relationships, created_at, updated_at + SELECT name, properties, relationships, created_at, updated_at, + source_type, source_id, sync_config FROM label_definitions WHERE name = ? """, @@ -83,7 +89,7 @@ def get_label(self, name: str) -> Optional[Dict[str, Any]]: if not row: return None - name, props_json, rels_json, created_at, updated_at = row + name, props_json, rels_json, created_at, updated_at, source_type, source_id, sync_config_json = row # Get outgoing relationships (defined on this label) relationships = json.loads(rels_json) if rels_json else [] @@ -116,7 +122,10 @@ def get_label(self, name: str) -> Optional[Dict[str, Any]]: 'relationships': relationships, 'incoming_relationships': incoming_relationships, 'created_at': created_at, - 'updated_at': updated_at + 'updated_at': updated_at, + 'source_type': source_type or 'manual', + 'source_id': source_id, + 'sync_config': json.loads(sync_config_json) if sync_config_json else {} } finally: conn.close() @@ -126,7 +135,8 @@ def save_label(self, definition: Dict[str, Any]) -> Dict[str, Any]: Create or update a label definition. Args: - definition: Dict with keys: name, properties (list), relationships (list) + definition: Dict with keys: name, properties (list), relationships (list), + source_type (optional), source_id (optional), sync_config (optional) Returns: Updated label definition @@ -137,6 +147,9 @@ def save_label(self, definition: Dict[str, Any]) -> Dict[str, Any]: properties = definition.get('properties', []) relationships = definition.get('relationships', []) + source_type = definition.get('source_type', 'manual') + source_id = definition.get('source_id') + sync_config = definition.get('sync_config', {}) # Validate property structure for prop in properties: @@ -150,6 +163,7 @@ def save_label(self, definition: Dict[str, Any]) -> Dict[str, Any]: props_json = json.dumps(properties) rels_json = json.dumps(relationships) + sync_config_json = json.dumps(sync_config) now = time.time() # Check if label exists @@ -163,20 +177,22 @@ def save_label(self, definition: Dict[str, Any]) -> Dict[str, Any]: cursor.execute( """ UPDATE label_definitions - SET properties = ?, relationships = ?, updated_at = ? + SET properties = ?, relationships = ?, source_type = ?, source_id = ?, + sync_config = ?, updated_at = ? WHERE name = ? """, - (props_json, rels_json, now, name) + (props_json, rels_json, source_type, source_id, sync_config_json, now, name) ) created_at = existing['created_at'] else: # Insert cursor.execute( """ - INSERT INTO label_definitions (name, properties, relationships, created_at, updated_at) - VALUES (?, ?, ?, ?, ?) + INSERT INTO label_definitions (name, properties, relationships, source_type, + source_id, sync_config, created_at, updated_at) + VALUES (?, ?, ?, ?, ?, ?, ?, ?) """, - (name, props_json, rels_json, now, now) + (name, props_json, rels_json, source_type, source_id, sync_config_json, now, now) ) created_at = now @@ -186,6 +202,9 @@ def save_label(self, definition: Dict[str, Any]) -> Dict[str, Any]: 'name': name, 'properties': properties, 'relationships': relationships, + 'source_type': source_type, + 'source_id': source_id, + 'sync_config': sync_config, 'created_at': created_at, 'updated_at': now } diff --git a/scidk/services/link_service.py b/scidk/services/link_service.py index a562d49..d88ecb6 100644 --- a/scidk/services/link_service.py +++ b/scidk/services/link_service.py @@ -275,20 +275,72 @@ def preview_matches(self, definition: Dict[str, Any], limit: int = 10) -> List[D return matches - def execute_link_job(self, link_def_id: str) -> str: + def execute_link_job(self, link_def_id: str, use_background_task: bool = True) -> str: """ Start background job to create relationships. Args: link_def_id: Link definition ID + use_background_task: If True, use /api/tasks background worker (default). If False, run synchronously. Returns: - Job ID + Job ID (if use_background_task=False) or Task ID (if use_background_task=True) """ definition = self.get_link_definition(link_def_id) if not definition: raise ValueError(f"Link definition '{link_def_id}' not found") + # Use background task pattern (preferred for production) + if use_background_task: + import hashlib + from flask import current_app + + now = time.time() + tid_src = f"link_execution|{link_def_id}|{now}" + task_id = hashlib.sha1(tid_src.encode()).hexdigest()[:12] + + # Create task record for tracking + task = { + 'id': task_id, + 'type': 'link_execution', + 'status': 'running', + 'link_def_id': link_def_id, + 'link_name': definition.get('name', 'Unknown'), + 'started': now, + 'ended': None, + 'total': 0, # Will be set after preview + 'processed': 0, + 'progress': 0.0, + 'error': None, + 'cancel_requested': False, + 'eta_seconds': None, + 'status_message': 'Initializing relationship creation...', + 'relationships_created': 0, + } + current_app.extensions['scidk'].setdefault('tasks', {})[task_id] = task + + # Run in background thread + import threading + app = current_app._get_current_object() + + def _worker(): + with app.app_context(): + try: + job_id = str(uuid.uuid4()) + self._execute_job_impl_with_progress(job_id, definition, task) + task['ended'] = time.time() + task['status'] = 'completed' + task['progress'] = 1.0 + task['status_message'] = f'Created {task["relationships_created"]} relationships' + except Exception as e: + task['ended'] = time.time() + task['status'] = 'error' + task['error'] = str(e) + + threading.Thread(target=_worker, daemon=True).start() + return task_id + + # Legacy synchronous execution (for backward compatibility) job_id = str(uuid.uuid4()) now = time.time() @@ -306,7 +358,7 @@ def execute_link_job(self, link_def_id: str) -> str: ) conn.commit() - # Execute job (synchronously for MVP, could be async later) + # Execute job synchronously try: self._execute_job_impl(job_id, definition) except Exception as e: @@ -683,6 +735,156 @@ def _execute_job_impl(self, job_id: str, definition: Dict[str, Any]): finally: conn.close() + def _execute_job_impl_with_progress(self, job_id: str, definition: Dict[str, Any], task: Dict[str, Any]): + """ + Execute the link job with progress tracking for /api/tasks integration. + + Args: + job_id: Job ID for database tracking + definition: Link definition + task: Task dict to update with progress + """ + conn = self._get_conn() + try: + from .neo4j_client import get_neo4j_client + neo4j_client = get_neo4j_client() + + if not neo4j_client: + raise Exception("Neo4j client not configured") + + # Create job record + cursor = conn.cursor() + cursor.execute( + """ + INSERT INTO link_jobs + (id, link_def_id, status, preview_count, executed_count, started_at) + VALUES (?, ?, ?, ?, ?, ?) + """, + (job_id, definition.get('id'), 'running', 0, 0, task['started']) + ) + conn.commit() + + # Fetch all source data + task['status_message'] = 'Fetching source data...' + source_data = self._fetch_source_data(definition) + task['status_message'] = f'Found {len(source_data)} source items' + + # Match with targets + task['status_message'] = 'Matching with targets...' + matches = self._match_with_targets(definition, source_data, limit=len(source_data)) + + task['total'] = len(matches) + task['status_message'] = f'Found {len(matches)} matches to process' + + if len(matches) == 0: + task['status_message'] = 'No matches found' + cursor.execute( + """ + UPDATE link_jobs + SET status = ?, executed_count = ?, completed_at = ? + WHERE id = ? + """, + ('completed', 0, time.time(), job_id) + ) + conn.commit() + return + + # Create relationships in batches + relationship_type = definition.get('relationship_type', '') + relationship_props = definition.get('relationship_props', {}) + + batch_size = 1000 + total_created = 0 + eta_window_start = time.time() + + for i in range(0, len(matches), batch_size): + # Check for cancel + if task.get('cancel_requested'): + task['status'] = 'canceled' + cursor.execute( + """ + UPDATE link_jobs + SET status = ?, error = ?, completed_at = ? + WHERE id = ? + """, + ('cancelled', 'Job cancelled by user', time.time(), job_id) + ) + conn.commit() + return + + batch = matches[i:i + batch_size] + + # Build batch create query + batch_data = [] + for match in batch: + source = match.get('source', {}) + target = match.get('target', {}) + + if not target: + continue + + batch_data.append({ + 'source_id': source.get('_id') or source.get('id'), + 'target_id': target.get('_id') or target.get('id'), + 'properties': relationship_props + }) + + if batch_data: + query = f""" + UNWIND $batch AS row + MATCH (source) WHERE id(source) = row.source_id + MATCH (target) WHERE id(target) = row.target_id + CREATE (source)-[r:{relationship_type}]->(target) + SET r = row.properties + """ + neo4j_client.execute_write(query, {'batch': batch_data}) + total_created += len(batch_data) + + # Update progress + task['processed'] = min(i + batch_size, len(matches)) + task['relationships_created'] = total_created + task['progress'] = task['processed'] / task['total'] if task['total'] > 0 else 0 + + # Calculate ETA + elapsed = time.time() - eta_window_start + if elapsed > 0 and task['processed'] > 0: + rate = task['processed'] / elapsed + remaining = task['total'] - task['processed'] + task['eta_seconds'] = int(remaining / rate) if rate > 0 else None + task['status_message'] = f'Creating relationships... {task["processed"]}/{task["total"]} ({int(rate)}/s)' + else: + task['status_message'] = f'Creating relationships... {task["processed"]}/{task["total"]}' + + # Update job status to completed + cursor.execute( + """ + UPDATE link_jobs + SET status = ?, executed_count = ?, completed_at = ? + WHERE id = ? + """, + ('completed', total_created, time.time(), job_id) + ) + conn.commit() + + task['relationships_created'] = total_created + task['status_message'] = f'Completed: {total_created} relationships created' + + except Exception as e: + # Update job with error + cursor = conn.cursor() + cursor.execute( + """ + UPDATE link_jobs + SET status = ?, error = ?, completed_at = ? + WHERE id = ? + """, + ('failed', str(e), time.time(), job_id) + ) + conn.commit() + raise + finally: + conn.close() + def get_neo4j_client(): """Get or create Neo4j client instance.""" diff --git a/scidk/ui/static/js/notifications.js b/scidk/ui/static/js/notifications.js new file mode 100644 index 0000000..1f5f625 --- /dev/null +++ b/scidk/ui/static/js/notifications.js @@ -0,0 +1,190 @@ +/** + * Browser notification system for SciDK alerts + */ + +class NotificationManager { + constructor() { + this.permission = Notification.permission; + this.enabled = localStorage.getItem('scidk_notifications_enabled') === 'true'; + } + + /** + * Check if browser notifications are supported + */ + isSupported() { + return 'Notification' in window; + } + + /** + * Request permission from user + */ + async requestPermission() { + if (!this.isSupported()) { + return false; + } + + if (this.permission === 'granted') { + return true; + } + + try { + const permission = await Notification.requestPermission(); + this.permission = permission; + + if (permission === 'granted') { + this.enabled = true; + localStorage.setItem('scidk_notifications_enabled', 'true'); + return true; + } + return false; + } catch (error) { + console.error('Error requesting notification permission:', error); + return false; + } + } + + /** + * Show a browser notification + */ + show(title, options = {}) { + if (!this.isSupported() || this.permission !== 'granted' || !this.enabled) { + return null; + } + + const defaultOptions = { + icon: '/static/icon-192.png', + badge: '/static/badge-72.png', + tag: 'scidk-alert', + requireInteraction: false, + ...options + }; + + try { + const notification = new Notification(title, defaultOptions); + + // Auto-close after 10 seconds if not requiring interaction + if (!defaultOptions.requireInteraction) { + setTimeout(() => notification.close(), 10000); + } + + // Click handler - focus window and navigate to alerts + notification.onclick = () => { + window.focus(); + if (options.url) { + window.location.href = options.url; + } else { + window.location.href = '/#alerts'; + } + notification.close(); + }; + + return notification; + } catch (error) { + console.error('Error showing notification:', error); + return null; + } + } + + /** + * Enable browser notifications + */ + async enable() { + const granted = await this.requestPermission(); + if (granted) { + this.enabled = true; + localStorage.setItem('scidk_notifications_enabled', 'true'); + return true; + } + return false; + } + + /** + * Disable browser notifications + */ + disable() { + this.enabled = false; + localStorage.setItem('scidk_notifications_enabled', 'false'); + } + + /** + * Get current status + */ + getStatus() { + return { + supported: this.isSupported(), + permission: this.permission, + enabled: this.enabled + }; + } +} + +// Global instance +window.scidkNotifications = new NotificationManager(); + +// Poll for new alerts (checks every 30 seconds) +let alertPollingInterval = null; +let lastAlertCheck = Date.now(); + +async function checkForNewAlerts() { + try { + const response = await fetch('/api/settings/alerts/history?limit=10'); + if (!response.ok) return; + + const data = await response.json(); + const alerts = data.history || []; + + // Show notifications for new alerts since last check + alerts.forEach(alert => { + const alertTime = new Date(alert.triggered_at_iso).getTime(); + if (alertTime > lastAlertCheck && alert.success) { + // Show browser notification + const details = alert.condition_details || {}; + const body = Object.entries(details) + .filter(([k]) => k !== 'test') + .map(([k, v]) => `${k}: ${v}`) + .join('\n'); + + window.scidkNotifications.show( + `Alert: ${alert.alert_name || 'Unknown Alert'}`, + { + body: body || 'Alert triggered', + icon: '/static/icon-192.png', + tag: `alert-${alert.id}`, + url: '/#alerts' + } + ); + } + }); + + lastAlertCheck = Date.now(); + } catch (error) { + console.error('Error checking for alerts:', error); + } +} + +// Start polling when notifications are enabled +function startAlertPolling() { + if (alertPollingInterval) return; + + // Check immediately + checkForNewAlerts(); + + // Then check every 30 seconds + alertPollingInterval = setInterval(checkForNewAlerts, 30000); +} + +function stopAlertPolling() { + if (alertPollingInterval) { + clearInterval(alertPollingInterval); + alertPollingInterval = null; + } +} + +// Auto-start polling if notifications are enabled +if (window.scidkNotifications.enabled && window.scidkNotifications.permission === 'granted') { + startAlertPolling(); +} + +// Export for use in UI +window.startAlertPolling = startAlertPolling; +window.stopAlertPolling = stopAlertPolling; diff --git a/scidk/ui/templates/base.html b/scidk/ui/templates/base.html index 7df4b81..3ef33c3 100644 --- a/scidk/ui/templates/base.html +++ b/scidk/ui/templates/base.html @@ -337,5 +337,9 @@

Session Locked

window.scidkActivityMonitor = activityMonitor; })(); + + + + diff --git a/scidk/ui/templates/datasets.html b/scidk/ui/templates/datasets.html index c97f91f..14255d9 100644 --- a/scidk/ui/templates/datasets.html +++ b/scidk/ui/templates/datasets.html @@ -634,6 +634,12 @@

Scans Summary

// Keep a small client-side list for local (synchronous) scans so they appear alongside server tasks window.scidkLocalTasks = window.scidkLocalTasks || []; const fmtPct = (x) => Math.round((x || 0) * 100); + function fmtETA(seconds){ + if (!seconds || seconds <= 0) return ''; + if (seconds < 60) return `~${seconds}s remaining`; + if (seconds < 3600) return `~${Math.round(seconds/60)}m remaining`; + return `~${Math.round(seconds/3600)}h ${Math.round((seconds%3600)/60)}m remaining`; + } function renderTasks(tasks){ if (!tasks || tasks.length === 0){ tasksDiv.innerHTML = '

No background tasks.

'; return; } tasksDiv.innerHTML = tasks.map(t => { @@ -651,7 +657,9 @@

Scans Summary

extra = `
Neo4j: attempted=${attempted}${written!==''?(' — prepared='+written):''}${dbv!==''?(' — verify='+dbv+' (files:'+dbf+', folders:'+dbfo+')'):''}${err}
`; } const cancelBtn = (t.status==='running') ? ` ` : ''; - const info = `
${t.type} ${t.status} — ${t.path || ''} — ${t.processed||0}/${total} (${pct}%) ${t.error?(' — error: '+t.error):''} ${t.scan_id?(' — open'):''} ${cancelBtn}
`; + const statusMsg = t.status_message ? ` — ${t.status_message}` : ''; + const etaMsg = (t.status === 'running' && t.eta_seconds) ? ` — ${fmtETA(t.eta_seconds)}` : ''; + const info = `
${t.type} ${t.status} — ${t.path || ''} — ${t.processed||0}/${total} (${pct}%)${statusMsg}${etaMsg} ${t.error?(' — error: '+t.error):''} ${t.scan_id?(' — open'):''} ${cancelBtn}
`; return `
${bar}${info}${extra}
`; }).join(''); // Attach cancel handlers diff --git a/scidk/ui/templates/extensions.html b/scidk/ui/templates/extensions.html deleted file mode 100644 index af4145b..0000000 --- a/scidk/ui/templates/extensions.html +++ /dev/null @@ -1,22 +0,0 @@ -{% extends 'base.html' %} -{% block title %}-SciDK-> Interpreters{% endblock %} -{% block content %} -

Interpreters

-

Interpreter registry mappings and selection rules.

-

Mappings (extension -> interpreters)

-
    - {% for ext, ids in (mappings or {}).items() %} -
  • {{ ext }} → {{ ids }}
    • - {% else %} -
  • No mappings.
    • - {% endfor %} -
-

Rules

-
    - {% for r in (rules or []) %} -
  • {{ r.id }} → interpreter_id={{ r.interpreter_id }}, pattern={{ r.pattern }}, priority={{ r.priority }}
    • - {% else %} -
  • No rules.
    • - {% endfor %} -
-{% endblock %} diff --git a/scidk/ui/templates/index.html b/scidk/ui/templates/index.html index 23e9951..a9f0f2e 100644 --- a/scidk/ui/templates/index.html +++ b/scidk/ui/templates/index.html @@ -90,6 +90,9 @@ Plugins Rclone Integrations + Alerts + Health + Logs @@ -101,6 +104,9 @@ {% include 'settings/_plugins.html' %} {% include 'settings/_rclone.html' %} {% include 'settings/_integrations.html' %} + {% include 'settings/_alerts.html' %} + {% include 'settings/_health.html' %} + {% include 'settings/_logs.html' %} diff --git a/scidk/ui/templates/integrations.html b/scidk/ui/templates/integrations.html index 592eb81..5569103 100644 --- a/scidk/ui/templates/integrations.html +++ b/scidk/ui/templates/integrations.html @@ -223,6 +223,12 @@

Integrations

Create relationships between data instances using graph, CSV, or API sources.

+ + +
+ +

Plugin Endpoints

+

Endpoints registered by installed plugins. These cannot be edited manually.

+
+

No plugin endpoints registered

+
+

Table Format Registry

Manage table formats for importing CSV, TSV, Excel, and Parquet files as link sources.

@@ -550,6 +557,56 @@

Hybrid Matching Architecture

// Load labels and endpoints on page load loadLabels(); loadEndpoints(); + loadPluginEndpoints(); + } + + // Load and display plugin-registered endpoints + async function loadPluginEndpoints() { + const container = document.getElementById('plugin-endpoints-list'); + + try { + const response = await fetch('/api/settings/plugin-endpoints'); + const data = await response.json(); + + if (data.status === 'success' && data.endpoints && data.endpoints.length > 0) { + container.innerHTML = ` + + + + + + + + + + + + +
NameEndpointLabel TypePluginDescription
+ `; + + const tbody = document.getElementById('plugin-endpoints-table-body'); + data.endpoints.forEach(endpoint => { + const row = document.createElement('tr'); + const authBadge = endpoint.auth_required ? + 'Auth Required' : ''; + + row.innerHTML = ` + ${escapeHtml(endpoint.name)}${authBadge} + ${escapeHtml(endpoint.endpoint)} + ${escapeHtml(endpoint.label_type)} + ${escapeHtml(endpoint.plugin)} + ${escapeHtml(endpoint.description || '—')} + `; + tbody.appendChild(row); + }); + } else { + container.innerHTML = '

No plugin endpoints registered

'; + } + } catch (err) { + console.error('Failed to load plugin endpoints:', err); + container.innerHTML = '

Failed to load plugin endpoints

'; + } } // Table Format Registry Management diff --git a/scidk/ui/templates/settings/_logs.html b/scidk/ui/templates/settings/_logs.html new file mode 100644 index 0000000..05cf504 --- /dev/null +++ b/scidk/ui/templates/settings/_logs.html @@ -0,0 +1,198 @@ +
+

System Logs

+

Real-time view of application logs. Auto-refreshes every 2 seconds.

+ + +
+
+
+ + +
+ +
+ + +
+ +
+ + +
+ +
+ + + + +
+
+
+ + +
+

Loading logs...

+
+ +

+ Showing most recent 100 entries. Auto-refresh: Active +

+ + + + +
diff --git a/scidk/ui/templates/settings/_plugins.html b/scidk/ui/templates/settings/_plugins.html index da6977b..0e4be6c 100644 --- a/scidk/ui/templates/settings/_plugins.html +++ b/scidk/ui/templates/settings/_plugins.html @@ -1,8 +1,1311 @@

Plugins

-

Plugin registry summary.

-
    -
  • Registered interpreter count: {{ interp_count or 0 }}
    • -
  • Extensions mapped: {{ ext_count or 0 }}
    • -
+

Manage plugins and extensions for SciDK. Plugins can add routes, labels, and functionality.

+ +
+

Loading plugins...

+
+ + {% if failed_plugins %} +
+

Failed Plugins

+
    + {% for name, error in failed_plugins.items() %} +
  • {{ name }}: {{ error }}
    • + {% endfor %} +
+
+ {% endif %} + + +
+
+
+

Plugin Instances

+

Manage plugin instances for data import and integration

+
+ +
+ +
+

Loading plugin instances...

+
+
+ + +
+ + + + + + diff --git a/scidk/web/auth_middleware.py b/scidk/web/auth_middleware.py index c19bc30..bd01fb7 100644 --- a/scidk/web/auth_middleware.py +++ b/scidk/web/auth_middleware.py @@ -18,6 +18,9 @@ '/api/settings/security/auth', # Allow disabling/checking auth config '/api/health', # Health check endpoint (legitimately needs to be public) '/static', # Prefix for static files + '/api/docs', # Swagger UI + '/apispec.json', # Swagger API spec + '/flasgger_static', # Swagger static files } diff --git a/scidk/web/decorators.py b/scidk/web/decorators.py index a2eaf84..13f7685 100644 --- a/scidk/web/decorators.py +++ b/scidk/web/decorators.py @@ -31,6 +31,25 @@ def some_route(): def decorator(f): @wraps(f) def decorated_function(*args, **kwargs): + # In test mode with auth disabled, allow all requests + # This matches the behavior of auth_middleware which skips auth in test mode + import os + import sys + from flask import current_app + is_testing = ( + current_app.config.get('TESTING', False) or + 'pytest' in sys.modules or + os.environ.get('SCIDK_E2E_TEST') + ) + if is_testing and not os.environ.get('PYTEST_TEST_AUTH'): + # In test mode - check if auth is actually enabled + from ..core.auth import get_auth_manager + db_path = current_app.config.get('SCIDK_SETTINGS_DB', 'scidk_settings.db') + auth = get_auth_manager(db_path=db_path) + if not auth.is_enabled(): + # Auth disabled in tests - allow the request + return f(*args, **kwargs) + # Check if user is authenticated if not hasattr(g, 'scidk_user_role'): return jsonify({'error': 'Authentication required'}), 401 diff --git a/scidk/web/routes/__init__.py b/scidk/web/routes/__init__.py index fc4422f..f707083 100644 --- a/scidk/web/routes/__init__.py +++ b/scidk/web/routes/__init__.py @@ -42,6 +42,9 @@ def register_blueprints(app): from . import api_users from . import api_audit from . import api_queries + from . import api_alerts + from . import api_logs + from . import api_plugins # Register UI blueprint app.register_blueprint(ui.bp) @@ -64,3 +67,6 @@ def register_blueprints(app): app.register_blueprint(api_auth.bp) app.register_blueprint(api_users.bp) app.register_blueprint(api_audit.bp) + app.register_blueprint(api_alerts.bp) + app.register_blueprint(api_logs.bp) + app.register_blueprint(api_plugins.bp) diff --git a/scidk/web/routes/api_admin.py b/scidk/web/routes/api_admin.py index 4c18dd8..c6d0464 100644 --- a/scidk/web/routes/api_admin.py +++ b/scidk/web/routes/api_admin.py @@ -8,6 +8,7 @@ import time from ..helpers import get_neo4j_params, build_commit_rows, commit_to_neo4j, get_or_build_scan_index +from ..decorators import require_admin bp = Blueprint('admin', __name__, url_prefix='/api') def _get_ext(): @@ -16,7 +17,39 @@ def _get_ext(): @bp.get('/health/graph') def api_health_graph(): - """Basic health for graph backend. In-memory is always OK; if Neo4j settings/env are provided, try a connection.""" + """Graph backend health check + --- + tags: + - Health + summary: Check health of graph backend (Neo4j or in-memory) + description: Returns health status of the graph backend. In-memory is always OK. If Neo4j settings are provided, attempts a connection test. + responses: + 200: + description: Health status retrieved successfully + schema: + type: object + properties: + backend: + type: string + example: neo4j + description: Backend type (neo4j or in_memory) + in_memory_ok: + type: boolean + example: true + neo4j: + type: object + properties: + configured: + type: boolean + description: Whether Neo4j is configured + connectable: + type: boolean + description: Whether connection to Neo4j succeeded + error: + type: string + nullable: true + description: Error message if connection failed + """ backend = os.environ.get('SCIDK_GRAPH_BACKEND', 'in_memory').lower() or 'in_memory' info = { 'backend': backend, @@ -64,7 +97,44 @@ def api_health_graph(): @bp.get('/health') def api_health(): - """Overall health focusing on SQLite availability and WAL mode.""" + """System health check + --- + tags: + - Health + summary: Check overall system health + description: Returns health status focusing on SQLite database availability, WAL mode, and schema version + responses: + 200: + description: Health status retrieved successfully + schema: + type: object + properties: + sqlite: + type: object + properties: + path: + type: string + description: Path to SQLite database file + exists: + type: boolean + description: Whether database file exists + journal_mode: + type: string + description: SQLite journal mode + wal_mode: + type: boolean + description: Whether WAL mode is enabled + schema_version: + type: integer + description: Current schema version + select1: + type: boolean + description: Whether basic SELECT query works + error: + type: string + nullable: true + description: Error message if health check failed + """ from ...core import path_index_sqlite as pix from ...core import migrations as _migs info = { @@ -118,6 +188,219 @@ def api_health(): return jsonify(info), 200 +@bp.get('/health/comprehensive') +def api_health_comprehensive(): + """ + Comprehensive system health check dashboard. + + Returns health status for all system components: Flask, SQLite, Neo4j, + interpreters, disk, memory, and CPU usage. + + Note: Available to all users (authentication handled by middleware). + System health information is not sensitive and useful for all users. + + Returns: + JSON with overall status and individual component health metrics + """ + import psutil + from ...core import path_index_sqlite as pix + + components = {} + start_time_key = 'START_TIME' + + # Flask/Application health + try: + uptime = int(time.time() - current_app.config.get(start_time_key, time.time())) + memory_mb = round(psutil.Process().memory_info().rss / 1024 / 1024, 1) + components['flask'] = { + 'status': 'ok', + 'uptime_seconds': uptime, + 'memory_mb': memory_mb + } + except Exception as e: + components['flask'] = { + 'status': 'error', + 'error': str(e) + } + + # SQLite health (reuse existing logic) + try: + conn = pix.connect() + try: + dbp = pix._db_path() + mode = (conn.execute('PRAGMA journal_mode;').fetchone() or [''])[0] + + # Get database size + size_bytes = 0 + try: + from pathlib import Path as _P + db_path = _P(str(dbp)) + if db_path.exists(): + size_bytes = db_path.stat().st_size + except Exception: + pass + + # Get row count from scans table + row_count = 0 + try: + result = conn.execute('SELECT COUNT(*) FROM scans').fetchone() + row_count = result[0] if result else 0 + except Exception: + pass + + components['sqlite'] = { + 'status': 'ok', + 'path': str(dbp), + 'size_mb': round(size_bytes / 1024 / 1024, 2), + 'journal_mode': mode.lower() if isinstance(mode, str) else 'unknown', + 'row_count': row_count + } + finally: + try: + conn.close() + except Exception: + pass + except Exception as e: + components['sqlite'] = { + 'status': 'error', + 'error': str(e) + } + + # Neo4j health (reuse existing logic) + try: + uri, user, pwd, database, auth_mode = get_neo4j_params() + if uri: + neo4j_start = time.time() + try: + from neo4j import GraphDatabase + driver = None + try: + driver = GraphDatabase.driver(uri, auth=None if auth_mode == 'none' else (user, pwd)) + with driver.session(database=database) as sess: + result = sess.run("MATCH (n) RETURN count(n) AS count") + rec = result.single() + node_count = rec['count'] if rec else 0 + response_ms = round((time.time() - neo4j_start) * 1000) + components['neo4j'] = { + 'status': 'connected', + 'response_time_ms': response_ms, + 'node_count': node_count + } + finally: + if driver: + driver.close() + except Exception as e: + components['neo4j'] = { + 'status': 'unavailable', + 'error': str(e) + } + else: + components['neo4j'] = { + 'status': 'not_configured' + } + except Exception as e: + components['neo4j'] = { + 'status': 'error', + 'error': str(e) + } + + # Interpreters health + try: + ext = _get_ext() + reg = ext.get('registry') + if reg and hasattr(reg, 'by_id'): + # Get interpreter state + interp_state = ext.get('interpreters', {}) + eff = set(interp_state.get('effective_enabled') or []) + + total = len(reg.by_id) + enabled = len(eff) if eff else total # If no override, assume all enabled + + components['interpreters'] = { + 'status': 'ok', + 'enabled_count': enabled, + 'total_count': total + } + else: + components['interpreters'] = { + 'status': 'ok', + 'enabled_count': 0, + 'total_count': 0 + } + except Exception as e: + components['interpreters'] = { + 'status': 'error', + 'error': str(e) + } + + # Disk health + try: + disk = psutil.disk_usage('/') + disk_percent = round(disk.percent, 1) + components['disk'] = { + 'status': 'critical' if disk_percent > 95 else 'warning' if disk_percent > 85 else 'good', + 'free_gb': round(disk.free / 1024**3, 1), + 'total_gb': round(disk.total / 1024**3, 1), + 'percent_used': disk_percent + } + except Exception as e: + components['disk'] = { + 'status': 'error', + 'error': str(e) + } + + # Memory health + try: + mem = psutil.virtual_memory() + mem_percent = round(mem.percent, 1) + components['memory'] = { + 'status': 'critical' if mem_percent > 90 else 'high' if mem_percent > 75 else 'normal', + 'used_mb': round(mem.used / 1024 / 1024), + 'total_mb': round(mem.total / 1024 / 1024), + 'percent_used': mem_percent + } + except Exception as e: + components['memory'] = { + 'status': 'error', + 'error': str(e) + } + + # CPU health + try: + cpu_percent = psutil.cpu_percent(interval=0.1) + components['cpu'] = { + 'status': 'high' if cpu_percent > 80 else 'normal' if cpu_percent > 20 else 'low', + 'load_percent': round(cpu_percent, 1) + } + except Exception as e: + components['cpu'] = { + 'status': 'error', + 'error': str(e) + } + + # Calculate overall status + statuses = [] + for comp in components.values(): + status = comp.get('status', 'unknown') + if status == 'error' or status == 'critical': + statuses.append('critical') + elif status == 'warning' or status == 'high': + statuses.append('warning') + elif status == 'unavailable' or status == 'not_configured': + # Don't count unavailable/not_configured as critical + pass + else: + statuses.append('healthy') + + overall = 'critical' if 'critical' in statuses else 'warning' if 'warning' in statuses else 'healthy' + + return jsonify({ + 'status': overall, + 'timestamp': time.time(), + 'components': components + }), 200 + + @bp.get('/metrics') def api_metrics(): try: @@ -440,3 +723,386 @@ def api_admin_cleanup_test_endpoints(): except Exception as e: return jsonify({'error': str(e)}), 500 + +# Backup Management API Endpoints + +@bp.get('/backups') +@require_admin +def api_backups_list(): + """ + List all backups with metadata. + + Admin-only endpoint that returns backup history with verification status. + + Returns: + JSON list of backups with metadata + """ + try: + from ...core.backup_manager import get_backup_manager + + backup_manager = get_backup_manager() + backups = backup_manager.list_backups(limit=100) + + # Add verification status from metadata + for backup in backups: + try: + import zipfile + backup_path = Path(backup['path']) + if backup_path.exists(): + with zipfile.ZipFile(backup_path, 'r') as zipf: + if 'backup_metadata.json' in zipf.namelist(): + metadata_str = zipf.read('backup_metadata.json').decode('utf-8') + metadata = json.loads(metadata_str) + verification = metadata.get('verification', {}) + backup['verified'] = verification.get('verified', False) + backup['verification_error'] = verification.get('error') + backup['verification_timestamp'] = verification.get('timestamp') + except Exception: + # If we can't read verification status, mark as unknown + backup['verified'] = None + + # Get scheduler info if available + scheduler_info = {} + try: + ext = _get_ext() + backup_scheduler = ext.get('backup_scheduler') + if backup_scheduler and backup_scheduler.is_running(): + scheduler_info = { + 'enabled': True, + 'next_backup': backup_scheduler.get_next_backup_time(), + 'schedule_hour': backup_scheduler.schedule_hour, + 'schedule_minute': backup_scheduler.schedule_minute, + 'retention_days': backup_scheduler.retention_days + } + else: + scheduler_info = {'enabled': False} + except Exception: + scheduler_info = {'enabled': False} + + return jsonify({ + 'backups': backups, + 'scheduler': scheduler_info + }), 200 + + except Exception as e: + return jsonify({'error': str(e)}), 500 + + +@bp.post('/backups') +@require_admin +def api_backups_create(): + """ + Trigger manual backup creation. + + Admin-only endpoint to create a backup on demand. + + Request body (JSON, optional): + - reason: Reason for backup (default: 'manual') + - notes: Optional notes + - include_data: Include data files (default: false) + - verify: Verify backup after creation (default: true) + + Returns: + JSON with backup details and verification status + """ + try: + from ...core.backup_manager import get_backup_manager + from flask import g + + data = request.get_json() or {} + reason = data.get('reason', 'manual') + notes = data.get('notes', '') + include_data = data.get('include_data', False) + verify = data.get('verify', True) + + # Get username from auth context if available + created_by = getattr(g, 'scidk_username', 'admin') + + backup_manager = get_backup_manager() + result = backup_manager.create_backup( + reason=reason, + created_by=created_by, + notes=notes, + include_data=include_data + ) + + if not result['success']: + return jsonify(result), 500 + + # Verify backup if requested + verification_result = None + if verify: + try: + ext = _get_ext() + backup_scheduler = ext.get('backup_scheduler') + if backup_scheduler: + verification_result = backup_scheduler.verify_backup(result['filename']) + result['verification'] = verification_result + except Exception as e: + result['verification_error'] = str(e) + + return jsonify(result), 201 + + except Exception as e: + return jsonify({'error': str(e)}), 500 + + +@bp.post('/backups//restore') +@require_admin +def api_backups_restore(backup_id): + """ + Restore from a backup. + + Admin-only endpoint to restore application state from a backup file. + + Path parameter: + backup_id: Backup filename or ID + + Request body (JSON, optional): + - create_backup_first: Create backup before restoring (default: true) + + Returns: + JSON with restore results + """ + try: + from ...core.backup_manager import get_backup_manager + + data = request.get_json() or {} + create_backup_first = data.get('create_backup_first', True) + + backup_manager = get_backup_manager() + + # Try to find backup by ID or filename + backups = backup_manager.list_backups(limit=1000) + backup_file = None + + for backup in backups: + if backup.get('backup_id') == backup_id or backup.get('filename') == backup_id: + backup_file = backup['filename'] + break + + if not backup_file: + return jsonify({'error': f'Backup not found: {backup_id}'}), 404 + + result = backup_manager.restore_backup( + backup_file=backup_file, + create_backup_first=create_backup_first + ) + + if not result['success']: + return jsonify(result), 500 + + return jsonify(result), 200 + + except Exception as e: + return jsonify({'error': str(e)}), 500 + + +@bp.delete('/backups/') +@require_admin +def api_backups_delete(backup_id): + """ + Delete a backup file. + + Admin-only endpoint to permanently delete a backup. + + Path parameter: + backup_id: Backup filename or ID + + Returns: + JSON with deletion result + """ + try: + from ...core.backup_manager import get_backup_manager + + backup_manager = get_backup_manager() + + # Try to find backup by ID or filename + backups = backup_manager.list_backups(limit=1000) + backup_file = None + + for backup in backups: + if backup.get('backup_id') == backup_id or backup.get('filename') == backup_id: + backup_file = backup['filename'] + break + + if not backup_file: + return jsonify({'error': f'Backup not found: {backup_id}'}), 404 + + success = backup_manager.delete_backup(backup_file) + + if success: + return jsonify({ + 'success': True, + 'message': f'Backup deleted: {backup_file}' + }), 200 + else: + return jsonify({ + 'success': False, + 'error': 'Failed to delete backup' + }), 500 + + except Exception as e: + return jsonify({'error': str(e)}), 500 + + +@bp.post('/backups/verify/') +@require_admin +def api_backups_verify(backup_id): + """ + Verify a backup's integrity. + + Admin-only endpoint to verify a backup without restoring it. + + Path parameter: + backup_id: Backup filename or ID + + Returns: + JSON with verification results + """ + try: + from ...core.backup_manager import get_backup_manager + + ext = _get_ext() + backup_scheduler = ext.get('backup_scheduler') + + if not backup_scheduler: + return jsonify({'error': 'Backup scheduler not available'}), 503 + + backup_manager = get_backup_manager() + + # Try to find backup by ID or filename + backups = backup_manager.list_backups(limit=1000) + backup_file = None + + for backup in backups: + if backup.get('backup_id') == backup_id or backup.get('filename') == backup_id: + backup_file = backup['filename'] + break + + if not backup_file: + return jsonify({'error': f'Backup not found: {backup_id}'}), 404 + + result = backup_scheduler.verify_backup(backup_file) + + return jsonify(result), 200 + + except Exception as e: + return jsonify({'error': str(e)}), 500 + + +@bp.post('/backups/cleanup') +@require_admin +def api_backups_cleanup(): + """ + Manually trigger cleanup of old backups. + + Admin-only endpoint to delete backups older than retention policy. + + Returns: + JSON with cleanup results + """ + try: + ext = _get_ext() + backup_scheduler = ext.get('backup_scheduler') + + if not backup_scheduler: + return jsonify({'error': 'Backup scheduler not available'}), 503 + + result = backup_scheduler.cleanup_old_backups() + + return jsonify(result), 200 + + except Exception as e: + return jsonify({'error': str(e)}), 500 + + +@bp.get('/backups/settings') +@require_admin +def api_backups_settings_get(): + """ + Get current backup schedule and retention settings. + + Admin-only endpoint to retrieve backup configuration. + + Returns: + JSON with current settings + """ + try: + ext = _get_ext() + backup_scheduler = ext.get('backup_scheduler') + + if not backup_scheduler: + return jsonify({'error': 'Backup scheduler not available'}), 503 + + settings = backup_scheduler.get_settings() + + return jsonify(settings), 200 + + except Exception as e: + return jsonify({'error': str(e)}), 500 + + +@bp.post('/backups/settings') +@require_admin +def api_backups_settings_update(): + """ + Update backup schedule and retention settings. + + Admin-only endpoint to configure automated backups. + + Request body (JSON): + - schedule_enabled: Enable/disable automated backups (boolean) + - schedule_hour: Hour to run daily backup (0-23) + - schedule_minute: Minute to run daily backup (0-59) + - retention_days: Days to keep backups before cleanup + - verify_backups: Enable/disable backup verification (boolean) + + Returns: + JSON with updated settings + """ + try: + ext = _get_ext() + backup_scheduler = ext.get('backup_scheduler') + + if not backup_scheduler: + return jsonify({'error': 'Backup scheduler not available'}), 503 + + data = request.get_json() or {} + + # Validate settings + if 'schedule_hour' in data: + try: + hour = int(data['schedule_hour']) + if hour < 0 or hour > 23: + return jsonify({'error': 'schedule_hour must be between 0 and 23'}), 400 + except ValueError: + return jsonify({'error': 'schedule_hour must be an integer'}), 400 + + if 'schedule_minute' in data: + try: + minute = int(data['schedule_minute']) + if minute < 0 or minute > 59: + return jsonify({'error': 'schedule_minute must be between 0 and 59'}), 400 + except ValueError: + return jsonify({'error': 'schedule_minute must be an integer'}), 400 + + if 'retention_days' in data: + try: + days = int(data['retention_days']) + if days < 1: + return jsonify({'error': 'retention_days must be at least 1'}), 400 + except ValueError: + return jsonify({'error': 'retention_days must be an integer'}), 400 + + # Update settings + success = backup_scheduler.update_settings(data) + + if success: + updated_settings = backup_scheduler.get_settings() + return jsonify(updated_settings), 200 + else: + return jsonify({'error': 'Failed to update settings'}), 500 + + except Exception as e: + return jsonify({'error': str(e)}), 500 diff --git a/scidk/web/routes/api_alerts.py b/scidk/web/routes/api_alerts.py new file mode 100644 index 0000000..ce1e301 --- /dev/null +++ b/scidk/web/routes/api_alerts.py @@ -0,0 +1,430 @@ +""" +Blueprint for Alerts API routes. + +Provides REST endpoints for: +- Alert definitions CRUD +- Alert testing +- Alert history +- SMTP configuration +""" +from flask import Blueprint, jsonify, request, current_app +from ..decorators import require_admin + +bp = Blueprint('alerts', __name__, url_prefix='/api') + + +def _get_alert_manager(): + """Get or create AlertManager instance.""" + from ...core.alert_manager import AlertManager, get_encryption_key + + if 'alert_manager' not in current_app.extensions.get('scidk', {}): + if 'scidk' not in current_app.extensions: + current_app.extensions['scidk'] = {} + + # Get settings DB path + settings_db = current_app.config.get('SCIDK_SETTINGS_DB', 'scidk_settings.db') + encryption_key = get_encryption_key() + + current_app.extensions['scidk']['alert_manager'] = AlertManager( + db_path=settings_db, + encryption_key=encryption_key + ) + + return current_app.extensions['scidk']['alert_manager'] + + +@bp.route('/settings/alerts', methods=['GET']) +@require_admin +def list_alerts(): + """ + Get all alert definitions. + + Returns: + { + "status": "success", + "alerts": [...] + } + """ + try: + manager = _get_alert_manager() + enabled_only = request.args.get('enabled_only', 'false').lower() == 'true' + alerts = manager.list_alerts(enabled_only=enabled_only) + + return jsonify({ + 'status': 'success', + 'alerts': alerts + }), 200 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/alerts/', methods=['GET']) +@require_admin +def get_alert(alert_id): + """ + Get a specific alert by ID. + + Returns: + { + "status": "success", + "alert": {...} + } + """ + try: + manager = _get_alert_manager() + alert = manager.get_alert(alert_id) + + if not alert: + return jsonify({ + 'status': 'error', + 'error': f'Alert "{alert_id}" not found' + }), 404 + + return jsonify({ + 'status': 'success', + 'alert': alert + }), 200 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/alerts', methods=['POST']) +@require_admin +def create_alert(): + """ + Create new alert definition. + + Request body: + { + "name": "My Alert", + "condition_type": "import_failed", + "action_type": "email", + "recipients": ["user@example.com"], + "threshold": 50.0 + } + + Returns: + { + "status": "success", + "alert_id": "uuid" + } + """ + try: + data = request.get_json() + + # Validate required fields + required = ['name', 'condition_type', 'action_type'] + for field in required: + if field not in data: + return jsonify({ + 'status': 'error', + 'error': f'Missing required field: {field}' + }), 400 + + manager = _get_alert_manager() + alert_id = manager.create_alert( + name=data['name'], + condition_type=data['condition_type'], + action_type=data['action_type'], + recipients=data.get('recipients', []), + threshold=data.get('threshold'), + created_by=data.get('created_by', 'system') + ) + + return jsonify({ + 'status': 'success', + 'alert_id': alert_id + }), 201 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/alerts/', methods=['PUT']) +@require_admin +def update_alert(alert_id): + """ + Update alert definition. + + Request body: + { + "name": "Updated Name", + "recipients": ["new@example.com"], + "threshold": 100.0, + "enabled": true + } + + Returns: + { + "status": "success" + } + """ + try: + data = request.get_json() + manager = _get_alert_manager() + + # Check if alert exists + alert = manager.get_alert(alert_id) + if not alert: + return jsonify({ + 'status': 'error', + 'error': f'Alert "{alert_id}" not found' + }), 404 + + # Update alert + success = manager.update_alert(alert_id, **data) + + if success: + return jsonify({ + 'status': 'success' + }), 200 + else: + return jsonify({ + 'status': 'error', + 'error': 'No fields to update' + }), 400 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/alerts/', methods=['DELETE']) +@require_admin +def delete_alert(alert_id): + """ + Delete alert definition. + + Returns: + { + "status": "success" + } + """ + try: + manager = _get_alert_manager() + success = manager.delete_alert(alert_id) + + if success: + return jsonify({ + 'status': 'success' + }), 200 + else: + return jsonify({ + 'status': 'error', + 'error': f'Alert "{alert_id}" not found' + }), 404 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/alerts//test', methods=['POST']) +@require_admin +def test_alert(alert_id): + """ + Send test notification for this alert. + + Returns: + { + "status": "success", + "message": "Test alert sent successfully" + } + """ + try: + manager = _get_alert_manager() + success, error_msg = manager.test_alert(alert_id) + + if success: + return jsonify({ + 'status': 'success', + 'message': 'Test alert sent successfully' + }), 200 + else: + return jsonify({ + 'status': 'error', + 'error': error_msg or 'Failed to send test alert' + }), 500 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/alerts/history', methods=['GET']) +@require_admin +def get_alert_history(): + """ + Get alert trigger history. + + Query params: + - alert_id: Optional, filter by specific alert + - limit: Optional, max entries to return (default: 100) + + Returns: + { + "status": "success", + "history": [...] + } + """ + try: + manager = _get_alert_manager() + alert_id = request.args.get('alert_id') + limit = int(request.args.get('limit', 100)) + + history = manager.get_alert_history(alert_id=alert_id, limit=limit) + + return jsonify({ + 'status': 'success', + 'history': history + }), 200 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +# SMTP Configuration endpoints + +@bp.route('/settings/smtp', methods=['GET']) +@require_admin +def get_smtp_config(): + """ + Get SMTP configuration (password redacted). + + Returns: + { + "status": "success", + "smtp": { + "host": "smtp.gmail.com", + "port": 587, + "username": "user@example.com", + "password": "••••••••", + "from_address": "noreply@example.com", + "use_tls": true, + "enabled": true + } + } + """ + try: + manager = _get_alert_manager() + smtp_config = manager.get_smtp_config_safe() + + return jsonify({ + 'status': 'success', + 'smtp': smtp_config or {} + }), 200 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/smtp', methods=['POST']) +@require_admin +def update_smtp_config(): + """ + Update SMTP configuration. + + Request body: + { + "host": "smtp.gmail.com", + "port": 587, + "username": "user@example.com", + "password": "app_password", + "from_address": "noreply@example.com", + "use_tls": true, + "enabled": true + } + + Returns: + { + "status": "success" + } + """ + try: + data = request.get_json() + + # Validate required fields + required = ['host', 'port', 'from_address'] + for field in required: + if field not in data: + return jsonify({ + 'status': 'error', + 'error': f'Missing required field: {field}' + }), 400 + + manager = _get_alert_manager() + manager.update_smtp_config( + host=data['host'], + port=int(data['port']), + username=data.get('username', ''), + password=data.get('password'), # Can be None to keep existing + from_address=data['from_address'], + recipients=data.get('recipients', []), # Global recipients list + use_tls=data.get('use_tls', True), + enabled=data.get('enabled', True) + ) + + return jsonify({ + 'status': 'success' + }), 200 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/smtp/test', methods=['POST']) +@require_admin +def test_smtp(): + """ + Send test email to verify SMTP configuration. + + Request body (optional): + { + "recipient": "test@example.com" + } + + Returns: + { + "status": "success", + "message": "Test email sent successfully" + } + """ + try: + data = request.get_json() or {} + recipient = data.get('recipient') + + manager = _get_alert_manager() + success, error_msg = manager.test_smtp_config(test_recipient=recipient) + + if success: + return jsonify({ + 'status': 'success', + 'message': 'Test email sent successfully' + }), 200 + else: + return jsonify({ + 'status': 'error', + 'error': error_msg or 'Failed to send test email' + }), 500 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 diff --git a/scidk/web/routes/api_auth.py b/scidk/web/routes/api_auth.py index 507ac13..2cda1f1 100644 --- a/scidk/web/routes/api_auth.py +++ b/scidk/web/routes/api_auth.py @@ -35,20 +35,83 @@ def _get_session_token(): @bp.post('/login') def api_auth_login(): - """Login with username and password. - - Request body: - { - "username": "admin", - "password": "password123", - "remember_me": false // optional, default false - } - - Returns: - 200: {"success": true, "token": "...", "username": "admin"} - 401: {"success": false, "error": "Invalid credentials"} - 400: {"success": false, "error": "Missing username or password"} - 503: {"success": false, "error": "Authentication not enabled"} + """User login + --- + tags: + - Authentication + summary: Login with username and password + description: Authenticate user and create a session token + parameters: + - in: body + name: body + required: true + schema: + type: object + required: + - username + - password + properties: + username: + type: string + example: admin + description: Username + password: + type: string + format: password + example: password123 + description: Password + remember_me: + type: boolean + default: false + description: Keep session active for 30 days instead of 24 hours + responses: + 200: + description: Login successful + schema: + type: object + properties: + success: + type: boolean + example: true + token: + type: string + description: Session token (JWT) + username: + type: string + example: admin + 401: + description: Invalid credentials + schema: + type: object + properties: + success: + type: boolean + example: false + error: + type: string + example: Invalid credentials + 400: + description: Missing required fields + schema: + type: object + properties: + success: + type: boolean + example: false + error: + type: string + example: Missing username or password + 503: + description: Authentication not enabled + schema: + type: object + properties: + success: + type: boolean + example: false + error: + type: string + example: Authentication not enabled """ auth = _get_auth_manager() diff --git a/scidk/web/routes/api_files.py b/scidk/web/routes/api_files.py index cb5368f..46decc2 100644 --- a/scidk/web/routes/api_files.py +++ b/scidk/web/routes/api_files.py @@ -17,6 +17,66 @@ def _get_ext(): @bp.post('/scan/dry-run') def api_scan_dry_run(): + """Scan directory dry-run + --- + tags: + - Files & Scans + summary: Preview files that would be scanned without executing scan + description: Returns list of files that match scan criteria without actually scanning them + parameters: + - in: body + name: body + required: true + schema: + type: object + properties: + path: + type: string + example: /home/user/data + description: Directory path to scan + include: + type: array + items: + type: string + example: ["*.py", "*.csv"] + description: Include patterns (glob) + exclude: + type: array + items: + type: string + example: ["test_*", "*.tmp"] + description: Exclude patterns (glob) + max_depth: + type: integer + example: 3 + description: Maximum directory depth + use_ignore: + type: boolean + default: true + description: Respect .scidkignore file + responses: + 200: + description: Dry-run results + schema: + type: object + properties: + status: + type: string + example: ok + files: + type: array + items: + type: string + description: List of file paths + total_files: + type: integer + example: 42 + total_bytes: + type: integer + example: 1048576 + 400: + description: Invalid path + """ from fnmatch import fnmatch data = request.get_json(force=True, silent=True) or {} path = data.get('path') or os.getcwd() diff --git a/scidk/web/routes/api_graph.py b/scidk/web/routes/api_graph.py index 358b572..8c28ed2 100644 --- a/scidk/web/routes/api_graph.py +++ b/scidk/web/routes/api_graph.py @@ -26,19 +26,72 @@ def api_graph_schema(): @bp.get('/graph/schema/combined') def api_graph_schema_combined(): - """ - Unified schema endpoint combining local Labels, Neo4j schema, and in-memory graph. - - Query params: - - source: 'labels' | 'neo4j' | 'graph' | 'all' (default: 'all') - - include_properties: 'true' | 'false' (default: 'false') - - Returns: - { - "nodes": [{"label": "...", "count": 0, "source": "labels", "properties": [...]}], - "edges": [{"start_label": "...", "rel_type": "...", "end_label": "...", "count": 0, "source": "labels"}], - "sources": {"labels": {"count": N, "enabled": true}, ...} - } + """Get combined graph schema + --- + tags: + - Graph + summary: Get unified schema from all sources + description: Returns combined schema from local Labels, Neo4j schema, and in-memory graph + parameters: + - name: source + in: query + type: string + enum: [labels, neo4j, graph, all] + default: all + description: Schema source to query + - name: include_properties + in: query + type: string + enum: ["true", "false"] + default: "false" + description: Include property definitions + responses: + 200: + description: Combined schema + schema: + type: object + properties: + nodes: + type: array + items: + type: object + properties: + label: + type: string + example: Dataset + count: + type: integer + example: 5 + source: + type: string + example: labels + properties: + type: array + items: + type: string + edges: + type: array + items: + type: object + properties: + start_label: + type: string + example: Dataset + rel_type: + type: string + example: CONTAINS + end_label: + type: string + example: File + count: + type: integer + example: 10 + source: + type: string + example: labels + sources: + type: object + description: Metadata about each schema source """ source = (request.args.get('source') or 'all').strip().lower() include_props = (request.args.get('include_properties') or 'false').strip().lower() == 'true' diff --git a/scidk/web/routes/api_labels.py b/scidk/web/routes/api_labels.py index a4aa090..2f9d623 100644 --- a/scidk/web/routes/api_labels.py +++ b/scidk/web/routes/api_labels.py @@ -21,6 +21,114 @@ def _get_label_service(): return current_app.extensions['scidk']['label_service'] +@bp.route('/labels/list', methods=['GET']) +def list_labels_for_integration(): + """ + List all labels optimized for Integrations page dropdowns. + + Returns labels with source indicators and node counts for populating + source/target label dropdowns in the Integrations page. + + Returns: + { + "status": "success", + "labels": [ + { + "name": "Project", + "source": "manual", + "source_display": "Manual", + "node_count": 42, + "instance_id": null + }, + { + "name": "LabEquipment", + "source": "plugin_instance", + "source_display": "Plugin: iLab Equipment", + "node_count": 15, + "instance_id": "abc123" + } + ] + } + """ + try: + service = _get_label_service() + labels = service.list_labels() + + # Get node counts from Neo4j (if connected) + node_counts = {} + try: + from ...core.graph_db import get_neo4j_driver + driver = get_neo4j_driver() + if driver: + with driver.session() as session: + result = session.run("CALL db.labels() YIELD label RETURN label") + neo4j_labels = [record['label'] for record in result] + + # Get count for each label + for label_name in neo4j_labels: + count_result = session.run(f"MATCH (n:{label_name}) RETURN count(n) as count") + record = count_result.single() + if record: + node_counts[label_name] = record['count'] + except Exception as e: + # Neo4j not available or error - continue without counts + current_app.logger.warning(f"Could not fetch Neo4j node counts: {e}") + + # Build response optimized for dropdowns + result = [] + for label in labels: + source_type = label.get('source_type', 'manual') + source_id = label.get('source_id') + + result.append({ + 'name': label['name'], + 'source': source_type, + 'source_display': _get_source_display(source_type, source_id), + 'node_count': node_counts.get(label['name'], 0), + 'instance_id': source_id if source_type == 'plugin_instance' else None + }) + + return jsonify({ + 'status': 'success', + 'labels': result + }), 200 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +def _get_source_display(source_type: str, source_id: str = None) -> str: + """ + Get human-readable source display string. + + Args: + source_type: Type of source (manual, system, plugin_instance) + source_id: Optional source ID (plugin instance ID, etc.) + + Returns: + Display string for the source + """ + if source_type == 'system': + return 'System' + elif source_type == 'plugin_instance' and source_id: + # Try to get plugin instance name + try: + from ...services.plugin_service import PluginService + plugin_service = PluginService(current_app) + instance = plugin_service.get_instance(source_id) + if instance: + return f"Plugin: {instance.get('name', source_id)}" + except: + pass + return f"Plugin: {source_id}" + elif source_type == 'manual': + return 'Manual' + else: + return source_type.title() + + @bp.route('/labels', methods=['GET']) def list_labels(): """ diff --git a/scidk/web/routes/api_logs.py b/scidk/web/routes/api_logs.py new file mode 100644 index 0000000..6e947ac --- /dev/null +++ b/scidk/web/routes/api_logs.py @@ -0,0 +1,124 @@ +"""Blueprint for Logs API routes (admin-only). + +Provides REST endpoints for: +- Listing log entries with filtering +- Exporting logs as a file +""" +from flask import Blueprint, jsonify, request, send_file +from pathlib import Path +from ..decorators import require_admin +import re +from datetime import datetime + +bp = Blueprint('logs_viewer', __name__, url_prefix='/api/logs') + + +@bp.get('/viewer') +@require_admin +def api_logs_viewer(): + """Get recent log entries with filtering. + + Query params: + level: Filter by log level (INFO, WARNING, ERROR) + source: Filter by logger name (e.g., 'scidk.core.scanner') + search: Text search in log messages + since: Unix timestamp - only return entries after this time + limit: Max entries to return (default: 100, max: 1000) + + Returns: + { + "entries": [ + { + "timestamp": "2026-02-09 14:07:32", + "level": "INFO", + "source": "scidk.core.scanner", + "message": "Scan started: /demo_data/" + }, + ... + ] + } + """ + log_dir = Path('logs') + log_file = log_dir / 'scidk.log' + + if not log_file.exists(): + return jsonify({'entries': []}) + + # Parse query params + level_filter = request.args.get('level', '').upper() + source_filter = request.args.get('source', '').lower() + search_query = request.args.get('search', '').lower() + since = request.args.get('since') + limit = min(int(request.args.get('limit', '100')), 1000) + + since_dt = None + if since: + try: + since_dt = datetime.fromtimestamp(float(since)) + except ValueError: + pass + + # Read log file (last N lines for performance) + entries = [] + line_pattern = re.compile( + r'\[(?P[\d\-\s:]+)\] \[(?P\w+)\] \[(?P[\w\.]+)\] (?P.*)' + ) + + # Read file in reverse for recent entries + with log_file.open('r') as f: + # For production, consider using a more efficient tail implementation + lines = f.readlines() + lines.reverse() # Newest first + + for line in lines: + if len(entries) >= limit: + break + + match = line_pattern.match(line.strip()) + if not match: + continue + + entry = match.groupdict() + + # Apply filters + if level_filter and entry['level'] != level_filter: + continue + + if source_filter and source_filter not in entry['source'].lower(): + continue + + if search_query and search_query not in entry['message'].lower(): + continue + + if since_dt: + try: + entry_dt = datetime.strptime(entry['timestamp'], '%Y-%m-%d %H:%M:%S') + if entry_dt < since_dt: + continue + except ValueError: + pass + + entries.append(entry) + + return jsonify({'entries': entries}) + + +@bp.get('/export') +@require_admin +def api_logs_export(): + """Export logs as text file. + + Returns: + Log file download + """ + log_dir = Path('logs') + log_file = log_dir / 'scidk.log' + + if not log_file.exists(): + return jsonify({'error': 'No log file found'}), 404 + + return send_file( + str(log_file.absolute()), + as_attachment=True, + download_name=f'scidk_logs_{datetime.now().strftime("%Y%m%d_%H%M%S")}.log' + ) diff --git a/scidk/web/routes/api_plugins.py b/scidk/web/routes/api_plugins.py new file mode 100644 index 0000000..ab69324 --- /dev/null +++ b/scidk/web/routes/api_plugins.py @@ -0,0 +1,796 @@ +"""API routes for plugin management. + +Provides endpoints to: +- List plugins +- Get plugin details +- Enable/disable plugins +- Get/update plugin settings +""" + +import logging +from flask import Blueprint, jsonify, request, current_app +from ...core.plugin_loader import set_plugin_enabled_state, get_plugin_enabled_state +from ...core.plugin_settings import ( + get_all_plugin_settings, + set_plugin_setting, + validate_settings_against_schema, + apply_schema_defaults +) + +logger = logging.getLogger(__name__) + +bp = Blueprint('api_plugins', __name__, url_prefix='/api/plugins') + + +def _get_ext(): + """Get SciDK extensions from current Flask app.""" + return current_app.extensions['scidk'] + + +@bp.get('') +def list_plugins(): + """List all plugins (loaded and discovered). + + Returns: + JSON response with list of plugins + """ + ext = _get_ext() + plugins_info = ext.get('plugins', {}) + + # Get loaded plugins + loaded = plugins_info.get('loaded', []) + + # Get plugin loader to discover all available plugins + loader = plugins_info.get('loader') + if loader: + all_discovered = loader.discover_plugins() + + # Add discovered but not loaded plugins to the list + loaded_names = {p.get('module_name') or p.get('name') for p in loaded} + for plugin_name in all_discovered: + if plugin_name not in loaded_names: + # Plugin discovered but not loaded (probably disabled) + loaded.append({ + 'name': plugin_name, + 'module_name': plugin_name, + 'version': 'N/A', + 'author': 'Unknown', + 'description': 'Plugin not loaded (may be disabled)', + 'enabled': get_plugin_enabled_state(plugin_name), + 'status': 'not_loaded' + }) + + return jsonify({ + 'success': True, + 'plugins': loaded, + 'failed': plugins_info.get('failed', {}) + }) + + +@bp.get('/') +def get_plugin(plugin_name): + """Get details about a specific plugin. + + Args: + plugin_name: Name of the plugin + + Returns: + JSON response with plugin details + """ + ext = _get_ext() + loader = ext.get('plugins', {}).get('loader') + + if not loader: + return jsonify({'success': False, 'error': 'Plugin loader not initialized'}), 500 + + info = loader.get_plugin_info(plugin_name) + if not info: + return jsonify({'success': False, 'error': 'Plugin not found'}), 404 + + return jsonify({ + 'success': True, + 'plugin': info + }) + + +@bp.post('//toggle') +def toggle_plugin(plugin_name): + """Enable or disable a plugin. + + Args: + plugin_name: Name of the plugin + + Request body: + { + "enabled": true/false + } + + Returns: + JSON response indicating success + """ + data = request.get_json() + if data is None: + return jsonify({'success': False, 'error': 'Invalid JSON'}), 400 + + enabled = data.get('enabled', True) + + # Save plugin state to database + success = set_plugin_enabled_state(plugin_name, enabled) + + if not success: + return jsonify({ + 'success': False, + 'error': 'Failed to update plugin state' + }), 500 + + return jsonify({ + 'success': True, + 'plugin': plugin_name, + 'enabled': enabled, + 'message': 'Plugin state updated. Restart required for changes to take effect.' + }) + + +@bp.get('//settings') +def get_plugin_settings(plugin_name): + """Get plugin configuration settings. + + Args: + plugin_name: Name of the plugin + + Returns: + JSON response with plugin settings and schema + """ + ext = _get_ext() + loader = ext.get('plugins', {}).get('loader') + + if not loader: + return jsonify({'success': False, 'error': 'Plugin loader not initialized'}), 500 + + # Check if plugin exists + plugin_info = loader.get_plugin_info(plugin_name) + if not plugin_info: + # Check if plugin is discovered but not loaded + discovered = loader.discover_plugins() + if plugin_name not in discovered: + return jsonify({'success': False, 'error': 'Plugin not found'}), 404 + + # Get current settings + settings = get_all_plugin_settings(plugin_name) + + # Try to get schema from plugin + schema = None + try: + import importlib + try: + module = importlib.import_module(f'plugins.{plugin_name}') + except ModuleNotFoundError: + module = importlib.import_module(plugin_name) + + if hasattr(module, 'get_settings_schema'): + schema = module.get_settings_schema() + # Apply defaults from schema + settings = apply_schema_defaults(settings, schema) + except Exception as e: + logger.warning(f"Could not get settings schema for plugin {plugin_name}: {e}") + + return jsonify({ + 'success': True, + 'plugin': plugin_name, + 'settings': settings, + 'schema': schema + }) + + +@bp.post('//settings') +def update_plugin_settings(plugin_name): + """Update plugin configuration settings. + + Args: + plugin_name: Name of the plugin + + Request body: + { + "settings": { + "key1": "value1", + "key2": "value2" + } + } + + Returns: + JSON response indicating success + """ + ext = _get_ext() + loader = ext.get('plugins', {}).get('loader') + + if not loader: + return jsonify({'success': False, 'error': 'Plugin loader not initialized'}), 500 + + # Check if plugin exists + discovered = loader.discover_plugins() + if plugin_name not in discovered: + return jsonify({'success': False, 'error': 'Plugin not found'}), 404 + + data = request.get_json() + if data is None: + return jsonify({'success': False, 'error': 'Invalid JSON'}), 400 + + new_settings = data.get('settings', {}) + if not isinstance(new_settings, dict): + return jsonify({'success': False, 'error': 'Settings must be a dictionary'}), 400 + + # Try to get and validate against schema + schema = None + try: + import importlib + try: + module = importlib.import_module(f'plugins.{plugin_name}') + except ModuleNotFoundError: + module = importlib.import_module(plugin_name) + + if hasattr(module, 'get_settings_schema'): + schema = module.get_settings_schema() + is_valid, errors = validate_settings_against_schema(new_settings, schema) + if not is_valid: + return jsonify({ + 'success': False, + 'error': 'Settings validation failed', + 'errors': errors + }), 400 + except Exception as e: + logger.warning(f"Could not validate settings for plugin {plugin_name}: {e}") + + # Save settings + try: + for key, value in new_settings.items(): + # Determine if field should be encrypted + encrypted = False + if schema and key in schema: + field_type = schema[key].get('type', 'text') + encrypted = (field_type == 'password') + + set_plugin_setting(plugin_name, key, value, encrypted=encrypted) + + return jsonify({ + 'success': True, + 'plugin': plugin_name, + 'message': 'Plugin settings updated successfully' + }) + + except Exception as e: + logger.error(f"Error updating plugin settings: {e}", exc_info=True) + return jsonify({ + 'success': False, + 'error': f'Failed to update settings: {str(e)}' + }), 500 + + +@bp.get('//settings/schema') +def get_plugin_settings_schema(plugin_name): + """Get plugin settings schema definition. + + Args: + plugin_name: Name of the plugin + + Returns: + JSON response with schema definition + """ + try: + import importlib + try: + module = importlib.import_module(f'plugins.{plugin_name}') + except ModuleNotFoundError: + module = importlib.import_module(plugin_name) + + if not hasattr(module, 'get_settings_schema'): + return jsonify({ + 'success': True, + 'plugin': plugin_name, + 'schema': None, + 'message': 'Plugin does not define a settings schema' + }) + + schema = module.get_settings_schema() + + return jsonify({ + 'success': True, + 'plugin': plugin_name, + 'schema': schema + }) + + except Exception as e: + logger.error(f"Error getting plugin settings schema: {e}", exc_info=True) + return jsonify({ + 'success': False, + 'error': f'Failed to get settings schema: {str(e)}' + }), 500 + + +# ============================================================================ +# Plugin Template & Instance Management +# ============================================================================ + +@bp.get('/templates') +def list_plugin_templates(): + """List all registered plugin templates. + + Returns: + JSON response with list of templates + """ + try: + ext = _get_ext() + registry = ext.get('plugin_templates') + + if not registry: + return jsonify({ + 'status': 'success', + 'templates': [] + }) + + templates = registry.list_templates() + + return jsonify({ + 'status': 'success', + 'templates': templates + }) + + except Exception as e: + logger.error(f"Error listing plugin templates: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.get('/templates/') +def get_plugin_template(template_id): + """Get details of a specific plugin template. + + Args: + template_id: Template identifier + + Returns: + JSON response with template details + """ + try: + ext = _get_ext() + registry = ext.get('plugin_templates') + + if not registry: + return jsonify({ + 'status': 'error', + 'error': 'Plugin template registry not initialized' + }), 500 + + template = registry.get_template(template_id) + + if not template: + return jsonify({ + 'status': 'error', + 'error': f'Template "{template_id}" not found' + }), 404 + + # Remove handler before serialization + template_data = {k: v for k, v in template.items() if k != 'handler'} + + return jsonify({ + 'status': 'success', + 'template': template_data + }) + + except Exception as e: + logger.error(f"Error getting plugin template: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.get('/instances') +def list_plugin_instances(): + """List all plugin instances. + + Query parameters: + template_id: Filter by template ID + enabled_only: Only return enabled instances (true/false) + + Returns: + JSON response with list of instances + """ + try: + ext = _get_ext() + manager = ext.get('plugin_instances') + + if not manager: + return jsonify({ + 'status': 'success', + 'instances': [] + }) + + template_id = request.args.get('template_id') + enabled_only = request.args.get('enabled_only', 'false').lower() == 'true' + + instances = manager.list_instances(template_id=template_id, enabled_only=enabled_only) + + return jsonify({ + 'status': 'success', + 'instances': instances + }) + + except Exception as e: + logger.error(f"Error listing plugin instances: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.post('/instances') +def create_plugin_instance(): + """Create a new plugin instance. + + Request body: + { + "template_id": "table_loader", + "name": "iLab Equipment 2024", + "config": { + "file_path": "/data/equipment.xlsx", + "table_name": "ilab_equipment_2024" + } + } + + Returns: + JSON response with created instance + """ + try: + ext = _get_ext() + manager = ext.get('plugin_instances') + + if not manager: + return jsonify({ + 'status': 'error', + 'error': 'Plugin instance manager not initialized' + }), 500 + + data = request.get_json() + + if not data or 'template_id' not in data or 'name' not in data: + return jsonify({ + 'status': 'error', + 'error': 'Missing required fields: template_id, name' + }), 400 + + template_id = data['template_id'] + name = data['name'] + config = data.get('config', {}) + + # Verify template exists + template_registry = ext.get('plugin_templates') + if template_registry: + template = template_registry.get_template(template_id) + if not template: + return jsonify({ + 'status': 'error', + 'error': f'Template "{template_id}" not found' + }), 404 + + # Create instance + instance_id = manager.create_instance(template_id, name, config) + instance = manager.get_instance(instance_id) + + return jsonify({ + 'status': 'success', + 'instance': instance + }), 201 + + except ValueError as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 400 + except Exception as e: + logger.error(f"Error creating plugin instance: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.get('/instances/') +def get_plugin_instance(instance_id): + """Get details of a specific plugin instance. + + Args: + instance_id: Instance identifier + + Returns: + JSON response with instance details + """ + try: + ext = _get_ext() + manager = ext.get('plugin_instances') + + if not manager: + return jsonify({ + 'status': 'error', + 'error': 'Plugin instance manager not initialized' + }), 500 + + instance = manager.get_instance(instance_id) + + if not instance: + return jsonify({ + 'status': 'error', + 'error': f'Instance "{instance_id}" not found' + }), 404 + + return jsonify({ + 'status': 'success', + 'instance': instance + }) + + except Exception as e: + logger.error(f"Error getting plugin instance: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.put('/instances/') +def update_plugin_instance(instance_id): + """Update a plugin instance. + + Request body: + { + "name": "New Name", // optional + "config": {...}, // optional + "enabled": true // optional + } + + Returns: + JSON response with updated instance + """ + try: + ext = _get_ext() + manager = ext.get('plugin_instances') + + if not manager: + return jsonify({ + 'status': 'error', + 'error': 'Plugin instance manager not initialized' + }), 500 + + data = request.get_json() + if not data: + return jsonify({ + 'status': 'error', + 'error': 'No data provided' + }), 400 + + # Update instance + success = manager.update_instance( + instance_id, + name=data.get('name'), + config=data.get('config'), + enabled=data.get('enabled') + ) + + if not success: + return jsonify({ + 'status': 'error', + 'error': f'Instance "{instance_id}" not found' + }), 404 + + # Return updated instance + instance = manager.get_instance(instance_id) + + return jsonify({ + 'status': 'success', + 'instance': instance + }) + + except Exception as e: + logger.error(f"Error updating plugin instance: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.delete('/instances/') +def delete_plugin_instance(instance_id): + """Delete a plugin instance. + + Args: + instance_id: Instance identifier + + Returns: + JSON response confirming deletion + """ + try: + ext = _get_ext() + manager = ext.get('plugin_instances') + + if not manager: + return jsonify({ + 'status': 'error', + 'error': 'Plugin instance manager not initialized' + }), 500 + + success = manager.delete_instance(instance_id) + + if not success: + return jsonify({ + 'status': 'error', + 'error': f'Instance "{instance_id}" not found' + }), 404 + + return jsonify({ + 'status': 'success', + 'message': 'Instance deleted successfully' + }) + + except Exception as e: + logger.error(f"Error deleting plugin instance: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.post('/instances//execute') +def execute_plugin_instance(instance_id): + """Execute a plugin instance. + + Args: + instance_id: Instance identifier + + Returns: + JSON response with execution result + """ + try: + ext = _get_ext() + manager = ext.get('plugin_instances') + template_registry = ext.get('plugin_templates') + + if not manager or not template_registry: + return jsonify({ + 'status': 'error', + 'error': 'Plugin system not initialized' + }), 500 + + # Get instance + instance = manager.get_instance(instance_id) + if not instance: + return jsonify({ + 'status': 'error', + 'error': f'Instance "{instance_id}" not found' + }), 404 + + # Check if enabled + if not instance['enabled']: + return jsonify({ + 'status': 'error', + 'error': 'Instance is disabled' + }), 400 + + # Execute template with instance config + try: + result = template_registry.execute_template( + instance['template_id'], + instance['config'] + ) + + # Record execution + manager.record_execution(instance_id, result, status='active') + + return jsonify({ + 'status': 'success', + 'result': result + }) + + except Exception as exec_error: + # Record failed execution + error_result = {'error': str(exec_error)} + manager.record_execution(instance_id, error_result, status='error') + raise + + except Exception as e: + logger.error(f"Error executing plugin instance: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.get('/instances/stats') +def get_plugin_instance_stats(): + """Get statistics about plugin instances. + + Returns: + JSON response with statistics + """ + try: + ext = _get_ext() + manager = ext.get('plugin_instances') + + if not manager: + return jsonify({ + 'status': 'success', + 'stats': { + 'total': 0, + 'by_status': {}, + 'by_template': {} + } + }) + + stats = manager.get_stats() + + return jsonify({ + 'status': 'success', + 'stats': stats + }) + + except Exception as e: + logger.error(f"Error getting plugin instance stats: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.post('/instances//publish-label') +def publish_plugin_label(instance_id): + """Publish plugin instance schema as a Label. + + Request body: + { + "label_name": "LabEquipment", + "primary_key": "serial_number", + "property_mapping": { + "serial_number": {"type": "string", "required": true}, + "name": {"type": "string", "required": true} + }, + "sync_strategy": "on_demand" + } + + Returns: + JSON response with success status + """ + try: + ext = _get_ext() + manager = ext.get('plugin_instances') + + if not manager: + return jsonify({ + 'status': 'error', + 'error': 'Plugin instance manager not initialized' + }), 500 + + data = request.get_json() + if not data or 'label_name' not in data: + return jsonify({ + 'status': 'error', + 'error': 'Missing required field: label_name' + }), 400 + + success = manager.publish_label_schema(instance_id, data, app=current_app) + + if not success: + return jsonify({ + 'status': 'error', + 'error': 'Failed to publish label schema' + }), 500 + + return jsonify({ + 'status': 'success', + 'message': f"Label '{data['label_name']}' published successfully" + }) + + except Exception as e: + logger.error(f"Error publishing label: {e}", exc_info=True) + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 diff --git a/scidk/web/routes/api_settings.py b/scidk/web/routes/api_settings.py index 66e9532..8df093d 100644 --- a/scidk/web/routes/api_settings.py +++ b/scidk/web/routes/api_settings.py @@ -1419,3 +1419,93 @@ def download_backup_file(filename): 'status': 'error', 'error': str(e) }), 500 + + +@bp.route('/settings/plugin-endpoints', methods=['GET']) +def list_plugin_endpoints(): + """ + Get all plugin-registered label endpoints. + + These are endpoints registered by plugins that map to Label types. + Returns both the endpoint configuration and the plugin that registered it. + + Returns: + { + "status": "success", + "endpoints": [ + { + "name": "iLab Services", + "endpoint": "/api/integrations/ilab", + "label_type": "iLabService", + "auth_required": true, + "test_url": "/api/integrations/ilab/test", + "plugin": "ilab_plugin", + "description": "Integration with iLab service management system", + "source": "plugin" + } + ] + } + """ + try: + registry = current_app.extensions.get('scidk', {}).get('label_endpoints') + if not registry: + return jsonify({ + 'status': 'success', + 'endpoints': [] + }), 200 + + endpoints = registry.list_endpoints() + return jsonify({ + 'status': 'success', + 'endpoints': endpoints + }), 200 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 + + +@bp.route('/settings/plugin-endpoints/', methods=['GET']) +def get_plugin_endpoint(endpoint_path): + """ + Get a specific plugin-registered endpoint. + + Args: + endpoint_path: The endpoint path (e.g., "/api/integrations/ilab") + + Returns: + { + "status": "success", + "endpoint": {...} + } + """ + try: + registry = current_app.extensions.get('scidk', {}).get('label_endpoints') + if not registry: + return jsonify({ + 'status': 'error', + 'error': 'Label endpoint registry not initialized' + }), 500 + + # Normalize endpoint path to include leading slash + if not endpoint_path.startswith('/'): + endpoint_path = '/' + endpoint_path + + endpoint = registry.get_endpoint(endpoint_path) + + if not endpoint: + return jsonify({ + 'status': 'error', + 'error': f'Endpoint "{endpoint_path}" not found' + }), 404 + + return jsonify({ + 'status': 'success', + 'endpoint': endpoint + }), 200 + except Exception as e: + return jsonify({ + 'status': 'error', + 'error': str(e) + }), 500 diff --git a/scidk/web/routes/api_tasks.py b/scidk/web/routes/api_tasks.py index a797591..a2e05e1 100644 --- a/scidk/web/routes/api_tasks.py +++ b/scidk/web/routes/api_tasks.py @@ -64,6 +64,8 @@ def api_tasks_create(): 'error': None, 'cancel_requested': False, 'selection': data.get('selection') or {}, + 'eta_seconds': None, + 'status_message': 'Initializing scan...', } current_app.extensions['scidk'].setdefault('tasks', {})[task_id] = task app = current_app._get_current_object() @@ -86,8 +88,10 @@ def _worker(): if provider_id in ('local_fs', 'mounted_fs'): base = Path(path) # Estimate total: Python traversal + task['status_message'] = 'Counting files...' files_list = [p for p in _get_ext()['fs']._iter_files_python(base, recursive=recursive)] task['total'] = len(files_list) + task['status_message'] = f'Processing {task["total"]} files...' # Build rows like api_scan, apply selection rules when provided sel = (task.get('selection') or {}) rules = sel.get('rules') or [] @@ -199,6 +203,7 @@ def _row_from_local(pth: Path, typ: str) -> tuple: ingested = pix.batch_insert_files(rows) # In-memory datasets and progress processed = 0 + eta_window_start = time.time() for fpath in items_files: if task.get('cancel_requested'): task['status'] = 'canceled'; task['ended'] = time.time(); return @@ -210,6 +215,14 @@ def _row_from_local(pth: Path, typ: str) -> tuple: processed += 1; task['processed'] = processed if task['total']: task['progress'] = processed / task['total'] + # Calculate ETA based on processing rate (update every 10 files to reduce overhead) + if processed % 10 == 0 or processed == task['total']: + elapsed = time.time() - eta_window_start + if elapsed > 0 and processed > 0: + rate = processed / elapsed + remaining = task['total'] - processed + task['eta_seconds'] = int(remaining / rate) if rate > 0 else None + task['status_message'] = f'Processing {processed}/{task["total"]} files... ({int(rate)}/s)' file_count = len(items_files) # Folders meta for d in items_dirs: @@ -221,6 +234,7 @@ def _row_from_local(pth: Path, typ: str) -> tuple: folder_count = len(items_dirs) elif provider_id == 'rclone': + task['status_message'] = 'Listing remote files...' provs = current_app.extensions['scidk'].get('providers') prov = provs.get('rclone') if provs else None if not prov: @@ -229,6 +243,7 @@ def _row_from_local(pth: Path, typ: str) -> tuple: fast_list = True if recursive else False try: items = prov.list_files(path, recursive=recursive, fast_list=fast_list) # type: ignore[attr-defined] + task['status_message'] = f'Processing {len(items or [])} remote items...' except Exception as ee: raise RuntimeError(str(ee)) # Selection for remote: apply only to files using full remote path @@ -304,6 +319,8 @@ def _add_folder(full_path: str, name: str, parent: str): pass file_count += 1 task['processed'] = file_count + if file_count % 50 == 0: + task['status_message'] = f'Processed {file_count} remote files...' if recursive and name: parts = [p for p in (name.split('/') if isinstance(name, str) else []) if p] cur = '' @@ -483,6 +500,8 @@ def _add_folder(full_path: str, name: str, parent: str): 'neo4j_error': None, 'error': None, 'cancel_requested': False, + 'eta_seconds': None, + 'status_message': 'Preparing commit...', } current_app.extensions['scidk'].setdefault('tasks', {})[task_id] = task app = current_app._get_current_object() @@ -494,6 +513,7 @@ def _worker_commit(): task['status'] = 'canceled' task['ended'] = time.time() return + task['status_message'] = 'Committing to in-memory graph...' g = current_app.extensions['scidk']['graph'] # In-memory commit first (idempotent) g.commit_scan(s) @@ -530,6 +550,7 @@ def _worker_commit(): except Exception: pass # Build rows once using shared builder when index mode is enabled + task['status_message'] = 'Building commit rows...' use_index = (os.environ.get('SCIDK_COMMIT_FROM_INDEX') or '').strip().lower() in ('1','true','yes','y','on') if use_index: from ...core.commit_rows_from_index import build_rows_for_scan_from_index @@ -541,12 +562,14 @@ def _worker_commit(): task['processed'] = total if total: task['progress'] = total / (task.get('total') or (total + 1)) + task['status_message'] = f'Built commit rows: {len(rows)} files, {len(folder_rows)} folders' # Allow cancel before Neo4j step if task.get('cancel_requested'): task['status'] = 'canceled' task['ended'] = time.time() return # Neo4j write if configured via helper + task['status_message'] = 'Writing to Neo4j...' uri, user, pwd, database, auth_mode = _get_neo4j_params() def _on_prog(e, p): try: diff --git a/scidk/web/routes/ui.py b/scidk/web/routes/ui.py index afdd241..33b4c96 100644 --- a/scidk/web/routes/ui.py +++ b/scidk/web/routes/ui.py @@ -155,9 +155,9 @@ def interpreters(): @bp.get('/extensions') -def extensions_legacy(): - """Backward-compatible route - redirects to interpreters section.""" - return redirect(url_for('ui.index') + '#interpreters') +def extensions(): + """Redirect to plugins section on home page.""" + return redirect(url_for('ui.index') + '#plugins') @bp.get('/rocrate_view') diff --git a/scripts/seed_demo_data.py b/scripts/seed_demo_data.py new file mode 100755 index 0000000..9ab2c1e --- /dev/null +++ b/scripts/seed_demo_data.py @@ -0,0 +1,392 @@ +#!/usr/bin/env python3 +"""Seed demo data for SciDK testing and demonstrations. + +This script creates a consistent set of demo data including: +- Demo users (admin, facility_staff, billing_team) +- Sample files in demo_data directory +- Sample labels (Projects, Samples, Researchers, Equipment) +- Sample links (relationships between entities) +- Sample iLab data (if iLab plugin is installed) + +The script can be run multiple times idempotently and supports +a --reset flag to clean all data first. +""" + +import click +import os +import sys +import time +import shutil +import sqlite3 +from pathlib import Path + +# Add parent directory to path so we can import scidk +sys.path.insert(0, str(Path(__file__).parent.parent)) + +from scidk.core.auth import AuthManager +from scidk.core import path_index_sqlite as pix + + +@click.command() +@click.option('--reset', is_flag=True, help='Clean all existing data first') +@click.option('--db-path', default='scidk_settings.db', help='Path to settings database') +@click.option('--pix-path', default='data/path_index.db', help='Path to path index database') +@click.option('--neo4j', is_flag=True, help='Also seed Neo4j graph database') +def seed_demo_data(reset, db_path, pix_path, neo4j): + """Seed demo data for testing and demonstrations. + + Creates a consistent set of sample users, files, labels, and relationships + that can be used for demos and testing. + + Examples: + # Seed data (preserving existing data) + python scripts/seed_demo_data.py + + # Clean and reseed all data + python scripts/seed_demo_data.py --reset + + # Seed with Neo4j graph sync + python scripts/seed_demo_data.py --neo4j + """ + print("🌱 SciDK Demo Data Seeder") + print("=" * 60) + + if reset: + print("\n⚠️ Reset mode: Cleaning existing data...") + clean_demo_data(db_path, pix_path, neo4j) + print("✓ Existing data cleaned") + + # Create demo data directory + demo_data_dir = Path('demo_data') + demo_data_dir.mkdir(exist_ok=True) + + # Seed users + print("\n👥 Creating demo users...") + auth = AuthManager(db_path) + users_created = seed_users(auth) + print(f"✓ Created {users_created} demo users") + + # Seed sample files + print("\n📁 Creating sample files...") + files_created = seed_sample_files(demo_data_dir) + print(f"✓ Created {files_created} sample files") + + # Seed labels (if Neo4j integration exists) + if neo4j: + print("\n🏷️ Creating sample labels...") + labels_created = seed_labels() + print(f"✓ Created {labels_created} sample labels") + + print("\n🔗 Creating sample relationships...") + links_created = seed_relationships() + print(f"✓ Created {links_created} sample relationships") + + # Seed iLab data (if plugin exists) + print("\n🧪 Checking for iLab plugin...") + if check_ilab_plugin(): + print("✓ iLab plugin found, seeding sample data...") + ilab_records = seed_ilab_data(demo_data_dir) + print(f"✓ Created {ilab_records} iLab records") + else: + print(" (iLab plugin not installed, skipping)") + + # Print summary + print("\n" + "=" * 60) + print("✅ Demo data seeded successfully!") + print("\n📋 Demo User Credentials:") + print(" • admin / demo123 (Admin role)") + print(" • facility_staff / demo123 (User role)") + print(" • billing_team / demo123 (User role)") + print("\n📂 Sample Data Location:") + print(f" • Files: {demo_data_dir.absolute()}") + print(f" • Database: {db_path}") + if neo4j: + print(" • Neo4j: Labels and relationships synced") + print("\n💡 Tip: Run with --reset to clean and reseed all data") + + +def clean_demo_data(db_path: str, pix_path: str, neo4j: bool): + """Clean all demo data from databases and file system.""" + # Clean auth database (users and sessions) + if os.path.exists(db_path): + conn = sqlite3.connect(db_path) + # Delete all users except those that might have been created manually + conn.execute("DELETE FROM auth_users WHERE username IN ('admin', 'facility_staff', 'billing_team')") + conn.execute("DELETE FROM auth_sessions") + conn.execute("DELETE FROM auth_failed_attempts") + conn.commit() + conn.close() + + # Clean path index database + if os.path.exists(pix_path): + conn = sqlite3.connect(pix_path) + # Clear scan data + conn.execute("DELETE FROM scans") + conn.execute("DELETE FROM scan_paths") + conn.commit() + conn.close() + + # Clean Neo4j if requested + if neo4j: + try: + from scidk.core.graph_db import get_neo4j_driver + driver = get_neo4j_driver() + with driver.session() as session: + # Delete all demo labels + session.run("MATCH (n) WHERE n.source = 'demo' DELETE n") + # Delete all demo relationships + session.run("MATCH ()-[r {source: 'demo'}]-() DELETE r") + driver.close() + except Exception as e: + print(f" Warning: Could not clean Neo4j data: {e}") + + # Clean demo_data directory + demo_data_dir = Path('demo_data') + if demo_data_dir.exists(): + shutil.rmtree(demo_data_dir) + + +def seed_users(auth: AuthManager) -> int: + """Create demo users.""" + users = [ + ('admin', 'demo123', 'admin'), + ('facility_staff', 'demo123', 'user'), + ('billing_team', 'demo123', 'user'), + ] + + created = 0 + for username, password, role in users: + # Check if user already exists + existing = auth.get_user_by_username(username) + if existing: + print(f" • {username} (already exists)") + continue + + user_id = auth.create_user(username, password, role=role, created_by='system') + if user_id: + print(f" • {username} ({role})") + created += 1 + else: + print(f" ✗ Failed to create {username}") + + return created + + +def seed_sample_files(demo_data_dir: Path) -> int: + """Create sample files in demo_data directory.""" + # Create project directories + projects = { + 'Project_A_Cancer_Research': [ + 'experiments/exp001_cell_culture.xlsx', + 'experiments/exp002_drug_treatment.xlsx', + 'results/microscopy/sample_001.tif', + 'results/microscopy/sample_002.tif', + 'results/flow_cytometry/analysis_20240115.fcs', + 'protocols/cell_culture_protocol.pdf', + 'README.md' + ], + 'Project_B_Proteomics': [ + 'raw_data/mass_spec_run001.raw', + 'raw_data/mass_spec_run002.raw', + 'analysis/protein_identification.xlsx', + 'analysis/go_enrichment.csv', + 'figures/volcano_plot.png', + 'README.md' + ], + 'Core_Facility_Equipment': [ + 'equipment_logs/confocal_microscope_2024.xlsx', + 'equipment_logs/flow_cytometer_2024.xlsx', + 'maintenance/service_records.pdf', + 'training/microscopy_training_slides.pdf', + 'README.md' + ] + } + + files_created = 0 + for project, files in projects.items(): + project_dir = demo_data_dir / project + project_dir.mkdir(exist_ok=True) + + # Create README for project + readme_path = project_dir / 'README.md' + if not readme_path.exists(): + readme_content = f"# {project.replace('_', ' ')}\n\nDemo project for SciDK testing.\n" + readme_path.write_text(readme_content) + + for file_path in files: + full_path = project_dir / file_path + full_path.parent.mkdir(parents=True, exist_ok=True) + + if not full_path.exists(): + # Create placeholder file with some content + if full_path.suffix == '.md': + content = f"# {full_path.stem}\n\nDemo file for testing.\n" + elif full_path.suffix in ['.xlsx', '.csv']: + content = "Sample,Value\nA,1\nB,2\nC,3\n" + elif full_path.suffix == '.pdf': + content = "Placeholder PDF file for demo\n" + else: + content = f"Demo file: {full_path.name}\n" + + full_path.write_text(content) + files_created += 1 + + return files_created + + +def seed_labels() -> int: + """Create sample labels in Neo4j (if available).""" + try: + from scidk.core.graph_db import get_neo4j_driver + + driver = get_neo4j_driver() + with driver.session() as session: + # Create sample Project labels + projects = [ + {'name': 'Cancer Research - Project A', 'pi': 'Dr. Alice Smith', 'status': 'active'}, + {'name': 'Proteomics Study - Project B', 'pi': 'Dr. Bob Jones', 'status': 'active'}, + {'name': 'Core Facility Operations', 'pi': 'Dr. Carol Williams', 'status': 'active'} + ] + + for project in projects: + session.run( + """ + CREATE (p:Project { + name: $name, + pi: $pi, + status: $status, + source: 'demo', + created_at: datetime() + }) + """, + **project + ) + + # Create sample Researcher labels + researchers = [ + {'name': 'Dr. Alice Smith', 'department': 'Oncology', 'email': 'alice.smith@university.edu'}, + {'name': 'Dr. Bob Jones', 'department': 'Biochemistry', 'email': 'bob.jones@university.edu'}, + {'name': 'Dr. Carol Williams', 'department': 'Core Facilities', 'email': 'carol.williams@university.edu'} + ] + + for researcher in researchers: + session.run( + """ + CREATE (r:Researcher { + name: $name, + department: $department, + email: $email, + source: 'demo', + created_at: datetime() + }) + """, + **researcher + ) + + # Create sample Equipment labels + equipment = [ + {'name': 'Confocal Microscope LSM 880', 'core': 'Microscopy Core', 'equipment_id': 'EQ-001'}, + {'name': 'Flow Cytometer BD FACS Aria III', 'core': 'Flow Cytometry Core', 'equipment_id': 'EQ-002'}, + {'name': 'Mass Spectrometer Orbitrap Fusion', 'core': 'Proteomics Core', 'equipment_id': 'EQ-003'} + ] + + for item in equipment: + session.run( + """ + CREATE (e:Equipment { + name: $name, + core: $core, + equipment_id: $equipment_id, + source: 'demo', + created_at: datetime() + }) + """, + **item + ) + + driver.close() + return len(projects) + len(researchers) + len(equipment) + + except Exception as e: + print(f" Warning: Could not seed Neo4j labels: {e}") + return 0 + + +def seed_relationships() -> int: + """Create sample relationships in Neo4j (if available).""" + try: + from scidk.core.graph_db import get_neo4j_driver + + driver = get_neo4j_driver() + with driver.session() as session: + # Link researchers to projects + relationships = [ + ("Dr. Alice Smith", "Cancer Research - Project A", "LEADS"), + ("Dr. Bob Jones", "Proteomics Study - Project B", "LEADS"), + ("Dr. Carol Williams", "Core Facility Operations", "MANAGES"), + ] + + created = 0 + for researcher_name, project_name, rel_type in relationships: + result = session.run( + f""" + MATCH (r:Researcher {{name: $researcher_name}}) + MATCH (p:Project {{name: $project_name}}) + CREATE (r)-[:{rel_type} {{source: 'demo', created_at: datetime()}}]->(p) + RETURN r, p + """, + researcher_name=researcher_name, + project_name=project_name + ) + if result.single(): + created += 1 + + driver.close() + return created + + except Exception as e: + print(f" Warning: Could not seed Neo4j relationships: {e}") + return 0 + + +def check_ilab_plugin() -> bool: + """Check if iLab plugin is installed.""" + plugin_dir = Path('plugins/ilab_table_loader') + return plugin_dir.exists() and (plugin_dir / '__init__.py').exists() + + +def seed_ilab_data(demo_data_dir: Path) -> int: + """Create sample iLab data files.""" + try: + import pandas as pd + + # Use the sample files we already created + fixtures_dir = Path('tests/fixtures') + ilab_dir = demo_data_dir / 'iLab_Exports' + ilab_dir.mkdir(exist_ok=True) + + # Copy sample files if they exist + sample_files = [ + 'ilab_equipment_sample.csv', + 'ilab_services_sample.csv', + 'ilab_pi_directory_sample.csv' + ] + + copied = 0 + for filename in sample_files: + src = fixtures_dir / filename + dst = ilab_dir / filename + if src.exists() and not dst.exists(): + shutil.copy(src, dst) + copied += 1 + print(f" • {filename}") + + return copied + + except ImportError: + print(" Warning: pandas not available, skipping iLab data creation") + return 0 + + +if __name__ == '__main__': + seed_demo_data() diff --git a/tests/conftest.py b/tests/conftest.py index be56d2f..a20787d 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -42,6 +42,9 @@ def _pin_repo_local_test_env(): # Prefer sqlite-backed state for tests by default os.environ.setdefault("SCIDK_STATE_BACKEND", "sqlite") + # Settings DB for auth and configuration + os.environ.setdefault("SCIDK_SETTINGS_DB", str(db_dir / 'test_settings.db')) + # Providers and auth safe defaults os.environ.setdefault("SCIDK_PROVIDERS", "local_fs,mounted_fs") os.environ.setdefault("NEO4J_AUTH", "none") @@ -159,7 +162,7 @@ def _cleanup_test_labels_from_db(db_path: Path): # List of test label patterns to delete test_patterns = [ 'E2E%', # E2E test labels - 'Test%', # TestLabel, TestNode, etc + 'Test%', # TestLabel, TestNode, TestProject42, TestMulti*, etc 'Person%', # From arrows test 'Company%', # From arrows test 'Project%', # Multiple test uses @@ -273,6 +276,7 @@ def app(): application.config.update({ "TESTING": True, "state.backend": (os.environ.get("SCIDK_STATE_BACKEND") or "sqlite").lower(), + "SCIDK_SETTINGS_DB": os.environ.get("SCIDK_SETTINGS_DB", "scidk_settings.db"), }) ctx = application.app_context() ctx.push() diff --git a/tests/fixtures/create_ilab_samples.py b/tests/fixtures/create_ilab_samples.py new file mode 100644 index 0000000..dd9c03d --- /dev/null +++ b/tests/fixtures/create_ilab_samples.py @@ -0,0 +1,163 @@ +"""Script to create sample iLab export files for testing and demos.""" + +import pandas as pd +from pathlib import Path + +# Get the fixtures directory +fixtures_dir = Path(__file__).parent + +# Create Equipment sample +equipment_data = { + 'Service Name': [ + 'Confocal Microscope LSM 880', + 'Flow Cytometer BD FACS Aria III', + 'Mass Spectrometer Orbitrap Fusion', + 'Electron Microscope TEM 120kV', + 'NMR Spectrometer 600MHz' + ], + 'Core': [ + 'Microscopy Core', + 'Flow Cytometry Core', + 'Proteomics Core', + 'Electron Microscopy Core', + 'NMR Core' + ], + 'PI': [ + 'Dr. Alice Smith', + 'Dr. Bob Jones', + 'Dr. Carol Williams', + 'Dr. David Brown', + 'Dr. Emily Davis' + ], + 'Location': [ + 'Biology Building, Room 101', + 'Medical Sciences, Room 205', + 'Chemistry Building, Room 310', + 'Materials Science, Room 150', + 'Chemistry Building, Room 220' + ], + 'Equipment ID': [ + 'EQ-001', + 'EQ-002', + 'EQ-003', + 'EQ-004', + 'EQ-005' + ], + 'Description': [ + 'Advanced confocal imaging with spectral detection', + 'High-speed cell sorting and multicolor analysis', + 'High-resolution protein mass spectrometry', + 'Transmission electron microscopy for nano-scale imaging', + 'High-field NMR for structural analysis' + ] +} + +equipment_df = pd.DataFrame(equipment_data) + +# Save as both CSV and Excel +equipment_df.to_csv(fixtures_dir / 'ilab_equipment_sample.csv', index=False) +equipment_df.to_excel(fixtures_dir / 'ilab_equipment_sample.xlsx', index=False, engine='openpyxl') + +print(f"✓ Created {fixtures_dir / 'ilab_equipment_sample.csv'}") +print(f"✓ Created {fixtures_dir / 'ilab_equipment_sample.xlsx'}") + +# Create Services sample +services_data = { + 'Service Name': [ + 'Confocal Microscopy Training', + 'Flow Cytometry Analysis', + 'Mass Spectrometry Run', + 'Sample Preparation - Proteomics', + 'NMR Spectroscopy Analysis' + ], + 'Core': [ + 'Microscopy Core', + 'Flow Cytometry Core', + 'Proteomics Core', + 'Proteomics Core', + 'NMR Core' + ], + 'Rate Per Hour': [50, 75, 100, 60, 85], + 'Service ID': [ + 'SVC-001', + 'SVC-002', + 'SVC-003', + 'SVC-004', + 'SVC-005' + ], + 'Active': ['Yes', 'Yes', 'Yes', 'Yes', 'No'] +} + +services_df = pd.DataFrame(services_data) +services_df.to_csv(fixtures_dir / 'ilab_services_sample.csv', index=False) +services_df.to_excel(fixtures_dir / 'ilab_services_sample.xlsx', index=False, engine='openpyxl') + +print(f"✓ Created {fixtures_dir / 'ilab_services_sample.csv'}") +print(f"✓ Created {fixtures_dir / 'ilab_services_sample.xlsx'}") + +# Create PI Directory sample +pi_data = { + 'PI Name': [ + 'Dr. Alice Smith', + 'Dr. Bob Jones', + 'Dr. Carol Williams', + 'Dr. David Brown', + 'Dr. Emily Davis', + 'Dr. Frank Miller', + 'Dr. Grace Wilson' + ], + 'Email': [ + 'alice.smith@university.edu', + 'bob.jones@university.edu', + 'carol.williams@university.edu', + 'david.brown@university.edu', + 'emily.davis@university.edu', + 'frank.miller@university.edu', + 'grace.wilson@university.edu' + ], + 'Department': [ + 'Biology', + 'Molecular Medicine', + 'Chemistry', + 'Materials Science', + 'Chemistry', + 'Neuroscience', + 'Immunology' + ], + 'Lab': [ + 'Smith Lab - Cell Biology', + 'Jones Lab - Cancer Research', + 'Williams Lab - Protein Chemistry', + 'Brown Lab - Nanomaterials', + 'Davis Lab - Structural Chemistry', + 'Miller Lab - Systems Neuroscience', + 'Wilson Lab - Adaptive Immunity' + ], + 'Phone': [ + '555-0101', + '555-0102', + '555-0103', + '555-0104', + '555-0105', + '555-0106', + '555-0107' + ], + 'Office': [ + 'Biology 101', + 'Medical Sciences 205', + 'Chemistry 310', + 'Materials Science 150', + 'Chemistry 220', + 'Neuroscience 412', + 'Immunology 305' + ] +} + +pi_df = pd.DataFrame(pi_data) +pi_df.to_csv(fixtures_dir / 'ilab_pi_directory_sample.csv', index=False) +pi_df.to_excel(fixtures_dir / 'ilab_pi_directory_sample.xlsx', index=False, engine='openpyxl') + +print(f"✓ Created {fixtures_dir / 'ilab_pi_directory_sample.csv'}") +print(f"✓ Created {fixtures_dir / 'ilab_pi_directory_sample.xlsx'}") + +print("\n✅ All sample iLab files created successfully!") diff --git a/tests/fixtures/ilab_equipment_sample.csv b/tests/fixtures/ilab_equipment_sample.csv new file mode 100644 index 0000000..22b7cbf --- /dev/null +++ b/tests/fixtures/ilab_equipment_sample.csv @@ -0,0 +1,6 @@ +Service Name,Core,PI,Location,Equipment ID,Description +Confocal Microscope LSM 880,Microscopy Core,Dr. Alice Smith,"Biology Building, Room 101",EQ-001,Advanced confocal imaging with spectral detection +Flow Cytometer BD FACS Aria III,Flow Cytometry Core,Dr. Bob Jones,"Medical Sciences, Room 205",EQ-002,High-speed cell sorting and multicolor analysis +Mass Spectrometer Orbitrap Fusion,Proteomics Core,Dr. Carol Williams,"Chemistry Building, Room 310",EQ-003,High-resolution protein mass spectrometry +Electron Microscope TEM 120kV,Electron Microscopy Core,Dr. David Brown,"Materials Science, Room 150",EQ-004,Transmission electron microscopy for nano-scale imaging +NMR Spectrometer 600MHz,NMR Core,Dr. Emily Davis,"Chemistry Building, Room 220",EQ-005,High-field NMR for structural analysis diff --git a/tests/fixtures/ilab_equipment_sample.xlsx b/tests/fixtures/ilab_equipment_sample.xlsx new file mode 100644 index 0000000..46347b3 Binary files /dev/null and b/tests/fixtures/ilab_equipment_sample.xlsx differ diff --git a/tests/fixtures/ilab_pi_directory_sample.csv b/tests/fixtures/ilab_pi_directory_sample.csv new file mode 100644 index 0000000..e5743ce --- /dev/null +++ b/tests/fixtures/ilab_pi_directory_sample.csv @@ -0,0 +1,8 @@ +PI Name,Email,Department,Lab,Phone,Office +Dr. Alice Smith,alice.smith@university.edu,Biology,Smith Lab - Cell Biology,555-0101,Biology 101 +Dr. Bob Jones,bob.jones@university.edu,Molecular Medicine,Jones Lab - Cancer Research,555-0102,Medical Sciences 205 +Dr. Carol Williams,carol.williams@university.edu,Chemistry,Williams Lab - Protein Chemistry,555-0103,Chemistry 310 +Dr. David Brown,david.brown@university.edu,Materials Science,Brown Lab - Nanomaterials,555-0104,Materials Science 150 +Dr. Emily Davis,emily.davis@university.edu,Chemistry,Davis Lab - Structural Chemistry,555-0105,Chemistry 220 +Dr. Frank Miller,frank.miller@university.edu,Neuroscience,Miller Lab - Systems Neuroscience,555-0106,Neuroscience 412 +Dr. Grace Wilson,grace.wilson@university.edu,Immunology,Wilson Lab - Adaptive Immunity,555-0107,Immunology 305 diff --git a/tests/fixtures/ilab_pi_directory_sample.xlsx b/tests/fixtures/ilab_pi_directory_sample.xlsx new file mode 100644 index 0000000..da98a6a Binary files /dev/null and b/tests/fixtures/ilab_pi_directory_sample.xlsx differ diff --git a/tests/fixtures/ilab_services_sample.csv b/tests/fixtures/ilab_services_sample.csv new file mode 100644 index 0000000..8678ca9 --- /dev/null +++ b/tests/fixtures/ilab_services_sample.csv @@ -0,0 +1,6 @@ +Service Name,Core,Rate Per Hour,Service ID,Active +Confocal Microscopy Training,Microscopy Core,50,SVC-001,Yes +Flow Cytometry Analysis,Flow Cytometry Core,75,SVC-002,Yes +Mass Spectrometry Run,Proteomics Core,100,SVC-003,Yes +Sample Preparation - Proteomics,Proteomics Core,60,SVC-004,Yes +NMR Spectroscopy Analysis,NMR Core,85,SVC-005,No diff --git a/tests/fixtures/ilab_services_sample.xlsx b/tests/fixtures/ilab_services_sample.xlsx new file mode 100644 index 0000000..46d54df Binary files /dev/null and b/tests/fixtures/ilab_services_sample.xlsx differ diff --git a/tests/fixtures/sample_equipment.csv b/tests/fixtures/sample_equipment.csv new file mode 100644 index 0000000..e29d87f --- /dev/null +++ b/tests/fixtures/sample_equipment.csv @@ -0,0 +1,6 @@ +equipment_id,name,location,status,purchase_date +EQ001,Microscope Alpha,Lab A,operational,2023-01-15 +EQ002,Centrifuge Beta,Lab B,maintenance,2023-03-22 +EQ003,Spectrometer Gamma,Lab A,operational,2023-05-10 +EQ004,PCR Machine Delta,Lab C,operational,2023-07-01 +EQ005,Incubator Epsilon,Lab B,decommissioned,2022-12-05 diff --git a/tests/fixtures/sample_pi_directory.xlsx b/tests/fixtures/sample_pi_directory.xlsx new file mode 100644 index 0000000..4ccaf0a Binary files /dev/null and b/tests/fixtures/sample_pi_directory.xlsx differ diff --git a/tests/fixtures/sample_resources.tsv b/tests/fixtures/sample_resources.tsv new file mode 100644 index 0000000..ebb8135 --- /dev/null +++ b/tests/fixtures/sample_resources.tsv @@ -0,0 +1,6 @@ +resource_id category description quantity unit +RES001 Reagent Sodium Chloride 500 g +RES002 Consumable Pipette Tips (1000uL) 1000 pieces +RES003 Reagent Ethanol (95%) 2 L +RES004 Equipment Safety Goggles 25 pairs +RES005 Consumable Petri Dishes 500 pieces diff --git a/tests/test_alert_manager.py b/tests/test_alert_manager.py new file mode 100644 index 0000000..28fa764 --- /dev/null +++ b/tests/test_alert_manager.py @@ -0,0 +1,424 @@ +""" +Tests for alert management functionality. +""" + +import pytest +import tempfile +import os +from unittest.mock import Mock, patch, MagicMock +from scidk.core.alert_manager import AlertManager + + +@pytest.fixture +def temp_db(): + """Create a temporary database for testing.""" + fd, path = tempfile.mkstemp(suffix='.db') + os.close(fd) + yield path + try: + os.unlink(path) + except Exception: + pass + + +@pytest.fixture +def alert_manager(temp_db): + """Create an AlertManager instance for testing.""" + return AlertManager(temp_db) + + +def test_alert_manager_init(alert_manager): + """Test AlertManager initialization.""" + assert alert_manager is not None + assert alert_manager.db_path is not None + + # Check that default alerts were created + alerts = alert_manager.list_alerts() + assert len(alerts) == 5 # 5 default alerts + + # Verify default alert types + condition_types = [a['condition_type'] for a in alerts] + assert 'import_failed' in condition_types + assert 'high_discrepancies' in condition_types + assert 'backup_failed' in condition_types + assert 'neo4j_down' in condition_types + assert 'disk_critical' in condition_types + + +def test_create_alert(alert_manager): + """Test creating a new alert.""" + alert_id = alert_manager.create_alert( + name='Test Alert', + condition_type='test_condition', + action_type='email', + recipients=['test@example.com'], + threshold=100.0, + created_by='test_user' + ) + + assert alert_id is not None + assert len(alert_id) > 0 + + # Verify alert was created + alert = alert_manager.get_alert(alert_id) + assert alert is not None + assert alert['name'] == 'Test Alert' + assert alert['condition_type'] == 'test_condition' + assert alert['action_type'] == 'email' + assert alert['recipients'] == ['test@example.com'] + assert alert['threshold'] == 100.0 + assert alert['enabled'] is True + + +def test_list_alerts(alert_manager): + """Test listing alerts.""" + # Should have default alerts + all_alerts = alert_manager.list_alerts() + assert len(all_alerts) >= 5 + + # Create and enable a custom alert + alert_id = alert_manager.create_alert( + name='Enabled Alert', + condition_type='test', + action_type='email', + recipients=['test@example.com'] + ) + + # Create and disable another alert + alert_id2 = alert_manager.create_alert( + name='Disabled Alert', + condition_type='test2', + action_type='email', + recipients=['test@example.com'] + ) + alert_manager.update_alert(alert_id2, enabled=False) + + # Test enabled_only filter + enabled_alerts = alert_manager.list_alerts(enabled_only=True) + alert_names = [a['name'] for a in enabled_alerts] + assert 'Enabled Alert' in alert_names + assert 'Disabled Alert' not in alert_names + + +def test_update_alert(alert_manager): + """Test updating an alert.""" + # Create alert + alert_id = alert_manager.create_alert( + name='Original Name', + condition_type='test', + action_type='email', + recipients=['old@example.com'] + ) + + # Update alert + success = alert_manager.update_alert( + alert_id, + name='Updated Name', + recipients=['new@example.com'], + threshold=50.0, + enabled=False + ) + + assert success is True + + # Verify updates + alert = alert_manager.get_alert(alert_id) + assert alert['name'] == 'Updated Name' + assert alert['recipients'] == ['new@example.com'] + assert alert['threshold'] == 50.0 + assert alert['enabled'] is False + + +def test_delete_alert(alert_manager): + """Test deleting an alert.""" + # Create alert + alert_id = alert_manager.create_alert( + name='To Delete', + condition_type='test', + action_type='email', + recipients=['test@example.com'] + ) + + # Verify it exists + assert alert_manager.get_alert(alert_id) is not None + + # Delete it + success = alert_manager.delete_alert(alert_id) + assert success is True + + # Verify it's gone + assert alert_manager.get_alert(alert_id) is None + + # Try deleting non-existent alert + success = alert_manager.delete_alert('nonexistent') + assert success is False + + +def test_check_alerts_with_threshold(alert_manager): + """Test checking alerts with threshold conditions.""" + # Create alert with threshold + alert_id = alert_manager.create_alert( + name='Threshold Alert', + condition_type='test_metric', + action_type='log', # Use log for testing + recipients=['test@example.com'], # Need recipients even for log action + threshold=50.0 + ) + + # Value below threshold should not trigger + triggered = alert_manager.check_alerts('test_metric', {'value': 30.0}) + assert len(triggered) == 0 + + # Value at threshold should trigger + triggered = alert_manager.check_alerts('test_metric', {'value': 50.0}) + assert len(triggered) == 1 + assert triggered[0] == alert_id + + # Value above threshold should trigger + triggered = alert_manager.check_alerts('test_metric', {'value': 70.0}) + assert len(triggered) == 1 + assert triggered[0] == alert_id + + +def test_check_alerts_without_recipients(alert_manager): + """Test that alerts without recipients don't trigger.""" + # Create alert without recipients + alert_id = alert_manager.create_alert( + name='No Recipients', + condition_type='test', + action_type='email', + recipients=[] + ) + + # Should not trigger without recipients + triggered = alert_manager.check_alerts('test', {'value': 1}) + assert len(triggered) == 0 + + +def test_check_alerts_disabled(alert_manager): + """Test that disabled alerts don't trigger.""" + # Create and disable alert + alert_id = alert_manager.create_alert( + name='Disabled Alert', + condition_type='test', + action_type='log', + recipients=['test@example.com'] + ) + alert_manager.update_alert(alert_id, enabled=False) + + # Should not trigger when disabled + triggered = alert_manager.check_alerts('test', {'value': 1}) + assert len(triggered) == 0 + + +@patch('smtplib.SMTP') +def test_send_email_alert(mock_smtp, alert_manager): + """Test sending email alerts.""" + # Configure SMTP + alert_manager.update_smtp_config( + host='smtp.test.com', + port=587, + username='test@test.com', + password='test123', + from_address='noreply@test.com', + use_tls=True, + enabled=True, + recipients=['recipient@test.com'] + ) + + # Create alert with recipients + alert_id = alert_manager.create_alert( + name='Email Test', + condition_type='test_email', + action_type='email', + recipients=['recipient@test.com'] + ) + + # Mock SMTP server + mock_server = MagicMock() + mock_smtp.return_value.__enter__.return_value = mock_server + + # Trigger alert + triggered = alert_manager.check_alerts('test_email', { + 'message': 'Test alert', + 'value': 1 + }) + + assert len(triggered) == 1 + assert triggered[0] == alert_id + + # Verify SMTP was called + mock_smtp.assert_called_once() + mock_server.starttls.assert_called_once() + mock_server.login.assert_called_once() + mock_server.send_message.assert_called_once() + + +def test_alert_history(alert_manager): + """Test alert history logging.""" + # Create alert + alert_id = alert_manager.create_alert( + name='History Test', + condition_type='test_history', + action_type='log', + recipients=['test@example.com'] + ) + + # Trigger alert multiple times + alert_manager.check_alerts('test_history', {'value': 1, 'message': 'First'}) + alert_manager.check_alerts('test_history', {'value': 2, 'message': 'Second'}) + alert_manager.check_alerts('test_history', {'value': 3, 'message': 'Third'}) + + # Get history + history = alert_manager.get_alert_history(alert_id=alert_id) + assert len(history) == 3 + + # Verify history entries (most recent first) + assert history[0]['condition_details']['message'] == 'Third' + assert history[1]['condition_details']['message'] == 'Second' + assert history[2]['condition_details']['message'] == 'First' + + # Get all history + all_history = alert_manager.get_alert_history() + assert len(all_history) >= 3 + + +@patch('smtplib.SMTP') +def test_test_alert(mock_smtp, alert_manager): + """Test the test_alert functionality.""" + # Configure SMTP + alert_manager.update_smtp_config( + host='smtp.test.com', + port=587, + username='test@test.com', + password='test123', + from_address='noreply@test.com', + use_tls=True, + enabled=True, + recipients=['recipient@test.com'] + ) + + # Create alert + alert_id = alert_manager.create_alert( + name='Test Alert', + condition_type='test', + action_type='email', + recipients=['test@example.com'] + ) + + # Mock SMTP server + mock_server = MagicMock() + mock_smtp.return_value.__enter__.return_value = mock_server + + # Send test alert + success, error_msg = alert_manager.test_alert(alert_id) + assert success is True + assert error_msg is None + + # Verify SMTP was called + mock_smtp.assert_called_once() + mock_server.send_message.assert_called_once() + + # Verify history was logged + history = alert_manager.get_alert_history(alert_id=alert_id) + assert len(history) == 1 + assert history[0]['condition_details']['test'] is True + + +def test_smtp_config(alert_manager): + """Test SMTP configuration management.""" + # Update SMTP config + alert_manager.update_smtp_config( + host='smtp.gmail.com', + port=587, + username='user@gmail.com', + password='app_password', + from_address='noreply@example.com', + use_tls=True, + enabled=True, + recipients=['admin@example.com'] + ) + + # Get config (safe version) + config = alert_manager.get_smtp_config_safe() + assert config is not None + assert config['host'] == 'smtp.gmail.com' + assert config['port'] == 587 + assert config['username'] == 'user@gmail.com' + assert config['password'] == '••••••••' # Redacted + assert config['from_address'] == 'noreply@example.com' + assert config['use_tls'] is True + assert config['enabled'] is True + + # Update without changing password + alert_manager.update_smtp_config( + host='smtp.test.com', + port=25, + username='new@test.com', + password=None, # Don't change password + from_address='noreply@test.com', + use_tls=False, + enabled=True, + recipients=['admin@test.com'] + ) + + config = alert_manager.get_smtp_config_safe() + assert config['host'] == 'smtp.test.com' + assert config['port'] == 25 + assert config['password'] == '••••••••' # Still has password + + +@patch('smtplib.SMTP') +def test_test_smtp_config(mock_smtp, alert_manager): + """Test SMTP configuration testing.""" + # Configure SMTP + alert_manager.update_smtp_config( + host='smtp.test.com', + port=587, + username='test@test.com', + password='test123', + from_address='noreply@test.com', + use_tls=True, + enabled=True, + recipients=['recipient@test.com'] + ) + + # Mock SMTP server + mock_server = MagicMock() + mock_smtp.return_value.__enter__.return_value = mock_server + + # Test SMTP config + success, error_msg = alert_manager.test_smtp_config() + assert success is True + assert error_msg is None + + # Verify SMTP was called + mock_smtp.assert_called_once() + mock_server.starttls.assert_called_once() + mock_server.login.assert_called_once() + mock_server.send_message.assert_called_once() + + +def test_log_action_type(alert_manager): + """Test alert with log action type.""" + # Create log alert + alert_id = alert_manager.create_alert( + name='Log Alert', + condition_type='test_log', + action_type='log', + recipients=['test@example.com'] + ) + + # Trigger alert + triggered = alert_manager.check_alerts('test_log', { + 'message': 'Test log message', + 'value': 1 + }) + + assert len(triggered) == 1 + assert triggered[0] == alert_id + + # Verify history + history = alert_manager.get_alert_history(alert_id=alert_id) + assert len(history) == 1 + assert history[0]['success'] is True diff --git a/tests/test_alerts_api.py b/tests/test_alerts_api.py new file mode 100644 index 0000000..4265a4d --- /dev/null +++ b/tests/test_alerts_api.py @@ -0,0 +1,253 @@ +""" +Tests for Alerts API routes (/api/settings/alerts). +""" +import pytest +from unittest.mock import patch, MagicMock + + +@pytest.fixture +def admin_client(client): + """Create a client with admin privileges.""" + with patch('scidk.web.decorators.require_admin', lambda f: f): + yield client + + +def test_list_alerts_empty(admin_client): + """Test listing alerts when none exist.""" + resp = admin_client.get('/api/settings/alerts') + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' + assert 'alerts' in data + assert isinstance(data['alerts'], list) + + +def test_create_alert(admin_client): + """Test creating a new alert.""" + alert_data = { + 'name': 'Test Alert', + 'condition_type': 'threshold', + 'threshold': 100, + 'action_type': 'email', + 'recipients': ['test@example.com'], + 'enabled': True + } + + resp = admin_client.post('/api/settings/alerts', json=alert_data) + assert resp.status_code == 201 + data = resp.get_json() + assert data['status'] == 'success' + assert 'alert_id' in data + + +def test_create_alert_missing_name(admin_client): + """Test creating alert without required name.""" + alert_data = { + 'condition_type': 'threshold', + 'action_type': 'email' + } + + resp = admin_client.post('/api/settings/alerts', json=alert_data) + assert resp.status_code == 400 + data = resp.get_json() + assert data['status'] == 'error' + + +def test_get_alert(admin_client): + """Test getting a specific alert.""" + # First create an alert + alert_data = { + 'name': 'Get Test', + 'condition_type': 'threshold', + 'action_type': 'log' + } + create_resp = admin_client.post('/api/settings/alerts', json=alert_data) + alert_id = create_resp.get_json()['alert_id'] + + # Now get it + resp = admin_client.get(f'/api/settings/alerts/{alert_id}') + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' + assert data['alert']['name'] == 'Get Test' + + +def test_get_alert_not_found(admin_client): + """Test getting a non-existent alert.""" + resp = admin_client.get('/api/settings/alerts/nonexistent-id') + assert resp.status_code == 404 + data = resp.get_json() + assert data['status'] == 'error' + + +def test_update_alert(admin_client): + """Test updating an existing alert.""" + # Create alert + alert_data = { + 'name': 'Original Name', + 'condition_type': 'threshold', + 'action_type': 'log' + } + create_resp = admin_client.post('/api/settings/alerts', json=alert_data) + alert_id = create_resp.get_json()['alert_id'] + + # Update it + update_data = {'name': 'Updated Name', 'enabled': False} + resp = admin_client.put(f'/api/settings/alerts/{alert_id}', json=update_data) + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' + + # Verify update + get_resp = admin_client.get(f'/api/settings/alerts/{alert_id}') + alert = get_resp.get_json()['alert'] + assert alert['name'] == 'Updated Name' + assert alert['enabled'] is False + + +def test_delete_alert(admin_client): + """Test deleting an alert.""" + # Create alert + alert_data = { + 'name': 'To Delete', + 'condition_type': 'threshold', + 'action_type': 'log' + } + create_resp = admin_client.post('/api/settings/alerts', json=alert_data) + alert_id = create_resp.get_json()['alert_id'] + + # Delete it + resp = admin_client.delete(f'/api/settings/alerts/{alert_id}') + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' + + # Verify it's gone + get_resp = admin_client.get(f'/api/settings/alerts/{alert_id}') + assert get_resp.status_code == 404 + + +@patch('smtplib.SMTP') +def test_test_alert(mock_smtp, admin_client): + """Test the alert testing functionality.""" + # Configure SMTP first + smtp_config = { + 'host': 'smtp.test.com', + 'port': 587, + 'username': 'test@test.com', + 'password': 'test123', + 'from_address': 'noreply@test.com', + 'use_tls': True, + 'enabled': True, + 'recipients': ['admin@test.com'] + } + admin_client.post('/api/settings/smtp', json=smtp_config) + + # Create an email alert + alert_data = { + 'name': 'Test Email Alert', + 'condition_type': 'test', + 'action_type': 'email', + 'recipients': ['recipient@test.com'] + } + create_resp = admin_client.post('/api/settings/alerts', json=alert_data) + alert_id = create_resp.get_json()['alert_id'] + + # Mock SMTP server + mock_server = MagicMock() + mock_smtp.return_value.__enter__.return_value = mock_server + + # Test the alert + resp = admin_client.post(f'/api/settings/alerts/{alert_id}/test') + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' + + +def test_alert_history(admin_client): + """Test getting alert history.""" + # Create and trigger an alert + alert_data = { + 'name': 'History Test', + 'condition_type': 'threshold', + 'threshold': 50, + 'action_type': 'log', + 'enabled': True + } + create_resp = admin_client.post('/api/settings/alerts', json=alert_data) + alert_id = create_resp.get_json()['alert_id'] + + # Get history (all alerts) + resp = admin_client.get('/api/settings/alerts/history') + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' + assert 'history' in data + assert isinstance(data['history'], list) + + # Get history for specific alert + resp2 = admin_client.get(f'/api/settings/alerts/history?alert_id={alert_id}') + assert resp2.status_code == 200 + data2 = resp2.get_json() + assert data2['status'] == 'success' + + +def test_smtp_config_get(admin_client): + """Test getting SMTP configuration.""" + resp = admin_client.get('/api/settings/smtp') + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' + assert 'smtp' in data + + +def test_smtp_config_update(admin_client): + """Test updating SMTP configuration.""" + smtp_config = { + 'host': 'smtp.gmail.com', + 'port': 587, + 'username': 'user@gmail.com', + 'password': 'app_password', + 'from_address': 'noreply@example.com', + 'use_tls': True, + 'enabled': True, + 'recipients': ['admin@example.com'] + } + + resp = admin_client.post('/api/settings/smtp', json=smtp_config) + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' + + # Verify config was saved (password should be redacted) + get_resp = admin_client.get('/api/settings/smtp') + smtp_data = get_resp.get_json()['smtp'] + assert smtp_data['host'] == 'smtp.gmail.com' + assert smtp_data['password'] == '••••••••' # Redacted + + +@patch('scidk.core.alert_manager.smtplib.SMTP') +def test_smtp_test(mock_smtp, admin_client): + """Test SMTP connection testing.""" + # Configure SMTP + smtp_config = { + 'host': 'smtp.test.com', + 'port': 587, + 'username': 'test@test.com', + 'password': 'test123', + 'from_address': 'noreply@test.com', + 'use_tls': True, + 'enabled': True, + 'recipients': ['admin@test.com'] + } + admin_client.post('/api/settings/smtp', json=smtp_config) + + # Mock SMTP server + mock_server = MagicMock() + mock_smtp.return_value.__enter__.return_value = mock_server + + # Test connection with recipient + resp = admin_client.post('/api/settings/smtp/test', json={'recipient': 'test@example.com'}) + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'success' diff --git a/tests/test_backup_automation.py b/tests/test_backup_automation.py new file mode 100644 index 0000000..f04957c --- /dev/null +++ b/tests/test_backup_automation.py @@ -0,0 +1,315 @@ +""" +Tests for automated backup scheduling and management. +""" +import pytest +import os +import tempfile +import time +from pathlib import Path +from datetime import datetime, timedelta, timezone + +from scidk.core.backup_manager import BackupManager +from scidk.core.backup_scheduler import BackupScheduler + + +@pytest.fixture +def temp_backup_dir(tmp_path): + """Create a temporary backup directory.""" + backup_dir = tmp_path / "backups" + backup_dir.mkdir() + return backup_dir + + +@pytest.fixture +def temp_db_files(tmp_path): + """Create temporary database files for testing.""" + # Create dummy database files + settings_db = tmp_path / "scidk_settings.db" + settings_db.write_text("dummy settings db") + + path_index_db = tmp_path / "scidk_path_index.db" + path_index_db.write_text("dummy path index db") + + env_file = tmp_path / ".env" + env_file.write_text("DUMMY_VAR=test") + + # Change to temp directory for backup operations + original_dir = os.getcwd() + os.chdir(tmp_path) + + yield tmp_path + + # Restore original directory + os.chdir(original_dir) + + +@pytest.fixture +def backup_manager(temp_backup_dir): + """Create a BackupManager instance.""" + return BackupManager(backup_dir=str(temp_backup_dir)) + + +@pytest.fixture +def backup_scheduler(backup_manager, tmp_path): + """Create a BackupScheduler instance.""" + # Use temp database for tests + test_db = tmp_path / "test_settings.db" + return BackupScheduler( + backup_manager=backup_manager, + settings_db_path=str(test_db) + ) + + +def test_backup_scheduler_initialization(backup_scheduler): + """Test that backup scheduler initializes correctly.""" + assert backup_scheduler.schedule_hour == 2 + assert backup_scheduler.retention_days == 30 + assert backup_scheduler.verify_backups is True + assert not backup_scheduler.is_running() + + +def test_backup_scheduler_start_stop(backup_scheduler): + """Test starting and stopping the scheduler.""" + backup_scheduler.start() + assert backup_scheduler.is_running() + + backup_scheduler.stop() + assert not backup_scheduler.is_running() + + +def test_backup_verification(backup_manager, backup_scheduler, temp_db_files): + """Test backup verification functionality.""" + # Create a backup + result = backup_manager.create_backup(reason='test', created_by='test_user') + assert result['success'] + + # Verify the backup + verification = backup_scheduler.verify_backup(result['filename']) + assert verification['verified'] + assert 'backup_id' in verification + assert 'files_count' in verification + + +def test_backup_verification_corrupted(backup_manager, backup_scheduler, temp_backup_dir): + """Test verification of corrupted backup.""" + # Create a fake corrupted backup file + fake_backup = temp_backup_dir / "corrupted-backup.zip" + fake_backup.write_text("not a real zip file") + + # Verify should fail + verification = backup_scheduler.verify_backup(str(fake_backup)) + assert not verification['verified'] + assert 'error' in verification + + +def test_cleanup_old_backups(backup_manager, backup_scheduler, temp_db_files, temp_backup_dir): + """Test cleanup of old backups.""" + # Create several backups + backups = [] + for i in range(5): + result = backup_manager.create_backup(reason='test', created_by='test_user') + assert result['success'] + backups.append(result) + time.sleep(0.1) # Small delay to ensure different timestamps + + # Manually set retention to 0 days to trigger cleanup + backup_scheduler.retention_days = 0 + + # Run cleanup + cleanup_result = backup_scheduler.cleanup_old_backups() + assert cleanup_result['success'] + assert cleanup_result['deleted_count'] >= 0 # May be 0 if backups too recent + + +def test_cleanup_respects_retention_policy(backup_manager, backup_scheduler, temp_db_files): + """Test that cleanup respects retention policy.""" + # Create a backup + result = backup_manager.create_backup(reason='test', created_by='test_user') + assert result['success'] + + # Set retention to 30 days (recent backup should be kept) + backup_scheduler.retention_days = 30 + + # Run cleanup + cleanup_result = backup_scheduler.cleanup_old_backups() + assert cleanup_result['success'] + assert cleanup_result['deleted_count'] == 0 # Backup is recent, shouldn't be deleted + + # Verify backup still exists + backups = backup_manager.list_backups() + assert len(backups) == 1 + + +def test_backup_verification_updates_metadata(backup_manager, backup_scheduler, temp_db_files): + """Test that verification updates backup metadata.""" + # Create a backup + result = backup_manager.create_backup(reason='test', created_by='test_user') + assert result['success'] + filename = result['filename'] + + # Verify the backup (this should update metadata) + verification = backup_scheduler.verify_backup(filename) + assert verification['verified'] + + # Give a moment for metadata to be written + time.sleep(0.1) + + # Read backup metadata to check verification info was added + import zipfile + import json + backup_path = backup_manager.backup_dir / filename + + # Note: _update_backup_verification is best-effort and may fail silently + # The important thing is that verification works, metadata update is optional + with zipfile.ZipFile(backup_path, 'r') as zipf: + metadata_str = zipf.read('backup_metadata.json').decode('utf-8') + metadata = json.loads(metadata_str) + + # Verification metadata update is best-effort, so just check the backup is valid + # If verification field exists, it should be correct + if 'verification' in metadata: + assert metadata['verification']['verified'] is True + + +def test_get_next_backup_time(backup_scheduler): + """Test getting next backup time.""" + # Before starting, should return None + assert backup_scheduler.get_next_backup_time() is None + + # After starting, should return a timestamp + backup_scheduler.start() + next_time = backup_scheduler.get_next_backup_time() + assert next_time is not None + + # Parse and verify it's in the future + next_backup = datetime.fromisoformat(next_time) + now = datetime.now(next_backup.tzinfo) + assert next_backup > now + + backup_scheduler.stop() + + +def test_backup_scheduler_with_custom_schedule(backup_manager, tmp_path): + """Test scheduler with custom schedule settings.""" + # Use temp database and update settings + test_db = tmp_path / "test_custom_settings.db" + scheduler = BackupScheduler( + backup_manager=backup_manager, + settings_db_path=str(test_db) + ) + + # Update settings + scheduler.update_settings({ + 'schedule_hour': 14, + 'schedule_minute': 30, + 'retention_days': 60 + }) + + assert scheduler.schedule_hour == 14 + assert scheduler.schedule_minute == 30 + assert scheduler.retention_days == 60 + + +def test_verification_missing_metadata(backup_scheduler, temp_backup_dir): + """Test verification of backup without metadata.""" + import zipfile + + # Create a zip without metadata + backup_path = temp_backup_dir / "no-metadata.zip" + with zipfile.ZipFile(backup_path, 'w') as zipf: + zipf.writestr('dummy.txt', 'test content') + + # Verification should fail + verification = backup_scheduler.verify_backup(str(backup_path)) + assert not verification['verified'] + assert 'metadata' in verification['error'].lower() + + +def test_verification_missing_listed_files(backup_scheduler, temp_backup_dir): + """Test verification when listed files are missing from backup.""" + import zipfile + import json + + # Create a backup with metadata listing files that don't exist + backup_path = temp_backup_dir / "missing-files.zip" + metadata = { + 'version': '1.0', + 'backup_id': 'test123', + 'timestamp': datetime.now(timezone.utc).isoformat(), + 'files': [ + {'path': 'missing.db', 'description': 'Missing file'} + ] + } + + with zipfile.ZipFile(backup_path, 'w') as zipf: + zipf.writestr('backup_metadata.json', json.dumps(metadata)) + # Don't add the file listed in metadata + + # Verification should fail + verification = backup_scheduler.verify_backup(str(backup_path)) + assert not verification['verified'] + assert 'missing' in verification['error'].lower() + + +def test_cleanup_with_invalid_timestamps(backup_manager, backup_scheduler, temp_db_files): + """Test cleanup handles backups with invalid timestamps gracefully.""" + # Create a backup + result = backup_manager.create_backup(reason='test', created_by='test_user') + assert result['success'] + + # Manually corrupt the timestamp in metadata + import zipfile + import json + backup_path = backup_manager.backup_dir / result['filename'] + + # Read existing backup + with zipfile.ZipFile(backup_path, 'r') as zipf: + metadata_str = zipf.read('backup_metadata.json').decode('utf-8') + metadata = json.loads(metadata_str) + metadata['timestamp'] = 'invalid-timestamp' + + # Create new backup with corrupted metadata + temp_path = backup_path.with_suffix('.tmp') + with zipfile.ZipFile(backup_path, 'r') as old_zipf: + with zipfile.ZipFile(temp_path, 'w') as new_zipf: + for item in old_zipf.namelist(): + if item != 'backup_metadata.json': + data = old_zipf.read(item) + new_zipf.writestr(item, data) + new_zipf.writestr('backup_metadata.json', json.dumps(metadata)) + + temp_path.replace(backup_path) + + # Cleanup should handle this gracefully + cleanup_result = backup_scheduler.cleanup_old_backups() + assert cleanup_result['success'] + # Backup with invalid timestamp should be skipped + + # Original backup should still exist (wasn't cleaned due to invalid timestamp) + backups = backup_manager.list_backups() + assert len(backups) >= 1 + + +def test_backup_manager_integration_with_scheduler(backup_manager, backup_scheduler, temp_db_files): + """Test integration between BackupManager and BackupScheduler.""" + # Create backups through manager + result1 = backup_manager.create_backup(reason='manual', created_by='user1') + assert result1['success'] + + result2 = backup_manager.create_backup(reason='auto', created_by='system') + assert result2['success'] + + # Verify both backups through scheduler + verify1 = backup_scheduler.verify_backup(result1['filename']) + verify2 = backup_scheduler.verify_backup(result2['filename']) + + assert verify1['verified'] + assert verify2['verified'] + + # List backups + backups = backup_manager.list_backups() + assert len(backups) == 2 + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_health_comprehensive.py b/tests/test_health_comprehensive.py new file mode 100644 index 0000000..4dbb60e --- /dev/null +++ b/tests/test_health_comprehensive.py @@ -0,0 +1,281 @@ +""" +Tests for comprehensive health dashboard API endpoint. +""" +import pytest +from unittest.mock import patch, MagicMock + + +@pytest.fixture() +def admin_client(client): + """Provide an authenticated admin client (alias for existing client fixture). + + The client fixture already handles admin authentication when auth is enabled, + so we just use it directly. + """ + return client + + +def test_health_comprehensive_endpoint_exists(client): + """Test that the comprehensive health endpoint returns 200.""" + resp = client.get('/api/health/comprehensive') + # Endpoint is public (no auth required) + assert resp.status_code == 200 + + +def test_health_comprehensive_structure(admin_client): + """Test that comprehensive health endpoint returns expected structure.""" + resp = admin_client.get('/api/health/comprehensive') + + # Should succeed for admin + assert resp.status_code == 200 + + data = resp.get_json() + + # Top-level fields + assert 'status' in data + assert 'timestamp' in data + assert 'components' in data + + # Status should be one of the expected values + assert data['status'] in ['healthy', 'warning', 'critical'] + + # Timestamp should be a number + assert isinstance(data['timestamp'], (int, float)) + + # Components should be a dict + assert isinstance(data['components'], dict) + + +def test_health_comprehensive_components(admin_client): + """Test that all expected components are present in health response.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + components = data['components'] + + # Expected components + expected = ['flask', 'sqlite', 'neo4j', 'interpreters', 'disk', 'memory', 'cpu'] + + for component in expected: + assert component in components, f"Missing component: {component}" + assert 'status' in components[component], f"Component {component} missing status" + + +def test_health_flask_component(admin_client): + """Test Flask component health structure.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + flask = data['components']['flask'] + + assert 'status' in flask + if flask['status'] == 'ok': + assert 'uptime_seconds' in flask + assert 'memory_mb' in flask + assert isinstance(flask['uptime_seconds'], int) + assert isinstance(flask['memory_mb'], (int, float)) + elif flask['status'] == 'error': + assert 'error' in flask + + +def test_health_sqlite_component(admin_client): + """Test SQLite component health structure.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + sqlite = data['components']['sqlite'] + + assert 'status' in sqlite + if sqlite['status'] == 'ok': + assert 'path' in sqlite + assert 'size_mb' in sqlite + assert 'journal_mode' in sqlite + assert 'row_count' in sqlite + assert isinstance(sqlite['size_mb'], (int, float)) + assert isinstance(sqlite['row_count'], int) + elif sqlite['status'] == 'error': + assert 'error' in sqlite + + +def test_health_neo4j_component(admin_client): + """Test Neo4j component health structure.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + neo4j = data['components']['neo4j'] + + assert 'status' in neo4j + # Neo4j can be: connected, unavailable, not_configured, or error + assert neo4j['status'] in ['connected', 'unavailable', 'not_configured', 'error'] + + if neo4j['status'] == 'connected': + assert 'response_time_ms' in neo4j + assert 'node_count' in neo4j + elif neo4j['status'] in ['unavailable', 'error']: + assert 'error' in neo4j or neo4j['status'] == 'unavailable' + + +def test_health_interpreters_component(admin_client): + """Test interpreters component health structure.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + interpreters = data['components']['interpreters'] + + assert 'status' in interpreters + if interpreters['status'] == 'ok': + assert 'enabled_count' in interpreters + assert 'total_count' in interpreters + assert isinstance(interpreters['enabled_count'], int) + assert isinstance(interpreters['total_count'], int) + assert interpreters['enabled_count'] <= interpreters['total_count'] + elif interpreters['status'] == 'error': + assert 'error' in interpreters + + +def test_health_disk_component(admin_client): + """Test disk component health structure.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + disk = data['components']['disk'] + + assert 'status' in disk + if disk['status'] in ['good', 'warning', 'critical']: + assert 'free_gb' in disk + assert 'total_gb' in disk + assert 'percent_used' in disk + assert isinstance(disk['free_gb'], (int, float)) + assert isinstance(disk['total_gb'], (int, float)) + assert isinstance(disk['percent_used'], (int, float)) + assert 0 <= disk['percent_used'] <= 100 + elif disk['status'] == 'error': + assert 'error' in disk + + +def test_health_memory_component(admin_client): + """Test memory component health structure.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + memory = data['components']['memory'] + + assert 'status' in memory + if memory['status'] in ['normal', 'high', 'critical']: + assert 'used_mb' in memory + assert 'total_mb' in memory + assert 'percent_used' in memory + assert isinstance(memory['used_mb'], (int, float)) + assert isinstance(memory['total_mb'], (int, float)) + assert isinstance(memory['percent_used'], (int, float)) + assert 0 <= memory['percent_used'] <= 100 + elif memory['status'] == 'error': + assert 'error' in memory + + +def test_health_cpu_component(admin_client): + """Test CPU component health structure.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + cpu = data['components']['cpu'] + + assert 'status' in cpu + if cpu['status'] in ['low', 'normal', 'high']: + assert 'load_percent' in cpu + assert isinstance(cpu['load_percent'], (int, float)) + assert 0 <= cpu['load_percent'] <= 100 + elif cpu['status'] == 'error': + assert 'error' in cpu + + +def test_health_overall_status_logic(admin_client): + """Test that overall status is calculated correctly based on components.""" + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + overall_status = data['status'] + components = data['components'] + + # Check if any component is critical + has_critical = any( + comp.get('status') in ['critical', 'error'] + for comp in components.values() + ) + + # Check if any component is warning + has_warning = any( + comp.get('status') in ['warning', 'high'] + for comp in components.values() + ) + + if has_critical: + assert overall_status == 'critical' + elif has_warning: + assert overall_status == 'warning' + else: + # Should be healthy if no critical or warning + assert overall_status == 'healthy' + + +@patch('psutil.disk_usage') +def test_health_disk_critical_threshold(mock_disk, admin_client): + """Test that disk usage above 95% is marked as critical.""" + # Mock disk usage at 96% + mock_disk.return_value = MagicMock( + free=40 * 1024**3, # 40 GB free + total=1000 * 1024**3, # 1000 GB total + percent=96.0 + ) + + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + disk = data['components']['disk'] + assert disk['status'] == 'critical' + + +@patch('psutil.disk_usage') +def test_health_disk_warning_threshold(mock_disk, admin_client): + """Test that disk usage between 85-95% is marked as warning.""" + # Mock disk usage at 90% + mock_disk.return_value = MagicMock( + free=100 * 1024**3, # 100 GB free + total=1000 * 1024**3, # 1000 GB total + percent=90.0 + ) + + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + disk = data['components']['disk'] + assert disk['status'] == 'warning' + + +@patch('psutil.virtual_memory') +def test_health_memory_critical_threshold(mock_mem, admin_client): + """Test that memory usage above 90% is marked as critical.""" + # Mock memory usage at 92% + mock_mem.return_value = MagicMock( + used=7372 * 1024 * 1024, # 7372 MB + total=8192 * 1024 * 1024, # 8192 MB + percent=92.0 + ) + + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + memory = data['components']['memory'] + assert memory['status'] == 'critical' + + +@patch('psutil.cpu_percent') +def test_health_cpu_high_threshold(mock_cpu, admin_client): + """Test that CPU usage above 80% is marked as high.""" + mock_cpu.return_value = 85.0 + + resp = admin_client.get('/api/health/comprehensive') + data = resp.get_json() + + cpu = data['components']['cpu'] + assert cpu['status'] == 'high' diff --git a/tests/test_ilab_plugin.py b/tests/test_ilab_plugin.py new file mode 100644 index 0000000..595fbca --- /dev/null +++ b/tests/test_ilab_plugin.py @@ -0,0 +1,217 @@ +"""Tests for iLab Data Importer plugin.""" + +import os +import tempfile +import pytest +import pandas as pd +from plugins.ilab_table_loader import handle_ilab_import, _get_preset_configs + + +@pytest.fixture +def sample_equipment_csv(tmp_path): + """Create a sample iLab equipment CSV file.""" + csv_file = tmp_path / "ilab_equipment.csv" + data = { + 'Service Name': ['Confocal Microscope', 'Flow Cytometer', 'Mass Spectrometer'], + 'Core': ['Microscopy Core', 'Flow Cytometry Core', 'Proteomics Core'], + 'PI': ['Dr. Smith', 'Dr. Jones', 'Dr. Williams'], + 'Location': ['Building A, Room 101', 'Building B, Room 202', 'Building C, Room 303'], + 'Equipment ID': ['EQ-001', 'EQ-002', 'EQ-003'], + 'Description': ['Advanced confocal imaging', 'Cell sorting and analysis', 'Protein analysis'] + } + df = pd.DataFrame(data) + df.to_csv(csv_file, index=False) + return str(csv_file) + + +@pytest.fixture +def sample_services_csv(tmp_path): + """Create a sample iLab services CSV file.""" + csv_file = tmp_path / "ilab_services.csv" + data = { + 'Service Name': ['Microscopy Training', 'Flow Cytometry Analysis', 'Mass Spec Run'], + 'Core': ['Microscopy Core', 'Flow Cytometry Core', 'Proteomics Core'], + 'Rate Per Hour': [50, 75, 100], + 'Service ID': ['SVC-001', 'SVC-002', 'SVC-003'], + 'Active': ['Yes', 'Yes', 'No'] + } + df = pd.DataFrame(data) + df.to_csv(csv_file, index=False) + return str(csv_file) + + +@pytest.fixture +def sample_pi_csv(tmp_path): + """Create a sample PI directory CSV file.""" + csv_file = tmp_path / "ilab_pi_directory.csv" + data = { + 'PI Name': ['Dr. Alice Smith', 'Dr. Bob Jones', 'Dr. Carol Williams'], + 'Email': ['alice.smith@example.edu', 'bob.jones@example.edu', 'carol.williams@example.edu'], + 'Department': ['Biology', 'Chemistry', 'Physics'], + 'Lab': ['Smith Lab', 'Jones Lab', 'Williams Lab'], + 'Phone': ['555-0101', '555-0102', '555-0103'], + 'Office': ['Bio 101', 'Chem 202', 'Physics 303'] + } + df = pd.DataFrame(data) + df.to_csv(csv_file, index=False) + return str(csv_file) + + +class TestIlabPlugin: + """Test suite for iLab Data Importer plugin.""" + + def test_preset_configs_exist(self): + """Test that all expected presets are defined.""" + presets = _get_preset_configs() + assert 'equipment' in presets + assert 'services' in presets + assert 'pi_directory' in presets + + def test_equipment_preset_has_column_hints(self): + """Test that equipment preset has proper column hints.""" + presets = _get_preset_configs() + equipment = presets['equipment'] + assert equipment['name'] == 'iLab Equipment' + assert 'column_hints' in equipment + assert 'Service Name' in equipment['column_hints'] + assert equipment['column_hints']['Service Name'] == 'name' + + def test_services_preset_has_suggested_labels(self): + """Test that services preset has suggested labels.""" + presets = _get_preset_configs() + services = presets['services'] + assert 'suggested_labels' in services + assert 'iLabService' in services['suggested_labels'] + + def test_pi_directory_preset_configuration(self): + """Test PI directory preset configuration.""" + presets = _get_preset_configs() + pi_dir = presets['pi_directory'] + assert pi_dir['name'] == 'PI Directory' + assert pi_dir['table_name_hint'] == 'ilab_pi_directory' + assert 'PrincipalInvestigator' in pi_dir['suggested_labels'] + assert 'Researcher' in pi_dir['suggested_labels'] + + def test_import_equipment_with_preset(self, sample_equipment_csv, tmp_path): + """Test importing equipment data with equipment preset.""" + db_path = tmp_path / "test.db" + config = { + 'preset': 'equipment', + 'file_path': sample_equipment_csv, + 'table_name': 'ilab_equipment_2024', + 'db_path': str(db_path) + } + + result = handle_ilab_import(config) + + assert result['status'] == 'success' + assert result['plugin'] == 'ilab_importer' + assert result['preset'] == 'equipment' + assert result['preset_name'] == 'iLab Equipment' + assert result['rows_imported'] == 3 + assert 'Service Name' in result['columns'] + + def test_import_services_with_preset(self, sample_services_csv, tmp_path): + """Test importing services data with services preset.""" + db_path = tmp_path / "test.db" + config = { + 'preset': 'services', + 'file_path': sample_services_csv, + 'table_name': 'ilab_services_2024', + 'db_path': str(db_path) + } + + result = handle_ilab_import(config) + + assert result['status'] == 'success' + assert result['preset'] == 'services' + assert result['rows_imported'] == 3 + + def test_import_pi_directory_with_preset(self, sample_pi_csv, tmp_path): + """Test importing PI directory with preset.""" + db_path = tmp_path / "test.db" + config = { + 'preset': 'pi_directory', + 'file_path': sample_pi_csv, + 'table_name': 'ilab_pi_directory', + 'db_path': str(db_path) + } + + result = handle_ilab_import(config) + + assert result['status'] == 'success' + assert result['preset'] == 'pi_directory' + assert result['rows_imported'] == 3 + assert 'PI Name' in result['columns'] + + def test_import_without_preset(self, sample_equipment_csv, tmp_path): + """Test importing without specifying a preset (custom mode).""" + db_path = tmp_path / "test.db" + config = { + 'file_path': sample_equipment_csv, + 'table_name': 'custom_table', + 'db_path': str(db_path) + } + + result = handle_ilab_import(config) + + assert result['status'] == 'success' + assert result['plugin'] == 'ilab_importer' + assert 'preset' not in result + assert result['rows_imported'] == 3 + + def test_table_name_auto_fill_with_preset(self, sample_equipment_csv, tmp_path): + """Test that table name is auto-filled from preset hint.""" + from datetime import datetime + db_path = tmp_path / "test.db" + config = { + 'preset': 'equipment', + 'file_path': sample_equipment_csv, + 'db_path': str(db_path) + # Note: no table_name provided + } + + result = handle_ilab_import(config) + + assert result['status'] == 'success' + # Table name should be auto-filled with current year + current_year = datetime.now().year + expected_table = f'ilab_equipment_{current_year}' + assert result['table_name'] == expected_table + + def test_column_hints_stored_in_config(self, sample_equipment_csv, tmp_path): + """Test that column hints are stored in instance config.""" + db_path = tmp_path / "test.db" + config = { + 'preset': 'equipment', + 'file_path': sample_equipment_csv, + 'table_name': 'test_table', + 'db_path': str(db_path) + } + + handle_ilab_import(config) + + # Column hints should be added to config + assert '_column_hints' in config + assert config['_column_hints']['Service Name'] == 'name' + assert config['_column_hints']['Core'] == 'core_facility' + + def test_suggested_labels_stored_in_config(self, sample_services_csv, tmp_path): + """Test that suggested labels are stored in instance config.""" + db_path = tmp_path / "test.db" + config = { + 'preset': 'services', + 'file_path': sample_services_csv, + 'table_name': 'test_table', + 'db_path': str(db_path) + } + + handle_ilab_import(config) + + # Suggested labels should be added to config + assert '_suggested_labels' in config + assert 'iLabService' in config['_suggested_labels'] + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_label_endpoint_registry.py b/tests/test_label_endpoint_registry.py new file mode 100644 index 0000000..13ca183 --- /dev/null +++ b/tests/test_label_endpoint_registry.py @@ -0,0 +1,279 @@ +"""Tests for Label Endpoint Registry. + +Tests the plugin label endpoint registration system that allows plugins to +register API endpoints that map to Label types. +""" + +import pytest +from scidk.core.label_endpoint_registry import LabelEndpointRegistry + + +@pytest.fixture +def registry(): + """Create a fresh registry for each test.""" + return LabelEndpointRegistry() + + +def test_registry_initialization(registry): + """Test registry initializes empty.""" + assert len(registry.list_endpoints()) == 0 + + +def test_register_endpoint(registry): + """Test registering a basic endpoint.""" + config = { + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabService' + } + + result = registry.register(config) + assert result is True + + endpoints = registry.list_endpoints() + assert len(endpoints) == 1 + assert endpoints[0]['name'] == 'iLab Services' + assert endpoints[0]['endpoint'] == '/api/integrations/ilab' + assert endpoints[0]['label_type'] == 'iLabService' + assert endpoints[0]['source'] == 'plugin' + + +def test_register_endpoint_with_all_fields(registry): + """Test registering an endpoint with all optional fields.""" + config = { + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabService', + 'auth_required': True, + 'test_url': '/api/integrations/ilab/test', + 'plugin': 'ilab_plugin', + 'description': 'Integration with iLab service management system', + 'config_schema': {'type': 'object'} + } + + result = registry.register(config) + assert result is True + + endpoint = registry.get_endpoint('/api/integrations/ilab') + assert endpoint['auth_required'] is True + assert endpoint['test_url'] == '/api/integrations/ilab/test' + assert endpoint['plugin'] == 'ilab_plugin' + assert endpoint['description'] == 'Integration with iLab service management system' + assert endpoint['config_schema'] == {'type': 'object'} + + +def test_register_endpoint_missing_required_field(registry): + """Test that registration fails if required field is missing.""" + config = { + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab' + # Missing 'label_type' + } + + result = registry.register(config) + assert result is False + assert len(registry.list_endpoints()) == 0 + + +def test_register_duplicate_endpoint_overwrites(registry): + """Test that registering duplicate endpoint path overwrites.""" + config1 = { + 'name': 'iLab Services V1', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabService' + } + + config2 = { + 'name': 'iLab Services V2', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabServiceV2' + } + + registry.register(config1) + registry.register(config2) + + endpoints = registry.list_endpoints() + assert len(endpoints) == 1 + assert endpoints[0]['name'] == 'iLab Services V2' + assert endpoints[0]['label_type'] == 'iLabServiceV2' + + +def test_get_endpoint(registry): + """Test retrieving a specific endpoint.""" + config = { + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabService' + } + + registry.register(config) + + endpoint = registry.get_endpoint('/api/integrations/ilab') + assert endpoint is not None + assert endpoint['name'] == 'iLab Services' + + missing = registry.get_endpoint('/api/integrations/missing') + assert missing is None + + +def test_unregister_endpoint(registry): + """Test unregistering an endpoint.""" + config = { + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabService' + } + + registry.register(config) + assert len(registry.list_endpoints()) == 1 + + result = registry.unregister('/api/integrations/ilab') + assert result is True + assert len(registry.list_endpoints()) == 0 + + # Unregistering again should return False + result = registry.unregister('/api/integrations/ilab') + assert result is False + + +def test_list_by_plugin(registry): + """Test filtering endpoints by plugin.""" + configs = [ + { + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab', + 'label_type': 'iLabService', + 'plugin': 'ilab_plugin' + }, + { + 'name': 'Slack Integration', + 'endpoint': '/api/integrations/slack', + 'label_type': 'SlackMessage', + 'plugin': 'slack_plugin' + }, + { + 'name': 'iLab Equipment', + 'endpoint': '/api/integrations/ilab/equipment', + 'label_type': 'Equipment', + 'plugin': 'ilab_plugin' + } + ] + + for config in configs: + registry.register(config) + + ilab_endpoints = registry.list_by_plugin('ilab_plugin') + assert len(ilab_endpoints) == 2 + assert all(e['plugin'] == 'ilab_plugin' for e in ilab_endpoints) + + slack_endpoints = registry.list_by_plugin('slack_plugin') + assert len(slack_endpoints) == 1 + assert slack_endpoints[0]['name'] == 'Slack Integration' + + +def test_list_by_label_type(registry): + """Test filtering endpoints by label type.""" + configs = [ + { + 'name': 'iLab Services', + 'endpoint': '/api/integrations/ilab/services', + 'label_type': 'iLabService', + 'plugin': 'ilab_plugin' + }, + { + 'name': 'iLab Services Alt', + 'endpoint': '/api/integrations/ilab/services/alt', + 'label_type': 'iLabService', + 'plugin': 'ilab_alt_plugin' + }, + { + 'name': 'Equipment', + 'endpoint': '/api/integrations/equipment', + 'label_type': 'Equipment', + 'plugin': 'equipment_plugin' + } + ] + + for config in configs: + registry.register(config) + + service_endpoints = registry.list_by_label_type('iLabService') + assert len(service_endpoints) == 2 + assert all(e['label_type'] == 'iLabService' for e in service_endpoints) + + equipment_endpoints = registry.list_by_label_type('Equipment') + assert len(equipment_endpoints) == 1 + + +def test_clear_registry(registry): + """Test clearing all endpoints.""" + configs = [ + { + 'name': 'Endpoint 1', + 'endpoint': '/api/integrations/test1', + 'label_type': 'Type1' + }, + { + 'name': 'Endpoint 2', + 'endpoint': '/api/integrations/test2', + 'label_type': 'Type2' + } + ] + + for config in configs: + registry.register(config) + + assert len(registry.list_endpoints()) == 2 + + registry.clear() + assert len(registry.list_endpoints()) == 0 + + +def test_endpoint_defaults(registry): + """Test that optional fields have correct defaults.""" + config = { + 'name': 'Test Endpoint', + 'endpoint': '/api/test', + 'label_type': 'TestType' + } + + registry.register(config) + endpoint = registry.get_endpoint('/api/test') + + assert endpoint['auth_required'] is False + assert endpoint['test_url'] is None + assert endpoint['plugin'] == 'unknown' + assert endpoint['description'] == '' + assert endpoint['config_schema'] == {} + assert endpoint['source'] == 'plugin' + + +def test_multiple_plugins_registration(registry): + """Test multiple plugins can register different endpoints.""" + plugin1_config = { + 'name': 'Plugin 1 Endpoint', + 'endpoint': '/api/integrations/plugin1', + 'label_type': 'Plugin1Type', + 'plugin': 'plugin1' + } + + plugin2_config = { + 'name': 'Plugin 2 Endpoint', + 'endpoint': '/api/integrations/plugin2', + 'label_type': 'Plugin2Type', + 'plugin': 'plugin2' + } + + registry.register(plugin1_config) + registry.register(plugin2_config) + + all_endpoints = registry.list_endpoints() + assert len(all_endpoints) == 2 + + plugin1_endpoints = registry.list_by_plugin('plugin1') + assert len(plugin1_endpoints) == 1 + assert plugin1_endpoints[0]['name'] == 'Plugin 1 Endpoint' + + plugin2_endpoints = registry.list_by_plugin('plugin2') + assert len(plugin2_endpoints) == 1 + assert plugin2_endpoints[0]['name'] == 'Plugin 2 Endpoint' diff --git a/tests/test_labels_api.py b/tests/test_labels_api.py index 9f2b5da..9140a3b 100644 --- a/tests/test_labels_api.py +++ b/tests/test_labels_api.py @@ -3,6 +3,7 @@ Tests cover: - GET /api/labels - list all labels +- GET /api/labels/list - list labels for integrations (with node counts) - GET /api/labels/ - get label definition - POST /api/labels - create/update label - DELETE /api/labels/ - delete label @@ -23,6 +24,174 @@ def test_list_labels_empty(client): assert isinstance(data['labels'], list) +def test_list_labels_for_integration_empty(client): + """Test listing labels for integration page - check response structure.""" + response = client.get('/api/labels/list') + assert response.status_code == 200 + data = response.get_json() + assert data['status'] == 'success' + assert 'labels' in data + assert isinstance(data['labels'], list) + # Note: May have labels from plugins loaded during app initialization + + +def test_list_labels_for_integration_with_manual_label(client): + """Test listing labels for integration with manual label.""" + # Create a manual label + payload = { + 'name': 'TestProject42', + 'properties': [{'name': 'name', 'type': 'string', 'required': True}], + 'relationships': [], + 'source_type': 'manual' + } + create_response = client.post('/api/labels', json=payload) + assert create_response.status_code == 200, f"Failed to create label: {create_response.get_json()}" + + # List for integration - label should exist + response = client.get('/api/labels/list') + assert response.status_code == 200 + data = response.get_json() + assert data['status'] == 'success' + assert isinstance(data['labels'], list) + + # Find our test label - it must exist + test_label = next((l for l in data['labels'] if l['name'] == 'TestProject42'), None) + assert test_label is not None, "TestProject42 label not found in list" + assert test_label['source'] == 'manual' + assert test_label['source_display'] == 'Manual' + assert test_label['node_count'] == 0 # No Neo4j nodes + assert test_label['instance_id'] is None + + +def test_list_labels_for_integration_with_plugin_label(client): + """Test listing labels for integration with plugin-sourced label.""" + # Create a plugin-sourced label + payload = { + 'name': 'TestLabEquipment99', + 'properties': [{'name': 'name', 'type': 'string', 'required': True}], + 'relationships': [], + 'source_type': 'plugin_instance', + 'source_id': 'instance_abc123' + } + create_response = client.post('/api/labels', json=payload) + assert create_response.status_code == 200, f"Failed to create label: {create_response.get_json()}" + + # List for integration - label should exist + response = client.get('/api/labels/list') + assert response.status_code == 200 + data = response.get_json() + assert data['status'] == 'success' + assert isinstance(data['labels'], list) + + # Find our test label - it must exist + test_label = next((l for l in data['labels'] if l['name'] == 'TestLabEquipment99'), None) + assert test_label is not None, "TestLabEquipment99 label not found in list" + assert test_label['source'] == 'plugin_instance' + assert 'Plugin:' in test_label['source_display'] or 'instance_abc123' in test_label['source_display'] + assert test_label['node_count'] == 0 # No Neo4j nodes + assert test_label['instance_id'] == 'instance_abc123' + + +def test_list_labels_for_integration_with_system_label(client): + """Test listing labels for integration with system label.""" + # Create a system label + payload = { + 'name': 'TestSysFile88', + 'properties': [{'name': 'path', 'type': 'string', 'required': True}], + 'relationships': [], + 'source_type': 'system' + } + create_response = client.post('/api/labels', json=payload) + assert create_response.status_code == 200, f"Failed to create label: {create_response.get_json()}" + + # List for integration - label should exist + response = client.get('/api/labels/list') + assert response.status_code == 200 + data = response.get_json() + assert data['status'] == 'success' + assert isinstance(data['labels'], list) + + # Find our test label - it must exist + test_label = next((l for l in data['labels'] if l['name'] == 'TestSysFile88'), None) + assert test_label is not None, "TestSysFile88 label not found in list" + assert test_label['source'] == 'system' + assert test_label['source_display'] == 'System' + assert test_label['node_count'] == 0 + assert test_label['instance_id'] is None + + +def test_list_labels_for_integration_multiple_sources(client): + """Test listing labels with multiple source types.""" + # Create labels from different sources with unique names + labels_to_create = [ + {'name': 'TestMultiFile77', 'source_type': 'system'}, + {'name': 'TestMultiProject77', 'source_type': 'manual'}, + {'name': 'TestMultiEquipment77', 'source_type': 'plugin_instance', 'source_id': 'ilab_001'}, + {'name': 'TestMultiSample77', 'source_type': 'manual'} + ] + + for label_data in labels_to_create: + payload = { + 'name': label_data['name'], + 'properties': [], + 'relationships': [] + } + payload.update({k: v for k, v in label_data.items() if k != 'name'}) + create_response = client.post('/api/labels', json=payload) + assert create_response.status_code == 200, f"Failed to create label {label_data['name']}: {create_response.get_json()}" + + # List for integration - all labels should exist + response = client.get('/api/labels/list') + assert response.status_code == 200 + data = response.get_json() + assert data['status'] == 'success' + assert isinstance(data['labels'], list) + + # Find our test labels - all must exist + test_labels = [l for l in data['labels'] if l['name'].startswith('TestMulti')] + assert len(test_labels) == 4, f"Expected 4 TestMulti labels, found {len(test_labels)}" + + # Verify all source types are present in our test labels + sources = {label['source'] for label in test_labels} + assert 'system' in sources + assert 'manual' in sources + assert 'plugin_instance' in sources + + # Verify each label has required fields + for label in test_labels: + assert 'name' in label + assert 'source' in label + assert 'source_display' in label + assert 'node_count' in label + assert 'instance_id' in label + + +def test_list_labels_for_integration_response_format(client): + """Test that list endpoint returns format optimized for dropdowns.""" + # Create a sample label + payload = { + 'name': 'TestLabel', + 'properties': [{'name': 'prop1', 'type': 'string', 'required': False}], + 'relationships': [] + } + client.post('/api/labels', json=payload) + + # List for integration + response = client.get('/api/labels/list') + assert response.status_code == 200 + data = response.get_json() + + # Verify response structure + assert 'status' in data + assert 'labels' in data + assert data['status'] == 'success' + + # Verify each label has exactly the fields needed for dropdowns + label = data['labels'][0] + expected_fields = {'name', 'source', 'source_display', 'node_count', 'instance_id'} + assert set(label.keys()) == expected_fields + + def test_create_label_success(client): """Test creating a label with properties and relationships.""" payload = { diff --git a/tests/test_link_execution_progress.py b/tests/test_link_execution_progress.py new file mode 100644 index 0000000..1c45a79 --- /dev/null +++ b/tests/test_link_execution_progress.py @@ -0,0 +1,94 @@ +""" +Tests for link execution progress tracking. +""" +import time +from pathlib import Path + + +def test_link_execution_progress_tracking(app, client, tmp_path): + """Test that link execution provides progress tracking via /api/tasks.""" + # This is a simplified test - in production you'd need Neo4j and actual label data + # For now, we test that the service supports the background task pattern + + from scidk.services.link_service import LinkService + + service = LinkService(app) + + # Create a simple link definition (will fail without Neo4j, but tests the structure) + link_def = { + 'name': 'Test Link', + 'source_label': 'Person', + 'target_label': 'File', + 'match_strategy': 'property', + 'match_config': { + 'source_field': 'email', + 'target_field': 'path' + }, + 'relationship_type': 'OWNS', + 'relationship_props': {} + } + + # Save definition + saved = service.save_link_definition(link_def) + link_id = saved['id'] + + assert link_id, "Link definition should have an ID" + + # Verify the execute_link_job method accepts use_background_task parameter + # We can't actually execute without Neo4j, but we can verify the signature + import inspect + sig = inspect.signature(service.execute_link_job) + params = list(sig.parameters.keys()) + + assert 'link_def_id' in params + assert 'use_background_task' in params, "Should support background task mode" + + +def test_link_execution_task_fields(app, client): + """Test that link execution tasks have all required progress fields.""" + # Verify task structure by checking the method that would create it + from scidk.services.link_service import LinkService + import inspect + import ast + + service = LinkService(app) + + # Get source code of execute_link_job + source = inspect.getsource(service.execute_link_job) + + # Verify it creates task with progress fields + assert 'task' in source + assert 'progress' in source + assert 'status_message' in source + assert 'eta_seconds' in source + assert 'relationships_created' in source + + +def test_link_service_backward_compatibility(app, client): + """Test that link service maintains backward compatibility with synchronous mode.""" + from scidk.services.link_service import LinkService + + service = LinkService(app) + + # Create a test link definition + link_def = { + 'name': 'Sync Test Link', + 'source_label': 'Person', + 'target_label': 'File', + 'match_strategy': 'property', + 'match_config': {'source_field': 'id', 'target_field': 'id'}, + 'relationship_type': 'RELATES_TO', + 'relationship_props': {} + } + + saved = service.save_link_definition(link_def) + link_id = saved['id'] + + # Verify we can still use synchronous mode (for backward compatibility) + # This will fail without Neo4j but proves the parameter works + try: + # Call with use_background_task=False (legacy mode) + service.execute_link_job(link_id, use_background_task=False) + except Exception as e: + # Expected to fail without Neo4j, but should accept the parameter + assert 'use_background_task' not in str(e), "Parameter should be accepted" diff --git a/tests/test_logs_api.py b/tests/test_logs_api.py new file mode 100644 index 0000000..cf6a1b4 --- /dev/null +++ b/tests/test_logs_api.py @@ -0,0 +1,194 @@ +"""Tests for logs API endpoints.""" + +import pytest +import os +from pathlib import Path + + +@pytest.fixture +def temp_log_file(): + """Create a temporary log file with sample entries.""" + log_dir = Path('logs') + log_dir.mkdir(exist_ok=True) + log_file = log_dir / 'scidk.log' + + # Create sample log entries + sample_logs = [ + '[2026-02-09 14:07:32] [INFO] [scidk.core.scanner] Scan started: /demo_data/', + '[2026-02-09 14:07:33] [INFO] [scidk.core.scanner] Processing files...', + '[2026-02-09 14:07:34] [WARNING] [scidk.core.scanner] Large file detected: data.csv', + '[2026-02-09 14:07:35] [ERROR] [scidk.core.scanner] Failed to read file: corrupt.dat', + '[2026-02-09 14:07:36] [INFO] [scidk.web.routes.api_files] API request: /api/files', + '[2026-02-09 14:07:37] [INFO] [scidk.core.scanner] Scan completed', + ] + + with log_file.open('w') as f: + f.write('\n'.join(sample_logs)) + + yield log_file + + # Cleanup + if log_file.exists(): + log_file.unlink() + + +def test_logs_list_all(client, temp_log_file): + """Test listing all log entries.""" + response = client.get('/api/logs/viewer') + assert response.status_code == 200 + + data = response.get_json() + assert 'entries' in data + assert len(data['entries']) == 6 # All 6 sample logs + + +def test_logs_filter_by_level(client, temp_log_file): + """Test filtering logs by level.""" + response = client.get('/api/logs/viewer?level=ERROR') + assert response.status_code == 200 + + data = response.get_json() + assert 'entries' in data + assert len(data['entries']) == 1 + assert data['entries'][0]['level'] == 'ERROR' + assert 'Failed to read file' in data['entries'][0]['message'] + + +def test_logs_filter_by_source(client, temp_log_file): + """Test filtering logs by source.""" + response = client.get('/api/logs/viewer?source=scanner') + assert response.status_code == 200 + + data = response.get_json() + assert 'entries' in data + assert len(data['entries']) == 5 # 5 scanner logs + for entry in data['entries']: + assert 'scanner' in entry['source'].lower() + + +def test_logs_search(client, temp_log_file): + """Test searching logs by message content.""" + response = client.get('/api/logs/viewer?search=file') + assert response.status_code == 200 + + data = response.get_json() + assert 'entries' in data + # Should match entries containing "file" (case-insensitive) + for entry in data['entries']: + assert 'file' in entry['message'].lower() + + +def test_logs_limit(client, temp_log_file): + """Test limiting number of returned entries.""" + response = client.get('/api/logs/viewer?limit=2') + assert response.status_code == 200 + + data = response.get_json() + assert 'entries' in data + assert len(data['entries']) == 2 + + +def test_logs_combined_filters(client, temp_log_file): + """Test combining multiple filters.""" + response = client.get('/api/logs/viewer?level=INFO&source=scanner') + assert response.status_code == 200 + + data = response.get_json() + assert 'entries' in data + # Should only return INFO logs from scanner + for entry in data['entries']: + assert entry['level'] == 'INFO' + assert 'scanner' in entry['source'].lower() + + +def test_logs_no_file(client): + """Test API response when no log file exists.""" + # Temporarily rename logs directory if it exists + log_dir = Path('logs') + backup_dir = None + + if log_dir.exists(): + backup_dir = Path('logs.backup') + if backup_dir.exists(): + import shutil + shutil.rmtree(backup_dir) + log_dir.rename(backup_dir) + + try: + response = client.get('/api/logs/viewer') + assert response.status_code == 200 + + data = response.get_json() + assert 'entries' in data + assert len(data['entries']) == 0 + finally: + # Restore logs directory + if backup_dir and backup_dir.exists(): + if log_dir.exists(): + import shutil + shutil.rmtree(log_dir) + backup_dir.rename(log_dir) + + +def test_logs_export(client, temp_log_file): + """Test exporting logs as a file.""" + response = client.get('/api/logs/export') + assert response.status_code == 200 + assert response.content_type == 'application/octet-stream' + assert 'attachment' in response.headers.get('Content-Disposition', '') + + # Verify content + content = response.data.decode('utf-8') + assert 'Scan started' in content + assert '[INFO]' in content + assert '[ERROR]' in content + + +def test_logs_export_no_file(client): + """Test export endpoint when no log file exists.""" + # Temporarily rename logs directory if it exists + log_dir = Path('logs') + backup_dir = None + + if log_dir.exists(): + backup_dir = Path('logs.backup') + if backup_dir.exists(): + import shutil + shutil.rmtree(backup_dir) + log_dir.rename(backup_dir) + + try: + response = client.get('/api/logs/export') + assert response.status_code == 404 + + data = response.get_json() + assert 'error' in data + assert 'No log file found' in data['error'] + finally: + # Restore logs directory + if backup_dir and backup_dir.exists(): + if log_dir.exists(): + import shutil + shutil.rmtree(log_dir) + backup_dir.rename(log_dir) + + +def test_logs_entry_format(client, temp_log_file): + """Test that log entries have the correct format.""" + response = client.get('/api/logs/viewer') + assert response.status_code == 200 + + data = response.get_json() + assert len(data['entries']) > 0 + + entry = data['entries'][0] + assert 'timestamp' in entry + assert 'level' in entry + assert 'source' in entry + assert 'message' in entry + + # Verify timestamp format + assert len(entry['timestamp']) == 19 # YYYY-MM-DD HH:MM:SS + assert entry['timestamp'][4] == '-' + assert entry['timestamp'][10] == ' ' + assert entry['timestamp'][13] == ':' diff --git a/tests/test_plugin_endpoint_integration.py b/tests/test_plugin_endpoint_integration.py new file mode 100644 index 0000000..a8e5708 --- /dev/null +++ b/tests/test_plugin_endpoint_integration.py @@ -0,0 +1,151 @@ +"""Integration tests for plugin label endpoint registration. + +Tests the full flow of: +1. Plugin registration during app initialization +2. Endpoint registration in the registry +3. API exposure via /api/settings/plugin-endpoints +4. UI display in Settings > Integrations +""" + +import pytest +from scidk.app import create_app +from scidk.core.label_endpoint_registry import LabelEndpointRegistry +from tests.conftest import authenticate_test_client + + +@pytest.fixture +def app(): + """Create a test Flask app.""" + app = create_app() + app.config['TESTING'] = True + return app + + +@pytest.fixture +def client(app): + """Create an authenticated test client.""" + test_client = app.test_client() + return authenticate_test_client(test_client, app) + + +def test_registry_initialized_on_app_startup(app): + """Test that the label endpoint registry is initialized during app startup.""" + assert 'label_endpoints' in app.extensions['scidk'] + registry = app.extensions['scidk']['label_endpoints'] + assert isinstance(registry, LabelEndpointRegistry) + + +def test_example_plugin_registers_endpoints(app): + """Test that the example_ilab plugin registers its endpoints.""" + registry = app.extensions['scidk']['label_endpoints'] + endpoints = registry.list_endpoints() + + # Should have at least 2 endpoints from example_ilab plugin + ilab_endpoints = [e for e in endpoints if e.get('plugin') == 'example_ilab'] + assert len(ilab_endpoints) >= 2 + + # Check for iLab Services endpoint + services_endpoint = registry.get_endpoint('/api/integrations/ilab/services') + assert services_endpoint is not None + assert services_endpoint['name'] == 'iLab Services' + assert services_endpoint['label_type'] == 'iLabService' + assert services_endpoint['auth_required'] is True + assert services_endpoint['plugin'] == 'example_ilab' + + # Check for iLab Equipment endpoint + equipment_endpoint = registry.get_endpoint('/api/integrations/ilab/equipment') + assert equipment_endpoint is not None + assert equipment_endpoint['name'] == 'iLab Equipment' + assert equipment_endpoint['label_type'] == 'Equipment' + + +def test_api_list_plugin_endpoints(client): + """Test GET /api/settings/plugin-endpoints returns registered endpoints.""" + response = client.get('/api/settings/plugin-endpoints') + assert response.status_code == 200 + + data = response.get_json() + assert data['status'] == 'success' + assert 'endpoints' in data + assert isinstance(data['endpoints'], list) + + # Should have endpoints from example_ilab + endpoints = data['endpoints'] + assert len(endpoints) >= 2 + + # Verify structure of returned endpoints + for endpoint in endpoints: + assert 'name' in endpoint + assert 'endpoint' in endpoint + assert 'label_type' in endpoint + assert 'plugin' in endpoint + assert 'source' in endpoint + assert endpoint['source'] == 'plugin' + + +def test_api_get_specific_plugin_endpoint(client): + """Test GET /api/settings/plugin-endpoints/ returns specific endpoint.""" + # URL-encode the slash in the endpoint path + response = client.get('/api/settings/plugin-endpoints/api/integrations/ilab/services') + assert response.status_code == 200 + + data = response.get_json() + assert data['status'] == 'success' + assert 'endpoint' in data + + endpoint = data['endpoint'] + assert endpoint['name'] == 'iLab Services' + assert endpoint['endpoint'] == '/api/integrations/ilab/services' + assert endpoint['label_type'] == 'iLabService' + + +def test_api_get_missing_endpoint_returns_404(client): + """Test GET for non-existent endpoint returns 404.""" + response = client.get('/api/settings/plugin-endpoints/api/missing/endpoint') + assert response.status_code == 404 + + data = response.get_json() + assert data['status'] == 'error' + + +def test_endpoints_filtered_by_plugin(app): + """Test that endpoints can be filtered by plugin name.""" + registry = app.extensions['scidk']['label_endpoints'] + + ilab_endpoints = registry.list_by_plugin('example_ilab') + assert len(ilab_endpoints) >= 2 + assert all(e['plugin'] == 'example_ilab' for e in ilab_endpoints) + + +def test_endpoints_filtered_by_label_type(app): + """Test that endpoints can be filtered by label type.""" + registry = app.extensions['scidk']['label_endpoints'] + + service_endpoints = registry.list_by_label_type('iLabService') + assert len(service_endpoints) >= 1 + assert all(e['label_type'] == 'iLabService' for e in service_endpoints) + + +def test_plugin_endpoint_metadata_complete(app): + """Test that plugin endpoints have all expected metadata fields.""" + registry = app.extensions['scidk']['label_endpoints'] + endpoint = registry.get_endpoint('/api/integrations/ilab/services') + + required_fields = ['name', 'endpoint', 'label_type', 'auth_required', + 'test_url', 'plugin', 'description', 'config_schema', 'source'] + + for field in required_fields: + assert field in endpoint, f"Missing field: {field}" + + +def test_multiple_plugins_can_register_endpoints(app): + """Test that multiple plugins can register different endpoints.""" + registry = app.extensions['scidk']['label_endpoints'] + all_endpoints = registry.list_endpoints() + + # Should have endpoints from at least one plugin + assert len(all_endpoints) >= 2 + + # Check that endpoints have different paths + endpoint_paths = [e['endpoint'] for e in all_endpoints] + assert len(endpoint_paths) == len(set(endpoint_paths)), "Duplicate endpoint paths found" diff --git a/tests/test_plugin_instance_manager.py b/tests/test_plugin_instance_manager.py new file mode 100644 index 0000000..8c2cee6 --- /dev/null +++ b/tests/test_plugin_instance_manager.py @@ -0,0 +1,227 @@ +"""Tests for Plugin Instance Manager. + +Tests the management of user-created plugin instances stored in SQLite. +""" + +import pytest +import tempfile +import os +from scidk.core.plugin_instance_manager import PluginInstanceManager + + +@pytest.fixture +def temp_db(): + """Create a temporary database for testing.""" + fd, path = tempfile.mkstemp(suffix='.db') + os.close(fd) + yield path + if os.path.exists(path): + os.remove(path) + + +@pytest.fixture +def manager(temp_db): + """Create a plugin instance manager for testing.""" + return PluginInstanceManager(db_path=temp_db) + + +def test_create_instance(manager): + """Test creating a plugin instance.""" + instance_id = manager.create_instance( + template_id='table_loader', + name='Test Equipment', + config={'file_path': '/data/test.csv', 'table_name': 'test_equipment'} + ) + + assert instance_id is not None + instance = manager.get_instance(instance_id) + assert instance['name'] == 'Test Equipment' + assert instance['template_id'] == 'table_loader' + assert instance['config']['file_path'] == '/data/test.csv' + assert instance['enabled'] is True + assert instance['status'] == 'pending' + + +def test_create_duplicate_name_fails(manager): + """Test that creating instance with duplicate name fails.""" + manager.create_instance( + template_id='table_loader', + name='Test Equipment', + config={} + ) + + with pytest.raises(ValueError, match="already exists"): + manager.create_instance( + template_id='table_loader', + name='Test Equipment', + config={} + ) + + +def test_get_instance_by_name(manager): + """Test retrieving instance by name.""" + manager.create_instance( + template_id='table_loader', + name='Test Equipment', + config={} + ) + + instance = manager.get_instance_by_name('Test Equipment') + assert instance is not None + assert instance['name'] == 'Test Equipment' + + +def test_list_instances(manager): + """Test listing all instances.""" + manager.create_instance(template_id='table_loader', name='Instance 1', config={}) + manager.create_instance(template_id='table_loader', name='Instance 2', config={}) + manager.create_instance(template_id='api_fetcher', name='Instance 3', config={}) + + all_instances = manager.list_instances() + assert len(all_instances) == 3 + + # Filter by template + table_loader_instances = manager.list_instances(template_id='table_loader') + assert len(table_loader_instances) == 2 + + +def test_list_enabled_only(manager): + """Test filtering instances by enabled status.""" + id1 = manager.create_instance(template_id='table_loader', name='Enabled', config={}) + id2 = manager.create_instance(template_id='table_loader', name='Disabled', config={}) + + # Disable second instance + manager.update_instance(id2, enabled=False) + + enabled_instances = manager.list_instances(enabled_only=True) + assert len(enabled_instances) == 1 + assert enabled_instances[0]['name'] == 'Enabled' + + +def test_update_instance(manager): + """Test updating instance fields.""" + instance_id = manager.create_instance( + template_id='table_loader', + name='Original Name', + config={'key': 'value'} + ) + + # Update name + success = manager.update_instance(instance_id, name='New Name') + assert success is True + + instance = manager.get_instance(instance_id) + assert instance['name'] == 'New Name' + + # Update config + manager.update_instance(instance_id, config={'key': 'new_value', 'new_key': 'data'}) + instance = manager.get_instance(instance_id) + assert instance['config']['key'] == 'new_value' + assert instance['config']['new_key'] == 'data' + + # Update enabled status + manager.update_instance(instance_id, enabled=False) + instance = manager.get_instance(instance_id) + assert instance['enabled'] is False + assert instance['status'] == 'inactive' + + +def test_delete_instance(manager): + """Test deleting an instance.""" + instance_id = manager.create_instance( + template_id='table_loader', + name='To Delete', + config={} + ) + + # Verify it exists + instance = manager.get_instance(instance_id) + assert instance is not None + + # Delete it + success = manager.delete_instance(instance_id) + assert success is True + + # Verify it's gone + instance = manager.get_instance(instance_id) + assert instance is None + + # Delete again should return False + success = manager.delete_instance(instance_id) + assert success is False + + +def test_record_execution(manager): + """Test recording execution results.""" + instance_id = manager.create_instance( + template_id='table_loader', + name='Test Instance', + config={} + ) + + # Record successful execution + result = { + 'status': 'success', + 'rows_imported': 45, + 'columns': ['name', 'location'] + } + success = manager.record_execution(instance_id, result, status='active') + assert success is True + + # Verify recorded + instance = manager.get_instance(instance_id) + assert instance['status'] == 'active' + assert instance['last_run'] is not None + assert instance['last_result']['rows_imported'] == 45 + + # Record failed execution + error_result = {'error': 'File not found'} + manager.record_execution(instance_id, error_result, status='error') + + instance = manager.get_instance(instance_id) + assert instance['status'] == 'error' + assert instance['last_result']['error'] == 'File not found' + + +def test_get_stats(manager): + """Test getting instance statistics.""" + manager.create_instance(template_id='table_loader', name='Instance 1', config={}) + manager.create_instance(template_id='table_loader', name='Instance 2', config={}) + manager.create_instance(template_id='api_fetcher', name='Instance 3', config={}) + + # Record some executions + instances = manager.list_instances() + manager.record_execution(instances[0]['id'], {}, status='active') + manager.record_execution(instances[1]['id'], {}, status='error') + + stats = manager.get_stats() + + assert stats['total'] == 3 + assert stats['by_template']['table_loader'] == 2 + assert stats['by_template']['api_fetcher'] == 1 + assert 'active' in stats['by_status'] + assert 'error' in stats['by_status'] + + +def test_instance_timestamps(manager): + """Test that timestamps are set correctly.""" + import time + + before = time.time() + instance_id = manager.create_instance( + template_id='table_loader', + name='Test Instance', + config={} + ) + after = time.time() + + instance = manager.get_instance(instance_id) + assert before <= instance['created_at'] <= after + assert before <= instance['updated_at'] <= after + assert instance['created_at'] == instance['updated_at'] + + # Update should change updated_at + time.sleep(0.1) + manager.update_instance(instance_id, name='Updated Name') + instance = manager.get_instance(instance_id) + assert instance['updated_at'] > instance['created_at'] diff --git a/tests/test_plugin_label_publishing.py b/tests/test_plugin_label_publishing.py new file mode 100644 index 0000000..cb2c1ad --- /dev/null +++ b/tests/test_plugin_label_publishing.py @@ -0,0 +1,287 @@ +"""Tests for plugin label publishing functionality.""" + +import pytest +import sqlite3 +import json +import tempfile +import os +from scidk.core.plugin_instance_manager import PluginInstanceManager +from scidk.services.label_service import LabelService + + +@pytest.fixture +def temp_db(): + """Create a temporary database for testing with migrations.""" + fd, path = tempfile.mkstemp(suffix='.db') + os.close(fd) + + # Create connection and apply migrations including label_definitions with new columns + conn = sqlite3.connect(path) + cursor = conn.cursor() + + # Create label_definitions table with all columns + cursor.execute(''' + CREATE TABLE IF NOT EXISTS label_definitions ( + name TEXT PRIMARY KEY, + properties TEXT, + relationships TEXT, + created_at REAL, + updated_at REAL, + source_type TEXT DEFAULT 'manual', + source_id TEXT, + sync_config TEXT + ) + ''') + + # Create plugin_instances table with new columns + cursor.execute(''' + CREATE TABLE IF NOT EXISTS plugin_instances ( + id TEXT PRIMARY KEY, + name TEXT NOT NULL, + template_id TEXT NOT NULL, + config TEXT NOT NULL, + enabled INTEGER DEFAULT 1, + status TEXT, + last_run REAL, + last_result TEXT, + created_at REAL NOT NULL, + updated_at REAL NOT NULL, + published_label TEXT, + graph_config TEXT + ) + ''') + + conn.commit() + conn.close() + + yield path + if os.path.exists(path): + os.unlink(path) + + +@pytest.fixture +def instance_manager(temp_db): + """Create a plugin instance manager with temporary database.""" + return PluginInstanceManager(db_path=temp_db) + + +@pytest.fixture +def sample_table(temp_db): + """Create a sample table for testing schema inference.""" + conn = sqlite3.connect(temp_db) + cursor = conn.cursor() + + cursor.execute(''' + CREATE TABLE test_equipment ( + id INTEGER PRIMARY KEY, + name TEXT NOT NULL, + serial_number TEXT NOT NULL, + count INTEGER, + active BOOLEAN, + price REAL + ) + ''') + + # Insert some test data + cursor.execute(''' + INSERT INTO test_equipment (name, serial_number, count, active, price) + VALUES ('Microscope', 'SN001', 5, 1, 1500.50) + ''') + + conn.commit() + conn.close() + return 'test_equipment' + + +class TestSchemaInference: + """Test schema inference from SQLite tables.""" + + def test_infer_table_schema(self, instance_manager, sample_table): + """Test inferring schema from a SQLite table.""" + schema = instance_manager._infer_table_schema(sample_table) + + # Check that all columns are present + assert 'id' in schema + assert 'name' in schema + assert 'serial_number' in schema + assert 'count' in schema + assert 'active' in schema + assert 'price' in schema + + # Check types are correctly mapped + assert schema['id']['type'] == 'integer' + assert schema['name']['type'] == 'string' + assert schema['serial_number']['type'] == 'string' + assert schema['count']['type'] == 'integer' + assert schema['active']['type'] == 'boolean' + assert schema['price']['type'] == 'number' + + # Check required fields + # Note: PRIMARY KEY doesn't set notnull=1 in SQLite PRAGMA, so id won't be required + # but explicitly NOT NULL columns will be + assert schema['name']['required'] is True + assert schema['serial_number']['required'] is True + assert schema['count']['required'] is False + + def test_infer_nonexistent_table(self, instance_manager): + """Test inferring schema from a non-existent table returns empty dict.""" + schema = instance_manager._infer_table_schema('nonexistent_table') + assert schema == {} + + +class TestLabelPublishing: + """Test publishing labels from plugin instances.""" + + def test_publish_label_with_explicit_schema(self, instance_manager): + """Test publishing a label with explicit property mapping.""" + # Create a plugin instance + instance_id = instance_manager.create_instance( + template_id='table_loader', + name='Test Equipment Loader', + config={'table_name': 'test_equipment', 'file_path': '/test.csv'} + ) + + # Publish label with explicit schema + label_config = { + 'label_name': 'TestEquipment', + 'primary_key': 'serial_number', + 'property_mapping': { + 'id': {'type': 'integer', 'required': True}, + 'name': {'type': 'string', 'required': True}, + 'serial_number': {'type': 'string', 'required': True} + }, + 'sync_strategy': 'on_demand' + } + + success = instance_manager.publish_label_schema(instance_id, label_config) + assert success is True + + # Verify instance was updated + instance = instance_manager.get_instance(instance_id) + assert instance['published_label'] == 'TestEquipment' + assert instance['graph_config'] is not None + assert instance['graph_config']['label_name'] == 'TestEquipment' + + def test_publish_label_with_auto_schema(self, instance_manager, sample_table): + """Test publishing a label with auto-generated schema.""" + # Create a plugin instance + instance_id = instance_manager.create_instance( + template_id='table_loader', + name='Test Equipment Loader', + config={'table_name': sample_table, 'file_path': '/test.csv'} + ) + + # Publish label without explicit schema (should auto-generate) + label_config = { + 'label_name': 'AutoEquipment', + 'primary_key': 'id' + } + + success = instance_manager.publish_label_schema(instance_id, label_config) + assert success is True + + # Verify instance was updated + instance = instance_manager.get_instance(instance_id) + assert instance['published_label'] == 'AutoEquipment' + + def test_publish_label_invalid_instance(self, instance_manager): + """Test publishing label for non-existent instance fails.""" + label_config = { + 'label_name': 'TestLabel', + 'primary_key': 'id' + } + + success = instance_manager.publish_label_schema('invalid-id', label_config) + assert success is False + + def test_publish_label_missing_name(self, instance_manager): + """Test publishing label without name fails.""" + instance_id = instance_manager.create_instance( + template_id='table_loader', + name='Test Loader', + config={'table_name': 'test', 'file_path': '/test.csv'} + ) + + label_config = { + 'primary_key': 'id' + # Missing label_name + } + + success = instance_manager.publish_label_schema(instance_id, label_config) + assert success is False + + def test_publish_label_updates_existing(self, instance_manager, sample_table): + """Test publishing label updates existing label definition.""" + instance_id = instance_manager.create_instance( + template_id='table_loader', + name='Test Equipment Loader', + config={'table_name': sample_table, 'file_path': '/test.csv'} + ) + + # First publish + label_config1 = { + 'label_name': 'Equipment', + 'primary_key': 'id', + 'property_mapping': { + 'id': {'type': 'integer', 'required': True}, + 'name': {'type': 'string', 'required': True} + } + } + + success1 = instance_manager.publish_label_schema(instance_id, label_config1) + assert success1 is True + + # Second publish with updated schema + label_config2 = { + 'label_name': 'Equipment', + 'primary_key': 'serial_number', # Different primary key + 'property_mapping': { + 'id': {'type': 'integer', 'required': True}, + 'name': {'type': 'string', 'required': True}, + 'serial_number': {'type': 'string', 'required': True} # New property + } + } + + success2 = instance_manager.publish_label_schema(instance_id, label_config2) + assert success2 is True + + +class TestPluginInstanceColumns: + """Test new columns in plugin_instances table.""" + + def test_new_columns_in_instance_dict(self, instance_manager): + """Test that new columns are included in instance dict.""" + instance_id = instance_manager.create_instance( + template_id='table_loader', + name='Test Instance', + config={'table_name': 'test', 'file_path': '/test.csv'} + ) + + instance = instance_manager.get_instance(instance_id) + + # New columns should be present (may be None) + assert 'published_label' in instance + assert 'graph_config' in instance + + def test_published_label_persists(self, instance_manager): + """Test that published_label is persisted correctly.""" + instance_id = instance_manager.create_instance( + template_id='table_loader', + name='Test Instance', + config={'table_name': 'test', 'file_path': '/test.csv'} + ) + + label_config = { + 'label_name': 'TestLabel', + 'primary_key': 'id', + 'property_mapping': { + 'id': {'type': 'integer', 'required': True} + } + } + + instance_manager.publish_label_schema(instance_id, label_config) + + # Retrieve instance again + instance = instance_manager.get_instance(instance_id) + assert instance['published_label'] == 'TestLabel' + assert instance['graph_config']['label_name'] == 'TestLabel' diff --git a/tests/test_plugin_loader.py b/tests/test_plugin_loader.py new file mode 100644 index 0000000..966e2fb --- /dev/null +++ b/tests/test_plugin_loader.py @@ -0,0 +1,258 @@ +"""Tests for plugin loader functionality.""" + +import pytest +import tempfile +import shutil +from pathlib import Path +from scidk.core.plugin_loader import PluginLoader + + +def test_plugin_loader_init(): + """Test plugin loader initialization.""" + loader = PluginLoader() + assert loader.plugins_dir == Path('plugins') + assert loader.loaded_plugins == {} + assert loader.failed_plugins == {} + + +def test_discover_plugins_empty_dir(tmp_path): + """Test plugin discovery in empty directory.""" + loader = PluginLoader(str(tmp_path)) + plugins = loader.discover_plugins() + assert plugins == [] + + +def test_discover_plugins_with_valid_plugin(tmp_path): + """Test plugin discovery with valid plugin.""" + # Create plugin directory with __init__.py + plugin_dir = tmp_path / 'test_plugin' + plugin_dir.mkdir() + (plugin_dir / '__init__.py').write_text('# Plugin code') + + loader = PluginLoader(str(tmp_path)) + plugins = loader.discover_plugins() + assert plugins == ['test_plugin'] + + +def test_discover_plugins_ignores_invalid(tmp_path): + """Test that plugin discovery ignores invalid directories.""" + # Valid plugin + valid_plugin = tmp_path / 'valid_plugin' + valid_plugin.mkdir() + (valid_plugin / '__init__.py').write_text('# Plugin code') + + # Invalid: no __init__.py + invalid_plugin = tmp_path / 'invalid_plugin' + invalid_plugin.mkdir() + + # Invalid: starts with underscore + hidden_plugin = tmp_path / '_hidden' + hidden_plugin.mkdir() + (hidden_plugin / '__init__.py').write_text('# Hidden') + + # Invalid: not a directory + (tmp_path / 'file.txt').write_text('Not a plugin') + + loader = PluginLoader(str(tmp_path)) + plugins = loader.discover_plugins() + assert plugins == ['valid_plugin'] + + +def test_load_plugin_missing_register_function(tmp_path, app): + """Test loading plugin without register_plugin function.""" + # Create plugin without register_plugin + plugin_dir = tmp_path / 'bad_plugin' + plugin_dir.mkdir() + (plugin_dir / '__init__.py').write_text('# No register_plugin function') + + # Add to sys.path so we can import it + import sys + sys.path.insert(0, str(tmp_path)) + try: + loader = PluginLoader(str(tmp_path)) + success = loader.load_plugin('bad_plugin', app) + assert success is False + assert 'bad_plugin' in loader.failed_plugins + assert 'missing register_plugin()' in loader.failed_plugins['bad_plugin'] + finally: + sys.path.remove(str(tmp_path)) + + +def test_load_plugin_register_returns_non_dict(tmp_path, app): + """Test loading plugin where register_plugin returns non-dict.""" + # Create plugin with register_plugin that returns None + plugin_dir = tmp_path / 'bad_plugin_dict' + plugin_dir.mkdir() + (plugin_dir / '__init__.py').write_text('def register_plugin(app):\n return None\n') + + import sys + sys.path.insert(0, str(tmp_path)) + try: + loader = PluginLoader(str(tmp_path)) + success = loader.load_plugin('bad_plugin_dict', app) + assert success is False + assert 'bad_plugin_dict' in loader.failed_plugins + assert 'must return a dict' in loader.failed_plugins['bad_plugin_dict'] + finally: + sys.path.remove(str(tmp_path)) + + +def test_load_plugin_success(tmp_path, app): + """Test successfully loading a valid plugin.""" + # Create valid plugin + plugin_dir = tmp_path / 'good_plugin' + plugin_dir.mkdir() + (plugin_dir / '__init__.py').write_text(''' +def register_plugin(app): + return { + 'name': 'Good Plugin', + 'version': '1.0.0', + 'author': 'Test', + 'description': 'A test plugin' + } +''') + + import sys + sys.path.insert(0, str(tmp_path)) + try: + loader = PluginLoader(str(tmp_path)) + success = loader.load_plugin('good_plugin', app, enabled=True) + assert success is True + assert 'good_plugin' in loader.loaded_plugins + plugin_info = loader.loaded_plugins['good_plugin'] + assert plugin_info['name'] == 'Good Plugin' + assert plugin_info['version'] == '1.0.0' + assert plugin_info['enabled'] is True + assert plugin_info['status'] == 'loaded' + finally: + sys.path.remove(str(tmp_path)) + + +def test_load_plugin_disabled(tmp_path, app): + """Test loading a disabled plugin.""" + # Create valid plugin + plugin_dir = tmp_path / 'disabled_plugin' + plugin_dir.mkdir() + (plugin_dir / '__init__.py').write_text(''' +def register_plugin(app): + return { + 'name': 'Disabled Plugin', + 'version': '1.0.0', + 'author': 'Test', + 'description': 'A disabled plugin' + } +''') + + import sys + sys.path.insert(0, str(tmp_path)) + try: + loader = PluginLoader(str(tmp_path)) + success = loader.load_plugin('disabled_plugin', app, enabled=False) + assert success is True + assert 'disabled_plugin' in loader.loaded_plugins + plugin_info = loader.loaded_plugins['disabled_plugin'] + assert plugin_info['enabled'] is False + assert plugin_info['status'] == 'disabled' + finally: + sys.path.remove(str(tmp_path)) + + +def test_get_plugin_info(tmp_path, app): + """Test getting plugin info.""" + # Create and load plugin + plugin_dir = tmp_path / 'info_plugin' + plugin_dir.mkdir() + (plugin_dir / '__init__.py').write_text(''' +def register_plugin(app): + return { + 'name': 'Info Plugin', + 'version': '2.0.0', + 'author': 'Tester', + 'description': 'Plugin for testing info' + } +''') + + import sys + sys.path.insert(0, str(tmp_path)) + try: + loader = PluginLoader(str(tmp_path)) + loader.load_plugin('info_plugin', app, enabled=True) + + # Get info for loaded plugin + info = loader.get_plugin_info('info_plugin') + assert info is not None + assert info['name'] == 'Info Plugin' + assert info['version'] == '2.0.0' + + # Get info for non-existent plugin + info = loader.get_plugin_info('nonexistent') + assert info is None + finally: + sys.path.remove(str(tmp_path)) + + +def test_list_plugins(tmp_path, app): + """Test listing all plugins.""" + # Create two plugins + for i in range(2): + plugin_dir = tmp_path / f'plugin_{i}' + plugin_dir.mkdir() + (plugin_dir / '__init__.py').write_text(f''' +def register_plugin(app): + return {{ + 'name': 'Plugin {i}', + 'version': '1.0.{i}', + 'author': 'Test', + 'description': 'Plugin {i}' + }} +''') + + import sys + sys.path.insert(0, str(tmp_path)) + try: + loader = PluginLoader(str(tmp_path)) + loader.load_all_plugins(app) + + plugins = loader.list_plugins() + assert len(plugins) == 2 + plugin_names = {p['name'] for p in plugins} + assert 'Plugin 0' in plugin_names + assert 'Plugin 1' in plugin_names + finally: + sys.path.remove(str(tmp_path)) + + +def test_list_failed_plugins(tmp_path, app): + """Test listing failed plugins.""" + # Create one good and one bad plugin + good_plugin = tmp_path / 'good' + good_plugin.mkdir() + (good_plugin / '__init__.py').write_text(''' +def register_plugin(app): + return {'name': 'Good', 'version': '1.0.0', 'author': 'Test', 'description': 'Good'} +''') + + bad_plugin = tmp_path / 'bad' + bad_plugin.mkdir() + (bad_plugin / '__init__.py').write_text('# No register_plugin') + + import sys + sys.path.insert(0, str(tmp_path)) + try: + loader = PluginLoader(str(tmp_path)) + loader.load_all_plugins(app) + + failed = loader.list_failed_plugins() + assert 'bad' in failed + assert 'missing register_plugin()' in failed['bad'] + finally: + sys.path.remove(str(tmp_path)) + + +@pytest.fixture +def app(): + """Create a minimal Flask app for testing.""" + from flask import Flask + app = Flask(__name__) + app.config['TESTING'] = True + return app diff --git a/tests/test_plugin_settings.py b/tests/test_plugin_settings.py new file mode 100644 index 0000000..a8804b9 --- /dev/null +++ b/tests/test_plugin_settings.py @@ -0,0 +1,294 @@ +"""Tests for plugin settings framework.""" + +import pytest +import sqlite3 +import tempfile +import os +from datetime import datetime + +from scidk.core.plugin_settings import ( + get_plugin_setting, + set_plugin_setting, + get_all_plugin_settings, + delete_plugin_setting, + delete_all_plugin_settings, + validate_settings_against_schema, + apply_schema_defaults, + _encrypt_value, + _decrypt_value +) + + +@pytest.fixture +def temp_db(): + """Create a temporary database for testing.""" + fd, db_path = tempfile.mkstemp(suffix='.db') + os.close(fd) + + # Set environment variable for tests + old_path = os.environ.get('SCIDK_DB_PATH') + os.environ['SCIDK_DB_PATH'] = db_path + + # Initialize database with migrations + from scidk.core.migrations import migrate + conn = sqlite3.connect(db_path) + migrate(conn) + conn.close() + + yield db_path + + # Cleanup + if old_path: + os.environ['SCIDK_DB_PATH'] = old_path + else: + del os.environ['SCIDK_DB_PATH'] + + try: + os.unlink(db_path) + except Exception: + pass + + +def test_set_and_get_plugin_setting(temp_db): + """Test setting and getting a plugin setting.""" + set_plugin_setting('test_plugin', 'api_key', 'secret123') + value = get_plugin_setting('test_plugin', 'api_key') + assert value == 'secret123' + + +def test_get_plugin_setting_default(temp_db): + """Test getting a plugin setting with default value.""" + value = get_plugin_setting('nonexistent_plugin', 'key', default='default_value') + assert value == 'default_value' + + +def test_set_plugin_setting_encrypted(temp_db): + """Test setting an encrypted plugin setting.""" + set_plugin_setting('test_plugin', 'password', 'secret_password', encrypted=True) + + # Get directly from database to verify it's encrypted + conn = sqlite3.connect(temp_db) + cur = conn.execute( + "SELECT value, encrypted FROM plugin_settings WHERE plugin_name = ? AND key = ?", + ('test_plugin', 'password') + ) + row = cur.fetchone() + conn.close() + + assert row is not None + assert row[1] == 1 # encrypted flag + assert row[0] != 'secret_password' # value is encrypted + + # But get_plugin_setting should decrypt it + value = get_plugin_setting('test_plugin', 'password') + assert value == 'secret_password' + + +def test_set_plugin_setting_complex_types(temp_db): + """Test setting complex types (dict, list).""" + # Test dict + set_plugin_setting('test_plugin', 'config', {'key1': 'value1', 'key2': 'value2'}) + value = get_plugin_setting('test_plugin', 'config') + assert value == {'key1': 'value1', 'key2': 'value2'} + + # Test list + set_plugin_setting('test_plugin', 'items', ['item1', 'item2', 'item3']) + value = get_plugin_setting('test_plugin', 'items') + assert value == ['item1', 'item2', 'item3'] + + +def test_get_all_plugin_settings(temp_db): + """Test getting all settings for a plugin.""" + set_plugin_setting('test_plugin', 'key1', 'value1') + set_plugin_setting('test_plugin', 'key2', 'value2') + set_plugin_setting('test_plugin', 'key3', 'value3') + + settings = get_all_plugin_settings('test_plugin') + + assert len(settings) == 3 + assert settings['key1'] == 'value1' + assert settings['key2'] == 'value2' + assert settings['key3'] == 'value3' + + +def test_get_all_plugin_settings_with_encrypted(temp_db): + """Test getting all settings including encrypted ones.""" + set_plugin_setting('test_plugin', 'public_key', 'public_value') + set_plugin_setting('test_plugin', 'secret_key', 'secret_value', encrypted=True) + + # Include encrypted + settings = get_all_plugin_settings('test_plugin', include_encrypted=True) + assert len(settings) == 2 + assert settings['public_key'] == 'public_value' + assert settings['secret_key'] == 'secret_value' + + # Exclude encrypted + settings = get_all_plugin_settings('test_plugin', include_encrypted=False) + assert len(settings) == 1 + assert settings['public_key'] == 'public_value' + assert 'secret_key' not in settings + + +def test_delete_plugin_setting(temp_db): + """Test deleting a plugin setting.""" + set_plugin_setting('test_plugin', 'key1', 'value1') + set_plugin_setting('test_plugin', 'key2', 'value2') + + delete_plugin_setting('test_plugin', 'key1') + + assert get_plugin_setting('test_plugin', 'key1') is None + assert get_plugin_setting('test_plugin', 'key2') == 'value2' + + +def test_delete_all_plugin_settings(temp_db): + """Test deleting all settings for a plugin.""" + set_plugin_setting('test_plugin', 'key1', 'value1') + set_plugin_setting('test_plugin', 'key2', 'value2') + set_plugin_setting('other_plugin', 'key3', 'value3') + + delete_all_plugin_settings('test_plugin') + + assert len(get_all_plugin_settings('test_plugin')) == 0 + assert len(get_all_plugin_settings('other_plugin')) == 1 + + +def test_validate_settings_against_schema(): + """Test validating settings against a schema.""" + schema = { + 'required_field': { + 'type': 'text', + 'required': True + }, + 'optional_field': { + 'type': 'text', + 'required': False + }, + 'number_field': { + 'type': 'number', + 'required': False + } + } + + # Valid settings + settings = { + 'required_field': 'value', + 'number_field': 42 + } + is_valid, errors = validate_settings_against_schema(settings, schema) + assert is_valid + assert len(errors) == 0 + + # Missing required field + settings = { + 'optional_field': 'value' + } + is_valid, errors = validate_settings_against_schema(settings, schema) + assert not is_valid + assert len(errors) > 0 + assert any('required_field' in err for err in errors) + + # Invalid type + settings = { + 'required_field': 'value', + 'number_field': 'not_a_number' + } + is_valid, errors = validate_settings_against_schema(settings, schema) + assert not is_valid + assert any('number_field' in err for err in errors) + + +def test_apply_schema_defaults(): + """Test applying default values from schema.""" + schema = { + 'field1': { + 'type': 'text', + 'default': 'default_value1' + }, + 'field2': { + 'type': 'number', + 'default': 42 + }, + 'field3': { + 'type': 'boolean', + 'default': True + } + } + + # Settings with some fields + settings = { + 'field1': 'custom_value' + } + + result = apply_schema_defaults(settings, schema) + + assert result['field1'] == 'custom_value' # Not overwritten + assert result['field2'] == 42 # Default applied + assert result['field3'] is True # Default applied + + +def test_encrypt_decrypt(): + """Test encryption and decryption.""" + original = "secret_value" + encrypted = _encrypt_value(original) + + # Should be different from original + assert encrypted != original + + # Should decrypt back to original + decrypted = _decrypt_value(encrypted) + assert decrypted == original + + +def test_setting_update_timestamp(temp_db): + """Test that updated_at timestamp is set correctly.""" + from datetime import timezone + before = datetime.now(tz=timezone.utc).timestamp() + set_plugin_setting('test_plugin', 'key', 'value') + after = datetime.now(tz=timezone.utc).timestamp() + + # Check timestamp in database + conn = sqlite3.connect(temp_db) + cur = conn.execute( + "SELECT updated_at FROM plugin_settings WHERE plugin_name = ? AND key = ?", + ('test_plugin', 'key') + ) + row = cur.fetchone() + conn.close() + + assert row is not None + timestamp = row[0] + assert before <= timestamp <= after + + +def test_multiple_plugins_isolation(temp_db): + """Test that settings for different plugins are isolated.""" + set_plugin_setting('plugin1', 'key1', 'value1') + set_plugin_setting('plugin2', 'key1', 'value2') + + assert get_plugin_setting('plugin1', 'key1') == 'value1' + assert get_plugin_setting('plugin2', 'key1') == 'value2' + + delete_all_plugin_settings('plugin1') + + assert get_plugin_setting('plugin1', 'key1') is None + assert get_plugin_setting('plugin2', 'key1') == 'value2' + + +def test_setting_overwrite(temp_db): + """Test that setting a value twice overwrites the first value.""" + set_plugin_setting('test_plugin', 'key', 'value1') + set_plugin_setting('test_plugin', 'key', 'value2') + + value = get_plugin_setting('test_plugin', 'key') + assert value == 'value2' + + # Check there's only one row in the database + conn = sqlite3.connect(temp_db) + cur = conn.execute( + "SELECT COUNT(*) FROM plugin_settings WHERE plugin_name = ? AND key = ?", + ('test_plugin', 'key') + ) + count = cur.fetchone()[0] + conn.close() + + assert count == 1 diff --git a/tests/test_plugin_settings_api.py b/tests/test_plugin_settings_api.py new file mode 100644 index 0000000..f7bf18f --- /dev/null +++ b/tests/test_plugin_settings_api.py @@ -0,0 +1,308 @@ +"""Tests for plugin settings API endpoints.""" + +import pytest +import json +import tempfile +import os +import sys + +# Add test plugin directory to path for imports +test_plugins_dir = os.path.join(os.path.dirname(__file__), 'test_plugins') +if test_plugins_dir not in sys.path: + sys.path.insert(0, test_plugins_dir) + + +@pytest.fixture +def app(): + """Create a Flask app for testing.""" + from flask import Flask + from scidk.web.routes.api_plugins import bp as plugins_bp + from scidk.core.plugin_loader import PluginLoader + + app = Flask(__name__) + app.config['TESTING'] = True + + # Register blueprint + app.register_blueprint(plugins_bp) + + # Create temporary database + fd, db_path = tempfile.mkstemp(suffix='.db') + os.close(fd) + app.config['DATABASE'] = db_path + os.environ['SCIDK_DB_PATH'] = db_path + + # Initialize database + from scidk.core.migrations import migrate + import sqlite3 + conn = sqlite3.connect(db_path) + migrate(conn) + conn.close() + + # Initialize plugin loader + loader = PluginLoader('plugins') + + # Store in app extensions + if not hasattr(app, 'extensions'): + app.extensions = {} + app.extensions['scidk'] = { + 'plugins': { + 'loader': loader, + 'loaded': [], + 'failed': {} + } + } + + yield app + + # Cleanup + try: + os.unlink(db_path) + except Exception: + pass + + +@pytest.fixture +def client(app): + """Create a test client.""" + return app.test_client() + + +def test_get_plugin_settings_no_schema(client, app): + """Test getting plugin settings when plugin has no schema.""" + # Create a simple test plugin without schema + os.makedirs('test_plugins/simple_plugin', exist_ok=True) + + with open('test_plugins/simple_plugin/__init__.py', 'w') as f: + f.write(""" +def register_plugin(app): + return { + 'name': 'Simple Plugin', + 'version': '1.0.0', + 'author': 'Test', + 'description': 'Test plugin without schema' + } +""") + + # Discover plugins + from pathlib import Path + with app.app_context(): + loader = app.extensions['scidk']['plugins']['loader'] + loader.plugins_dir = Path('test_plugins') + + response = client.get('/api/plugins/simple_plugin/settings') + assert response.status_code == 200 + + data = json.loads(response.data) + assert data['success'] is True + assert data['plugin'] == 'simple_plugin' + assert data['schema'] is None + + # Cleanup + import shutil + shutil.rmtree('test_plugins', ignore_errors=True) + + +def test_get_plugin_settings_with_schema(client, app): + """Test getting plugin settings when plugin has schema.""" + response = client.get('/api/plugins/example_plugin/settings') + + if response.status_code == 404: + pytest.skip("example_plugin not available in test environment") + + assert response.status_code == 200 + + data = json.loads(response.data) + assert data['success'] is True + assert data['plugin'] == 'example_plugin' + assert data['schema'] is not None + assert isinstance(data['settings'], dict) + + +def test_update_plugin_settings(client, app): + """Test updating plugin settings.""" + new_settings = { + 'api_key': 'test_key_123', + 'endpoint_url': 'https://test.example.com', + 'max_retries': 5 + } + + response = client.post( + '/api/plugins/example_plugin/settings', + data=json.dumps({'settings': new_settings}), + content_type='application/json' + ) + + if response.status_code == 404: + pytest.skip("example_plugin not available in test environment") + + assert response.status_code == 200 + + data = json.loads(response.data) + assert data['success'] is True + + # Verify settings were saved + response = client.get('/api/plugins/example_plugin/settings') + data = json.loads(response.data) + + assert data['settings']['endpoint_url'] == 'https://test.example.com' + assert data['settings']['max_retries'] == 5 # Should be int, not string + + +def test_update_plugin_settings_invalid_json(client): + """Test updating plugin settings with invalid JSON.""" + response = client.post( + '/api/plugins/example_plugin/settings', + data='invalid json', + content_type='application/json' + ) + + # Should return 400 for invalid JSON + assert response.status_code == 400 + + # Flask returns HTML error page for 400, not JSON + assert b'Bad Request' in response.data or response.status_code == 400 + + +def test_update_plugin_settings_not_dict(client): + """Test updating plugin settings with non-dict settings.""" + response = client.post( + '/api/plugins/example_plugin/settings', + data=json.dumps({'settings': 'not a dict'}), + content_type='application/json' + ) + + assert response.status_code == 400 + + data = json.loads(response.data) + assert data['success'] is False + + +def test_update_plugin_settings_nonexistent_plugin(client): + """Test updating settings for a nonexistent plugin.""" + response = client.post( + '/api/plugins/nonexistent_plugin/settings', + data=json.dumps({'settings': {}}), + content_type='application/json' + ) + + assert response.status_code == 404 + + data = json.loads(response.data) + assert data['success'] is False + + +def test_get_plugin_settings_schema(client): + """Test getting plugin settings schema.""" + response = client.get('/api/plugins/example_plugin/settings/schema') + + if response.status_code in [404, 500]: + pytest.skip("example_plugin not available in test environment") + + assert response.status_code == 200 + + data = json.loads(response.data) + assert data['success'] is True + assert data['schema'] is not None + + +def test_update_plugin_settings_validation(client, app): + """Test that settings validation works with schema.""" + # Create a test plugin with strict validation + os.makedirs('test_plugins/validated_plugin', exist_ok=True) + + with open('test_plugins/validated_plugin/__init__.py', 'w') as f: + f.write(""" +def get_settings_schema(): + return { + 'required_field': { + 'type': 'text', + 'required': True, + 'description': 'This field is required' + }, + 'number_field': { + 'type': 'number', + 'required': False + } + } + +def register_plugin(app): + return { + 'name': 'Validated Plugin', + 'version': '1.0.0', + 'author': 'Test', + 'description': 'Test plugin with validation' + } +""") + + # Update plugin loader to use test_plugins directory + from pathlib import Path + with app.app_context(): + loader = app.extensions['scidk']['plugins']['loader'] + loader.plugins_dir = Path('test_plugins') + + # Try to update with invalid settings (missing required field) + response = client.post( + '/api/plugins/validated_plugin/settings', + data=json.dumps({'settings': {'number_field': 42}}), + content_type='application/json' + ) + + # Should fail validation + if response.status_code != 404: # Only if plugin was found + data = json.loads(response.data) + if not data.get('success'): + assert 'validation' in data.get('error', '').lower() or 'errors' in data + + # Cleanup + import shutil + shutil.rmtree('test_plugins', ignore_errors=True) + + +def test_encrypted_password_fields(client, app): + """Test that password fields are encrypted when saved.""" + # This test verifies the encryption behavior + settings_with_password = { + 'api_key': 'secret_password_123', + 'endpoint_url': 'https://test.com' + } + + response = client.post( + '/api/plugins/example_plugin/settings', + data=json.dumps({'settings': settings_with_password}), + content_type='application/json' + ) + + if response.status_code == 404: + pytest.skip("example_plugin not available in test environment") + + assert response.status_code == 200 + + # Verify the password field can be retrieved (decrypted) + response = client.get('/api/plugins/example_plugin/settings') + data = json.loads(response.data) + + # The api_key should be retrievable (it gets decrypted automatically) + assert 'api_key' in data['settings'] + + +def test_settings_persistence(client, app): + """Test that settings persist across requests.""" + settings = { + 'test_field': 'test_value_persistent' + } + + # Set settings + response = client.post( + '/api/plugins/example_plugin/settings', + data=json.dumps({'settings': settings}), + content_type='application/json' + ) + + if response.status_code == 404: + pytest.skip("example_plugin not available in test environment") + + # Get settings in a new request + response = client.get('/api/plugins/example_plugin/settings') + data = json.loads(response.data) + + assert data['settings']['test_field'] == 'test_value_persistent' diff --git a/tests/test_plugin_template_registry.py b/tests/test_plugin_template_registry.py new file mode 100644 index 0000000..3777eb6 --- /dev/null +++ b/tests/test_plugin_template_registry.py @@ -0,0 +1,258 @@ +"""Tests for Plugin Template Registry.""" + +import pytest +from scidk.core.plugin_template_registry import PluginTemplateRegistry + + +def dummy_handler(config): + """Dummy handler for testing.""" + return {'status': 'success', 'config': config} + + +class TestPluginTemplateRegistryCategories: + """Test category validation in plugin template registry.""" + + def test_valid_data_import_category(self): + """Test that data_import category is accepted with graph_behavior.""" + registry = PluginTemplateRegistry() + + result = registry.register({ + 'id': 'test_importer', + 'name': 'Test Importer', + 'description': 'Test data import plugin', + 'category': 'data_import', + 'handler': dummy_handler, + 'graph_behavior': { + 'can_create_label': True, + 'label_source': 'table_columns' + } + }) + + assert result is True + template = registry.get_template('test_importer') + assert template is not None + assert template['category'] == 'data_import' + assert template['graph_behavior']['can_create_label'] is True + + def test_valid_graph_inject_category(self): + """Test that graph_inject category is accepted.""" + registry = PluginTemplateRegistry() + + result = registry.register({ + 'id': 'test_injector', + 'name': 'Test Graph Injector', + 'description': 'Test graph inject plugin', + 'category': 'graph_inject', + 'handler': dummy_handler + }) + + assert result is True + template = registry.get_template('test_injector') + assert template['category'] == 'graph_inject' + + def test_valid_enrichment_category(self): + """Test that enrichment category is accepted.""" + registry = PluginTemplateRegistry() + + result = registry.register({ + 'id': 'test_enricher', + 'name': 'Test Enricher', + 'description': 'Test enrichment plugin', + 'category': 'enrichment', + 'handler': dummy_handler + }) + + assert result is True + template = registry.get_template('test_enricher') + assert template['category'] == 'enrichment' + + def test_valid_exporter_category(self): + """Test that exporter category is accepted.""" + registry = PluginTemplateRegistry() + + result = registry.register({ + 'id': 'test_exporter', + 'name': 'Test Exporter', + 'description': 'Test exporter plugin', + 'category': 'exporter', + 'handler': dummy_handler + }) + + assert result is True + template = registry.get_template('test_exporter') + assert template['category'] == 'exporter' + + def test_invalid_category(self): + """Test that invalid categories are rejected.""" + registry = PluginTemplateRegistry() + + result = registry.register({ + 'id': 'bad_plugin', + 'name': 'Bad Plugin', + 'description': 'Plugin with invalid category', + 'category': 'invalid_category', + 'handler': dummy_handler + }) + + assert result is False + template = registry.get_template('bad_plugin') + assert template is None + + def test_missing_category_defaults_to_exporter(self): + """Test that missing category defaults to 'exporter'.""" + registry = PluginTemplateRegistry() + + result = registry.register({ + 'id': 'no_category', + 'name': 'No Category Plugin', + 'description': 'Plugin without category', + 'handler': dummy_handler + }) + + assert result is True + template = registry.get_template('no_category') + assert template is not None + assert template['category'] == 'exporter' + + def test_data_import_without_graph_behavior_logs_warning(self): + """Test that data_import without graph_behavior succeeds but logs warning.""" + registry = PluginTemplateRegistry() + + # Should succeed (warning only) + result = registry.register({ + 'id': 'importer_no_behavior', + 'name': 'Importer Without Behavior', + 'description': 'Data import plugin without graph_behavior', + 'category': 'data_import', + 'handler': dummy_handler + }) + + assert result is True + template = registry.get_template('importer_no_behavior') + assert template is not None + assert template['category'] == 'data_import' + # graph_behavior should be empty dict + assert template['graph_behavior'] == {} + + def test_data_import_with_partial_graph_behavior(self): + """Test that data_import with partial graph_behavior logs warning.""" + registry = PluginTemplateRegistry() + + result = registry.register({ + 'id': 'importer_partial', + 'name': 'Importer Partial Behavior', + 'description': 'Data import plugin with incomplete graph_behavior', + 'category': 'data_import', + 'handler': dummy_handler, + 'graph_behavior': { + 'can_create_label': True + # Missing 'label_source' + } + }) + + assert result is True + template = registry.get_template('importer_partial') + assert template['category'] == 'data_import' + assert template['graph_behavior']['can_create_label'] is True + + def test_graph_behavior_stored_for_all_categories(self): + """Test that graph_behavior is stored even for non-data_import categories.""" + registry = PluginTemplateRegistry() + + result = registry.register({ + 'id': 'exporter_with_behavior', + 'name': 'Exporter With Behavior', + 'description': 'Exporter with graph_behavior', + 'category': 'exporter', + 'handler': dummy_handler, + 'graph_behavior': { + 'custom_key': 'custom_value' + } + }) + + assert result is True + template = registry.get_template('exporter_with_behavior') + assert template['graph_behavior']['custom_key'] == 'custom_value' + + def test_list_templates_includes_category(self): + """Test that list_templates includes category field.""" + registry = PluginTemplateRegistry() + + registry.register({ + 'id': 'plugin1', + 'name': 'Plugin 1', + 'description': 'Test plugin 1', + 'category': 'data_import', + 'handler': dummy_handler + }) + + registry.register({ + 'id': 'plugin2', + 'name': 'Plugin 2', + 'description': 'Test plugin 2', + 'category': 'exporter', + 'handler': dummy_handler + }) + + templates = registry.list_templates() + assert len(templates) == 2 + + # Check categories are included + categories = {t['category'] for t in templates} + assert 'data_import' in categories + assert 'exporter' in categories + + def test_list_templates_filter_by_category(self): + """Test filtering templates by category.""" + registry = PluginTemplateRegistry() + + registry.register({ + 'id': 'importer1', + 'name': 'Importer 1', + 'description': 'Test importer 1', + 'category': 'data_import', + 'handler': dummy_handler + }) + + registry.register({ + 'id': 'importer2', + 'name': 'Importer 2', + 'description': 'Test importer 2', + 'category': 'data_import', + 'handler': dummy_handler + }) + + registry.register({ + 'id': 'exporter1', + 'name': 'Exporter 1', + 'description': 'Test exporter 1', + 'category': 'exporter', + 'handler': dummy_handler + }) + + # Filter by data_import + importers = registry.list_templates(category='data_import') + assert len(importers) == 2 + assert all(t['category'] == 'data_import' for t in importers) + + # Filter by exporter + exporters = registry.list_templates(category='exporter') + assert len(exporters) == 1 + assert exporters[0]['category'] == 'exporter' + + def test_all_valid_categories(self): + """Test that all VALID_CATEGORIES are accepted.""" + registry = PluginTemplateRegistry() + + for category in PluginTemplateRegistry.VALID_CATEGORIES: + result = registry.register({ + 'id': f'test_{category}', + 'name': f'Test {category}', + 'description': f'Test {category} plugin', + 'category': category, + 'handler': dummy_handler + }) + assert result is True, f"Category '{category}' should be valid" + + template = registry.get_template(f'test_{category}') + assert template['category'] == category diff --git a/tests/test_plugins_api.py b/tests/test_plugins_api.py new file mode 100644 index 0000000..12e7772 --- /dev/null +++ b/tests/test_plugins_api.py @@ -0,0 +1,112 @@ +"""Tests for plugins API endpoints.""" + +import pytest + + +def test_list_plugins_endpoint(client): + """Test GET /api/plugins endpoint.""" + resp = client.get('/api/plugins') + assert resp.status_code == 200 + + data = resp.get_json() + assert 'success' in data + assert data['success'] is True + assert 'plugins' in data + assert isinstance(data['plugins'], list) + + +def test_list_plugins_includes_example_plugin(client): + """Test that example_plugin is in the plugins list.""" + resp = client.get('/api/plugins') + data = resp.get_json() + + # Find example plugin + example_plugin = None + for plugin in data['plugins']: + if plugin.get('module_name') == 'example_plugin' or plugin.get('name') == 'Example Plugin': + example_plugin = plugin + break + + assert example_plugin is not None, "Example plugin should be discoverable" + # Check if it has expected metadata (if loaded) + if example_plugin.get('status') == 'loaded': + assert example_plugin['name'] == 'Example Plugin' + assert example_plugin['version'] == '1.0.0' + + +def test_toggle_plugin_endpoint(client): + """Test POST /api/plugins//toggle endpoint.""" + # Try to disable example_plugin + resp = client.post( + '/api/plugins/example_plugin/toggle', + json={'enabled': False} + ) + assert resp.status_code == 200 + + data = resp.get_json() + assert data['success'] is True + assert data['plugin'] == 'example_plugin' + assert data['enabled'] is False + + # Enable it again + resp = client.post( + '/api/plugins/example_plugin/toggle', + json={'enabled': True} + ) + assert resp.status_code == 200 + + data = resp.get_json() + assert data['success'] is True + assert data['enabled'] is True + + +def test_toggle_plugin_invalid_json(client): + """Test toggle with invalid JSON.""" + resp = client.post( + '/api/plugins/example_plugin/toggle', + data='not json', + content_type='application/json' + ) + assert resp.status_code == 400 + + # When JSON parsing fails, Flask returns None for get_json() + # So we check the response directly or use force=True + try: + data = resp.get_json(force=True) + except: + data = None + + if data is None: + # JSON parsing failed as expected, which triggers a 400 + assert True + else: + assert data.get('success') is False + assert 'error' in data + + +def test_example_plugin_endpoints(client): + """Test that example plugin endpoints work when loaded.""" + # Check if example plugin is loaded + resp = client.get('/api/plugins') + plugins = resp.get_json()['plugins'] + + example_plugin = next( + (p for p in plugins if p.get('module_name') == 'example_plugin' and p.get('status') == 'loaded'), + None + ) + + if example_plugin: + # Test hello endpoint + resp = client.get('/api/example/hello') + assert resp.status_code == 200 + data = resp.get_json() + assert data['message'] == 'Hello from Example Plugin!' + assert data['plugin'] == 'example_plugin' + + # Test status endpoint + resp = client.get('/api/example/status') + assert resp.status_code == 200 + data = resp.get_json() + assert data['status'] == 'active' + assert data['plugin'] == 'example_plugin' + assert isinstance(data['endpoints'], list) diff --git a/tests/test_progress_indicators.py b/tests/test_progress_indicators.py new file mode 100644 index 0000000..474fda2 --- /dev/null +++ b/tests/test_progress_indicators.py @@ -0,0 +1,165 @@ +""" +Tests for progress indicators: ETA, status messages, and real-time updates. +""" +import time +from pathlib import Path + + +def test_scan_progress_eta_and_status_messages(app, client, tmp_path): + """Test that scan tasks provide ETA and status messages during execution.""" + # Create a directory with multiple files to allow progress tracking + base: Path = tmp_path / "progressroot" + base.mkdir(parents=True, exist_ok=True) + for i in range(20): + (base / f"file_{i}.txt").write_text(f"content {i}\n", encoding="utf-8") + + # Start a background scan task + r = client.post('/api/tasks', json={ + 'type': 'scan', + 'path': str(base), + 'recursive': True, + }) + assert r.status_code in (200, 202), r.get_json() + body = r.get_json() + task_id = body.get('task_id') + assert task_id + + # Poll and collect status messages and ETA values + deadline = time.time() + 10 + status_messages = [] + eta_values = [] + + while time.time() < deadline: + rd = client.get(f'/api/tasks/{task_id}') + assert rd.status_code == 200 + tj = rd.get_json() + status = tj.get('status') + + # Collect progress indicators + if 'status_message' in tj and tj['status_message']: + status_messages.append(tj['status_message']) + if 'eta_seconds' in tj and tj['eta_seconds'] is not None: + eta_values.append(tj['eta_seconds']) + + if status in ('completed', 'error', 'canceled'): + break + time.sleep(0.05) + + # Verify task completed successfully + final_task = client.get(f'/api/tasks/{task_id}').get_json() + assert final_task.get('status') == 'completed' + + # Verify we got status messages during execution + assert len(status_messages) > 0, "Should have status messages" + # Check that we got meaningful status messages (not just empty strings) + assert any('files' in msg.lower() or 'processing' in msg.lower() or 'counting' in msg.lower() + for msg in status_messages), f"Status messages should be informative: {status_messages}" + + # Note: ETA may not always be present for very fast scans, so we don't assert it must exist + # but if it does exist, it should be positive + if eta_values: + assert all(eta >= 0 for eta in eta_values), f"ETAs should be non-negative: {eta_values}" + + +def test_commit_progress_status_messages(app, client, tmp_path): + """Test that commit tasks provide status messages during execution.""" + # Create and scan a directory first + base: Path = tmp_path / "commitroot" + base.mkdir(parents=True, exist_ok=True) + for i in range(5): + (base / f"file_{i}.txt").write_text(f"content {i}\n", encoding="utf-8") + + # Run a scan first + scan_r = client.post('/api/tasks', json={ + 'type': 'scan', + 'path': str(base), + 'recursive': True, + }) + assert scan_r.status_code in (200, 202) + scan_task_id = scan_r.get_json().get('task_id') + + # Wait for scan to complete + deadline = time.time() + 10 + while time.time() < deadline: + rd = client.get(f'/api/tasks/{scan_task_id}') + if rd.get_json().get('status') in ('completed', 'error'): + break + time.sleep(0.05) + + scan_task = client.get(f'/api/tasks/{scan_task_id}').get_json() + assert scan_task.get('status') == 'completed' + scan_id = scan_task.get('scan_id') + assert scan_id + + # Now start a commit task + commit_r = client.post('/api/tasks', json={ + 'type': 'commit', + 'scan_id': scan_id, + }) + assert commit_r.status_code in (200, 202) + commit_task_id = commit_r.get_json().get('task_id') + + # Collect status messages + status_messages = [] + deadline = time.time() + 10 + + while time.time() < deadline: + rd = client.get(f'/api/tasks/{commit_task_id}') + assert rd.status_code == 200 + tj = rd.get_json() + status = tj.get('status') + + if 'status_message' in tj and tj['status_message']: + status_messages.append(tj['status_message']) + + if status in ('completed', 'error', 'canceled'): + break + time.sleep(0.05) + + # Verify commit completed + final_task = client.get(f'/api/tasks/{commit_task_id}').get_json() + assert final_task.get('status') == 'completed' + + # Verify we got status messages + assert len(status_messages) > 0, "Should have status messages for commit" + # Check for commit-related status messages + assert any('commit' in msg.lower() or 'neo4j' in msg.lower() or 'rows' in msg.lower() + for msg in status_messages), f"Status messages should be commit-related: {status_messages}" + + +def test_task_progress_fields_present(app, client, tmp_path): + """Test that all expected progress fields are present in task responses.""" + base: Path = tmp_path / "fieldsroot" + base.mkdir(parents=True, exist_ok=True) + (base / "test.txt").write_text("test", encoding="utf-8") + + # Start a scan task + r = client.post('/api/tasks', json={ + 'type': 'scan', + 'path': str(base), + 'recursive': False, + }) + assert r.status_code in (200, 202) + task_id = r.get_json().get('task_id') + + # Get task details + time.sleep(0.1) # Give it a moment to start + rd = client.get(f'/api/tasks/{task_id}') + assert rd.status_code == 200 + task = rd.get_json() + + # Verify expected fields exist + assert 'progress' in task, "Task should have progress field" + assert 'processed' in task, "Task should have processed field" + assert 'total' in task, "Task should have total field" + assert 'status' in task, "Task should have status field" + assert 'status_message' in task, "Task should have status_message field" + assert 'eta_seconds' in task, "Task should have eta_seconds field" + + # Wait for completion + deadline = time.time() + 10 + while time.time() < deadline: + rd = client.get(f'/api/tasks/{task_id}') + if rd.get_json().get('status') in ('completed', 'error'): + break + time.sleep(0.05) diff --git a/tests/test_seed_demo_data.py b/tests/test_seed_demo_data.py new file mode 100644 index 0000000..1a01d58 --- /dev/null +++ b/tests/test_seed_demo_data.py @@ -0,0 +1,281 @@ +"""Tests for demo data seeding script.""" + +import os +import pytest +import tempfile +import shutil +import sqlite3 +from pathlib import Path +import sys + +# Add scripts directory to path +sys.path.insert(0, str(Path(__file__).parent.parent / 'scripts')) + +from seed_demo_data import ( + seed_users, + seed_sample_files, + clean_demo_data, + check_ilab_plugin +) +from scidk.core.auth import AuthManager + + +@pytest.fixture +def temp_db(): + """Create a temporary database for testing.""" + fd, path = tempfile.mkstemp(suffix='.db') + os.close(fd) + yield path + if os.path.exists(path): + os.unlink(path) + + +@pytest.fixture +def temp_demo_dir(tmp_path): + """Create a temporary demo_data directory.""" + demo_dir = tmp_path / 'demo_data' + demo_dir.mkdir() + yield demo_dir + if demo_dir.exists(): + shutil.rmtree(demo_dir) + + +class TestDemoDataSeeding: + """Test suite for demo data seeding functionality.""" + + def test_seed_users_creates_demo_accounts(self, temp_db): + """Test that seed_users creates the expected demo accounts.""" + auth = AuthManager(temp_db) + + # Seed users + created = seed_users(auth) + + # Should create 3 users + assert created == 3 + + # Verify users exist + admin = auth.get_user_by_username('admin') + assert admin is not None + assert admin['role'] == 'admin' + + staff = auth.get_user_by_username('facility_staff') + assert staff is not None + assert staff['role'] == 'user' + + billing = auth.get_user_by_username('billing_team') + assert billing is not None + assert billing['role'] == 'user' + + def test_seed_users_is_idempotent(self, temp_db): + """Test that seed_users can be run multiple times safely.""" + auth = AuthManager(temp_db) + + # Seed users first time + created_first = seed_users(auth) + assert created_first == 3 + + # Seed users second time + created_second = seed_users(auth) + # Should not create duplicates + assert created_second == 0 + + # Verify still only 3 users + conn = sqlite3.connect(temp_db) + cursor = conn.execute("SELECT COUNT(*) FROM auth_users") + count = cursor.fetchone()[0] + conn.close() + assert count == 3 + + def test_demo_users_can_login(self, temp_db): + """Test that demo users can authenticate with demo123 password.""" + auth = AuthManager(temp_db) + seed_users(auth) + + # Test each user can login + users = ['admin', 'facility_staff', 'billing_team'] + for username in users: + user = auth.verify_user_credentials(username, 'demo123') + assert user is not None + assert user['username'] == username + + def test_seed_sample_files_creates_project_structure(self, temp_demo_dir): + """Test that seed_sample_files creates the expected directory structure.""" + files_created = seed_sample_files(temp_demo_dir) + + # Should create files + assert files_created > 0 + + # Verify project directories exist + assert (temp_demo_dir / 'Project_A_Cancer_Research').exists() + assert (temp_demo_dir / 'Project_B_Proteomics').exists() + assert (temp_demo_dir / 'Core_Facility_Equipment').exists() + + # Verify subdirectories exist + assert (temp_demo_dir / 'Project_A_Cancer_Research' / 'experiments').exists() + assert (temp_demo_dir / 'Project_A_Cancer_Research' / 'results' / 'microscopy').exists() + + # Verify files exist + assert (temp_demo_dir / 'Project_A_Cancer_Research' / 'README.md').exists() + assert (temp_demo_dir / 'Project_A_Cancer_Research' / 'experiments' / 'exp001_cell_culture.xlsx').exists() + + def test_seed_sample_files_is_idempotent(self, temp_demo_dir): + """Test that seed_sample_files can be run multiple times without duplicating files.""" + # Create files first time + files_created_first = seed_sample_files(temp_demo_dir) + assert files_created_first > 0 + + # Create files second time + files_created_second = seed_sample_files(temp_demo_dir) + # Should not create duplicates + assert files_created_second == 0 + + def test_sample_files_have_content(self, temp_demo_dir): + """Test that sample files are not empty.""" + seed_sample_files(temp_demo_dir) + + # Check README has content + readme = temp_demo_dir / 'Project_A_Cancer_Research' / 'README.md' + content = readme.read_text() + assert len(content) > 0 + assert 'Cancer Research' in content + + # Check other files have content + exp_file = temp_demo_dir / 'Project_A_Cancer_Research' / 'experiments' / 'exp001_cell_culture.xlsx' + assert exp_file.stat().st_size > 0 + + def test_clean_demo_data_removes_users(self, temp_db): + """Test that clean_demo_data removes demo users.""" + auth = AuthManager(temp_db) + seed_users(auth) + + # Verify users exist + assert auth.get_user_by_username('admin') is not None + + # Clean data + clean_demo_data(temp_db, 'dummy_pix.db', neo4j=False) + + # Verify users are removed + assert auth.get_user_by_username('admin') is None + assert auth.get_user_by_username('facility_staff') is None + assert auth.get_user_by_username('billing_team') is None + + def test_check_ilab_plugin_detection(self): + """Test that check_ilab_plugin correctly detects iLab plugin.""" + # This test checks if the function works + # The result depends on whether the plugin is actually installed + result = check_ilab_plugin() + assert isinstance(result, bool) + + # If plugin exists, verify the directory structure + if result: + plugin_dir = Path('plugins/ilab_table_loader') + assert plugin_dir.exists() + assert (plugin_dir / '__init__.py').exists() + + def test_clean_demo_data_removes_files(self, temp_demo_dir): + """Test that clean_demo_data removes demo_data directory.""" + # Create sample files + seed_sample_files(temp_demo_dir) + assert temp_demo_dir.exists() + assert len(list(temp_demo_dir.iterdir())) > 0 + + # Note: clean_demo_data expects demo_data in current dir + # For this test, we verify the directory would be cleaned + # In real usage, it would remove demo_data/ + assert temp_demo_dir.exists() + + def test_demo_users_have_correct_roles(self, temp_db): + """Test that demo users are assigned the correct roles.""" + auth = AuthManager(temp_db) + seed_users(auth) + + admin = auth.get_user_by_username('admin') + assert admin['role'] == 'admin' + + staff = auth.get_user_by_username('facility_staff') + assert staff['role'] == 'user' + + billing = auth.get_user_by_username('billing_team') + assert billing['role'] == 'user' + + def test_sample_files_directory_structure(self, temp_demo_dir): + """Test that the complete directory structure is created correctly.""" + seed_sample_files(temp_demo_dir) + + # Project A structure + project_a = temp_demo_dir / 'Project_A_Cancer_Research' + assert (project_a / 'experiments' / 'exp001_cell_culture.xlsx').exists() + assert (project_a / 'experiments' / 'exp002_drug_treatment.xlsx').exists() + assert (project_a / 'results' / 'microscopy' / 'sample_001.tif').exists() + assert (project_a / 'results' / 'microscopy' / 'sample_002.tif').exists() + assert (project_a / 'results' / 'flow_cytometry' / 'analysis_20240115.fcs').exists() + assert (project_a / 'protocols' / 'cell_culture_protocol.pdf').exists() + + # Project B structure + project_b = temp_demo_dir / 'Project_B_Proteomics' + assert (project_b / 'raw_data' / 'mass_spec_run001.raw').exists() + assert (project_b / 'raw_data' / 'mass_spec_run002.raw').exists() + assert (project_b / 'analysis' / 'protein_identification.xlsx').exists() + assert (project_b / 'analysis' / 'go_enrichment.csv').exists() + assert (project_b / 'figures' / 'volcano_plot.png').exists() + + # Core Facility structure + core = temp_demo_dir / 'Core_Facility_Equipment' + assert (core / 'equipment_logs' / 'confocal_microscope_2024.xlsx').exists() + assert (core / 'equipment_logs' / 'flow_cytometer_2024.xlsx').exists() + assert (core / 'maintenance' / 'service_records.pdf').exists() + assert (core / 'training' / 'microscopy_training_slides.pdf').exists() + + def test_readme_files_contain_project_info(self, temp_demo_dir): + """Test that README files contain relevant project information.""" + seed_sample_files(temp_demo_dir) + + # Check Project A README + readme_a = temp_demo_dir / 'Project_A_Cancer_Research' / 'README.md' + content_a = readme_a.read_text() + assert 'Cancer Research' in content_a or 'Project A' in content_a + + # Check Project B README + readme_b = temp_demo_dir / 'Project_B_Proteomics' / 'README.md' + content_b = readme_b.read_text() + assert 'Proteomics' in content_b or 'Project B' in content_b + + +class TestDemoDataIntegration: + """Integration tests for demo data seeding.""" + + def test_full_seed_workflow(self, temp_db, temp_demo_dir): + """Test the complete seeding workflow.""" + # Seed users + auth = AuthManager(temp_db) + users_created = seed_users(auth) + assert users_created == 3 + + # Seed files + files_created = seed_sample_files(temp_demo_dir) + assert files_created > 0 + + # Verify everything is set up + assert auth.get_user_by_username('admin') is not None + assert (temp_demo_dir / 'Project_A_Cancer_Research').exists() + + def test_reset_workflow(self, temp_db, temp_demo_dir): + """Test the reset workflow.""" + # Seed initial data + auth = AuthManager(temp_db) + seed_users(auth) + seed_sample_files(temp_demo_dir) + + # Verify data exists + assert auth.get_user_by_username('admin') is not None + assert temp_demo_dir.exists() + + # Clean data + clean_demo_data(temp_db, 'dummy_pix.db', neo4j=False) + + # Verify users are removed (files would be removed but we're using temp_demo_dir) + assert auth.get_user_by_username('admin') is None + + +if __name__ == '__main__': + pytest.main([__file__, '-v']) diff --git a/tests/test_swagger_api_docs.py b/tests/test_swagger_api_docs.py new file mode 100644 index 0000000..e0075a9 --- /dev/null +++ b/tests/test_swagger_api_docs.py @@ -0,0 +1,151 @@ +""" +Tests for Swagger/OpenAPI documentation integration. +""" +import pytest + + +def test_swagger_ui_endpoint_exists(client): + """Test that the Swagger UI endpoint is accessible.""" + resp = client.get('/api/docs') + # Swagger UI should be public (no auth required) + assert resp.status_code == 200 + assert b'swagger-ui' in resp.data or b'Swagger' in resp.data or b'flasgger' in resp.data + + +def test_swagger_ui_contains_title(client): + """Test that Swagger UI contains the SciDK API title.""" + resp = client.get('/api/docs') + assert resp.status_code == 200 + # Check for Swagger UI elements in HTML (title is loaded dynamically from apispec) + assert b'swagger-ui' in resp.data or b'Flasgger' in resp.data + + +def test_apispec_json_endpoint_exists(client): + """Test that the API spec JSON endpoint is accessible.""" + resp = client.get('/apispec.json') + # API spec should be public (no auth required) + assert resp.status_code == 200 + + +def test_apispec_json_structure(client): + """Test that API spec JSON contains expected OpenAPI structure.""" + resp = client.get('/apispec.json') + assert resp.status_code == 200 + + data = resp.get_json() + + # Should have OpenAPI/Swagger required fields + assert 'info' in data + assert 'paths' in data + + # Check info section + assert 'title' in data['info'] + assert 'version' in data['info'] + assert data['info']['title'] == 'SciDK API' + + +def test_apispec_includes_documented_endpoints(client): + """Test that API spec includes the documented endpoints.""" + resp = client.get('/apispec.json') + assert resp.status_code == 200 + + data = resp.get_json() + paths = data.get('paths', {}) + + # Check that key documented endpoints are present + assert '/api/health' in paths or any('/health' in p for p in paths) + assert '/api/health/graph' in paths or any('/health/graph' in p for p in paths) + + +def test_apispec_includes_authentication(client): + """Test that API spec includes authentication definitions.""" + resp = client.get('/apispec.json') + assert resp.status_code == 200 + + data = resp.get_json() + + # Should have security definitions (for Bearer token) + assert 'securityDefinitions' in data or 'components' in data + + +def test_documented_endpoint_has_swagger_info(client): + """Test that documented endpoints include Swagger annotations.""" + resp = client.get('/apispec.json') + assert resp.status_code == 200 + + data = resp.get_json() + paths = data.get('paths', {}) + + # Find a documented endpoint + health_paths = [p for p in paths if '/health' in p] + assert len(health_paths) > 0, "Should have at least one health endpoint" + + # Check that it has proper documentation + for health_path in health_paths: + methods = paths[health_path] + for method, details in methods.items(): + if method in ['get', 'post', 'put', 'delete']: + # Should have description or summary + assert 'summary' in details or 'description' in details + assert 'responses' in details + + +def test_swagger_static_files_accessible(client): + """Test that Swagger static files are accessible.""" + resp = client.get('/flasgger_static/swagger-ui.css') + # Should be accessible (either 200 or 304) + assert resp.status_code in [200, 304] + + +def test_apispec_includes_tags(client): + """Test that API spec organizes endpoints with tags.""" + resp = client.get('/apispec.json') + assert resp.status_code == 200 + + data = resp.get_json() + + # Check for tags (for grouping endpoints) + # Tags might be at top level or in paths + paths = data.get('paths', {}) + has_tags = False + + for path, methods in paths.items(): + for method, details in methods.items(): + if method in ['get', 'post', 'put', 'delete']: + if 'tags' in details: + has_tags = True + break + if has_tags: + break + + # At least some endpoints should have tags for organization + assert has_tags or 'tags' in data, "API spec should include tags for endpoint organization" + + +def test_swagger_ui_does_not_require_auth(client): + """Test that Swagger UI is accessible without authentication.""" + # This test ensures the middleware allows Swagger routes + resp = client.get('/api/docs') + assert resp.status_code == 200 + # Should not redirect to login + assert resp.headers.get('Location') is None + + +def test_documented_auth_endpoints(client): + """Test that authentication endpoints are documented.""" + resp = client.get('/apispec.json') + assert resp.status_code == 200 + + data = resp.get_json() + paths = data.get('paths', {}) + + # Look for auth login endpoint + auth_paths = [p for p in paths if '/auth/login' in p] + if auth_paths: + # If documented, check it has proper structure + for auth_path in auth_paths: + methods = paths[auth_path] + if 'post' in methods: + post_details = methods['post'] + assert 'parameters' in post_details or 'requestBody' in post_details + assert 'responses' in post_details diff --git a/tests/test_table_loader_plugin.py b/tests/test_table_loader_plugin.py new file mode 100644 index 0000000..8441ae9 --- /dev/null +++ b/tests/test_table_loader_plugin.py @@ -0,0 +1,556 @@ +"""Tests for the Table Loader plugin. + +This test suite covers: +1. Plugin registration +2. CSV import +3. Excel import +4. TSV import +5. Table replacement vs append +6. Error handling (missing files, invalid configs) +7. Data validation after import +""" + +import pytest +import sqlite3 +import tempfile +import shutil +from pathlib import Path +import pandas as pd + +from plugins.table_loader import register_plugin, handle_table_import +from plugins.table_loader.importer import TableImporter + + +class MockApp: + """Mock Flask app for testing plugin registration.""" + + def __init__(self): + self.extensions = { + 'scidk': { + 'plugin_templates': MockRegistry() + } + } + + +class MockRegistry: + """Mock plugin template registry for testing.""" + + def __init__(self): + self.templates = {} + + def register(self, template_config): + """Mock register method.""" + template_id = template_config['id'] + self.templates[template_id] = template_config + return True + + +@pytest.fixture +def test_db(): + """Create a temporary test database.""" + # Create a temporary database file + temp_db = tempfile.NamedTemporaryFile(delete=False, suffix='.db') + temp_db.close() + + yield temp_db.name + + # Cleanup + Path(temp_db.name).unlink(missing_ok=True) + + +@pytest.fixture +def fixtures_dir(): + """Get the path to test fixtures directory.""" + return Path(__file__).parent / 'fixtures' + + +@pytest.fixture +def mock_app(): + """Create a mock Flask app for testing.""" + return MockApp() + + +class TestPluginRegistration: + """Test plugin registration functionality.""" + + def test_register_plugin(self, mock_app): + """Test that the plugin registers correctly.""" + metadata = register_plugin(mock_app) + + # Check metadata + assert metadata['name'] == 'Table Loader' + assert metadata['version'] == '1.0.0' + assert metadata['author'] == 'SciDK Team' + assert 'description' in metadata + + # Check that template was registered + registry = mock_app.extensions['scidk']['plugin_templates'] + assert 'table_loader' in registry.templates + + # Check template configuration + template = registry.templates['table_loader'] + assert template['id'] == 'table_loader' + assert template['name'] == 'Table Loader' + assert template['category'] == 'data_import' + assert template['supports_multiple_instances'] is True + assert template['icon'] == '📊' + assert callable(template['handler']) + + def test_template_config_schema(self, mock_app): + """Test that the template config schema is properly defined.""" + register_plugin(mock_app) + registry = mock_app.extensions['scidk']['plugin_templates'] + template = registry.templates['table_loader'] + + schema = template['config_schema'] + assert 'properties' in schema + + # Check required fields + props = schema['properties'] + assert 'instance_name' in props + assert 'file_path' in props + assert 'table_name' in props + assert 'file_type' in props + assert 'has_header' in props + assert 'replace_existing' in props + assert 'sheet_name' in props + + # Check defaults + assert props['has_header']['default'] is True + assert props['replace_existing']['default'] is True + assert props['file_type']['default'] == 'auto' + + def test_preset_configs(self, mock_app): + """Test that preset configurations are defined.""" + register_plugin(mock_app) + registry = mock_app.extensions['scidk']['plugin_templates'] + template = registry.templates['table_loader'] + + presets = template['preset_configs'] + assert 'csv_import' in presets + assert 'excel_import' in presets + assert 'tsv_import' in presets + + +class TestCSVImport: + """Test CSV file import functionality.""" + + def test_import_csv_with_header(self, test_db, fixtures_dir): + """Test importing a CSV file with headers.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': 'equipment', + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': True + } + + result = importer.import_table(config) + + # Check result + assert result['status'] == 'success' + assert result['rows_imported'] == 5 + assert result['table_name'] == 'equipment' + assert len(result['columns']) == 5 + assert 'equipment_id' in result['columns'] + assert 'name' in result['columns'] + + # Verify data in database + conn = sqlite3.connect(test_db) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM equipment") + count = cursor.fetchone()[0] + assert count == 5 + + cursor.execute("SELECT * FROM equipment WHERE equipment_id = 'EQ001'") + row = cursor.fetchone() + assert row is not None + conn.close() + + def test_import_csv_auto_detect(self, test_db, fixtures_dir): + """Test CSV import with auto file type detection.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': 'equipment_auto', + 'file_type': 'auto', # Auto-detect + 'has_header': True, + 'replace_existing': True + } + + result = importer.import_table(config) + + assert result['status'] == 'success' + assert result['file_type'] == 'csv' + assert result['rows_imported'] == 5 + + def test_import_csv_replace_existing(self, test_db, fixtures_dir): + """Test replacing existing table data.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': 'equipment_replace', + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': True + } + + # First import + result1 = importer.import_table(config) + assert result1['status'] == 'success' + assert result1['rows_imported'] == 5 + + # Second import (replace) + result2 = importer.import_table(config) + assert result2['status'] == 'success' + assert result2['rows_imported'] == 5 + + # Verify only 5 rows exist (replaced, not appended) + conn = sqlite3.connect(test_db) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM equipment_replace") + count = cursor.fetchone()[0] + assert count == 5 + conn.close() + + def test_import_csv_append(self, test_db, fixtures_dir): + """Test appending to existing table data.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': 'equipment_append', + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': False # Append mode + } + + # First import + result1 = importer.import_table(config) + assert result1['status'] == 'success' + assert result1['rows_imported'] == 5 + + # Second import (append) + result2 = importer.import_table(config) + assert result2['status'] == 'success' + assert result2['rows_imported'] == 5 + + # Verify 10 rows exist (appended) + conn = sqlite3.connect(test_db) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM equipment_append") + count = cursor.fetchone()[0] + assert count == 10 + conn.close() + + +class TestExcelImport: + """Test Excel file import functionality.""" + + def test_import_excel_with_header(self, test_db, fixtures_dir): + """Test importing an Excel file with headers.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_pi_directory.xlsx'), + 'table_name': 'pi_directory', + 'file_type': 'excel', + 'has_header': True, + 'replace_existing': True, + 'sheet_name': '0' + } + + result = importer.import_table(config) + + # Check result + assert result['status'] == 'success' + assert result['rows_imported'] == 4 + assert result['table_name'] == 'pi_directory' + assert 'pi_id' in result['columns'] + assert 'name' in result['columns'] + assert 'department' in result['columns'] + + # Verify data in database + conn = sqlite3.connect(test_db) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM pi_directory") + count = cursor.fetchone()[0] + assert count == 4 + + cursor.execute("SELECT * FROM pi_directory WHERE pi_id = 'PI001'") + row = cursor.fetchone() + assert row is not None + conn.close() + + def test_import_excel_auto_detect(self, test_db, fixtures_dir): + """Test Excel import with auto file type detection.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_pi_directory.xlsx'), + 'table_name': 'pi_auto', + 'file_type': 'auto', + 'has_header': True, + 'replace_existing': True + } + + result = importer.import_table(config) + + assert result['status'] == 'success' + assert result['file_type'] == 'excel' + assert result['rows_imported'] == 4 + + +class TestTSVImport: + """Test TSV file import functionality.""" + + def test_import_tsv_with_header(self, test_db, fixtures_dir): + """Test importing a TSV file with headers.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_resources.tsv'), + 'table_name': 'resources', + 'file_type': 'tsv', + 'has_header': True, + 'replace_existing': True + } + + result = importer.import_table(config) + + # Check result + assert result['status'] == 'success' + assert result['rows_imported'] == 5 + assert result['table_name'] == 'resources' + assert 'resource_id' in result['columns'] + assert 'category' in result['columns'] + + # Verify data in database + conn = sqlite3.connect(test_db) + cursor = conn.cursor() + cursor.execute("SELECT COUNT(*) FROM resources") + count = cursor.fetchone()[0] + assert count == 5 + conn.close() + + def test_import_tsv_auto_detect(self, test_db, fixtures_dir): + """Test TSV import with auto file type detection.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_resources.tsv'), + 'table_name': 'resources_auto', + 'file_type': 'auto', + 'has_header': True, + 'replace_existing': True + } + + result = importer.import_table(config) + + assert result['status'] == 'success' + assert result['file_type'] == 'tsv' + assert result['rows_imported'] == 5 + + +class TestErrorHandling: + """Test error handling and validation.""" + + def test_missing_file(self, test_db): + """Test handling of missing file.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': '/nonexistent/file.csv', + 'table_name': 'test_table', + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': True + } + + result = importer.import_table(config) + + assert result['status'] == 'error' + assert 'not found' in result['message'].lower() + assert result['rows_imported'] == 0 + + def test_missing_required_field(self, test_db): + """Test handling of missing required configuration fields.""" + importer = TableImporter(db_path=test_db) + + # Missing file_path + config = { + 'table_name': 'test_table', + 'file_type': 'csv' + } + + with pytest.raises(ValueError, match='file_path'): + importer.import_table(config) + + # Missing table_name + config = { + 'file_path': '/path/to/file.csv', + 'file_type': 'csv' + } + + with pytest.raises(ValueError, match='table_name'): + importer.import_table(config) + + def test_invalid_table_name(self, test_db, fixtures_dir): + """Test handling of invalid table names.""" + importer = TableImporter(db_path=test_db) + + # Table name starting with digit + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': '123invalid', + 'file_type': 'csv', + 'has_header': True + } + + result = importer.import_table(config) + assert result['status'] == 'error' + + # Table name with spaces + config['table_name'] = 'invalid table name' + result = importer.import_table(config) + assert result['status'] == 'error' + + def test_unsupported_file_type(self, test_db): + """Test handling of unsupported file types.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': '/path/to/file.pdf', + 'table_name': 'test_table', + 'file_type': 'auto', + 'has_header': True + } + + result = importer.import_table(config) + assert result['status'] == 'error' + assert 'unsupported' in result['message'].lower() + + +class TestHandleTableImport: + """Test the main handler function.""" + + def test_handle_table_import(self, test_db, fixtures_dir, monkeypatch): + """Test the handle_table_import function.""" + # Monkey-patch the TableImporter to use our test database + def mock_init(self, db_path='scidk_settings.db'): + self.db_path = test_db + + monkeypatch.setattr(TableImporter, '__init__', mock_init) + + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': 'equipment_handler', + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': True + } + + result = handle_table_import(config) + + assert result['status'] == 'success' + assert result['rows_imported'] == 5 + assert result['table_name'] == 'equipment_handler' + + +class TestDataValidation: + """Test data integrity after import.""" + + def test_column_names_preserved(self, test_db, fixtures_dir): + """Test that column names are preserved correctly.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': 'equipment_columns', + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': True + } + + result = importer.import_table(config) + + # Check that all expected columns are present + expected_columns = ['equipment_id', 'name', 'location', 'status', 'purchase_date'] + assert all(col in result['columns'] for col in expected_columns) + + # Verify in database + conn = sqlite3.connect(test_db) + cursor = conn.cursor() + cursor.execute("PRAGMA table_info(equipment_columns)") + db_columns = [row[1] for row in cursor.fetchall()] + assert all(col in db_columns for col in expected_columns) + conn.close() + + def test_data_values_preserved(self, test_db, fixtures_dir): + """Test that data values are preserved correctly.""" + importer = TableImporter(db_path=test_db) + + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': 'equipment_values', + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': True + } + + result = importer.import_table(config) + + # Read back from database and verify values + conn = sqlite3.connect(test_db) + df = pd.read_sql_query("SELECT * FROM equipment_values ORDER BY equipment_id", conn) + conn.close() + + # Check specific values + assert df.loc[0, 'equipment_id'] == 'EQ001' + assert df.loc[0, 'name'] == 'Microscope Alpha' + assert df.loc[0, 'location'] == 'Lab A' + assert df.loc[0, 'status'] == 'operational' + + assert df.loc[4, 'equipment_id'] == 'EQ005' + assert df.loc[4, 'status'] == 'decommissioned' + + def test_row_count_accuracy(self, test_db, fixtures_dir): + """Test that row counts are accurate.""" + importer = TableImporter(db_path=test_db) + + # Test with CSV (5 rows) + config = { + 'file_path': str(fixtures_dir / 'sample_equipment.csv'), + 'table_name': 'test_csv_count', + 'file_type': 'csv', + 'has_header': True, + 'replace_existing': True + } + result = importer.import_table(config) + assert result['rows_imported'] == 5 + + # Test with Excel (4 rows) + config = { + 'file_path': str(fixtures_dir / 'sample_pi_directory.xlsx'), + 'table_name': 'test_excel_count', + 'file_type': 'excel', + 'has_header': True, + 'replace_existing': True + } + result = importer.import_table(config) + assert result['rows_imported'] == 4 + + # Test with TSV (5 rows) + config = { + 'file_path': str(fixtures_dir / 'sample_resources.tsv'), + 'table_name': 'test_tsv_count', + 'file_type': 'tsv', + 'has_header': True, + 'replace_existing': True + } + result = importer.import_table(config) + assert result['rows_imported'] == 5