wiliot-certificate 4.5.0a3__py3-none-any.whl → 4.5.0a4__py3-none-any.whl

gui_certificate/server.py

@@ -1,7 +1,8 @@
 import os
 import json
 import tempfile
-from flask import Flask, render_template, request, session, redirect, url_for, flash, send_file, jsonify
+import datetime
+from flask import Flask, render_template, request, session, redirect, url_for, flash, send_file
 from jinja2 import ChoiceLoader, PackageLoader
 from werkzeug.utils import secure_filename
 from certificate.certificate_cli import CertificateCLI
@@ -31,9 +32,21 @@ TEMP_BASE = tempfile.gettempdir()
 UPLOAD_FOLDER = os.path.join(TEMP_BASE, "wiliot_certificate_uploaded_schemas")
 CONFIG_FOLDER = os.path.join(TEMP_BASE, "wiliot_certificate_saved_configs")
 TEST_LIST_FOLDER = os.path.join(TEMP_BASE, "wiliot_certificate_test_lists")
+CUSTOM_BROKER_FOLDER = os.path.join(TEMP_BASE, "wiliot_certificate_custom_brokers")
 ALLOWED_EXTENSIONS = {'json'}
 MAX_UPLOAD_SIZE = 16 * 1024 * 1024  # 16MB
 
+# Default custom broker configuration (from hivemq.json)
+DEFAULT_CUSTOM_BROKER = {
+    "port": 8883,
+    "brokerUrl": "mqtts://broker.hivemq.com",
+    "username": "",
+    "password": "",
+    "updateTopic": "update/wiliot/<gatewayId>",
+    "statusTopic": "status/wiliot/<gatewayId>",
+    "dataTopic": "data/wiliot/<gatewayId>"
+}
+
 app = Flask(__name__)
 app.secret_key = os.urandom(24)  # Required for sessions
 app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
@@ -43,6 +56,7 @@ app.config['MAX_CONTENT_LENGTH'] = MAX_UPLOAD_SIZE
 os.makedirs(UPLOAD_FOLDER, exist_ok=True)
 os.makedirs(CONFIG_FOLDER, exist_ok=True)
 os.makedirs(TEST_LIST_FOLDER, exist_ok=True)
