Make one config handler for Jurisdictionso

YAML parsing of the jurisdiction configs was originally handled in
multiple places, with duplicate configs all around.

This PR puts all of the config info for each jurisdiction in
its YAML file, and reads it everywhere that jurisdiction configs are
used. No more multiple parsing functions[^1].


[^1]: Okay, one parsing function: left in `get_case_type_config`, since it's
      unclear to me if case_types in jurisdictions should contain all of the base
      case types or just the ones they've defined / overriden. Need more understanding
      to make that choice, so I left the code as is there.

Author: BryceStevenWilley

efile_app/efile/api/case_form_views.py

@@ -14,6 +14,8 @@
 import yaml
 from django.views.decorators.http import require_http_methods
 
+from ..utils.config_loader import config_loader
+
 from .base import APIResponseMixin
 
 logger = logging.getLogger(__name__)
@@ -22,117 +24,6 @@
 class CaseFormAPIViews(APIResponseMixin):
     """API views for dynamic case form configuration"""
 
-    @staticmethod
-    @lru_cache(maxsize=32)
-    def _load_base_configuration():
-        """Load base case type configuration from base-case-types.yaml"""
-        try:
-            config_path = os.path.join(
-                os.path.dirname(os.path.dirname(__file__)), "static", "config", "base-case-types.yaml"
-            )
-
-            with open(config_path, encoding="utf-8") as file:
-                return yaml.safe_load(file) or {}
-        except Exception as e:
-            logger.exception(f"Error loading base-case-types.yaml: {e}")
-            return {}
-
-    @staticmethod
-    @lru_cache(maxsize=32)
-    def _load_jurisdiction_configuration(jurisdiction="illinois"):
-        """Load jurisdiction-specific configuration and merge with base"""
-        try:
-            # Load base configuration first
-            base_config = CaseFormAPIViews._load_base_configuration()
-
-            # Load jurisdiction-specific configuration
-            config_path = os.path.join(
-                os.path.dirname(os.path.dirname(__file__)), "static", "config", "states", f"{jurisdiction}.yaml"
-            )
-
-            jurisdiction_config = {}
-            if os.path.exists(config_path):
-                with open(config_path, encoding="utf-8") as file:
-                    jurisdiction_config = yaml.safe_load(file) or {}
-
-            # Merge configurations - jurisdiction overrides base
-            return CaseFormAPIViews._deep_merge_configs(base_config, jurisdiction_config)
-
-        except Exception as e:
-            logger.exception(f"Error loading jurisdiction configuration for {jurisdiction}: {e}")
-            return CaseFormAPIViews._load_base_configuration()
-
-    @staticmethod
-    def _deep_merge_configs(base, overlay):
-        """Deep merge two configuration dictionaries"""
-        merged = base.copy()
-
-        for key, value in overlay.items():
-            if key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
-                merged[key] = CaseFormAPIViews._deep_merge_configs(merged[key], value)
-            else:
-                merged[key] = value
-
-        return merged
-
-    @staticmethod
-    def _find_case_type_config(case_type_name, jurisdiction="illinois"):
-        """Find case type configuration by matching keywords in merged config"""
-        config = CaseFormAPIViews._load_jurisdiction_configuration(jurisdiction)
-
-        # Check both case_types and base_case_types sections
-        case_types_sources = [config.get("case_types", {}), config.get("base_case_types", {})]
-
-        case_type_name_lower = case_type_name.lower()
-        found_config = None
-
-        print(f"� Looking for case type: '{case_type_name}' (lower: '{case_type_name_lower}')")
-
-        for case_types in case_types_sources:
-            # Try exact match first
-            if case_type_name_lower in case_types:
-                found_config = case_types[case_type_name_lower]
-                break
-
-            # Try keyword matching
-            for _case_type_key, case_type_config in case_types.items():
-                if "keywords" in case_type_config:
-                    for keyword in case_type_config["keywords"]:
-                        # Check both substring matching and exact matching
-                        keyword_lower = keyword.lower()
-                        if (
-                            keyword_lower in case_type_name_lower
-                            or case_type_name_lower in keyword_lower
-                            or keyword_lower == case_type_name_lower
-                        ):
-                            found_config = case_type_config
-                            break
-                if found_config:
-                    break
-            if found_config:
-                break
-
-        if not found_config:
-            return None
-
-        # Resolve inheritance if extends is present
-        if "extends" in found_config:
-            extends_ref = found_config["extends"]
-            base_config = None
-
-            # Parse the extends reference (e.g., "base_case_types.name_change")
-            if "." in extends_ref:
-                section, key = extends_ref.split(".", 1)
-                if section in config and key in config[section]:
-                    base_config = config[section][key]
-
-            if base_config:
-                # Deep merge base config with the current config
-                merged_config = CaseFormAPIViews._deep_merge_configs(base_config.copy(), found_config)
-                return merged_config
-
-        return found_config
-
     @staticmethod
     @require_http_methods(["GET"])
     def get_case_form_config(request):
