medicafe 0.251027.3__py3-none-any.whl → 0.251030.0__py3-none-any.whl

MediBot/MediBot.bat

@@ -732,7 +732,8 @@ echo 4. Toggle Performance Logging ^(session^)
 echo 5. Send TEST error report (email)
 echo 6. Forced MediCafe version rollback
 echo 7. Process CSV Files
-echo 8. Back to Main Menu
+echo 8. Edit Config File (JSON Editor)
+echo 9. Back to Main Menu
 echo.
 set /p tchoice=Enter your choice:  
 if "%tchoice%"=="1" goto open_latest_log
@@ -742,7 +743,8 @@ if "%tchoice%"=="4" goto toggle_perf_logging
 if "%tchoice%"=="5" goto send_test_error_report
 if "%tchoice%"=="6" goto forced_version_rollback
 if "%tchoice%"=="7" goto process_csvs
-if "%tchoice%"=="8" goto main_menu
+if "%tchoice%"=="8" goto config_editor
+if "%tchoice%"=="9" goto main_menu
 echo Invalid choice. Please try again.
 pause
 goto troubleshooting_menu
@@ -876,6 +878,14 @@ echo Rollback complete. Current MediCafe version: %medicafe_version%
 pause >nul
 goto troubleshooting_menu
 
+::: Config Editor
+:config_editor
+cls
+echo Starting Config Editor...
+call "%~dp0config_editor.bat"
+pause
+goto troubleshooting_menu
+
 ::: Subroutine to display the last N lines of a file
 :tail
 ::: Usage: call :tail filename number_of_lines

MediBot/__init__.py

@@ -19,7 +19,7 @@ Smart Import Integration:
         medibot_main = get_components('medibot_main')
 """
 
-__version__ = "0.251027.3"
+__version__ = "0.251030.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

MediBot/config_editor.bat

@@ -0,0 +1,90 @@
+@echo off
+setlocal enabledelayedexpansion
+
+:: Config Editor Launcher
+:: Called from MediBot.bat Troubleshooting menu
+
+:: Get script directory and set paths
+set "script_dir=%~dp0"
+set "workspace_root=%script_dir%.."
+set "python_script=%script_dir%config_editor.py"
+
+:: Use the same path resolution logic as MediLink_ConfigLoader
+:: Try default path first (relative to MediCafe module)
+set "config_path=%workspace_root%\json\config.json"
+
+:: If default path doesn't exist, try platform-specific fallbacks
+if not exist "%config_path%" (
+    :: Check for Windows XP (F: drive)
+    if exist "F:\" (
+        set "config_path=F:\Medibot\json\config.json"
+    ) else (
+        :: Use current working directory for other Windows versions
+        set "config_path=%CD%\json\config.json"
+    )
+)
+
+:: Display header
+cls
+echo ========================================
+echo        MediCafe Config Editor
+echo ========================================
+echo.
+
+:: Check if Python is available
+python --version >nul 2>&1
+if errorlevel 1 (
+    echo ERROR: Python is not available or not in PATH
+    echo.
+    echo Please ensure Python 3.4.4 or later is installed and accessible.
+    echo.
+    pause
+    exit /b 1
+)
+
+:: Check if config file exists
+if not exist "%config_path%" (
+    echo WARNING: Config file not found at:
+    echo %config_path%
+    echo.
+    echo The editor will start with an empty configuration.
+    echo You can create a new config file or navigate to the correct location.
+    echo.
+    set /p continue_choice="Continue anyway? (Y/N): "
+    if /i not "!continue_choice!"=="Y" (
+        echo Operation cancelled.
+        pause
+        exit /b 0
+    )
+)
+
+:: Check if editor script exists
+if not exist "%python_script%" (
+    echo ERROR: Config editor script not found at:
+    echo %python_script%
+    echo.
+    echo Please ensure config_editor.py is in the MediBot directory.
+    echo.
+    pause
+    exit /b 1
+)
+
+:: Run the config editor
+echo Starting config editor...
+echo.
+python "%python_script%" "%config_path%"
+
+:: Check exit code
+if errorlevel 1 (
+    echo.
+    echo ERROR: Config editor encountered an error.
+    echo.
+) else (
+    echo.
+    echo Config editor completed successfully.
+    echo.
+)
+
+:: Return to caller
+pause
+exit /b %errorlevel%

MediBot/config_editor.py

@@ -0,0 +1,430 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+DOS-Style Config.json Editor
+Interactive JSON configuration editor with DOS-like interface.
+Compatible with Python 3.4.4 and Windows XP.
+"""
+
+import os
+import sys
+import json
+from collections import OrderedDict
+
+# Import our helper functions
+from config_editor_helpers import (
+    load_config_safe, create_backup, save_config_atomic, validate_json_structure,
+    is_sensitive_key, get_value_type, format_value_for_display, clear_config_cache,
+    get_nested_value, set_nested_value, get_path_string, validate_key_name, parse_value_input,
+    resolve_config_path
+)
+
+class ConfigEditor:
+    def __init__(self, config_path):
+        self.config_path = config_path
+        self.config = OrderedDict()
+        self.original_config = OrderedDict()
+        self.current_path = []  # List of keys representing current location
+        self.staged_changes = []  # List of (path, old_value, new_value) tuples
+        self.running = True
+        
+        # Load initial config
+        self.config, error = load_config_safe(config_path)
+        if error:
+            print("WARNING: {}".format(error))
+            print("Starting with empty configuration.")
+            self.config = OrderedDict()
+        
+        # Keep a copy of original for comparison
+        self.original_config = json.loads(json.dumps(self.config, ensure_ascii=False), object_pairs_hook=OrderedDict)
+    
+    def clear_screen(self):
+        """Clear the console screen (XP compatible)."""
+        os.system('cls' if os.name == 'nt' else 'clear')
+    
+    def print_header(self):
+        """Print the editor header."""
+        print("=" * 60)
+        print("           MediCafe Config Editor")
+        print("=" * 60)
+        print("")
+    
+    def print_breadcrumb(self):
+        """Print current navigation path."""
+        path_str = get_path_string(self.current_path)
+        print("Current Path: {}".format(path_str))
+        print("-" * 60)
+    
+    def print_current_level(self):
+        """Print the current level of the config tree."""
+        current_data, found = get_nested_value(self.config, self.current_path)
+        
+        if not found:
+            print("ERROR: Invalid path")
+            return
+        
+        if not isinstance(current_data, dict):
+            print("ERROR: Cannot navigate into non-object value")
+            return
+        
+        if not current_data:
+            print("(Empty object)")
+            return
+        
+        # Print numbered items
+        items = list(current_data.items())
+        for i, (key, value) in enumerate(items, 1):
+            value_display = format_value_for_display(value)
+            value_type = get_value_type(value)
+            
+            # Mark sensitive keys
+            sensitive_mark = " [SENSITIVE]" if is_sensitive_key(key) else ""
+            
+            print("[{}] {}: {} ({}){}".format(i, key, value_display, value_type, sensitive_mark))
+    
+    def print_commands(self):
+        """Print available commands."""
+        print("")
+        print("Commands:")
+        print("  [1-N] Navigate/Edit  [0] Back  [EDIT #] Edit  [ADD] Add Key")
+        print("  [DIR] Refresh  [HELP] Help  [EXIT] Save & Exit")
+        print("-" * 60)
+    
+    def print_help(self):
+        """Print detailed help information."""
+        self.clear_screen()
+        self.print_header()
+        print("HELP - Config Editor Commands")
+        print("=" * 60)
+        print("")
+        print("Navigation:")
+        print("  [1-N]     - Navigate into nested objects or edit simple values")
+        print("  [0]       - Go back to parent level")
+        print("  [..]      - Same as [0]")
+        print("")
+        print("Editing:")
+        print("  [EDIT #]  - Edit the numbered item")
+        print("  [ADD]     - Add a new key at current level")
+        print("")
+        print("Utilities:")
+        print("  [DIR]     - Refresh current level display")
+        print("  [HELP]    - Show this help screen")
+        print("  [EXIT]    - Save changes and exit")
+        print("  [Q]       - Same as [EXIT]")
+        print("")
+        print("Safety Features:")
+        print("  - All changes are staged until you save")
+        print("  - Automatic backup created before saving")
+        print("  - Sensitive keys marked with [SENSITIVE]")
+        print("  - Preview all changes before committing")
+        print("")
+        print("Press Enter to continue...")
+        input()
+    
+    def navigate_to_item(self, item_number):
+        """Navigate to a numbered item."""
+        current_data, found = get_nested_value(self.config, self.current_path)
+        
+        if not found or not isinstance(current_data, dict):
+            print("ERROR: Cannot navigate from current location")
+            return
+        
+        items = list(current_data.items())
+        if item_number < 1 or item_number > len(items):
+            print("ERROR: Invalid item number")
+            return
+        
+        key, value = items[item_number - 1]
+        
+        # If it's a simple value, offer to edit it
+        if not isinstance(value, dict):
+            self.edit_simple_value(key, value)
+        else:
+            # Navigate into the object
+            self.current_path.append(key)
+    
+    def edit_simple_value(self, key, current_value):
+        """Edit a simple (non-object) value."""
+        current_type = get_value_type(current_value)
+        current_display = format_value_for_display(current_value)
+        
+        print("")
+        print("Editing: {}".format(key))
+        print("Current value: {} ({})".format(current_display, current_type))
+        print("")
+        
+        # Get new value
+        new_value_str = input("Enter new value: ").strip()
+        
+        if not new_value_str:
+            print("No changes made.")
+            return
+        
+        # Parse the new value
+        new_value, error = parse_value_input(new_value_str, current_type)
+        if error:
+            print("ERROR: {}".format(error))
+            return
+        
+        # Show preview
+        new_display = format_value_for_display(new_value)
+        print("")
+        print("Preview: {} -> {}".format(current_display, new_display))
+        
+        # Confirm change
+        if is_sensitive_key(key):
+            print("WARNING: This appears to be a sensitive key!")
+        
+        confirm = input("Apply this change? (Y/N): ").strip().upper()
+        if confirm in ['Y', 'YES']:
+            # Stage the change
+            full_path = self.current_path + [key]
+            self.staged_changes.append((full_path, current_value, new_value))
+            set_nested_value(self.config, full_path, new_value)
+            print("Change staged.")
+        else:
+            print("Change cancelled.")
+    
+    def add_new_key(self):
+        """Add a new key at the current level."""
+        current_data, found = get_nested_value(self.config, self.current_path)
+        
+        if not found or not isinstance(current_data, dict):
+            print("ERROR: Cannot add key at current location")
+            return
+        
+        print("")
+        print("Add New Key")
+        print("-" * 30)
+        
+        # Get key name
+        while True:
+            key_name = input("Enter key name: ").strip()
+            is_valid, error = validate_key_name(key_name, current_data.keys())
+            if is_valid:
+                break
+            print("ERROR: {}".format(error))
+        
+        # Get value type
+        print("")
+        print("Value types:")
+        print("  1. string   - Text value")
+        print("  2. number   - Numeric value")
+        print("  3. boolean  - true/false")
+        print("  4. array    - List of values")
+        print("  5. object   - Nested structure")
+        print("")
+        
+        while True:
+            type_choice = input("Select value type (1-5): ").strip()
+            type_map = {'1': 'string', '2': 'number', '3': 'boolean', '4': 'array', '5': 'object'}
+            if type_choice in type_map:
+                value_type = type_map[type_choice]
+                break
+            print("ERROR: Invalid choice. Enter 1-5.")
+        
+        # Get value based on type
+        if value_type == 'string':
+            value_input = input("Enter string value: ").strip()
+        elif value_type == 'number':
+            value_input = input("Enter number value: ").strip()
+        elif value_type == 'boolean':
+            value_input = input("Enter boolean value (true/false): ").strip()
+        elif value_type == 'array':
+            value_input = input("Enter array values (comma-separated): ").strip()
+        elif value_type == 'object':
+            value_input = ""  # Empty object
+            print("Creating empty object. You can add keys to it later.")
+        
+        # Parse the value
+        new_value, error = parse_value_input(value_input, value_type)
+        if error:
+            print("ERROR: {}".format(error))
+            return
+        
+        # Show preview
+        new_display = format_value_for_display(new_value)
+        print("")
+        print("Preview: {}: {} ({})".format(key_name, new_display, value_type))
+        
+        # Confirm addition
+        if is_sensitive_key(key_name):
+            print("WARNING: This appears to be a sensitive key!")
+        
+        confirm = input("Add this key? (Y/N): ").strip().upper()
+        if confirm in ['Y', 'YES']:
+            # Stage the change
+            full_path = self.current_path + [key_name]
+            self.staged_changes.append((full_path, None, new_value))
+            set_nested_value(self.config, full_path, new_value)
+            print("Key added and staged.")
+        else:
+            print("Addition cancelled.")
+    
+    def show_staged_changes(self):
+        """Show all staged changes."""
+        if not self.staged_changes:
+            print("No staged changes.")
+            return
+        
+        print("")
+        print("Staged Changes:")
+        print("-" * 30)
+        
+        for i, (path, old_value, new_value) in enumerate(self.staged_changes, 1):
+            path_str = " > ".join(path)
+            if old_value is None:
+                print("{}. ADD: {} = {}".format(i, path_str, format_value_for_display(new_value)))
+            else:
+                print("{}. EDIT: {} = {} -> {}".format(
+                    i, path_str, 
+                    format_value_for_display(old_value), 
+                    format_value_for_display(new_value)
+                ))
+    
+    def save_changes(self):
+        """Save all staged changes to file."""
+        if not self.staged_changes:
+            print("No changes to save.")
+            return True
+        
+        print("")
+        print("Saving Changes...")
+        print("-" * 30)
+        
+        # Show summary
+        self.show_staged_changes()
+        print("")
+        
+        # Validate JSON structure
+        is_valid, error = validate_json_structure(self.config)
+        if not is_valid:
+            print("ERROR: {}".format(error))
+            return False
+        
+        # Create backup
+        backup_path = create_backup(self.config_path)
+        if backup_path:
+            print("Backup created: {}".format(os.path.basename(backup_path)))
+        else:
+            print("WARNING: Could not create backup")
+        
+        # Save to file
+        success, error = save_config_atomic(self.config_path, self.config)
+        if not success:
+            print("ERROR: {}".format(error))
+            return False
+        
+        # Clear cache
+        cache_success, cache_error = clear_config_cache()
+        if not cache_success:
+            print("WARNING: {}".format(cache_error))
+        
+        print("Configuration saved successfully!")
+        return True
+    
+    def process_command(self, command):
+        """Process a user command."""
+        command = command.strip().upper()
+        
+        if command == 'EXIT' or command == 'Q':
+            if self.staged_changes:
+                print("")
+                print("You have unsaved changes.")
+                self.show_staged_changes()
+                print("")
+                save_choice = input("Save changes before exiting? (Y/N): ").strip().upper()
+                if save_choice in ['Y', 'YES']:
+                    if self.save_changes():
+                        self.running = False
+                else:
+                    print("Changes discarded.")
+                    self.running = False
+            else:
+                self.running = False
+        
+        elif command == 'HELP':
+            self.print_help()
+        
+        elif command == 'DIR':
+            pass  # Will refresh display
+        
+        elif command == 'ADD':
+            self.add_new_key()
+        
+        elif command.startswith('EDIT '):
+            try:
+                item_num = int(command[5:].strip())
+                self.navigate_to_item(item_num)
+            except ValueError:
+                print("ERROR: Invalid EDIT command. Use EDIT followed by a number.")
+        
+        elif command == '0' or command == '..':
+            if self.current_path:
+                self.current_path.pop()
+            else:
+                print("Already at root level.")
+        
+        elif command.isdigit():
+            item_num = int(command)
+            self.navigate_to_item(item_num)
+        
+        else:
+            print("ERROR: Unknown command '{}'. Type HELP for available commands.".format(command))
+    
+    def run(self):
+        """Main editor loop."""
+        while self.running:
+            self.clear_screen()
+            self.print_header()
+            self.print_breadcrumb()
+            self.print_current_level()
+            self.print_commands()
+            
+            if self.staged_changes:
+                print("")
+                print("You have {} unsaved changes.".format(len(self.staged_changes)))
+            
+            try:
+                command = input("Config> ").strip()
+                if command:
+                    self.process_command(command)
+            except KeyboardInterrupt:
+                print("\n")
+                print("Interrupted by user.")
+                if self.staged_changes:
+                    save_choice = input("Save changes before exiting? (Y/N): ").strip().upper()
+                    if save_choice in ['Y', 'YES']:
+                        self.save_changes()
+                break
+            except EOFError:
+                break
+        
+        print("Config editor closed.")
+
+def main():
+    """Main entry point."""
+    if len(sys.argv) != 2:
+        print("Usage: python config_editor.py <config_path>")
+        sys.exit(1)
+    
+    # Resolve the config path using the same logic as MediLink_ConfigLoader
+    default_path = sys.argv[1]
+    config_path = resolve_config_path(default_path)
+    
+    # Ensure the directory exists (create it if needed)
+    config_dir = os.path.dirname(config_path)
+    if not os.path.exists(config_dir):
+        try:
+            os.makedirs(config_dir)
+        except OSError as e:
+            # Ignore error if directory already exists (race condition)
+            if e.errno != 17:  # EEXIST
+                print("ERROR: Could not create config directory '{}': {}".format(config_dir, str(e)))
+                sys.exit(1)
+    
+    editor = ConfigEditor(config_path)
+    editor.run()
+
+if __name__ == "__main__":
+    main()

