d365fo-client 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

d365fo_client/cli.py

@@ -99,6 +99,7 @@ class CLIManager:
             "metadata": self._handle_metadata_commands,
             "entity": self._handle_entity_commands,
             "action": self._handle_action_commands,
+            "service": self._handle_service_commands,
         }
 
         command = getattr(args, "command", None)
@@ -694,6 +695,140 @@ class CLIManager:
             print(format_error_message(f"Error setting default profile: {e}"))
             return 1
 
+    async def _handle_service_commands(self, args: argparse.Namespace) -> int:
+        """Handle JSON service commands."""
+        subcommand = getattr(args, "service_subcommand", None)
+
+        if subcommand == "call":
+            return await self._handle_service_call(args)
+        elif subcommand == "sql-diagnostic":
+            return await self._handle_service_sql_diagnostic(args)
+        else:
+            print(format_error_message(f"Unknown service subcommand: {subcommand}"))
+            return 1
+
+    async def _handle_service_call(self, args: argparse.Namespace) -> int:
+        """Handle generic JSON service call command."""
+        try:
+            service_group = getattr(args, "service_group", "")
+            service_name = getattr(args, "service_name", "")
+            operation_name = getattr(args, "operation_name", "")
+            
+            # Parse parameters from JSON string if provided
+            parameters = None
+            parameters_str = getattr(args, "parameters", None)
+            if parameters_str:
+                try:
+                    parameters = json.loads(parameters_str)
+                except json.JSONDecodeError as e:
+                    print(format_error_message(f"Invalid JSON in parameters: {e}"))
+                    return 1
+
+            # Call the service
+            response = await self.client.post_json_service(
+                service_group=service_group,
+                service_name=service_name,
+                operation_name=operation_name,
+                parameters=parameters,
+            )
+
+            # Format and display response
+            if response.success:
+                result = {
+                    "success": True,
+                    "statusCode": response.status_code,
+                    "data": response.data,
+                    "serviceGroup": service_group,
+                    "serviceName": service_name,
+                    "operationName": operation_name,
+                }
+                output = self.output_formatter.format_output(result)
+                print(output)
+                return 0
+            else:
+                error_result = {
+                    "success": False,
+                    "statusCode": response.status_code,
+                    "error": response.error_message,
+                    "serviceGroup": service_group,
+                    "serviceName": service_name,
+                    "operationName": operation_name,
+                }
+                output = self.output_formatter.format_output(error_result)
+                print(output)
+                return 1
+
+        except Exception as e:
+            print(format_error_message(f"Error calling service: {e}"))
+            return 1
+
+    async def _handle_service_sql_diagnostic(self, args: argparse.Namespace) -> int:
+        """Handle SQL diagnostic service call command."""
+        try:
+            operation = getattr(args, "operation", "")
+            
+            # Prepare parameters based on operation
+            parameters = {}
+            
+            if operation == "GetAxSqlResourceStats":
+                since_minutes = getattr(args, "since_minutes", 10)
+                start_time = getattr(args, "start_time", None)
+                end_time = getattr(args, "end_time", None)
+                
+                if start_time and end_time:
+                    parameters = {
+                        "start": start_time,
+                        "end": end_time,
+                    }
+                else:
+                    # Use since_minutes to calculate start/end
+                    from datetime import datetime, timezone, timedelta
+                    end = datetime.now(timezone.utc)
+                    start = end - timedelta(minutes=since_minutes)
+                    parameters = {
+                        "start": start.isoformat(),
+                        "end": end.isoformat(),
+                    }
+
+            # Call the SQL diagnostic service
+            response = await self.client.post_json_service(
+                service_group="SysSqlDiagnosticService",
+                service_name="SysSqlDiagnosticServiceOperations",
+                operation_name=operation,
+                parameters=parameters if parameters else None,
+            )
+
+            # Format and display response
+            if response.success:
+                result = {
+                    "success": True,
+                    "statusCode": response.status_code,
+                    "operation": operation,
+                    "data": response.data,
+                }
+                
+                # Add summary information
+                if isinstance(response.data, list):
+                    result["recordCount"] = len(response.data)
+                    
+                output = self.output_formatter.format_output(result)
+                print(output)
+                return 0
+            else:
+                error_result = {
+                    "success": False,
+                    "statusCode": response.status_code,
+                    "operation": operation,
+                    "error": response.error_message,
+                }
+                output = self.output_formatter.format_output(error_result)
+                print(output)
+                return 1
+
+        except Exception as e:
+            print(format_error_message(f"Error calling SQL diagnostic service: {e}"))
+            return 1
+
     def _handle_error(self, error: Exception, verbose: bool = False) -> None:
         """Handle and display errors consistently.
 

d365fo_client/client.py

@@ -19,6 +19,8 @@ from .models import (
     DataEntityInfo,
     EnumerationInfo,
     FOClientConfig,
+    JsonServiceRequest,
+    JsonServiceResponse,
     PublicEntityInfo,
     QueryOptions,
 )
@@ -531,36 +533,58 @@ class FOClient:
     # CRUD Operations
 
     async def get_entities(
-        self, entity_name: str, options: Optional[QueryOptions] = None
+        self, entity_name: str, options: Optional[QueryOptions] = None, skip_validation: bool = False
     ) -> Dict[str, Any]:
         """Get entities with OData query options
 
         Args:
             entity_name: Name of the entity set
             options: OData query options
+            skip_validation: Skip schema validation for performance
 
         Returns:
             Response containing entities
         """
-        return await self.crud_ops.get_entities(entity_name, options)
+        entity_schema = None
+        if not skip_validation:
+            entity_schema = await self.get_public_entity_schema_by_entityset(entity_name)
+            if not entity_schema:
+                raise FOClientError(
+                    f"Entity '{entity_name}' not found or not accessible for OData operations"
+                )
+
+        return await self.crud_ops.get_entities(entity_name, options, entity_schema)
 
     async def get_entity(
         self,
         entity_name: str,
         key: Union[str, Dict[str, Any]],
         options: Optional[QueryOptions] = None,
+        skip_validation: bool = False,
     ) -> Dict[str, Any]:
-        """Get single entity by key
+        """Get single entity by key with schema validation
 
         Args:
-            entity_name: Name of the entity set
+            entity_name: Name of the entity set (entityset/collection name)
             key: Entity key value (string for simple keys, dict for composite keys)
             options: OData query options
+            skip_validation: Skip schema validation for performance (batch operations)
 
         Returns:
             Entity data
+
+        Raises:
+            FOClientError: If entity not found or not accessible
         """
-        return await self.crud_ops.get_entity(entity_name, key, options)
+        entity_schema = None
+        if not skip_validation:
+            entity_schema = await self.get_public_entity_schema_by_entityset(entity_name)
+            if not entity_schema:
+                raise FOClientError(
+                    f"Entity '{entity_name}' not found or not accessible for OData operations"
+                )
+
+        return await self.crud_ops.get_entity(entity_name, key, options, entity_schema)
 
     async def get_entity_by_key(
         self,
@@ -568,6 +592,7 @@ class FOClient:
         key: Union[str, Dict[str, Any]],
         select: Optional[List[str]] = None,
         expand: Optional[List[str]] = None,
+        skip_validation: bool = False,
     ) -> Optional[Dict[str, Any]]:
         """Get single entity by key with optional field selection and expansion
 
@@ -576,6 +601,7 @@ class FOClient:
             key: Entity key value (string for simple keys, dict for composite keys)
             select: Optional list of fields to select
             expand: Optional list of navigation properties to expand
+            skip_validation: Skip schema validation for performance
 
         Returns:
             Entity data or None if not found
@@ -584,7 +610,7 @@ class FOClient:
             options = (
                 QueryOptions(select=select, expand=expand) if select or expand else None
             )
-            return await self.crud_ops.get_entity(entity_name, key, options)
+            return await self.get_entity(entity_name, key, options, skip_validation)
         except Exception as e:
             # If the entity is not found, return None instead of raising exception
             if "404" in str(e):
@@ -592,18 +618,34 @@ class FOClient:
             raise
 
     async def create_entity(
-        self, entity_name: str, data: Dict[str, Any]
+        self, entity_name: str, data: Dict[str, Any], skip_validation: bool = False
     ) -> Dict[str, Any]:
-        """Create new entity
+        """Create new entity with schema validation
 
         Args:
             entity_name: Name of the entity set
             data: Entity data to create
+            skip_validation: Skip schema validation for performance (batch operations)
 
         Returns:
             Created entity data
+
+        Raises:
+            FOClientError: If entity not found, read-only, or validation fails
         """
