d365fo-client 0.1.0__py3-none-any.whl

d365fo_client/output.py

@@ -0,0 +1,181 @@
+"""Output formatting module for d365fo-client CLI."""
+
+import csv
+import io
+import json
+from typing import Any, Dict, List, Optional, Union
+
+import yaml
+from tabulate import tabulate
+
+
+class OutputFormatter:
+    """Handles formatting of output data in various formats."""
+
+    SUPPORTED_FORMATS = ["json", "table", "csv", "yaml"]
+
+    def __init__(self, format_type: str = "table"):
+        """Initialize the output formatter.
+
+        Args:
+            format_type: Output format type (json, table, csv, yaml)
+        """
+        if format_type not in self.SUPPORTED_FORMATS:
+            raise ValueError(
+                f"Unsupported format: {format_type}. Supported: {self.SUPPORTED_FORMATS}"
+            )
+
+        self.format_type = format_type
+
+    def format_output(self, data: Any, headers: Optional[List[str]] = None) -> str:
+        """Format data according to the specified output format.
+
+        Args:
+            data: Data to format
+            headers: Optional headers for table format
+
+        Returns:
+            Formatted string output
+        """
+        if data is None:
+            return ""
+
+        if self.format_type == "json":
+            return self._format_json(data)
+        elif self.format_type == "table":
+            return self._format_table(data, headers)
+        elif self.format_type == "csv":
+            return self._format_csv(data, headers)
+        elif self.format_type == "yaml":
+            return self._format_yaml(data)
+        else:
+            # Fallback to JSON
+            return self._format_json(data)
+
+    def _format_json(self, data: Any) -> str:
+        """Format data as JSON."""
+        return json.dumps(data, indent=2, default=str, ensure_ascii=False)
+
+    def _format_yaml(self, data: Any) -> str:
+        """Format data as YAML."""
+        return yaml.dump(data, default_flow_style=False, allow_unicode=True, indent=2)
+
+    def _format_table(self, data: Any, headers: Optional[List[str]] = None) -> str:
+        """Format data as a table using tabulate."""
+        if not data:
+            return "No data to display."
+
+        # Handle different data types
+        if isinstance(data, dict):
+            # For single record or key-value pairs
+            if headers:
+                # If headers provided, try to extract those fields
+                rows = [[data.get(h, "") for h in headers]]
+                return tabulate(rows, headers=headers, tablefmt="grid")
+            else:
+                # Show as key-value pairs
+                rows = [[k, v] for k, v in data.items()]
+                return tabulate(rows, headers=["Property", "Value"], tablefmt="grid")
+
+        elif isinstance(data, list):
+            if not data:
+                return "No data to display."
+
+            # For list of records
+            if isinstance(data[0], dict):
+                # Extract headers from first item if not provided
+                if not headers:
+                    headers = list(data[0].keys())
+
+                # Extract rows
+                rows = []
+                for item in data:
+                    row = []
+                    for header in headers:
+                        value = item.get(header, "")
+                        # Handle nested objects/lists by converting to string
+                        if isinstance(value, (dict, list)):
+                            value = str(value)
+                        row.append(value)
+                    rows.append(row)
+
+                return tabulate(rows, headers=headers, tablefmt="grid")
+            else:
+                # List of simple values
+                rows = [[item] for item in data]
+                return tabulate(rows, headers=["Value"], tablefmt="grid")
+
+        else:
+            # Single value
+            return str(data)
+
+    def _format_csv(self, data: Any, headers: Optional[List[str]] = None) -> str:
+        """Format data as CSV."""
+        if not data:
+            return ""
+
+        output = io.StringIO()
+        writer = csv.writer(output)
+
+        if isinstance(data, dict):
+            # Single record
+            if headers:
+                writer.writerow(headers)
+                writer.writerow([data.get(h, "") for h in headers])
+            else:
+                # Key-value pairs
+                writer.writerow(["Property", "Value"])
+                for k, v in data.items():
+                    writer.writerow([k, v])
+
+        elif isinstance(data, list):
+            if not data:
+                return ""
+
+            if isinstance(data[0], dict):
+                # List of records
+                if not headers:
+                    headers = list(data[0].keys())
+
+                writer.writerow(headers)
+                for item in data:
+                    row = []
+                    for header in headers:
+                        value = item.get(header, "")
+                        # Handle nested objects by converting to JSON string
+                        if isinstance(value, (dict, list)):
+                            value = json.dumps(value, default=str)
+                        row.append(value)
+                    writer.writerow(row)
+            else:
+                # List of simple values
+                writer.writerow(["Value"])
+                for item in data:
+                    writer.writerow([item])
+
+        else:
+            # Single value
+            writer.writerow(["Value"])
+            writer.writerow([data])
+
+        return output.getvalue()
+
+
+def format_success_message(message: str) -> str:
+    """Format a success message with checkmark."""
+    return f"✅ {message}"
+
+
+def format_error_message(message: str) -> str:
+    """Format an error message with X mark."""
+    return f"❌ {message}"
+
+
+def format_info_message(message: str) -> str:
+    """Format an info message with info icon."""
+    return f"ℹ️  {message}"
+
+
+def format_warning_message(message: str) -> str:
+    """Format a warning message with warning icon."""
+    return f"⚠️  {message}"