MediBot/config_editor_helpers.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Config Editor Helper Functions
+Provides JSON loading, validation, backup, and atomic write utilities for the config editor.
+Compatible with Python 3.4.4 and Windows XP.
+"""
+
+import os
+import json
+import time
+import tempfile
+import shutil
+import platform
+from collections import OrderedDict
+
+# Sensitive keys that should trigger extra confirmation
+SENSITIVE_KEYS = ['password', 'token', 'secret', 'key', 'auth', 'credential', 'api_key', 'client_secret']
+
+def resolve_config_path(default_path):
+    """
+    Resolve the config file path using the same logic as MediLink_ConfigLoader.
+    This ensures the editor finds the config file in the same location as the main application.
+    
+    Args:
+        default_path: The default path to try first
+        
+    Returns:
+        str: The resolved config file path
+    """
+    # If the default path exists, use it
+    if os.path.exists(default_path):
+        return default_path
+    
+    # Try platform-specific fallbacks (same logic as MediLink_ConfigLoader)
+    if platform.system() == 'Windows' and platform.release() == 'XP':
+        # Use F: paths for Windows XP
+        xp_path = "F:\\Medibot\\json\\config.json"
+        if os.path.exists(xp_path):
+            return xp_path
+    elif platform.system() == 'Windows':
+        # Use current working directory for other versions of Windows
+        cwd_path = os.path.join(os.getcwd(), 'json', 'config.json')
+        if os.path.exists(cwd_path):
+            return cwd_path
+    
+    # If no fallback paths exist, return the original default path
+    # (the editor will handle the missing file gracefully)
+    return default_path
+
+def load_config_safe(config_path):
+    """
+    Safely load config.json with fallback to empty structure.
+    Returns (config_dict, error_message)
+    """
+    try:
+        if not os.path.exists(config_path):
+            return {}, "Config file not found: {}".format(config_path)
+        
+        with open(config_path, 'r', encoding='utf-8') as f:
+            config = json.load(f, object_pairs_hook=OrderedDict)
+        
+        if not isinstance(config, dict):
+            return {}, "Config file does not contain a valid JSON object"
+        
+        return config, None
+        
+    except json.JSONDecodeError as e:
+        return {}, "Invalid JSON in config file: {}".format(str(e))
+    except Exception as e:
+        return {}, "Error loading config file: {}".format(str(e))
+
+def create_backup(config_path):
+    """
+    Create a timestamped backup of the config file.
+    Returns backup_path or None if failed.
+    """
+    try:
+        if not os.path.exists(config_path):
+            return None
+        
+        # Create timestamp in format YYYYMMDD_HHMMSS
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        backup_path = "{}.bak.{}".format(config_path, timestamp)
+        
+        shutil.copy2(config_path, backup_path)
+        return backup_path
+        
+    except Exception as e:
+        print("Warning: Could not create backup: {}".format(str(e)))
+        return None
+
+def save_config_atomic(config_path, config_dict):
+    """
+    Save config dictionary to file using atomic write (temp file + rename).
+    Compatible with Windows XP.
+    Returns (success, error_message)
+    """
+    try:
+        # Create temp file in same directory as target
+        temp_dir = os.path.dirname(config_path)
+        temp_fd, temp_path = tempfile.mkstemp(suffix='.tmp', dir=temp_dir)
+        
+        try:
+            # Write to temp file
+            with os.fdopen(temp_fd, 'w', encoding='utf-8') as f:
+                json.dump(config_dict, f, ensure_ascii=False, indent=4, separators=(',', ': '))
+            
+            # Atomic rename (works on Windows XP)
+            if os.name == 'nt':  # Windows
+                if os.path.exists(config_path):
+                    os.remove(config_path)
+                os.rename(temp_path, config_path)
+            else:  # Unix-like
+                os.rename(temp_path, config_path)
+            
+            return True, None
+            
+        except Exception as e:
+            # Clean up temp file on error
+            try:
+                os.close(temp_fd)
+                if os.path.exists(temp_path):
+                    os.remove(temp_path)
+            except:
+                pass
+            raise e
+            
+    except Exception as e:
+        return False, "Error saving config: {}".format(str(e))
+
+def validate_json_structure(data):
+    """
+    Validate that data can be serialized to valid JSON.
+    Returns (is_valid, error_message)
+    """
+    try:
+        json.dumps(data, ensure_ascii=False)
+        return True, None
+    except Exception as e:
+        return False, "Invalid JSON structure: {}".format(str(e))
+
+def is_sensitive_key(key_name):
+    """
+    Check if a key name appears to be sensitive.
+    """
+    key_lower = key_name.lower()
+    return any(sensitive in key_lower for sensitive in SENSITIVE_KEYS)
+
+def get_value_type(value):
+    """
+    Determine the type of a JSON value for display purposes.
+    """
+    if isinstance(value, str):
+        return "string"
+    elif isinstance(value, (int, float)):
+        return "number"
+    elif isinstance(value, bool):
+        return "boolean"
+    elif isinstance(value, list):
+        return "array"
+    elif isinstance(value, dict):
+        return "object"
+    else:
+        return "unknown"
+
+def format_value_for_display(value, max_length=50):
+    """
+    Format a value for display in the editor, truncating if too long.
+    """
+    if isinstance(value, str):
+        if len(value) > max_length:
+            return '"{}..."'.format(value[:max_length-3])
+        else:
+            return '"{}"'.format(value)
+    elif isinstance(value, (int, float)):
+        return str(value)
+    elif isinstance(value, bool):
+        return "true" if value else "false"
+    elif isinstance(value, list):
+        return "[{} items]".format(len(value))
+    elif isinstance(value, dict):
+        return "{{{} keys}}".format(len(value))
+    else:
+        return str(value)
+
+def clear_config_cache():
+    """
+    Clear the MediLink_ConfigLoader cache after config changes.
+    """
+    try:
+        # Import here to avoid issues if MediCafe not available
+        import sys
+        import os
+        
+        # Add parent directory to path to find MediCafe
+        parent_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+        if parent_dir not in sys.path:
+            sys.path.insert(0, parent_dir)
+        
+        from MediCafe.MediLink_ConfigLoader import clear_config_cache as clear_loader_cache
+        
+        # Use the loader's own cache clearing function
+        clear_loader_cache()
+        
+        return True, None
+        
+    except Exception as e:
+        return False, "Warning: Could not clear config cache: {}".format(str(e))
+
+def get_nested_value(config, path_list):
+    """
+    Get a value from nested dictionary using path list.
+    Returns (value, found) where found is boolean.
+    """
+    current = config
+    try:
+        for key in path_list:
+            current = current[key]
+        return current, True
+    except (KeyError, TypeError):
+        return None, False
+
+def set_nested_value(config, path_list, value):
+    """
+    Set a value in nested dictionary using path list.
+    Creates intermediate dictionaries if needed.
+    """
+    current = config
+    for key in path_list[:-1]:
+        if key not in current or not isinstance(current[key], dict):
+            current[key] = OrderedDict()
+        current = current[key]
+    current[path_list[-1]] = value
+
+def get_path_string(path_list):
+    """
+    Convert path list to breadcrumb string.
+    """
+    if not path_list:
+        return "config"
+    return "config > " + " > ".join(path_list)
+
+def validate_key_name(key_name, existing_keys):
+    """
+    Validate a new key name.
+    Returns (is_valid, error_message)
+    """
+    if not key_name:
+        return False, "Key name cannot be empty"
+    
+    if key_name in existing_keys:
+        return False, "Key '{}' already exists".format(key_name)
+    
+    # Check for invalid characters that might break JSON
+    invalid_chars = ['"', '\\', '/', '\n', '\r', '\t']
+    for char in invalid_chars:
+        if char in key_name:
+            return False, "Key name contains invalid character: '{}'".format(char)
+    
+    return True, None
+
+def parse_value_input(value_str, value_type):
+    """
+    Parse user input string into appropriate Python type.
+    Returns (parsed_value, error_message)
+    """
+    try:
+        if value_type == "string":
+            # Remove surrounding quotes if present
+            if value_str.startswith('"') and value_str.endswith('"'):
+                value_str = value_str[1:-1]
+            return value_str, None
+            
+        elif value_type == "number":
+            # Try int first, then float
+            if '.' in value_str:
+                return float(value_str), None
+            else:
+                return int(value_str), None
+                
+        elif value_type == "boolean":
+            value_lower = value_str.lower()
+            if value_lower in ['true', 't', 'yes', 'y', '1']:
+                return True, None
+            elif value_lower in ['false', 'f', 'no', 'n', '0']:
+                return False, None
+            else:
+                return None, "Invalid boolean value. Use true/false, yes/no, or 1/0"
+                
+        elif value_type == "array":
+            # Simple array parsing - comma separated values
+            if not value_str.strip():
+                return [], None
+            
+            # Split by comma and strip whitespace
+            items = [item.strip() for item in value_str.split(',')]
+            return items, None
+            
+        elif value_type == "object":
+            # For now, return empty object - user can add keys later
+            return OrderedDict(), None
+            
+        else:
+            return None, "Unknown value type: {}".format(value_type)
+            
+    except ValueError as e:
+        return None, "Invalid value format: {}".format(str(e))
+    except Exception as e:
+        return None, "Error parsing value: {}".format(str(e))

MediCafe/__init__.py

@@ -27,7 +27,7 @@ Smart Import System:
         api_suite = get_api_access()
 """
 
-__version__ = "0.251027.3"
+__version__ = "0.251030.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

MediLink/MediLink_Gmail.py

@@ -458,10 +458,19 @@ def open_browser_with_executable(url, browser_path=None):
 def initiate_link_retrieval(config):
     log("Initiating browser via implicit GET.")
     medi = extract_medilink_config(config)
-    url_get = "https://script.google.com/macros/s/{}/exec?action=get_link".format(medi.get('webapp_deployment_id', ''))
+    dep_id = (medi.get('webapp_deployment_id', '') or '').strip()
+    if not dep_id:
+        log("webapp_deployment_id is empty. Please set it in config before continuing.")
+        shutdown_event.set()
+        return
+    url_get = "https://script.google.com/macros/s/{}/exec?action=get_link".format(dep_id)
+    try:
+        log("Opening GAS web app: {}".format(url_get))
+    except Exception:
+        pass
     open_browser_with_executable(url_get)
     log("Preparing POST call.")
-    url = "https://script.google.com/macros/s/{}/exec".format(medi.get('webapp_deployment_id', ''))
+    url = "https://script.google.com/macros/s/{}/exec".format(dep_id)
     downloaded_emails = list(load_downloaded_emails())
     payload = {"downloadedEmails": downloaded_emails}
     access_token = get_access_token()

MediLink/__init__.py

@@ -22,7 +22,7 @@ Smart Import Integration:
         datamgmt = get_components('medilink_datamgmt')
 """
 
-__version__ = "0.251027.3"
+__version__ = "0.251030.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

MediLink/webapp.html

@@ -177,7 +177,13 @@
         </main>
     <script>
         document.addEventListener("DOMContentLoaded", () => {
-            console.log("Document ready, initializing flows...");
+            try {
+                var params = new URLSearchParams(window.location.search || '');
+                var actionParam = params.get('action');
+                console.log("Document ready, initializing flows... action=", actionParam);
+            } catch (e) {
+                console.log("Document ready, initializing flows...");
+            }
             // initializeEmailListFlow();
             initializeDocxEmailListFlow();
         });

{medicafe-0.251027.3.dist-info → medicafe-0.251030.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.251027.3
+Version: 0.251030.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2/MediCafe
 Author: Daniel Vidaud

{medicafe-0.251027.3.dist-info → medicafe-0.251030.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-MediBot/MediBot.bat,sha256=mBoD0Dit4Om_iGgSbSoVZ0d0kScGWofA7qaYqhlJhWo,29161
+MediBot/MediBot.bat,sha256=z8LmLbqdi_CmpUSN5EBDFl29Xe9sgFBjCgewW4-Wq54,29380
 MediBot/MediBot.py,sha256=ABSqWikb_c1VSuR4n8Vh5YfOqzDCi2jnnp3sg_xOYg0,51092
 MediBot/MediBot_Charges.py,sha256=a28if_f_IoazIHiqlaFosFnfEgEoCwb9LQ6aOyk5-D0,10704
 MediBot/MediBot_Crosswalk_Library.py,sha256=6LrpRx2UKVeH3TspS9LpR93iw5M7nTqN6IYpC-6PPGE,26060
@@ -12,8 +12,11 @@ MediBot/MediBot_dataformat_library.py,sha256=D46fdPtxcgfWTzaLBtSvjtozzZBNqNiODgu
 MediBot/MediBot_debug.bat,sha256=F5Lfi3nFEEo4Ddx9EbX94u3fNAMgzMp3wsn-ULyASTM,6017
 MediBot/MediBot_docx_decoder.py,sha256=9BSjV-kB90VHnqfL_5iX4zl5u0HcHvHuL7YNfx3gXpQ,33143
 MediBot/MediBot_smart_import.py,sha256=Emvz7NwemHGCHvG5kZcUyXMcCheidbGKaPfOTg-YCEs,6684
-MediBot/__init__.py,sha256=W7JANBDt-VBMAzdtL-KXgJ3-ODNLji-8stnIn38LUIQ,3192
+MediBot/__init__.py,sha256=XbpIvNejZ4LpOh_pRbEyb46jxmqGfzyZAtyRTfAPK0k,3192
 MediBot/clear_cache.bat,sha256=F6-VhETWw6xDdGWG2wUqvtXjCl3lY4sSUFqF90bM8-8,1860
+MediBot/config_editor.bat,sha256=gwR_GP5a72vhrij6U8e1jH48xQDwLgLY3vEJI9KZtcs,2340
+MediBot/config_editor.py,sha256=fwFMhHA7xmrHUW_V7XY7HfjWeY19BFje1Z-D0mK70zA,15788
+MediBot/config_editor_helpers.py,sha256=7jsBg9NpDla09EuT0nvKgk4EmIEbyH8vma92lfk88uM,10510
 MediBot/crash_diagnostic.bat,sha256=j8kUtyBg6NOWbXpeFuEqIRHOkVzgUrLOqO3FBMfNxTo,9268
 MediBot/f_drive_diagnostic.bat,sha256=4572hZaiwZ5wVAarPcZJQxkOSTwAdDuT_X914noARak,6878
 MediBot/full_debug_suite.bat,sha256=b3Euz-VbRaPE6tWmgpjApfv4_cB5-Rk8BLNlLrp2bpo,2223
@@ -22,7 +25,7 @@ MediBot/process_csvs.bat,sha256=3tI7h1z9eRj8rUUL4wJ7dy-Qrak20lRmpAPtGbUMbVQ,3489
 MediBot/update_json.py,sha256=vvUF4mKCuaVly8MmoadDO59M231fCIInc0KI1EtDtPA,3704
 MediBot/update_medicafe.py,sha256=G1lyvVOHYuho1d-TJQNN6qaB4HBWaJ2PpXqemBoPlRQ,17937
 MediCafe/MediLink_ConfigLoader.py,sha256=heTbZ0ItwlpxqbAb0oV2dbTFRSTMnZyhBT9fS8nI0YU,12735
-MediCafe/__init__.py,sha256=56u8QPxfilu-bGcU5MF8kleMtvRMpsOVEQ1VKKlZai4,5721
+MediCafe/__init__.py,sha256=R7IiwM-8skk7HPc2qpkE1U8pVyUt7IreovdKhSfYkMA,5721
 MediCafe/__main__.py,sha256=NZMgsjuXYF39YS7mCWMjTO0vYf_0IAotQpNyUXfbahs,13233
 MediCafe/api_core.py,sha256=wLAdRNZdmovKReXvzsmAgKrbYon4-wbJbGCyOm_C3AU,89896
 MediCafe/api_factory.py,sha256=I5AeJoyu6m7oCrjc2OvVvO_4KSBRutTsR1riiWhTZV0,12086
@@ -51,7 +54,7 @@ MediLink/MediLink_Deductible.py,sha256=opGa5YQ6tfowurlf8xDWRtAtQMmoNYout0gYe3R5f
 MediLink/MediLink_Deductible_Validator.py,sha256=x6tHJOi88TblUpDPSH6QhIdXXRgr3rXI7kYPVGZYCgU,24998
 MediLink/MediLink_Display_Utils.py,sha256=MonsX6VPbdvqwY_V8sHUYrXCS0fMKc4toJvG0oyr-V4,24872
 MediLink/MediLink_Down.py,sha256=s4_z-RaqHYanjwbQCl-OSkg4XIpcIQ2Q6jXa8-q_QXw,28111
-MediLink/MediLink_Gmail.py,sha256=Gnc-tI8ACeFaw0YVPp5JUBAXhwYfptY8QGxShJu4Pbg,31476
+MediLink/MediLink_Gmail.py,sha256=JuDyO8mckxwRtO8Jfty37lpbgTIA91x8LpEb6y9l_iU,31742
 MediLink/MediLink_Mailer.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 MediLink/MediLink_Parser.py,sha256=eRVZ4ckZ5gDOrcvtCUZP3DOd3Djly66rCIk0aYXLz14,12567
 MediLink/MediLink_PatientProcessor.py,sha256=9r2w4p45d30Tn0kbXL3j5574MYOehP83tDirNOw_Aek,19977
@@ -63,15 +66,15 @@ MediLink/MediLink_insurance_utils.py,sha256=g741Fj2K26cMy0JX5d_XavMw9LgkK6hjaUJY
 MediLink/MediLink_main.py,sha256=1nmDtbJ9IfPwLnFhCZvDtBPSG_8gzj6LneuoV60l4IQ,26736
 MediLink/MediLink_smart_import.py,sha256=ZUXvAkIA2Pk2uuyLZazKfKK8YGdkZt1VAeZo_ZSUyxk,9942
 MediLink/Soumit_api.py,sha256=5JfOecK98ZC6NpZklZW2AkOzkjvrbYxpJpZNH3rFxDw,497
-MediLink/__init__.py,sha256=I6BiRTvpQ5QhK_7dLbb_4VFtyYWZf1nH2dLX1OYtgr0,3888
+MediLink/__init__.py,sha256=OIl0UcNgWUpkZClnyh099Hq_sTH6TaddlcY7qpK66oM,3888
 MediLink/gmail_http_utils.py,sha256=mYChIhkbA1oJaAJA-nY3XgHQY-H7zvZJUZPhUagomsI,4047
 MediLink/gmail_oauth_utils.py,sha256=Ugr-DEqs4_RddRMSCJ_dbgA3TVeaxpbAor-dktcTIgY,3713
 MediLink/openssl.cnf,sha256=76VdcGCykf0Typyiv8Wd1mMVKixrQ5RraG6HnfKFqTo,887
 MediLink/test.py,sha256=DM_E8gEbhbVfTAm3wTMiNnK2GCD1e5eH6gwTk89QIc4,3116
-MediLink/webapp.html,sha256=DwDYjVvluGJ7eDdvEogfKN4t24ZJRoIUuSBfCYCL-3w,21252
-medicafe-0.251027.3.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
-medicafe-0.251027.3.dist-info/METADATA,sha256=xsE3H4MHme5SYio00FfRVaSBO51wYxwQIC190GL8_7Y,3414
-medicafe-0.251027.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-medicafe-0.251027.3.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
-medicafe-0.251027.3.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
-medicafe-0.251027.3.dist-info/RECORD,,
+MediLink/webapp.html,sha256=SSBuPCtdv7dWj_ZiMfkCj7LRIjma6YHVJMDHjoBIdyk,21547
+medicafe-0.251030.0.dist-info/LICENSE,sha256=65lb-vVujdQK7uMH3RRJSMwUW-WMrMEsc5sOaUn2xUk,1096
+medicafe-0.251030.0.dist-info/METADATA,sha256=oOPTKfF8Iw-0JSxfpB6tGqSJQpGuLTASjKi2k43ZQp4,3414
+medicafe-0.251030.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+medicafe-0.251030.0.dist-info/entry_points.txt,sha256=m3RBUBjr-xRwEkKJ5W4a7NlqHZP_1rllGtjZnrRqKe8,52
+medicafe-0.251030.0.dist-info/top_level.txt,sha256=U6-WBJ9RCEjyIs0BlzbQq_PwedCp_IV9n1616NNV5zA,26
+medicafe-0.251030.0.dist-info/RECORD,,