wxcli 1.2.0__py3-none-any.whl

wxcli/migration/cucm/extractors/locations.py

@@ -0,0 +1,221 @@
+"""Locations extractor — Device Pools, DateTime Groups, CUCM Locations.
+
+Extracts CUCM location-related entities that feed the location_mapper
+(from 03b §1), which maps Device Pools → Webex Calling Locations.
+
+Sources:
+- 02b-cucm-extraction.md §2.1 (locations extractor spec)
+- 03b-transform-mappers.md §1 (location_mapper field mapping)
+- 02-normalization-architecture.md cross-ref #1, #2
+"""
+
+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__)
+
+# --- returnedTags constants (from 02b §2.1) ---
+
+DEVICE_POOL_RETURNED_TAGS = {
+    'name': '',                          # The device pool name itself (maps to location name)
+    'dateTimeSettingName': '',           # Reference → DateTime Group (cross-ref #1)
+    'locationName': '',                  # Reference → CUCM Location entity (cross-ref #2)
+    'callManagerGroupName': '',          # Not migratable — "Webex is cloud-managed"
+    'srstName': '',                      # Not migratable — "on-prem only"
+    'regionName': '',                    # Not migratable — "cloud-managed"
+    'mediaResourceListName': '',         # Not migratable — "cloud-managed"
+}
+
+DATETIME_GROUP_RETURNED_TAGS = {
+    'name': '',                          # DateTime group name (referenced by device pool)
+    'timeZone': '',                      # IANA timezone string — verified via pipeline execution
+}
+
+CUCM_LOCATION_RETURNED_TAGS = {
+    'name': '',                          # Location entity name
+    # Address fields not present on CAC Location object — verified via pipeline execution
+}
+
+
+class LocationExtractor(BaseExtractor):
+    """Extract Device Pools, DateTime Groups, and CUCM Locations.
+
+    Three-entity extractor:
+    1. Device Pools — discovered via listDevicePool, full detail via getDevicePool
+    2. DateTime Groups — discovered via listDateTimeGroup, detail via getDateTimeGroup
+    3. CUCM Locations — discovered via listLocation (verified via pipeline execution)
+
+    Results stored in self.results with keys:
+        device_pools, datetime_groups, cucm_locations
+
+    (from 02b §2.1)
+    """
+
+    name = "locations"
+
+    def __init__(self, connection: AXLConnection) -> None:
+        super().__init__(connection)
+        self.results: dict[str, list[dict[str, Any]]] = {
+            'device_pools': [],
+            'datetime_groups': [],
+            'cucm_locations': [],
+        }
+
+    def extract(self) -> ExtractionResult:
+        """Run all three sub-extractions and return combined result."""
+        total = 0
+        failed = 0
+        errors: list[str] = []
+
+        # --- Device Pools ---
+        dp_total, dp_failed, dp_errors = self._extract_device_pools()
+        total += dp_total
+        failed += dp_failed
+        errors.extend(dp_errors)
+
+        # --- DateTime Groups ---
+        dt_total, dt_failed, dt_errors = self._extract_datetime_groups()
+        total += dt_total
+        failed += dt_failed
+        errors.extend(dt_errors)
+
+        # --- CUCM Locations ---
+        loc_total, loc_failed, loc_errors = self._extract_cucm_locations()
+        total += loc_total
+        failed += loc_failed
+        errors.extend(loc_errors)
+
+        return ExtractionResult(
+            extractor=self.name,
+            total=total,
+            failed=failed,
+            errors=errors,
+        )
+
+    def _extract_device_pools(self) -> tuple[int, int, list[str]]:
+        """List all device pools, then get full detail for each.
+
+        listDevicePool returns summary; getDevicePool returns full references
+        (datetime group, CUCM location, region, SRST).
+        (from 02b §2.1 AXL Method Mapping)
+        """
+        errors: list[str] = []
+        failed = 0
+
+        try:
+            summary_list = self.paginated_list(
+                'listDevicePool',
+                search_criteria={'name': '%'},
+                returned_tags=DEVICE_POOL_RETURNED_TAGS,
+            )
+        except Exception as exc:
+            msg = f"listDevicePool failed: {exc}"
+            logger.error("[%s] %s", self.name, msg)
+            return 0, 0, [msg]
+        total = len(summary_list)
+        logger.info("Found %d device pools via listDevicePool", total)
+
+        for dp_summary in summary_list:
+            dp_name = dp_summary.get('name', '<unknown>')
+            try:
+                detail = self.get_detail('getDevicePool', name=dp_name)
+                if detail is not None:
+                    self.results['device_pools'].append(detail)
+                else:
+                    logger.warning("getDevicePool returned None for '%s'", dp_name)
+                    failed += 1
+                    errors.append(f"getDevicePool returned None for '{dp_name}'")
+            except Exception as exc:
+                logger.warning("getDevicePool failed for '%s': %s", dp_name, exc)
+                failed += 1
+                errors.append(f"getDevicePool failed for '{dp_name}': {exc}")
+
+        logger.info(
+            "Device pools: %d total, %d succeeded, %d failed",
+            total, total - failed, failed,
+        )
+        return total, failed, errors
+
+    def _extract_datetime_groups(self) -> tuple[int, int, list[str]]:
+        """List all DateTime Groups, then get full detail for each.
+
+        Get returns timezone name and offset details.
+        (from 02b §2.1 AXL Method Mapping)
+        """
+        errors: list[str] = []
+        failed = 0
+
+        try:
+            summary_list = self.paginated_list(
+                'listDateTimeGroup',
+                search_criteria={'name': '%'},
+                returned_tags=DATETIME_GROUP_RETURNED_TAGS,
+            )
+        except Exception as exc:
+            msg = f"listDateTimeGroup failed: {exc}"
+            logger.error("[%s] %s", self.name, msg)
+            return 0, 0, [msg]
+        total = len(summary_list)
+        logger.info("Found %d datetime groups via listDateTimeGroup", total)
+
+        for dtg_summary in summary_list:
+            dtg_name = dtg_summary.get('name', '<unknown>')
+            try:
+                detail = self.get_detail('getDateTimeGroup', name=dtg_name)
+                if detail is not None:
+                    self.results['datetime_groups'].append(detail)
+                else:
+                    logger.warning("getDateTimeGroup returned None for '%s'", dtg_name)
+                    failed += 1
+                    errors.append(f"getDateTimeGroup returned None for '{dtg_name}'")
+            except Exception as exc:
+                logger.warning("getDateTimeGroup failed for '%s': %s", dtg_name, exc)
+                failed += 1
+                errors.append(f"getDateTimeGroup failed for '{dtg_name}': {exc}")
+
+        logger.info(
+            "DateTime groups: %d total, %d succeeded, %d failed",
+            total, total - failed, failed,
+        )
+        return total, failed, errors
+
+    def _extract_cucm_locations(self) -> tuple[int, int, list[str]]:
+        """List all CUCM Location entities.
+
+        CUCM Locations are primarily for Call Admission Control (bandwidth).
+        May not contain physical address fields.
+        Verified via pipeline execution against CUCM 15.0 testbed.
+        (from 02b §2.1 design decision)
+        """
+        errors: list[str] = []
+        failed = 0
+
+        try:
+            summary_list = self.paginated_list(
+                'listLocation',
+                search_criteria={'name': '%'},
+                returned_tags=CUCM_LOCATION_RETURNED_TAGS,
+            )
+        except Exception as exc:
+            msg = f"listLocation failed: {exc}"
+            logger.error("[%s] %s", self.name, msg)
+            return 0, 0, [msg]
+        total = len(summary_list)
+        logger.info("Found %d CUCM locations via listLocation", total)
+
+        # CUCM Location entities are simple enough that list may return
+        # all needed fields. Store directly without per-object get.
+        for loc in summary_list:
+            self.results['cucm_locations'].append(loc)
+
+        logger.info(
+            "CUCM locations: %d total, %d succeeded, %d failed",
+            total, total - failed, failed,
+        )
+        return total, failed, errors