+os.makedirs(CUSTOM_BROKER_FOLDER, exist_ok=True)
 
 # extend Jinja search path to include shared dir
 app.jinja_loader = ChoiceLoader([
@@ -84,11 +98,11 @@ def get_mandatory_modules_by_schema(schema_data, flavor):
         return []
     
     # Map schema module names to test module names
-    mandatory_by_schema = []    
+    mandatory_by_schema = []
     for schema_mod_name in schema_modules.keys():
         # Map schema module name to test module name
         test_mod_name = test_module_and_schema_module_to_other(schema_mod_name)
-        if test_mod_name not in mandatory_by_schema:
+        if test_mod_name not in mandatory_by_schema and test_mod_name != 'custom':
             mandatory_by_schema.append(test_mod_name)
     
     return mandatory_by_schema
@@ -324,7 +338,7 @@ def verify_schema_matches_selection(schema_data, flavor, selected_modules, selec
     
     return len(errors) == 0, errors, warnings
 
-def check_certification_status(flavor, selected_modules, selected_tests, tests_schema, schema_data=None):
+def check_certification_status(flavor, selected_modules, selected_tests, tests_schema, schema_data=None, unsterile_run=False):
     """Check if the selection qualifies for certification or is test-only."""
     mandatory_modules = get_mandatory_modules_for_flavor(flavor)
     mandatory_by_schema = get_mandatory_modules_by_schema(schema_data, flavor) if schema_data else []
@@ -359,8 +373,9 @@ def check_certification_status(flavor, selected_modules, selected_tests, tests_s
         if len(additional_modules) == 0:
             missing_additional_module = True
     
+    # A certifying run must be sterile - if unsterile_run is set, force non-certifying
     is_certified = (len(missing_modules) == 0 and len(missing_modules_by_schema) == 0 and 
-                   len(missing_tests) == 0 and not missing_additional_module)
+                   len(missing_tests) == 0 and not missing_additional_module and not unsterile_run)
     
     return is_certified, missing_modules, missing_tests, missing_additional_module, missing_modules_by_schema
 
@@ -465,6 +480,43 @@ def _write_testlist(selected_ids: list[str], form_data=None, is_certified=False)
     print(f"Custom test list saved in {path}")
     return path
 
+def _write_custom_broker_config(form_data, cert_schema_title="cert_run") -> str:
+    """
+    Generate a custom broker JSON configuration file from form data.
+    Extracts broker field values and creates a JSON file matching hivemq.json format.
+    """
+    # Extract broker configuration from form_data
+    broker_config = {}
+    
+    # Field names follow pattern: {schema_title}_custom_broker_{field_name}
+    field_prefix = f"{cert_schema_title}_custom_broker_"
+    
+    # Extract values from form_data, using defaults if not provided
+    for field in DEFAULT_CUSTOM_BROKER.keys():
+        field_name = f"{field_prefix}{field}"
+        value = form_data.get(field_name, "")
+        
+        # Convert port to int if it's a number
+        if field == "port":
+            try:
+                broker_config[field] = int(value) if value else DEFAULT_CUSTOM_BROKER[field]
+            except (ValueError, TypeError):
+                broker_config[field] = DEFAULT_CUSTOM_BROKER[field]
+        else:
+            broker_config[field] = value
+    
+    # Generate filename with timestamp
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"custom_broker_{timestamp}.json"
+    filepath = os.path.join(CUSTOM_BROKER_FOLDER, filename)
+    
+    # Write JSON file
+    with open(filepath, 'w', encoding='utf-8') as f:
+        json.dump(broker_config, f, indent=4)
+    
+    print(f"Custom broker config saved in {filepath}")
+    return filepath
+
 @app.route("/")
 def index():
     """Redirect to step 1 or show current step."""
@@ -632,43 +684,19 @@ def step(step_num):
                 else:
                     form_data_dict[key] = request.form.get(key)
             
-            # Handle custom_broker file upload
+            # Handle custom_broker configuration from form fields
             cert_cli = CertificateCLI()
             cert_schema = web_utils.parser_to_schema(cert_cli.parser)
             custom_broker_field_name = f"{cert_schema['title']}_custom_broker"
-            custom_broker_file_key = f"{custom_broker_field_name}_file"
-            
-            # Preserve existing custom_broker_path if no new file is uploaded
-            existing_custom_broker_path = session.get('custom_broker_path')
-            if existing_custom_broker_path:
-                form_data_dict[custom_broker_field_name] = existing_custom_broker_path
             
-            if custom_broker_file_key in request.files:
-                file = request.files[custom_broker_file_key]
-                if file and file.filename and allowed_file(file.filename):
-                    filename = secure_filename(file.filename)
-                    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-                    filename = f"{timestamp}_{filename}"
-                    filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
-                    file.save(filepath)
-                    
-                    # Validate file is valid JSON
-                    try:
-                        with open(filepath, "r", encoding="utf-8") as f:
-                            json.load(f)
-                        # Store normalized path
-                        normalized_path = os.path.normpath(filepath)
-                        session['custom_broker_path'] = normalized_path
-                        form_data_dict[custom_broker_field_name] = normalized_path
-                    except json.JSONDecodeError as e:
-                        error = f"Invalid JSON in custom broker file: {e}"
-                        os.remove(filepath)
-                    except Exception as e:
-                        error = f"Error reading custom broker file: {e}"
-                        if os.path.exists(filepath):
-                            os.remove(filepath)
-                elif file and file.filename:
-                    error = "Custom broker file must be a JSON file"
+            # Generate custom broker JSON file from form fields
+            try:
+                broker_config_path = _write_custom_broker_config(form_data_dict, cert_schema['title'])
+                normalized_path = os.path.normpath(broker_config_path)
+                session['custom_broker_path'] = normalized_path
+                form_data_dict[custom_broker_field_name] = normalized_path
+            except Exception as e:
+                error = f"Error generating custom broker configuration: {e}"
             
             # Validate all required fields (required for moving forward, but allow going back)
             if action == 'next':
@@ -688,13 +716,22 @@ def step(step_num):
                     field_name = f"{cert_schema['title']}_{field['name']}"
                     field_value = form_data_dict.get(field_name, '')
                     
-                    # Special handling for custom_broker file upload
+                    # Special handling for custom_broker - check if all required broker fields are filled
                     if field['name'] == 'custom_broker':
-                        # Check if file was uploaded or path exists in session
-                        custom_broker_file_key = f"{field_name}_file"
-                        if custom_broker_file_key not in request.files or not request.files[custom_broker_file_key].filename:
-                            # Check if path exists in form_data or session
-                            if not field_value and not session.get('custom_broker_path'):
+                        # Check all broker fields except username and password are filled
+                        broker_field_prefix = f"{cert_schema['title']}_custom_broker_"
+                        optional_fields = {'username', 'password'}
+                        for broker_field_key in DEFAULT_CUSTOM_BROKER.keys():
+                            if broker_field_key not in optional_fields:
+                                broker_field_name = f"{broker_field_prefix}{broker_field_key}"
+                                broker_field_value = form_data_dict.get(broker_field_name, '')
+                                if not broker_field_value or (isinstance(broker_field_value, str) and not broker_field_value.strip()):
+                                    missing_required.append(f"custom_broker.{broker_field_key}")
+                                    break
+                        # Also check if path was generated (should be generated above if fields are valid)
+                        if not field_value and not session.get('custom_broker_path'):
+                            # Only add if we haven't already added a broker field error
+                            if not any('custom_broker.' in req for req in missing_required):
                                 missing_required.append(field.get('name', field['label']))
                     else:
                         # For other fields, check if value is provided
@@ -792,6 +829,15 @@ def step(step_num):
         schema_data = load_schema_data(schema_path) if schema_path else None
         filtered_modules = filter_modules_by_flavor(tests_schema, flavor, schema_data)
     
+    # Get CLI schemas for form fields - use certificate_cli for all flavors (needed early for unsterile_run check)
+    cert_cli = CertificateCLI()
+    cert_schema = web_utils.parser_to_schema(cert_cli.parser)
+    
+    # Check if unsterile_run is set in form_data
+    form_data = _prepare_form_data_for_template(session, cert_schema)
+    unsterile_run_field = f"{cert_schema['title']}_unsterile_run"
+    unsterile_run = bool(form_data.get(unsterile_run_field))
+    
     # Get certification status
     is_certified = True
     missing_modules = []
@@ -804,7 +850,7 @@ def step(step_num):
         module_dicts = [m for m in filtered_modules if m.get('name') in selected_modules]
         schema_data = load_schema_data(schema_path) if schema_path else None
         is_certified, missing_modules, missing_tests, missing_additional_module, missing_modules_by_schema = check_certification_status(
-            flavor, module_dicts, selected_tests, tests_schema, schema_data
+            flavor, module_dicts, selected_tests, tests_schema, schema_data, unsterile_run
         )
         
         # Get test details (labels) for missing tests
@@ -834,12 +880,9 @@ def step(step_num):
             # Get missing schema-mandatory modules for display (recalculate if not already set)
             if not missing_modules_by_schema and step_num >= 4 and flavor and selected_modules:
                 _, _, _, _, missing_modules_by_schema = check_certification_status(
-                    flavor, module_dicts, selected_tests, tests_schema, schema_data
+                    flavor, module_dicts, selected_tests, tests_schema, schema_data, unsterile_run
                 )
     
-    # Get CLI schemas for form fields - use certificate_cli for all flavors
-    cert_cli = CertificateCLI()
-    cert_schema = web_utils.parser_to_schema(cert_cli.parser)
     
     # Calculate total test count including mandatory tests from selected modules
     total_test_count = len(selected_tests)
@@ -933,11 +976,14 @@ def step(step_num):
                            error=error,
                            warning=warning,
                            form_data=_prepare_form_data_for_template(session, cert_schema),
+                           custom_broker_defaults=DEFAULT_CUSTOM_BROKER,
+                           custom_broker_field_keys=list(DEFAULT_CUSTOM_BROKER.keys()),
                            run_completed=run_completed,
                            run_terminal=run_terminal,
                            run_pid=run_pid,
                            run_is_certified=run_is_certified,
-                           available_ports=available_ports)
+                           available_ports=available_ports,
+                           unsterile_run=unsterile_run)
 
 def execute_certificate():
     """Execute the certificate run based on session data."""
@@ -964,7 +1010,12 @@ def execute_certificate():
     filtered_modules = filter_modules_by_flavor(tests_schema, flavor)
     module_dicts = [m for m in filtered_modules if m.get('name') in session.get('selected_modules', [])]
     schema_data = load_schema_data(schema_path) if schema_path else None
-    is_certified, _, _, _, _ = check_certification_status(flavor, module_dicts, selected_tests, tests_schema, schema_data)
+    # Check if unsterile_run is set in form_data
+    cert_cli = CertificateCLI()
+    cert_schema = web_utils.parser_to_schema(cert_cli.parser)
+    unsterile_run_field = f"{cert_schema['title']}_unsterile_run"
+    unsterile_run = bool(form_data.get(unsterile_run_field))
+    is_certified, _, _, _, _ = check_certification_status(flavor, module_dicts, selected_tests, tests_schema, schema_data, unsterile_run)
     
     full_cmd = []
     
@@ -1027,6 +1078,17 @@ def export_config():
         flash("No configuration to export. Please complete at least step 1 and 2.", "error")
         return redirect(url_for('step', step_num=session.get('current_step', 1)))
     
+    # Extract custom broker form field values from form_data
+    form_data = session.get('form_data', {})
+    cert_cli = CertificateCLI()
+    cert_schema = web_utils.parser_to_schema(cert_cli.parser)
+    custom_broker_fields = {}
+    field_prefix = f"{cert_schema['title']}_custom_broker_"
+    for field_name in DEFAULT_CUSTOM_BROKER.keys():
+        full_field_name = f"{field_prefix}{field_name}"
+        if full_field_name in form_data:
+            custom_broker_fields[field_name] = form_data[full_field_name]
+    
     # Prepare configuration data
     config = {
         'version': '1.0',
@@ -1035,9 +1097,10 @@ def export_config():
         'schema_path': session.get('schema_path'),
         'selected_modules': session.get('selected_modules', []),
         'selected_tests': session.get('selected_tests', []),
-        'form_data': session.get('form_data', {}),
+        'form_data': form_data,
         'schema_data': load_schema_data(session.get('schema_path')),  # Load schema data from file for export
-        'custom_broker_path': session.get('custom_broker_path')  # Include custom broker file path
+        'custom_broker_path': session.get('custom_broker_path'),  # Include custom broker file path for backward compatibility
+        'custom_broker_fields': custom_broker_fields  # Include custom broker form field values
     }
     
     # Create filename with timestamp
@@ -1098,17 +1161,47 @@ def import_config():
                     json.dump(schema_data, f, indent=2)
             except Exception:
                 pass  # If we can't save, user will need to re-upload
-        session['custom_broker_path'] = config_data.get('custom_broker_path')
+        # Handle custom broker configuration
+        custom_broker_fields = config_data.get('custom_broker_fields', {})
+        if custom_broker_fields:
+            # Restore broker form field values to form_data
+            cert_cli = CertificateCLI()
+            cert_schema = web_utils.parser_to_schema(cert_cli.parser)
+            field_prefix = f"{cert_schema['title']}_custom_broker_"
+            for field_name, field_value in custom_broker_fields.items():
+                full_field_name = f"{field_prefix}{field_name}"
+                session['form_data'][full_field_name] = field_value
+            # Regenerate broker config file from form fields
+            try:
+                broker_config_path = _write_custom_broker_config(session['form_data'], cert_schema['title'])
+                session['custom_broker_path'] = os.path.normpath(broker_config_path)
+            except Exception:
+                pass  # If generation fails, user can reconfigure in step 4
+        else:
+            # Backward compatibility: try to use existing path
+            session['custom_broker_path'] = config_data.get('custom_broker_path')
         
         # Validate schema file still exists
         if session['schema_path'] and not os.path.exists(session['schema_path']):
             flash(f"Warning: Schema file not found at {session['schema_path']}. Please re-upload it in step 2.", "warning")
             session['current_step'] = 2
-        # Validate custom_broker file still exists if present
+        # Validate custom_broker file still exists if present (or regenerate if we have fields)
         elif session.get('custom_broker_path') and not os.path.exists(session['custom_broker_path']):
-            flash(f"Warning: Custom broker file not found at {session['custom_broker_path']}. Please re-upload it in step 4.", "warning")
-            if session.get('current_step', 0) < 4:
-                session['current_step'] = 4
+            if custom_broker_fields:
+                # Regenerate from fields if file doesn't exist
+                try:
+                    cert_cli = CertificateCLI()
+                    cert_schema = web_utils.parser_to_schema(cert_cli.parser)
+                    broker_config_path = _write_custom_broker_config(session['form_data'], cert_schema['title'])
+                    session['custom_broker_path'] = os.path.normpath(broker_config_path)
+                except Exception:
+                    flash(f"Warning: Custom broker configuration will be regenerated in step 4.", "warning")
+                    if session.get('current_step', 0) < 4:
+                        session['current_step'] = 4
+            else:
+                flash(f"Warning: Custom broker file not found at {session['custom_broker_path']}. Please reconfigure it in step 4.", "warning")
+                if session.get('current_step', 0) < 4:
+                    session['current_step'] = 4
         else:
             # Determine appropriate step based on what's configured
             if session.get('selected_tests'):

gui_certificate/templates/cert_run.html

@@ -156,6 +156,7 @@
         {%- endmacro %}
         
         {% set non_cert_text = "NOT READY FOR CERTIFICATION" %}
+        {% set unsterile_run_warning = "Unsterile run mode is set - a certifying run must be sterile." %}
         
         <!-- Progress Indicator -->
         <div class="step-indicator">
@@ -454,7 +455,7 @@
                 {% set common_parameters = ['dut', 'custom_broker'] %}
                 
                 {% for f in cert_schema.fields %}
-                    {% if f.name != 'validation_schema' and f.name != 'tl' and f.name in common_parameters %}
+                    {% if f.name != 'validation_schema' and f.name != 'tl' and f.name != 'custom_broker' and f.name in common_parameters %}
                         {% set arg_label = (f.option_strings|join(', ') if f.option_strings else f.name) %}
                         {% set tip_id = 'help_' ~ f.name %}
                         {% set field_name = cert_schema.title ~ '_' ~ f.name %}
@@ -481,18 +482,6 @@
                                         <input type="checkbox" class="form-check-input" id="{{ field_name }}" name="{{ field_name }}" {% if field_value %}checked{% endif %}>
                                     </div>
                                 </div>
-                            {% elif f.name == "overwrite_defaults" %}
-                                <div class="col-sm-4">
-                                    <textarea id="{{ field_name }}" class="form-control" name="{{ field_name }}" rows="3" placeholder="key1=value1&#10;key2=value2">{{ field_value }}</textarea>
-                                </div>
-                            {% elif f.name == "custom_broker" %}
-                                <div class="col-sm-4">
-                                    <input type="file" class="form-control" id="{{ field_name }}" name="{{ field_name }}_file" accept=".json">
-                                    {% if field_value %}
-                                        {% set path_parts = field_value.replace('\\', '/').split('/') %}
-                                        <div class="form-text">Current: {{ path_parts[-1] if path_parts|length > 1 else field_value }}</div>
-                                    {% endif %}
-                                </div>
                             {% else %}
                                 <div class="col-sm-4">
                                     <input type="{{ f.type }}" class="form-control" id="{{ field_name }}" name="{{ field_name }}" value="{{ field_value }}">
@@ -512,6 +501,43 @@
                     {% endif %}
                 {% endfor %}
                 
+                <!-- Custom Broker Configuration -->
+                {% set cert_schema = cert_schema %}
+                {% set broker_field_prefix = cert_schema.title ~ '_custom_broker_' %}
+                <div class="card mb-3">
+                    <div class="card-header d-flex align-items-center">
+                        <button class="btn btn-sm btn-link text-decoration-none test-toggle me-2 collapsed"
+                                type="button"
+                                data-bs-toggle="collapse"
+                                data-bs-target="#customBrokerConfig"
+                                aria-expanded="false">
+                            <svg class="chev" width="16" height="16" viewBox="0 0 16 16">
+                                <path d="M4.646 5.646a.5.5 0 0 1 .708 0L8 8.293l2.646-2.647a.5.5 0 1 1 .708.708L8.354 9.354a.5.5 0 0 1-.708 0L4.646 6.354a.5.5 0 0 1 0-.708z" fill="currentColor"/>
+                            </svg>
+                        </button>
+                        <strong>Custom MQTT Broker Configuration</strong>
+                        <span class="text-danger ms-2">*</span>
+                    </div>
+                    <div id="customBrokerConfig" class="collapse">
+                        <div class="card-body">
+                            {% for field_key, field_default in custom_broker_defaults.items() %}
+                                {% set field_name = broker_field_prefix ~ field_key %}
+                                {% set field_value = form_data.get(field_name, field_default) %}
+                                {% set input_type = 'number' if field_key == 'port' else 'password' if field_key == 'password' else 'text' %}
+                                {% set is_required = field_key not in ['username', 'password'] %}
+                                <div class="row mb-3">
+                                    <label for="{{ field_name }}" class="col-sm-3 col-form-label">
+                                        {{ field_key }}{% if is_required %} <span class="text-danger">*</span>{% endif %}
+                                    </label>
+                                    <div class="col-sm-4">
+                                        <input type="{{ input_type }}" class="form-control" id="{{ field_name }}" name="{{ field_name }}" value="{{ field_value }}" {% if is_required %}required{% endif %}>
+                                    </div>
+                                </div>
+                            {% endfor %}
+                        </div>
+                    </div>
+                </div>
+                
                 <div class="card mb-3">
                     <div class="card-header d-flex align-items-center">
                         <button class="btn btn-sm btn-link text-decoration-none test-toggle me-2 collapsed"
@@ -618,10 +644,20 @@
                                 <small class="text-muted d-block mt-1">All mandatory modules and tests are selected</small>
                             {% else %}
                                 <span class="badge bg-warning text-dark">{{ non_cert_text }}</span>
-                                <small class="text-muted d-block mt-1">Some mandatory modules or tests are missing</small>
+                                <small class="text-muted d-block mt-1">
+                                    {% if not unsterile_run %}
+                                        Some mandatory modules or tests are missing
+                                    {% endif %}
+                                </small>
                             {% endif %}
                         </p>
                         
+                        {% if unsterile_run %}
+                        <div class="alert alert-warning">
+                            <strong>⚠️ Warning:</strong> {{ unsterile_run_warning }}
+                        </div>
+                        {% endif %}
+                        
                         {% if not is_certified %}
                             {% if missing_modules %}
                                 <div class="alert alert-warning">
@@ -711,76 +747,6 @@
                     </div>
                 </div>
                 
-                <!-- Run Parameters Summary -->
-                {% set cert_schema = cert_schema %}
-                {% set cb_index = -1 %}
-                {% for f in cert_schema.fields %}
-                    {% if f.name == 'custom_broker' %}
-                        {% set cb_index = loop.index0 %}
-                    {% endif %}
-                {% endfor %}
-                {% set has_advanced = False %}
-                {% for f in cert_schema.fields %}
-                    {% if f.name != 'validation_schema' and f.name != 'tl' and cb_index >= 0 and loop.index0 > cb_index %}
-                        {% set has_advanced = True %}
-                    {% endif %}
-                {% endfor %}
-                {% if has_advanced %}
-                <div class="card mb-4">
-                    <div class="card-header">
-                        <h5 class="mb-0">Run Parameters</h5>
-                    </div>
-                    <div class="card-body">
-                        {% for f in cert_schema.fields %}
-                            {% if f.name != 'validation_schema' and f.name != 'tl' %}
-                                {% set field_name = cert_schema.title ~ '_' ~ f.name %}
-                                {% set field_value = form_data.get(field_name, f.default if f.default is not none else '') %}
-                                {% set is_advanced = cb_index >= 0 and loop.index0 > cb_index %}
-                                
-                                {% if not is_advanced %}
-                                    {% set arg_label = (f.option_strings|join(', ') if f.option_strings else f.name) %}
-                                    <p><strong>{{ arg_label }}:</strong> 
-                                        {% if f.is_flag %}
-                                            {{ 'Yes' if field_value else 'No' }}
-                                        {% else %}
-                                            {{ field_value if field_value else '(not set)' }}
-                                        {% endif %}
-                                    </p>
-                                {% endif %}
-                            {% endif %}
-                        {% endfor %}
-                        
-                        {% if has_advanced %}
-                            <div class="mb-3">
-                                <button class="btn btn-outline-secondary btn-sm" type="button" data-bs-toggle="collapse" data-bs-target="#advancedParamsReview" aria-expanded="false" aria-controls="advancedParamsReview">
-                                    Advanced Parameters ▼
-                                </button>
-                            </div>
-                            <div class="collapse" id="advancedParamsReview">
-                                {% for f in cert_schema.fields %}
-                                    {% if f.name != 'validation_schema' and f.name != 'tl' %}
-                                        {% set field_name = cert_schema.title ~ '_' ~ f.name %}
-                                        {% set field_value = form_data.get(field_name, f.default if f.default is not none else '') %}
-                                        {% set is_advanced = cb_index >= 0 and loop.index0 > cb_index %}
-                                        
-                                        {% if is_advanced %}
-                                            {% set arg_label = (f.option_strings|join(', ') if f.option_strings else f.name) %}
-                                            <p><strong>{{ arg_label }}:</strong> 
-                                                {% if f.is_flag %}
-                                                    {{ 'Yes' if field_value else 'No' }}
-                                                {% else %}
-                                                    {{ field_value if field_value else '(not set)' }}
-                                                {% endif %}
-                                            </p>
-                                        {% endif %}
-                                    {% endif %}
-                                {% endfor %}
-                            </div>
-                        {% endif %}
-                    </div>
-                </div>
-                {% endif %}
-                
                 <!-- Edit Links -->
                 <div class="mb-4">
                     <p>Need to make changes?</p>
@@ -860,6 +826,7 @@
             const mandatoryTests = {{ mandatory_tests_for_js|tojson|safe }};
             const currentSelectedModules = {{ selected_modules|tojson|safe }};
             const brgCertSchema = {{ cert_schema|tojson|safe }};
+            const customBrokerFieldKeys = {{ custom_broker_field_keys|tojson|safe }};
             
             // Step 3: Module selection validation
             const mandatoryModulesBySchema = {{ mandatory_modules_by_schema_for_js|tojson|safe }};
@@ -925,6 +892,12 @@
                 
                 let warnings = [];
                 
+                // Check if unsterile_run is enabled
+                const unsterileRunField = document.querySelector('input[id*="unsterile_run"], input[name*="unsterile_run"]');
+                if (unsterileRunField && unsterileRunField.checked) {
+                    warnings.push('{{ unsterile_run_warning }}');
+                }
+                
                 // Check if mandatory modules are deselected (from step 3)
                 const missingMandatoryModules = mandatoryModules.filter(m => !selectedModules.includes(m));
                 if (missingMandatoryModules.length > 0) {
@@ -1072,6 +1045,18 @@
                     if (stepNum === 3) checkStep3Validation();
                     if (stepNum === 4) checkStep4Validation();
                 }
+                
+                // Unsterile run checkbox change
+                const unsterileRunField = document.querySelector('input[id*="unsterile_run"], input[name*="unsterile_run"]');
+                if (unsterileRunField && e.target === unsterileRunField) {
+                    // Show/hide warning and update validation
+                    const warningDiv = document.getElementById('step4_warning');
+                    const warningText = document.getElementById('step4_warning_text');
+                    if (warningDiv && warningText) {
+                        // Re-run validation to update warning
+                        if (stepNum === 4) checkStep4Validation();
+                    }
+                }
             });
             
             // Initialize params visibility for pre-checked tests