-        return await self.crud_ops.create_entity(entity_name, data)
+        entity_schema = None
+        if not skip_validation:
+            entity_schema = await self.get_public_entity_schema_by_entityset(entity_name)
+            if not entity_schema:
+                raise FOClientError(
+                    f"Entity '{entity_name}' not found or not accessible for OData operations"
+                )
+            if entity_schema.is_read_only:
+                raise FOClientError(
+                    f"Entity '{entity_name}' is read-only and cannot accept create operations"
+                )
+
+        return await self.crud_ops.create_entity(entity_name, data, entity_schema)
 
     async def update_entity(
         self,
@@ -611,33 +653,66 @@ class FOClient:
         key: Union[str, Dict[str, Any]],
         data: Dict[str, Any],
         method: str = "PATCH",
+        skip_validation: bool = False,
     ) -> Dict[str, Any]:
-        """Update existing entity
+        """Update existing entity with schema validation
 
         Args:
             entity_name: Name of the entity set
             key: Entity key value (string for simple keys, dict for composite keys)
             data: Updated entity data
             method: HTTP method (PATCH or PUT)
+            skip_validation: Skip schema validation for performance (batch operations)
 
         Returns:
             Updated entity data
+
+        Raises:
+            FOClientError: If entity not found, read-only, or validation fails
         """
-        return await self.crud_ops.update_entity(entity_name, key, data, method)
+        entity_schema = None
+        if not skip_validation:
+            entity_schema = await self.get_public_entity_schema_by_entityset(entity_name)
+            if not entity_schema:
+                raise FOClientError(
+                    f"Entity '{entity_name}' not found or not accessible for OData operations"
+                )
+            if entity_schema.is_read_only:
+                raise FOClientError(
+                    f"Entity '{entity_name}' is read-only and cannot accept update operations"
+                )
+
+        return await self.crud_ops.update_entity(entity_name, key, data, method, entity_schema)
 
     async def delete_entity(
-        self, entity_name: str, key: Union[str, Dict[str, Any]]
+        self, entity_name: str, key: Union[str, Dict[str, Any]], skip_validation: bool = False
     ) -> bool:
-        """Delete entity
+        """Delete entity with schema validation
 
         Args:
             entity_name: Name of the entity set
             key: Entity key value (string for simple keys, dict for composite keys)
+            skip_validation: Skip schema validation for performance (batch operations)
 
         Returns:
             True if successful
+
+        Raises:
+            FOClientError: If entity not found, read-only, or validation fails
         """
-        return await self.crud_ops.delete_entity(entity_name, key)
+        entity_schema = None
+        if not skip_validation:
+            entity_schema = await self.get_public_entity_schema_by_entityset(entity_name)
+            if not entity_schema:
+                raise FOClientError(
+                    f"Entity '{entity_name}' not found or not accessible for OData operations"
+                )
+            if entity_schema.is_read_only:
+                raise FOClientError(
+                    f"Entity '{entity_name}' is read-only and cannot accept delete operations"
+                )
+
+        return await self.crud_ops.delete_entity(entity_name, key, entity_schema)
 
     async def call_action(
         self,
@@ -645,6 +720,7 @@ class FOClient:
         parameters: Optional[Dict[str, Any]] = None,
         entity_name: Optional[str] = None,
         entity_key: Optional[Union[str, Dict[str, Any]]] = None,
+        skip_validation: bool = False,
     ) -> Any:
         """Call OData action method
 
@@ -653,12 +729,21 @@ class FOClient:
             parameters: Action parameters
             entity_name: Entity name for bound actions
             entity_key: Entity key for bound actions (string for simple keys, dict for composite keys)
+            skip_validation: Skip schema validation for performance
 
         Returns:
             Action result
         """
+        entity_schema = None
+        if not skip_validation and entity_name:
+            entity_schema = await self.get_public_entity_schema_by_entityset(entity_name)
+            if not entity_schema:
+                raise FOClientError(
+                    f"Entity '{entity_name}' not found or not accessible for OData operations"
+                )
+
         return await self.crud_ops.call_action(
-            action_name, parameters, entity_name, entity_key
+            action_name, parameters, entity_name, entity_key, entity_schema
         )
 
     # Label Operations
@@ -1244,17 +1329,284 @@ class FOClient:
 
     # Application Version Operations
 
-    async def get_entity_schema(self, entity_name: str) -> Optional[PublicEntityInfo]:
-        """Get entity schema - compatibility method for SmartSyncManagerV2
+    async def post_json_service(
+        self,
+        service_group: str,
+        service_name: str,
+        operation_name: str,
+        parameters: Optional[Dict[str, Any]] = None,
+    ) -> JsonServiceResponse:
+        """Call D365 F&O JSON service endpoint using POST method
+
+        This method provides a generic way to call D365 F&O JSON services that use the
+        /api/services/{ServiceGroup}/{ServiceName}/{OperationName} endpoint pattern.
+
+        Args:
+            service_group: Service group name (e.g., "SysSqlDiagnosticService")
+            service_name: Service name (e.g., "SysSqlDiagnosticServiceOperations") 
+            operation_name: Operation name (e.g., "GetAxSqlExecuting")
+            parameters: Optional parameters to send in the POST body
+
+        Returns:
+            JsonServiceResponse containing the result data and metadata
+
+        Raises:
+            FOClientError: If the service call fails
+
+        Example:
+            # Call a service without parameters
+            response = await client.post_json_service(
+                "SysSqlDiagnosticService",
+                "SysSqlDiagnosticServiceOperations", 
+                "GetAxSqlExecuting"
+            )
+
+            # Call a service with parameters
+            response = await client.post_json_service(
+                "SysSqlDiagnosticService",
+                "SysSqlDiagnosticServiceOperations",
+                "GetAxSqlResourceStats",
+                {
+                    "start": "2023-01-01T00:00:00Z",
+                    "end": "2023-01-02T00:00:00Z"
+                }
+            )
+        """
+        try:
+            # Create service request
+            request = JsonServiceRequest(
+                service_group=service_group,
+                service_name=service_name,
+                operation_name=operation_name,
+                parameters=parameters,
+            )
+
+            # Get the endpoint path
+            endpoint_path = request.get_endpoint_path()
+            url = f"{self.config.base_url.rstrip('/')}{endpoint_path}"
+
+            # Get session and make request
+            session = await self.session_manager.get_session()
+
+            # Prepare headers
+            headers = {"Content-Type": "application/json"}
+
+            # Prepare request body
+            body = parameters or {}
+
+            async with session.post(url, json=body, headers=headers) as response:
+                status_code = response.status
+                
+                # Handle success cases
+                if status_code in [200, 201]:
+                    try:
+                        content_type = response.headers.get("content-type", "")
+                        if "application/json" in content_type:
+                            data = await response.json()
+                        else:
+                            data = await response.text()
+                        
+                        return JsonServiceResponse(
+                            success=True,
+                            data=data,
+                            status_code=status_code,
+                        )
+                    except Exception as parse_error:
+                        # If we can't parse the response, still return success with raw text
+                        text_data = await response.text()
+                        return JsonServiceResponse(
+                            success=True,
+                            data=text_data,
+                            status_code=status_code,
+                            error_message=f"Response parsing warning: {parse_error}",
+                        )
+                
+                # Handle error cases
+                else:
+                    error_text = await response.text()
+                    return JsonServiceResponse(
+                        success=False,
+                        data=None,
+                        status_code=status_code,
+                        error_message=f"HTTP {status_code}: {error_text}",
+                    )
+
+        except Exception as e:
+            # Handle network errors and other exceptions
+            return JsonServiceResponse(
+                success=False,
+                data=None,
+                status_code=0,
+                error_message=f"Request failed: {e}",
+            )
+
+    async def call_json_service(
+        self,
+        request: JsonServiceRequest,
+    ) -> JsonServiceResponse:
+        """Call D365 F&O JSON service using a JsonServiceRequest object
+
+        This is an alternative interface to post_json_service that accepts a request object.
+
+        Args:
+            request: JsonServiceRequest containing service details and parameters
+
+        Returns:
+            JsonServiceResponse containing the result data and metadata
+
+        Example:
+            request = JsonServiceRequest(
+                service_group="SysSqlDiagnosticService",
+                service_name="SysSqlDiagnosticServiceOperations",
+                operation_name="GetAxSqlExecuting"
+            )
+            response = await client.call_json_service(request)
+        """
+        return await self.post_json_service(
+            request.service_group,
+            request.service_name,
+            request.operation_name,
+            request.parameters,
+        )
+
+    async def get_public_entity_schema_by_entityset(
+        self,
+        entityset_name: str,
+        use_cache_first: Optional[bool] = True
+    ) -> Optional[PublicEntityInfo]:
+        """Get public entity schema by entityset name (public collection name).
+
+        This method resolves the entityset name to the actual public entity name
+        and retrieves the full schema with cache-first optimization.
+
+        Args:
+            entityset_name: Public collection name or entity set name
+                           (e.g., "CustomersV3", "SalesOrders", "DataManagementEntities")
+            use_cache_first: Use metadata cache before F&O API (default: True)
+
+        Returns:
+            PublicEntityInfo with full schema, or None if entity not found
+
+        Resolution Logic:
+            1. Try direct lookup in public entities (entityset_name == entity name)
+            2. Search data entities for public_collection_name match
+            3. Resolve to public_entity_name and fetch schema
+            4. Use cache-first pattern for all lookups
+        """
+
+        async def cache_lookup():
+            if not self.metadata_cache:
+                return None
+
+            # Try direct public entity lookup first (entityset_name might be the entity name)
+            entity_schema = await self.metadata_cache.get_public_entity_schema(entityset_name)
+            if entity_schema:
+                self.logger.debug(f"Found entity schema directly for '{entityset_name}'")
+                return entity_schema
+
+            # Try resolving via data entity metadata
+            # Search for entities matching the entityset name
+            data_entities = await self.metadata_cache.get_data_entities(
+                name_pattern=entityset_name
+            )
+
+            for data_entity in data_entities:
+                # Check if public_collection_name matches
+                if data_entity.public_collection_name == entityset_name:
+                    self.logger.debug(
+                        f"Resolved '{entityset_name}' to entity '{data_entity.public_entity_name or data_entity.name}'"
+                    )
+                    # Found match - get schema by public_entity_name
+                    return await self.metadata_cache.get_public_entity_schema(
+                        data_entity.public_entity_name or data_entity.name
+                    )
+
+                # Also check if entity name matches (for direct name usage)
+                if data_entity.name == entityset_name:
+                    self.logger.debug(f"Found entity by name '{entityset_name}'")
+                    return await self.metadata_cache.get_public_entity_schema(
+                        data_entity.public_entity_name or data_entity.name
+                    )
+
+                # Check if public_entity_name matches
+                if data_entity.public_entity_name == entityset_name:
+                    self.logger.debug(f"Found entity by public_entity_name '{entityset_name}'")
+                    return await self.metadata_cache.get_public_entity_schema(entityset_name)
+
+            return None
+
+        async def fallback_lookup():
+            # Try direct public entity lookup first
+            try:
+                entity_schema = await self.metadata_api_ops.get_public_entity_info(
+                    entityset_name, resolve_labels=False
+                )
+                if entity_schema:
+                    self.logger.debug(f"Found entity schema via API for '{entityset_name}'")
+                    return entity_schema
+            except Exception as e:
+                self.logger.debug(f"Direct API lookup failed for '{entityset_name}': {e}")
+
+            # Search data entities to find the mapping
+            try:
+                data_entities = await self.metadata_api_ops.search_data_entities("")
+
+                for data_entity in data_entities:
+                    # Check if public_collection_name matches
+                    if data_entity.public_collection_name == entityset_name:
+                        self.logger.debug(
+                            f"Resolved '{entityset_name}' to entity '{data_entity.public_entity_name or data_entity.name}' via API"
+                        )
+                        # Found match - get schema by public_entity_name
+                        return await self.metadata_api_ops.get_public_entity_info(
+                            data_entity.public_entity_name or data_entity.name,
+                            resolve_labels=False
+                        )
+
+                    # Also check if entity name matches
+                    if data_entity.name == entityset_name:
+                        return await self.metadata_api_ops.get_public_entity_info(
+                            data_entity.public_entity_name or data_entity.name,
+                            resolve_labels=False
+                        )
+
+                    # Check if public_entity_name matches
+                    if data_entity.public_entity_name == entityset_name:
+                        return await self.metadata_api_ops.get_public_entity_info(
+                            entityset_name,
+                            resolve_labels=False
+                        )
+            except Exception as e:
+                self.logger.debug(f"Data entity search failed for '{entityset_name}': {e}")
+
+            return None
+
+        return await self._get_from_cache_first(
+            cache_lookup,
+            fallback_lookup,
+            use_cache_first=use_cache_first,
+        )
+
+    async def get_entity_schema(
+        self,
+        entity_name: str,
+        use_cache_first: Optional[bool] = True
+    ) -> Optional[PublicEntityInfo]:
+        """Get entity schema with cache-first optimization.
+
+        This is an enhanced version that uses the cache-first pattern for better performance.
 
         Args:
             entity_name: Name of the public entity
+            use_cache_first: Use metadata cache before F&O API (default: True)
 
         Returns:
             PublicEntityInfo object with schema details or None if not found
         """
-        return await self.metadata_api_ops.get_public_entity_info(
-            entity_name, resolve_labels=False
+        return await self.get_public_entity_info(
+            entity_name,
+            resolve_labels=False,
+            use_cache_first=use_cache_first
         )
 
     async def get_application_version(self) -> str: