d365fo-client 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

d365fo_client/metadata_v2/cache_v2.py

@@ -213,17 +213,19 @@ class MetadataCacheV2:
             entities: List of data entity information
         """
         async with aiosqlite.connect(self.db_path) as db:
-            # Clear existing entities for this version
-            await db.execute(
-                "DELETE FROM data_entities WHERE global_version_id = ?",
-                (global_version_id,),
-            )
+            
 
             # Insert new entities with label processing
             for entity in entities:
                 # Process label fallback for this entity
                 processed_label_text = process_label_fallback(entity.label_id, entity.label_text)
-                
+
+                # Clear existing entity for this version
+                await db.execute(
+                    "DELETE FROM data_entities WHERE global_version_id = ? and name = ?",
+                    (global_version_id, entity.name,),
+                )
+                    
                 await db.execute(
                     """INSERT INTO data_entities
                        (global_version_id, name, public_entity_name, public_collection_name,
@@ -237,7 +239,7 @@ class MetadataCacheV2:
                         entity.public_collection_name,
                         entity.label_id,
                         processed_label_text,  # Use processed label text
-                        entity.entity_category.value if entity.entity_category else None,
+                        entity.entity_category if entity.entity_category else None,
                         entity.data_service_enabled,
                         entity.data_management_enabled,
                         entity.is_read_only,
@@ -245,7 +247,7 @@ class MetadataCacheV2:
                 )
 
             await db.commit()
-            logger.info(
+            logger.debug(
                 f"Stored {len(entities)} data entities for version {global_version_id}"
             )
 
@@ -481,7 +483,7 @@ class MetadataCacheV2:
                         nav_prop.name,
                         nav_prop.related_entity,
                         nav_prop.related_relation_name,
-                        nav_prop.cardinality.value,  # Convert enum to string value
+                        nav_prop.cardinality,  # StrEnum automatically converts to string
                     ),
                 )
 
@@ -519,7 +521,7 @@ class MetadataCacheV2:
                         entity_id,
                         global_version_id,
                         action.name,
-                        action.binding_kind.value,  # Convert enum to string value
+                        action.binding_kind,  # StrEnum automatically converts to string
                         entity_schema.name,
                         entity_schema.entity_set_name,
                         action.return_type.type_name if action.return_type else None,
@@ -1357,7 +1359,7 @@ class MetadataCacheV2:
             )
             await db.commit()
 
-        logger.info(
+        logger.debug(
             f"Batch cached {len(labels)} labels for version {global_version_id}"
         )
 
@@ -1495,19 +1497,24 @@ class MetadataCacheV2:
         """Get cache statistics
 
         Returns:
-            Dictionary with cache statistics
+            Dictionary with cache statistics scoped to the current environment
         """
+        await self.initialize()
+        
+        if self._environment_id is None:
+            raise ValueError("Environment not initialized")
+            
         stats = {}
 
-        # Database statistics
-        db_stats = await self.database.get_database_statistics()
+        # Environment-scoped database statistics
+        db_stats = await self.database.get_environment_database_statistics(self._environment_id)
         stats.update(db_stats)
 
-        # Version statistics
-        version_stats = await self.version_manager.get_version_statistics()
+        # Environment-scoped version statistics
+        version_stats = await self.version_manager.get_environment_version_statistics(self._environment_id)
         stats["version_manager"] = version_stats
 
-        # Current version info
+        # Current version info (already environment-scoped)
         current_version = await self._get_current_global_version_id()
         if current_version:
             version_info = await self.version_manager.get_global_version_info(
@@ -1517,11 +1524,11 @@ class MetadataCacheV2:
                 stats["current_version"] = {
                     "global_version_id": version_info.id,
                     "version_hash": version_info.version_hash,
-                    "modules_count": len(version_info.sample_modules),
+                    "modules_count": len(version_info.modules),
                     "reference_count": version_info.reference_count,
                 }
 
-        # Label cache statistics
+        # Label cache statistics (already environment-scoped via current_version)
         label_stats = await self.get_label_cache_statistics(current_version)
         stats["label_cache"] = label_stats
 

d365fo_client/metadata_v2/database_v2.py

@@ -542,6 +542,99 @@ class MetadataDatabaseV2:
 
             return stats
 
+    async def get_statistics(self) -> Dict[str, Any]:
+        """Alias for get_database_statistics for backward compatibility
+
+        Returns:
+            Dictionary with database statistics
+        """
+        return await self.get_database_statistics()
+
+    async def get_environment_database_statistics(self, environment_id: int) -> Dict[str, Any]:
+        """Get database statistics scoped to a specific environment
+
+        Args:
+            environment_id: Environment ID to get statistics for
+
+        Returns:
+            Dictionary with environment-scoped database statistics
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            stats = {}
+
+            # Get active global versions for this environment
+            cursor = await db.execute(
+                """SELECT DISTINCT global_version_id 
+                   FROM environment_versions 
+                   WHERE environment_id = ? AND is_active = 1""",
+                (environment_id,)
+            )
+            active_versions = [row[0] for row in await cursor.fetchall()]
+            
+            if not active_versions:
+                # No active versions, return zero counts
+                return {
+                    "data_entities_count": 0,
+                    "public_entities_count": 0,
+                    "entity_properties_count": 0,
+                    "navigation_properties_count": 0,
+                    "entity_actions_count": 0,
+                    "enumerations_count": 0,
+                    "labels_cache_count": 0,
+                    "environment_statistics": {
+                        "total_environments": 1,
+                        "linked_versions": 0,
+                    },
+                    "database_size_bytes": None,
+                    "database_size_mb": None,
+                }
+
+            # Create placeholders for SQL IN clause
+            version_placeholders = ",".join("?" for _ in active_versions)
+
+            # Environment-scoped metadata counts
+            tables = [
+                ("data_entities", "entities"),
+                ("public_entities", "public_entities"),
+                ("entity_properties", "properties"),
+                ("navigation_properties", "navigation_properties"),
+                ("entity_actions", "actions"),
+                ("enumerations", "enumerations"),
+                ("labels_cache", "labels"),
+            ]
+
+            for table, key in tables:
+                cursor = await db.execute(
+                    f"SELECT COUNT(*) FROM {table} WHERE global_version_id IN ({version_placeholders})",
+                    active_versions
+                )
+                stats[f"{table}_count"] = (await cursor.fetchone())[0]
+
+            # Environment-specific statistics
+            cursor = await db.execute(
+                """SELECT 
+                     COUNT(DISTINCT ev.global_version_id) as linked_versions
+                   FROM environment_versions ev
+                   WHERE ev.environment_id = ? AND ev.is_active = 1""",
+                (environment_id,)
+            )
+            env_stats = await cursor.fetchone()
+            stats["environment_statistics"] = {
+                "total_environments": 1,  # Current environment only
+                "linked_versions": env_stats[0] or 0,
+            }
+
+            # Database file size (shared across all environments)
+            try:
+                db_size = self.db_path.stat().st_size
+                stats["database_size_bytes"] = db_size
+                stats["database_size_mb"] = round(db_size / (1024 * 1024), 2)
+            except Exception:
+                stats["database_size_bytes"] = None
+                stats["database_size_mb"] = None
+
+            return stats
+
     async def vacuum_database(self) -> bool:
         """Vacuum database to reclaim space
 

d365fo_client/metadata_v2/global_version_manager.py

@@ -325,13 +325,11 @@ class GlobalVersionManager:
                 first_seen_at=datetime.fromisoformat(row[3]),
                 last_used_at=datetime.fromisoformat(row[4]),
                 reference_count=row[5],
-                sample_modules=(
-                    modules[:10] if modules else []
-                ),  # Use first 10 modules as sample
+                modules=modules
             )
 
     async def find_compatible_versions(
-        self, modules: List[ModuleVersionInfo], exact_match: bool = False
+        self, modules: List[ModuleVersionInfo], exact_match: bool = True
     ) -> List[GlobalVersionInfo]:
         """Find compatible global versions
 
@@ -571,3 +569,63 @@ class GlobalVersionManager:
             }
 
             return stats
+
+    async def get_environment_version_statistics(self, environment_id: int) -> Dict[str, Any]:
+        """Get version statistics scoped to a specific environment
+
+        Args:
+            environment_id: Environment ID to get statistics for
+
+        Returns:
+            Dictionary with environment-scoped version statistics
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            stats = {}
+
+            # Get versions for this specific environment
+            cursor = await db.execute(
+                """SELECT COUNT(DISTINCT global_version_id) 
+                   FROM environment_versions 
+                   WHERE environment_id = ? AND is_active = 1""",
+                (environment_id,)
+            )
+            stats["total_versions"] = (await cursor.fetchone())[0]
+
+            # This environment only
+            stats["total_environments"] = 1
+
+            # Reference statistics for this environment's versions
+            cursor = await db.execute(
+                """SELECT 
+                     SUM(gv.reference_count) as total_references,
+                     AVG(gv.reference_count) as avg_references,
+                     MAX(gv.reference_count) as max_references,
+                     COUNT(*) as versions_with_refs
+                   FROM global_versions gv
+                   INNER JOIN environment_versions ev ON gv.id = ev.global_version_id
+                   WHERE ev.environment_id = ? AND ev.is_active = 1 AND gv.reference_count > 0""",
+                (environment_id,)
+            )
+            ref_stats = await cursor.fetchone()
+            stats["reference_statistics"] = {
+                "total_references": ref_stats[0] or 0,
+                "avg_references": round(ref_stats[1] or 0, 2),
+                "max_references": ref_stats[2] or 0,
+                "versions_with_references": ref_stats[3] or 0,
+            }
+
+            # Version age statistics for this environment
+            cursor = await db.execute(
+                """SELECT 
+                     COUNT(*) as recent_versions
+                   FROM global_versions gv
+                   INNER JOIN environment_versions ev ON gv.id = ev.global_version_id
+                   WHERE ev.environment_id = ? AND ev.is_active = 1
+                   AND gv.last_used_at >= datetime('now', '-7 days')""",
+                (environment_id,)
+            )
+            stats["recent_activity"] = {
+                "versions_used_last_7_days": (await cursor.fetchone())[0]
+            }
+
+            return stats

d365fo_client/metadata_v2/sync_manager_v2.py

@@ -656,7 +656,7 @@ class SmartSyncManagerV2:
 
             # Check for compatible versions (sharing opportunity)
             compatible_versions = await self.version_manager.find_compatible_versions(
-                version_info.sample_modules, exact_match=True
+                version_info.modules, exact_match=True
             )
 
             for version in compatible_versions: