wxcli 1.2.0__py3-none-any.whl

wxcli/migration/cucm/extractors/features.py

@@ -0,0 +1,309 @@
+"""Feature extractors for CUCM AXL.
+
+Pulls Hunt Pilots, Hunt Lists, Line Groups, CTI Route Points, Call Park,
+Pickup Groups, Time Schedules, and Time Periods.
+
+Sources:
+- 02b-cucm-extraction.md §2.5 (feature extraction)
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from wxcli.migration.cucm.connection import AXLConnection
+from wxcli.migration.cucm.extractors.base import BaseExtractor, ExtractionResult
+from wxcli.migration.cucm.extractors.helpers import ref_value, to_list
+
+logger = logging.getLogger(__name__)
+
+# AXL Gotchas (discovered test bed expansion 2026-03-24):
+# - addCallPickupGroup with <members>/<directoryNumber> fails on CUCM 15.0
+#   (null priority FK constraint). Use empty create + updateLine workaround.
+# - No listPagingGroup/getPagingGroup AXL methods exist. Paging requires
+#   InformaCast/Cisco Paging Server. CanonicalPagingGroup is manual-only.
+# - CTI Route Points may require SCCP instead of SIP on some device pools.
+# - TimePeriod monthOfYear: 3-letter abbreviations only (Dec, Jan, etc.)
+
+# ------------------------------------------------------------------
+# ReturnedTags constants
+# ------------------------------------------------------------------
+
+# Verified: listHuntPilot accepts these fields per WSDL LHuntPilot schema.
+# Fields like mohSourceId, maxCallersInQueue, huntTimerCallPick, overflowDestination,
+# enabled are only on getHuntPilot.
+HUNT_PILOT_LIST_RETURNED_TAGS = {
+    "pattern": "", "description": "", "routePartitionName": "",
+    "huntListName": "",
+}
+
+# Verified: list operations do NOT accept nested fields (members, lines).
+# Use list tags for discovery, get operations for full detail.
+HUNT_LIST_LIST_RETURNED_TAGS = {
+    "name": "", "description": "",
+}
+
+LINE_GROUP_LIST_RETURNED_TAGS = {
+    "name": "", "distributionAlgorithm": "",
+}
+
+CTI_RP_LIST_RETURNED_TAGS = {
+    "name": "", "description": "", "devicePoolName": "", "callingSearchSpaceName": "",
+}
+
+CALL_PARK_RETURNED_TAGS = {
+    "pattern": "", "description": "", "routePartitionName": "",
+}
+
+PICKUP_GROUP_LIST_RETURNED_TAGS = {
+    "name": "",
+}
+
+TIME_SCHEDULE_LIST_RETURNED_TAGS = {
+    "name": "",
+}
+
+TIME_PERIOD_LIST_RETURNED_TAGS = {
+    "name": "",
+}
+
+
+class FeatureExtractor(BaseExtractor):
+    """Extract calling features from CUCM AXL.
+
+    Covers Hunt Pilots, Hunt Lists, Line Groups, CTI Route Points,
+    Call Park, Pickup Groups, Time Schedules, and Time Periods.
+
+    (from 02b §2.5)
+    """
+
+    name = "features"
+
+    def __init__(self, connection: AXLConnection) -> None:
+        super().__init__(connection)
+        self.results: dict[str, list[dict[str, Any]]] = {}
+
+    def extract(self) -> ExtractionResult:
+        """Run all feature extractions.
+
+        Returns an ExtractionResult summarizing total objects and errors.
+        """
+        result = ExtractionResult(extractor=self.name)
+
+        self.results["hunt_pilots"] = self._extract_hunt_pilots(result)
+        self.results["hunt_lists"] = self._extract_hunt_lists(result)
+        self.results["line_groups"] = self._extract_line_groups(result)
+        self.results["cti_route_points"] = self._extract_cti_route_points(result)
+        self.results["call_parks"] = self._extract_call_parks(result)
+        self.results["pickup_groups"] = self._extract_pickup_groups(result)
+        self.results["time_schedules"] = self._extract_time_schedules(result)
+        self.results["time_periods"] = self._extract_time_periods(result)
+        self.results["executive_assistant_pairs"] = self._extract_executive_assistant_pairs(result)
+        self.results["executive_settings"] = self._extract_executive_settings(result)
+
+        return result
+
+    # ------------------------------------------------------------------
+    # Common list+get pattern
+    # ------------------------------------------------------------------
+
+    def _list_and_get(
+        self,
+        result: ExtractionResult,
+        list_method: str,
+        get_method: str,
+        search_criteria: dict[str, str],
+        returned_tags: dict[str, str],
+        name_field: str = "name",
+    ) -> list[dict[str, Any]]:
+        """Common pattern: paginated list then per-object get.
+
+        On get failure (exception or None), the object is skipped and counted
+        as failed — consistent with DeviceExtractor and RoutingExtractor.
+        """
+        items: list[dict[str, Any]] = []
+        try:
+            summaries = self.paginated_list(list_method, search_criteria, returned_tags)
+        except Exception as exc:
+            msg = f"{list_method} failed: {exc}"
+            logger.error("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+            return items
+
+        for summary in summaries:
+            result.total += 1
+            obj_name = ref_value(summary.get(name_field)) or summary.get(name_field, "")
+            if not obj_name:
+                result.failed += 1
+                result.errors.append(f"{list_method} returned object with no {name_field}")
+                continue
+
+            try:
+                kwargs = {name_field: obj_name}
+                # Hunt pilots are looked up by pattern + partition, not name
+                if name_field == "pattern":
+                    partition = ref_value(summary.get("routePartitionName"))
+                    kwargs["routePartitionName"] = partition or ""
+                detail = self.get_detail(get_method, **kwargs)
+            except Exception as exc:
+                result.failed += 1
+                msg = f"{get_method}({obj_name}): {exc}"
+                logger.warning("[%s] %s", self.name, msg)
+                result.errors.append(msg)
+                continue
+
+            if detail is None:
+                result.failed += 1
+                result.errors.append(f"{get_method} returned None for {obj_name}")
+                continue
+
+            items.append(detail)
+
+        return items
+
+    # ------------------------------------------------------------------
+    # Hunt Pilots
+    # ------------------------------------------------------------------
+
+    def _extract_hunt_pilots(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract hunt pilots. Verified against live CUCM 15.0 2026-03-23."""
+        return self._list_and_get(
+            result, "listHuntPilot", "getHuntPilot",
+            {"pattern": "%"}, HUNT_PILOT_LIST_RETURNED_TAGS, name_field="pattern",
+        )
+
+    # ------------------------------------------------------------------
+    # Hunt Lists
+    # ------------------------------------------------------------------
+
+    def _extract_hunt_lists(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract hunt lists. Verified via pipeline execution against CUCM 15.0 testbed."""
+        return self._list_and_get(
+            result, "listHuntList", "getHuntList",
+            {"name": "%"}, HUNT_LIST_LIST_RETURNED_TAGS,
+        )
+
+    # ------------------------------------------------------------------
+    # Line Groups
+    # ------------------------------------------------------------------
+
+    def _extract_line_groups(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract line groups. Verified via pipeline execution against CUCM 15.0 testbed."""
+        return self._list_and_get(
+            result, "listLineGroup", "getLineGroup",
+            {"name": "%"}, LINE_GROUP_LIST_RETURNED_TAGS,
+        )
+
+    # ------------------------------------------------------------------
+    # CTI Route Points
+    # ------------------------------------------------------------------
+
+    def _extract_cti_route_points(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract CTI route points. Verified via pipeline execution against CUCM 15.0 testbed."""
+        return self._list_and_get(
+            result, "listCtiRoutePoint", "getCtiRoutePoint",
+            {"name": "%"}, CTI_RP_LIST_RETURNED_TAGS,
+        )
+
+    # ------------------------------------------------------------------
+    # Call Parks — list only, no get needed
+    # ------------------------------------------------------------------
+
+    def _extract_call_parks(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract call parks (list only, no get needed). Verified via pipeline execution."""
+        try:
+            parks = self.paginated_list(
+                "listCallPark", {"pattern": "%"}, CALL_PARK_RETURNED_TAGS,
+            )
+            result.total += len(parks)
+            return parks
+        except Exception as exc:
+            msg = f"listCallPark failed: {exc}"
+            logger.error("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+            return []
+
+    # ------------------------------------------------------------------
+    # Pickup Groups
+    # ------------------------------------------------------------------
+
+    def _extract_pickup_groups(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract pickup groups. Verified against live CUCM 15.0 2026-03-24."""
+        return self._list_and_get(
+            result, "listCallPickupGroup", "getCallPickupGroup",
+            {"pattern": "%"}, PICKUP_GROUP_LIST_RETURNED_TAGS,
+        )
+
+    # ------------------------------------------------------------------
+    # Time Schedules
+    # ------------------------------------------------------------------
+
+    def _extract_time_schedules(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract time schedules. Verified via pipeline execution against CUCM 15.0 testbed."""
+        return self._list_and_get(
+            result, "listTimeSchedule", "getTimeSchedule",
+            {"name": "%"}, TIME_SCHEDULE_LIST_RETURNED_TAGS,
+        )
+
+    # ------------------------------------------------------------------
+    # Time Periods
+    # ------------------------------------------------------------------
+
+    def _extract_time_periods(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract time periods. Verified via pipeline execution against CUCM 15.0 testbed."""
+        return self._list_and_get(
+            result, "listTimePeriod", "getTimePeriod",
+            {"name": "%"}, TIME_PERIOD_LIST_RETURNED_TAGS,
+        )
+
+    # ------------------------------------------------------------------
+    # Executive/Assistant Pairs (SQL query)
+    # ------------------------------------------------------------------
+
+    def _extract_executive_assistant_pairs(
+        self, result: ExtractionResult,
+    ) -> list[dict[str, Any]]:
+        """Extract executive/assistant pairings via SQL query."""
+        try:
+            rows = self.conn.execute_sql(
+                "SELECT "
+                "exec_user.userid AS executive_userid, "
+                "asst_user.userid AS assistant_userid, "
+                "ea.fkexecutive AS executive_pkid, "
+                "ea.fkassistant AS assistant_pkid "
+                "FROM executiveassistant ea "
+                "JOIN enduser exec_user ON exec_user.pkid = ea.fkexecutive "
+                "JOIN enduser asst_user ON asst_user.pkid = ea.fkassistant"
+            )
+        except Exception as exc:
+            msg = f"executiveassistant SQL query failed: {exc}"
+            logger.warning("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+            return []
+        result.total += len(rows)
+        return rows
+
+    # ------------------------------------------------------------------
+    # Executive/Assistant Settings (SQL query)
+    # ------------------------------------------------------------------
+
+    def _extract_executive_settings(
+        self, result: ExtractionResult,
+    ) -> list[dict[str, Any]]:
+        """Extract executive/assistant service subscriptions via SQL query."""
+        try:
+            rows = self.conn.execute_sql(
+                "SELECT eu.userid, s.name AS service_name, s.servicetype "
+                "FROM enduser eu "
+                "JOIN endusersubscribedservice euss ON euss.fkenduser = eu.pkid "
+                "JOIN subscribedservice s ON s.pkid = euss.fksubscribedservice "
+                "WHERE s.name IN ('Executive', 'Executive-Assistant')"
+            )
+        except Exception as exc:
+            msg = f"executive settings SQL query failed: {exc}"
+            logger.warning("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+            return []
+        result.total += len(rows)
+        return rows

wxcli/migration/cucm/extractors/helpers.py

@@ -0,0 +1,73 @@
+"""Zeep dict navigation helpers for AXL response parsing.
+
+AXL reference fields consistently use the ``{'_value_1': value, 'uuid': uuid}``
+pattern. List fields may be a bare dict (single item) or a list.
+
+Sources:
+- 02b-cucm-extraction.md §3 (zeep dict navigation helpers)
+- 02-normalization-architecture.md pass 1 example (reference field pattern)
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def ref_value(field: dict[str, Any] | str | None) -> str | None:
+    """Extract the display value from a zeep reference field.
+
+    Zeep reference pattern: ``{'_value_1': 'DP-HQ', 'uuid': '{...}'}``
+    Returns ``'DP-HQ'``. Also handles plain strings and None.
+    (from 02b §3)
+    """
+    if field is None:
+        return None
+    if isinstance(field, str):
+        return field
+    if isinstance(field, dict):
+        return field.get("_value_1")
+    return None
+
+
+def ref_uuid(field: dict[str, Any] | None) -> str | None:
+    """Extract the UUID from a zeep reference field.
+
+    (from 02b §3)
+    """
+    if isinstance(field, dict):
+        return field.get("uuid")
+    return None
+
+
+def to_list(field: dict[str, Any] | list[Any] | None, key: str) -> list[Any]:
+    """Normalize a zeep list field to a Python list.
+
+    Zeep list pattern:
+        ``{'line': [item1, item2, ...]}``  — multiple items
+        ``{'line': item1}``                — single item (not wrapped in list)
+        ``None``                           — empty
+
+    (from 02b §3)
+    """
+    if field is None:
+        return []
+    if isinstance(field, dict):
+        inner = field.get(key)
+        if inner is None:
+            return []
+        if isinstance(inner, list):
+            return inner
+        return [inner]
+    if isinstance(field, list):
+        return field
+    return []
+
+
+def str_to_bool(value: str | None) -> bool | None:
+    """Convert AXL string boolean to Python bool.
+
+    (from 02b §3)
+    """
+    if value is None:
+        return None
+    return str(value).lower() == "true"

wxcli/migration/cucm/extractors/informational.py

@@ -0,0 +1,295 @@
+"""Tier 3: Informational extraction — CUCM objects with no Webex equivalent.
+
+Extracted for assessment report only. No canonical types, no mappers.
+Objects stored as MigrationObject with object_type="info_{type_name}".
+
+20 types across 4 categories:
+- cloud_managed (7): Regions, SRST, MRG, MRL, AAR, Device Mobility, Conference Bridges
+- not_migratable (3): Softkey Templates, IP Phone Services, Intercom DNs
+- different_arch (6): Common Phone Config, Phone Button Templates, Feature Control,
+                      Credential Policies, Recording Profiles, LDAP Directories
+- planning (4): Application Users, H.323 Gateways, Enterprise Params, Service Params
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from wxcli.migration.cucm.extractors.base import BaseExtractor, ExtractionResult
+
+logger = logging.getLogger(__name__)
+
+# (suffix, axl_list_method, search_criteria, returned_tags, category)
+# These 16 types use standard paginated_list().
+INFORMATIONAL_TYPES: list[tuple[str, str, dict, dict, str]] = [
+    # Category 1: Cloud-managed
+    ("region", "listRegion", {"name": "%"}, {"name": "", "defaultCodec": ""}, "cloud_managed"),
+    ("srst", "listSrst", {"name": "%"}, {"name": "", "ipAddress": "", "port": ""}, "cloud_managed"),
+    ("media_resource_group", "listMediaResourceGroup", {"name": "%"}, {"name": "", "description": ""}, "cloud_managed"),
+    ("media_resource_list", "listMediaResourceList", {"name": "%"}, {"name": "", "description": ""}, "cloud_managed"),
+    ("aar_group", "listAarGroup", {"name": "%"}, {"name": "", "description": ""}, "cloud_managed"),
+    ("device_mobility_group", "listDeviceMobilityGroup", {"name": "%"}, {"name": "", "description": ""}, "cloud_managed"),
+    ("conference_bridge", "listConferenceBridge", {"name": "%"}, {"name": "", "description": "", "product": ""}, "cloud_managed"),
+    # Category 2: Not migratable
+    ("ip_phone_service", "listIpPhoneService", {"name": "%"}, {"name": "", "url": "", "serviceType": ""}, "not_migratable"),
+    # Category 3: Different architecture
+    ("common_phone_config", "listCommonPhoneConfig", {"name": "%"}, {"name": "", "description": ""}, "different_arch"),
+    ("phone_button_template", "listPhoneButtonTemplate", {"name": "%"}, {"name": ""}, "different_arch"),
+    ("feature_control_policy", "listFeatureControlPolicy", {"name": "%"}, {"name": "", "description": ""}, "different_arch"),
+    ("credential_policy", "listCredentialPolicy", {"name": "%"}, {"name": "", "description": ""}, "different_arch"),
+    ("recording_profile", "listRecordingProfile", {"name": "%"}, {"name": "", "recorderDestination": ""}, "different_arch"),
+    ("ldap_directory", "listLdapDirectory", {"name": "%"}, {"name": "", "ldapDn": ""}, "different_arch"),
+    # Category 4: Planning input
+    ("app_user", "listAppUser", {"userid": "%"}, {"userid": "", "description": "", "associatedDevices": ""}, "planning"),
+    ("h323_gateway", "listH323Gateway", {"name": "%"}, {"name": "", "description": "", "product": ""}, "planning"),
+]
+
+# Category metadata for report rendering
+CATEGORY_METADATA: dict[str, dict[str, str]] = {
+    "cloud_managed": {
+        "label": "Cloud-Managed Resources",
+        "message": "No migration action needed — Webex manages this automatically.",
+    },
+    "not_migratable": {
+        "label": "Feature Gaps",
+        "message": "This CUCM feature has no Webex equivalent — functionality will be lost.",
+    },
+    "different_arch": {
+        "label": "Manual Reconfiguration Required",
+        "message": "Must be reconfigured manually in Webex Control Hub.",
+    },
+    "planning": {
+        "label": "Migration Planning Inputs",
+        "message": "Data informing migration planning decisions.",
+    },
+}
+
+# Friendly display names for each info type
+DISPLAY_NAMES: dict[str, str] = {
+    "region": "Regions",
+    "srst": "SRST References",
+    "media_resource_group": "Media Resource Groups",
+    "media_resource_list": "Media Resource Lists",
+    "aar_group": "AAR Groups",
+    "device_mobility_group": "Device Mobility Groups",
+    "conference_bridge": "Conference Bridges",
+    "softkey_template": "Softkey Templates",
+    "ip_phone_service": "IP Phone Services",
+    "intercom": "Intercom DNs",
+    "common_phone_config": "Common Phone Profiles",
+    "phone_button_template": "Phone Button Templates",
+    "feature_control_policy": "Feature Control Policies",
+    "credential_policy": "Credential Policies",
+    "recording_profile": "Recording Profiles",
+    "ldap_directory": "LDAP Directories",
+    "app_user": "Application Users",
+    "h323_gateway": "H.323 Gateways",
+    "enterprise_params": "Enterprise Parameters",
+    "service_params": "Service Parameters",
+}
+
+# Webex equivalents for "different_arch" types
+WEBEX_EQUIVALENTS: dict[str, str] = {
+    "common_phone_config": "Device configuration templates",
+    "phone_button_template": "Line key templates",
+    "feature_control_policy": "Calling policies (org/location level)",
+    "credential_policy": "SSO / password policies",
+    "recording_profile": "Call recording settings",
+    "ldap_directory": "Directory sync (Azure AD / Okta / SCIM)",
+}
+
+# Workarounds for "not_migratable" types
+NOT_MIGRATABLE_WORKAROUNDS: dict[str, str] = {
+    "softkey_template": "9800-series supports PSK; classic MPP uses Webex defaults",
+    "ip_phone_service": "Webex app replaces most XML service use cases",
+    "intercom": "Speed dial + auto-answer as workaround",
+}
+
+
+class InformationalExtractor(BaseExtractor):
+    """Extract 20 CUCM object types for assessment report only.
+
+    No canonical types, no mappers, no execution handlers.
+    Data flows: extractor -> store -> report appendix.
+    """
+
+    name = "informational"
+
+    def __init__(self, connection) -> None:
+        super().__init__(connection)
+        self.results: dict[str, list[dict[str, Any]]] = {}
+
+    def extract(self) -> ExtractionResult:
+        """Run extraction for all 20 informational types."""
+        result = ExtractionResult(extractor=self.name)
+
+        # 1. Standard AXL list types (16 types)
+        for suffix, method, criteria, tags, category in INFORMATIONAL_TYPES:
+            items = self._extract_list_type(suffix, method, criteria, tags, category, result)
+            self.results[suffix] = items
+
+        # Enrich common_phone_config with vendorConfig detail
+        cpcs = self.results.get("common_phone_config", [])
+        if cpcs:
+            self._fetch_common_phone_config_details(cpcs, result)
+
+        # 2. Softkey templates via SQL (AXL list doesn't exist)
+        self.results["softkey_template"] = self._extract_softkey_templates(result)
+
+        # 3. Intercom DNs via SQL
+        self.results["intercom"] = self._extract_intercom_dns(result)
+
+        # 4. Enterprise parameters (single getEnterprise call)
+        self.results["enterprise_params"] = self._extract_enterprise_params(result)
+
+        # 5. Service parameters (filtered listProcessConfig)
+        self.results["service_params"] = self._extract_service_params(result)
+
+        logger.info(
+            "[%s] Extracted %d informational objects across %d types (%d failed)",
+            self.name,
+            result.total,
+            sum(1 for v in self.results.values() if v),
+            result.failed,
+        )
+        return result
+
+    def _fetch_common_phone_config_details(
+        self, items: list[dict[str, Any]], result: ExtractionResult,
+    ) -> None:
+        """Enrich common_phone_config items with vendorConfig from getCommonPhoneConfig."""
+        for item in items:
+            name = item.get("name")
+            if not name:
+                continue
+            try:
+                resp = self.conn.service.getCommonPhoneConfig(name=name)
+                detail = resp
+                if isinstance(resp, dict):
+                    detail = resp.get("return", resp)
+                    if isinstance(detail, dict):
+                        detail = detail.get("commonPhoneConfig", detail)
+                if isinstance(detail, dict):
+                    vendor_config = detail.get("vendorConfig")
+                    if vendor_config is not None:
+                        item["vendorConfig"] = (
+                            str(vendor_config) if not isinstance(vendor_config, str)
+                            else vendor_config
+                        )
+                    for field in ("dndOption", "dndAlertingType"):
+                        val = detail.get(field)
+                        if val is not None:
+                            item[field] = val
+            except Exception as exc:
+                logger.debug(
+                    "[%s] getCommonPhoneConfig(%s) failed: %s", self.name, name, exc
+                )
+
+    def _extract_list_type(
+        self,
+        suffix: str,
+        method: str,
+        criteria: dict,
+        tags: dict,
+        category: str,
+        result: ExtractionResult,
+    ) -> list[dict[str, Any]]:
+        """Extract a single AXL list type."""
+        try:
+            items = self.paginated_list(method, criteria, tags)
+        except Exception as exc:
+            logger.warning("[%s] %s failed: %s", self.name, method, exc)
+            result.errors.append(f"{method} failed: {exc}")
+            result.failed += 1
+            return []
+
+        result.total += len(items)
+        for item in items:
+            item["_category"] = category
+            item["_info_type"] = suffix
+        return items
+
+    def _extract_softkey_templates(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract softkey template names via SQL (AXL list doesn't exist in CUCM 15.0)."""
+        try:
+            rows = self.conn.execute_sql(
+                "SELECT name, description FROM softkeytemplate ORDER BY name"
+            )
+        except Exception as exc:
+            logger.warning("[%s] Softkey template SQL failed: %s", self.name, exc)
+            result.errors.append(f"Softkey template SQL failed: {exc}")
+            return []
+
+        result.total += len(rows)
+        for row in rows:
+            row["_category"] = "not_migratable"
+            row["_info_type"] = "softkey_template"
+        return rows
+
+    def _extract_intercom_dns(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract intercom DNs via SQL query."""
+        try:
+            rows = self.conn.execute_sql(
+                "SELECT dnorpattern, description, fkroutepartition "
+                "FROM numplan WHERE tkpatternusage = 9 ORDER BY dnorpattern"
+            )
+        except Exception as exc:
+            logger.warning("[%s] Intercom DN SQL failed: %s", self.name, exc)
+            result.errors.append(f"Intercom DN SQL failed: {exc}")
+            return []
+
+        result.total += len(rows)
+        for row in rows:
+            row["_category"] = "not_migratable"
+            row["_info_type"] = "intercom"
+        return rows
+
+    def _extract_enterprise_params(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract enterprise parameters via single getEnterprise call."""
+        try:
+            raw = self.conn.service.getEnterprise()
+            if raw is None:
+                return []
+            from zeep.helpers import serialize_object
+            params = serialize_object(raw, dict)
+            if not isinstance(params, dict):
+                params = {"raw": str(params)}
+        except Exception as exc:
+            logger.warning("[%s] getEnterprise failed: %s", self.name, exc)
+            result.errors.append(f"getEnterprise failed: {exc}")
+            return []
+
+        result.total += 1
+        params["_category"] = "planning"
+        params["_info_type"] = "enterprise_params"
+        params["name"] = "Enterprise Parameters"
+        return [params]
+
+    def _extract_service_params(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract telephony-related service parameters via listProcessConfig."""
+        try:
+            items = self.paginated_list(
+                "listProcessConfig",
+                {"name": "%"},
+                {"name": "", "service": "", "value": ""},
+            )
+        except Exception as exc:
+            logger.warning("[%s] listProcessConfig failed: %s", self.name, exc)
+            result.errors.append(f"listProcessConfig failed: {exc}")
+            return []
+
+        telephony_keywords = (
+            "callmanager", "telephony", "tftp", "certificate",
+            "cisco call", "cisco ip voice",
+        )
+        filtered = []
+        for item in items:
+            service = (item.get("service") or "").lower()
+            if any(kw in service for kw in telephony_keywords):
+                item["_category"] = "planning"
+                item["_info_type"] = "service_params"
+                filtered.append(item)
+
+        result.total += len(filtered)
+        return filtered