- Partner model additions

- menu changes to allow for partners
- partner views and forms now in partner_forms.py and partner_views.py
- Introduction of services layer
- Allow all configuration to handle partner configurations, and adaptation of caching to allow for this

common/utils/cache/config_cache.py

@@ -62,13 +62,7 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
     def _load_specific_config(self, type_name: str, version_str: str) -> Dict[str, Any]:
         """
         Load a specific configuration version
-
-        Args:
-            type_name: Type name
-            version_str: Version string
-
-        Returns:
-            Configuration data
+        Automatically handles global vs partner-specific configs
         """
         version_tree = self.version_tree_cache.get_versions(type_name)
         versions = version_tree['versions']
@@ -79,11 +73,16 @@ class BaseConfigCacheHandler(CacheHandler[Dict[str, Any]]):
         if version_str not in versions:
             raise ValueError(f"Version {version_str} not found for {type_name}")
 
-        file_path = versions[version_str]['file_path']
+        version_info = versions[version_str]
+        file_path = version_info['file_path']
+        partner = version_info.get('partner')
 
         try:
             with open(file_path) as f:
                 config = yaml.safe_load(f)
+                # Add partner information to the config
+                if partner:
+                    config['partner'] = partner
                 return config
         except Exception as e:
             raise ValueError(f"Error loading config from {file_path}: {e}")
@@ -133,20 +132,37 @@ class BaseConfigVersionTreeCacheHandler(CacheHandler[Dict[str, Any]]):
     def _load_version_tree(self, type_name: str) -> Dict[str, Any]:
         """
         Load version tree for a specific type without loading full configurations
-
-        Args:
-            type_name: Name of configuration type
-
-        Returns:
-            Dict containing available versions and their metadata
+        Checks both global and partner-specific directories
         """
-        type_path = Path(self._config_dir) / type_name
-        if not type_path.exists():
+        # First check the global path
+        global_path = Path(self._config_dir) / "global" / type_name
+
+        # If global path doesn't exist, check if the type exists directly in the root
+        # (for backward compatibility)
+        if not global_path.exists():
+            global_path = Path(self._config_dir) / type_name
+
+        if not global_path.exists():
+            # Check if it exists in any partner subdirectories
+            partner_dirs = [d for d in Path(self._config_dir).iterdir()
+                            if d.is_dir() and d.name != "global"]
+
+            for partner_dir in partner_dirs:
+                partner_type_path = partner_dir / type_name
+                if partner_type_path.exists():
+                    # Found in partner directory
+                    return self._load_versions_from_path(partner_type_path)
+
+            # If we get here, the type wasn't found anywhere
             raise ValueError(f"No configuration found for type {type_name}")
 
-        version_files = list(type_path.glob('*.yaml'))
+        return self._load_versions_from_path(global_path)
+
+    def _load_versions_from_path(self, path: Path) -> Dict[str, Any]:
+        """Load all versions from a specific path"""
+        version_files = list(path.glob('*.yaml'))
         if not version_files:
-            raise ValueError(f"No versions found for type {type_name}")
+            raise ValueError(f"No versions found in {path}")
 
         versions = {}
         latest_version = None
@@ -160,9 +176,17 @@ class BaseConfigVersionTreeCacheHandler(CacheHandler[Dict[str, Any]]):
                 with open(file_path) as f:
                     yaml_data = yaml.safe_load(f)
                     metadata = yaml_data.get('metadata', {})
+                    # Add partner information if available
+                    partner = None
+                    if "global" not in str(file_path):
+                        # Extract partner name from path
+                        # Path format: config_dir/partner_name/type_name/version.yaml
+                        partner = file_path.parent.parent.name
+
                     versions[ver] = {
                         'metadata': metadata,
-                        'file_path': str(file_path)
+                        'file_path': str(file_path),
+                        'partner': partner
                     }
 
                 # Track latest version
@@ -316,7 +340,8 @@ class BaseConfigTypesCacheHandler(CacheHandler[Dict[str, Any]]):
         type_definitions = {
             type_id: {
                 'name': info['name'],
-                'description': info['description']
+                'description': info['description'],
+                'partner': info.get('partner')  # Include partner info if available
             }
             for type_id, info in self._types_module.items()
         }