@@ -159,7 +50,7 @@ def get_case_form_config(request):
             # Try to find case type configuration using jurisdiction-aware lookup
             case_config = None
             if case_type_id:
-                case_config = CaseFormAPIViews._find_case_type_config(case_type_id, jurisdiction)
+                case_config = config_loader.get_case_type_config(jurisdiction, case_type_id, court_code)
 
             # If no specific configuration found, return minimal structure
             if not case_config:
@@ -178,13 +69,6 @@ def get_case_form_config(request):
                     }
                 )
 
-            # Apply court-specific customizations if they exist
-            sections = case_config.get("sections", {})
-            if court_code:
-                sections = CaseFormAPIViews._apply_court_specific_config(
-                    sections, court_code, case_type_id, jurisdiction
-                )
-
             # Structure the response based on the new configuration format
             form_config = {
                 "case_info": {
@@ -205,68 +89,3 @@ def get_case_form_config(request):
 
         except Exception as e:
             return CaseFormAPIViews.error_response(f"Error retrieving case form configuration: {str(e)}")
-
-    @staticmethod
-    def _apply_court_specific_config(sections, court_code, case_type_id, jurisdiction):
-        """Apply court-specific configurations and conditional requirements"""
-        try:
-            config = CaseFormAPIViews._load_jurisdiction_configuration(jurisdiction)
-            court_requirements = config.get("court_specific_requirements", {}).get(court_code, {})
-
-            if not court_requirements:
-                return sections
-
-            case_specific = court_requirements.get("case_types", {}).get(case_type_id, {})
-            if not case_specific:
-                return sections
-
-            # Apply field modifications first
-            field_modifications = case_specific.get("field_modifications", [])
-            for modification in field_modifications:
-                field_group_name = modification.get("field_group")
-                modifications = modification.get("modifications", {})
-
-                # Apply modifications to the matching field group
-                if "parties" in sections and "fields" in sections["parties"]:
-                    # Use a copy of the list to avoid modification during iteration
-                    fields_list = sections["parties"]["fields"][:]
-                    for field_group in fields_list:
-                        if field_group.get("section_title") == field_group_name:
-                            # Apply modifications to this field group
-                            for key, value in modifications.items():
-                                if key == "hidden" and value:
-                                    # Remove this field group entirely if hidden
-                                    if field_group in sections["parties"]["fields"]:
-                                        sections["parties"]["fields"].remove(field_group)
-                                    break
-                                elif key == "required":
-                                    field_group["required"] = value
-                                elif key == "conditional_requirements":
-                                    field_group["conditional_requirements"] = value
-                            break
-
-            # Apply additional fields
-            additional_fields = case_specific.get("additional_fields", [])
-            if additional_fields and "parties" in sections and "fields" in sections["parties"]:
-                # Add additional fields to the first section of parties
-                if sections["parties"]["fields"]:
-                    first_section = sections["parties"]["fields"][0]
-                    if "fields" in first_section:
-                        # Check for existing fields to prevent duplicates
-                        existing_field_names = {field.get("name") for field in first_section["fields"]}
-
-                        # Only add fields that don't already exist
-                        new_fields = []
-                        for field in additional_fields:
-                            field_name = field.get("name")
-                            if field_name and field_name not in existing_field_names:
-                                new_fields.append(field)
-
-                        if new_fields:
-                            first_section["fields"].extend(new_fields)
-
-            return sections
-
-        except Exception as e:
-            logger.exception(f"Error applying court-specific config: {e}")
-            return sections

efile_app/efile/api/case_type_config.py

@@ -1,6 +1,7 @@
 from django.http import JsonResponse
 
 from .case_form_views import CaseFormAPIViews
+from ..utils.config_loader import JurisdictionConfigLoader, config_loader
 
 
 def get_case_type_config(request):
@@ -11,11 +12,13 @@ def get_case_type_config(request):
         jurisdiction = request.GET.get("jurisdiction") or request.session.get("jurisdiction", "illinois")
 
         # Use the new jurisdiction-aware configuration loader
-        config_data = CaseFormAPIViews._load_jurisdiction_configuration(jurisdiction)
+        config_data = config_loader.load_jurisdiction_config(jurisdiction)
 
         # Process case types to ensure proper inheritance from base_case_types
         processed_case_types = {}
 
+        # TODO(brycew): decide if jurisdictions get all from base_case_types, or
+        # just the listed ones. Remove this if it's the latter.
         # First, add all base case types
         if "base_case_types" in config_data:
             for key, value in config_data["base_case_types"].items():
@@ -30,7 +33,7 @@ def get_case_type_config(request):
                     jurisdiction_config = value.copy()
 
                     # Deep merge the configurations
-                    merged_config = CaseFormAPIViews._deep_merge_configs(base_config, jurisdiction_config)
+                    merged_config = JurisdictionConfigLoader._deep_merge(base_config, jurisdiction_config)
                     processed_case_types[key] = merged_config
                 else:
                     # New case type not in base

efile_app/efile/api/config_views.py

@@ -9,37 +9,14 @@
 
 from .base import APIResponseMixin
 from .case_form_views import CaseFormAPIViews
+from ..utils.config_loader import config_loader
 
 logger = logging.getLogger(__name__)
 
 
 class ConfigAPIViews(APIResponseMixin):
     """API views for form configuration - delegates to CaseFormAPIViews for jurisdiction-aware configs"""
 
-    @staticmethod
-    def _find_config_key_for_case_type(case_type_id, jurisdiction="illinois"):
-        """Find the config key (like 'name_change') that corresponds to a case type ID (like '78346')"""
-        try:
-            config = CaseFormAPIViews._load_jurisdiction_configuration(jurisdiction)
-            case_types_sources = [config.get("case_types", {}), config.get("base_case_types", {})]
-
-            case_type_id_lower = case_type_id.lower()
-
-            for case_types in case_types_sources:
-                for case_type_key, case_type_config in case_types.items():
-                    if "keywords" in case_type_config:
-                        for keyword in case_type_config["keywords"]:
-                            keyword_lower = keyword.lower()
-                            if (
-                                keyword_lower in case_type_id_lower
-                                or case_type_id_lower in keyword_lower
-                                or keyword_lower == case_type_id_lower
-                            ):
-                                return case_type_key
-            return None
-        except Exception:
-            return None
-
     @staticmethod
     @require_http_methods(["GET"])
     def get_form_config(request):
@@ -62,7 +39,7 @@ def get_form_config(request):
                 return ConfigAPIViews.error_response("Missing required parameter: case_type")
 
             # Use the new jurisdiction-aware configuration system
-            case_config = CaseFormAPIViews._find_case_type_config(case_type_id, jurisdiction)
+            case_config = config_loader.get_case_type_config(jurisdiction, case_type_id, court=court_code)
 
             # If no specific configuration found, return minimal structure
             if not case_config:
@@ -76,15 +53,7 @@ def get_form_config(request):
                     }
                 )
 
-            # Apply court-specific customizations if they exist
             sections = case_config.get("sections", {})
-            if court_code:
-                # For court-specific modifications, we need to use the config key (like "name_change")
-                # not the case type ID (like "78346"). Find the config key by reverse lookup.
-                case_config_key = ConfigAPIViews._find_config_key_for_case_type(case_type_id, jurisdiction)
-                sections = CaseFormAPIViews._apply_court_specific_config(
-                    sections, court_code, case_config_key or case_type_id, jurisdiction
-                )
 
             # Structure the response in the expected format
             config = {

efile_app/efile/context_processors.py

@@ -2,32 +2,17 @@
 Context processors for jurisdiction-aware templates
 """
 
+from .utils.config_loader import config_loader
 
 def jurisdiction_context(request):
     """Add current jurisdiction to all template contexts"""
     current_jurisdiction = request.session.get("jurisdiction", "illinois")
 
-    jurisdiction_configs = {
-        "illinois": {
-            "name": "Illinois eFile",
-            "code": "illinois",
-            "display_name": "Illinois",
-            "icon": "fas fa-balance-scale",
-            "api_endpoint": "/api/illinois/",
-            "config_file": "illinois.yaml",
-        },
-        "massachusetts": {
-            "name": "Massachusetts eFile",
-            "code": "massachusetts",
-            "display_name": "Massachusetts",
-            "icon": "fas fa-balance-scale",
-            "api_endpoint": "/api/massachusetts/",
-            "config_file": "massachusetts.yaml",
-        },
-    }
+    config = config_loader.get_short_jurisdiction_config(current_jurisdiction)
 
     return {
         "current_jurisdiction": current_jurisdiction,
-        "jurisdiction_config": jurisdiction_configs.get(current_jurisdiction, jurisdiction_configs["illinois"]),
-        "available_jurisdictions": jurisdiction_configs,
+        # Returns just a subset of the keys in the config
+        "jurisdiction_config": config,
+        "available_jurisdictions": {code: config_loader.get_short_jurisdiction_config(code) for code in config_loader.get_available_jurisdictions()},
     }

efile_app/efile/static/config/states/illinois.yaml

@@ -1,7 +1,15 @@
 # Illinois-specific Case Type Configuration
 # This file extends the base configuration with Illinois-specific settings
 
-# State metadata
+# High level metadata
+jurisdiction:
+  name: "Illinois eFile"
+  code: "illinois"
+  display_name: "Illinois"
+  icon: "fas fa-balance-scale"
+  api_endpoint: "/api/illinois"
+
+# State metadata, for the address
 state:
   code: "IL"
   name: "Illinois"

efile_app/efile/static/config/states/massachusetts.yaml

@@ -3,6 +3,13 @@
 # Massachusetts-specific Case Type Configuration
 # This file extends the base configuration with Massachusetts-specific settings
 
+jurisdiction:
+  name: "Massachusetts eFile"
+  code: "massachusetts"
+  display_name: "Massachusetts"
+  icon: "fas fa-balance-scale"
+  api_endpoint: "/api/massachusetts"
+
 # State metadata
 state:
   code: "MA"