d365fo_client/profile_manager.py

@@ -0,0 +1,342 @@
+"""Profile management for d365fo-client.
+
+Provides centralized profile management functionality that can be used by both CLI and MCP.
+"""
+
+import logging
+import os
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+from .config import ConfigManager
+from .models import FOClientConfig
+from .profiles import Profile
+
+logger = logging.getLogger(__name__)
+
+# Legacy alias for backward compatibility
+EnvironmentProfile = Profile
+
+
+class ProfileManager:
+    """Manages environment profiles for D365FO connections."""
+
+    def __init__(self, config_path: Optional[str] = None):
+        """Initialize profile manager.
+
+        Args:
+            config_path: Path to configuration file. If None, uses default.
+        """
+        # Use CLI ConfigManager as the underlying storage
+        self.config_manager = ConfigManager(config_path)
+
+    def list_profiles(self) -> Dict[str, Profile]:
+        """List all available profiles.
+
+        Returns:
+            Dictionary of profile name to Profile instances
+        """
+        try:
+            return self.config_manager.list_profiles()
+        except Exception as e:
+            logger.error(f"Error listing profiles: {e}")
+            return {}
+
+    def get_profile(self, profile_name: str) -> Optional[Profile]:
+        """Get a specific profile.
+
+        Args:
+            profile_name: Name of the profile to retrieve
+
+        Returns:
+            Profile instance or None if not found
+        """
+        try:
+            return self.config_manager.get_profile(profile_name)
+        except Exception as e:
+            logger.error(f"Error getting profile {profile_name}: {e}")
+            return None
+
+    def create_profile(
+        self,
+        name: str,
+        base_url: str,
+        auth_mode: str = "default",
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        tenant_id: Optional[str] = None,
+        verify_ssl: bool = True,
+        timeout: int = 60,
+        use_label_cache: bool = True,
+        label_cache_expiry_minutes: int = 60,
+        use_cache_first: bool = True,
+        language: str = "en-US",
+        cache_dir: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> bool:
+        """Create a new profile.
+
+        Args:
+            name: Profile name
+            base_url: D365FO base URL
+            auth_mode: Authentication mode
+            client_id: Azure client ID (optional)
+            client_secret: Azure client secret (optional)
+            tenant_id: Azure tenant ID (optional)
+            verify_ssl: Whether to verify SSL certificates
+            timeout: Request timeout in seconds
+            use_label_cache: Whether to enable label caching
+            label_cache_expiry_minutes: Label cache expiry in minutes
+            language: Default language code
+            cache_dir: Cache directory path
+            description: Profile description (stored separately from CLI profile)
+
+        Returns:
+            True if created successfully
+        """
+        try:
+            # Check if profile already exists
+            if self.config_manager.get_profile(name):
+                logger.error(f"Profile already exists: {name}")
+                return False
+
+            # Create unified profile
+            profile = Profile(
+                name=name,
+                base_url=base_url,
+                auth_mode=auth_mode,
+                client_id=client_id,
+                client_secret=client_secret,
+                tenant_id=tenant_id,
+                verify_ssl=verify_ssl,
+                timeout=timeout,
+                use_label_cache=use_label_cache,
+                label_cache_expiry_minutes=label_cache_expiry_minutes,
+                use_cache_first=use_cache_first,
+                language=language,
+                cache_dir=cache_dir,
+                description=description,
+                output_format="table",  # Default for CLI compatibility
+            )
+
+            self.config_manager.save_profile(profile)
+
+            logger.info(f"Created profile: {name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Error creating profile {name}: {e}")
+            return False
+
+    def update_profile(self, name: str, **kwargs) -> bool:
+        """Update an existing profile.
+
+        Args:
+            name: Profile name
+            **kwargs: Profile attributes to update
+
+        Returns:
+            True if updated successfully
+        """
+        try:
+            # Get existing profile
+            profile = self.get_profile(name)
+            if not profile:
+                logger.error(f"Profile not found: {name}")
+                return False
+
+            # Create updated profile with new attributes
+            from dataclasses import replace
+
+            updated_profile = replace(profile, **kwargs)
+
+            # Save updated profile
+            self.config_manager.save_profile(updated_profile)
+
+            logger.info(f"Updated profile: {name}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Error updating profile {name}: {e}")
+            return False
+
+    def delete_profile(self, profile_name: str) -> bool:
+        """Delete a profile.
+
+        Args:
+            profile_name: Name of the profile to delete
+
+        Returns:
+            True if deleted successfully
+        """
+        try:
+            success = self.config_manager.delete_profile(profile_name)
+            if success:
+                logger.info(f"Deleted profile: {profile_name}")
+            else:
+                logger.error(f"Profile not found: {profile_name}")
+            return success
+        except Exception as e:
+            logger.error(f"Error deleting profile {profile_name}: {e}")
+            return False
+
+    def get_default_profile(self) -> Optional[Profile]:
+        """Get the default profile.
+
+        Returns:
+            Default Profile instance or None if not set
+        """
+        try:
+            return self.config_manager.get_default_profile()
+        except Exception as e:
+            logger.error(f"Error getting default profile: {e}")
+            return None
+
+    def set_default_profile(self, profile_name: str) -> bool:
+        """Set the default profile.
+
+        Args:
+            profile_name: Name of the profile to set as default
+
+        Returns:
+            True if set successfully
+        """
+        try:
+            success = self.config_manager.set_default_profile(profile_name)
+            if success:
+                logger.info(f"Set default profile: {profile_name}")
+            else:
+                logger.error(f"Profile not found: {profile_name}")
+            return success
+        except Exception as e:
+            logger.error(f"Error setting default profile {profile_name}: {e}")
+            return False
+
+    def profile_to_client_config(self, profile: Profile) -> FOClientConfig:
+        """Convert a Profile to FOClientConfig.
+
+        Args:
+            profile: Profile instance
+
+        Returns:
+            FOClientConfig instance
+        """
+        return profile.to_client_config()
+
+    def get_effective_profile(
+        self, profile_name: Optional[str] = None
+    ) -> Optional[Profile]:
+        """Get the effective profile to use.
+
+        Args:
+            profile_name: Specific profile name, or None to use default
+
+        Returns:
+            Profile instance or None if not found
+        """
+        if profile_name:
+            return self.get_profile(profile_name)
+        else:
+            return self.get_default_profile()
+
+    def validate_profile(self, profile: Profile) -> List[str]:
+        """Validate a profile configuration.
+
+        Args:
+            profile: Profile to validate
+
+        Returns:
+            List of validation error messages (empty if valid)
+        """
+        return profile.validate()
+
+    def get_profile_names(self) -> List[str]:
+        """Get list of all profile names.
+
+        Returns:
+            List of profile names
+        """
+        return list(self.list_profiles().keys())
+
+    def export_profiles(self, file_path: str) -> bool:
+        """Export all profiles to a file.
+
+        Args:
+            file_path: Path to export file
+
+        Returns:
+            True if exported successfully
+        """
+        try:
+            profiles = self.list_profiles()
+            export_data = {"version": "1.0", "profiles": {}}
+
+            for name, profile in profiles.items():
+                export_data["profiles"][name] = asdict(profile)
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                yaml.dump(export_data, f, default_flow_style=False, allow_unicode=True)
+
+            logger.info(f"Exported {len(profiles)} profiles to {file_path}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Error exporting profiles to {file_path}: {e}")
+            return False
+
+    def import_profiles(
+        self, file_path: str, overwrite: bool = False
+    ) -> Dict[str, bool]:
+        """Import profiles from a file.
+
+        Args:
+            file_path: Path to import file
+            overwrite: Whether to overwrite existing profiles
+
+        Returns:
+            Dictionary of profile name to import success status
+        """
+        results = {}
+
+        try:
+            with open(file_path, "r", encoding="utf-8") as f:
+                import_data = yaml.safe_load(f)
+
+            if not import_data or "profiles" not in import_data:
+                logger.error("Invalid import file format")
+                return results
+
+            for name, profile_data in import_data["profiles"].items():
+                try:
+                    # Check if profile exists
+                    if self.get_profile(name) and not overwrite:
+                        logger.warning(f"Profile {name} already exists, skipping")
+                        results[name] = False
+                        continue
+
+                    # If overwrite is enabled, delete existing profile first
+                    if overwrite and self.get_profile(name):
+                        self.delete_profile(name)
+
+                    # Extract description if present
+                    description = profile_data.pop("description", None)
+
+                    # Create profile
+                    success = self.create_profile(
+                        description=description, **profile_data
+                    )
+                    results[name] = success
+
+                except Exception as e:
+                    logger.error(f"Error importing profile {name}: {e}")
+                    results[name] = False
+
+            logger.info(f"Imported profiles from {file_path}: {results}")
+            return results
+
+        except Exception as e:
+            logger.error(f"Error importing profiles from {file_path}: {e}")
+            return results

d365fo_client/profiles.py

@@ -0,0 +1,178 @@
+"""Unified profile management for d365fo-client."""
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+if TYPE_CHECKING:
+    from .models import FOClientConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Profile:
+    """Unified profile for CLI and MCP operations."""
+
+    # Core identification
+    name: str
+    description: Optional[str] = None
+
+    # Connection settings
+    base_url: str = ""
+    auth_mode: str = "default"
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    tenant_id: Optional[str] = None
+    verify_ssl: bool = True
+    timeout: int = 60
+
+    # Cache settings
+    use_label_cache: bool = True
+    label_cache_expiry_minutes: int = 60
+    use_cache_first: bool = True
+    cache_dir: Optional[str] = None
+
+    # Localization
+    language: str = "en-US"
+
+    # CLI-specific settings (with defaults for MCP)
+    output_format: str = "table"
+
+    def to_client_config(self) -> "FOClientConfig":
+        """Convert profile to FOClientConfig."""
+        from .models import FOClientConfig
+
+        return FOClientConfig(
+            base_url=self.base_url,
+            client_id=self.client_id,
+            client_secret=self.client_secret,
+            tenant_id=self.tenant_id,
+            use_default_credentials=self.auth_mode == "default",
+            timeout=self.timeout,
+            verify_ssl=self.verify_ssl,
+            use_label_cache=self.use_label_cache,
+            label_cache_expiry_minutes=self.label_cache_expiry_minutes,
+            use_cache_first=self.use_cache_first,
+            metadata_cache_dir=self.cache_dir,
+        )
+
+    def validate(self) -> List[str]:
+        """Validate profile configuration."""
+        errors = []
+
+        if not self.base_url:
+            errors.append("Base URL is required")
+
+        if self.auth_mode == "client_credentials":
+            if not self.client_id:
+                errors.append("Client ID is required for client_credentials auth mode")
+            if not self.client_secret:
+                errors.append(
+                    "Client secret is required for client_credentials auth mode"
+                )
+            if not self.tenant_id:
+                errors.append("Tenant ID is required for client_credentials auth mode")
+
+        if self.timeout <= 0:
+            errors.append("Timeout must be greater than 0")
+
+        if self.label_cache_expiry_minutes <= 0:
+            errors.append("Label cache expiry must be greater than 0")
+
+        return errors
+
+    @classmethod
+    def from_dict(cls, name: str, data: Dict[str, Any]) -> "Profile":
+        """Create Profile from dictionary data with migration support."""
+
+        # Handle parameter migration from legacy formats
+        migrated_data = cls._migrate_legacy_parameters(data.copy())
+
+        # Ensure name is set
+        migrated_data["name"] = name
+
+        # Add defaults for missing parameters
+        defaults = {
+            "description": None,
+            "base_url": "",
+            "auth_mode": "default",
+            "client_id": None,
+            "client_secret": None,
+            "tenant_id": None,
+            "verify_ssl": True,
+            "timeout": 60,
+            "use_label_cache": True,
+            "label_cache_expiry_minutes": 60,
+            "use_cache_first": True,
+            "cache_dir": None,
+            "language": "en-US",
+            "output_format": "table",
+        }
+
+        for key, default_value in defaults.items():
+            if key not in migrated_data:
+                migrated_data[key] = default_value
+
+        # Filter out any unknown parameters
+        valid_params = {
+            k: v for k, v in migrated_data.items() if k in cls.__dataclass_fields__
+        }
+
+        try:
+            return cls(**valid_params)
+        except Exception as e:
+            logger.error(f"Error creating profile {name}: {e}")
+            logger.error(f"Data: {valid_params}")
+            raise
+
+    @classmethod
+    def _migrate_legacy_parameters(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Migrate legacy parameter names to current format."""
+
+        # Map old parameter names to new ones
+        parameter_migrations = {
+            "label_cache": "use_label_cache",
+            "label_expiry": "label_cache_expiry_minutes",
+        }
+
+        for old_name, new_name in parameter_migrations.items():
+            if old_name in data and new_name not in data:
+                data[new_name] = data.pop(old_name)
+                logger.debug(f"Migrated parameter {old_name} -> {new_name}")
+
+        return data
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert profile to dictionary for storage."""
+        from dataclasses import asdict
+
+        # Convert to dict and remove name (stored as key)
+        data = asdict(self)
+        data.pop("name", None)
+
+        return data
+
+    def clone(self, name: str, **overrides) -> "Profile":
+        """Create a copy of this profile with a new name and optional overrides."""
+        from dataclasses import replace
+
+        # Create a copy with new name
+        new_profile = replace(self, name=name)
+
+        # Apply any overrides
+        if overrides:
+            new_profile = replace(new_profile, **overrides)
+
+        return new_profile
+
+    def __str__(self) -> str:
+        """String representation of the profile."""
+        return f"Profile(name='{self.name}', base_url='{self.base_url}', auth_mode='{self.auth_mode}')"
+
+    def __repr__(self) -> str:
+        """Detailed string representation of the profile."""
+        return (
+            f"Profile(name='{self.name}', base_url='{self.base_url}', "
+            f"auth_mode='{self.auth_mode}', description='{self.description}')"
+        )