wxcli 1.2.0__py3-none-any.whl

wxcli/migration/transform/mappers/ecbn_mapper.py

@@ -0,0 +1,263 @@
+"""EcbnMapper — produce per-entity ECBN configuration for E911 execution.
+
+Reads CanonicalUser and CanonicalWorkspace objects and classifies each
+entity's ECBN eligibility. No new AXL queries — uses existing cross-refs
+and canonical line data.
+
+Classification logic (from 2026-04-10-e911-ecbn-execution.md §4.1):
+  1. Entity has exactly one DID  -> DIRECT_LINE (auto-configured)
+  2. Entity has multiple DIDs    -> E911_ECBN_AMBIGUOUS decision
+  3. Entity has zero DIDs        -> LOCATION_ECBN (auto-configured)
+  4. User location differs from device location -> E911_LOCATION_MISMATCH
+"""
+
+from __future__ import annotations
+
+import logging
+
+from wxcli.migration.models import (
+    CanonicalEcbnConfig,
+    DecisionOption,
+    DecisionType,
+    MapperResult,
+    MigrationStatus,
+)
+from wxcli.migration.store import MigrationStore
+from wxcli.migration.transform.mappers.base import (
+    Mapper,
+    extract_provenance,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class EcbnMapper(Mapper):
+    """Classify each user/workspace by ECBN eligibility.
+
+    Depends on UserMapper, WorkspaceMapper, LocationMapper, LineMapper,
+    DeviceMapper — must run after all entity mappers have populated the store.
+    """
+
+    name = "ecbn_mapper"
+    depends_on = [
+        "user_mapper",
+        "workspace_mapper",
+        "location_mapper",
+        "line_mapper",
+        "device_mapper",
+    ]
+
+    def map(self, store: MigrationStore) -> MapperResult:
+        result = MapperResult()
+
+        # Process users
+        for user_data in store.get_objects("user"):
+            status = user_data.get("status")
+            if status in (MigrationStatus.SKIPPED.value, "skipped"):
+                continue
+            self._process_user(store, user_data, result)
+
+        # Process workspaces
+        for ws_data in store.get_objects("workspace"):
+            status = ws_data.get("status")
+            if status in (MigrationStatus.SKIPPED.value, "skipped"):
+                continue
+            self._process_workspace(store, ws_data, result)
+
+        return result
+
+    # ------------------------------------------------------------------
+    # User processing
+    # ------------------------------------------------------------------
+
+    def _process_user(
+        self,
+        store: MigrationStore,
+        user_data: dict,
+        result: MapperResult,
+    ) -> None:
+        user_cid = user_data["canonical_id"]
+        user_location = user_data.get("location_id")
+
+        # Collect all DIDs (E.164 numbers) from devices -> DNs -> lines
+        dids, device_locations = self._collect_user_dids(store, user_cid)
+        primary_did = dids[0] if dids else None
+
+        # Determine ECBN selection
+        if len(dids) >= 1:
+            selection = "DIRECT_LINE"
+            needs_loc = False
+        else:
+            selection = "LOCATION_ECBN"
+            needs_loc = True
+
+        cfg = CanonicalEcbnConfig(
+            canonical_id=f"ecbn_config:{user_cid}",
+            provenance=extract_provenance(user_data),
+            status=MigrationStatus.ANALYZED,
+            entity_type="user",
+            entity_canonical_id=user_cid,
+            location_canonical_id=user_location,
+            ecbn_selection=selection,
+            did_numbers=dids,
+            primary_did=primary_did,
+            needs_location_ecbn=needs_loc,
+        )
+        store.upsert_object(cfg)
+        result.objects_created += 1
+
+        # Multi-DID → ambiguous decision
+        if len(dids) >= 2:
+            options = [
+                DecisionOption(
+                    id=f"did_{d}",
+                    label=f"Use {d}",
+                    impact=f"ECBN set to {d} (DIRECT_LINE)",
+                )
+                for d in dids
+            ]
+            options.append(DecisionOption(
+                id="location_ecbn",
+                label="Use location ECBN",
+                impact="ECBN set to LOCATION_ECBN",
+            ))
+            decision = self._create_decision(
+                store=store,
+                decision_type=DecisionType.E911_ECBN_AMBIGUOUS,
+                severity="HIGH",
+                summary=f"User {user_cid} has {len(dids)} DIDs — which is the ECBN?",
+                context={
+                    "user_canonical_id": user_cid,
+                    "did_numbers": dids,
+                    "primary_did": primary_did,
+                    "user_location": user_location,
+                },
+                options=options,
+                affected_objects=[cfg.canonical_id, user_cid],
+            )
+            result.decisions.append(decision)
+
+        # Location mismatch detection
+        if user_location and device_locations:
+            distinct_device_locs = {loc for loc in device_locations if loc}
+            if distinct_device_locs and user_location not in distinct_device_locs:
+                # Sort the set before picking — iteration order over sets
+                # depends on PYTHONHASHSEED and would produce nondeterministic
+                # fingerprints when a user has 2+ devices at different
+                # locations.
+                sorted_dev_locs = sorted(distinct_device_locs)
+                dev_loc = sorted_dev_locs[0]
+                options = [
+                    DecisionOption(
+                        id="use_user_location",
+                        label=f"Use user's assigned location ({user_location})",
+                        impact="ECBN resolves to user_location",
+                    ),
+                    DecisionOption(
+                        id="use_device_location",
+                        label=f"Use device's physical location ({dev_loc})",
+                        impact="ECBN resolves to device_location",
+                    ),
+                    DecisionOption(
+                        id="manual",
+                        label="Operator must verify physical location",
+                        impact="Requires manual verification",
+                    ),
+                ]
+                decision = self._create_decision(
+                    store=store,
+                    decision_type=DecisionType.E911_LOCATION_MISMATCH,
+                    severity="HIGH",
+                    summary=f"User {user_cid} location differs from device location",
+                    context={
+                        "user_canonical_id": user_cid,
+                        "user_location": user_location,
+                        "device_location": dev_loc,
+                        "device_locations": sorted_dev_locs,
+                    },
+                    options=options,
+                    affected_objects=[cfg.canonical_id, user_cid],
+                )
+                result.decisions.append(decision)
+
+    def _collect_user_dids(
+        self,
+        store: MigrationStore,
+        user_cid: str,
+    ) -> tuple[list[str], list[str]]:
+        """Walk user -> devices -> DNs -> lines to collect DID numbers.
+
+        Returns (did_numbers, device_location_canonical_ids).
+        Dedupes DIDs (same DID on multiple devices counts once).
+        """
+        dids: list[str] = []
+        seen: set[str] = set()
+        device_locations: list[str] = []
+
+        device_cids = store.find_cross_refs(user_cid, "user_has_device")
+        for dev_cid in device_cids:
+            dev_data = store.get_object(dev_cid)
+            if dev_data:
+                dev_loc = dev_data.get("location_canonical_id")
+                if dev_loc:
+                    device_locations.append(dev_loc)
+
+            dn_cids = store.find_cross_refs(dev_cid, "device_has_dn")
+            for dn_cid in dn_cids:
+                if not dn_cid.startswith("dn:"):
+                    continue
+                line_cid = "line:" + dn_cid[len("dn:"):]
+                line = store.get_object(line_cid)
+                if not line:
+                    continue
+                e164 = line.get("e164")
+                if e164 and e164 not in seen:
+                    dids.append(e164)
+                    seen.add(e164)
+
+        # Sort DIDs for deterministic ordering — fingerprint stability depends
+        # on this. store.find_cross_refs returns SQLite rows in insertion order,
+        # not by any semantic notion of "primary," so primary_did = dids[0] on
+        # the caller side must be derived from a stable sort.
+        dids.sort()
+        return dids, device_locations
+
+    # ------------------------------------------------------------------
+    # Workspace processing
+    # ------------------------------------------------------------------
+
+    def _process_workspace(
+        self,
+        store: MigrationStore,
+        ws_data: dict,
+        result: MapperResult,
+    ) -> None:
+        ws_cid = ws_data["canonical_id"]
+        phone_number = ws_data.get("phone_number")
+        location = ws_data.get("location_id")
+
+        if phone_number:
+            selection = "DIRECT_LINE"
+            dids = [phone_number]
+            primary = phone_number
+            needs_loc = False
+        else:
+            selection = "LOCATION_ECBN"
+            dids = []
+            primary = None
+            needs_loc = True
+
+        cfg = CanonicalEcbnConfig(
+            canonical_id=f"ecbn_config:{ws_cid}",
+            provenance=extract_provenance(ws_data),
+            status=MigrationStatus.ANALYZED,
+            entity_type="workspace",
+            entity_canonical_id=ws_cid,
+            location_canonical_id=location,
+            ecbn_selection=selection,
+            did_numbers=dids,
+            primary_did=primary,
+            needs_location_ecbn=needs_loc,
+        )
+        store.upsert_object(cfg)
+        result.objects_created += 1

wxcli/migration/transform/mappers/executive_assistant_mapper.py

@@ -0,0 +1,156 @@
+"""Maps CUCM executive/assistant pairings to Webex Executive/Assistant config.
+
+Reads normalized exec_asst_pair objects from the store, groups by executive,
+resolves assistant user canonical_ids, and produces CanonicalExecutiveAssistant
+objects. Generates MISSING_DATA decisions when one side of a pair is not in
+migration scope.
+
+(from executive-assistant-migration spec §4c)
+"""
+from __future__ import annotations
+
+import logging
+from collections import defaultdict
+from typing import Any
+
+from wxcli.migration.models import (
+    CanonicalExecutiveAssistant,
+    DecisionType,
+    MapperResult,
+    MigrationStatus,
+)
+from wxcli.migration.store import MigrationStore
+from wxcli.migration.transform.mappers.base import (
+    Mapper,
+    decision_to_store_dict,
+    extract_provenance,
+    manual_option,
+    skip_option,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ExecutiveAssistantMapper(Mapper):
+    """Maps CUCM executive/assistant pairs to Webex config objects."""
+
+    name = "executive_assistant_mapper"
+    depends_on = ["user_mapper"]
+
+    def map(self, store: MigrationStore) -> MapperResult:
+        result = MapperResult()
+
+        # Group pairs by executive userid
+        pairs_by_exec: dict[str, list[str]] = defaultdict(list)
+        for pair_data in store.get_objects("exec_asst_pair"):
+            state = pair_data.get("pre_migration_state") or {}
+            exec_userid = state.get("executive_userid")
+            asst_userid = state.get("assistant_userid")
+            if exec_userid and asst_userid:
+                pairs_by_exec[exec_userid].append(asst_userid)
+
+        if not pairs_by_exec:
+            return result
+
+        # Build settings lookup
+        settings_by_userid: dict[str, dict[str, Any]] = {}
+        for setting_data in store.get_objects("exec_setting"):
+            state = setting_data.get("pre_migration_state") or {}
+            userid = state.get("userid")
+            if userid:
+                settings_by_userid[userid] = state
+
+        # Process each executive
+        for exec_userid, asst_userids in pairs_by_exec.items():
+            exec_canonical_id = f"user:{exec_userid}"
+
+            # Verify executive exists in store
+            exec_obj = store.get_object(exec_canonical_id)
+            if exec_obj is None:
+                decision = self._create_decision(
+                    store=store,
+                    decision_type=DecisionType.MISSING_DATA,
+                    severity="HIGH",
+                    summary=(
+                        f"Executive '{exec_userid}' not in migration scope \u2014 "
+                        f"{len(asst_userids)} assistant pairing(s) cannot be migrated"
+                    ),
+                    context={
+                        "missing_reason": "executive_assistant_broken_pair",
+                        "missing_side": "executive",
+                        "executive_userid": exec_userid,
+                        "assistant_userids": asst_userids,
+                    },
+                    options=[
+                        manual_option(
+                            "Configure executive/assistant manually in Webex after migration"
+                        ),
+                        skip_option("Executive/assistant pairing not migrated"),
+                    ],
+                    affected_objects=[exec_canonical_id],
+                )
+                store.save_decision(decision_to_store_dict(decision))
+                result.decisions.append(decision)
+                continue
+
+            # Verify each assistant exists
+            valid_assistants: list[str] = []
+            for asst_userid in asst_userids:
+                asst_canonical_id = f"user:{asst_userid}"
+                asst_obj = store.get_object(asst_canonical_id)
+                if asst_obj is None:
+                    decision = self._create_decision(
+                        store=store,
+                        decision_type=DecisionType.MISSING_DATA,
+                        severity="HIGH",
+                        summary=(
+                            f"Assistant '{asst_userid}' for executive '{exec_userid}' "
+                            f"not in migration scope"
+                        ),
+                        context={
+                            "missing_reason": "executive_assistant_broken_pair",
+                            "missing_side": "assistant",
+                            "executive_userid": exec_userid,
+                            "assistant_userid": asst_userid,
+                        },
+                        options=[
+                            manual_option(
+                                "Configure assistant manually in Webex after migration"
+                            ),
+                            skip_option("This assistant pairing not migrated"),
+                        ],
+                        affected_objects=[exec_canonical_id, asst_canonical_id],
+                    )
+                    store.save_decision(decision_to_store_dict(decision))
+                    result.decisions.append(decision)
+                else:
+                    valid_assistants.append(asst_canonical_id)
+
+            if not valid_assistants:
+                continue
+
+            # Read executive settings
+            exec_settings = settings_by_userid.get(exec_userid, {})
+
+            ea_obj = CanonicalExecutiveAssistant(
+                canonical_id=f"executive_assistant:{exec_userid}",
+                provenance=extract_provenance(exec_obj),
+                status=MigrationStatus.ANALYZED,
+                executive_canonical_id=exec_canonical_id,
+                assistant_canonical_ids=valid_assistants,
+                alerting_mode=exec_settings.get("alerting_mode", "SIMULTANEOUS"),
+                filter_enabled=bool(exec_settings.get("filter_enabled", False)),
+                filter_type=exec_settings.get("filter_type", "ALL_CALLS"),
+                screening_enabled=bool(exec_settings.get("screening_enabled", False)),
+            )
+
+            store.upsert_object(ea_obj)
+            result.objects_created += 1
+
+            store.add_cross_ref(
+                exec_canonical_id,
+                ea_obj.canonical_id,
+                "user_has_executive_assistant_config",
+            )
+
+        return result