wxcli/migration/cucm/extractors/moh.py

@@ -0,0 +1,100 @@
+"""MOH (Music On Hold) extractor for CUCM AXL.
+
+Pulls MOH Audio Sources from CUCM AXL.
+
+Sources:
+- tier2-enterprise-expansion.md §2.3 (MOH extraction)
+- AXL WSDL: listMohAudioSource / getMohAudioSource
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from wxcli.migration.cucm.extractors.base import BaseExtractor, ExtractionResult
+
+logger = logging.getLogger(__name__)
+
+# ------------------------------------------------------------------
+# ReturnedTags constants
+# ------------------------------------------------------------------
+
+MOH_AUDIO_SOURCE_LIST_RETURNED_TAGS = {
+    "name": "",
+    "sourceFileName": "",
+    "isDefault": "",
+    "sourceId": "",
+}
+
+
+class MOHExtractor(BaseExtractor):
+    """Extract Music On Hold audio sources from CUCM AXL.
+
+    MOH audio sources define the audio files played to callers on hold.
+    CUCM supports multiple audio sources; Webex Calling supports per-location
+    MOH with a single audio file or default music.
+
+    (from tier2-enterprise-expansion.md §2.3)
+    """
+
+    name = "moh"
+
+    def __init__(self, connection) -> None:
+        super().__init__(connection)
+        self.results: dict[str, list[dict[str, Any]]] = {}
+
+    def extract(self) -> ExtractionResult:
+        """Run MOH audio source extraction.
+
+        Returns an ExtractionResult summarizing total objects and errors.
+        """
+        result = ExtractionResult(extractor=self.name)
+        self.results["moh_sources"] = self._extract_moh_sources(result)
+        return result
+
+    # ------------------------------------------------------------------
+    # MOH Audio Sources
+    # ------------------------------------------------------------------
+
+    def _extract_moh_sources(
+        self, result: ExtractionResult
+    ) -> list[dict[str, Any]]:
+        """List all MOH audio sources, then get full detail for each.
+
+        Uses listMohAudioSource for summary, getMohAudioSource for detail.
+        """
+        sources: list[dict[str, Any]] = []
+        try:
+            summaries = self.paginated_list(
+                "listMohAudioSource",
+                {"name": "%"},
+                MOH_AUDIO_SOURCE_LIST_RETURNED_TAGS,
+            )
+        except Exception as exc:
+            msg = f"listMohAudioSource failed: {exc}"
+            logger.error("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+            return sources
+
+        for summary in summaries:
+            result.total += 1
+            name = summary.get("name", "")
+            if not name:
+                result.failed += 1
+                continue
+            try:
+                detail = self.get_detail("getMohAudioSource", name=name)
+            except Exception as exc:
+                logger.warning(
+                    "[%s] getMohAudioSource error for %s: %s",
+                    self.name, name, exc,
+                )
+                sources.append(summary)
+                continue
+            if detail is None:
+                sources.append(summary)
+                continue
+            sources.append({**summary, **detail})
+
+        return sources

wxcli/migration/cucm/extractors/remote_destinations.py

@@ -0,0 +1,96 @@
+"""Remote Destination extractor for CUCM AXL.
+
+Pulls Remote Destinations (mobile numbers for Single Number Reach) from CUCM.
+
+Sources:
+- tier2-enterprise-expansion.md §4 (SNR extraction)
+- AXL WSDL: listRemoteDestination / getRemoteDestination
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from wxcli.migration.cucm.extractors.base import BaseExtractor, ExtractionResult
+
+logger = logging.getLogger(__name__)
+
+# returnedTags for listRemoteDestination (from tier2 spec §4)
+REMOTE_DEST_LIST_RETURNED_TAGS = {
+    "name": "",
+    "destination": "",
+    "ownerUserId": "",
+    "isMobilePhone": "",
+    "enableMobileConnect": "",
+}
+
+# Additional fields from getRemoteDestination
+REMOTE_DEST_GET_RETURNED_TAGS = {
+    "answerTooSoonTimer": "",
+    "answerTooLateTimer": "",
+    "lineAssociations": "",
+    "remoteDestinationProfileName": "",
+}
+
+
+class RemoteDestinationExtractor(BaseExtractor):
+    """Extract Remote Destinations from CUCM AXL.
+
+    Remote Destinations define mobile numbers that ring when a user's
+    desk phone rings (Single Number Reach / Mobile Connect).
+
+    (from tier2-enterprise-expansion.md §4)
+    """
+
+    name = "remote_destinations"
+
+    def __init__(self, connection) -> None:
+        super().__init__(connection)
+        self.results: dict[str, list[dict[str, Any]]] = {}
+
+    def extract(self) -> ExtractionResult:
+        result = ExtractionResult(extractor=self.name)
+        self.results["remote_destinations"] = self._extract_remote_destinations(result)
+        return result
+
+    def _extract_remote_destinations(
+        self, result: ExtractionResult
+    ) -> list[dict[str, Any]]:
+        """List all remote destinations, then get full detail for each."""
+        destinations: list[dict[str, Any]] = []
+        try:
+            summaries = self.paginated_list(
+                "listRemoteDestination",
+                {"name": "%"},
+                REMOTE_DEST_LIST_RETURNED_TAGS,
+            )
+        except Exception as exc:
+            msg = f"listRemoteDestination failed: {exc}"
+            logger.error("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+            return destinations
+
+        for summary in summaries:
+            result.total += 1
+            dest_name = summary.get("name", "")
+            if not dest_name:
+                result.failed += 1
+                continue
+            try:
+                detail = self.get_detail("getRemoteDestination", name=dest_name)
+            except Exception as exc:
+                logger.warning(
+                    "[%s] getRemoteDestination error for %s: %s",
+                    self.name, dest_name, exc,
+                )
+                destinations.append(summary)
+                continue
+            if detail is None:
+                destinations.append(summary)
+                continue
+            # Merge list-level fields into detail (detail may not have all list fields)
+            merged = {**summary, **detail}
+            destinations.append(merged)
+
+        return destinations