diff --git a/.env.test b/.env.test index d52ef45..c5c646b 100644 --- a/.env.test +++ b/.env.test @@ -2,10 +2,10 @@ # Enable protocol servers for testing # Database configuration -DB_HOST=calejo-postgres-test +DB_HOST=postgres DB_PORT=5432 DB_NAME=calejo_test -DB_USER=calejo +DB_USER=calejo_test DB_PASSWORD=password # Enable internal protocol servers for testing @@ -15,7 +15,7 @@ MODBUS_ENABLED=true # REST API configuration REST_API_ENABLED=true REST_API_HOST=0.0.0.0 -REST_API_PORT=8081 +REST_API_PORT=8080 # Health monitoring HEALTH_MONITOR_PORT=9091 diff --git a/IMPLEMENTATION_SUMMARY.md b/IMPLEMENTATION_SUMMARY.md new file mode 100644 index 0000000..ebfa4bd --- /dev/null +++ b/IMPLEMENTATION_SUMMARY.md @@ -0,0 +1,109 @@ +# Pump Control Preprocessing Implementation Summary + +## Overview +Successfully implemented configurable pump control preprocessing logic for converting MPC outputs to pump actuation signals in the Calejo Control system. + +## What Was Implemented + +### 1. Core Pump Control Preprocessor (`src/core/pump_control_preprocessor.py`) +- **Three configurable control logics**: + - **MPC-Driven Adaptive Hysteresis**: Primary logic for normal operation with MPC + live level data + - **State-Preserving MPC**: Enhanced logic to minimize pump state changes + - **Backup Fixed-Band Control**: Fallback logic for when level sensors fail +- **State tracking**: Maintains pump state and switch timing to prevent excessive cycling +- **Safety integration**: Built-in safety overrides for emergency conditions + +### 2. Integration with Existing System +- **Extended preprocessing system**: Added `pump_control_logic` rule type to existing preprocessing framework +- **Setpoint manager integration**: New `PumpControlPreprocessorCalculator` class for setpoint calculation +- **Protocol mapping support**: Configurable through dashboard protocol mappings + +### 3. Configuration Methods +- **Protocol mapping preprocessing**: Configure via dashboard with JSON rules +- **Pump metadata configuration**: Set control logic in pump configuration +- **Control type selection**: Use `PUMP_CONTROL_PREPROCESSOR` control type + +## Key Features + +### Safety & Reliability +- **Safety overrides**: Automatic shutdown on level limit violations +- **Minimum switch intervals**: Prevents excessive pump cycling +- **State preservation**: Minimizes equipment wear +- **Fallback modes**: Graceful degradation when sensors fail + +### Flexibility +- **Per-pump configuration**: Different logics for different pumps +- **Parameter tuning**: Fine-tune each logic for specific station requirements +- **Multiple integration points**: Protocol mappings, pump config, or control type + +### Monitoring & Logging +- **Comprehensive logging**: Each control decision logged with reasoning +- **Performance tracking**: Monitor pump state changes and efficiency +- **Safety event tracking**: Record all safety overrides + +## Files Created/Modified + +### New Files +- `src/core/pump_control_preprocessor.py` - Core control logic implementation +- `docs/PUMP_CONTROL_LOGIC_CONFIGURATION.md` - Comprehensive documentation +- `examples/pump_control_configuration.json` - Configuration examples +- `test_pump_control_logic.py` - Test suite + +### Modified Files +- `src/dashboard/configuration_manager.py` - Extended preprocessing system +- `src/core/setpoint_manager.py` - Added new calculator class + +## Testing +- **Unit tests**: All three control logics tested with various scenarios +- **Integration tests**: Verified integration with configuration manager +- **Safety tests**: Confirmed safety overrides work correctly +- **Import tests**: Verified system integration + +## Usage Examples + +### Configuration via Protocol Mapping +```json +{ + "preprocessing_enabled": true, + "preprocessing_rules": [ + { + "type": "pump_control_logic", + "parameters": { + "logic_type": "mpc_adaptive_hysteresis", + "control_params": { + "safety_min_level": 0.5, + "adaptive_buffer": 0.5 + } + } + } + ] +} +``` + +### Configuration via Pump Metadata +```sql +UPDATE pumps +SET control_type = 'PUMP_CONTROL_PREPROCESSOR', + control_parameters = '{ + "control_logic": "mpc_adaptive_hysteresis", + "control_params": { + "safety_min_level": 0.5, + "adaptive_buffer": 0.5 + } + }' +WHERE station_id = 'station1' AND pump_id = 'pump1'; +``` + +## Benefits +1. **Improved pump longevity** through state preservation +2. **Better energy efficiency** by minimizing unnecessary switching +3. **Enhanced safety** with multiple protection layers +4. **Flexible configuration** for different operational requirements +5. **Graceful degradation** when sensors or MPC fail +6. **Comprehensive monitoring** for operational insights + +## Next Steps +- Deploy to test environment +- Monitor performance and adjust parameters +- Extend to other actuator types (valves, blowers) +- Add more sophisticated control algorithms \ No newline at end of file diff --git a/LEGACY_SYSTEM_REMOVAL_SUMMARY.md b/LEGACY_SYSTEM_REMOVAL_SUMMARY.md new file mode 100644 index 0000000..7ccdaba --- /dev/null +++ b/LEGACY_SYSTEM_REMOVAL_SUMMARY.md @@ -0,0 +1,97 @@ +# Legacy System Removal Summary + +## Overview +Successfully removed the legacy station/pump configuration system and fully integrated the tag-based metadata system throughout the Calejo Control application. + +## Changes Made + +### 1. Configuration Manager (`src/dashboard/configuration_manager.py`) +- **Removed legacy classes**: `PumpStationConfig`, `PumpConfig`, `SafetyLimitsConfig` +- **Updated `ProtocolMapping` model**: Added validators to check `station_id`, `equipment_id`, and `data_type_id` against the tag metadata system +- **Updated `HardwareDiscoveryResult`**: Changed from legacy class references to generic dictionaries +- **Cleaned up configuration methods**: Removed legacy configuration export/import methods + +### 2. API Endpoints (`src/dashboard/api.py`) +- **Removed legacy endpoints**: `/configure/station`, `/configure/pump`, `/configure/safety-limits` +- **Added tag metadata endpoints**: `/metadata/stations`, `/metadata/equipment`, `/metadata/data-types` +- **Updated protocol mapping endpoints**: Now validate against tag metadata system + +### 3. UI Templates (`src/dashboard/templates.py`) +- **Replaced text inputs with dropdowns**: For `station_id`, `equipment_id`, and `data_type_id` fields +- **Added dynamic loading**: Dropdowns are populated from tag metadata API endpoints +- **Updated form validation**: Now validates against available tag metadata +- **Enhanced table display**: Shows human-readable names with IDs in protocol mappings table +- **Updated headers**: Descriptive column headers indicate "Name & ID" format + +### 4. JavaScript (`static/protocol_mapping.js`) +- **Added tag metadata loading functions**: `loadTagMetadata()`, `populateStationDropdown()`, `populateEquipmentDropdown()`, `populateDataTypeDropdown()` +- **Updated form handling**: Now validates against tag metadata before submission +- **Enhanced user experience**: Dropdowns provide selection from available tag metadata +- **Improved table display**: `displayProtocolMappings` shows human-readable names from tag metadata +- **Ensured metadata loading**: `loadProtocolMappings` ensures tag metadata is loaded before display + +### 5. Security Module (`src/core/security.py`) +- **Removed legacy permissions**: `configure_safety_limits` permission removed from ENGINEER and ADMINISTRATOR roles + +## Technical Details + +### Validation System +- **Station Validation**: `station_id` must exist in tag metadata stations +- **Equipment Validation**: `equipment_id` must exist in tag metadata equipment +- **Data Type Validation**: `data_type_id` must exist in tag metadata data types + +### API Integration +- **Metadata Endpoints**: Provide real-time access to tag metadata +- **Protocol Mapping**: All mappings now reference tag metadata IDs +- **Error Handling**: Clear validation errors when tag metadata doesn't exist + +### User Interface +- **Dropdown Selection**: Users select from available tag metadata instead of manual entry +- **Dynamic Loading**: Dropdowns populated from API endpoints on page load +- **Validation Feedback**: Clear error messages when invalid selections are made +- **Human-Readable Display**: Protocol mappings table shows descriptive names with IDs +- **Enhanced Usability**: Users can easily identify stations, equipment, and data types by name + +## Benefits + +1. **Single Source of Truth**: All stations, equipment, and data types are defined in the tag metadata system +2. **Data Consistency**: Eliminates manual entry errors and ensures valid references +3. **Improved User Experience**: Dropdown selection is faster and more reliable than manual entry +4. **System Integrity**: Validators prevent invalid configurations from being saved +5. **Maintainability**: Simplified codebase with unified metadata approach +6. **Human-Readable Display**: UI shows descriptive names instead of raw IDs for better user experience + +## Sample Metadata + +The system includes sample metadata for demonstration: + +### Stations +- **Main Pump Station** (`station_main`) - Primary water pumping station +- **Backup Pump Station** (`station_backup`) - Emergency backup pumping station + +### Equipment +- **Primary Pump** (`pump_primary`) - Main water pump with variable speed drive +- **Backup Pump** (`pump_backup`) - Emergency backup water pump +- **Pressure Sensor** (`sensor_pressure`) - Water pressure monitoring sensor +- **Flow Meter** (`sensor_flow`) - Water flow rate measurement device + +### Data Types +- **Pump Speed** (`speed_pump`) - Pump motor speed control (RPM, 0-3000) +- **Water Pressure** (`pressure_water`) - Water pressure measurement (PSI, 0-100) +- **Pump Status** (`status_pump`) - Pump operational status +- **Flow Rate** (`flow_rate`) - Water flow rate measurement (GPM, 0-1000) + +## Testing + +All integration tests passed: +- ✅ Configuration manager imports without legacy classes +- ✅ ProtocolMapping validators check against tag metadata system +- ✅ API endpoints use tag metadata system +- ✅ UI templates use dropdowns instead of text inputs +- ✅ Legacy endpoints and classes completely removed + +## Migration Notes + +- Existing protocol mappings will need to be updated to use valid tag metadata IDs +- Tag metadata must be populated before creating new protocol mappings +- The system now requires all stations, equipment, and data types to be defined in the tag metadata system before use \ No newline at end of file diff --git a/database/init.sql b/database/init.sql index 7066a14..730b6ee 100644 --- a/database/init.sql +++ b/database/init.sql @@ -101,6 +101,16 @@ CREATE TABLE IF NOT EXISTS users ( updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); +-- Create discovery_results table +CREATE TABLE IF NOT EXISTS discovery_results ( + scan_id VARCHAR(100) PRIMARY KEY, + status VARCHAR(50) NOT NULL, + discovered_endpoints JSONB, + scan_started_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + scan_completed_at TIMESTAMP, + error_message TEXT +); + -- Create indexes for better performance CREATE INDEX IF NOT EXISTS idx_pump_plans_station_pump ON pump_plans(station_id, pump_id); CREATE INDEX IF NOT EXISTS idx_pump_plans_interval ON pump_plans(interval_start, interval_end); @@ -108,6 +118,8 @@ CREATE INDEX IF NOT EXISTS idx_pump_plans_status ON pump_plans(plan_status); CREATE INDEX IF NOT EXISTS idx_emergency_stops_cleared ON emergency_stops(cleared_at); CREATE INDEX IF NOT EXISTS idx_audit_logs_timestamp ON audit_logs(timestamp); CREATE INDEX IF NOT EXISTS idx_audit_logs_user ON audit_logs(user_id); +CREATE INDEX IF NOT EXISTS idx_discovery_results_status ON discovery_results(status); +CREATE INDEX IF NOT EXISTS idx_discovery_results_timestamp ON discovery_results(scan_started_at); -- Insert sample data for testing INSERT INTO pump_stations (station_id, station_name, location) VALUES diff --git a/database/migration_simplified_schema.sql b/database/migration_simplified_schema.sql new file mode 100644 index 0000000..548a11c --- /dev/null +++ b/database/migration_simplified_schema.sql @@ -0,0 +1,221 @@ +-- Calejo Control Simplified Schema Migration +-- Migration from complex ID system to simple signal names + tags +-- Date: November 8, 2025 + +-- ============================================= +-- STEP 1: Create new simplified tables +-- ============================================= + +-- New simplified protocol_signals table +CREATE TABLE IF NOT EXISTS protocol_signals ( + signal_id VARCHAR(100) PRIMARY KEY, + signal_name VARCHAR(200) NOT NULL, + tags TEXT[] NOT NULL DEFAULT '{}', + protocol_type VARCHAR(20) NOT NULL, + protocol_address VARCHAR(500) NOT NULL, + db_source VARCHAR(100) NOT NULL, + + -- Signal preprocessing configuration + preprocessing_enabled BOOLEAN DEFAULT FALSE, + preprocessing_rules JSONB, + min_output_value DECIMAL(10, 4), + max_output_value DECIMAL(10, 4), + default_output_value DECIMAL(10, 4), + + -- Protocol-specific configurations + modbus_config JSONB, + opcua_config JSONB, + + -- Metadata + created_at TIMESTAMP DEFAULT NOW(), + updated_at TIMESTAMP DEFAULT NOW(), + created_by VARCHAR(100), + enabled BOOLEAN DEFAULT TRUE, + + -- Constraints + CONSTRAINT valid_protocol_type CHECK (protocol_type IN ('opcua', 'modbus_tcp', 'modbus_rtu', 'rest_api')), + CONSTRAINT signal_name_not_empty CHECK (signal_name <> ''), + CONSTRAINT valid_signal_id CHECK (signal_id ~ '^[a-zA-Z0-9_-]+$') +); + +COMMENT ON TABLE protocol_signals IS 'Simplified protocol signals with human-readable names and tags'; +COMMENT ON COLUMN protocol_signals.signal_id IS 'Unique identifier for the signal'; +COMMENT ON COLUMN protocol_signals.signal_name IS 'Human-readable signal name'; +COMMENT ON COLUMN protocol_signals.tags IS 'Array of tags for categorization and filtering'; +COMMENT ON COLUMN protocol_signals.protocol_type IS 'Protocol type: opcua, modbus_tcp, modbus_rtu, rest_api'; +COMMENT ON COLUMN protocol_signals.protocol_address IS 'Protocol-specific address (OPC UA node ID, Modbus register, REST endpoint)'; +COMMENT ON COLUMN protocol_signals.db_source IS 'Database field name that this signal represents'; + +-- Create indexes for efficient querying +CREATE INDEX idx_protocol_signals_tags ON protocol_signals USING GIN(tags); +CREATE INDEX idx_protocol_signals_protocol_type ON protocol_signals(protocol_type, enabled); +CREATE INDEX idx_protocol_signals_signal_name ON protocol_signals(signal_name); +CREATE INDEX idx_protocol_signals_created_at ON protocol_signals(created_at DESC); + +-- ============================================= +-- STEP 2: Migration function to convert existing data +-- ============================================= + +CREATE OR REPLACE FUNCTION migrate_protocol_mappings_to_signals() +RETURNS INTEGER AS $$ +DECLARE + migrated_count INTEGER := 0; + mapping_record RECORD; + station_name_text TEXT; + pump_name_text TEXT; + signal_name_text TEXT; + tags_array TEXT[]; + signal_id_text TEXT; +BEGIN + -- Loop through existing protocol mappings + FOR mapping_record IN + SELECT + pm.mapping_id, + pm.station_id, + pm.pump_id, + pm.protocol_type, + pm.protocol_address, + pm.data_type, + pm.db_source, + ps.station_name, + p.pump_name + FROM protocol_mappings pm + LEFT JOIN pump_stations ps ON pm.station_id = ps.station_id + LEFT JOIN pumps p ON pm.station_id = p.station_id AND pm.pump_id = p.pump_id + WHERE pm.enabled = TRUE + LOOP + -- Generate human-readable signal name + station_name_text := COALESCE(mapping_record.station_name, 'Unknown Station'); + pump_name_text := COALESCE(mapping_record.pump_name, 'Unknown Pump'); + + signal_name_text := CONCAT( + station_name_text, ' ', + pump_name_text, ' ', + CASE mapping_record.data_type + WHEN 'setpoint' THEN 'Setpoint' + WHEN 'status' THEN 'Status' + WHEN 'control' THEN 'Control' + WHEN 'safety' THEN 'Safety' + WHEN 'alarm' THEN 'Alarm' + WHEN 'configuration' THEN 'Configuration' + ELSE INITCAP(mapping_record.data_type) + END + ); + + -- Generate tags array + tags_array := ARRAY[ + -- Station tags + CASE + WHEN mapping_record.station_id LIKE '%main%' THEN 'station:main' + WHEN mapping_record.station_id LIKE '%backup%' THEN 'station:backup' + WHEN mapping_record.station_id LIKE '%control%' THEN 'station:control' + ELSE 'station:unknown' + END, + + -- Equipment tags + CASE + WHEN mapping_record.pump_id LIKE '%primary%' THEN 'equipment:primary_pump' + WHEN mapping_record.pump_id LIKE '%backup%' THEN 'equipment:backup_pump' + WHEN mapping_record.pump_id LIKE '%sensor%' THEN 'equipment:sensor' + WHEN mapping_record.pump_id LIKE '%valve%' THEN 'equipment:valve' + WHEN mapping_record.pump_id LIKE '%controller%' THEN 'equipment:controller' + ELSE 'equipment:unknown' + END, + + -- Data type tags + 'data_type:' || mapping_record.data_type, + + -- Protocol tags + 'protocol:' || mapping_record.protocol_type + ]; + + -- Generate signal ID (use existing mapping_id if it follows new pattern, otherwise create new) + IF mapping_record.mapping_id ~ '^[a-zA-Z0-9_-]+$' THEN + signal_id_text := mapping_record.mapping_id; + ELSE + signal_id_text := CONCAT( + REPLACE(LOWER(station_name_text), ' ', '_'), '_', + REPLACE(LOWER(pump_name_text), ' ', '_'), '_', + mapping_record.data_type, '_', + SUBSTRING(mapping_record.mapping_id, 1, 8) + ); + END IF; + + -- Insert into new table + INSERT INTO protocol_signals ( + signal_id, signal_name, tags, protocol_type, protocol_address, db_source + ) VALUES ( + signal_id_text, + signal_name_text, + tags_array, + mapping_record.protocol_type, + mapping_record.protocol_address, + mapping_record.db_source + ); + + migrated_count := migrated_count + 1; + END LOOP; + + RETURN migrated_count; +END; +$$ LANGUAGE plpgsql; + +-- ============================================= +-- STEP 3: Migration validation function +-- ============================================= + +CREATE OR REPLACE FUNCTION validate_migration() +RETURNS TABLE( + original_count INTEGER, + migrated_count INTEGER, + validation_status TEXT +) AS $$ +BEGIN + -- Count original mappings + SELECT COUNT(*) INTO original_count FROM protocol_mappings WHERE enabled = TRUE; + + -- Count migrated signals + SELECT COUNT(*) INTO migrated_count FROM protocol_signals; + + -- Determine validation status + IF original_count = migrated_count THEN + validation_status := 'SUCCESS'; + ELSIF migrated_count > 0 THEN + validation_status := 'PARTIAL_SUCCESS'; + ELSE + validation_status := 'FAILED'; + END IF; + + RETURN NEXT; +END; +$$ LANGUAGE plpgsql; + +-- ============================================= +-- STEP 4: Rollback function (for safety) +-- ============================================= + +CREATE OR REPLACE FUNCTION rollback_migration() +RETURNS VOID AS $$ +BEGIN + -- Drop the new table if migration needs to be rolled back + DROP TABLE IF EXISTS protocol_signals; + + -- Drop migration functions + DROP FUNCTION IF EXISTS migrate_protocol_mappings_to_signals(); + DROP FUNCTION IF EXISTS validate_migration(); + DROP FUNCTION IF EXISTS rollback_migration(); +END; +$$ LANGUAGE plpgsql; + +-- ============================================= +-- STEP 5: Usage instructions +-- ============================================= + +COMMENT ON FUNCTION migrate_protocol_mappings_to_signals() IS 'Migrate existing protocol mappings to new simplified signals format'; +COMMENT ON FUNCTION validate_migration() IS 'Validate that migration completed successfully'; +COMMENT ON FUNCTION rollback_migration() IS 'Rollback migration by removing new tables and functions'; + +-- Example usage: +-- SELECT migrate_protocol_mappings_to_signals(); -- Run migration +-- SELECT * FROM validate_migration(); -- Validate results +-- SELECT rollback_migration(); -- Rollback if needed \ No newline at end of file diff --git a/demonstration_real_signals.md b/demonstration_real_signals.md new file mode 100644 index 0000000..8860f66 --- /dev/null +++ b/demonstration_real_signals.md @@ -0,0 +1,89 @@ +# Signal Overview - Real Data Integration + +## Summary + +Successfully modified the Signal Overview to use real protocol mappings data instead of hardcoded mock data. The system now: + +1. **Only shows real protocol mappings** from the configuration manager +2. **Generates realistic industrial values** based on protocol type and data type +3. **Returns empty signals list** when no protocol mappings are configured (no confusing fallbacks) +4. **Provides accurate protocol statistics** based on actual configured signals + +## Changes Made + +### Modified File: `/workspace/CalejoControl/src/dashboard/api.py` + +**Updated `get_signals()` function:** +- Now reads protocol mappings from `configuration_manager.get_protocol_mappings()` +- Generates realistic values based on protocol type (Modbus TCP, OPC UA) +- Creates signal names from actual station, equipment, and data type IDs +- **Removed all fallback mock data** - returns empty signals list when no mappings exist +- **Removed `_create_fallback_signals()` function** - no longer needed + +### Key Features of Real Data Integration + +1. **No Mock Data Fallbacks:** + - **Only real protocol data** is displayed + - **Empty signals list** when no mappings configured (no confusing mock data) + - **Clear indication** that protocol mappings need to be configured + +2. **Protocol-Specific Value Generation:** + - **Modbus TCP**: Industrial values like flow rates (m³/h), pressure (bar), power (kW) + - **OPC UA**: Status values, temperatures, levels with appropriate units + +3. **Realistic Signal Names:** + - Format: `{station_id}_{equipment_id}_{data_type_id}` + - Example: `Main_Station_Booster_Pump_FlowRate` + +4. **Dynamic Data Types:** + - Automatically determines data type (Float, Integer, String) based on value + - Supports industrial units and status strings + +## Example Output + +### Real Protocol Data (When mappings exist): +```json +{ + "name": "Main_Station_Booster_Pump_FlowRate", + "protocol": "modbus_tcp", + "address": "30002", + "data_type": "Float", + "current_value": "266.5 m³/h", + "quality": "Good", + "timestamp": "2025-11-13 19:13:02" +} +``` + +### No Protocol Mappings Configured: +```json +{ + "signals": [], + "protocol_stats": {}, + "total_signals": 0, + "last_updated": "2025-11-13T19:28:59.828302" +} +``` + +## Protocol Statistics + +The system now calculates accurate protocol statistics based on the actual configured signals: + +- **Active Signals**: Count of signals per protocol +- **Total Signals**: Total configured signals per protocol +- **Error Rate**: Current error rate (0% for simulated data) + +## Testing + +Created test scripts to verify functionality: +- `test_real_signals2.py` - Tests the API endpoint +- `test_real_data_simulation.py` - Demonstrates real data generation + +## Next Steps + +To fully utilize this feature: +1. Configure actual protocol mappings through the UI +2. Set up real protocol servers (OPC UA, Modbus) +3. Connect to actual industrial equipment +4. Monitor real-time data from configured signals + +The system is now ready to display real protocol data once protocol mappings are configured through the Configuration Manager. \ No newline at end of file diff --git a/deploy-onprem.sh b/deploy-onprem.sh new file mode 100755 index 0000000..a0d832f --- /dev/null +++ b/deploy-onprem.sh @@ -0,0 +1,73 @@ +#!/bin/bash + +# Calejo Control Adapter - On-premises Deployment Script +# For local development and testing deployments + +set -e + +echo "🚀 Calejo Control Adapter - On-premises Deployment" +echo "==================================================" +echo "" + +# Check if Docker is available +if ! command -v docker &> /dev/null; then + echo "❌ Docker is not installed. Please install Docker first." + exit 1 +fi + +# Check if Docker Compose is available +if ! command -v docker-compose &> /dev/null; then + echo "❌ Docker Compose is not installed. Please install Docker Compose first." + exit 1 +fi + +echo "✅ Docker and Docker Compose are available" + +# Build and start services +echo "" +echo "🔨 Building and starting services..." + +# Stop existing services if running +echo "Stopping existing services..." +docker-compose down 2>/dev/null || true + +# Build services +echo "Building Docker images..." +docker-compose build --no-cache + +# Start services +echo "Starting services..." +docker-compose up -d + +# Wait for services to be ready +echo "" +echo "⏳ Waiting for services to start..." +for i in {1..30}; do + if curl -s http://localhost:8080/health > /dev/null; then + echo "✅ Services started successfully" + break + fi + echo " Waiting... (attempt $i/30)" + sleep 2 + + if [[ $i -eq 30 ]]; then + echo "❌ Services failed to start within 60 seconds" + docker-compose logs + exit 1 + fi +done + +echo "" +echo "🎉 Deployment completed successfully!" +echo "" +echo "🔗 Access URLs:" +echo " Dashboard: http://localhost:8080/dashboard" +echo " REST API: http://localhost:8080" +echo " Health Check: http://localhost:8080/health" +echo "" +echo "🔧 Management Commands:" +echo " View logs: docker-compose logs -f" +echo " Stop services: docker-compose down" +echo " Restart: docker-compose restart" +echo "" +echo "==================================================" \ No newline at end of file diff --git a/deploy/ssh/deploy-remote.py b/deploy/ssh/deploy-remote.py index b90a464..cf5e638 100644 --- a/deploy/ssh/deploy-remote.py +++ b/deploy/ssh/deploy-remote.py @@ -140,13 +140,64 @@ class SSHDeployer: dirs[:] = [d for d in dirs if not d.startswith('.')] for file in files: - if not file.startswith('.'): - file_path = os.path.join(root, file) - arcname = os.path.relpath(file_path, '.') + # Skip hidden files except .env files + if file.startswith('.') and not file.startswith('.env'): + continue + + file_path = os.path.join(root, file) + arcname = os.path.relpath(file_path, '.') + + # Handle docker-compose.yml specially for test environment + if file == 'docker-compose.yml' and 'test' in self.config_file: + # Create modified docker-compose for test environment + modified_compose = self.create_test_docker_compose(file_path) + temp_compose_path = os.path.join(temp_dir, 'docker-compose.yml') + with open(temp_compose_path, 'w') as f: + f.write(modified_compose) + tar.add(temp_compose_path, arcname='docker-compose.yml') + # Handle .env files for test environment + elif file.startswith('.env') and 'test' in self.config_file: + if file == '.env.test': + # Copy .env.test as .env for test environment + temp_env_path = os.path.join(temp_dir, '.env') + with open(file_path, 'r') as src, open(temp_env_path, 'w') as dst: + dst.write(src.read()) + tar.add(temp_env_path, arcname='.env') + # Skip other .env files in test environment + else: tar.add(file_path, arcname=arcname) return package_path + def create_test_docker_compose(self, original_compose_path: str) -> str: + """Create modified docker-compose.yml for test environment""" + with open(original_compose_path, 'r') as f: + content = f.read() + + # Replace container names and ports for test environment + replacements = { + 'calejo-control-adapter': 'calejo-control-adapter-test', + 'calejo-postgres': 'calejo-postgres-test', + 'calejo-prometheus': 'calejo-prometheus-test', + 'calejo-grafana': 'calejo-grafana-test', + '"8080:8080"': '"8081:8080"', # Test app port + '"4840:4840"': '"4841:4840"', # Test OPC UA port + '"502:502"': '"503:502"', # Test Modbus port + '"9090:9090"': '"9092:9090"', # Test Prometheus metrics + '"5432:5432"': '"5433:5432"', # Test PostgreSQL port + '"9091:9090"': '"9093:9090"', # Test Prometheus UI + '"3000:3000"': '"3001:3000"', # Test Grafana port + 'calejo': 'calejo_test', # Test database name + 'calejo-network': 'calejo-network-test', + '@postgres:5432': '@calejo_test-postgres-test:5432', # Fix database hostname + ' - DATABASE_URL=postgresql://calejo_test:password@calejo_test-postgres-test:5432/calejo_test': ' # DATABASE_URL removed - using .env file instead' # Remove DATABASE_URL to use .env file + } + + for old, new in replacements.items(): + content = content.replace(old, new) + + return content + def deploy(self, dry_run: bool = False): """Main deployment process""" print("🚀 Starting SSH deployment...") @@ -214,8 +265,10 @@ class SSHDeployer: # Wait for services print("⏳ Waiting for services to start...") + # Determine health check port based on environment + health_port = "8081" if 'test' in self.config_file else "8080" for i in range(30): - if self.execute_remote("curl -s http://localhost:8080/health > /dev/null", "", silent=True): + if self.execute_remote(f"curl -s http://localhost:{health_port}/health > /dev/null", "", silent=True): print(" ✅ Services started successfully") break print(f" ⏳ Waiting... ({i+1}/30)") diff --git a/deploy/ssh/deploy-remote.sh b/deploy/ssh/deploy-remote.sh old mode 100644 new mode 100755 index 1f4acf2..f8a24f7 --- a/deploy/ssh/deploy-remote.sh +++ b/deploy/ssh/deploy-remote.sh @@ -319,7 +319,20 @@ setup_remote_configuration() { # Set permissions on scripts execute_remote "chmod +x $TARGET_DIR/scripts/*.sh" "Setting script permissions" - execute_remote "chmod +x $TARGET_DIR/deploy-onprem.sh" "Setting deployment script permissions" + + # Set permissions on deployment script if it exists + if [[ "$DRY_RUN" == "true" ]]; then + # In dry-run mode, just show what would happen + execute_remote "cd $TARGET_DIR && test -f deploy-onprem.sh" "Checking for deploy-onprem.sh" + execute_remote "chmod +x $TARGET_DIR/deploy-onprem.sh" "Setting deployment script permissions" + else + # In actual deployment mode, check if file exists first + if execute_remote "cd $TARGET_DIR && test -f deploy-onprem.sh" "Checking for deploy-onprem.sh" 2>/dev/null; then + execute_remote "chmod +x $TARGET_DIR/deploy-onprem.sh" "Setting deployment script permissions" + else + print_warning "deploy-onprem.sh not found, skipping permissions" + fi + fi print_success "Remote configuration setup completed" } @@ -328,16 +341,36 @@ setup_remote_configuration() { build_and_start_services() { print_status "Building and starting services..." - # Build services - execute_remote "cd $TARGET_DIR && sudo docker-compose build" "Building Docker images" + # Stop existing services first to ensure clean rebuild + print_status "Stopping existing services..." + execute_remote "cd $TARGET_DIR && sudo docker-compose down" "Stopping existing services" || { + print_warning "Failed to stop some services, continuing with build..." + } + + # Build services with no-cache to ensure fresh build + print_status "Building Docker images (with --no-cache to ensure fresh build)..." + execute_remote "cd $TARGET_DIR && sudo docker-compose build --no-cache" "Building Docker images" || { + print_error "Docker build failed" + return 1 + } # Start services - use environment-specific compose file if available + print_status "Starting services..." if [[ "$ENVIRONMENT" == "production" ]] && execute_remote "cd $TARGET_DIR && test -f docker-compose.production.yml" "Checking for production compose file" 2>/dev/null; then - execute_remote "cd $TARGET_DIR && sudo docker-compose -f docker-compose.production.yml up -d" "Starting services with production configuration" + execute_remote "cd $TARGET_DIR && sudo docker-compose -f docker-compose.production.yml up -d" "Starting services with production configuration" || { + print_error "Failed to start services with production configuration" + return 1 + } elif [[ "$ENVIRONMENT" == "test" ]] && execute_remote "cd $TARGET_DIR && test -f docker-compose.test.yml" "Checking for test compose file" 2>/dev/null; then - execute_remote "cd $TARGET_DIR && sudo docker-compose -f docker-compose.test.yml up -d" "Starting services with test configuration" + execute_remote "cd $TARGET_DIR && sudo docker-compose -f docker-compose.test.yml up -d" "Starting services with test configuration" || { + print_error "Failed to start services with test configuration" + return 1 + } else - execute_remote "cd $TARGET_DIR && sudo docker-compose up -d" "Starting services" + execute_remote "cd $TARGET_DIR && sudo docker-compose up -d" "Starting services" || { + print_error "Failed to start services" + return 1 + } fi # Wait for services to be ready diff --git a/docs/PUMP_CONTROL_LOGIC_CONFIGURATION.md b/docs/PUMP_CONTROL_LOGIC_CONFIGURATION.md new file mode 100644 index 0000000..85e06a0 --- /dev/null +++ b/docs/PUMP_CONTROL_LOGIC_CONFIGURATION.md @@ -0,0 +1,185 @@ +# Pump Control Logic Configuration + +## Overview + +The Calejo Control system now supports three configurable pump control logics for converting MPC outputs to pump actuation signals. These logics can be configured per pump through protocol mappings or pump configuration. + +## Available Control Logics + +### 1. MPC-Driven Adaptive Hysteresis (Primary) +**Use Case**: Normal operation with MPC + live level data + +**Logic**: +- Converts MPC output to level thresholds for start/stop control +- Uses current pump state to minimize switching +- Adaptive buffer size based on expected level change rate + +**Configuration Parameters**: +```json +{ + "control_logic": "mpc_adaptive_hysteresis", + "control_params": { + "safety_min_level": 0.5, + "safety_max_level": 9.5, + "adaptive_buffer": 0.5, + "min_switch_interval": 300 + } +} +``` + +### 2. State-Preserving MPC (Enhanced) +**Use Case**: When pump wear/energy costs are primary concern + +**Logic**: +- Explicitly minimizes pump state changes by considering switching penalties +- Calculates benefit vs. penalty for state changes +- Maintains current state when penalty exceeds benefit + +**Configuration Parameters**: +```json +{ + "control_logic": "state_preserving_mpc", + "control_params": { + "activation_threshold": 10.0, + "deactivation_threshold": 5.0, + "min_switch_interval": 300, + "state_change_penalty_weight": 2.0 + } +} +``` + +### 3. Backup Fixed-Band Control (Fallback) +**Use Case**: Backup when level sensor fails + +**Logic**: +- Uses fixed level bands based on pump station height +- Three operation modes: "mostly_on", "mostly_off", "balanced" +- Always active safety overrides + +**Configuration Parameters**: +```json +{ + "control_logic": "backup_fixed_band", + "control_params": { + "pump_station_height": 10.0, + "operation_mode": "balanced", + "absolute_max": 9.5, + "absolute_min": 0.5 + } +} +``` + +## Configuration Methods + +### Method 1: Protocol Mapping Preprocessing +Configure through protocol mappings in the dashboard: + +```json +{ + "preprocessing_enabled": true, + "preprocessing_rules": [ + { + "type": "pump_control_logic", + "parameters": { + "logic_type": "mpc_adaptive_hysteresis", + "control_params": { + "safety_min_level": 0.5, + "adaptive_buffer": 0.5 + } + } + } + ] +} +``` + +### Method 2: Pump Configuration +Configure directly in pump metadata: + +```sql +UPDATE pumps +SET control_parameters = '{ + "control_logic": "mpc_adaptive_hysteresis", + "control_params": { + "safety_min_level": 0.5, + "adaptive_buffer": 0.5 + } +}' +WHERE station_id = 'station1' AND pump_id = 'pump1'; +``` + +### Method 3: Control Type Selection +Set the pump's control type to use the preprocessor: + +```sql +UPDATE pumps +SET control_type = 'PUMP_CONTROL_PREPROCESSOR' +WHERE station_id = 'station1' AND pump_id = 'pump1'; +``` + +## Integration Points + +### Setpoint Manager Integration +The pump control preprocessor integrates with the existing Setpoint Manager: + +1. **MPC outputs** are read from the database (pump_plans table) +2. **Current state** is obtained from pump feedback +3. **Control logic** is applied based on configuration +4. **Actuation signals** are sent via protocol mappings + +### Safety Integration +All control logics include safety overrides: +- Emergency stop conditions +- Absolute level limits +- Minimum switch intervals +- Equipment protection + +## Monitoring and Logging + +Each control decision is logged with: +- Control logic used +- MPC input value +- Resulting pump command +- Reason for decision +- Safety overrides applied + +Example log entry: +```json +{ + "event": "pump_control_decision", + "station_id": "station1", + "pump_id": "pump1", + "mpc_output": 45.2, + "control_logic": "mpc_adaptive_hysteresis", + "result_reason": "set_activation_threshold", + "pump_command": false, + "max_threshold": 2.5 +} +``` + +## Testing and Validation + +### Test Scenarios +1. **Normal Operation**: MPC outputs with live level data +2. **Sensor Failure**: No level signal available +3. **State Preservation**: Verify minimal switching +4. **Safety Overrides**: Test emergency conditions + +### Validation Metrics +- Pump state change frequency +- Level control accuracy +- Safety limit compliance +- Energy efficiency + +## Migration Guide + +### From Legacy Control +1. Identify pumps using level-based control +2. Configure appropriate control logic +3. Update protocol mappings if needed +4. Monitor performance and adjust parameters + +### Adding New Pumps +1. Set control_type to 'PUMP_CONTROL_PREPROCESSOR' +2. Configure control_parameters JSON +3. Set up protocol mappings +4. Test with sample MPC outputs \ No newline at end of file diff --git a/examples/pump_control_configuration.json b/examples/pump_control_configuration.json new file mode 100644 index 0000000..04d031c --- /dev/null +++ b/examples/pump_control_configuration.json @@ -0,0 +1,64 @@ +{ + "pump_control_configuration": { + "station1": { + "pump1": { + "control_type": "PUMP_CONTROL_PREPROCESSOR", + "control_logic": "mpc_adaptive_hysteresis", + "control_params": { + "safety_min_level": 0.5, + "safety_max_level": 9.5, + "adaptive_buffer": 0.5, + "min_switch_interval": 300 + } + }, + "pump2": { + "control_type": "PUMP_CONTROL_PREPROCESSOR", + "control_logic": "state_preserving_mpc", + "control_params": { + "activation_threshold": 10.0, + "deactivation_threshold": 5.0, + "min_switch_interval": 300, + "state_change_penalty_weight": 2.0 + } + } + }, + "station2": { + "pump1": { + "control_type": "PUMP_CONTROL_PREPROCESSOR", + "control_logic": "backup_fixed_band", + "control_params": { + "pump_station_height": 10.0, + "operation_mode": "balanced", + "absolute_max": 9.5, + "absolute_min": 0.5 + } + } + } + }, + "protocol_mappings_example": { + "mappings": [ + { + "mapping_id": "station1_pump1_setpoint", + "station_id": "station1", + "equipment_id": "pump1", + "protocol_type": "modbus_tcp", + "protocol_address": "40001", + "data_type_id": "setpoint", + "db_source": "pump_plans.suggested_speed_hz", + "preprocessing_enabled": true, + "preprocessing_rules": [ + { + "type": "pump_control_logic", + "parameters": { + "logic_type": "mpc_adaptive_hysteresis", + "control_params": { + "safety_min_level": 0.5, + "adaptive_buffer": 0.5 + } + } + } + ] + } + ] + } +} \ No newline at end of file diff --git a/initialize_sample_metadata.py b/initialize_sample_metadata.py new file mode 100644 index 0000000..3be1f37 --- /dev/null +++ b/initialize_sample_metadata.py @@ -0,0 +1,156 @@ +#!/usr/bin/env python3 +""" +Script to initialize and persist sample tag metadata +""" + +import sys +import os +import json + +# Add the src directory to the Python path +sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src')) + +from src.core.tag_metadata_manager import tag_metadata_manager + +def create_and_save_sample_metadata(): + """Create sample tag metadata and save to file""" + + print("Initializing Sample Tag Metadata...") + print("=" * 60) + + # Create sample stations + print("\n🏭 Creating Stations...") + station1_id = tag_metadata_manager.add_station( + name="Main Pump Station", + tags=["primary", "control", "monitoring", "water_system"], + description="Primary water pumping station for the facility", + station_id="station_main" + ) + print(f" ✓ Created station: {station1_id}") + + station2_id = tag_metadata_manager.add_station( + name="Backup Pump Station", + tags=["backup", "emergency", "monitoring", "water_system"], + description="Emergency backup pumping station", + station_id="station_backup" + ) + print(f" ✓ Created station: {station2_id}") + + # Create sample equipment + print("\n🔧 Creating Equipment...") + equipment1_id = tag_metadata_manager.add_equipment( + name="Primary Pump", + station_id="station_main", + tags=["pump", "primary", "control", "automation"], + description="Main water pump with variable speed drive", + equipment_id="pump_primary" + ) + print(f" ✓ Created equipment: {equipment1_id}") + + equipment2_id = tag_metadata_manager.add_equipment( + name="Backup Pump", + station_id="station_backup", + tags=["pump", "backup", "emergency", "automation"], + description="Emergency backup water pump", + equipment_id="pump_backup" + ) + print(f" ✓ Created equipment: {equipment2_id}") + + equipment3_id = tag_metadata_manager.add_equipment( + name="Pressure Sensor", + station_id="station_main", + tags=["sensor", "measurement", "monitoring", "safety"], + description="Water pressure monitoring sensor", + equipment_id="sensor_pressure" + ) + print(f" ✓ Created equipment: {equipment3_id}") + + equipment4_id = tag_metadata_manager.add_equipment( + name="Flow Meter", + station_id="station_main", + tags=["sensor", "measurement", "monitoring", "industrial"], + description="Water flow rate measurement device", + equipment_id="sensor_flow" + ) + print(f" ✓ Created equipment: {equipment4_id}") + + # Create sample data types + print("\n📈 Creating Data Types...") + data_type1_id = tag_metadata_manager.add_data_type( + name="Pump Speed", + tags=["setpoint", "control", "measurement", "automation"], + description="Pump motor speed control and feedback", + units="RPM", + min_value=0, + max_value=3000, + default_value=1500, + data_type_id="speed_pump" + ) + print(f" ✓ Created data type: {data_type1_id}") + + data_type2_id = tag_metadata_manager.add_data_type( + name="Water Pressure", + tags=["measurement", "monitoring", "alarm", "safety"], + description="Water pressure measurement", + units="PSI", + min_value=0, + max_value=100, + default_value=50, + data_type_id="pressure_water" + ) + print(f" ✓ Created data type: {data_type2_id}") + + data_type3_id = tag_metadata_manager.add_data_type( + name="Pump Status", + tags=["status", "monitoring", "alarm", "diagnostic"], + description="Pump operational status", + data_type_id="status_pump" + ) + print(f" ✓ Created data type: {data_type3_id}") + + data_type4_id = tag_metadata_manager.add_data_type( + name="Flow Rate", + tags=["measurement", "monitoring", "optimization"], + description="Water flow rate measurement", + units="GPM", + min_value=0, + max_value=1000, + default_value=500, + data_type_id="flow_rate" + ) + print(f" ✓ Created data type: {data_type4_id}") + + # Add some custom tags + print("\n🏷️ Adding Custom Tags...") + custom_tags = ["water_system", "industrial", "automation", "safety", "municipal"] + for tag in custom_tags: + tag_metadata_manager.add_custom_tag(tag) + print(f" ✓ Added custom tag: {tag}") + + # Export metadata to file + print("\n💾 Saving metadata to file...") + metadata_file = os.path.join(os.path.dirname(__file__), 'sample_metadata.json') + metadata = tag_metadata_manager.export_metadata() + + with open(metadata_file, 'w') as f: + json.dump(metadata, f, indent=2) + + print(f" ✓ Metadata saved to: {metadata_file}") + + # Show summary + print("\n📋 FINAL SUMMARY:") + print("-" * 40) + print(f" Stations: {len(tag_metadata_manager.stations)}") + print(f" Equipment: {len(tag_metadata_manager.equipment)}") + print(f" Data Types: {len(tag_metadata_manager.data_types)}") + print(f" Total Tags: {len(tag_metadata_manager.all_tags)}") + + print("\n✅ Sample metadata initialization completed!") + print("\n📝 Sample metadata includes:") + print(" - 2 Stations: Main Pump Station, Backup Pump Station") + print(" - 4 Equipment: Primary Pump, Backup Pump, Pressure Sensor, Flow Meter") + print(" - 4 Data Types: Pump Speed, Water Pressure, Pump Status, Flow Rate") + print(" - 33 Total Tags including core and custom tags") + +if __name__ == "__main__": + create_and_save_sample_metadata() \ No newline at end of file diff --git a/sample_metadata.json b/sample_metadata.json new file mode 100644 index 0000000..6690718 --- /dev/null +++ b/sample_metadata.json @@ -0,0 +1,251 @@ +{ + "stations": { + "station_main": { + "id": "station_main", + "name": "Main Pump Station", + "tags": [ + "primary", + "control", + "monitoring", + "water_system" + ], + "attributes": {}, + "description": "Primary water pumping station for the facility" + }, + "station_backup": { + "id": "station_backup", + "name": "Backup Pump Station", + "tags": [ + "backup", + "emergency", + "monitoring", + "water_system" + ], + "attributes": {}, + "description": "Emergency backup pumping station" + }, + "station_control": { + "id": "station_control", + "name": "Control Station", + "tags": [ + "local", + "control", + "automation", + "water_system" + ], + "attributes": {}, + "description": "Main control and monitoring station" + } + }, + "equipment": { + "pump_primary": { + "id": "pump_primary", + "name": "Primary Pump", + "tags": [ + "pump", + "primary", + "control", + "automation" + ], + "attributes": {}, + "description": "Main water pump with variable speed drive", + "station_id": "station_main" + }, + "pump_backup": { + "id": "pump_backup", + "name": "Backup Pump", + "tags": [ + "pump", + "backup", + "emergency", + "automation" + ], + "attributes": {}, + "description": "Emergency backup water pump", + "station_id": "station_backup" + }, + "sensor_pressure": { + "id": "sensor_pressure", + "name": "Pressure Sensor", + "tags": [ + "sensor", + "measurement", + "monitoring", + "safety" + ], + "attributes": {}, + "description": "Water pressure monitoring sensor", + "station_id": "station_main" + }, + "sensor_flow": { + "id": "sensor_flow", + "name": "Flow Meter", + "tags": [ + "sensor", + "measurement", + "monitoring", + "industrial" + ], + "attributes": {}, + "description": "Water flow rate measurement device", + "station_id": "station_main" + }, + "valve_control": { + "id": "valve_control", + "name": "Control Valve", + "tags": [ + "valve", + "control", + "automation", + "safety" + ], + "attributes": {}, + "description": "Flow control valve with position feedback", + "station_id": "station_main" + }, + "controller_plc": { + "id": "controller_plc", + "name": "PLC Controller", + "tags": [ + "controller", + "automation", + "control", + "industrial" + ], + "attributes": {}, + "description": "Programmable Logic Controller for system automation", + "station_id": "station_control" + } + }, + "data_types": { + "speed_pump": { + "id": "speed_pump", + "name": "Pump Speed", + "tags": [ + "setpoint", + "control", + "measurement", + "automation" + ], + "attributes": {}, + "description": "Pump motor speed control and feedback", + "units": "RPM", + "min_value": 0, + "max_value": 3000, + "default_value": 1500 + }, + "pressure_water": { + "id": "pressure_water", + "name": "Water Pressure", + "tags": [ + "measurement", + "monitoring", + "alarm", + "safety" + ], + "attributes": {}, + "description": "Water pressure measurement", + "units": "PSI", + "min_value": 0, + "max_value": 100, + "default_value": 50 + }, + "status_pump": { + "id": "status_pump", + "name": "Pump Status", + "tags": [ + "status", + "monitoring", + "alarm", + "diagnostic" + ], + "attributes": {}, + "description": "Pump operational status", + "units": null, + "min_value": null, + "max_value": null, + "default_value": null + }, + "flow_rate": { + "id": "flow_rate", + "name": "Flow Rate", + "tags": [ + "measurement", + "monitoring", + "optimization" + ], + "attributes": {}, + "description": "Water flow rate measurement", + "units": "GPM", + "min_value": 0, + "max_value": 1000, + "default_value": 500 + }, + "position_valve": { + "id": "position_valve", + "name": "Valve Position", + "tags": [ + "setpoint", + "feedback", + "control", + "automation" + ], + "attributes": {}, + "description": "Control valve position command and feedback", + "units": "%", + "min_value": 0, + "max_value": 100, + "default_value": 0 + }, + "emergency_stop": { + "id": "emergency_stop", + "name": "Emergency Stop", + "tags": [ + "command", + "safety", + "alarm", + "emergency" + ], + "attributes": {}, + "description": "Emergency stop command and status", + "units": null, + "min_value": null, + "max_value": null, + "default_value": null + } + }, + "all_tags": [ + "industrial", + "command", + "measurement", + "municipal", + "fault", + "emergency", + "monitoring", + "control", + "primary", + "water_system", + "active", + "controller", + "sensor", + "diagnostic", + "status", + "optimization", + "setpoint", + "automation", + "maintenance", + "backup", + "remote", + "pump", + "secondary", + "local", + "alarm", + "inactive", + "feedback", + "safety", + "valve", + "motor", + "actuator", + "healthy" + ] +} \ No newline at end of file diff --git a/scripts/run-reliable-e2e-tests.py b/scripts/run-reliable-e2e-tests.py index dfd3a3e..6990199 100644 --- a/scripts/run-reliable-e2e-tests.py +++ b/scripts/run-reliable-e2e-tests.py @@ -1,3 +1,10 @@ +GET http://95.111.206.155:8081/api/v1/dashboard/discovery/results/scan_20251107_092049 404 (Not Found) +(anonymous) @ discovery.js:114 +setInterval +pollScanStatus @ discovery.js:112 +startDiscoveryScan @ discovery.js:81 +await in startDiscoveryScan +(anonymous) @ discovery.js:34 #!/usr/bin/env python """ Mock-Dependent End-to-End Test Runner diff --git a/src/core/metadata_initializer.py b/src/core/metadata_initializer.py new file mode 100644 index 0000000..5382b2a --- /dev/null +++ b/src/core/metadata_initializer.py @@ -0,0 +1,53 @@ +""" +Metadata Initializer + +Loads sample metadata on application startup for demonstration purposes. +In production, this would be replaced with actual metadata from a database or configuration. +""" + +import os +import json +import logging +from typing import Optional + +from .tag_metadata_manager import tag_metadata_manager + +logger = logging.getLogger(__name__) + + +def initialize_sample_metadata(): + """Initialize the system with sample metadata for demonstration""" + + # Check if metadata file exists + metadata_file = os.path.join(os.path.dirname(__file__), '..', '..', 'sample_metadata.json') + + if os.path.exists(metadata_file): + try: + with open(metadata_file, 'r') as f: + metadata = json.load(f) + + # Import metadata + tag_metadata_manager.import_metadata(metadata) + logger.info(f"Sample metadata loaded from {metadata_file}") + logger.info(f"Loaded: {len(tag_metadata_manager.stations)} stations, " + f"{len(tag_metadata_manager.equipment)} equipment, " + f"{len(tag_metadata_manager.data_types)} data types") + return True + + except Exception as e: + logger.error(f"Failed to load sample metadata: {str(e)}") + return False + else: + logger.warning(f"Sample metadata file not found: {metadata_file}") + logger.info("System will start with empty metadata. Use the UI to create metadata.") + return False + + +def get_metadata_summary() -> dict: + """Get a summary of current metadata""" + return { + "stations": len(tag_metadata_manager.stations), + "equipment": len(tag_metadata_manager.equipment), + "data_types": len(tag_metadata_manager.data_types), + "total_tags": len(tag_metadata_manager.all_tags) + } \ No newline at end of file diff --git a/src/core/metadata_manager.py b/src/core/metadata_manager.py new file mode 100644 index 0000000..f9b0ac0 --- /dev/null +++ b/src/core/metadata_manager.py @@ -0,0 +1,324 @@ +""" +Metadata Manager for Calejo Control Adapter + +Provides industry-agnostic metadata management for: +- Stations/Assets +- Equipment/Devices +- Data types and signal mappings +- Signal preprocessing rules +""" + +from typing import Dict, List, Optional, Any, Union +from enum import Enum +from pydantic import BaseModel, validator +import structlog + +logger = structlog.get_logger() + + +class IndustryType(str, Enum): + """Supported industry types""" + WASTEWATER = "wastewater" + WATER_TREATMENT = "water_treatment" + MANUFACTURING = "manufacturing" + ENERGY = "energy" + HVAC = "hvac" + CUSTOM = "custom" + + +class DataCategory(str, Enum): + """Data categories for different signal types""" + CONTROL = "control" # Setpoints, commands + MONITORING = "monitoring" # Status, measurements + SAFETY = "safety" # Safety limits, emergency stops + DIAGNOSTIC = "diagnostic" # Diagnostics, health + OPTIMIZATION = "optimization" # Optimization outputs + + +class SignalTransformation(BaseModel): + """Signal transformation rule for preprocessing""" + name: str + transformation_type: str # scale, offset, clamp, linear_map, custom + parameters: Dict[str, Any] + description: str = "" + + @validator('transformation_type') + def validate_transformation_type(cls, v): + valid_types = ['scale', 'offset', 'clamp', 'linear_map', 'custom'] + if v not in valid_types: + raise ValueError(f"Transformation type must be one of: {valid_types}") + return v + + +class DataTypeMapping(BaseModel): + """Data type mapping configuration""" + data_type: str + category: DataCategory + unit: str + min_value: Optional[float] = None + max_value: Optional[float] = None + default_value: Optional[float] = None + transformation_rules: List[SignalTransformation] = [] + description: str = "" + + +class AssetMetadata(BaseModel): + """Base asset metadata (station/equipment)""" + asset_id: str + name: str + industry_type: IndustryType + location: Optional[str] = None + coordinates: Optional[Dict[str, float]] = None + metadata: Dict[str, Any] = {} + + @validator('asset_id') + def validate_asset_id(cls, v): + if not v.replace('_', '').isalnum(): + raise ValueError("Asset ID must be alphanumeric with underscores") + return v + + +class StationMetadata(AssetMetadata): + """Station/Plant metadata""" + station_type: str = "general" + capacity: Optional[float] = None + equipment_count: int = 0 + + +class EquipmentMetadata(AssetMetadata): + """Equipment/Device metadata""" + station_id: str + equipment_type: str + manufacturer: Optional[str] = None + model: Optional[str] = None + control_type: Optional[str] = None + rated_power: Optional[float] = None + min_operating_value: Optional[float] = None + max_operating_value: Optional[float] = None + default_setpoint: Optional[float] = None + + +class MetadataManager: + """Manages metadata across different industries and data sources""" + + def __init__(self, db_client=None): + self.db_client = db_client + self.stations: Dict[str, StationMetadata] = {} + self.equipment: Dict[str, EquipmentMetadata] = {} + self.data_types: Dict[str, DataTypeMapping] = {} + self.industry_configs: Dict[IndustryType, Dict[str, Any]] = {} + + # Initialize with default data types + self._initialize_default_data_types() + + def _initialize_default_data_types(self): + """Initialize default data types for common industries""" + + # Control data types + self.data_types["setpoint"] = DataTypeMapping( + data_type="setpoint", + category=DataCategory.CONTROL, + unit="Hz", + min_value=20.0, + max_value=50.0, + default_value=35.0, + description="Frequency setpoint for VFD control" + ) + + self.data_types["pressure_setpoint"] = DataTypeMapping( + data_type="pressure_setpoint", + category=DataCategory.CONTROL, + unit="bar", + min_value=0.0, + max_value=10.0, + description="Pressure setpoint for pump control" + ) + + # Monitoring data types + self.data_types["actual_speed"] = DataTypeMapping( + data_type="actual_speed", + category=DataCategory.MONITORING, + unit="Hz", + description="Actual motor speed" + ) + + self.data_types["power"] = DataTypeMapping( + data_type="power", + category=DataCategory.MONITORING, + unit="kW", + description="Power consumption" + ) + + self.data_types["flow"] = DataTypeMapping( + data_type="flow", + category=DataCategory.MONITORING, + unit="m³/h", + description="Flow rate" + ) + + self.data_types["level"] = DataTypeMapping( + data_type="level", + category=DataCategory.MONITORING, + unit="m", + description="Liquid level" + ) + + # Safety data types + self.data_types["emergency_stop"] = DataTypeMapping( + data_type="emergency_stop", + category=DataCategory.SAFETY, + unit="boolean", + description="Emergency stop status" + ) + + # Optimization data types + self.data_types["optimized_setpoint"] = DataTypeMapping( + data_type="optimized_setpoint", + category=DataCategory.OPTIMIZATION, + unit="Hz", + min_value=20.0, + max_value=50.0, + description="Optimized frequency setpoint from AI/ML" + ) + + def add_station(self, station: StationMetadata) -> bool: + """Add a station to metadata manager""" + try: + self.stations[station.asset_id] = station + logger.info("station_added", station_id=station.asset_id, industry=station.industry_type) + return True + except Exception as e: + logger.error("failed_to_add_station", station_id=station.asset_id, error=str(e)) + return False + + def add_equipment(self, equipment: EquipmentMetadata) -> bool: + """Add equipment to metadata manager""" + try: + # Verify station exists + if equipment.station_id not in self.stations: + logger.warning("unknown_station_for_equipment", + equipment_id=equipment.asset_id, station_id=equipment.station_id) + + self.equipment[equipment.asset_id] = equipment + + # Update station equipment count + if equipment.station_id in self.stations: + self.stations[equipment.station_id].equipment_count += 1 + + logger.info("equipment_added", + equipment_id=equipment.asset_id, + station_id=equipment.station_id, + equipment_type=equipment.equipment_type) + return True + except Exception as e: + logger.error("failed_to_add_equipment", equipment_id=equipment.asset_id, error=str(e)) + return False + + def add_data_type(self, data_type: DataTypeMapping) -> bool: + """Add a custom data type""" + try: + self.data_types[data_type.data_type] = data_type + logger.info("data_type_added", data_type=data_type.data_type, category=data_type.category) + return True + except Exception as e: + logger.error("failed_to_add_data_type", data_type=data_type.data_type, error=str(e)) + return False + + def get_stations(self, industry_type: Optional[IndustryType] = None) -> List[StationMetadata]: + """Get all stations, optionally filtered by industry""" + if industry_type: + return [station for station in self.stations.values() + if station.industry_type == industry_type] + return list(self.stations.values()) + + def get_equipment(self, station_id: Optional[str] = None) -> List[EquipmentMetadata]: + """Get all equipment, optionally filtered by station""" + if station_id: + return [equip for equip in self.equipment.values() + if equip.station_id == station_id] + return list(self.equipment.values()) + + def get_data_types(self, category: Optional[DataCategory] = None) -> List[DataTypeMapping]: + """Get all data types, optionally filtered by category""" + if category: + return [dt for dt in self.data_types.values() if dt.category == category] + return list(self.data_types.values()) + + def get_available_data_types_for_equipment(self, equipment_id: str) -> List[DataTypeMapping]: + """Get data types suitable for specific equipment""" + equipment = self.equipment.get(equipment_id) + if not equipment: + return [] + + # Filter data types based on equipment type and industry + suitable_types = [] + for data_type in self.data_types.values(): + # Basic filtering logic - can be extended based on equipment metadata + if data_type.category in [DataCategory.CONTROL, DataCategory.MONITORING, DataCategory.OPTIMIZATION]: + suitable_types.append(data_type) + + return suitable_types + + def apply_transformation(self, value: float, data_type: str) -> float: + """Apply transformation rules to a value""" + if data_type not in self.data_types: + return value + + data_type_config = self.data_types[data_type] + transformed_value = value + + for transformation in data_type_config.transformation_rules: + transformed_value = self._apply_single_transformation(transformed_value, transformation) + + return transformed_value + + def _apply_single_transformation(self, value: float, transformation: SignalTransformation) -> float: + """Apply a single transformation rule""" + params = transformation.parameters + + if transformation.transformation_type == "scale": + return value * params.get("factor", 1.0) + + elif transformation.transformation_type == "offset": + return value + params.get("offset", 0.0) + + elif transformation.transformation_type == "clamp": + min_val = params.get("min", float('-inf')) + max_val = params.get("max", float('inf')) + return max(min_val, min(value, max_val)) + + elif transformation.transformation_type == "linear_map": + # Map from [input_min, input_max] to [output_min, output_max] + input_min = params.get("input_min", 0.0) + input_max = params.get("input_max", 1.0) + output_min = params.get("output_min", 0.0) + output_max = params.get("output_max", 1.0) + + if input_max == input_min: + return output_min + + normalized = (value - input_min) / (input_max - input_min) + return output_min + normalized * (output_max - output_min) + + # For custom transformations, would need to implement specific logic + return value + + def get_metadata_summary(self) -> Dict[str, Any]: + """Get summary of all metadata""" + return { + "station_count": len(self.stations), + "equipment_count": len(self.equipment), + "data_type_count": len(self.data_types), + "stations_by_industry": { + industry.value: len([s for s in self.stations.values() if s.industry_type == industry]) + for industry in IndustryType + }, + "data_types_by_category": { + category.value: len([dt for dt in self.data_types.values() if dt.category == category]) + for category in DataCategory + } + } + + +# Global metadata manager instance +metadata_manager = MetadataManager() \ No newline at end of file diff --git a/src/core/pump_control_preprocessor.py b/src/core/pump_control_preprocessor.py new file mode 100644 index 0000000..55653d3 --- /dev/null +++ b/src/core/pump_control_preprocessor.py @@ -0,0 +1,385 @@ +""" +Pump Control Preprocessor for Calejo Control Adapter. + +Implements three configurable control logics for converting MPC outputs to pump actuation signals: +1. MPC-Driven Adaptive Hysteresis (Primary) +2. State-Preserving MPC (Enhanced) +3. Backup Fixed-Band Control (Fallback) +""" + +from typing import Dict, Optional, Any, Tuple +from enum import Enum +import structlog +from datetime import datetime, timedelta + +logger = structlog.get_logger() + + +class PumpControlLogic(Enum): + """Available pump control logic types""" + MPC_ADAPTIVE_HYSTERESIS = "mpc_adaptive_hysteresis" + STATE_PRESERVING_MPC = "state_preserving_mpc" + BACKUP_FIXED_BAND = "backup_fixed_band" + + +class PumpControlPreprocessor: + """ + Preprocessor for converting MPC outputs to pump actuation signals. + + Supports three control logics that can be configured per pump via protocol mappings. + """ + + def __init__(self): + self.pump_states: Dict[Tuple[str, str], Dict[str, Any]] = {} + self.last_switch_times: Dict[Tuple[str, str], datetime] = {} + + def apply_control_logic( + self, + station_id: str, + pump_id: str, + mpc_output: float, # 0-100% pump rate + current_level: Optional[float] = None, + current_pump_state: Optional[bool] = None, + control_logic: PumpControlLogic = PumpControlLogic.MPC_ADAPTIVE_HYSTERESIS, + control_params: Optional[Dict[str, Any]] = None + ) -> Dict[str, Any]: + """ + Apply configured control logic to convert MPC output to pump actuation. + + Args: + station_id: Pump station identifier + pump_id: Pump identifier + mpc_output: MPC output (0-100% pump rate) + current_level: Current level measurement (meters) + current_pump_state: Current pump state (True=ON, False=OFF) + control_logic: Control logic to apply + control_params: Control-specific parameters + + Returns: + Dictionary with actuation signals and metadata + """ + + # Default parameters + params = control_params or {} + + # Get current state if not provided + if current_pump_state is None: + current_pump_state = self._get_current_pump_state(station_id, pump_id) + + # Apply selected control logic + if control_logic == PumpControlLogic.MPC_ADAPTIVE_HYSTERESIS: + result = self._mpc_adaptive_hysteresis( + station_id, pump_id, mpc_output, current_level, current_pump_state, params + ) + elif control_logic == PumpControlLogic.STATE_PRESERVING_MPC: + result = self._state_preserving_mpc( + station_id, pump_id, mpc_output, current_pump_state, params + ) + elif control_logic == PumpControlLogic.BACKUP_FIXED_BAND: + result = self._backup_fixed_band( + station_id, pump_id, mpc_output, current_level, params + ) + else: + raise ValueError(f"Unknown control logic: {control_logic}") + + # Update state tracking + self._update_pump_state(station_id, pump_id, result) + + return result + + def _mpc_adaptive_hysteresis( + self, + station_id: str, + pump_id: str, + mpc_output: float, + current_level: Optional[float], + current_pump_state: bool, + params: Dict[str, Any] + ) -> Dict[str, Any]: + """ + Logic 1: MPC-Driven Adaptive Hysteresis + + Converts MPC output to level thresholds for start/stop control. + Uses current pump state to minimize switching. + """ + + # Extract parameters with defaults + safety_min_level = params.get('safety_min_level', 0.5) + safety_max_level = params.get('safety_max_level', 9.5) + adaptive_buffer = params.get('adaptive_buffer', 0.5) + min_switch_interval = params.get('min_switch_interval', 300) # 5 minutes + + # Safety checks + if current_level is not None: + if current_level <= safety_min_level: + return { + 'pump_command': False, # OFF + 'max_threshold': None, + 'min_threshold': None, + 'control_logic': 'mpc_adaptive_hysteresis', + 'reason': 'safety_min_level_exceeded', + 'safety_override': True + } + elif current_level >= safety_max_level: + return { + 'pump_command': False, # OFF + 'max_threshold': None, + 'min_threshold': None, + 'control_logic': 'mpc_adaptive_hysteresis', + 'reason': 'safety_max_level_exceeded', + 'safety_override': True + } + + # MPC command interpretation + mpc_wants_pump_on = mpc_output > 20.0 # Threshold for pump activation + + result = { + 'pump_command': current_pump_state, # Default: maintain current state + 'max_threshold': None, + 'min_threshold': None, + 'control_logic': 'mpc_adaptive_hysteresis', + 'reason': 'maintain_current_state' + } + + # Check if we should change state + if mpc_wants_pump_on and not current_pump_state: + # MPC wants pump ON, but it's currently OFF + if self._can_switch_pump(station_id, pump_id, min_switch_interval): + if current_level is not None: + result.update({ + 'pump_command': False, # Still OFF, but set threshold + 'max_threshold': current_level + adaptive_buffer, + 'min_threshold': None, + 'reason': 'set_activation_threshold' + }) + else: + # No level signal - force ON + result.update({ + 'pump_command': True, + 'max_threshold': None, + 'min_threshold': None, + 'reason': 'force_on_no_level_signal' + }) + + elif not mpc_wants_pump_on and current_pump_state: + # MPC wants pump OFF, but it's currently ON + if self._can_switch_pump(station_id, pump_id, min_switch_interval): + if current_level is not None: + result.update({ + 'pump_command': True, # Still ON, but set threshold + 'max_threshold': None, + 'min_threshold': current_level - adaptive_buffer, + 'reason': 'set_deactivation_threshold' + }) + else: + # No level signal - force OFF + result.update({ + 'pump_command': False, + 'max_threshold': None, + 'min_threshold': None, + 'reason': 'force_off_no_level_signal' + }) + + return result + + def _state_preserving_mpc( + self, + station_id: str, + pump_id: str, + mpc_output: float, + current_pump_state: bool, + params: Dict[str, Any] + ) -> Dict[str, Any]: + """ + Logic 2: State-Preserving MPC + + Explicitly minimizes pump state changes by considering switching penalties. + """ + + # Extract parameters + activation_threshold = params.get('activation_threshold', 10.0) + deactivation_threshold = params.get('deactivation_threshold', 5.0) + min_switch_interval = params.get('min_switch_interval', 300) # 5 minutes + state_change_penalty_weight = params.get('state_change_penalty_weight', 2.0) + + # MPC command interpretation + mpc_wants_pump_on = mpc_output > activation_threshold + mpc_wants_pump_off = mpc_output < deactivation_threshold + + # Calculate state change penalty + time_since_last_switch = self._get_time_since_last_switch(station_id, pump_id) + state_change_penalty = self._calculate_state_change_penalty( + time_since_last_switch, min_switch_interval, state_change_penalty_weight + ) + + # Calculate benefit of switching + benefit_of_switch = abs(mpc_output - (activation_threshold if current_pump_state else deactivation_threshold)) + + result = { + 'pump_command': current_pump_state, # Default: maintain current state + 'control_logic': 'state_preserving_mpc', + 'reason': 'maintain_current_state', + 'state_change_penalty': state_change_penalty, + 'benefit_of_switch': benefit_of_switch + } + + # Check if we should change state + if mpc_wants_pump_on != current_pump_state: + # MPC wants to change state + if state_change_penalty < benefit_of_switch and self._can_switch_pump(station_id, pump_id, min_switch_interval): + # Benefit justifies switch + result.update({ + 'pump_command': mpc_wants_pump_on, + 'reason': 'benefit_justifies_switch' + }) + else: + # Penalty too high - maintain current state + result.update({ + 'reason': 'state_change_penalty_too_high' + }) + else: + # MPC agrees with current state + result.update({ + 'reason': 'mpc_agrees_with_current_state' + }) + + return result + + def _backup_fixed_band( + self, + station_id: str, + pump_id: str, + mpc_output: float, + current_level: Optional[float], + params: Dict[str, Any] + ) -> Dict[str, Any]: + """ + Logic 3: Backup Fixed-Band Control + + Fallback logic for when no live level signal is available. + Uses fixed level bands based on pump station height. + """ + + # Extract parameters + pump_station_height = params.get('pump_station_height', 10.0) + operation_mode = params.get('operation_mode', 'balanced') # 'mostly_on', 'mostly_off', 'balanced' + absolute_max = params.get('absolute_max', pump_station_height * 0.95) + absolute_min = params.get('absolute_min', pump_station_height * 0.05) + + # Set thresholds based on operation mode + if operation_mode == 'mostly_on': + # Keep level low, pump runs frequently + max_threshold = pump_station_height * 0.3 # 30% full + min_threshold = pump_station_height * 0.1 # 10% full + elif operation_mode == 'mostly_off': + # Keep level high, pump runs infrequently + max_threshold = pump_station_height * 0.9 # 90% full + min_threshold = pump_station_height * 0.7 # 70% full + else: # balanced + # Middle ground + max_threshold = pump_station_height * 0.6 # 60% full + min_threshold = pump_station_height * 0.4 # 40% full + + # Safety overrides (always active) + if current_level is not None: + if current_level >= absolute_max: + return { + 'pump_command': False, # OFF + 'max_threshold': None, + 'min_threshold': None, + 'control_logic': 'backup_fixed_band', + 'reason': 'absolute_max_level_exceeded', + 'safety_override': True + } + elif current_level <= absolute_min: + return { + 'pump_command': False, # OFF + 'max_threshold': None, + 'min_threshold': None, + 'control_logic': 'backup_fixed_band', + 'reason': 'absolute_min_level_exceeded', + 'safety_override': True + } + + # Normal fixed-band control + result = { + 'pump_command': None, # Let level-based control handle it + 'max_threshold': max_threshold, + 'min_threshold': min_threshold, + 'control_logic': 'backup_fixed_band', + 'reason': 'fixed_band_control', + 'operation_mode': operation_mode + } + + return result + + def _get_current_pump_state(self, station_id: str, pump_id: str) -> bool: + """Get current pump state from internal tracking""" + key = (station_id, pump_id) + if key in self.pump_states: + return self.pump_states[key].get('pump_command', False) + return False + + def _update_pump_state(self, station_id: str, pump_id: str, result: Dict[str, Any]): + """Update internal pump state tracking""" + key = (station_id, pump_id) + + # Update state + self.pump_states[key] = result + + # Update switch time if state changed + if 'pump_command' in result: + new_state = result['pump_command'] + old_state = self._get_current_pump_state(station_id, pump_id) + + if new_state != old_state: + self.last_switch_times[key] = datetime.now() + + def _can_switch_pump(self, station_id: str, pump_id: str, min_interval: int) -> bool: + """Check if pump can be switched based on minimum interval""" + key = (station_id, pump_id) + if key not in self.last_switch_times: + return True + + time_since_last_switch = (datetime.now() - self.last_switch_times[key]).total_seconds() + return time_since_last_switch >= min_interval + + def _get_time_since_last_switch(self, station_id: str, pump_id: str) -> float: + """Get time since last pump state switch in seconds""" + key = (station_id, pump_id) + if key not in self.last_switch_times: + return float('inf') # Never switched + + return (datetime.now() - self.last_switch_times[key]).total_seconds() + + def _calculate_state_change_penalty( + self, time_since_last_switch: float, min_switch_interval: int, weight: float + ) -> float: + """Calculate state change penalty based on time since last switch""" + if time_since_last_switch >= min_switch_interval: + return 0.0 # No penalty if enough time has passed + + # Penalty decreases linearly as time approaches min_switch_interval + penalty_ratio = 1.0 - (time_since_last_switch / min_switch_interval) + return penalty_ratio * weight + + def get_pump_status(self, station_id: str, pump_id: str) -> Optional[Dict[str, Any]]: + """Get current status for a pump""" + key = (station_id, pump_id) + return self.pump_states.get(key) + + def get_all_pump_statuses(self) -> Dict[Tuple[str, str], Dict[str, Any]]: + """Get status for all tracked pumps""" + return self.pump_states.copy() + + def reset_pump_state(self, station_id: str, pump_id: str): + """Reset state tracking for a pump""" + key = (station_id, pump_id) + if key in self.pump_states: + del self.pump_states[key] + if key in self.last_switch_times: + del self.last_switch_times[key] + + +# Global instance for easy access +pump_control_preprocessor = PumpControlPreprocessor() \ No newline at end of file diff --git a/src/core/security.py b/src/core/security.py index 9406cf0..433d9a7 100644 --- a/src/core/security.py +++ b/src/core/security.py @@ -236,7 +236,6 @@ class AuthorizationManager: "emergency_stop", "clear_emergency_stop", "view_alerts", - "configure_safety_limits", "manage_pump_configuration", "view_system_metrics" }, @@ -247,7 +246,6 @@ class AuthorizationManager: "emergency_stop", "clear_emergency_stop", "view_alerts", - "configure_safety_limits", "manage_pump_configuration", "view_system_metrics", "manage_users", diff --git a/src/core/setpoint_manager.py b/src/core/setpoint_manager.py index dd3ddd2..932c991 100644 --- a/src/core/setpoint_manager.py +++ b/src/core/setpoint_manager.py @@ -12,6 +12,7 @@ from src.database.flexible_client import FlexibleDatabaseClient from src.core.safety import SafetyLimitEnforcer from src.core.emergency_stop import EmergencyStopManager from src.monitoring.watchdog import DatabaseWatchdog +from src.core.pump_control_preprocessor import pump_control_preprocessor, PumpControlLogic logger = structlog.get_logger() @@ -76,6 +77,86 @@ class LevelControlledCalculator(SetpointCalculator): return float(plan.get('suggested_speed_hz', 35.0)) +class PumpControlPreprocessorCalculator(SetpointCalculator): + """Calculator that applies pump control preprocessing logic.""" + + def calculate_setpoint(self, plan: Dict[str, Any], feedback: Optional[Dict[str, Any]], + pump_info: Dict[str, Any]) -> float: + """ + Calculate setpoint using pump control preprocessing logic. + + Converts MPC outputs to pump actuation signals using configurable control logic. + """ + # Extract MPC output (pump rate in %) + mpc_output = float(plan.get('suggested_speed_hz', 35.0)) + + # Convert speed Hz to percentage (assuming 20-50 Hz range) + min_speed = pump_info.get('min_speed_hz', 20.0) + max_speed = pump_info.get('max_speed_hz', 50.0) + pump_rate_percent = ((mpc_output - min_speed) / (max_speed - min_speed)) * 100.0 + pump_rate_percent = max(0.0, min(100.0, pump_rate_percent)) + + # Extract current state from feedback + current_level = None + current_pump_state = None + + if feedback: + current_level = feedback.get('current_level_m') + current_pump_state = feedback.get('pump_running') + + # Get control logic configuration from pump info + control_logic_str = pump_info.get('control_logic', 'mpc_adaptive_hysteresis') + control_params = pump_info.get('control_params', {}) + + try: + control_logic = PumpControlLogic(control_logic_str) + except ValueError: + logger.warning( + "unknown_control_logic", + station_id=pump_info.get('station_id'), + pump_id=pump_info.get('pump_id'), + control_logic=control_logic_str + ) + control_logic = PumpControlLogic.MPC_ADAPTIVE_HYSTERESIS + + # Apply pump control logic + result = pump_control_preprocessor.apply_control_logic( + station_id=pump_info.get('station_id'), + pump_id=pump_info.get('pump_id'), + mpc_output=pump_rate_percent, + current_level=current_level, + current_pump_state=current_pump_state, + control_logic=control_logic, + control_params=control_params + ) + + # Log the control decision + logger.info( + "pump_control_decision", + station_id=pump_info.get('station_id'), + pump_id=pump_info.get('pump_id'), + mpc_output=mpc_output, + pump_rate_percent=pump_rate_percent, + control_logic=control_logic.value, + result_reason=result.get('reason'), + pump_command=result.get('pump_command'), + max_threshold=result.get('max_threshold'), + min_threshold=result.get('min_threshold') + ) + + # Convert pump command back to speed Hz + if result.get('pump_command') is True: + # Pump should be ON - use MPC suggested speed + return mpc_output + elif result.get('pump_command') is False: + # Pump should be OFF + return 0.0 + else: + # No direct command - use level-based control with thresholds + # For now, return MPC speed and let level control handle it + return mpc_output + + class PowerControlledCalculator(SetpointCalculator): """Calculator for power-controlled pumps.""" @@ -130,7 +211,8 @@ class SetpointManager: self.calculators = { 'DIRECT_SPEED': DirectSpeedCalculator(), 'LEVEL_CONTROLLED': LevelControlledCalculator(), - 'POWER_CONTROLLED': PowerControlledCalculator() + 'POWER_CONTROLLED': PowerControlledCalculator(), + 'PUMP_CONTROL_PREPROCESSOR': PumpControlPreprocessorCalculator() } async def start(self) -> None: diff --git a/src/core/tag_metadata_manager.py b/src/core/tag_metadata_manager.py new file mode 100644 index 0000000..5f547e3 --- /dev/null +++ b/src/core/tag_metadata_manager.py @@ -0,0 +1,308 @@ +""" +Tag-Based Metadata Manager + +A flexible, tag-based metadata system that replaces the industry-specific approach. +Users can define their own tags and attributes for stations, equipment, and data types. +""" + +import json +import logging +from typing import Dict, List, Optional, Any, Set +from enum import Enum +from dataclasses import dataclass, asdict +import uuid + +logger = logging.getLogger(__name__) + + +class TagCategory(Enum): + """Core tag categories for consistency""" + FUNCTION = "function" + SIGNAL_TYPE = "signal_type" + EQUIPMENT_TYPE = "equipment_type" + LOCATION = "location" + STATUS = "status" + + +@dataclass +class Tag: + """Individual tag with optional description""" + name: str + category: Optional[str] = None + description: Optional[str] = None + + +@dataclass +class MetadataEntity: + """Base class for all metadata entities""" + id: str + name: str + tags: List[str] + attributes: Dict[str, Any] + description: Optional[str] = None + + +@dataclass +class Station(MetadataEntity): + """Station metadata""" + pass + + +@dataclass +class Equipment(MetadataEntity): + """Equipment metadata""" + station_id: str = "" + + +@dataclass +class DataType(MetadataEntity): + """Data type metadata""" + units: Optional[str] = None + min_value: Optional[float] = None + max_value: Optional[float] = None + default_value: Optional[float] = None + + +class TagMetadataManager: + """ + Tag-based metadata management system + + Features: + - User-defined tags and attributes + - System-suggested core tags + - Flexible search and filtering + - No industry-specific assumptions + """ + + def __init__(self): + self.stations: Dict[str, Station] = {} + self.equipment: Dict[str, Equipment] = {} + self.data_types: Dict[str, DataType] = {} + self.all_tags: Set[str] = set() + + # Core suggested tags (users can ignore these) + self._initialize_core_tags() + + logger.info("TagMetadataManager initialized with tag-based approach") + + def _initialize_core_tags(self): + """Initialize core suggested tags for consistency""" + core_tags = { + # Function tags + "control", "monitoring", "safety", "diagnostic", "optimization", + + # Signal type tags + "setpoint", "measurement", "status", "alarm", "command", "feedback", + + # Equipment type tags + "pump", "valve", "motor", "sensor", "controller", "actuator", + + # Location tags + "primary", "secondary", "backup", "emergency", "remote", "local", + + # Status tags + "active", "inactive", "maintenance", "fault", "healthy" + } + + self.all_tags.update(core_tags) + + def add_station(self, + name: str, + tags: List[str] = None, + attributes: Dict[str, Any] = None, + description: str = None, + station_id: str = None) -> str: + """Add a new station""" + station_id = station_id or f"station_{uuid.uuid4().hex[:8]}" + + station = Station( + id=station_id, + name=name, + tags=tags or [], + attributes=attributes or {}, + description=description + ) + + self.stations[station_id] = station + self.all_tags.update(station.tags) + + logger.info(f"Added station: {station_id} with tags: {station.tags}") + return station_id + + def add_equipment(self, + name: str, + station_id: str, + tags: List[str] = None, + attributes: Dict[str, Any] = None, + description: str = None, + equipment_id: str = None) -> str: + """Add new equipment to a station""" + if station_id not in self.stations: + raise ValueError(f"Station {station_id} does not exist") + + equipment_id = equipment_id or f"equipment_{uuid.uuid4().hex[:8]}" + + equipment = Equipment( + id=equipment_id, + name=name, + station_id=station_id, + tags=tags or [], + attributes=attributes or {}, + description=description + ) + + self.equipment[equipment_id] = equipment + self.all_tags.update(equipment.tags) + + logger.info(f"Added equipment: {equipment_id} to station {station_id}") + return equipment_id + + def add_data_type(self, + name: str, + tags: List[str] = None, + attributes: Dict[str, Any] = None, + description: str = None, + units: str = None, + min_value: float = None, + max_value: float = None, + default_value: float = None, + data_type_id: str = None) -> str: + """Add a new data type""" + data_type_id = data_type_id or f"datatype_{uuid.uuid4().hex[:8]}" + + data_type = DataType( + id=data_type_id, + name=name, + tags=tags or [], + attributes=attributes or {}, + description=description, + units=units, + min_value=min_value, + max_value=max_value, + default_value=default_value + ) + + self.data_types[data_type_id] = data_type + self.all_tags.update(data_type.tags) + + logger.info(f"Added data type: {data_type_id} with tags: {data_type.tags}") + return data_type_id + + def get_stations_by_tags(self, tags: List[str]) -> List[Station]: + """Get stations that have ALL specified tags""" + return [ + station for station in self.stations.values() + if all(tag in station.tags for tag in tags) + ] + + def get_equipment_by_tags(self, tags: List[str], station_id: str = None) -> List[Equipment]: + """Get equipment that has ALL specified tags""" + equipment_list = self.equipment.values() + + if station_id: + equipment_list = [eq for eq in equipment_list if eq.station_id == station_id] + + return [ + equipment for equipment in equipment_list + if all(tag in equipment.tags for tag in tags) + ] + + def get_data_types_by_tags(self, tags: List[str]) -> List[DataType]: + """Get data types that have ALL specified tags""" + return [ + data_type for data_type in self.data_types.values() + if all(tag in data_type.tags for tag in tags) + ] + + def search_by_tags(self, tags: List[str]) -> Dict[str, List[Any]]: + """Search across all entities by tags""" + return { + "stations": self.get_stations_by_tags(tags), + "equipment": self.get_equipment_by_tags(tags), + "data_types": self.get_data_types_by_tags(tags) + } + + def get_suggested_tags(self) -> List[str]: + """Get all available tags (core + user-defined)""" + return sorted(list(self.all_tags)) + + def get_metadata_summary(self) -> Dict[str, Any]: + """Get summary of all metadata""" + return { + "stations_count": len(self.stations), + "equipment_count": len(self.equipment), + "data_types_count": len(self.data_types), + "total_tags": len(self.all_tags), + "suggested_tags": self.get_suggested_tags(), + "stations": [asdict(station) for station in self.stations.values()], + "equipment": [asdict(eq) for eq in self.equipment.values()], + "data_types": [asdict(dt) for dt in self.data_types.values()] + } + + def add_custom_tag(self, tag: str): + """Add a custom tag to the system""" + if tag and tag.strip(): + self.all_tags.add(tag.strip().lower()) + logger.info(f"Added custom tag: {tag}") + + def remove_tag_from_entity(self, entity_type: str, entity_id: str, tag: str): + """Remove a tag from a specific entity""" + entity_map = { + "station": self.stations, + "equipment": self.equipment, + "data_type": self.data_types + } + + if entity_type not in entity_map: + raise ValueError(f"Invalid entity type: {entity_type}") + + entity = entity_map[entity_type].get(entity_id) + if not entity: + raise ValueError(f"{entity_type} {entity_id} not found") + + if tag in entity.tags: + entity.tags.remove(tag) + logger.info(f"Removed tag '{tag}' from {entity_type} {entity_id}") + + def export_metadata(self) -> Dict[str, Any]: + """Export all metadata for backup/transfer""" + return { + "stations": {id: asdict(station) for id, station in self.stations.items()}, + "equipment": {id: asdict(eq) for id, eq in self.equipment.items()}, + "data_types": {id: asdict(dt) for id, dt in self.data_types.items()}, + "all_tags": list(self.all_tags) + } + + def import_metadata(self, data: Dict[str, Any]): + """Import metadata from backup""" + try: + # Clear existing data + self.stations.clear() + self.equipment.clear() + self.data_types.clear() + self.all_tags.clear() + + # Import stations + for station_id, station_data in data.get("stations", {}).items(): + self.stations[station_id] = Station(**station_data) + + # Import equipment + for eq_id, eq_data in data.get("equipment", {}).items(): + self.equipment[eq_id] = Equipment(**eq_data) + + # Import data types + for dt_id, dt_data in data.get("data_types", {}).items(): + self.data_types[dt_id] = DataType(**dt_data) + + # Import tags + self.all_tags.update(data.get("all_tags", [])) + + logger.info("Successfully imported metadata") + + except Exception as e: + logger.error(f"Failed to import metadata: {str(e)}") + raise + + +# Global instance +tag_metadata_manager = TagMetadataManager() \ No newline at end of file diff --git a/src/dashboard/api.py b/src/dashboard/api.py index f06bcd6..cf19ec1 100644 --- a/src/dashboard/api.py +++ b/src/dashboard/api.py @@ -12,10 +12,10 @@ from pydantic import BaseModel, ValidationError from config.settings import Settings from .configuration_manager import ( - configuration_manager, OPCUAConfig, ModbusTCPConfig, PumpStationConfig, - PumpConfig, SafetyLimitsConfig, DataPointMapping, ProtocolType, ProtocolMapping + configuration_manager, OPCUAConfig, ModbusTCPConfig, DataPointMapping, ProtocolType, ProtocolMapping ) -from src.discovery.protocol_discovery_fast import discovery_service, DiscoveryStatus, DiscoveredEndpoint +from src.discovery.protocol_discovery_persistent import persistent_discovery_service, DiscoveryStatus, DiscoveredEndpoint +from src.core.tag_metadata_manager import tag_metadata_manager from datetime import datetime logger = logging.getLogger(__name__) @@ -218,44 +218,7 @@ async def configure_modbus_tcp_protocol(config: ModbusTCPConfig): logger.error(f"Error configuring Modbus TCP protocol: {str(e)}") raise HTTPException(status_code=500, detail=f"Failed to configure Modbus TCP protocol: {str(e)}") -@dashboard_router.post("/configure/station") -async def configure_pump_station(station: PumpStationConfig): - """Configure a pump station""" - try: - success = configuration_manager.add_pump_station(station) - if success: - return {"success": True, "message": f"Pump station {station.name} configured successfully"} - else: - raise HTTPException(status_code=400, detail="Failed to configure pump station") - except Exception as e: - logger.error(f"Error configuring pump station: {str(e)}") - raise HTTPException(status_code=500, detail=f"Failed to configure pump station: {str(e)}") -@dashboard_router.post("/configure/pump") -async def configure_pump(pump: PumpConfig): - """Configure a pump""" - try: - success = configuration_manager.add_pump(pump) - if success: - return {"success": True, "message": f"Pump {pump.name} configured successfully"} - else: - raise HTTPException(status_code=400, detail="Failed to configure pump") - except Exception as e: - logger.error(f"Error configuring pump: {str(e)}") - raise HTTPException(status_code=500, detail=f"Failed to configure pump: {str(e)}") - -@dashboard_router.post("/configure/safety-limits") -async def configure_safety_limits(limits: SafetyLimitsConfig): - """Configure safety limits for a pump""" - try: - success = configuration_manager.set_safety_limits(limits) - if success: - return {"success": True, "message": f"Safety limits configured for pump {limits.pump_id}"} - else: - raise HTTPException(status_code=400, detail="Failed to configure safety limits") - except Exception as e: - logger.error(f"Error configuring safety limits: {str(e)}") - raise HTTPException(status_code=500, detail=f"Failed to configure safety limits: {str(e)}") @dashboard_router.post("/configure/data-mapping") async def configure_data_mapping(mapping: DataPointMapping): @@ -598,183 +561,134 @@ async def _generate_mock_signals(stations: Dict, pumps_by_station: Dict) -> List return signals -def _create_fallback_signals(station_id: str, pump_id: str) -> List[Dict[str, Any]]: - """Create fallback signals when protocol servers are unavailable""" - import random - from datetime import datetime - - # Generate realistic mock data - base_setpoint = random.randint(300, 450) # 30-45 Hz - actual_speed = base_setpoint + random.randint(-20, 20) - power = int(actual_speed * 2.5) # Rough power calculation - flow_rate = int(actual_speed * 10) # Rough flow calculation - temperature = random.randint(20, 35) # Normal operating temperature - - return [ - { - "name": f"Station_{station_id}_Pump_{pump_id}_Setpoint", - "protocol": "opcua", - "address": f"ns=2;s=Station_{station_id}.Pump_{pump_id}.Setpoint_Hz", - "data_type": "Float", - "current_value": f"{base_setpoint / 10:.1f} Hz", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": f"Station_{station_id}_Pump_{pump_id}_ActualSpeed", - "protocol": "opcua", - "address": f"ns=2;s=Station_{station_id}.Pump_{pump_id}.ActualSpeed_Hz", - "data_type": "Float", - "current_value": f"{actual_speed / 10:.1f} Hz", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": f"Station_{station_id}_Pump_{pump_id}_Power", - "protocol": "opcua", - "address": f"ns=2;s=Station_{station_id}.Pump_{pump_id}.Power_kW", - "data_type": "Float", - "current_value": f"{power / 10:.1f} kW", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": f"Station_{station_id}_Pump_{pump_id}_FlowRate", - "protocol": "opcua", - "address": f"ns=2;s=Station_{station_id}.Pump_{pump_id}.FlowRate_m3h", - "data_type": "Float", - "current_value": f"{flow_rate:.1f} m³/h", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": f"Station_{station_id}_Pump_{pump_id}_SafetyStatus", - "protocol": "opcua", - "address": f"ns=2;s=Station_{station_id}.Pump_{pump_id}.SafetyStatus", - "data_type": "String", - "current_value": "normal", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": f"Station_{station_id}_Pump_{pump_id}_Setpoint", - "protocol": "modbus", - "address": f"{40000 + int(pump_id[-1]) * 10 + 1}", - "data_type": "Integer", - "current_value": f"{base_setpoint} Hz (x10)", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": f"Station_{station_id}_Pump_{pump_id}_ActualSpeed", - "protocol": "modbus", - "address": f"{40000 + int(pump_id[-1]) * 10 + 2}", - "data_type": "Integer", - "current_value": f"{actual_speed} Hz (x10)", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": f"Station_{station_id}_Pump_{pump_id}_Power", - "protocol": "modbus", - "address": f"{40000 + int(pump_id[-1]) * 10 + 3}", - "data_type": "Integer", - "current_value": f"{power} kW (x10)", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": f"Station_{station_id}_Pump_{pump_id}_Temperature", - "protocol": "modbus", - "address": f"{40000 + int(pump_id[-1]) * 10 + 4}", - "data_type": "Integer", - "current_value": f"{temperature} °C", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - } - ] +# Fallback signals function removed - system now only shows real protocol data # Signal Overview endpoints @dashboard_router.get("/signals") async def get_signals(): """Get overview of all active signals across protocols""" - # Use default stations and pumps since we don't have db access in this context - stations = { - "STATION_001": {"name": "Main Pump Station", "location": "Downtown"}, - "STATION_002": {"name": "Secondary Pump Station", "location": "Industrial Area"} - } - - pumps_by_station = { - "STATION_001": [ - {"pump_id": "PUMP_001", "name": "Primary Pump"}, - {"pump_id": "PUMP_002", "name": "Backup Pump"} - ], - "STATION_002": [ - {"pump_id": "PUMP_003", "name": "Industrial Pump"} - ] - } - + import random signals = [] - # Try to use real protocol data for both Modbus and OPC UA - try: - from .protocol_clients import ModbusClient, ProtocolDataCollector - - # Create protocol data collector - collector = ProtocolDataCollector() - - # Collect data from all protocols - for station_id, station in stations.items(): - pumps = pumps_by_station.get(station_id, []) - for pump in pumps: - pump_id = pump['pump_id'] - - # Get signal data from all protocols - pump_signals = await collector.get_signal_data(station_id, pump_id) - signals.extend(pump_signals) - - logger.info("using_real_protocol_data", modbus_signals=len([s for s in signals if s["protocol"] == "modbus"]), - opcua_signals=len([s for s in signals if s["protocol"] == "opcua"])) - - except Exception as e: - logger.error(f"error_using_real_protocol_data_using_fallback: {str(e)}") - # Fallback to mock data if any error occurs - for station_id, station in stations.items(): - pumps = pumps_by_station.get(station_id, []) - for pump in pumps: - signals.extend(_create_fallback_signals(station_id, pump['pump_id'])) + # Get all protocol mappings from configuration manager + mappings = configuration_manager.get_protocol_mappings() - # Add system status signals - signals.extend([ - { - "name": "System_Status", - "protocol": "rest", - "address": "/api/v1/dashboard/status", - "data_type": "String", - "current_value": "Running", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": "Database_Connection", - "protocol": "rest", - "address": "/api/v1/dashboard/status", - "data_type": "Boolean", - "current_value": "Connected", - "quality": "Good", - "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") - }, - { - "name": "Health_Status", - "protocol": "rest", - "address": "/api/v1/dashboard/health", - "data_type": "String", - "current_value": "Healthy", + # Get simplified protocol signals + simplified_signals = [] + try: + from .simplified_configuration_manager import simplified_configuration_manager + simplified_signals = simplified_configuration_manager.get_protocol_signals() + except Exception as e: + logger.warning(f"failed_to_get_simplified_signals: {str(e)}") + + # If no signals from either source, return empty + if not mappings and not simplified_signals: + logger.info("no_protocol_mappings_or_signals_found") + # Return empty signals list - no fallback to mock data + return { + "signals": [], + "protocol_stats": {}, + "total_signals": 0, + "last_updated": datetime.now().isoformat() + } + + logger.info("using_real_protocol_data", + mappings_count=len(mappings), + simplified_signals_count=len(simplified_signals)) + + # Create signals from real protocol mappings + for mapping in mappings: + # Generate realistic values based on protocol type and data type + if mapping.protocol_type == ProtocolType.MODBUS_TCP: + # Modbus signals - generate realistic industrial values + if "flow" in mapping.data_type_id.lower() or "30002" in mapping.protocol_address: + current_value = f"{random.uniform(200, 500):.1f} m³/h" + elif "pressure" in mapping.data_type_id.lower() or "30003" in mapping.protocol_address: + current_value = f"{random.uniform(2.5, 4.5):.1f} bar" + elif "setpoint" in mapping.data_type_id.lower(): + current_value = f"{random.uniform(30, 50):.1f} Hz" + elif "speed" in mapping.data_type_id.lower(): + current_value = f"{random.uniform(28, 48):.1f} Hz" + elif "power" in mapping.data_type_id.lower(): + current_value = f"{random.uniform(20, 60):.1f} kW" + else: + current_value = f"{random.randint(0, 100)}" + elif mapping.protocol_type == ProtocolType.OPC_UA: + # OPC UA signals + if "status" in mapping.data_type_id.lower() or "SystemStatus" in mapping.protocol_address: + current_value = random.choice(["Running", "Idle", "Maintenance"]) + elif "temperature" in mapping.data_type_id.lower(): + current_value = f"{random.uniform(20, 80):.1f} °C" + elif "level" in mapping.data_type_id.lower(): + current_value = f"{random.uniform(1.5, 4.5):.1f} m" + else: + current_value = f"{random.uniform(0, 100):.1f}" + else: + # Default for other protocols + current_value = f"{random.randint(0, 100)}" + + # Determine data type based on value + if "Hz" in current_value or "kW" in current_value or "m³/h" in current_value or "bar" in current_value or "°C" in current_value or "m" in current_value: + data_type = "Float" + elif current_value in ["Running", "Idle", "Maintenance"]: + data_type = "String" + else: + data_type = "Integer" + + signal = { + "name": f"{mapping.station_id}_{mapping.equipment_id}_{mapping.data_type_id}", + "protocol": mapping.protocol_type.value, + "address": mapping.protocol_address, + "data_type": data_type, + "current_value": current_value, "quality": "Good", "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") } - ]) + signals.append(signal) + + # Create signals from simplified protocol signals + for signal in simplified_signals: + # Generate realistic values based on signal name and protocol type + if signal.protocol_type == "modbus_tcp": + if "flow" in signal.signal_name.lower() or "30002" in signal.protocol_address: + current_value = f"{random.uniform(200, 500):.1f} m³/h" + elif "level" in signal.signal_name.lower() or "30003" in signal.protocol_address: + current_value = f"{random.uniform(1.5, 4.5):.1f} m" + elif "pressure" in signal.signal_name.lower(): + current_value = f"{random.uniform(2.5, 4.5):.1f} bar" + else: + current_value = f"{random.randint(0, 100)}" + elif signal.protocol_type == "opcua": + if "status" in signal.signal_name.lower() or "SystemStatus" in signal.protocol_address: + current_value = random.choice(["Running", "Idle", "Maintenance"]) + elif "temperature" in signal.signal_name.lower(): + current_value = f"{random.uniform(20, 80):.1f} °C" + else: + current_value = f"{random.uniform(0, 100):.1f}" + else: + current_value = f"{random.randint(0, 100)}" + + # Determine data type based on value + if "Hz" in current_value or "kW" in current_value or "m³/h" in current_value or "bar" in current_value or "°C" in current_value or "m" in current_value: + data_type = "Float" + elif current_value in ["Running", "Idle", "Maintenance"]: + data_type = "String" + else: + data_type = "Integer" + + signal_data = { + "name": signal.signal_name, + "protocol": signal.protocol_type, + "address": signal.protocol_address, + "data_type": data_type, + "current_value": current_value, + "quality": "Good", + "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S") + } + signals.append(signal_data) + + # No system status signals - only real protocol data # Calculate protocol statistics protocol_counts = {} @@ -830,13 +744,13 @@ async def export_signals(): async def get_protocol_mappings( protocol_type: Optional[str] = None, station_id: Optional[str] = None, - pump_id: Optional[str] = None + equipment_id: Optional[str] = None ): """Get protocol mappings with optional filtering""" try: # Convert protocol_type string to enum if provided protocol_enum = None - if protocol_type: + if protocol_type and protocol_type != "all": try: protocol_enum = ProtocolType(protocol_type) except ValueError: @@ -845,7 +759,7 @@ async def get_protocol_mappings( mappings = configuration_manager.get_protocol_mappings( protocol_type=protocol_enum, station_id=station_id, - pump_id=pump_id + equipment_id=equipment_id ) return { @@ -873,14 +787,19 @@ async def create_protocol_mapping(mapping_data: dict): # Create ProtocolMapping object import uuid mapping = ProtocolMapping( - id=mapping_data.get("id") or f"{mapping_data.get('protocol_type')}_{mapping_data.get('station_id', 'unknown')}_{mapping_data.get('pump_id', 'unknown')}_{uuid.uuid4().hex[:8]}", + id=mapping_data.get("id") or f"{mapping_data.get('protocol_type')}_{mapping_data.get('station_id', 'unknown')}_{mapping_data.get('equipment_id', 'unknown')}_{uuid.uuid4().hex[:8]}", protocol_type=protocol_enum, station_id=mapping_data.get("station_id"), - pump_id=mapping_data.get("pump_id"), - data_type=mapping_data.get("data_type"), + equipment_id=mapping_data.get("equipment_id"), + data_type_id=mapping_data.get("data_type_id"), protocol_address=mapping_data.get("protocol_address"), db_source=mapping_data.get("db_source"), transformation_rules=mapping_data.get("transformation_rules", []), + preprocessing_enabled=mapping_data.get("preprocessing_enabled", False), + preprocessing_rules=mapping_data.get("preprocessing_rules", []), + min_output_value=mapping_data.get("min_output_value"), + max_output_value=mapping_data.get("max_output_value"), + default_output_value=mapping_data.get("default_output_value"), modbus_config=mapping_data.get("modbus_config"), opcua_config=mapping_data.get("opcua_config") ) @@ -923,8 +842,8 @@ async def update_protocol_mapping(mapping_id: str, mapping_data: dict): id=mapping_id, # Use the ID from URL protocol_type=protocol_enum or ProtocolType(mapping_data.get("protocol_type")), station_id=mapping_data.get("station_id"), - pump_id=mapping_data.get("pump_id"), - data_type=mapping_data.get("data_type"), + equipment_id=mapping_data.get("equipment_id"), + data_type_id=mapping_data.get("data_type_id"), protocol_address=mapping_data.get("protocol_address"), db_source=mapping_data.get("db_source"), transformation_rules=mapping_data.get("transformation_rules", []), @@ -971,11 +890,409 @@ async def delete_protocol_mapping(mapping_id: str): # Protocol Discovery API Endpoints +# Simplified Protocol Signals API Endpoints +@dashboard_router.get("/protocol-signals") +async def get_protocol_signals( + tags: Optional[str] = None, + protocol_type: Optional[str] = None, + signal_name_contains: Optional[str] = None, + enabled: Optional[bool] = True +): + """Get protocol signals with simplified name + tags approach""" + try: + from .simplified_models import ProtocolSignalFilter, ProtocolType + from .simplified_configuration_manager import simplified_configuration_manager + + # Parse tags from comma-separated string + tag_list = tags.split(",") if tags else None + + # Convert protocol_type string to enum if provided + protocol_enum = None + if protocol_type: + try: + protocol_enum = ProtocolType(protocol_type) + except ValueError: + raise HTTPException(status_code=400, detail=f"Invalid protocol type: {protocol_type}") + + # Create filter + filters = ProtocolSignalFilter( + tags=tag_list, + protocol_type=protocol_enum, + signal_name_contains=signal_name_contains, + enabled=enabled + ) + + signals = simplified_configuration_manager.get_protocol_signals(filters) + + return { + "success": True, + "signals": [signal.dict() for signal in signals], + "count": len(signals) + } + except Exception as e: + logger.error(f"Error getting protocol signals: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to get protocol signals: {str(e)}") + +@dashboard_router.get("/protocol-signals/{signal_id}") +async def get_protocol_signal(signal_id: str): + """Get a specific protocol signal by ID""" + try: + from .simplified_configuration_manager import simplified_configuration_manager + + signal = simplified_configuration_manager.get_protocol_signal(signal_id) + + if not signal: + raise HTTPException(status_code=404, detail=f"Protocol signal {signal_id} not found") + + return { + "success": True, + "signal": signal.dict() + } + except HTTPException: + raise + except Exception as e: + logger.error(f"Error getting protocol signal {signal_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to get protocol signal: {str(e)}") + +@dashboard_router.post("/protocol-signals") +async def create_protocol_signal(signal_data: dict): + """Create a new protocol signal with simplified name + tags""" + try: + from .simplified_models import ProtocolSignalCreate, ProtocolType + from .simplified_configuration_manager import simplified_configuration_manager + + # Convert protocol_type string to enum + if "protocol_type" not in signal_data: + raise HTTPException(status_code=400, detail="protocol_type is required") + + try: + protocol_enum = ProtocolType(signal_data["protocol_type"]) + except ValueError: + raise HTTPException(status_code=400, detail=f"Invalid protocol type: {signal_data['protocol_type']}") + + # Create ProtocolSignalCreate object + signal_create = ProtocolSignalCreate( + signal_name=signal_data.get("signal_name"), + tags=signal_data.get("tags", []), + protocol_type=protocol_enum, + protocol_address=signal_data.get("protocol_address"), + db_source=signal_data.get("db_source"), + preprocessing_enabled=signal_data.get("preprocessing_enabled", False), + preprocessing_rules=signal_data.get("preprocessing_rules", []), + min_output_value=signal_data.get("min_output_value"), + max_output_value=signal_data.get("max_output_value"), + default_output_value=signal_data.get("default_output_value"), + modbus_config=signal_data.get("modbus_config"), + opcua_config=signal_data.get("opcua_config") + ) + + # Validate configuration + validation = simplified_configuration_manager.validate_signal_configuration(signal_create) + if not validation["valid"]: + return { + "success": False, + "message": "Configuration validation failed", + "errors": validation["errors"], + "warnings": validation["warnings"] + } + + # Add the signal + success = simplified_configuration_manager.add_protocol_signal(signal_create) + + if success: + # Get the created signal to return + signal_id = signal_create.generate_signal_id() + signal = simplified_configuration_manager.get_protocol_signal(signal_id) + + return { + "success": True, + "message": "Protocol signal created successfully", + "signal": signal.dict() if signal else None, + "warnings": validation["warnings"] + } + else: + raise HTTPException(status_code=400, detail="Failed to create protocol signal") + + except ValidationError as e: + logger.error(f"Validation error creating protocol signal: {str(e)}") + raise HTTPException(status_code=400, detail=f"Validation error: {str(e)}") + except HTTPException: + # Re-raise HTTP exceptions + raise + except Exception as e: + logger.error(f"Error creating protocol signal: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to create protocol signal: {str(e)}") + +@dashboard_router.put("/protocol-signals/{signal_id}") +async def update_protocol_signal(signal_id: str, signal_data: dict): + """Update an existing protocol signal""" + try: + from .simplified_models import ProtocolSignalUpdate, ProtocolType + from .simplified_configuration_manager import simplified_configuration_manager + + # Convert protocol_type string to enum if provided + protocol_enum = None + if "protocol_type" in signal_data: + try: + protocol_enum = ProtocolType(signal_data["protocol_type"]) + except ValueError: + raise HTTPException(status_code=400, detail=f"Invalid protocol type: {signal_data['protocol_type']}") + + # Create ProtocolSignalUpdate object + update_data = ProtocolSignalUpdate( + signal_name=signal_data.get("signal_name"), + tags=signal_data.get("tags"), + protocol_type=protocol_enum, + protocol_address=signal_data.get("protocol_address"), + db_source=signal_data.get("db_source"), + preprocessing_enabled=signal_data.get("preprocessing_enabled"), + preprocessing_rules=signal_data.get("preprocessing_rules"), + min_output_value=signal_data.get("min_output_value"), + max_output_value=signal_data.get("max_output_value"), + default_output_value=signal_data.get("default_output_value"), + modbus_config=signal_data.get("modbus_config"), + opcua_config=signal_data.get("opcua_config"), + enabled=signal_data.get("enabled") + ) + + success = simplified_configuration_manager.update_protocol_signal(signal_id, update_data) + + if success: + # Get the updated signal to return + signal = simplified_configuration_manager.get_protocol_signal(signal_id) + + return { + "success": True, + "message": "Protocol signal updated successfully", + "signal": signal.dict() if signal else None + } + else: + raise HTTPException(status_code=404, detail=f"Protocol signal {signal_id} not found") + + except ValidationError as e: + logger.error(f"Validation error updating protocol signal: {str(e)}") + raise HTTPException(status_code=400, detail=f"Validation error: {str(e)}") + except Exception as e: + logger.error(f"Error updating protocol signal {signal_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to update protocol signal: {str(e)}") + +@dashboard_router.delete("/protocol-signals/{signal_id}") +async def delete_protocol_signal(signal_id: str): + """Delete a protocol signal""" + try: + from .simplified_configuration_manager import simplified_configuration_manager + + success = simplified_configuration_manager.delete_protocol_signal(signal_id) + + if success: + return { + "success": True, + "message": f"Protocol signal {signal_id} deleted successfully" + } + else: + raise HTTPException(status_code=404, detail=f"Protocol signal {signal_id} not found") + + except Exception as e: + logger.error(f"Error deleting protocol signal {signal_id}: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to delete protocol signal: {str(e)}") + +@dashboard_router.get("/protocol-signals/tags/all") +async def get_all_signal_tags(): + """Get all unique tags used across protocol signals""" + try: + from .simplified_configuration_manager import simplified_configuration_manager + + all_tags = simplified_configuration_manager.get_all_tags() + + return { + "success": True, + "tags": all_tags, + "count": len(all_tags) + } + except Exception as e: + logger.error(f"Error getting all signal tags: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to get signal tags: {str(e)}") + +# Tag-Based Metadata API Endpoints + +@dashboard_router.get("/metadata/summary") +async def get_metadata_summary(): + """Get tag-based metadata summary""" + try: + summary = tag_metadata_manager.get_metadata_summary() + return { + "success": True, + "summary": summary + } + except Exception as e: + logger.error(f"Error getting metadata summary: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to get metadata summary: {str(e)}") + +@dashboard_router.get("/metadata/stations") +async def get_stations(tags: Optional[str] = None): + """Get stations, optionally filtered by tags (comma-separated)""" + try: + tag_list = tags.split(",") if tags else [] + stations = tag_metadata_manager.get_stations_by_tags(tag_list) + return { + "success": True, + "stations": stations, + "count": len(stations) + } + except Exception as e: + logger.error(f"Error getting stations: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to get stations: {str(e)}") + +@dashboard_router.get("/metadata/equipment") +async def get_equipment(station_id: Optional[str] = None, tags: Optional[str] = None): + """Get equipment, optionally filtered by station and tags""" + try: + tag_list = tags.split(",") if tags else [] + equipment = tag_metadata_manager.get_equipment_by_tags(tag_list, station_id) + return { + "success": True, + "equipment": equipment, + "count": len(equipment) + } + except Exception as e: + logger.error(f"Error getting equipment: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to get equipment: {str(e)}") + +@dashboard_router.get("/metadata/data-types") +async def get_data_types(tags: Optional[str] = None): + """Get data types, optionally filtered by tags""" + try: + tag_list = tags.split(",") if tags else [] + data_types = tag_metadata_manager.get_data_types_by_tags(tag_list) + return { + "success": True, + "data_types": data_types, + "count": len(data_types) + } + except Exception as e: + logger.error(f"Error getting data types: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to get data types: {str(e)}") + +@dashboard_router.get("/metadata/tags") +async def get_suggested_tags(): + """Get all available tags (core + user-defined)""" + try: + tags = tag_metadata_manager.get_suggested_tags() + return { + "success": True, + "tags": tags, + "count": len(tags) + } + except Exception as e: + logger.error(f"Error getting tags: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to get tags: {str(e)}") + +@dashboard_router.post("/metadata/stations") +async def create_station(station_data: dict): + """Create a new station with tags""" + try: + station_id = tag_metadata_manager.add_station( + name=station_data.get("name"), + tags=station_data.get("tags", []), + attributes=station_data.get("attributes", {}), + description=station_data.get("description"), + station_id=station_data.get("id") + ) + return { + "success": True, + "station_id": station_id, + "message": "Station created successfully" + } + except Exception as e: + logger.error(f"Error creating station: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to create station: {str(e)}") + +@dashboard_router.post("/metadata/equipment") +async def create_equipment(equipment_data: dict): + """Create new equipment with tags""" + try: + equipment_id = tag_metadata_manager.add_equipment( + name=equipment_data.get("name"), + station_id=equipment_data.get("station_id"), + tags=equipment_data.get("tags", []), + attributes=equipment_data.get("attributes", {}), + description=equipment_data.get("description"), + equipment_id=equipment_data.get("id") + ) + return { + "success": True, + "equipment_id": equipment_id, + "message": "Equipment created successfully" + } + except Exception as e: + logger.error(f"Error creating equipment: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to create equipment: {str(e)}") + +@dashboard_router.post("/metadata/data-types") +async def create_data_type(data_type_data: dict): + """Create new data type with tags""" + try: + data_type_id = tag_metadata_manager.add_data_type( + name=data_type_data.get("name"), + tags=data_type_data.get("tags", []), + attributes=data_type_data.get("attributes", {}), + description=data_type_data.get("description"), + units=data_type_data.get("units"), + min_value=data_type_data.get("min_value"), + max_value=data_type_data.get("max_value"), + default_value=data_type_data.get("default_value"), + data_type_id=data_type_data.get("id") + ) + return { + "success": True, + "data_type_id": data_type_id, + "message": "Data type created successfully" + } + except Exception as e: + logger.error(f"Error creating data type: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to create data type: {str(e)}") + +@dashboard_router.post("/metadata/tags") +async def add_custom_tag(tag_data: dict): + """Add a custom tag to the system""" + try: + tag = tag_data.get("tag") + if not tag: + raise HTTPException(status_code=400, detail="Tag is required") + + tag_metadata_manager.add_custom_tag(tag) + return { + "success": True, + "message": f"Tag '{tag}' added successfully" + } + except Exception as e: + logger.error(f"Error adding tag: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to add tag: {str(e)}") + +@dashboard_router.get("/metadata/search") +async def search_metadata(tags: str): + """Search across all metadata entities by tags""" + try: + if not tags: + raise HTTPException(status_code=400, detail="Tags parameter is required") + + tag_list = tags.split(",") + results = tag_metadata_manager.search_by_tags(tag_list) + return { + "success": True, + "search_tags": tag_list, + "results": results + } + except Exception as e: + logger.error(f"Error searching metadata: {str(e)}") + raise HTTPException(status_code=500, detail=f"Failed to search metadata: {str(e)}") + + @dashboard_router.get("/discovery/status") async def get_discovery_status(): """Get current discovery service status""" try: - status = discovery_service.get_discovery_status() + status = persistent_discovery_service.get_discovery_status() return { "success": True, "status": status @@ -990,7 +1307,7 @@ async def start_discovery_scan(background_tasks: BackgroundTasks): """Start a new discovery scan""" try: # Check if scan is already running - status = discovery_service.get_discovery_status() + status = persistent_discovery_service.get_discovery_status() if status["is_scanning"]: raise HTTPException(status_code=409, detail="Discovery scan already in progress") @@ -998,7 +1315,7 @@ async def start_discovery_scan(background_tasks: BackgroundTasks): scan_id = f"scan_{datetime.now().strftime('%Y%m%d_%H%M%S')}" async def run_discovery(): - await discovery_service.discover_all_protocols(scan_id) + await persistent_discovery_service.discover_all_protocols(scan_id) background_tasks.add_task(run_discovery) @@ -1018,33 +1335,33 @@ async def start_discovery_scan(background_tasks: BackgroundTasks): async def get_discovery_results(scan_id: str): """Get results for a specific discovery scan""" try: - result = discovery_service.get_scan_result(scan_id) + result = persistent_discovery_service.get_scan_result(scan_id) if not result: raise HTTPException(status_code=404, detail=f"Discovery scan {scan_id} not found") # Convert discovered endpoints to dict format endpoints_data = [] - for endpoint in result.discovered_endpoints: + for endpoint in result["discovered_endpoints"]: endpoint_data = { - "protocol_type": endpoint.protocol_type.value, - "address": endpoint.address, - "port": endpoint.port, - "device_id": endpoint.device_id, - "device_name": endpoint.device_name, - "capabilities": endpoint.capabilities, - "response_time": endpoint.response_time, - "discovered_at": endpoint.discovered_at.isoformat() if endpoint.discovered_at else None + "protocol_type": endpoint.get("protocol_type"), + "address": endpoint.get("address"), + "port": endpoint.get("port"), + "device_id": endpoint.get("device_id"), + "device_name": endpoint.get("device_name"), + "capabilities": endpoint.get("capabilities", []), + "response_time": endpoint.get("response_time"), + "discovered_at": endpoint.get("discovered_at") } endpoints_data.append(endpoint_data) return { "success": True, "scan_id": scan_id, - "status": result.status.value, - "scan_duration": result.scan_duration, - "errors": result.errors, - "timestamp": result.timestamp.isoformat() if result.timestamp else None, + "status": result.get("status"), + "scan_duration": None, # Not available in current implementation + "errors": result.get("error_message"), + "timestamp": result.get("scan_started_at"), "discovered_endpoints": endpoints_data } except HTTPException: @@ -1059,12 +1376,12 @@ async def get_recent_discoveries(): """Get most recently discovered endpoints""" try: # Get recent scan results and extract endpoints - status = discovery_service.get_discovery_status() + status = persistent_discovery_service.get_discovery_status() recent_scans = status.get("recent_scans", [])[-5:] # Last 5 scans recent_endpoints = [] for scan_id in recent_scans: - result = discovery_service.get_scan_result(scan_id) + result = persistent_discovery_service.get_scan_result(scan_id) if result and result.discovered_endpoints: recent_endpoints.extend(result.discovered_endpoints) @@ -1076,14 +1393,14 @@ async def get_recent_discoveries(): endpoints_data = [] for endpoint in recent_endpoints: endpoint_data = { - "protocol_type": endpoint.protocol_type.value, - "address": endpoint.address, - "port": endpoint.port, - "device_id": endpoint.device_id, - "device_name": endpoint.device_name, - "capabilities": endpoint.capabilities, - "response_time": endpoint.response_time, - "discovered_at": endpoint.discovered_at.isoformat() if endpoint.discovered_at else None + "protocol_type": endpoint.get("protocol_type"), + "address": endpoint.get("address"), + "port": endpoint.get("port"), + "device_id": endpoint.get("device_id"), + "device_name": endpoint.get("device_name"), + "capabilities": endpoint.get("capabilities", []), + "response_time": endpoint.get("response_time"), + "discovered_at": endpoint.get("discovered_at") } endpoints_data.append(endpoint_data) @@ -1097,32 +1414,46 @@ async def get_recent_discoveries(): @dashboard_router.post("/discovery/apply/{scan_id}") -async def apply_discovery_results(scan_id: str, station_id: str, pump_id: str, data_type: str, db_source: str): +async def apply_discovery_results(scan_id: str, station_id: str, equipment_id: str, data_type_id: str, db_source: str): """Apply discovered endpoints as protocol mappings""" try: - result = discovery_service.get_scan_result(scan_id) + result = persistent_discovery_service.get_scan_result(scan_id) if not result: raise HTTPException(status_code=404, detail=f"Discovery scan {scan_id} not found") - if result.status != DiscoveryStatus.COMPLETED: + if result.get("status") != "completed": raise HTTPException(status_code=400, detail="Cannot apply incomplete discovery scan") created_mappings = [] errors = [] - for endpoint in result.discovered_endpoints: + for endpoint in result.get("discovered_endpoints", []): try: # Create protocol mapping from discovered endpoint - mapping_id = f"{endpoint.device_id}_{data_type}" + mapping_id = f"{endpoint.get('device_id')}_{data_type_id}" + + # Convert protocol types to match configuration manager expectations + protocol_type = endpoint.get("protocol_type") + if protocol_type == "opc_ua": + protocol_type = "opcua" + + # Convert addresses based on protocol type + protocol_address = endpoint.get("address") + if protocol_type == "modbus_tcp": + # For Modbus TCP, use a default register address since IP is not valid + protocol_address = "40001" # Default holding register + elif protocol_type == "opcua": + # For OPC UA, construct a proper node ID + protocol_address = f"ns=2;s={endpoint.get('device_name', 'Device').replace(' ', '_')}" protocol_mapping = ProtocolMapping( id=mapping_id, station_id=station_id, - pump_id=pump_id, - protocol_type=endpoint.protocol_type, - protocol_address=endpoint.address, - data_type=data_type, + equipment_id=equipment_id, + protocol_type=protocol_type, + protocol_address=protocol_address, + data_type_id=data_type_id, db_source=db_source ) @@ -1132,10 +1463,10 @@ async def apply_discovery_results(scan_id: str, station_id: str, pump_id: str, d if success: created_mappings.append(mapping_id) else: - errors.append(f"Failed to create mapping for {endpoint.device_name}") + errors.append(f"Failed to create mapping for {endpoint.get('device_name')}") except Exception as e: - errors.append(f"Error creating mapping for {endpoint.device_name}: {str(e)}") + errors.append(f"Error creating mapping for {endpoint.get('device_name')}: {str(e)}") return { "success": True, @@ -1167,8 +1498,8 @@ async def validate_protocol_mapping(mapping_id: str, mapping_data: dict): id=mapping_id, protocol_type=protocol_enum, station_id=mapping_data.get("station_id"), - pump_id=mapping_data.get("pump_id"), - data_type=mapping_data.get("data_type"), + equipment_id=mapping_data.get("equipment_id"), + data_type_id=mapping_data.get("data_type_id"), protocol_address=mapping_data.get("protocol_address"), db_source=mapping_data.get("db_source"), transformation_rules=mapping_data.get("transformation_rules", []), diff --git a/src/dashboard/configuration_manager.py b/src/dashboard/configuration_manager.py index 1b94d2f..fd741fd 100644 --- a/src/dashboard/configuration_manager.py +++ b/src/dashboard/configuration_manager.py @@ -52,57 +52,7 @@ class ModbusTCPConfig(SCADAProtocolConfig): raise ValueError("Port must be between 1 and 65535") return v -class PumpStationConfig(BaseModel): - """Pump station configuration""" - station_id: str - name: str - location: str = "" - description: str = "" - max_pumps: int = 4 - power_capacity: float = 150.0 - flow_capacity: float = 500.0 - - @validator('station_id') - def validate_station_id(cls, v): - if not v.replace('_', '').isalnum(): - raise ValueError("Station ID must be alphanumeric with underscores") - return v -class PumpConfig(BaseModel): - """Individual pump configuration""" - pump_id: str - station_id: str - name: str - type: str = "centrifugal" # centrifugal, submersible, etc. - power_rating: float # kW - max_speed: float # Hz - min_speed: float # Hz - vfd_model: str = "" - manufacturer: str = "" - serial_number: str = "" - - @validator('pump_id') - def validate_pump_id(cls, v): - if not v.replace('_', '').isalnum(): - raise ValueError("Pump ID must be alphanumeric with underscores") - return v - -class SafetyLimitsConfig(BaseModel): - """Safety limits configuration""" - station_id: str - pump_id: str - hard_min_speed_hz: float = 20.0 - hard_max_speed_hz: float = 50.0 - hard_min_level_m: Optional[float] = None - hard_max_level_m: Optional[float] = None - hard_max_power_kw: Optional[float] = None - max_speed_change_hz_per_min: float = 30.0 - - @validator('hard_max_speed_hz') - def validate_speed_limits(cls, v, values): - if 'hard_min_speed_hz' in values and v <= values['hard_min_speed_hz']: - raise ValueError("Maximum speed must be greater than minimum speed") - return v class DataPointMapping(BaseModel): """Data point mapping between protocol and internal representation""" @@ -118,12 +68,19 @@ class ProtocolMapping(BaseModel): id: str protocol_type: ProtocolType station_id: str - pump_id: str - data_type: str # setpoint, status, power, flow, level, safety, etc. + equipment_id: str + data_type_id: str protocol_address: str # register address or OPC UA node db_source: str # database table and column transformation_rules: List[Dict[str, Any]] = [] + # Signal preprocessing configuration + preprocessing_enabled: bool = False + preprocessing_rules: List[Dict[str, Any]] = [] + min_output_value: Optional[float] = None + max_output_value: Optional[float] = None + default_output_value: Optional[float] = None + # Protocol-specific configurations modbus_config: Optional[Dict[str, Any]] = None opcua_config: Optional[Dict[str, Any]] = None @@ -134,6 +91,36 @@ class ProtocolMapping(BaseModel): raise ValueError("Mapping ID must be alphanumeric with underscores") return v + @validator('station_id') + def validate_station_id(cls, v): + """Validate that station exists in tag metadata system""" + from src.core.tag_metadata_manager import tag_metadata_manager + if v and v not in tag_metadata_manager.stations: + raise ValueError(f"Station '{v}' does not exist in tag metadata system") + return v + + @validator('equipment_id') + def validate_equipment_id(cls, v, values): + """Validate that equipment exists in tag metadata system and belongs to station""" + from src.core.tag_metadata_manager import tag_metadata_manager + if v and v not in tag_metadata_manager.equipment: + raise ValueError(f"Equipment '{v}' does not exist in tag metadata system") + + # Validate equipment belongs to station + if 'station_id' in values and values['station_id']: + equipment = tag_metadata_manager.equipment.get(v) + if equipment and equipment.station_id != values['station_id']: + raise ValueError(f"Equipment '{v}' does not belong to station '{values['station_id']}'") + return v + + @validator('data_type_id') + def validate_data_type_id(cls, v): + """Validate that data type exists in tag metadata system""" + from src.core.tag_metadata_manager import tag_metadata_manager + if v and v not in tag_metadata_manager.data_types: + raise ValueError(f"Data type '{v}' does not exist in tag metadata system") + return v + @validator('protocol_address') def validate_protocol_address(cls, v, values): if 'protocol_type' in values: @@ -158,12 +145,96 @@ class ProtocolMapping(BaseModel): if not v.startswith(('http://', 'https://')): raise ValueError("REST API endpoint must start with 'http://' or 'https://'") return v + + def apply_preprocessing(self, value: float, context: Optional[Dict[str, Any]] = None) -> float: + """Apply preprocessing rules to a value""" + if not self.preprocessing_enabled: + return value + + processed_value = value + + for rule in self.preprocessing_rules: + rule_type = rule.get('type') + params = rule.get('parameters', {}) + + if rule_type == 'scale': + processed_value *= params.get('factor', 1.0) + elif rule_type == 'offset': + processed_value += params.get('offset', 0.0) + elif rule_type == 'clamp': + min_val = params.get('min', float('-inf')) + max_val = params.get('max', float('inf')) + processed_value = max(min_val, min(processed_value, max_val)) + elif rule_type == 'linear_map': + # Map from [input_min, input_max] to [output_min, output_max] + input_min = params.get('input_min', 0.0) + input_max = params.get('input_max', 1.0) + output_min = params.get('output_min', 0.0) + output_max = params.get('output_max', 1.0) + + if input_max == input_min: + processed_value = output_min + else: + normalized = (processed_value - input_min) / (input_max - input_min) + processed_value = output_min + normalized * (output_max - output_min) + elif rule_type == 'deadband': + # Apply deadband to prevent oscillation + center = params.get('center', 0.0) + width = params.get('width', 0.0) + if abs(processed_value - center) <= width: + processed_value = center + elif rule_type == 'pump_control_logic': + # Apply pump control logic preprocessing + from src.core.pump_control_preprocessor import pump_control_preprocessor, PumpControlLogic + + # Extract pump control parameters from context + station_id = context.get('station_id') if context else None + pump_id = context.get('pump_id') if context else None + current_level = context.get('current_level') if context else None + current_pump_state = context.get('current_pump_state') if context else None + + if station_id and pump_id: + # Get control logic type + logic_type_str = params.get('logic_type', 'mpc_adaptive_hysteresis') + try: + logic_type = PumpControlLogic(logic_type_str) + except ValueError: + logger.warning(f"Unknown pump control logic: {logic_type_str}, using default") + logic_type = PumpControlLogic.MPC_ADAPTIVE_HYSTERESIS + + # Apply pump control logic + result = pump_control_preprocessor.apply_control_logic( + station_id=station_id, + pump_id=pump_id, + mpc_output=processed_value, + current_level=current_level, + current_pump_state=current_pump_state, + control_logic=logic_type, + control_params=params.get('control_params', {}) + ) + + # Convert result to output value + # For level-based control, we return the MPC output but store control signals + # The actual pump control will use the thresholds from the result + processed_value = 100.0 if result.get('pump_command', False) else 0.0 + + # Store control result in context for downstream use + if context is not None: + context['pump_control_result'] = result + + # Apply final output limits + if self.min_output_value is not None: + processed_value = max(self.min_output_value, processed_value) + if self.max_output_value is not None: + processed_value = min(self.max_output_value, processed_value) + + return processed_value class HardwareDiscoveryResult(BaseModel): """Result from hardware auto-discovery""" success: bool - discovered_stations: List[PumpStationConfig] = [] - discovered_pumps: List[PumpConfig] = [] + discovered_stations: List[Dict[str, Any]] = [] + discovered_pumps: List[Dict[str, Any]] = [] errors: List[str] = [] warnings: List[str] = [] @@ -172,9 +243,6 @@ class ConfigurationManager: def __init__(self, db_client=None): self.protocol_configs: Dict[ProtocolType, SCADAProtocolConfig] = {} - self.stations: Dict[str, PumpStationConfig] = {} - self.pumps: Dict[str, PumpConfig] = {} - self.safety_limits: Dict[str, SafetyLimitsConfig] = {} self.data_mappings: List[DataPointMapping] = [] self.protocol_mappings: List[ProtocolMapping] = [] self.db_client = db_client @@ -187,11 +255,11 @@ class ConfigurationManager: """Load protocol mappings from database""" try: query = """ - SELECT mapping_id, station_id, pump_id, protocol_type, - protocol_address, data_type, db_source, enabled + SELECT mapping_id, station_id, equipment_id, protocol_type, + protocol_address, data_type_id, db_source, enabled FROM protocol_mappings WHERE enabled = true - ORDER BY station_id, pump_id, protocol_type + ORDER BY station_id, equipment_id, protocol_type """ results = self.db_client.execute_query(query) @@ -205,10 +273,10 @@ class ConfigurationManager: mapping = ProtocolMapping( id=row['mapping_id'], station_id=row['station_id'], - pump_id=row['pump_id'], + equipment_id=row['equipment_id'], protocol_type=protocol_type, protocol_address=row['protocol_address'], - data_type=row['data_type'], + data_type_id=row['data_type_id'], db_source=row['db_source'] ) self.protocol_mappings.append(mapping) @@ -230,44 +298,7 @@ class ConfigurationManager: logger.error(f"Failed to configure protocol {config.protocol_type}: {str(e)}") return False - def add_pump_station(self, station: PumpStationConfig) -> bool: - """Add a pump station configuration""" - try: - self.stations[station.station_id] = station - logger.info(f"Added pump station: {station.name} ({station.station_id})") - return True - except Exception as e: - logger.error(f"Failed to add pump station {station.station_id}: {str(e)}") - return False - - def add_pump(self, pump: PumpConfig) -> bool: - """Add a pump configuration""" - try: - # Verify station exists - if pump.station_id not in self.stations: - raise ValueError(f"Station {pump.station_id} does not exist") - - self.pumps[pump.pump_id] = pump - logger.info(f"Added pump: {pump.name} ({pump.pump_id}) to station {pump.station_id}") - return True - except Exception as e: - logger.error(f"Failed to add pump {pump.pump_id}: {str(e)}") - return False - - def set_safety_limits(self, limits: SafetyLimitsConfig) -> bool: - """Set safety limits for a pump""" - try: - # Verify pump exists - if limits.pump_id not in self.pumps: - raise ValueError(f"Pump {limits.pump_id} does not exist") - - key = f"{limits.station_id}_{limits.pump_id}" - self.safety_limits[key] = limits - logger.info(f"Set safety limits for pump {limits.pump_id}") - return True - except Exception as e: - logger.error(f"Failed to set safety limits for {limits.pump_id}: {str(e)}") - return False + def map_data_point(self, mapping: DataPointMapping) -> bool: """Map a data point between protocol and internal representation""" @@ -307,14 +338,14 @@ class ConfigurationManager: if self.db_client: query = """ INSERT INTO protocol_mappings - (mapping_id, station_id, pump_id, protocol_type, protocol_address, data_type, db_source, created_by, enabled) - VALUES (:mapping_id, :station_id, :pump_id, :protocol_type, :protocol_address, :data_type, :db_source, :created_by, :enabled) + (mapping_id, station_id, equipment_id, protocol_type, protocol_address, data_type_id, db_source, created_by, enabled) + VALUES (:mapping_id, :station_id, :equipment_id, :protocol_type, :protocol_address, :data_type_id, :db_source, :created_by, :enabled) ON CONFLICT (mapping_id) DO UPDATE SET station_id = EXCLUDED.station_id, - pump_id = EXCLUDED.pump_id, + equipment_id = EXCLUDED.equipment_id, protocol_type = EXCLUDED.protocol_type, protocol_address = EXCLUDED.protocol_address, - data_type = EXCLUDED.data_type, + data_type_id = EXCLUDED.data_type_id, db_source = EXCLUDED.db_source, enabled = EXCLUDED.enabled, updated_at = CURRENT_TIMESTAMP @@ -322,10 +353,10 @@ class ConfigurationManager: params = { 'mapping_id': mapping.id, 'station_id': mapping.station_id, - 'pump_id': mapping.pump_id, + 'equipment_id': mapping.equipment_id, 'protocol_type': mapping.protocol_type.value, 'protocol_address': mapping.protocol_address, - 'data_type': mapping.data_type, + 'data_type_id': mapping.data_type_id, 'db_source': mapping.db_source, 'created_by': 'dashboard', 'enabled': True @@ -333,7 +364,7 @@ class ConfigurationManager: self.db_client.execute(query, params) self.protocol_mappings.append(mapping) - logger.info(f"Added protocol mapping {mapping.id}: {mapping.protocol_type} for {mapping.station_id}/{mapping.pump_id}") + logger.info(f"Added protocol mapping {mapping.id}: {mapping.protocol_type} for {mapping.station_id}/{mapping.equipment_id}") return True except Exception as e: logger.error(f"Failed to add protocol mapping {mapping.id}: {str(e)}") @@ -342,8 +373,8 @@ class ConfigurationManager: def get_protocol_mappings(self, protocol_type: Optional[ProtocolType] = None, station_id: Optional[str] = None, - pump_id: Optional[str] = None) -> List[ProtocolMapping]: - """Get mappings filtered by protocol/station/pump""" + equipment_id: Optional[str] = None) -> List[ProtocolMapping]: + """Get mappings filtered by protocol/station/equipment""" filtered_mappings = self.protocol_mappings.copy() if protocol_type: @@ -352,8 +383,8 @@ class ConfigurationManager: if station_id: filtered_mappings = [m for m in filtered_mappings if m.station_id == station_id] - if pump_id: - filtered_mappings = [m for m in filtered_mappings if m.pump_id == pump_id] + if equipment_id: + filtered_mappings = [m for m in filtered_mappings if m.equipment_id == equipment_id] return filtered_mappings @@ -373,10 +404,10 @@ class ConfigurationManager: query = """ UPDATE protocol_mappings SET station_id = :station_id, - pump_id = :pump_id, + equipment_id = :equipment_id, protocol_type = :protocol_type, protocol_address = :protocol_address, - data_type = :data_type, + data_type_id = :data_type_id, db_source = :db_source, updated_at = CURRENT_TIMESTAMP WHERE mapping_id = :mapping_id @@ -384,10 +415,10 @@ class ConfigurationManager: params = { 'mapping_id': mapping_id, 'station_id': updated_mapping.station_id, - 'pump_id': updated_mapping.pump_id, + 'equipment_id': updated_mapping.equipment_id, 'protocol_type': updated_mapping.protocol_type.value, 'protocol_address': updated_mapping.protocol_address, - 'data_type': updated_mapping.data_type, + 'data_type_id': updated_mapping.data_type_id, 'db_source': updated_mapping.db_source } self.db_client.execute(query, params) @@ -445,7 +476,7 @@ class ConfigurationManager: if (existing.id != mapping.id and existing.protocol_type == ProtocolType.MODBUS_TCP and existing.protocol_address == mapping.protocol_address): - errors.append(f"Modbus address {mapping.protocol_address} already used by {existing.station_id}/{existing.pump_id}") + errors.append(f"Modbus address {mapping.protocol_address} already used by {existing.station_id}/{existing.equipment_id}") break except ValueError: @@ -461,7 +492,7 @@ class ConfigurationManager: if (existing.id != mapping.id and existing.protocol_type == ProtocolType.OPC_UA and existing.protocol_address == mapping.protocol_address): - errors.append(f"OPC UA node {mapping.protocol_address} already used by {existing.station_id}/{existing.pump_id}") + errors.append(f"OPC UA node {mapping.protocol_address} already used by {existing.station_id}/{existing.equipment_id}") break elif mapping.protocol_type == ProtocolType.MODBUS_RTU: @@ -476,7 +507,7 @@ class ConfigurationManager: if (existing.id != mapping.id and existing.protocol_type == ProtocolType.MODBUS_RTU and existing.protocol_address == mapping.protocol_address): - errors.append(f"Modbus RTU address {mapping.protocol_address} already used by {existing.station_id}/{existing.pump_id}") + errors.append(f"Modbus RTU address {mapping.protocol_address} already used by {existing.station_id}/{existing.equipment_id}") break except ValueError: @@ -492,7 +523,7 @@ class ConfigurationManager: if (existing.id != mapping.id and existing.protocol_type == ProtocolType.REST_API and existing.protocol_address == mapping.protocol_address): - errors.append(f"REST API endpoint {mapping.protocol_address} already used by {existing.station_id}/{existing.pump_id}") + errors.append(f"REST API endpoint {mapping.protocol_address} already used by {existing.station_id}/{existing.equipment_id}") break # Check database source format @@ -517,25 +548,25 @@ class ConfigurationManager: if ProtocolType.OPC_UA in self.protocol_configs: logger.info("Performing OPC UA hardware discovery...") # Simulate discovering a station via OPC UA - mock_station = PumpStationConfig( - station_id="discovered_station_001", - name="Discovered Pump Station", - location="Building A", - max_pumps=2, - power_capacity=100.0 - ) + mock_station = { + "station_id": "discovered_station_001", + "name": "Discovered Pump Station", + "location": "Building A", + "max_pumps": 2, + "power_capacity": 100.0 + } result.discovered_stations.append(mock_station) # Simulate discovering pumps - mock_pump = PumpConfig( - pump_id="discovered_pump_001", - station_id="discovered_station_001", - name="Discovered Primary Pump", - type="centrifugal", - power_rating=55.0, - max_speed=50.0, - min_speed=20.0 - ) + mock_pump = { + "pump_id": "discovered_pump_001", + "station_id": "discovered_station_001", + "name": "Discovered Primary Pump", + "type": "centrifugal", + "power_rating": 55.0, + "max_speed": 50.0, + "min_speed": 20.0 + } result.discovered_pumps.append(mock_pump) # Mock Modbus discovery @@ -592,9 +623,6 @@ class ConfigurationManager: # Create summary validation_result["summary"] = { "protocols_configured": len(self.protocol_configs), - "stations_configured": len(self.stations), - "pumps_configured": len(self.pumps), - "safety_limits_set": len(self.safety_limits), "data_mappings": len(self.data_mappings), "protocol_mappings": len(self.protocol_mappings) } @@ -605,9 +633,6 @@ class ConfigurationManager: """Export complete configuration for backup""" return { "protocols": {pt.value: config.dict() for pt, config in self.protocol_configs.items()}, - "stations": {sid: station.dict() for sid, station in self.stations.items()}, - "pumps": {pid: pump.dict() for pid, pump in self.pumps.items()}, - "safety_limits": {key: limits.dict() for key, limits in self.safety_limits.items()}, "data_mappings": [mapping.dict() for mapping in self.data_mappings], "protocol_mappings": [mapping.dict() for mapping in self.protocol_mappings] } @@ -617,9 +642,6 @@ class ConfigurationManager: try: # Clear existing configuration self.protocol_configs.clear() - self.stations.clear() - self.pumps.clear() - self.safety_limits.clear() self.data_mappings.clear() self.protocol_mappings.clear() @@ -634,21 +656,6 @@ class ConfigurationManager: config = SCADAProtocolConfig(**config_dict) self.protocol_configs[protocol_type] = config - # Import stations - for sid, station_dict in config_data.get("stations", {}).items(): - station = PumpStationConfig(**station_dict) - self.stations[sid] = station - - # Import pumps - for pid, pump_dict in config_data.get("pumps", {}).items(): - pump = PumpConfig(**pump_dict) - self.pumps[pid] = pump - - # Import safety limits - for key, limits_dict in config_data.get("safety_limits", {}).items(): - limits = SafetyLimitsConfig(**limits_dict) - self.safety_limits[key] = limits - # Import data mappings for mapping_dict in config_data.get("data_mappings", []): mapping = DataPointMapping(**mapping_dict) diff --git a/src/dashboard/simplified_configuration_manager.py b/src/dashboard/simplified_configuration_manager.py new file mode 100644 index 0000000..9086d06 --- /dev/null +++ b/src/dashboard/simplified_configuration_manager.py @@ -0,0 +1,277 @@ +""" +Simplified Configuration Manager +Manages protocol signals with human-readable names and tags +Replaces the complex ID-based system +""" + +import logging +from typing import List, Optional, Dict, Any +from datetime import datetime + +from .simplified_models import ( + ProtocolSignal, ProtocolSignalCreate, ProtocolSignalUpdate, + ProtocolSignalFilter, ProtocolType +) + +logger = logging.getLogger(__name__) + +class SimplifiedConfigurationManager: + """ + Manages protocol signals with simplified name + tags approach + """ + + def __init__(self, database_client=None): + self.database_client = database_client + self.signals: Dict[str, ProtocolSignal] = {} + logger.info("SimplifiedConfigurationManager initialized") + + def add_protocol_signal(self, signal_create: ProtocolSignalCreate) -> bool: + """ + Add a new protocol signal + """ + try: + # Generate signal ID + signal_id = signal_create.generate_signal_id() + + # Check if signal ID already exists + if signal_id in self.signals: + logger.warning(f"Signal ID {signal_id} already exists") + return False + + # Create ProtocolSignal object + signal = ProtocolSignal( + signal_id=signal_id, + signal_name=signal_create.signal_name, + tags=signal_create.tags, + protocol_type=signal_create.protocol_type, + protocol_address=signal_create.protocol_address, + db_source=signal_create.db_source, + preprocessing_enabled=signal_create.preprocessing_enabled, + preprocessing_rules=signal_create.preprocessing_rules, + min_output_value=signal_create.min_output_value, + max_output_value=signal_create.max_output_value, + default_output_value=signal_create.default_output_value, + modbus_config=signal_create.modbus_config, + opcua_config=signal_create.opcua_config, + created_at=datetime.now().isoformat(), + updated_at=datetime.now().isoformat() + ) + + # Store in memory (in production, this would be in database) + self.signals[signal_id] = signal + + logger.info(f"Added protocol signal: {signal_id} - {signal.signal_name}") + return True + + except Exception as e: + logger.error(f"Error adding protocol signal: {str(e)}") + return False + + def get_protocol_signals(self, filters: Optional[ProtocolSignalFilter] = None) -> List[ProtocolSignal]: + """ + Get protocol signals with optional filtering + """ + try: + signals = list(self.signals.values()) + + if not filters: + return signals + + # Apply filters + filtered_signals = signals + + # Filter by tags + if filters.tags: + filtered_signals = [ + s for s in filtered_signals + if any(tag in s.tags for tag in filters.tags) + ] + + # Filter by protocol type + if filters.protocol_type: + filtered_signals = [ + s for s in filtered_signals + if s.protocol_type == filters.protocol_type + ] + + # Filter by signal name + if filters.signal_name_contains: + filtered_signals = [ + s for s in filtered_signals + if filters.signal_name_contains.lower() in s.signal_name.lower() + ] + + # Filter by enabled status + if filters.enabled is not None: + filtered_signals = [ + s for s in filtered_signals + if s.enabled == filters.enabled + ] + + return filtered_signals + + except Exception as e: + logger.error(f"Error getting protocol signals: {str(e)}") + return [] + + def get_protocol_signal(self, signal_id: str) -> Optional[ProtocolSignal]: + """ + Get a specific protocol signal by ID + """ + return self.signals.get(signal_id) + + def update_protocol_signal(self, signal_id: str, update_data: ProtocolSignalUpdate) -> bool: + """ + Update an existing protocol signal + """ + try: + if signal_id not in self.signals: + logger.warning(f"Signal {signal_id} not found for update") + return False + + signal = self.signals[signal_id] + + # Update fields if provided + if update_data.signal_name is not None: + signal.signal_name = update_data.signal_name + + if update_data.tags is not None: + signal.tags = update_data.tags + + if update_data.protocol_type is not None: + signal.protocol_type = update_data.protocol_type + + if update_data.protocol_address is not None: + signal.protocol_address = update_data.protocol_address + + if update_data.db_source is not None: + signal.db_source = update_data.db_source + + if update_data.preprocessing_enabled is not None: + signal.preprocessing_enabled = update_data.preprocessing_enabled + + if update_data.preprocessing_rules is not None: + signal.preprocessing_rules = update_data.preprocessing_rules + + if update_data.min_output_value is not None: + signal.min_output_value = update_data.min_output_value + + if update_data.max_output_value is not None: + signal.max_output_value = update_data.max_output_value + + if update_data.default_output_value is not None: + signal.default_output_value = update_data.default_output_value + + if update_data.modbus_config is not None: + signal.modbus_config = update_data.modbus_config + + if update_data.opcua_config is not None: + signal.opcua_config = update_data.opcua_config + + if update_data.enabled is not None: + signal.enabled = update_data.enabled + + # Update timestamp + signal.updated_at = datetime.now().isoformat() + + logger.info(f"Updated protocol signal: {signal_id}") + return True + + except Exception as e: + logger.error(f"Error updating protocol signal {signal_id}: {str(e)}") + return False + + def delete_protocol_signal(self, signal_id: str) -> bool: + """ + Delete a protocol signal + """ + try: + if signal_id not in self.signals: + logger.warning(f"Signal {signal_id} not found for deletion") + return False + + del self.signals[signal_id] + logger.info(f"Deleted protocol signal: {signal_id}") + return True + + except Exception as e: + logger.error(f"Error deleting protocol signal {signal_id}: {str(e)}") + return False + + def search_signals_by_tags(self, tags: List[str]) -> List[ProtocolSignal]: + """ + Search signals by tags (all tags must match) + """ + try: + return [ + signal for signal in self.signals.values() + if all(tag in signal.tags for tag in tags) + ] + except Exception as e: + logger.error(f"Error searching signals by tags: {str(e)}") + return [] + + def get_all_tags(self) -> List[str]: + """ + Get all unique tags used across all signals + """ + all_tags = set() + for signal in self.signals.values(): + all_tags.update(signal.tags) + return sorted(list(all_tags)) + + def get_signals_by_protocol_type(self, protocol_type: ProtocolType) -> List[ProtocolSignal]: + """ + Get all signals for a specific protocol type + """ + return [ + signal for signal in self.signals.values() + if signal.protocol_type == protocol_type + ] + + def validate_signal_configuration(self, signal_create: ProtocolSignalCreate) -> Dict[str, Any]: + """ + Validate signal configuration before creation + """ + validation_result = { + "valid": True, + "errors": [], + "warnings": [] + } + + try: + # Validate signal name + if not signal_create.signal_name or not signal_create.signal_name.strip(): + validation_result["valid"] = False + validation_result["errors"].append("Signal name cannot be empty") + + # Validate protocol address + if not signal_create.protocol_address: + validation_result["valid"] = False + validation_result["errors"].append("Protocol address cannot be empty") + + # Validate database source + if not signal_create.db_source: + validation_result["valid"] = False + validation_result["errors"].append("Database source cannot be empty") + + # Check for duplicate signal names + existing_names = [s.signal_name for s in self.signals.values()] + if signal_create.signal_name in existing_names: + validation_result["warnings"].append( + f"Signal name '{signal_create.signal_name}' already exists" + ) + + # Validate tags + if not signal_create.tags: + validation_result["warnings"].append("No tags provided - consider adding tags for better organization") + + return validation_result + + except Exception as e: + validation_result["valid"] = False + validation_result["errors"].append(f"Validation error: {str(e)}") + return validation_result + +# Global instance for simplified configuration management +simplified_configuration_manager = SimplifiedConfigurationManager() \ No newline at end of file diff --git a/src/dashboard/simplified_models.py b/src/dashboard/simplified_models.py new file mode 100644 index 0000000..0db6e84 --- /dev/null +++ b/src/dashboard/simplified_models.py @@ -0,0 +1,195 @@ +""" +Simplified Protocol Signal Models +Migration from complex ID system to simple signal names + tags +""" + +from typing import List, Optional, Dict, Any +from pydantic import BaseModel, validator +from enum import Enum +import uuid +import logging + +logger = logging.getLogger(__name__) + +class ProtocolType(str, Enum): + """Supported protocol types""" + OPCUA = "opcua" + MODBUS_TCP = "modbus_tcp" + MODBUS_RTU = "modbus_rtu" + REST_API = "rest_api" + +class ProtocolSignal(BaseModel): + """ + Simplified protocol signal with human-readable name and tags + Replaces the complex station_id/equipment_id/data_type_id system + """ + signal_id: str + signal_name: str + tags: List[str] + protocol_type: ProtocolType + protocol_address: str + db_source: str + + # Signal preprocessing configuration + preprocessing_enabled: bool = False + preprocessing_rules: List[Dict[str, Any]] = [] + min_output_value: Optional[float] = None + max_output_value: Optional[float] = None + default_output_value: Optional[float] = None + + # Protocol-specific configurations + modbus_config: Optional[Dict[str, Any]] = None + opcua_config: Optional[Dict[str, Any]] = None + + # Metadata + created_at: Optional[str] = None + updated_at: Optional[str] = None + created_by: Optional[str] = None + enabled: bool = True + + @validator('signal_id') + def validate_signal_id(cls, v): + """Validate signal ID format""" + if not v.replace('_', '').replace('-', '').isalnum(): + raise ValueError("Signal ID must be alphanumeric with underscores and hyphens") + return v + + @validator('signal_name') + def validate_signal_name(cls, v): + """Validate signal name is not empty""" + if not v or not v.strip(): + raise ValueError("Signal name cannot be empty") + return v.strip() + + @validator('tags') + def validate_tags(cls, v): + """Validate tags format""" + if not isinstance(v, list): + raise ValueError("Tags must be a list") + + # Remove empty tags and normalize + cleaned_tags = [] + for tag in v: + if tag and isinstance(tag, str) and tag.strip(): + cleaned_tags.append(tag.strip().lower()) + + return cleaned_tags + + @validator('protocol_address') + def validate_protocol_address(cls, v, values): + """Validate protocol address based on protocol type""" + if 'protocol_type' not in values: + return v + + protocol_type = values['protocol_type'] + + if protocol_type == ProtocolType.MODBUS_TCP or protocol_type == ProtocolType.MODBUS_RTU: + # Modbus addresses should be numeric + if not v.isdigit(): + raise ValueError(f"Modbus address must be numeric, got: {v}") + address = int(v) + if address < 0 or address > 65535: + raise ValueError(f"Modbus address must be between 0 and 65535, got: {address}") + + elif protocol_type == ProtocolType.OPCUA: + # OPC UA addresses should follow NodeId format + if not v.startswith(('ns=', 'i=', 's=')): + raise ValueError(f"OPC UA address should start with ns=, i=, or s=, got: {v}") + + elif protocol_type == ProtocolType.REST_API: + # REST API addresses should be URLs or paths + if not v.startswith('/'): + raise ValueError(f"REST API address should start with /, got: {v}") + + return v + +class ProtocolSignalCreate(BaseModel): + """Model for creating new protocol signals""" + signal_name: str + tags: List[str] + protocol_type: ProtocolType + protocol_address: str + db_source: str + preprocessing_enabled: bool = False + preprocessing_rules: List[Dict[str, Any]] = [] + min_output_value: Optional[float] = None + max_output_value: Optional[float] = None + default_output_value: Optional[float] = None + modbus_config: Optional[Dict[str, Any]] = None + opcua_config: Optional[Dict[str, Any]] = None + + def generate_signal_id(self) -> str: + """Generate a unique signal ID from the signal name""" + base_id = self.signal_name.lower().replace(' ', '_').replace('/', '_') + base_id = ''.join(c for c in base_id if c.isalnum() or c in ['_', '-']) + + # Add random suffix to ensure uniqueness + random_suffix = uuid.uuid4().hex[:8] + return f"{base_id}_{random_suffix}" + +class ProtocolSignalUpdate(BaseModel): + """Model for updating existing protocol signals""" + signal_name: Optional[str] = None + tags: Optional[List[str]] = None + protocol_type: Optional[ProtocolType] = None + protocol_address: Optional[str] = None + db_source: Optional[str] = None + preprocessing_enabled: Optional[bool] = None + preprocessing_rules: Optional[List[Dict[str, Any]]] = None + min_output_value: Optional[float] = None + max_output_value: Optional[float] = None + default_output_value: Optional[float] = None + modbus_config: Optional[Dict[str, Any]] = None + opcua_config: Optional[Dict[str, Any]] = None + enabled: Optional[bool] = None + +class ProtocolSignalFilter(BaseModel): + """Model for filtering protocol signals""" + tags: Optional[List[str]] = None + protocol_type: Optional[ProtocolType] = None + signal_name_contains: Optional[str] = None + enabled: Optional[bool] = True + +class SignalDiscoveryResult(BaseModel): + """Model for discovery results that can be converted to protocol signals""" + device_name: str + protocol_type: ProtocolType + protocol_address: str + data_point: str + device_address: Optional[str] = None + device_port: Optional[int] = None + + def to_protocol_signal_create(self) -> ProtocolSignalCreate: + """Convert discovery result to protocol signal creation data""" + signal_name = f"{self.device_name} {self.data_point}" + + # Generate meaningful tags from discovery data + tags = [ + f"device:{self.device_name.lower().replace(' ', '_')}", + f"protocol:{self.protocol_type.value}", + f"data_point:{self.data_point.lower().replace(' ', '_')}" + ] + + if self.device_address: + tags.append(f"address:{self.device_address}") + + return ProtocolSignalCreate( + signal_name=signal_name, + tags=tags, + protocol_type=self.protocol_type, + protocol_address=self.protocol_address, + db_source=f"measurements.{self.device_name.lower().replace(' ', '_')}_{self.data_point.lower().replace(' ', '_')}" + ) + +# Example usage: +# discovery_result = SignalDiscoveryResult( +# device_name="Water Pump Controller", +# protocol_type=ProtocolType.MODBUS_TCP, +# protocol_address="40001", +# data_point="Speed", +# device_address="192.168.1.100" +# ) +# +# signal_create = discovery_result.to_protocol_signal_create() +# print(signal_create.signal_name) # "Water Pump Controller Speed" +# print(signal_create.tags) # ["device:water_pump_controller", "protocol:modbus_tcp", "data_point:speed", "address:192.168.1.100"] \ No newline at end of file diff --git a/src/dashboard/simplified_templates.py b/src/dashboard/simplified_templates.py new file mode 100644 index 0000000..2205a85 --- /dev/null +++ b/src/dashboard/simplified_templates.py @@ -0,0 +1,164 @@ +""" +Simplified Protocol Signals HTML Template +""" + +SIMPLIFIED_PROTOCOL_SIGNALS_HTML = """ +
+

Protocol Signals Management

+
+ + +
+

Protocol Signals

+

Manage your industrial protocol signals with human-readable names and flexible tags

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

Popular Tags

+
+ +
+
+ + +
+ + + +
+ + +
+ + + + + + + + + + + + + + + +
Signal NameProtocol TypeTagsProtocol AddressDatabase SourceStatusActions
+
+
+ + +
+

Protocol Discovery

+
+ +
+
+ + + +
+ +
+
+ + Discovery service ready - Discovered devices will auto-populate signal forms +
+
+
+ +
+ +
+
+ + + +
+""" \ No newline at end of file diff --git a/src/dashboard/templates.py b/src/dashboard/templates.py index c210989..e5c53d6 100644 --- a/src/dashboard/templates.py +++ b/src/dashboard/templates.py @@ -153,10 +153,12 @@ DASHBOARD_HTML = """ .protocol-btn { padding: 8px 16px; background: #f8f9fa; + color: #333; border: 1px solid #ddd; border-radius: 4px; cursor: pointer; font-weight: normal; + transition: all 0.2s ease; } .protocol-btn.active { @@ -168,10 +170,17 @@ DASHBOARD_HTML = """ .protocol-btn:hover { background: #e9ecef; + color: #222; + border-color: #007acc; + transform: translateY(-1px); + box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1); } .protocol-btn.active:hover { background: #005a9e; + color: white; + transform: translateY(-1px); + box-shadow: 0 2px 4px rgba(0, 122, 204, 0.3); } /* Modal Styles */ @@ -229,6 +238,161 @@ DASHBOARD_HTML = """ .log-entry.info { color: #007acc; } + + /* Discovery Results Styling */ + .discovery-result-card { + border: 1px solid #ddd; + border-radius: 6px; + padding: 15px; + margin-bottom: 10px; + background: #f8f9fa; + } + + .discovery-result-card .signal-info { + margin-bottom: 10px; + } + + .discovery-result-card .signal-tags { + margin: 5px 0; + } + + .discovery-result-card .signal-details { + display: flex; + gap: 15px; + font-size: 14px; + color: #666; + } + + .use-signal-btn { + background: #007acc; + color: white; + border: none; + padding: 8px 16px; + border-radius: 4px; + cursor: pointer; + font-weight: bold; + } + + .use-signal-btn:hover { + background: #005a9e; + } + + .apply-all-btn { + background: #28a745; + color: white; + border: none; + padding: 10px 20px; + border-radius: 4px; + cursor: pointer; + font-weight: bold; + margin-top: 15px; + } + + .apply-all-btn:hover { + background: #218838; + } + + .discovery-notification { + position: fixed; + top: 20px; + right: 20px; + padding: 15px; + border-radius: 4px; + z-index: 10000; + max-width: 300px; + } + + .discovery-notification.success { + background: #d4edda; + color: #155724; + border: 1px solid #c3e6cb; + } + + .discovery-notification.error { + background: #f8d7da; + color: #721c24; + border: 1px solid #f5c6cb; + } + + .discovery-notification.warning { + background: #fff3cd; + color: #856404; + border: 1px solid #ffeaa7; + } + + /* Table Layout Fixes for Protocol Mappings */ + .protocol-mappings-table-container { + overflow-x: auto; + margin-top: 20px; + } + + #protocol-mappings-table { + table-layout: fixed; + width: 100%; + min-width: 800px; + } + + #protocol-mappings-table th, + #protocol-mappings-table td { + padding: 8px 10px; + border: 1px solid #ddd; + text-align: left; + word-wrap: break-word; + overflow-wrap: break-word; + } + + #protocol-mappings-table th:nth-child(1) { width: 10%; min-width: 80px; } /* ID */ + #protocol-mappings-table th:nth-child(2) { width: 8%; min-width: 80px; } /* Protocol */ + #protocol-mappings-table th:nth-child(3) { width: 15%; min-width: 120px; } /* Station */ + #protocol-mappings-table th:nth-child(4) { width: 15%; min-width: 120px; } /* Equipment */ + #protocol-mappings-table th:nth-child(5) { width: 15%; min-width: 120px; } /* Data Type */ + #protocol-mappings-table th:nth-child(6) { width: 12%; min-width: 100px; } /* Protocol Address */ + #protocol-mappings-table th:nth-child(7) { width: 15%; min-width: 120px; } /* Database Source */ + #protocol-mappings-table th:nth-child(8) { width: 10%; min-width: 100px; } /* Actions */ + + /* Protocol Signals Table */ + .protocol-signals-table-container { + overflow-x: auto; + margin-top: 20px; + } + + #protocol-signals-table { + table-layout: fixed; + width: 100%; + min-width: 700px; + } + + #protocol-signals-table th, + #protocol-signals-table td { + padding: 8px 10px; + border: 1px solid #ddd; + text-align: left; + word-wrap: break-word; + overflow-wrap: break-word; + } + + #protocol-signals-table th:nth-child(1) { width: 20%; min-width: 120px; } /* Signal Name */ + #protocol-signals-table th:nth-child(2) { width: 12%; min-width: 100px; } /* Protocol Type */ + #protocol-signals-table th:nth-child(3) { width: 20%; min-width: 150px; } /* Tags */ + #protocol-signals-table th:nth-child(4) { width: 15%; min-width: 100px; } /* Protocol Address */ + #protocol-signals-table th:nth-child(5) { width: 18%; min-width: 120px; } /* Database Source */ + #protocol-signals-table th:nth-child(6) { width: 8%; min-width: 80px; } /* Status */ + #protocol-signals-table th:nth-child(7) { width: 7%; min-width: 100px; } /* Actions */ + + /* Mobile responsiveness */ + @media (max-width: 768px) { + .protocol-mappings-table-container, + .protocol-signals-table-container { + font-size: 14px; + } + + #protocol-mappings-table th, + #protocol-mappings-table td, + #protocol-signals-table th, + #protocol-signals-table td { + padding: 6px 8px; + } + } @@ -552,23 +716,23 @@ DASHBOARD_HTML = """

Protocol Mappings

- - + +
-
- +
+
- - - - - - - - + + + + + + + + @@ -578,6 +742,31 @@ DASHBOARD_HTML = """ + +
+

Protocol Signals

+

Signals discovered through protocol discovery will appear here

+ +
+
IDProtocolStationPumpData TypeProtocol AddressDatabase SourceActionsIDProtocolStation (Name & ID)Equipment (Name & ID)Data Type (Name & ID)Protocol AddressDatabase SourceActions
+ + + + + + + + + + + + + + +
Signal NameProtocol TypeTagsProtocol AddressDatabase SourceStatusActions
+
+
+ + + + @@ -662,7 +908,9 @@ DASHBOARD_HTML = """ + + """ \ No newline at end of file diff --git a/src/discovery/protocol_discovery_persistent.py b/src/discovery/protocol_discovery_persistent.py new file mode 100644 index 0000000..165c41b --- /dev/null +++ b/src/discovery/protocol_discovery_persistent.py @@ -0,0 +1,258 @@ +""" +Protocol Discovery Service - Persistent version with database storage +""" +import asyncio +import json +import logging +from datetime import datetime +from typing import List, Dict, Any, Optional +from enum import Enum +from dataclasses import dataclass, asdict + +from sqlalchemy import text +from config.settings import settings +from src.database.flexible_client import FlexibleDatabaseClient + +logger = logging.getLogger(__name__) + + +class DiscoveryStatus(Enum): + """Discovery operation status""" + PENDING = "pending" + RUNNING = "running" + COMPLETED = "completed" + FAILED = "failed" + + +class ProtocolType(Enum): + MODBUS_TCP = "modbus_tcp" + MODBUS_RTU = "modbus_rtu" + OPC_UA = "opc_ua" + REST_API = "rest_api" + + +@dataclass +class DiscoveredEndpoint: + protocol_type: ProtocolType + address: str + port: Optional[int] = None + device_id: Optional[str] = None + device_name: Optional[str] = None + capabilities: Optional[List[str]] = None + response_time: Optional[float] = None + discovered_at: Optional[datetime] = None + + def __post_init__(self): + if self.capabilities is None: + self.capabilities = [] + + +@dataclass +class DiscoveryResult: + scan_id: str + status: DiscoveryStatus + discovered_endpoints: List[DiscoveredEndpoint] + scan_started_at: datetime + scan_completed_at: Optional[datetime] = None + error_message: Optional[str] = None + + +class PersistentProtocolDiscoveryService: + """ + Protocol discovery service with database persistence + """ + + def __init__(self): + self._current_scan_id: Optional[str] = None + self._db_client = FlexibleDatabaseClient(settings.database_url) + + async def initialize(self): + """Initialize database connection""" + try: + await self._db_client.connect() + logger.info("Discovery service database initialized") + except Exception as e: + logger.error(f"Failed to initialize discovery service database: {e}") + + def get_discovery_status(self) -> Dict[str, Any]: + """Get current discovery service status""" + try: + # Get recent scans from database + query = text(""" + SELECT scan_id, status, scan_started_at, scan_completed_at + FROM discovery_results + ORDER BY scan_started_at DESC + LIMIT 5 + """) + + with self._db_client.engine.connect() as conn: + result = conn.execute(query) + recent_scans = [ + { + 'scan_id': row[0], + 'status': row[1], + 'scan_started_at': row[2].isoformat() if row[2] else None, + 'scan_completed_at': row[3].isoformat() if row[3] else None + } + for row in result + ] + + # Get total discovered endpoints (count unique endpoints across all scans) + query = text(""" + SELECT COUNT(DISTINCT endpoint->>'device_id') + FROM discovery_results dr, + jsonb_array_elements(dr.discovered_endpoints) AS endpoint + WHERE dr.status = 'completed' + """) + + with self._db_client.engine.connect() as conn: + result = conn.execute(query) + total_endpoints = result.scalar() or 0 + + return { + "current_scan_id": self._current_scan_id, + "is_scanning": self._current_scan_id is not None, + "recent_scans": recent_scans, + "total_discovered_endpoints": total_endpoints + } + except Exception as e: + logger.error(f"Error getting discovery status: {e}") + return { + "current_scan_id": None, + "is_scanning": False, + "recent_scans": [], + "total_discovered_endpoints": 0 + } + + def get_scan_result(self, scan_id: str) -> Optional[Dict[str, Any]]: + """Get result for a specific scan from database""" + try: + query = text(""" + SELECT scan_id, status, discovered_endpoints, + scan_started_at, scan_completed_at, error_message + FROM discovery_results + WHERE scan_id = :scan_id + """) + + with self._db_client.engine.connect() as conn: + result = conn.execute(query, {"scan_id": scan_id}) + row = result.fetchone() + + if row: + return { + "scan_id": row[0], + "status": row[1], + "discovered_endpoints": row[2] if row[2] else [], + "scan_started_at": row[3].isoformat() if row[3] else None, + "scan_completed_at": row[4].isoformat() if row[4] else None, + "error_message": row[5] + } + return None + except Exception as e: + logger.error(f"Error getting scan result {scan_id}: {e}") + return None + + async def discover_all_protocols(self, scan_id: str) -> None: + """ + Discover all available protocols (simulated for now) + """ + try: + # Store scan as started + await self._store_scan_result( + scan_id=scan_id, + status=DiscoveryStatus.RUNNING, + discovered_endpoints=[], + scan_started_at=datetime.now(), + scan_completed_at=None, + error_message=None + ) + + # Simulate discovery process + await asyncio.sleep(2) + + # Create mock discovered endpoints + discovered_endpoints = [ + { + "protocol_type": "modbus_tcp", + "address": "192.168.1.100", + "port": 502, + "device_id": "pump_controller_001", + "device_name": "Main Pump Controller", + "capabilities": ["read_coils", "read_holding_registers"], + "response_time": 0.15, + "discovered_at": datetime.now().isoformat() + }, + { + "protocol_type": "opc_ua", + "address": "192.168.1.101", + "port": 4840, + "device_id": "scada_server_001", + "device_name": "SCADA Server", + "capabilities": ["browse", "read", "write"], + "response_time": 0.25, + "discovered_at": datetime.now().isoformat() + } + ] + + # Store completed scan + await self._store_scan_result( + scan_id=scan_id, + status=DiscoveryStatus.COMPLETED, + discovered_endpoints=discovered_endpoints, + scan_started_at=datetime.now(), + scan_completed_at=datetime.now(), + error_message=None + ) + + logger.info(f"Discovery scan {scan_id} completed with {len(discovered_endpoints)} endpoints") + + except Exception as e: + logger.error(f"Discovery scan {scan_id} failed: {e}") + await self._store_scan_result( + scan_id=scan_id, + status=DiscoveryStatus.FAILED, + discovered_endpoints=[], + scan_started_at=datetime.now(), + scan_completed_at=datetime.now(), + error_message=str(e) + ) + + async def _store_scan_result( + self, + scan_id: str, + status: DiscoveryStatus, + discovered_endpoints: List[Dict[str, Any]], + scan_started_at: datetime, + scan_completed_at: Optional[datetime] = None, + error_message: Optional[str] = None + ) -> None: + """Store scan result in database""" + try: + query = text(""" + INSERT INTO discovery_results + (scan_id, status, discovered_endpoints, scan_started_at, scan_completed_at, error_message) + VALUES (:scan_id, :status, :discovered_endpoints, :scan_started_at, :scan_completed_at, :error_message) + ON CONFLICT (scan_id) DO UPDATE SET + status = EXCLUDED.status, + discovered_endpoints = EXCLUDED.discovered_endpoints, + scan_completed_at = EXCLUDED.scan_completed_at, + error_message = EXCLUDED.error_message + """) + + with self._db_client.engine.connect() as conn: + conn.execute(query, { + "scan_id": scan_id, + "status": status.value, + "discovered_endpoints": json.dumps(discovered_endpoints), + "scan_started_at": scan_started_at, + "scan_completed_at": scan_completed_at, + "error_message": error_message + }) + conn.commit() + + except Exception as e: + logger.error(f"Failed to store scan result {scan_id}: {e}") + + +# Global instance +persistent_discovery_service = PersistentProtocolDiscoveryService() \ No newline at end of file diff --git a/src/main.py b/src/main.py index aa0af73..43c8957 100644 --- a/src/main.py +++ b/src/main.py @@ -25,6 +25,7 @@ from src.core.optimization_manager import OptimizationPlanManager from src.core.setpoint_manager import SetpointManager from src.core.security import SecurityManager from src.core.compliance_audit import ComplianceAuditLogger +from src.core.metadata_initializer import initialize_sample_metadata from src.monitoring.watchdog import DatabaseWatchdog from src.monitoring.alerts import AlertManager from src.monitoring.health_monitor import HealthMonitor @@ -177,6 +178,15 @@ class CalejoControlAdapter: await self.db_client.connect() logger.info("database_connected") + # Initialize persistent discovery service + from src.discovery.protocol_discovery_persistent import persistent_discovery_service + await persistent_discovery_service.initialize() + logger.info("persistent_discovery_service_initialized") + + # Initialize sample metadata for demonstration + initialize_sample_metadata() + logger.info("sample_metadata_initialized") + # Load safety limits await self.safety_enforcer.load_safety_limits() logger.info("safety_limits_loaded") diff --git a/start_dashboard.py b/start_dashboard.py index e2dd81b..ec50e1d 100644 --- a/start_dashboard.py +++ b/start_dashboard.py @@ -4,6 +4,7 @@ Start Dashboard Server for Protocol Mapping Testing """ import os +import asyncio import uvicorn from fastapi import FastAPI from fastapi.staticfiles import StaticFiles @@ -13,6 +14,7 @@ from fastapi import Request from src.dashboard.api import dashboard_router from src.dashboard.templates import DASHBOARD_HTML +from src.discovery.protocol_discovery_persistent import persistent_discovery_service # Create FastAPI app app = FastAPI(title="Calejo Control Adapter Dashboard", version="1.0.0") @@ -38,6 +40,22 @@ async def health_check(): """Health check endpoint""" return {"status": "healthy", "service": "dashboard"} +async def initialize_services(): + """Initialize services before starting the server""" + try: + print("🔄 Starting persistent discovery service initialization...") + await persistent_discovery_service.initialize() + print("✅ Persistent discovery service initialized") + + # Test that it's working + status = persistent_discovery_service.get_discovery_status() + print(f"📊 Discovery status: {status}") + + except Exception as e: + print(f"❌ Failed to initialize persistent discovery service: {e}") + import traceback + traceback.print_exc() + if __name__ == "__main__": # Get port from environment variable or default to 8080 port = int(os.getenv("REST_API_PORT", "8080")) @@ -45,6 +63,9 @@ if __name__ == "__main__": print("🚀 Starting Calejo Control Adapter Dashboard...") print(f"📊 Dashboard available at: http://localhost:{port}") print("📊 Protocol Mapping tab should be visible in the navigation") + + # Initialize services + asyncio.run(initialize_services()) uvicorn.run( app, diff --git a/static/dashboard.js b/static/dashboard.js index 46fea40..c0b447e 100644 --- a/static/dashboard.js +++ b/static/dashboard.js @@ -24,7 +24,11 @@ function showTab(tabName) { } else if (tabName === 'logs') { loadLogs(); } else if (tabName === 'protocol-mapping') { - loadProtocolMappings(); + if (typeof loadAllSignals === 'function') { + loadAllSignals(); + } else { + console.warn('loadAllSignals function not available - protocol mapping tab may not work correctly'); + } } } diff --git a/static/discovery.js b/static/discovery.js index b3f5ce2..26171b4 100644 --- a/static/discovery.js +++ b/static/discovery.js @@ -1,398 +1,575 @@ -/** - * Protocol Discovery JavaScript - * Handles auto-discovery of protocol endpoints and integration with protocol mapping - */ +// Simplified Discovery Integration +// Updated for simplified signal names + tags architecture -class ProtocolDiscovery { +console.log('=== DISCOVERY.JS FILE LOADED - START ==='); + +class SimplifiedProtocolDiscovery { constructor() { - this.currentScanId = null; - this.scanInterval = null; + this.currentScanId = 'simplified-scan-123'; this.isScanning = false; } - /** - * Initialize discovery functionality - */ init() { - this.bindDiscoveryEvents(); - this.loadDiscoveryStatus(); - - // Auto-refresh discovery status every 5 seconds - setInterval(() => { - if (this.isScanning) { - this.loadDiscoveryStatus(); - } - }, 5000); - } - - /** - * Bind discovery event handlers - */ - bindDiscoveryEvents() { - // Start discovery scan - document.getElementById('start-discovery-scan')?.addEventListener('click', () => { - this.startDiscoveryScan(); - }); - - // Stop discovery scan - document.getElementById('stop-discovery-scan')?.addEventListener('click', () => { - this.stopDiscoveryScan(); - }); - - // Apply discovery results - document.getElementById('apply-discovery-results')?.addEventListener('click', () => { - this.applyDiscoveryResults(); - }); - - // Refresh discovery status - document.getElementById('refresh-discovery-status')?.addEventListener('click', () => { - this.loadDiscoveryStatus(); - }); - - // Auto-fill protocol form from discovery - document.addEventListener('click', (e) => { - if (e.target.classList.contains('use-discovered-endpoint')) { - this.useDiscoveredEndpoint(e.target.dataset.endpointId); - } - }); - } - - /** - * Start a new discovery scan - */ - async startDiscoveryScan() { + console.log('Discovery.js: init() called'); try { - this.setScanningState(true); - - const response = await fetch('/api/v1/dashboard/discovery/scan', { - method: 'POST', - headers: { - 'Content-Type': 'application/json' + this.bindDiscoveryEvents(); + console.log('Discovery.js: bindDiscoveryEvents() completed successfully'); + } catch (error) { + console.error('Discovery.js: Error in init():', error); + } + } + + bindDiscoveryEvents() { + console.log('Binding discovery events...'); + + // Discovery scan button + const startScanBtn = document.getElementById('start-discovery-scan'); + console.log('Start scan button:', startScanBtn); + if (startScanBtn) { + startScanBtn.addEventListener('click', () => { + console.log('Start Discovery Scan button clicked!'); + this.startDiscoveryScan(); + }); + } else { + console.error('Start scan button not found!'); + } + + // Check if discovery results container exists + const resultsContainer = document.getElementById('discovery-results'); + console.log('Discovery results container during init:', resultsContainer); + + // Auto-fill signal form from discovery + console.log('Setting up global click event listener for use-signal-btn'); + try { + const self = this; // Capture 'this' context + document.addEventListener('click', function(e) { + console.log('Global click event fired, target:', e.target.tagName, 'classes:', e.target.className); + console.log('Target dataset:', e.target.dataset); + + if (e.target.classList.contains('use-signal-btn')) { + console.log('Use This Signal button clicked!'); + console.log('Signal index from dataset:', e.target.dataset.signalIndex); + self.useDiscoveredEndpoint(e.target.dataset.signalIndex); + } else { + console.log('Clicked element is not a use-signal-btn'); } }); - - const result = await response.json(); - - if (result.success) { - this.currentScanId = result.scan_id; - this.showNotification('Discovery scan started successfully', 'success'); - - // Start polling for scan completion - this.pollScanStatus(); - } else { - throw new Error(result.detail || 'Failed to start discovery scan'); - } + console.log('Global click event listener set up successfully'); } catch (error) { - console.error('Error starting discovery scan:', error); - this.showNotification(`Failed to start discovery scan: ${error.message}`, 'error'); - this.setScanningState(false); + console.error('Error setting up event listener:', error); } } - /** - * Stop current discovery scan - */ - async stopDiscoveryScan() { - // Note: This would require additional API endpoint to stop scans - // For now, we'll just stop polling - if (this.scanInterval) { - clearInterval(this.scanInterval); - this.scanInterval = null; + async useDiscoveredEndpoint(signalIndex) { + console.log('Using discovered endpoint with index:', signalIndex); + + // Get the actual discovered endpoints from the mock scan + const discoveredEndpoints = await this.mockDiscoveryScan('192.168.1.0/24'); + + // Map signal index to endpoint + const endpoint = discoveredEndpoints[signalIndex]; + if (!endpoint) { + this.showNotification(`Endpoint with index ${signalIndex} not found`, 'error'); + return; + } + + // Convert to simplified signal format + const signalData = this.convertEndpointToSignal(endpoint); + + // Auto-populate the signal form with retry logic + this.autoPopulateSignalFormWithRetry(signalData); + + this.showNotification(`Endpoint ${endpoint.device_name} selected for signal creation`, 'success'); + } + + autoPopulateSignalFormWithRetry(signalData, retryCount = 0) { + console.log('Attempting to auto-populate signal form, attempt:', retryCount + 1); + + if (typeof window.autoPopulateSignalForm === 'function') { + console.log('Found window.autoPopulateSignalForm, calling it...'); + window.autoPopulateSignalForm(signalData); + } else { + console.error('autoPopulateSignalForm function not found'); + + // Retry after a delay if we haven't exceeded max retries + if (retryCount < 5) { + console.log(`Retrying in 500ms... (${retryCount + 1}/5)`); + setTimeout(() => { + this.autoPopulateSignalFormWithRetry(signalData, retryCount + 1); + }, 500); + } else { + console.error('Max retries exceeded, autoPopulateSignalForm function still not found'); + this.showNotification('Error: Could not open signal form. Please ensure the protocol mapping system is loaded.', 'error'); + } } - this.setScanningState(false); - this.showNotification('Discovery scan stopped', 'info'); } - /** - * Poll for scan completion - */ - async pollScanStatus() { - if (!this.currentScanId) return; + convertEndpointToSignal(endpoint) { + // Generate human-readable signal name + const signalName = `${endpoint.device_name} ${endpoint.data_point}`; + + // Generate meaningful tags + const tags = [ + `device:${endpoint.device_name.toLowerCase().replace(/[^a-z0-9]/g, '_')}`, + `protocol:${endpoint.protocol_type}`, + `data_point:${endpoint.data_point.toLowerCase().replace(/[^a-z0-9]/g, '_')}`, + 'discovered:true' + ]; + + // Add device-specific tags + if (endpoint.device_name.toLowerCase().includes('pump')) { + tags.push('equipment:pump'); + } + if (endpoint.device_name.toLowerCase().includes('sensor')) { + tags.push('equipment:sensor'); + } + if (endpoint.device_name.toLowerCase().includes('controller')) { + tags.push('equipment:controller'); + } + + // Add protocol-specific tags + if (endpoint.protocol_type === 'modbus_tcp') { + tags.push('interface:modbus'); + } else if (endpoint.protocol_type === 'opcua') { + tags.push('interface:opcua'); + } + + // Generate database source + const dbSource = `measurements.${endpoint.device_name.toLowerCase().replace(/[^a-z0-9]/g, '_')}_${endpoint.data_point.toLowerCase().replace(/[^a-z0-9]/g, '_')}`; + + return { + signal_name: signalName, + tags: tags, + protocol_type: endpoint.protocol_type, + protocol_address: endpoint.protocol_address, + db_source: dbSource + }; + } - this.scanInterval = setInterval(async () => { + + // Start discovery scan + async startDiscoveryScan() { + console.log('Starting discovery scan...'); + + // Update UI + const startBtn = document.getElementById('start-discovery-scan'); + const stopBtn = document.getElementById('stop-discovery-scan'); + const statusDiv = document.getElementById('discovery-status'); + + if (startBtn) startBtn.disabled = true; + if (stopBtn) stopBtn.disabled = false; + if (statusDiv) { + statusDiv.innerHTML = '
Discovery scan in progress...
'; + } + + try { + // Run discovery + const results = await this.discoverAndSuggestSignals(); + + // Update status + if (statusDiv) { + statusDiv.innerHTML = `
Discovery complete. Found ${results.length} devices.
`; + } + + this.showNotification(`Discovery complete. Found ${results.length} devices.`, 'success'); + + } catch (error) { + console.error('Discovery scan failed:', error); + if (statusDiv) { + statusDiv.innerHTML = '
Discovery scan failed
'; + } + this.showNotification('Discovery scan failed', 'error'); + } finally { + // Reset UI + if (startBtn) startBtn.disabled = false; + if (stopBtn) stopBtn.disabled = true; + } + } + + // Advanced discovery features + async discoverAndSuggestSignals(networkRange = '192.168.1.0/24') { + console.log(`Starting discovery scan on ${networkRange}`); + this.isScanning = true; + + try { + // Mock discovery results + const discoveredEndpoints = await this.mockDiscoveryScan(networkRange); + + // Convert to suggested signals + const suggestedSignals = discoveredEndpoints.map(endpoint => + this.convertEndpointToSignal(endpoint) + ); + + this.displayDiscoveryResults(suggestedSignals); + this.isScanning = false; + + return suggestedSignals; + + } catch (error) { + console.error('Discovery scan failed:', error); + this.showNotification('Discovery scan failed', 'error'); + this.isScanning = false; + return []; + } + } + + async mockDiscoveryScan(networkRange) { + // Simulate network discovery delay + await new Promise(resolve => setTimeout(resolve, 2000)); + + // Return mock discovered endpoints + return [ + { + device_id: 'discovered_001', + protocol_type: 'modbus_tcp', + device_name: 'Booster Pump', + address: '192.168.1.110', + port: 502, + data_point: 'Flow Rate', + protocol_address: '30002' + }, + { + device_id: 'discovered_002', + protocol_type: 'modbus_tcp', + device_name: 'Level Sensor', + address: '192.168.1.111', + port: 502, + data_point: 'Tank Level', + protocol_address: '30003' + }, + { + device_id: 'discovered_003', + protocol_type: 'opcua', + device_name: 'PLC Controller', + address: '192.168.1.112', + port: 4840, + data_point: 'System Status', + protocol_address: 'ns=2;s=SystemStatus' + } + ]; + } + + displayDiscoveryResults(suggestedSignals) { + console.log('Displaying discovery results:', suggestedSignals); + const resultsContainer = document.getElementById('discovery-results'); + if (!resultsContainer) { + console.error('Discovery results container not found!'); + this.showNotification('Discovery results container not found', 'error'); + return; + } + + console.log('Found discovery results container:', resultsContainer); + resultsContainer.innerHTML = '

Discovery Results

'; + + suggestedSignals.forEach((signal, index) => { + const signalCard = document.createElement('div'); + signalCard.className = 'discovery-result-card'; + signalCard.innerHTML = ` +
+ ${signal.signal_name} +
+ ${signal.tags.map(tag => `${tag}`).join('')} +
+
+ Protocol: ${signal.protocol_type} + Address: ${signal.protocol_address} +
+
+ + `; + + resultsContainer.appendChild(signalCard); + }); + + // Add event listeners for use buttons + console.log('Adding event listener to results container'); + console.log('Results container:', resultsContainer); + console.log('Results container ID:', resultsContainer.id); + console.log('Number of use-signal-btn elements:', resultsContainer.querySelectorAll('.use-signal-btn').length); + + const clickHandler = (e) => { + console.log('Discovery results container clicked:', e.target); + console.log('Button classes:', e.target.classList); + console.log('Button tag name:', e.target.tagName); + if (e.target.classList.contains('use-signal-btn')) { + console.log('Use This Signal button clicked!'); + const signalIndex = parseInt(e.target.dataset.signalIndex); + console.log('Signal index:', signalIndex); + const signal = suggestedSignals[signalIndex]; + console.log('Signal data:', signal); + + // Use the global function directly + if (typeof window.autoPopulateSignalForm === 'function') { + window.autoPopulateSignalForm(signal); + } else { + console.error('autoPopulateSignalForm function not found!'); + } + } else { + console.log('Clicked element is not a use-signal-btn'); + } + }; + + resultsContainer.addEventListener('click', clickHandler); + console.log('Event listener added to results container'); + + // Add "Apply All" button + const applyAllButton = document.createElement('button'); + applyAllButton.className = 'apply-all-btn'; + applyAllButton.textContent = 'Apply All as Protocol Signals'; + applyAllButton.style.marginTop = '15px'; + applyAllButton.style.padding = '10px 20px'; + applyAllButton.style.background = '#28a745'; + applyAllButton.style.color = 'white'; + applyAllButton.style.border = 'none'; + applyAllButton.style.borderRadius = '4px'; + applyAllButton.style.cursor = 'pointer'; + applyAllButton.style.fontWeight = 'bold'; + + applyAllButton.onclick = () => { + this.applyAllAsProtocolSignals(suggestedSignals); + }; + + resultsContainer.appendChild(applyAllButton); + } + + // Apply all discovered signals as protocol signals + async applyAllAsProtocolSignals(signals) { + console.log('Applying all discovered signals as protocol signals:', signals); + + let successCount = 0; + let errorCount = 0; + let duplicateCount = 0; + + // First, check which signals already exist + const existingSignals = await this.getExistingSignals(); + const existingSignalNames = new Set(existingSignals.map(s => s.signal_name)); + + for (const signal of signals) { + // Skip if signal with same name already exists + if (existingSignalNames.has(signal.signal_name)) { + console.log(`⚠ Skipping duplicate signal: ${signal.signal_name}`); + duplicateCount++; + continue; + } + try { - const response = await fetch(`/api/v1/dashboard/discovery/results/${this.currentScanId}`); - const result = await response.json(); - - if (result.success) { - if (result.status === 'completed' || result.status === 'failed') { - clearInterval(this.scanInterval); - this.scanInterval = null; - this.setScanningState(false); - - if (result.status === 'completed') { - this.showNotification(`Discovery scan completed. Found ${result.discovered_endpoints.length} endpoints`, 'success'); - this.displayDiscoveryResults(result); - } else { - this.showNotification('Discovery scan failed', 'error'); - } + const response = await fetch('/api/v1/dashboard/protocol-signals', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify(signal) + }); + + const data = await response.json(); + + if (data.success) { + successCount++; + console.log(`✓ Created signal: ${signal.signal_name}`); + // Add to existing set to prevent duplicates in same batch + existingSignalNames.add(signal.signal_name); + } else { + errorCount++; + console.error(`✗ Failed to create signal: ${signal.signal_name}`, data.detail); + + // Check if it's a duplicate error + if (data.detail && data.detail.includes('already exists')) { + duplicateCount++; } } } catch (error) { - console.error('Error polling scan status:', error); - clearInterval(this.scanInterval); - this.scanInterval = null; - this.setScanningState(false); + errorCount++; + console.error(`✗ Error creating signal: ${signal.signal_name}`, error); } - }, 2000); - } - - /** - * Load current discovery status - */ - async loadDiscoveryStatus() { - try { - const response = await fetch('/api/v1/dashboard/discovery/status'); - const result = await response.json(); - - if (result.success) { - this.updateDiscoveryStatusUI(result.status); - } - } catch (error) { - console.error('Error loading discovery status:', error); } - } - - /** - * Update discovery status UI - */ - updateDiscoveryStatusUI(status) { - const statusElement = document.getElementById('discovery-status'); - const scanButton = document.getElementById('start-discovery-scan'); - const stopButton = document.getElementById('stop-discovery-scan'); - - if (!statusElement) return; - - this.isScanning = status.is_scanning; - - if (status.is_scanning) { - statusElement.innerHTML = ` -
- - Discovery scan in progress... (Scan ID: ${status.current_scan_id}) -
- `; - scanButton?.setAttribute('disabled', 'true'); - stopButton?.removeAttribute('disabled'); - } else { - statusElement.innerHTML = ` -
- - Discovery service ready - ${status.total_discovered_endpoints > 0 ? - `- ${status.total_discovered_endpoints} endpoints discovered` : - '' - } -
- `; - scanButton?.removeAttribute('disabled'); - stopButton?.setAttribute('disabled', 'true'); - } - } - - /** - * Display discovery results - */ - displayDiscoveryResults(result) { - const resultsContainer = document.getElementById('discovery-results'); - if (!resultsContainer) return; - - const endpoints = result.discovered_endpoints || []; - - if (endpoints.length === 0) { - resultsContainer.innerHTML = ` -
- - No endpoints discovered in this scan -
- `; - return; - } - - let html = ` -
-
-
- - Discovery Results (${endpoints.length} endpoints found) -
-
-
-
- - - - - - - - - - - - - `; - - endpoints.forEach(endpoint => { - const protocolBadge = this.getProtocolBadge(endpoint.protocol_type); - const capabilities = endpoint.capabilities ? endpoint.capabilities.join(', ') : 'N/A'; - const discoveredTime = endpoint.discovered_at ? - new Date(endpoint.discovered_at).toLocaleString() : 'N/A'; - - html += ` - - - - - - - - - `; - }); - - html += ` - -
ProtocolDevice NameAddressCapabilitiesDiscoveredActions
${protocolBadge}${endpoint.device_name || 'Unknown Device'}${endpoint.address}${endpoint.port ? ':' + endpoint.port : ''}${capabilities}${discoveredTime} - -
-
-
- -
-
-
- `; - - resultsContainer.innerHTML = html; - - // Re-bind apply button - document.getElementById('apply-discovery-results')?.addEventListener('click', () => { - this.applyDiscoveryResults(); - }); - } - - /** - * Apply discovery results as protocol mappings - */ - async applyDiscoveryResults() { - if (!this.currentScanId) { - this.showNotification('No discovery results to apply', 'warning'); - return; - } - - // Get station and pump info from form or prompt - const stationId = document.getElementById('station-id')?.value || 'station_001'; - const pumpId = document.getElementById('pump-id')?.value || 'pump_001'; - const dataType = document.getElementById('data-type')?.value || 'setpoint'; - const dbSource = document.getElementById('db-source')?.value || 'frequency_hz'; - - try { - const response = await fetch(`/api/v1/dashboard/discovery/apply/${this.currentScanId}`, { - method: 'POST', - headers: { - 'Content-Type': 'application/json' - }, - body: JSON.stringify({ - station_id: stationId, - pump_id: pumpId, - data_type: dataType, - db_source: dbSource - }) - }); - - const result = await response.json(); - - if (result.success) { - this.showNotification(`Successfully created ${result.created_mappings.length} protocol mappings`, 'success'); - - // Refresh protocol mappings grid - if (window.protocolMappingGrid) { - window.protocolMappingGrid.loadProtocolMappings(); - } - } else { - throw new Error(result.detail || 'Failed to apply discovery results'); - } - } catch (error) { - console.error('Error applying discovery results:', error); - this.showNotification(`Failed to apply discovery results: ${error.message}`, 'error'); - } - } - - /** - * Use discovered endpoint in protocol form - */ - useDiscoveredEndpoint(endpointId) { - // This would fetch the specific endpoint details and populate the form - // For now, we'll just show a notification - this.showNotification(`Endpoint ${endpointId} selected for protocol mapping`, 'info'); - // In a real implementation, we would: - // 1. Fetch endpoint details - // 2. Populate protocol form fields - // 3. Switch to protocol mapping tab + // Show results + let message = `Created ${successCount} signals successfully.`; + if (errorCount > 0) { + message += ` ${errorCount} failed.`; + } + if (duplicateCount > 0) { + message += ` ${duplicateCount} duplicates skipped.`; + } + + const notificationType = errorCount > 0 ? 'warning' : (successCount > 0 ? 'success' : 'info'); + this.showNotification(message, notificationType); + + // Refresh the protocol signals display + if (typeof window.loadAllSignals === 'function') { + window.loadAllSignals(); + } } - - /** - * Set scanning state - */ - setScanningState(scanning) { - this.isScanning = scanning; - const scanButton = document.getElementById('start-discovery-scan'); - const stopButton = document.getElementById('stop-discovery-scan'); - - if (scanning) { - scanButton?.setAttribute('disabled', 'true'); - stopButton?.removeAttribute('disabled'); - } else { - scanButton?.removeAttribute('disabled'); - stopButton?.setAttribute('disabled', 'true'); + + // Get existing signals to check for duplicates + async getExistingSignals() { + try { + const response = await fetch('/api/v1/dashboard/protocol-signals'); + const data = await response.json(); + + if (data.success) { + return data.signals || []; + } else { + console.error('Failed to get existing signals:', data.detail); + return []; + } + } catch (error) { + console.error('Error getting existing signals:', error); + return []; } } - /** - * Get protocol badge HTML - */ - getProtocolBadge(protocolType) { - const badges = { - 'modbus_tcp': 'Modbus TCP', - 'modbus_rtu': 'Modbus RTU', - 'opc_ua': 'OPC UA', - 'rest_api': 'REST API' - }; - - return badges[protocolType] || `${protocolType}`; + // Tag-based signal search + async searchSignalsByTags(tags) { + try { + const params = new URLSearchParams(); + tags.forEach(tag => params.append('tags', tag)); + + const response = await fetch(`/api/v1/dashboard/protocol-signals?${params}`); + const data = await response.json(); + + if (data.success) { + return data.signals; + } else { + console.error('Failed to search signals by tags:', data.detail); + return []; + } + } catch (error) { + console.error('Error searching signals by tags:', error); + return []; + } + } + + // Clear all existing signals (for testing) + async clearAllSignals() { + if (!confirm('Are you sure you want to delete ALL protocol signals? This action cannot be undone.')) { + return; + } + + try { + const existingSignals = await this.getExistingSignals(); + let deletedCount = 0; + + for (const signal of existingSignals) { + try { + const response = await fetch(`/api/v1/dashboard/protocol-signals/${signal.signal_id}`, { + method: 'DELETE' + }); + + const data = await response.json(); + + if (data.success) { + deletedCount++; + console.log(`✓ Deleted signal: ${signal.signal_name}`); + } else { + console.error(`✗ Failed to delete signal: ${signal.signal_name}`, data.detail); + } + } catch (error) { + console.error(`✗ Error deleting signal: ${signal.signal_name}`, error); + } + } + + this.showNotification(`Deleted ${deletedCount} signals successfully.`, 'success'); + + // Refresh the protocol signals display + if (typeof window.loadAllSignals === 'function') { + window.loadAllSignals(); + } + } catch (error) { + console.error('Error clearing signals:', error); + this.showNotification('Error clearing signals', 'error'); + } + } + + // Signal name suggestions based on device type + generateSignalNameSuggestions(deviceName, dataPoint) { + const baseName = `${deviceName} ${dataPoint}`; + + const suggestions = [ + baseName, + `${dataPoint} of ${deviceName}`, + `${deviceName} ${dataPoint} Reading`, + `${dataPoint} Measurement - ${deviceName}` + ]; + + // Add context-specific suggestions + if (dataPoint.toLowerCase().includes('speed')) { + suggestions.push(`${deviceName} Motor Speed`); + suggestions.push(`${deviceName} RPM`); + } + + if (dataPoint.toLowerCase().includes('temperature')) { + suggestions.push(`${deviceName} Temperature`); + suggestions.push(`Temperature at ${deviceName}`); + } + + if (dataPoint.toLowerCase().includes('pressure')) { + suggestions.push(`${deviceName} Pressure`); + suggestions.push(`Pressure Reading - ${deviceName}`); + } + + return suggestions; + } + + // Tag suggestions based on device and protocol + generateTagSuggestions(deviceName, protocolType, dataPoint) { + const suggestions = new Set(); + + // Device type tags + if (deviceName.toLowerCase().includes('pump')) { + suggestions.add('equipment:pump'); + suggestions.add('fluid:water'); + } + if (deviceName.toLowerCase().includes('sensor')) { + suggestions.add('equipment:sensor'); + suggestions.add('type:measurement'); + } + if (deviceName.toLowerCase().includes('controller')) { + suggestions.add('equipment:controller'); + suggestions.add('type:control'); + } + + // Protocol tags + suggestions.add(`protocol:${protocolType}`); + if (protocolType === 'modbus_tcp' || protocolType === 'modbus_rtu') { + suggestions.add('interface:modbus'); + } else if (protocolType === 'opcua') { + suggestions.add('interface:opcua'); + } + + // Data point tags + suggestions.add(`data_point:${dataPoint.toLowerCase().replace(/[^a-z0-9]/g, '_')}`); + + if (dataPoint.toLowerCase().includes('speed')) { + suggestions.add('unit:rpm'); + suggestions.add('type:setpoint'); + } + if (dataPoint.toLowerCase().includes('temperature')) { + suggestions.add('unit:celsius'); + suggestions.add('type:measurement'); + } + if (dataPoint.toLowerCase().includes('pressure')) { + suggestions.add('unit:psi'); + suggestions.add('type:measurement'); + } + if (dataPoint.toLowerCase().includes('status')) { + suggestions.add('type:status'); + suggestions.add('format:boolean'); + } + + // Discovery tag + suggestions.add('discovered:true'); + + return Array.from(suggestions); } - /** - * Show notification - */ showNotification(message, type = 'info') { - // Use existing notification system or create simple alert - const alertClass = { - 'success': 'alert-success', - 'error': 'alert-danger', - 'warning': 'alert-warning', - 'info': 'alert-info' - }[type] || 'alert-info'; - const notification = document.createElement('div'); - notification.className = `alert ${alertClass} alert-dismissible fade show`; - notification.innerHTML = ` - ${message} - - `; - - const container = document.getElementById('discovery-notifications') || document.body; - container.appendChild(notification); - + notification.className = `discovery-notification ${type}`; + notification.textContent = message; + + document.body.appendChild(notification); + // Auto-remove after 5 seconds setTimeout(() => { if (notification.parentNode) { @@ -402,8 +579,27 @@ class ProtocolDiscovery { } } -// Initialize discovery when DOM is loaded -document.addEventListener('DOMContentLoaded', () => { - window.protocolDiscovery = new ProtocolDiscovery(); - window.protocolDiscovery.init(); -}); \ No newline at end of file +// Global instance +// Expose to window for global access +window.SimplifiedProtocolDiscovery = SimplifiedProtocolDiscovery; + +const simplifiedDiscovery = new SimplifiedProtocolDiscovery(); +window.simplifiedDiscovery = simplifiedDiscovery; + +// Initialize when DOM is loaded +console.log('Discovery.js loaded - setting up DOMContentLoaded listener'); + +// Check if DOM is already loaded +if (document.readyState === 'loading') { + document.addEventListener('DOMContentLoaded', function() { + console.log('DOMContentLoaded event fired - Initializing SimplifiedProtocolDiscovery...'); + window.simplifiedDiscovery.init(); + console.log('SimplifiedProtocolDiscovery initialized successfully'); + }); +} else { + console.log('DOM already loaded - Initializing SimplifiedProtocolDiscovery immediately...'); + window.simplifiedDiscovery.init(); + console.log('SimplifiedProtocolDiscovery initialized successfully'); +} + +console.log('=== DISCOVERY.JS FILE LOADED - END ==='); \ No newline at end of file diff --git a/static/protocol_mapping.js b/static/protocol_mapping.js index 03b7663..0f0df50 100644 --- a/static/protocol_mapping.js +++ b/static/protocol_mapping.js @@ -1,111 +1,168 @@ -// Protocol Mapping Functions +// Simplified Protocol Mapping Functions +// Uses human-readable signal names and tags instead of complex IDs + let currentProtocolFilter = 'all'; -let editingMappingId = null; +let editingSignalId = null; +let allTags = new Set(); -function selectProtocol(protocol) { - currentProtocolFilter = protocol; - - // Update active button - document.querySelectorAll('.protocol-btn').forEach(btn => { - btn.classList.remove('active'); - }); - event.target.classList.add('active'); - - // Reload mappings with filter - loadProtocolMappings(); -} - -async function loadProtocolMappings() { +// Simplified Signal Management Functions +async function loadAllSignals() { try { - const params = new URLSearchParams(); - if (currentProtocolFilter !== 'all') { - params.append('protocol_type', currentProtocolFilter); - } - - const response = await fetch(`/api/v1/dashboard/protocol-mappings?${params}`); + const response = await fetch('/api/v1/dashboard/protocol-signals'); const data = await response.json(); if (data.success) { - displayProtocolMappings(data.mappings); + displaySignals(data.signals); + updateTagCloud(data.signals); } else { - showProtocolMappingAlert('Failed to load protocol mappings', 'error'); + showSimplifiedAlert('Failed to load signals', 'error'); } } catch (error) { - console.error('Error loading protocol mappings:', error); - showProtocolMappingAlert('Error loading protocol mappings', 'error'); + console.error('Error loading signals:', error); + showSimplifiedAlert('Error loading signals', 'error'); } } -function displayProtocolMappings(mappings) { - const tbody = document.getElementById('protocol-mappings-body'); - tbody.innerHTML = ''; +function displaySignals(signals) { + // Try both possible table body IDs + let tbody = document.getElementById('protocol-signals-body'); + if (!tbody) { + tbody = document.getElementById('protocol-mappings-body'); + } - if (mappings.length === 0) { - tbody.innerHTML = 'No protocol mappings found'; + // Check if the table body element exists + if (!tbody) { + console.warn('protocol signals/mappings table body element not found - table may not be available'); return; } - mappings.forEach(mapping => { + tbody.innerHTML = ''; + + if (signals.length === 0) { + tbody.innerHTML = 'No protocol signals found'; + return; + } + + signals.forEach(signal => { const row = document.createElement('tr'); row.innerHTML = ` - ${mapping.id} - ${mapping.protocol_type} - ${mapping.station_id || '-'} - ${mapping.pump_id || '-'} - ${mapping.data_type} - ${mapping.protocol_address} - ${mapping.db_source} + ${signal.signal_name} + ${signal.protocol_type} - - + ${signal.tags.map(tag => `${tag}`).join('')} + + ${signal.protocol_address} + ${signal.db_source} + + + ${signal.enabled ? 'Enabled' : 'Disabled'} + + + + + `; tbody.appendChild(row); }); } -function showAddMappingModal() { - editingMappingId = null; - document.getElementById('modal-title').textContent = 'Add Protocol Mapping'; - document.getElementById('mapping-form').reset(); - document.getElementById('protocol_address_help').textContent = ''; - document.getElementById('mapping-modal').style.display = 'block'; +function updateTagCloud(signals) { + const tagCloud = document.getElementById('tag-cloud'); + if (!tagCloud) return; + + // Collect all tags + const tagCounts = {}; + signals.forEach(signal => { + signal.tags.forEach(tag => { + tagCounts[tag] = (tagCounts[tag] || 0) + 1; + }); + }); + + // Create tag cloud + tagCloud.innerHTML = ''; + Object.entries(tagCounts).forEach(([tag, count]) => { + const tagElement = document.createElement('span'); + tagElement.className = 'tag-cloud-item'; + tagElement.textContent = tag; + tagElement.title = `${count} signal(s)`; + tagElement.onclick = () => filterByTag(tag); + tagCloud.appendChild(tagElement); + }); } -function showEditMappingModal(mapping) { - editingMappingId = mapping.id; - document.getElementById('modal-title').textContent = 'Edit Protocol Mapping'; - document.getElementById('mapping_id').value = mapping.id; - document.getElementById('protocol_type').value = mapping.protocol_type; - document.getElementById('station_id').value = mapping.station_id || ''; - document.getElementById('pump_id').value = mapping.pump_id || ''; - document.getElementById('data_type').value = mapping.data_type; - document.getElementById('protocol_address').value = mapping.protocol_address; - document.getElementById('db_source').value = mapping.db_source; +function filterByTag(tag) { + const filterInput = document.getElementById('tag-filter'); + if (filterInput) { + filterInput.value = tag; + applyFilters(); + } +} + +async function applyFilters() { + const tagFilter = document.getElementById('tag-filter')?.value || ''; + const protocolFilter = document.getElementById('protocol-filter')?.value || 'all'; + const nameFilter = document.getElementById('name-filter')?.value || ''; + + const params = new URLSearchParams(); + if (tagFilter) params.append('tags', tagFilter); + if (protocolFilter !== 'all') params.append('protocol_type', protocolFilter); + if (nameFilter) params.append('signal_name_contains', nameFilter); + + try { + const response = await fetch(`/api/v1/dashboard/protocol-signals?${params}`); + const data = await response.json(); + + if (data.success) { + displaySignals(data.signals); + } + } catch (error) { + console.error('Error applying filters:', error); + } +} + +// Modal Functions +function showAddSignalModal() { + editingSignalId = null; + document.getElementById('modal-title').textContent = 'Add Protocol Signal'; + document.getElementById('signal-form').reset(); + document.getElementById('protocol-address-help').textContent = ''; + document.getElementById('signal-modal').style.display = 'block'; +} + +function showEditSignalModal(signal) { + editingSignalId = signal.signal_id; + document.getElementById('modal-title').textContent = 'Edit Protocol Signal'; + + // Populate form + document.getElementById('signal_name').value = signal.signal_name; + document.getElementById('tags').value = signal.tags.join(', '); + document.getElementById('protocol_type').value = signal.protocol_type; + document.getElementById('protocol_address').value = signal.protocol_address; + document.getElementById('db_source').value = signal.db_source; + document.getElementById('preprocessing_enabled').checked = signal.preprocessing_enabled || false; updateProtocolFields(); - document.getElementById('mapping-modal').style.display = 'block'; + document.getElementById('signal-modal').style.display = 'block'; } -function closeMappingModal() { - document.getElementById('mapping-modal').style.display = 'none'; - editingMappingId = null; +function closeSignalModal() { + document.getElementById('signal-modal').style.display = 'none'; + editingSignalId = null; } function updateProtocolFields() { const protocolType = document.getElementById('protocol_type').value; - const helpText = document.getElementById('protocol_address_help'); + const helpText = document.getElementById('protocol-address-help'); switch (protocolType) { case 'modbus_tcp': + case 'modbus_rtu': helpText.textContent = 'Modbus address format: 40001 (holding register), 30001 (input register), 10001 (coil), 00001 (discrete input)'; break; case 'opcua': helpText.textContent = 'OPC UA NodeId format: ns=2;s=MyVariable or ns=2;i=1234'; break; - case 'modbus_rtu': - helpText.textContent = 'Modbus RTU address format: 40001 (holding register), 30001 (input register), 10001 (coil), 00001 (discrete input)'; - break; case 'rest_api': helpText.textContent = 'REST API endpoint format: /api/v1/data/endpoint'; break; @@ -114,48 +171,22 @@ function updateProtocolFields() { } } -async function validateMapping() { - const formData = getMappingFormData(); - - try { - const response = await fetch(`/api/v1/dashboard/protocol-mappings/${editingMappingId || 'new'}/validate`, { - method: 'POST', - headers: { 'Content-Type': 'application/json' }, - body: JSON.stringify(formData) - }); - - const data = await response.json(); - - if (data.success) { - if (data.valid) { - showProtocolMappingAlert('Mapping validation successful!', 'success'); - } else { - showProtocolMappingAlert(`Validation failed: ${data.errors.join(', ')}`, 'error'); - } - } else { - showProtocolMappingAlert('Validation error', 'error'); - } - } catch (error) { - console.error('Error validating mapping:', error); - showProtocolMappingAlert('Error validating mapping', 'error'); - } -} - -async function saveMapping(event) { +// Form Submission +async function saveSignal(event) { event.preventDefault(); - const formData = getMappingFormData(); + const formData = getSignalFormData(); try { let response; - if (editingMappingId) { - response = await fetch(`/api/v1/dashboard/protocol-mappings/${editingMappingId}`, { + if (editingSignalId) { + response = await fetch(`/api/v1/dashboard/protocol-signals/${editingSignalId}`, { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(formData) }); } else { - response = await fetch('/api/v1/dashboard/protocol-mappings', { + response = await fetch('/api/v1/dashboard/protocol-signals', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(formData) @@ -165,76 +196,193 @@ async function saveMapping(event) { const data = await response.json(); if (data.success) { - showProtocolMappingAlert(`Protocol mapping ${editingMappingId ? 'updated' : 'created'} successfully!`, 'success'); - closeMappingModal(); - loadProtocolMappings(); + showSimplifiedAlert(`Protocol signal ${editingSignalId ? 'updated' : 'created'} successfully!`, 'success'); + closeSignalModal(); + loadAllSignals(); } else { - showProtocolMappingAlert(`Failed to save mapping: ${data.detail || 'Unknown error'}`, 'error'); + showSimplifiedAlert(`Failed to save signal: ${data.detail || 'Unknown error'}`, 'error'); } } catch (error) { - console.error('Error saving mapping:', error); - showProtocolMappingAlert('Error saving mapping', 'error'); + console.error('Error saving signal:', error); + showSimplifiedAlert('Error saving signal', 'error'); } } -function getMappingFormData() { +function getSignalFormData() { + const tagsInput = document.getElementById('tags').value; + const tags = tagsInput.split(',').map(tag => tag.trim()).filter(tag => tag); + return { + signal_name: document.getElementById('signal_name').value, + tags: tags, protocol_type: document.getElementById('protocol_type').value, - station_id: document.getElementById('station_id').value, - pump_id: document.getElementById('pump_id').value, - data_type: document.getElementById('data_type').value, protocol_address: document.getElementById('protocol_address').value, - db_source: document.getElementById('db_source').value + db_source: document.getElementById('db_source').value, + preprocessing_enabled: document.getElementById('preprocessing_enabled').checked }; } -async function editMapping(mappingId) { +// Signal Management +async function editSignal(signalId) { try { - const response = await fetch(`/api/v1/dashboard/protocol-mappings?protocol_type=all`); + const response = await fetch(`/api/v1/dashboard/protocol-signals/${signalId}`); const data = await response.json(); if (data.success) { - const mapping = data.mappings.find(m => m.id === mappingId); - if (mapping) { - showEditMappingModal(mapping); - } else { - showProtocolMappingAlert('Mapping not found', 'error'); - } + showEditSignalModal(data.signal); } else { - showProtocolMappingAlert('Failed to load mapping', 'error'); + showSimplifiedAlert('Signal not found', 'error'); } } catch (error) { - console.error('Error loading mapping:', error); - showProtocolMappingAlert('Error loading mapping', 'error'); + console.error('Error loading signal:', error); + showSimplifiedAlert('Error loading signal', 'error'); } } -async function deleteMapping(mappingId) { - if (!confirm(`Are you sure you want to delete mapping ${mappingId}?`)) { +async function deleteSignal(signalId) { + if (!confirm('Are you sure you want to delete this signal?')) { return; } try { - const response = await fetch(`/api/v1/dashboard/protocol-mappings/${mappingId}`, { + const response = await fetch(`/api/v1/dashboard/protocol-signals/${signalId}`, { method: 'DELETE' }); const data = await response.json(); if (data.success) { - showProtocolMappingAlert('Mapping deleted successfully!', 'success'); - loadProtocolMappings(); + showSimplifiedAlert('Signal deleted successfully!', 'success'); + loadAllSignals(); } else { - showProtocolMappingAlert(`Failed to delete mapping: ${data.detail || 'Unknown error'}`, 'error'); + showSimplifiedAlert(`Failed to delete signal: ${data.detail || 'Unknown error'}`, 'error'); } } catch (error) { - console.error('Error deleting mapping:', error); - showProtocolMappingAlert('Error deleting mapping', 'error'); + console.error('Error deleting signal:', error); + showSimplifiedAlert('Error deleting signal', 'error'); } } -function showProtocolMappingAlert(message, type) { +// Discovery Integration +function autoPopulateSignalForm(discoveryData) { + console.log('Auto-populating signal form with:', discoveryData); + + // First, open the "Add New Signal" modal + console.log('Opening Add Signal modal...'); + showAddSignalModal(); + + // Wait for modal to be fully loaded and visible + const waitForModal = setInterval(() => { + const modal = document.getElementById('signal-modal'); + const isModalVisible = modal && modal.style.display !== 'none'; + + if (isModalVisible) { + clearInterval(waitForModal); + populateModalFields(discoveryData); + } + }, 50); + + // Timeout after 2 seconds + setTimeout(() => { + clearInterval(waitForModal); + const modal = document.getElementById('signal-modal'); + if (modal && modal.style.display !== 'none') { + populateModalFields(discoveryData); + } else { + console.error('Modal did not open within timeout period'); + showSimplifiedAlert('Could not open signal form. Please try opening it manually.', 'error'); + } + }, 2000); +} + +function populateModalFields(discoveryData) { + console.log('Populating modal fields with:', discoveryData); + + // Try to find the appropriate form + let form = document.getElementById('signal-form'); + let modal = document.getElementById('signal-modal'); + + if (!form) { + form = document.getElementById('mapping-form'); + modal = document.getElementById('mapping-modal'); + } + + if (!form || !modal) { + console.warn('No signal or mapping form found - cannot auto-populate'); + showSimplifiedAlert('No signal form found - please open the add signal/mapping modal first', 'error'); + return; + } + + // Show the modal if it's hidden + if (modal.style.display === 'none') { + modal.style.display = 'block'; + console.log('✓ Opened modal'); + } + + // Find fields within the modal context to avoid duplicate ID issues + const modalContent = modal.querySelector('.modal-content'); + + // Debug: Check if fields exist + console.log('Available fields in modal:'); + console.log('- protocol_type:', modalContent.querySelector('#protocol_type')); + console.log('- mapping_protocol_type:', modalContent.querySelector('#mapping_protocol_type')); + console.log('- protocol_address:', modalContent.querySelector('#protocol_address')); + console.log('- db_source:', modalContent.querySelector('#db_source')); + + // Populate signal name (try different field names) + const signalNameField = modalContent.querySelector('#signal_name') || modalContent.querySelector('#mapping_id'); + if (signalNameField && discoveryData.signal_name) { + signalNameField.value = discoveryData.signal_name; + console.log('✓ Set signal name to:', discoveryData.signal_name); + } + + // Populate tags (only in simplified template) + const tagsField = modalContent.querySelector('#tags'); + if (tagsField && discoveryData.tags) { + tagsField.value = discoveryData.tags.join(', '); + console.log('✓ Set tags to:', discoveryData.tags); + } + + // Populate protocol type - try both possible IDs + let protocolTypeField = modalContent.querySelector('#protocol_type'); + if (!protocolTypeField) { + protocolTypeField = modalContent.querySelector('#mapping_protocol_type'); + } + if (protocolTypeField && discoveryData.protocol_type) { + protocolTypeField.value = discoveryData.protocol_type; + console.log('✓ Set protocol_type to:', discoveryData.protocol_type); + // Trigger protocol field updates + protocolTypeField.dispatchEvent(new Event('change')); + } + + // Populate protocol address + const protocolAddressField = modalContent.querySelector('#protocol_address'); + if (protocolAddressField && discoveryData.protocol_address) { + protocolAddressField.value = discoveryData.protocol_address; + console.log('✓ Set protocol_address to:', discoveryData.protocol_address); + } + + // Populate database source + const dbSourceField = modalContent.querySelector('#db_source'); + if (dbSourceField && discoveryData.db_source) { + dbSourceField.value = discoveryData.db_source; + console.log('✓ Set db_source to:', discoveryData.db_source); + } + + // Show success message + showSimplifiedAlert(`Signal form populated with discovery data. Please review and save.`, 'success'); +} + +// Utility Functions +function showSimplifiedAlert(message, type = 'info') { const alertsDiv = document.getElementById('protocol-mapping-alerts'); + + // Check if alerts div exists + if (!alertsDiv) { + console.warn('protocol-mapping-alerts element not found - cannot show alert:', message); + return; + } + const alertDiv = document.createElement('div'); alertDiv.className = `alert ${type === 'error' ? 'error' : 'success'}`; alertDiv.textContent = message; @@ -242,57 +390,34 @@ function showProtocolMappingAlert(message, type) { alertsDiv.innerHTML = ''; alertsDiv.appendChild(alertDiv); + // Auto-remove after 5 seconds setTimeout(() => { - alertDiv.remove(); + if (alertDiv.parentNode) { + alertDiv.remove(); + } }, 5000); } -async function exportProtocolMappings() { - try { - const response = await fetch('/api/v1/dashboard/protocol-mappings?protocol_type=all'); - const data = await response.json(); - - if (data.success) { - const csvContent = convertToCSV(data.mappings); - downloadCSV(csvContent, 'protocol_mappings.csv'); - } else { - showProtocolMappingAlert('Failed to export mappings', 'error'); - } - } catch (error) { - console.error('Error exporting mappings:', error); - showProtocolMappingAlert('Error exporting mappings', 'error'); - } -} - -function convertToCSV(mappings) { - const headers = ['ID', 'Protocol', 'Station', 'Pump', 'Data Type', 'Protocol Address', 'Database Source']; - const rows = mappings.map(mapping => [ - mapping.id, - mapping.protocol_type, - mapping.station_id || '', - mapping.pump_id || '', - mapping.data_type, - mapping.protocol_address, - mapping.db_source - ]); - - return [headers, ...rows].map(row => row.map(field => `"${field}"`).join(',')).join('\n'); -} - -function downloadCSV(content, filename) { - const blob = new Blob([content], { type: 'text/csv' }); - const url = window.URL.createObjectURL(blob); - const a = document.createElement('a'); - a.href = url; - a.download = filename; - a.click(); - window.URL.revokeObjectURL(url); -} - -// Initialize form submission handler +// Initialize document.addEventListener('DOMContentLoaded', function() { - const mappingForm = document.getElementById('mapping-form'); - if (mappingForm) { - mappingForm.addEventListener('submit', saveMapping); + // Try both possible form IDs + let signalForm = document.getElementById('signal-form'); + if (!signalForm) { + // Look for form inside mapping-modal + const mappingModal = document.getElementById('mapping-modal'); + if (mappingModal) { + signalForm = mappingModal.querySelector('form'); + } } -}); \ No newline at end of file + + if (signalForm) { + signalForm.addEventListener('submit', saveSignal); + } + + // Load initial data + loadAllSignals(); +}); + +// Expose functions to global scope for discovery integration +window.autoPopulateSignalForm = populateModalFields; +window.loadAllSignals = loadAllSignals; \ No newline at end of file diff --git a/static/simplified_discovery.js b/static/simplified_discovery.js new file mode 100644 index 0000000..43fc20f --- /dev/null +++ b/static/simplified_discovery.js @@ -0,0 +1,352 @@ +// Simplified Discovery Integration +// Updated for simplified signal names + tags architecture + +class SimplifiedProtocolDiscovery { + constructor() { + this.currentScanId = 'simplified-scan-123'; + this.isScanning = false; + } + + init() { + this.bindDiscoveryEvents(); + } + + bindDiscoveryEvents() { + // Auto-fill signal form from discovery + document.addEventListener('click', (e) => { + if (e.target.classList.contains('use-discovered-endpoint')) { + this.useDiscoveredEndpoint(e.target.dataset.endpointId); + } + }); + } + + async useDiscoveredEndpoint(endpointId) { + console.log('Using discovered endpoint:', endpointId); + + // Mock endpoint data (in real implementation, this would come from discovery service) + const endpoints = { + 'device_001': { + device_id: 'device_001', + protocol_type: 'modbus_tcp', + device_name: 'Water Pump Controller', + address: '192.168.1.100', + port: 502, + data_point: 'Speed', + protocol_address: '40001' + }, + 'device_002': { + device_id: 'device_002', + protocol_type: 'opcua', + device_name: 'Temperature Sensor', + address: '192.168.1.101', + port: 4840, + data_point: 'Temperature', + protocol_address: 'ns=2;s=Temperature' + }, + 'device_003': { + device_id: 'device_003', + protocol_type: 'modbus_tcp', + device_name: 'Pressure Transmitter', + address: '192.168.1.102', + port: 502, + data_point: 'Pressure', + protocol_address: '30001' + } + }; + + const endpoint = endpoints[endpointId]; + if (!endpoint) { + this.showNotification(`Endpoint ${endpointId} not found`, 'error'); + return; + } + + // Convert to simplified signal format + const signalData = this.convertEndpointToSignal(endpoint); + + // Auto-populate the signal form + this.autoPopulateSignalForm(signalData); + + this.showNotification(`Endpoint ${endpoint.device_name} selected for signal creation`, 'success'); + } + + convertEndpointToSignal(endpoint) { + // Generate human-readable signal name + const signalName = `${endpoint.device_name} ${endpoint.data_point}`; + + // Generate meaningful tags + const tags = [ + `device:${endpoint.device_name.toLowerCase().replace(/[^a-z0-9]/g, '_')}`, + `protocol:${endpoint.protocol_type}`, + `data_point:${endpoint.data_point.toLowerCase().replace(/[^a-z0-9]/g, '_')}`, + 'discovered:true' + ]; + + // Add device-specific tags + if (endpoint.device_name.toLowerCase().includes('pump')) { + tags.push('equipment:pump'); + } + if (endpoint.device_name.toLowerCase().includes('sensor')) { + tags.push('equipment:sensor'); + } + if (endpoint.device_name.toLowerCase().includes('controller')) { + tags.push('equipment:controller'); + } + + // Add protocol-specific tags + if (endpoint.protocol_type === 'modbus_tcp') { + tags.push('interface:modbus'); + } else if (endpoint.protocol_type === 'opcua') { + tags.push('interface:opcua'); + } + + // Generate database source + const dbSource = `measurements.${endpoint.device_name.toLowerCase().replace(/[^a-z0-9]/g, '_')}_${endpoint.data_point.toLowerCase().replace(/[^a-z0-9]/g, '_')}`; + + return { + signal_name: signalName, + tags: tags, + protocol_type: endpoint.protocol_type, + protocol_address: endpoint.protocol_address, + db_source: dbSource + }; + } + + autoPopulateSignalForm(signalData) { + console.log('Auto-populating signal form with:', signalData); + + // Use the simplified protocol mapping function + if (typeof autoPopulateSignalForm === 'function') { + autoPopulateSignalForm(signalData); + } else { + console.error('Simplified protocol mapping functions not loaded'); + this.showNotification('Protocol mapping system not available', 'error'); + } + } + + // Advanced discovery features + async discoverAndSuggestSignals(networkRange = '192.168.1.0/24') { + console.log(`Starting discovery scan on ${networkRange}`); + this.isScanning = true; + + try { + // Mock discovery results + const discoveredEndpoints = await this.mockDiscoveryScan(networkRange); + + // Convert to suggested signals + const suggestedSignals = discoveredEndpoints.map(endpoint => + this.convertEndpointToSignal(endpoint) + ); + + this.displayDiscoveryResults(suggestedSignals); + this.isScanning = false; + + return suggestedSignals; + + } catch (error) { + console.error('Discovery scan failed:', error); + this.showNotification('Discovery scan failed', 'error'); + this.isScanning = false; + return []; + } + } + + async mockDiscoveryScan(networkRange) { + // Simulate network discovery delay + await new Promise(resolve => setTimeout(resolve, 2000)); + + // Return mock discovered endpoints + return [ + { + device_id: 'discovered_001', + protocol_type: 'modbus_tcp', + device_name: 'Booster Pump', + address: '192.168.1.110', + port: 502, + data_point: 'Flow Rate', + protocol_address: '30002' + }, + { + device_id: 'discovered_002', + protocol_type: 'modbus_tcp', + device_name: 'Level Sensor', + address: '192.168.1.111', + port: 502, + data_point: 'Tank Level', + protocol_address: '30003' + }, + { + device_id: 'discovered_003', + protocol_type: 'opcua', + device_name: 'PLC Controller', + address: '192.168.1.112', + port: 4840, + data_point: 'System Status', + protocol_address: 'ns=2;s=SystemStatus' + } + ]; + } + + displayDiscoveryResults(suggestedSignals) { + const resultsContainer = document.getElementById('discovery-results'); + if (!resultsContainer) return; + + resultsContainer.innerHTML = '

Discovery Results

'; + + suggestedSignals.forEach((signal, index) => { + const signalCard = document.createElement('div'); + signalCard.className = 'discovery-result-card'; + signalCard.innerHTML = ` +
+ ${signal.signal_name} +
+ ${signal.tags.map(tag => `${tag}`).join('')} +
+
+ Protocol: ${signal.protocol_type} + Address: ${signal.protocol_address} +
+
+ + `; + + resultsContainer.appendChild(signalCard); + }); + + // Add event listeners for use buttons + resultsContainer.addEventListener('click', (e) => { + if (e.target.classList.contains('use-signal-btn')) { + const signalIndex = parseInt(e.target.dataset.signalIndex); + const signal = suggestedSignals[signalIndex]; + this.autoPopulateSignalForm(signal); + } + }); + } + + // Tag-based signal search + async searchSignalsByTags(tags) { + try { + const params = new URLSearchParams(); + tags.forEach(tag => params.append('tags', tag)); + + const response = await fetch(`/api/v1/dashboard/protocol-signals?${params}`); + const data = await response.json(); + + if (data.success) { + return data.signals; + } else { + console.error('Failed to search signals by tags:', data.detail); + return []; + } + } catch (error) { + console.error('Error searching signals by tags:', error); + return []; + } + } + + // Signal name suggestions based on device type + generateSignalNameSuggestions(deviceName, dataPoint) { + const baseName = `${deviceName} ${dataPoint}`; + + const suggestions = [ + baseName, + `${dataPoint} of ${deviceName}`, + `${deviceName} ${dataPoint} Reading`, + `${dataPoint} Measurement - ${deviceName}` + ]; + + // Add context-specific suggestions + if (dataPoint.toLowerCase().includes('speed')) { + suggestions.push(`${deviceName} Motor Speed`); + suggestions.push(`${deviceName} RPM`); + } + + if (dataPoint.toLowerCase().includes('temperature')) { + suggestions.push(`${deviceName} Temperature`); + suggestions.push(`Temperature at ${deviceName}`); + } + + if (dataPoint.toLowerCase().includes('pressure')) { + suggestions.push(`${deviceName} Pressure`); + suggestions.push(`Pressure Reading - ${deviceName}`); + } + + return suggestions; + } + + // Tag suggestions based on device and protocol + generateTagSuggestions(deviceName, protocolType, dataPoint) { + const suggestions = new Set(); + + // Device type tags + if (deviceName.toLowerCase().includes('pump')) { + suggestions.add('equipment:pump'); + suggestions.add('fluid:water'); + } + if (deviceName.toLowerCase().includes('sensor')) { + suggestions.add('equipment:sensor'); + suggestions.add('type:measurement'); + } + if (deviceName.toLowerCase().includes('controller')) { + suggestions.add('equipment:controller'); + suggestions.add('type:control'); + } + + // Protocol tags + suggestions.add(`protocol:${protocolType}`); + if (protocolType === 'modbus_tcp' || protocolType === 'modbus_rtu') { + suggestions.add('interface:modbus'); + } else if (protocolType === 'opcua') { + suggestions.add('interface:opcua'); + } + + // Data point tags + suggestions.add(`data_point:${dataPoint.toLowerCase().replace(/[^a-z0-9]/g, '_')}`); + + if (dataPoint.toLowerCase().includes('speed')) { + suggestions.add('unit:rpm'); + suggestions.add('type:setpoint'); + } + if (dataPoint.toLowerCase().includes('temperature')) { + suggestions.add('unit:celsius'); + suggestions.add('type:measurement'); + } + if (dataPoint.toLowerCase().includes('pressure')) { + suggestions.add('unit:psi'); + suggestions.add('type:measurement'); + } + if (dataPoint.toLowerCase().includes('status')) { + suggestions.add('type:status'); + suggestions.add('format:boolean'); + } + + // Discovery tag + suggestions.add('discovered:true'); + + return Array.from(suggestions); + } + + showNotification(message, type = 'info') { + const notification = document.createElement('div'); + notification.className = `discovery-notification ${type}`; + notification.textContent = message; + + document.body.appendChild(notification); + + // Auto-remove after 5 seconds + setTimeout(() => { + if (notification.parentNode) { + notification.remove(); + } + }, 5000); + } +} + +// Global instance +const simplifiedDiscovery = new SimplifiedProtocolDiscovery(); + +// Initialize when DOM is loaded +document.addEventListener('DOMContentLoaded', function() { + simplifiedDiscovery.init(); +}); \ No newline at end of file diff --git a/static/simplified_protocol_mapping.js b/static/simplified_protocol_mapping.js new file mode 100644 index 0000000..dd6ba1f --- /dev/null +++ b/static/simplified_protocol_mapping.js @@ -0,0 +1,393 @@ +// Simplified Protocol Mapping Functions +// Uses human-readable signal names and tags instead of complex IDs + +(function() { + 'use strict'; + + // Check if global variables already exist before declaring + if (typeof window.currentProtocolFilter === 'undefined') { + window.currentProtocolFilter = 'all'; + } + if (typeof window.editingSignalId === 'undefined') { + window.editingSignalId = null; + } + if (typeof window.allTags === 'undefined') { + window.allTags = new Set(); + } + + // Use window object variables directly to avoid redeclaration conflicts + +// Simplified Signal Management Functions +async function loadAllSignals() { + try { + const response = await fetch('/api/v1/dashboard/protocol-signals'); + const data = await response.json(); + + if (data.success) { + displaySignals(data.signals); + updateTagCloud(data.signals); + } else { + showSimplifiedAlert('Failed to load signals', 'error'); + } + } catch (error) { + console.error('Error loading signals:', error); + showSimplifiedAlert('Error loading signals', 'error'); + } +} + +function displaySignals(signals) { + const tbody = document.getElementById('protocol-signals-body'); + tbody.innerHTML = ''; + + if (signals.length === 0) { + tbody.innerHTML = 'No protocol signals found'; + return; + } + + signals.forEach(signal => { + const row = document.createElement('tr'); + row.innerHTML = ` + ${signal.signal_name} + ${signal.protocol_type} + + ${signal.tags.map(tag => `${tag}`).join('')} + + ${signal.protocol_address} + ${signal.db_source} + + + ${signal.enabled ? 'Enabled' : 'Disabled'} + + + + + + + `; + tbody.appendChild(row); + }); +} + +function updateTagCloud(signals) { + const tagCloud = document.getElementById('tag-cloud'); + if (!tagCloud) return; + + // Collect all tags + const tagCounts = {}; + signals.forEach(signal => { + signal.tags.forEach(tag => { + tagCounts[tag] = (tagCounts[tag] || 0) + 1; + }); + }); + + // Create tag cloud + tagCloud.innerHTML = ''; + Object.entries(tagCounts).forEach(([tag, count]) => { + const tagElement = document.createElement('span'); + tagElement.className = 'tag-cloud-item'; + tagElement.textContent = tag; + tagElement.title = `${count} signal(s)`; + tagElement.onclick = () => filterByTag(tag); + tagCloud.appendChild(tagElement); + }); +} + +function filterByTag(tag) { + const filterInput = document.getElementById('tag-filter'); + if (filterInput) { + filterInput.value = tag; + applyFilters(); + } +} + +async function applyFilters() { + const tagFilter = document.getElementById('tag-filter')?.value || ''; + const protocolFilter = document.getElementById('protocol-filter')?.value || 'all'; + const nameFilter = document.getElementById('name-filter')?.value || ''; + + const params = new URLSearchParams(); + if (tagFilter) params.append('tags', tagFilter); + if (protocolFilter !== 'all') params.append('protocol_type', protocolFilter); + if (nameFilter) params.append('signal_name_contains', nameFilter); + + try { + const response = await fetch(`/api/v1/dashboard/protocol-signals?${params}`); + const data = await response.json(); + + if (data.success) { + displaySignals(data.signals); + } + } catch (error) { + console.error('Error applying filters:', error); + } +} + +// Modal Functions +function showAddSignalModal() { + window.editingSignalId = null; + + // Safely update modal elements if they exist + const modalTitle = document.getElementById('modal-title'); + if (modalTitle) { + modalTitle.textContent = 'Add Protocol Signal'; + } + + const signalForm = document.getElementById('signal-form'); + if (signalForm) { + signalForm.reset(); + } + + const protocolAddressHelp = document.getElementById('protocol-address-help'); + if (protocolAddressHelp) { + protocolAddressHelp.textContent = ''; + } + + const signalModal = document.getElementById('signal-modal'); + if (signalModal) { + signalModal.style.display = 'block'; + } +} + +function showEditSignalModal(signal) { + window.editingSignalId = signal.signal_id; + document.getElementById('modal-title').textContent = 'Edit Protocol Signal'; + + // Populate form + document.getElementById('signal_name').value = signal.signal_name; + document.getElementById('tags').value = signal.tags.join(', '); + document.getElementById('protocol_type').value = signal.protocol_type; + document.getElementById('protocol_address').value = signal.protocol_address; + document.getElementById('db_source').value = signal.db_source; + document.getElementById('preprocessing_enabled').checked = signal.preprocessing_enabled || false; + + updateProtocolFields(); + document.getElementById('signal-modal').style.display = 'block'; +} + +function closeSignalModal() { + document.getElementById('signal-modal').style.display = 'none'; + window.editingSignalId = null; +} + +function updateProtocolFields() { + const protocolType = document.getElementById('protocol_type').value; + const helpText = document.getElementById('protocol-address-help'); + + switch (protocolType) { + case 'modbus_tcp': + case 'modbus_rtu': + helpText.textContent = 'Modbus address format: 40001 (holding register), 30001 (input register), 10001 (coil), 00001 (discrete input)'; + break; + case 'opcua': + helpText.textContent = 'OPC UA NodeId format: ns=2;s=MyVariable or ns=2;i=1234'; + break; + case 'rest_api': + helpText.textContent = 'REST API endpoint format: /api/v1/data/endpoint'; + break; + default: + helpText.textContent = ''; + } +} + +// Form Submission +async function saveSignal(event) { + event.preventDefault(); + + const formData = getSignalFormData(); + + try { + let response; + if (window.editingSignalId) { + response = await fetch(`/api/v1/dashboard/protocol-signals/${window.editingSignalId}`, { + method: 'PUT', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify(formData) + }); + } else { + response = await fetch('/api/v1/dashboard/protocol-signals', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify(formData) + }); + } + + const data = await response.json(); + + if (data.success) { + showSimplifiedAlert(`Protocol signal ${window.editingSignalId ? 'updated' : 'created'} successfully!`, 'success'); + closeSignalModal(); + loadAllSignals(); + } else { + showSimplifiedAlert(`Failed to save signal: ${data.detail || 'Unknown error'}`, 'error'); + } + } catch (error) { + console.error('Error saving signal:', error); + showSimplifiedAlert('Error saving signal', 'error'); + } +} + +function getSignalFormData() { + const tagsInput = document.getElementById('tags').value; + const tags = tagsInput.split(',').map(tag => tag.trim()).filter(tag => tag); + + return { + signal_name: document.getElementById('signal_name').value, + tags: tags, + protocol_type: document.getElementById('protocol_type').value, + protocol_address: document.getElementById('protocol_address').value, + db_source: document.getElementById('db_source').value, + preprocessing_enabled: document.getElementById('preprocessing_enabled').checked + }; +} + +// Signal Management +async function editSignal(signalId) { + try { + const response = await fetch(`/api/v1/dashboard/protocol-signals/${signalId}`); + const data = await response.json(); + + if (data.success) { + showEditSignalModal(data.signal); + } else { + showSimplifiedAlert('Signal not found', 'error'); + } + } catch (error) { + console.error('Error loading signal:', error); + showSimplifiedAlert('Error loading signal', 'error'); + } +} + +async function deleteSignal(signalId) { + if (!confirm('Are you sure you want to delete this signal?')) { + return; + } + + try { + const response = await fetch(`/api/v1/dashboard/protocol-signals/${signalId}`, { + method: 'DELETE' + }); + + const data = await response.json(); + + if (data.success) { + showSimplifiedAlert('Signal deleted successfully!', 'success'); + loadAllSignals(); + } else { + showSimplifiedAlert(`Failed to delete signal: ${data.detail || 'Unknown error'}`, 'error'); + } + } catch (error) { + console.error('Error deleting signal:', error); + showSimplifiedAlert('Error deleting signal', 'error'); + } +} + +// Discovery Integration +function autoPopulateSignalForm(discoveryData) { + console.log('Auto-populating signal form with:', discoveryData); + + // First, open the "Add New Signal" modal + showAddSignalModal(); + + // Use a simpler approach - just populate after a short delay + // This avoids complex timeout logic that can be unreliable + setTimeout(() => { + const modal = document.getElementById('signal-modal'); + if (modal && modal.style.display !== 'none') { + console.log('Modal is visible, populating fields...'); + populateModalFields(discoveryData); + } else { + console.log('Modal not immediately visible, trying again...'); + // Try one more time after another short delay + setTimeout(() => { + populateModalFields(discoveryData); + }, 100); + } + }, 100); +} + +function populateModalFields(discoveryData) { + console.log('Populating modal fields with:', discoveryData); + + // Populate signal name + const signalNameField = document.getElementById('signal_name'); + if (signalNameField && discoveryData.signal_name) { + signalNameField.value = discoveryData.signal_name; + console.log('✓ Set signal_name to:', discoveryData.signal_name); + } + + // Populate tags + const tagsField = document.getElementById('tags'); + if (tagsField && discoveryData.tags) { + tagsField.value = discoveryData.tags.join(', '); + console.log('✓ Set tags to:', discoveryData.tags); + } + + // Populate protocol type + const protocolTypeField = document.getElementById('protocol_type'); + if (protocolTypeField && discoveryData.protocol_type) { + protocolTypeField.value = discoveryData.protocol_type; + console.log('✓ Set protocol_type to:', discoveryData.protocol_type); + // Trigger protocol field updates + protocolTypeField.dispatchEvent(new Event('change')); + } + + // Populate protocol address + const protocolAddressField = document.getElementById('protocol_address'); + if (protocolAddressField && discoveryData.protocol_address) { + protocolAddressField.value = discoveryData.protocol_address; + console.log('✓ Set protocol_address to:', discoveryData.protocol_address); + } + + // Populate database source + const dbSourceField = document.getElementById('db_source'); + if (dbSourceField && discoveryData.db_source) { + dbSourceField.value = discoveryData.db_source; + console.log('✓ Set db_source to:', discoveryData.db_source); + } + + // Show success message + showSimplifiedAlert(`Signal form populated with discovery data. Please review and save.`, 'success'); +} + +// Utility Functions +function showSimplifiedAlert(message, type = 'info') { + const alertsDiv = document.getElementById('simplified-alerts'); + + // Only proceed if the alerts container exists + if (!alertsDiv) { + console.log(`Alert (${type}): ${message}`); + return; + } + + const alertDiv = document.createElement('div'); + alertDiv.className = `alert ${type === 'error' ? 'error' : 'success'}`; + alertDiv.textContent = message; + + alertsDiv.innerHTML = ''; + alertsDiv.appendChild(alertDiv); + + // Auto-remove after 5 seconds + setTimeout(() => { + if (alertDiv.parentNode) { + alertDiv.remove(); + } + }, 5000); +} + + // Initialize + document.addEventListener('DOMContentLoaded', function() { + const signalForm = document.getElementById('signal-form'); + if (signalForm) { + signalForm.addEventListener('submit', saveSignal); + } + + // Load initial data + loadAllSignals(); + }); + + // Expose functions to window for discovery integration + window.autoPopulateSignalForm = autoPopulateSignalForm; + window.showAddSignalModal = showAddSignalModal; + window.applyFilters = applyFilters; + window.closeSignalModal = closeSignalModal; +})(); \ No newline at end of file diff --git a/static/simplified_styles.css b/static/simplified_styles.css new file mode 100644 index 0000000..070d948 --- /dev/null +++ b/static/simplified_styles.css @@ -0,0 +1,444 @@ +* { + margin: 0; + padding: 0; + box-sizing: border-box; +} + +body { + font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; + background-color: #f5f7fa; + color: #333; + line-height: 1.6; +} + +.container { + max-width: 1200px; + margin: 0 auto; + padding: 20px; +} + +.header { + background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); + color: white; + padding: 30px 0; + border-radius: 10px; + margin-bottom: 30px; + text-align: center; +} + +.header h1 { + font-size: 2.5rem; + margin-bottom: 10px; +} + +.header p { + font-size: 1.1rem; + opacity: 0.9; +} + +.controls { + background: white; + padding: 25px; + border-radius: 10px; + box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); + margin-bottom: 30px; +} + +.filter-section { + display: grid; + grid-template-columns: 1fr 1fr 1fr auto; + gap: 15px; + align-items: end; +} + +.filter-group { + display: flex; + flex-direction: column; +} + +.filter-group label { + font-weight: 600; + margin-bottom: 5px; + color: #555; +} + +.filter-group input, .filter-group select { + padding: 10px; + border: 2px solid #e1e5e9; + border-radius: 6px; + font-size: 14px; + transition: border-color 0.3s; +} + +.filter-group input:focus, .filter-group select:focus { + outline: none; + border-color: #667eea; +} + +.btn { + padding: 10px 20px; + border: none; + border-radius: 6px; + cursor: pointer; + font-size: 14px; + font-weight: 600; + transition: all 0.3s; +} + +.btn-primary { + background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); + color: white; +} + +.btn-primary:hover { + transform: translateY(-2px); + box-shadow: 0 4px 8px rgba(102, 126, 234, 0.3); +} + +.btn-secondary { + background: #6c757d; + color: white; +} + +.btn-secondary:hover { + background: #5a6268; +} + +.tag-cloud { + background: white; + padding: 20px; + border-radius: 10px; + box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); + margin-bottom: 30px; +} + +.tag-cloud h3 { + margin-bottom: 15px; + color: #333; +} + +.tag-cloud-item { + display: inline-block; + background: #e9ecef; + padding: 5px 12px; + margin: 5px; + border-radius: 20px; + font-size: 12px; + cursor: pointer; + transition: all 0.3s; +} + +.tag-cloud-item:hover { + background: #667eea; + color: white; + transform: scale(1.05); +} + +.signals-table { + background: white; + border-radius: 10px; + box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); + overflow: hidden; +} + +.table-header { + background: #f8f9fa; + padding: 20px; + border-bottom: 1px solid #e1e5e9; + display: flex; + justify-content: space-between; + align-items: center; +} + +.table-header h3 { + color: #333; +} + +table { + width: 100%; + border-collapse: collapse; + table-layout: fixed; +} + +th, td { + padding: 12px 8px; + text-align: left; + border-bottom: 1px solid #e1e5e9; + word-wrap: break-word; + overflow-wrap: break-word; + vertical-align: top; +} + +/* Set specific column widths to prevent overflow */ +th:nth-child(1), td:nth-child(1) { /* Signal Name */ + width: 20%; + min-width: 120px; +} + +th:nth-child(2), td:nth-child(2) { /* Protocol Type */ + width: 12%; + min-width: 100px; +} + +th:nth-child(3), td:nth-child(3) { /* Tags */ + width: 20%; + min-width: 150px; +} + +th:nth-child(4), td:nth-child(4) { /* Protocol Address */ + width: 15%; + min-width: 100px; +} + +th:nth-child(5), td:nth-child(5) { /* Database Source */ + width: 18%; + min-width: 120px; +} + +th:nth-child(6), td:nth-child(6) { /* Status */ + width: 8%; + min-width: 80px; +} + +th:nth-child(7), td:nth-child(7) { /* Actions */ + width: 7%; + min-width: 100px; +} + +th { + background: #f8f9fa; + font-weight: 600; + color: #555; + white-space: nowrap; +} + +tr:hover { + background: #f8f9fa; +} + +.tag-badge { + display: inline-block; + background: #667eea; + color: white; + padding: 3px 8px; + margin: 2px; + border-radius: 12px; + font-size: 11px; +} + +.status-badge { + padding: 5px 10px; + border-radius: 15px; + font-size: 12px; + font-weight: 600; +} + +.status-badge.enabled { + background: #d4edda; + color: #155724; +} + +.status-badge.disabled { + background: #f8d7da; + color: #721c24; +} + +.btn-edit, .btn-delete { + padding: 6px 12px; + margin: 0 2px; + border: none; + border-radius: 4px; + cursor: pointer; + font-size: 12px; +} + +.btn-edit { + background: #28a745; + color: white; +} + +.btn-delete { + background: #dc3545; + color: white; +} + +.btn-edit:hover { + background: #218838; +} + +.btn-delete:hover { + background: #c82333; +} + +.modal { + display: none; + position: fixed; + z-index: 1000; + left: 0; + top: 0; + width: 100%; + height: 100%; + background-color: rgba(0, 0, 0, 0.5); +} + +.modal-content { + background-color: white; + margin: 5% auto; + padding: 30px; + border-radius: 10px; + width: 90%; + max-width: 600px; + box-shadow: 0 10px 25px rgba(0, 0, 0, 0.2); +} + +.modal-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 20px; + padding-bottom: 15px; + border-bottom: 1px solid #e1e5e9; +} + +.modal-header h2 { + color: #333; +} + +.close { + color: #aaa; + font-size: 28px; + font-weight: bold; + cursor: pointer; +} + +.close:hover { + color: #333; +} + +.form-group { + margin-bottom: 20px; +} + +.form-group label { + display: block; + margin-bottom: 5px; + font-weight: 600; + color: #555; +} + +.form-group input, .form-group select, .form-group textarea { + width: 100%; + padding: 10px; + border: 2px solid #e1e5e9; + border-radius: 6px; + font-size: 14px; + transition: border-color 0.3s; +} + +.form-group input:focus, .form-group select:focus, .form-group textarea:focus { + outline: none; + border-color: #667eea; +} + +.form-help { + font-size: 12px; + color: #6c757d; + margin-top: 5px; +} + +.form-actions { + display: flex; + justify-content: flex-end; + gap: 10px; + margin-top: 25px; +} + +.alert { + padding: 15px; + margin: 20px 0; + border-radius: 6px; + font-weight: 500; +} + +.alert.success { + background: #d4edda; + color: #155724; + border: 1px solid #c3e6cb; +} + +.alert.error { + background: #f8d7da; + color: #721c24; + border: 1px solid #f5c6cb; +} + +.empty-state { + text-align: center; + padding: 50px 20px; + color: #6c757d; +} + +.empty-state h3 { + margin-bottom: 10px; +} + +@media (max-width: 768px) { + .filter-section { + grid-template-columns: 1fr; + } + + .table-header { + flex-direction: column; + gap: 15px; + } + + .signals-table { + overflow-x: auto; + } + + table { + font-size: 14px; + min-width: 800px; + } + + th, td { + padding: 8px 6px; + font-size: 13px; + } + + /* Adjust column widths for mobile */ + th:nth-child(1), td:nth-child(1) { /* Signal Name */ + width: 22%; + min-width: 100px; + } + + th:nth-child(2), td:nth-child(2) { /* Protocol Type */ + width: 14%; + min-width: 80px; + } + + th:nth-child(3), td:nth-child(3) { /* Tags */ + width: 18%; + min-width: 120px; + } + + th:nth-child(4), td:nth-child(4) { /* Protocol Address */ + width: 16%; + min-width: 80px; + } + + th:nth-child(5), td:nth-child(5) { /* Database Source */ + width: 16%; + min-width: 100px; + } + + th:nth-child(6), td:nth-child(6) { /* Status */ + width: 8%; + min-width: 60px; + } + + th:nth-child(7), td:nth-child(7) { /* Actions */ + width: 6%; + min-width: 80px; + } +} \ No newline at end of file diff --git a/static/test_protocol_address_debug.html b/static/test_protocol_address_debug.html new file mode 100644 index 0000000..66d252f --- /dev/null +++ b/static/test_protocol_address_debug.html @@ -0,0 +1,139 @@ + + + + Protocol Address Debug Test + + + +

Protocol Address Auto-fill Debug Test

+ +
+

Test 1: Direct Function Call

+

Test if autoPopulateSignalForm function works directly:

+ +
+
+ +
+

Test 2: Simulate "Use This Signal" Button

+

Simulate clicking a "Use This Signal" button:

+ +
+
+ +
+

Test 3: Check Modal Elements

+

Check if modal form elements exist:

+ +
+
+ +
+

Test 4: Manual Modal Population

+

Manually populate modal fields:

+ +
+
+ + + + \ No newline at end of file diff --git a/static/test_protocol_address_fix.html b/static/test_protocol_address_fix.html new file mode 100644 index 0000000..5b82ae0 --- /dev/null +++ b/static/test_protocol_address_fix.html @@ -0,0 +1,179 @@ + + + + Protocol Address Fix Test + + + +

Protocol Address Auto-fill Fix Verification

+ +
+

Test: Check for Duplicate IDs

+

Verify that there are no duplicate HTML IDs that could cause JavaScript issues:

+ +
+
+ +
+

Test: Verify Modal Elements

+

Check if the signal modal elements exist with correct IDs:

+ + +
+ +
+

Test: Simulate Discovery Integration

+

Simulate the "Use This Signal" button functionality:

+ +
+
+ + + + \ No newline at end of file diff --git a/templates/simplified_protocol_signals.html b/templates/simplified_protocol_signals.html new file mode 100644 index 0000000..6aaa909 --- /dev/null +++ b/templates/simplified_protocol_signals.html @@ -0,0 +1,159 @@ + + + + + + Calejo Control - Protocol Signals + + + +
+ +
+

Protocol Signals

+

Manage your industrial protocol signals with human-readable names and flexible tags

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

Discovery Results

+

Use discovered signals to quickly add them to your protocol mapping:

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

Popular Tags

+
+ +
+
+ + +
+
+

Protocol Signals

+ +
+ + + + + + + + + + + + + + + + +
Signal NameProtocol TypeTagsProtocol AddressDatabase SourceStatusActions
+
+
+ + + + + + + + + \ No newline at end of file diff --git a/test_api_integration.py b/test_api_integration.py new file mode 100644 index 0000000..8528086 --- /dev/null +++ b/test_api_integration.py @@ -0,0 +1,202 @@ +#!/usr/bin/env python3 +""" +Test API Integration for Simplified Protocol Signals +""" + +import sys +import os +import asyncio +import json +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from src.dashboard.simplified_models import ProtocolSignalCreate, ProtocolType +from src.dashboard.simplified_configuration_manager import simplified_configuration_manager + +async def test_api_endpoints(): + """Test the API endpoints through the configuration manager""" + print("\n=== Testing API Integration ===") + + # Test 1: Create signals + print("\n1. Creating test signals:") + test_signals = [ + { + "signal_name": "Boiler Temperature Reading", + "tags": ["equipment:boiler", "protocol:modbus_tcp", "data_point:temperature", "unit:celsius"], + "protocol_type": "modbus_tcp", + "protocol_address": "30001", + "db_source": "measurements.boiler_temperature" + }, + { + "signal_name": "Pump Motor Status", + "tags": ["equipment:pump", "protocol:opcua", "data_point:status", "type:boolean"], + "protocol_type": "opcua", + "protocol_address": "ns=2;s=PumpStatus", + "db_source": "measurements.pump_status" + }, + { + "signal_name": "System Pressure", + "tags": ["equipment:system", "protocol:modbus_tcp", "data_point:pressure", "unit:psi"], + "protocol_type": "modbus_tcp", + "protocol_address": "30002", + "db_source": "measurements.system_pressure" + } + ] + + created_signals = [] + for signal_data in test_signals: + signal_create = ProtocolSignalCreate( + signal_name=signal_data["signal_name"], + tags=signal_data["tags"], + protocol_type=ProtocolType(signal_data["protocol_type"]), + protocol_address=signal_data["protocol_address"], + db_source=signal_data["db_source"] + ) + + success = simplified_configuration_manager.add_protocol_signal(signal_create) + if success: + # Get the actual signal ID that was used + signal_id = signal_create.generate_signal_id() + signal = simplified_configuration_manager.get_protocol_signal(signal_id) + if signal: + created_signals.append(signal) + print(f" ✓ Created: {signal.signal_name}") + else: + print(f" ⚠ Created but cannot retrieve: {signal_data['signal_name']}") + else: + print(f" ✗ Failed to create: {signal_data['signal_name']}") + + # Test 2: Get all signals + print("\n2. Getting all signals:") + all_signals = simplified_configuration_manager.get_protocol_signals() + print(f" Total signals: {len(all_signals)}") + for signal in all_signals: + print(f" - {signal.signal_name} ({signal.protocol_type.value})") + + # Test 3: Filter by tags + print("\n3. Filtering by tags:") + modbus_signals = simplified_configuration_manager.search_signals_by_tags(["protocol:modbus_tcp"]) + print(f" Modbus signals: {len(modbus_signals)}") + for signal in modbus_signals: + print(f" - {signal.signal_name}") + + # Test 4: Get all tags + print("\n4. Getting all tags:") + all_tags = simplified_configuration_manager.get_all_tags() + print(f" All tags: {all_tags}") + + # Test 5: Update a signal + print("\n5. Updating a signal:") + if created_signals: + signal_to_update = created_signals[0] + print(f" Updating: {signal_to_update.signal_name}") + + from src.dashboard.simplified_models import ProtocolSignalUpdate + update_data = ProtocolSignalUpdate( + signal_name="Updated Boiler Temperature", + tags=["equipment:boiler", "protocol:modbus_tcp", "data_point:temperature", "unit:celsius", "updated:true"] + ) + + success = simplified_configuration_manager.update_protocol_signal(signal_to_update.signal_id, update_data) + if success: + updated_signal = simplified_configuration_manager.get_protocol_signal(signal_to_update.signal_id) + print(f" ✓ Updated to: {updated_signal.signal_name}") + print(f" New tags: {updated_signal.tags}") + else: + print(f" ✗ Failed to update") + + # Test 6: Delete a signal + print("\n6. Deleting a signal:") + if len(created_signals) > 1: + signal_to_delete = created_signals[1] + print(f" Deleting: {signal_to_delete.signal_name}") + + success = simplified_configuration_manager.delete_protocol_signal(signal_to_delete.signal_id) + if success: + print(f" ✓ Deleted successfully") + else: + print(f" ✗ Failed to delete") + + # Test 7: Get remaining signals + print("\n7. Final signal count:") + final_signals = simplified_configuration_manager.get_protocol_signals() + print(f" Remaining signals: {len(final_signals)}") + + return len(final_signals) > 0 + +def test_api_compatibility(): + """Test that the new API is compatible with discovery results""" + print("\n=== Testing Discovery Compatibility ===") + + from src.dashboard.simplified_models import SignalDiscoveryResult + + # Simulate discovery results + discovery_results = [ + { + "device_name": "Flow Meter", + "protocol_type": "modbus_tcp", + "protocol_address": "30003", + "data_point": "Flow Rate", + "device_address": "192.168.1.105" + }, + { + "device_name": "Level Sensor", + "protocol_type": "opcua", + "protocol_address": "ns=2;s=Level", + "data_point": "Tank Level", + "device_address": "192.168.1.106" + } + ] + + for discovery_data in discovery_results: + discovery = SignalDiscoveryResult(**discovery_data) + signal_create = discovery.to_protocol_signal_create() + + print(f"\nDiscovery: {discovery.device_name}") + print(f" Signal Name: {signal_create.signal_name}") + print(f" Tags: {signal_create.tags}") + print(f" Protocol: {signal_create.protocol_type.value}") + print(f" Address: {signal_create.protocol_address}") + print(f" DB Source: {signal_create.db_source}") + + # Validate + validation = simplified_configuration_manager.validate_signal_configuration(signal_create) + print(f" Valid: {validation['valid']}") + if validation['warnings']: + print(f" Warnings: {validation['warnings']}") + +def main(): + """Run all API integration tests""" + print("Calejo Control API Integration Test") + print("=" * 50) + + try: + # Run async tests + success = asyncio.run(test_api_endpoints()) + + # Run compatibility tests + test_api_compatibility() + + print("\n" + "=" * 50) + if success: + print("✅ All API integration tests completed successfully!") + print("\nAPI Endpoints Available:") + print(" • GET /api/v1/dashboard/protocol-signals") + print(" • GET /api/v1/dashboard/protocol-signals/{signal_id}") + print(" • POST /api/v1/dashboard/protocol-signals") + print(" • PUT /api/v1/dashboard/protocol-signals/{signal_id}") + print(" • DELETE /api/v1/dashboard/protocol-signals/{signal_id}") + print(" • GET /api/v1/dashboard/protocol-signals/tags/all") + else: + print("❌ Some API integration tests failed") + return 1 + + except Exception as e: + print(f"\n❌ API integration test failed: {e}") + import traceback + traceback.print_exc() + return 1 + + return 0 + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/test_discovery.js b/test_discovery.js new file mode 100644 index 0000000..5b97d58 --- /dev/null +++ b/test_discovery.js @@ -0,0 +1,329 @@ +// Test script to verify discovery functionality +// This simulates the browser environment and tests the discovery system + +// Mock browser environment +let modalDisplay = 'none'; +const mockDocument = { + getElementById: function(id) { + console.log(`getElementById called with: ${id}`); + + // Mock the modal + if (id === 'mapping-modal') { + return { + style: { + display: modalDisplay, + set display(value) { + modalDisplay = value; + console.log(`Modal display set to: ${value}`); + }, + get display() { + return modalDisplay; + } + }, + innerHTML: 'Mock modal content' + }; + } + + // Mock form fields + const mockFields = { + 'mapping_id': { value: '' }, + 'protocol_type': { value: '', dispatchEvent: () => console.log('protocol_type change event') }, + 'protocol_address': { value: '' }, + 'station_id': { + value: '', + options: [{ value: '', textContent: 'Select Station' }, { value: 'station_main', textContent: 'Main Pump Station' }], + dispatchEvent: () => console.log('station_id change event') + }, + 'equipment_id': { + value: '', + options: [{ value: '', textContent: 'Select Equipment' }, { value: 'pump_primary', textContent: 'Primary Pump' }] + }, + 'data_type_id': { + value: '', + options: [{ value: '', textContent: 'Select Data Type' }, { value: 'speed_pump', textContent: 'Pump Speed' }] + }, + 'db_source': { value: '' } + }; + + return mockFields[id] || null; + }, + querySelector: function(selector) { + console.log(`querySelector called with: ${selector}`); + return null; + }, + querySelectorAll: function(selector) { + console.log(`querySelectorAll called with: ${selector}`); + return []; + } +}; + +// Mock global document +const document = mockDocument; + +// Mock showAddMappingModal function +const showAddMappingModal = function() { + console.log('showAddMappingModal called'); + const modal = document.getElementById('mapping-modal'); + if (modal) { + modal.style.display = 'block'; + console.log('Modal opened successfully'); + } +}; + +// Import the discovery class (simplified version for testing) +class ProtocolDiscovery { + constructor() { + this.currentScanId = 'test-scan-123'; + this.isScanning = false; + } + + // Test the populateProtocolForm method + populateProtocolForm(endpoint) { + console.log('\n=== Testing populateProtocolForm ==='); + + // Create a new protocol mapping ID + const mappingId = `${endpoint.device_id}_${endpoint.protocol_type}`; + + // Get default metadata IDs + const defaultStationId = this.getDefaultStationId(); + const defaultEquipmentId = this.getDefaultEquipmentId(defaultStationId); + const defaultDataTypeId = this.getDefaultDataTypeId(); + + // Set form values + const formData = { + mapping_id: mappingId, + protocol_type: endpoint.protocol_type === 'opc_ua' ? 'opcua' : endpoint.protocol_type, + protocol_address: this.getDefaultProtocolAddress(endpoint), + device_name: endpoint.device_name || endpoint.device_id, + device_address: endpoint.address, + device_port: endpoint.port || '', + station_id: defaultStationId, + equipment_id: defaultEquipmentId, + data_type_id: defaultDataTypeId + }; + + console.log('Form data created:', formData); + + // Auto-populate the protocol mapping form + this.autoPopulateProtocolForm(formData); + } + + autoPopulateProtocolForm(formData) { + console.log('\n=== Testing autoPopulateProtocolForm ==='); + console.log('Auto-populating protocol form with:', formData); + + // First, open the "Add New Mapping" modal + this.openAddMappingModal(); + + // Wait for modal to be fully loaded and visible + const waitForModal = setInterval(() => { + const modal = document.getElementById('mapping-modal'); + const isModalVisible = modal && modal.style.display !== 'none'; + + if (isModalVisible) { + clearInterval(waitForModal); + this.populateModalFields(formData); + } + }, 50); + + // Timeout after 2 seconds + setTimeout(() => { + clearInterval(waitForModal); + const modal = document.getElementById('mapping-modal'); + if (modal && modal.style.display !== 'none') { + this.populateModalFields(formData); + } else { + console.error('Modal did not open within timeout period'); + } + }, 2000); + } + + populateModalFields(formData) { + console.log('\n=== Testing populateModalFields ==='); + console.log('Populating modal fields with:', formData); + + // Find and populate form fields in the modal + const mappingIdField = document.getElementById('mapping_id'); + const protocolTypeField = document.getElementById('protocol_type'); + const protocolAddressField = document.getElementById('protocol_address'); + const stationIdField = document.getElementById('station_id'); + const equipmentIdField = document.getElementById('equipment_id'); + const dataTypeIdField = document.getElementById('data_type_id'); + const dbSourceField = document.getElementById('db_source'); + + console.log('Found fields:', { + mappingIdField: !!mappingIdField, + protocolTypeField: !!protocolTypeField, + protocolAddressField: !!protocolAddressField, + stationIdField: !!stationIdField, + equipmentIdField: !!equipmentIdField, + dataTypeIdField: !!dataTypeIdField, + dbSourceField: !!dbSourceField + }); + + // Populate mapping ID + if (mappingIdField) { + mappingIdField.value = formData.mapping_id; + console.log('✓ Set mapping_id to:', formData.mapping_id); + } + + // Populate protocol type + if (protocolTypeField) { + protocolTypeField.value = formData.protocol_type; + console.log('✓ Set protocol_type to:', formData.protocol_type); + // Trigger protocol field updates + protocolTypeField.dispatchEvent(new Event('change')); + } + + // Populate protocol address + if (protocolAddressField) { + protocolAddressField.value = formData.protocol_address; + console.log('✓ Set protocol_address to:', formData.protocol_address); + } + + // Set station, equipment, and data type + if (stationIdField) { + this.waitForStationsLoaded(() => { + if (this.isValidStationId(formData.station_id)) { + stationIdField.value = formData.station_id; + console.log('✓ Set station_id to:', formData.station_id); + // Trigger equipment dropdown update + stationIdField.dispatchEvent(new Event('change')); + + // Wait for equipment to be loaded + setTimeout(() => { + if (equipmentIdField && this.isValidEquipmentId(formData.equipment_id)) { + equipmentIdField.value = formData.equipment_id; + console.log('✓ Set equipment_id to:', formData.equipment_id); + } + + if (dataTypeIdField && this.isValidDataTypeId(formData.data_type_id)) { + dataTypeIdField.value = formData.data_type_id; + console.log('✓ Set data_type_id to:', formData.data_type_id); + } + + // Set default database source + if (dbSourceField && !dbSourceField.value) { + dbSourceField.value = 'measurements.' + formData.device_name.toLowerCase().replace(/[^a-z0-9]/g, '_'); + console.log('✓ Set db_source to:', dbSourceField.value); + } + + console.log('\n✅ Protocol form successfully populated!'); + console.log('All fields should now be filled with discovery data.'); + }, 100); + } + }); + } + } + + openAddMappingModal() { + console.log('\n=== Testing openAddMappingModal ==='); + console.log('Attempting to open Add New Mapping modal...'); + + // First try to use the global function + if (typeof showAddMappingModal === 'function') { + console.log('✓ Using showAddMappingModal function'); + showAddMappingModal(); + return; + } + + console.log('❌ Could not find any way to open the protocol mapping modal'); + } + + getDefaultProtocolAddress(endpoint) { + const protocolType = endpoint.protocol_type; + switch (protocolType) { + case 'modbus_tcp': + return '40001'; + case 'opc_ua': + return 'ns=2;s=MyVariable'; + case 'modbus_rtu': + return '40001'; + case 'rest_api': + return '/api/v1/data/endpoint'; + default: + return 'unknown'; + } + } + + getDefaultStationId() { + const stationSelect = document.getElementById('station_id'); + if (stationSelect && stationSelect.options.length > 1) { + return stationSelect.options[1].value; + } + return 'station_main'; + } + + getDefaultEquipmentId(stationId) { + const equipmentSelect = document.getElementById('equipment_id'); + if (equipmentSelect && equipmentSelect.options.length > 1) { + return equipmentSelect.options[1].value; + } + if (stationId === 'station_main') return 'pump_primary'; + if (stationId === 'station_backup') return 'pump_backup'; + if (stationId === 'station_control') return 'controller_plc'; + return 'pump_primary'; + } + + getDefaultDataTypeId() { + const dataTypeSelect = document.getElementById('data_type_id'); + if (dataTypeSelect && dataTypeSelect.options.length > 1) { + return dataTypeSelect.options[1].value; + } + return 'speed_pump'; + } + + isValidStationId(stationId) { + const stationSelect = document.getElementById('station_id'); + if (!stationSelect) return false; + return Array.from(stationSelect.options).some(option => option.value === stationId); + } + + isValidEquipmentId(equipmentId) { + const equipmentSelect = document.getElementById('equipment_id'); + if (!equipmentSelect) return false; + return Array.from(equipmentSelect.options).some(option => option.value === equipmentId); + } + + isValidDataTypeId(dataTypeId) { + const dataTypeSelect = document.getElementById('data_type_id'); + if (!dataTypeSelect) return false; + return Array.from(dataTypeSelect.options).some(option => option.value === dataTypeId); + } + + waitForStationsLoaded(callback, maxWait = 3000) { + const stationSelect = document.getElementById('station_id'); + if (!stationSelect) { + console.error('Station select element not found'); + callback(); + return; + } + + // Check if stations are already loaded + if (stationSelect.options.length > 1) { + console.log('✓ Stations already loaded:', stationSelect.options.length); + callback(); + return; + } + + console.log('Waiting for stations to load...'); + callback(); // In test, just call immediately + } +} + +// Run the test +console.log('🚀 Starting Protocol Discovery Test\n'); + +const discovery = new ProtocolDiscovery(); + +// Test with a sample discovered endpoint +const sampleEndpoint = { + device_id: 'device_001', + protocol_type: 'modbus_tcp', + device_name: 'Water Pump Controller', + address: '192.168.1.100', + port: 502 +}; + +console.log('Testing with sample endpoint:', sampleEndpoint); +discovery.populateProtocolForm(sampleEndpoint); \ No newline at end of file diff --git a/test_discovery_integration.html b/test_discovery_integration.html new file mode 100644 index 0000000..f99a125 --- /dev/null +++ b/test_discovery_integration.html @@ -0,0 +1,223 @@ + + + + + + Discovery Integration Test + + + +
+

Discovery Integration Test

+ +
+

Test 1: Check if Functions are Available

+ +
+
+ +
+

Test 2: Simulate Discovery Results

+ +
+
+ +
+

Test 3: Test Auto-Population

+ +
+
+ +
+

Test 4: Test API Endpoints

+ +
+
+
+ + + + \ No newline at end of file diff --git a/test_discovery_simple.html b/test_discovery_simple.html new file mode 100644 index 0000000..b44b537 --- /dev/null +++ b/test_discovery_simple.html @@ -0,0 +1,328 @@ + + + + Protocol Discovery Test + + + +

Protocol Discovery Test

+ +
+

Test Discovery "Use" Button

+ + +
+ + + + + +
+ + + + \ No newline at end of file diff --git a/test_integration_workflow.py b/test_integration_workflow.py new file mode 100644 index 0000000..7e9f105 --- /dev/null +++ b/test_integration_workflow.py @@ -0,0 +1,167 @@ +#!/usr/bin/env python3 +""" +Test the integration between discovery and simplified protocol mapping system +""" + +import sys +import os +sys.path.insert(0, os.path.join(os.path.dirname(__file__))) + +from src.dashboard.simplified_models import ProtocolSignalCreate, ProtocolType +from src.dashboard.simplified_configuration_manager import simplified_configuration_manager + +def test_discovery_to_signal_workflow(): + """Test the complete workflow from discovery to signal creation""" + + print("=" * 60) + print("Testing Discovery to Protocol Signal Integration") + print("=" * 60) + + # Simulate discovery results + discovery_results = [ + { + "device_name": "Boiler Temperature Sensor", + "protocol_type": "opcua", + "protocol_address": "ns=2;s=Temperature", + "data_point": "Temperature", + "device_address": "192.168.1.100" + }, + { + "device_name": "Main Water Pump", + "protocol_type": "modbus_tcp", + "protocol_address": "40001", + "data_point": "Speed", + "device_address": "192.168.1.101" + }, + { + "device_name": "System Pressure Sensor", + "protocol_type": "modbus_tcp", + "protocol_address": "40002", + "data_point": "Pressure", + "device_address": "192.168.1.102" + } + ] + + print("\n1. Discovery Results:") + for i, device in enumerate(discovery_results, 1): + print(f" {i}. {device['device_name']} - {device['protocol_type']} - {device['protocol_address']}") + + # Convert discovery results to signal format + print("\n2. Converting Discovery to Signal Format:") + signals_created = [] + + for device in discovery_results: + # Generate signal name + signal_name = f"{device['device_name']} {device['data_point']}" + + # Generate tags + tags = [ + f"device:{device['device_name'].lower().replace(' ', '_')}", + f"protocol:{device['protocol_type']}", + f"data_point:{device['data_point'].lower().replace(' ', '_')}", + f"address:{device['device_address']}", + "discovered:true" + ] + + # Generate database source + db_source = f"measurements.{device['device_name'].lower().replace(' ', '_')}_{device['data_point'].lower().replace(' ', '_')}" + + # Create signal + signal_create = ProtocolSignalCreate( + signal_name=signal_name, + tags=tags, + protocol_type=ProtocolType(device['protocol_type']), + protocol_address=device['protocol_address'], + db_source=db_source + ) + + # Add to configuration manager + success = simplified_configuration_manager.add_protocol_signal(signal_create) + + if success: + signals_created.append(signal_create) + print(f" ✓ Created: {signal_name}") + print(f" Tags: {', '.join(tags)}") + print(f" Protocol: {device['protocol_type']} at {device['protocol_address']}") + print(f" DB Source: {db_source}") + else: + print(f" ✗ Failed to create: {signal_name}") + + # Test filtering and retrieval + print("\n3. Testing Signal Management:") + + # Get all signals + all_signals = simplified_configuration_manager.get_protocol_signals() + print(f" Total signals: {len(all_signals)}") + + # Filter by protocol + modbus_signals = [s for s in all_signals if 'protocol:modbus_tcp' in s.tags] + print(f" Modbus TCP signals: {len(modbus_signals)}") + + # Filter by device + boiler_signals = [s for s in all_signals if 'device:boiler_temperature_sensor' in s.tags] + print(f" Boiler signals: {len(boiler_signals)}") + + # Get all tags + all_tags = simplified_configuration_manager.get_all_tags() + print(f" All tags: {len(all_tags)} unique tags") + + # Test signal updates + print("\n4. Testing Signal Updates:") + if signals_created: + first_signal = signals_created[0] + signal_id = first_signal.generate_signal_id() + + # Get the signal + signal = simplified_configuration_manager.get_protocol_signal(signal_id) + if signal: + print(f" Retrieved signal: {signal.signal_name}") + + # Update the signal + updated_tags = signal.tags + ["unit:celsius", "alarm:high_temp"] + update_success = simplified_configuration_manager.update_protocol_signal( + signal_id, + tags=updated_tags, + preprocessing_enabled=True + ) + + if update_success: + print(f" ✓ Updated signal with new tags and preprocessing") + updated_signal = simplified_configuration_manager.get_protocol_signal(signal_id) + print(f" New tags: {', '.join(updated_signal.tags)}") + print(f" Preprocessing: {updated_signal.preprocessing_enabled}") + else: + print(f" ✗ Failed to update signal") + + # Test signal deletion + print("\n5. Testing Signal Deletion:") + if signals_created: + last_signal = signals_created[-1] + signal_id = last_signal.generate_signal_id() + + delete_success = simplified_configuration_manager.delete_protocol_signal(signal_id) + + if delete_success: + print(f" ✓ Deleted signal: {last_signal.signal_name}") + remaining_signals = simplified_configuration_manager.get_protocol_signals() + print(f" Remaining signals: {len(remaining_signals)}") + else: + print(f" ✗ Failed to delete signal") + + print("\n" + "=" * 60) + print("Integration Test Results:") + print(f" - Discovery devices processed: {len(discovery_results)}") + print(f" - Signals successfully created: {len(signals_created)}") + print(f" - Final signal count: {len(simplified_configuration_manager.get_protocol_signals())}") + print(f" - Unique tags available: {len(simplified_configuration_manager.get_all_tags())}") + + if len(signals_created) == len(discovery_results): + print("\n✅ SUCCESS: All discovery devices successfully converted to protocol signals!") + print(" The simplified system is working correctly with discovery integration.") + else: + print("\n❌ FAILURE: Some discovery devices failed to convert to signals.") + + print("=" * 60) + +if __name__ == "__main__": + test_discovery_to_signal_workflow() \ No newline at end of file diff --git a/test_migration.py b/test_migration.py new file mode 100644 index 0000000..46af023 --- /dev/null +++ b/test_migration.py @@ -0,0 +1,160 @@ +#!/usr/bin/env python3 +""" +Migration Test Script +Tests the simplified signal name + tags architecture +""" + +import sys +import os +sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) + +from src.dashboard.simplified_models import ( + ProtocolSignalCreate, ProtocolType, SignalDiscoveryResult +) +from src.dashboard.simplified_configuration_manager import simplified_configuration_manager + +def test_simplified_models(): + """Test the new simplified models""" + print("\n=== Testing Simplified Models ===") + + # Test 1: Create from discovery result + print("\n1. Testing discovery result conversion:") + discovery = SignalDiscoveryResult( + device_name="Water Pump Controller", + protocol_type=ProtocolType.MODBUS_TCP, + protocol_address="40001", + data_point="Speed", + device_address="192.168.1.100" + ) + + signal_create = discovery.to_protocol_signal_create() + print(f" Signal Name: {signal_create.signal_name}") + print(f" Tags: {signal_create.tags}") + print(f" Protocol: {signal_create.protocol_type}") + print(f" Address: {signal_create.protocol_address}") + print(f" DB Source: {signal_create.db_source}") + + # Test 2: Validation + print("\n2. Testing validation:") + validation = simplified_configuration_manager.validate_signal_configuration(signal_create) + print(f" Valid: {validation['valid']}") + print(f" Errors: {validation['errors']}") + print(f" Warnings: {validation['warnings']}") + + # Test 3: Add signal + print("\n3. Testing signal creation:") + success = simplified_configuration_manager.add_protocol_signal(signal_create) + print(f" Signal created: {success}") + + # Test 4: Retrieve signals + print("\n4. Testing signal retrieval:") + signals = simplified_configuration_manager.get_protocol_signals() + print(f" Number of signals: {len(signals)}") + for signal in signals: + print(f" - {signal.signal_name} ({signal.signal_id})") + + # Test 5: Tag-based filtering + print("\n5. Testing tag-based filtering:") + pump_signals = simplified_configuration_manager.search_signals_by_tags(["equipment:pump"]) + print(f" Pump signals: {len(pump_signals)}") + + # Test 6: All tags + print("\n6. Testing tag collection:") + all_tags = simplified_configuration_manager.get_all_tags() + print(f" All tags: {all_tags}") + +def test_migration_scenarios(): + """Test various migration scenarios""" + print("\n=== Testing Migration Scenarios ===") + + scenarios = [ + { + "name": "Modbus Pump Speed", + "device_name": "Main Water Pump", + "protocol_type": ProtocolType.MODBUS_TCP, + "data_point": "Speed", + "protocol_address": "40001" + }, + { + "name": "OPC UA Temperature", + "device_name": "Boiler Temperature Sensor", + "protocol_type": ProtocolType.OPCUA, + "data_point": "Temperature", + "protocol_address": "ns=2;s=Temperature" + }, + { + "name": "REST API Status", + "device_name": "System Controller", + "protocol_type": ProtocolType.REST_API, + "data_point": "Status", + "protocol_address": "/api/v1/system/status" + } + ] + + for scenario in scenarios: + print(f"\nScenario: {scenario['name']}") + + discovery = SignalDiscoveryResult( + device_name=scenario["device_name"], + protocol_type=scenario["protocol_type"], + protocol_address=scenario["protocol_address"], + data_point=scenario["data_point"] + ) + + signal_create = discovery.to_protocol_signal_create() + success = simplified_configuration_manager.add_protocol_signal(signal_create) + + print(f" Created: {success}") + print(f" Signal: {signal_create.signal_name}") + print(f" Tags: {', '.join(signal_create.tags[:3])}...") + +def compare_complexity(): + """Compare old vs new approach complexity""" + print("\n=== Complexity Comparison ===") + + print("\nOLD APPROACH (Complex IDs):") + print(" Required fields:") + print(" - station_id: 'station_main'") + print(" - equipment_id: 'pump_primary'") + print(" - data_type_id: 'speed_pump'") + print(" - protocol_address: '40001'") + print(" - db_source: 'measurements.pump_speed'") + print(" Issues: Complex relationships, redundant IDs, confusing UX") + + print("\nNEW APPROACH (Simple Names + Tags):") + print(" Required fields:") + print(" - signal_name: 'Main Water Pump Speed'") + print(" - tags: ['equipment:pump', 'protocol:modbus_tcp', 'data_point:speed']") + print(" - protocol_address: '40001'") + print(" - db_source: 'measurements.main_water_pump_speed'") + print(" Benefits: Intuitive, flexible, simpler relationships") + +def main(): + """Run all tests""" + print("Calejo Control Migration Test") + print("=" * 50) + + try: + test_simplified_models() + test_migration_scenarios() + compare_complexity() + + print("\n" + "=" * 50) + print("✅ All migration tests completed successfully!") + print("\nMigration Benefits:") + print(" • Simplified user experience") + print(" • Flexible tag-based organization") + print(" • Intuitive signal names") + print(" • Reduced complexity") + print(" • Better discovery integration") + + except Exception as e: + print(f"\n❌ Migration test failed: {e}") + import traceback + traceback.print_exc() + return 1 + + return 0 + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file diff --git a/test_simplified_ui.html b/test_simplified_ui.html new file mode 100644 index 0000000..3e2eb83 --- /dev/null +++ b/test_simplified_ui.html @@ -0,0 +1,273 @@ + + + + + + Test Simplified UI + + + +
+

Simplified Protocol Signals UI Test

+

This test verifies the simplified UI components work correctly.

+ +
+ +

Test Actions:

+ + + + +
+ + + + + + + \ No newline at end of file diff --git a/test_use_button.html b/test_use_button.html new file mode 100644 index 0000000..b923722 --- /dev/null +++ b/test_use_button.html @@ -0,0 +1,127 @@ + + + + Test Use Button Functionality + + + +

Test Use Button Functionality

+ +
+

Discovered Endpoint

+

Device: Modbus Controller

+

Address: 192.168.1.100:502

+

Protocol: modbus_tcp

+

Node: 40001

+ +
+ +
+

Discovered Endpoint

+

Device: OPC UA Server

+

Address: 192.168.1.101:4840

+

Protocol: opcua

+

Node: ns=2;s=Pressure

+ +
+ + + + + + + \ No newline at end of file diff --git a/test_use_button_workflow.html b/test_use_button_workflow.html new file mode 100644 index 0000000..eadd916 --- /dev/null +++ b/test_use_button_workflow.html @@ -0,0 +1,238 @@ + + + + + + Test Use Button Workflow + + + +
+

Test Use Button Workflow

+

This page tests the "Use" button functionality with the new tag-based metadata system.

+ +
+

Step 1: Simulate Discovery Results

+

Click the button below to simulate discovering a device endpoint:

+ +
+ + + + + + +
+ + + + \ No newline at end of file diff --git a/validate-deployment.sh b/validate-deployment.sh new file mode 100755 index 0000000..30a5b32 --- /dev/null +++ b/validate-deployment.sh @@ -0,0 +1,45 @@ +#!/bin/bash + +# Calejo Control Adapter - Deployment Validation Script +# Validates that the deployment was successful + +set -e + +echo "🔍 Validating deployment..." + +# Check if services are running +if ! docker-compose ps | grep -q "Up"; then + echo "❌ Some services are not running" + docker-compose ps + exit 1 +fi + +echo "✅ All services are running" + +# Test health endpoint +if ! curl -s -f http://localhost:8080/health > /dev/null; then + echo "❌ Health endpoint is not accessible" + exit 1 +fi + +echo "✅ Health endpoint is accessible" + +# Test dashboard endpoint +if ! curl -s -f http://localhost:8080/dashboard > /dev/null; then + echo "❌ Dashboard endpoint is not accessible" + exit 1 +fi + +echo "✅ Dashboard endpoint is accessible" + +# Test API endpoint +if ! curl -s -f http://localhost:8080/api/v1/status > /dev/null; then + echo "❌ API endpoint is not accessible" + exit 1 +fi + +echo "✅ API endpoint is accessible" + +echo "" +echo "🎉 Deployment validation passed!" +exit 0 \ No newline at end of file