@@ -1104,18 +1089,26 @@
                     const fieldName = `${brgCertSchema.title}_${field.name}`;
                     let fieldValue = null;
                     
-                    // Special handling for custom_broker file upload
+                    // Special handling for custom_broker - check if all required broker fields have values (like dut)
+                    // Username and password are optional, all other fields are required
                     if (field.name === 'custom_broker') {
-                        const fileInput = document.querySelector(`input[name="${fieldName}_file"]`);
-                        if (fileInput && fileInput.files && fileInput.files.length > 0) {
-                            fieldValue = fileInput.files[0].name;
-                        } else {
-                            // Check if there's a current value displayed
-                            const currentValueDiv = fileInput?.closest('.col-sm-4')?.querySelector('.form-text');
-                            if (currentValueDiv) {
-                                fieldValue = 'exists';
+                        const brokerFieldPrefix = `${brgCertSchema.title}_custom_broker_`;
+                        const optionalFields = ['username', 'password'];
+                        let allRequiredFieldsFilled = true;
+                        for (const brokerField of customBrokerFieldKeys) {
+                            // Skip optional fields
+                            if (optionalFields.includes(brokerField)) {
+                                continue;
+                            }
+                            const input = document.querySelector(`input[name="${brokerFieldPrefix}${brokerField}"]`);
+                            if (!input || !input.value || (typeof input.value === 'string' && !input.value.trim())) {
+                                allRequiredFieldsFilled = false;
+                                break;
                             }
                         }
+                        if (allRequiredFieldsFilled) {
+                            fieldValue = 'configured';
+                        }
                     } else {
                         // For other fields, check input/select value
                         const inputs = document.querySelectorAll(`input[name="${fieldName}"], select[name="${fieldName}"]`);

{wiliot_certificate-4.5.0a3.dist-info → wiliot_certificate-4.5.0a4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wiliot_certificate
-Version: 4.5.0a3
+Version: 4.5.0a4
 Summary: A library for certifying Wiliot-compliant boards
 Author-email: Wiliot <support@wiliot.com>
 License-Expression: MIT
@@ -55,7 +55,7 @@ wlt-cert
 ````
 This tool is the default to test and certify your device.
 It runs a setup wizard that walks you through the initialization steps before running the tests.
-You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema), tester device and custom broker json file ([more info here](https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification)).
+You'll need a [validation schema](https://community.wiliot.com/customers/s/article/Validation-Schema), tester device and custom broker json file (more info [here](https://community.wiliot.com/customers/s/article/Wiliot-Certification)).
 Once set up it opens a terminal and tests your device.
 
 
@@ -80,7 +80,7 @@ wlt-cert-reg
 ````
 Certify the gateway registration process to Wiliot platform.
 The gateway must use Wiliot production MQTT broker, and mustn't be registered to any account on Wiliot platform.
-Use -h for details on the arguments. [More info here](https://community.wiliot.com/customers/s/article/Wiliot-Gateway-Certification)
+Use -h for details on the arguments (see [Registration](https://community.wiliot.com/customers/s/article/Wiliot-Certification) for more info).
 
 
 ## The following capabilities are not tested in this version