wxcli 1.2.0__py3-none-any.whl

wxcli/migration/cucm/extractors/templates.py

@@ -0,0 +1,229 @@
+"""Template extractor — phone button templates and softkey templates.
+
+Phone button templates use two-step AXL extraction (list → get-detail).
+Softkey templates use SQL queries (AXL list/get operations don't exist in v15.0).
+
+Templates are shared objects — typically 5-20 button templates and
+3-10 softkey templates per cluster.
+
+AXL gotchas (verified 2026-03-25 against CUCM 15.0):
+- listPhoneButtonTemplate returnedTags only supports {name, isUserModifiable},
+  NOT basePhoneTemplateName.
+- getPhoneButtonTemplate returns buttons with <buttonNumber> (not <index>),
+  and "Speed Dial BLF" as the feature name (not "Busy Lamp Field" as in add).
+- addSoftkeyTemplate, getSoftkeyTemplate, listSoftkeyTemplate DO NOT EXIST.
+  Softkey templates must be queried via executeSQLQuery on the softkeytemplate
+  table, with typesoftkey for ID-to-name decoding.
+
+Sources:
+- tier2-phase2-phone-config-design.md §1.1, §13.1, §13.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
+
+logger = logging.getLogger(__name__)
+
+# listPhoneButtonTemplate only supports these returnedTags (verified 2026-03-25)
+BUTTON_TEMPLATE_LIST_TAGS = {"name": "", "isUserModifiable": ""}
+
+
+# Softkey ID → name mapping, populated once from typesoftkey SQL table
+_SOFTKEY_ID_CACHE: dict[str, str] = {}
+
+# softkeysetclause state positions (verified 2026-03-25, CUCM 15.0)
+# Semicolon-delimited, 12 states in fixed order:
+SOFTKEY_STATE_ORDER = [
+    "On Hook",
+    "Connected",
+    "On Hold",
+    "Ring In",
+    "Off Hook",
+    "Connected Transfer",
+    "Transition",
+    "Connected Conference",
+    "Park",
+    "Alerting",
+    "Shared Active",
+    "Shared Held",
+]
+
+
+class TemplateExtractor(BaseExtractor):
+    """Extract phone button templates and softkey templates from CUCM."""
+
+    name = "templates"
+
+    def __init__(self, connection: AXLConnection) -> None:
+        super().__init__(connection)
+        self.results: dict[str, list[dict[str, Any]]] = {}
+
+    def extract(self) -> ExtractionResult:
+        """Run extraction for button templates (AXL) and softkey templates (SQL)."""
+        result = ExtractionResult(extractor=self.name)
+
+        button_templates = self._extract_button_templates(result)
+        softkey_templates = self._extract_softkey_templates(result)
+
+        self.results["button_templates"] = button_templates
+        self.results["softkey_templates"] = softkey_templates
+
+        logger.info(
+            "[%s] Extracted %d button templates, %d softkey templates (%d failed)",
+            self.name, len(button_templates), len(softkey_templates), result.failed,
+        )
+        return result
+
+    # ------------------------------------------------------------------
+    # Phone button templates — AXL list + get-detail
+    # ------------------------------------------------------------------
+
+    def _extract_button_templates(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """List and get-detail all phone button templates."""
+        logger.info("[%s] Listing phone button templates...", self.name)
+        try:
+            summaries = self.paginated_list(
+                method_name="listPhoneButtonTemplate",
+                search_criteria={"name": "%"},
+                returned_tags=BUTTON_TEMPLATE_LIST_TAGS,
+            )
+        except Exception as exc:
+            logger.warning("[%s] listPhoneButtonTemplate failed: %s", self.name, exc)
+            result.errors.append(f"listPhoneButtonTemplate failed: {exc}")
+            return []
+
+        result.total += len(summaries)
+
+        templates: list[dict[str, Any]] = []
+        for summary in summaries:
+            name = ref_value(summary.get("name")) or summary.get("name")
+            if not name:
+                result.failed += 1
+                result.errors.append("Button template with no name")
+                continue
+
+            try:
+                detail = self.get_detail("getPhoneButtonTemplate", name=name)
+            except Exception as exc:
+                logger.warning("[%s] getPhoneButtonTemplate(%s) failed: %s", self.name, name, exc)
+                result.failed += 1
+                result.errors.append(f"getPhoneButtonTemplate failed for {name}")
+                continue
+
+            if detail is None:
+                result.failed += 1
+                result.errors.append(f"getPhoneButtonTemplate returned None for {name}")
+                continue
+
+            templates.append(detail)
+
+        return templates
+
+    # ------------------------------------------------------------------
+    # Softkey templates — SQL queries (AXL operations don't exist)
+    # ------------------------------------------------------------------
+
+    def _extract_softkey_templates(self, result: ExtractionResult) -> list[dict[str, Any]]:
+        """Extract softkey templates via SQL (AXL list/get don't exist in v15.0)."""
+        logger.info("[%s] Querying softkey templates via SQL...", self.name)
+
+        # Load softkey ID → name mapping
+        softkey_names = self._load_softkey_type_names()
+
+        try:
+            rows = self.conn.execute_sql(
+                "SELECT name, description, softkeyclause, softkeysetclause, "
+                "iksoftkeytemplate_base FROM softkeytemplate ORDER BY name"
+            )
+        except Exception as exc:
+            logger.warning("[%s] Softkey template SQL query failed: %s", self.name, exc)
+            result.errors.append(f"Softkey template SQL failed: {exc}")
+            return []
+
+        result.total += len(rows)
+        templates: list[dict[str, Any]] = []
+
+        for row in rows:
+            name = row.get("name")
+            if not name:
+                result.failed += 1
+                continue
+
+            try:
+                parsed = self._parse_softkey_template(row, softkey_names)
+                templates.append(parsed)
+            except Exception as exc:
+                logger.warning("[%s] Failed to parse softkey template %s: %s", self.name, name, exc)
+                result.failed += 1
+                result.errors.append(f"Parse failed for softkey template {name}: {exc}")
+
+        return templates
+
+    def _load_softkey_type_names(self) -> dict[str, str]:
+        """Load typesoftkey enum → name mapping from CUCM DB."""
+        if _SOFTKEY_ID_CACHE:
+            return _SOFTKEY_ID_CACHE
+
+        try:
+            rows = self.conn.execute_sql(
+                "SELECT enum, name FROM typesoftkey ORDER BY enum"
+            )
+            for row in rows:
+                enum_val = str(row.get("enum", ""))
+                sk_name = row.get("name", "")
+                if enum_val and sk_name:
+                    _SOFTKEY_ID_CACHE[enum_val] = sk_name
+        except Exception as exc:
+            logger.warning("[%s] typesoftkey query failed: %s", self.name, exc)
+
+        return _SOFTKEY_ID_CACHE
+
+    def _parse_softkey_template(
+        self, row: dict[str, Any], softkey_names: dict[str, str]
+    ) -> dict[str, Any]:
+        """Parse a softkeytemplate SQL row into a structured dict.
+
+        Decodes softkeyclause and softkeysetclause into human-readable form.
+        """
+        name = row.get("name", "")
+        description = row.get("description", "")
+        base_pkid = row.get("iksoftkeytemplate_base", "")
+
+        # Decode softkeyclause: "0:1:2:3:4" → ["Undefined", "Redial", "NewCall", ...]
+        softkey_clause = row.get("softkeyclause", "")
+        available_softkeys: list[str] = []
+        if softkey_clause:
+            for sk_id in softkey_clause.split(":"):
+                sk_name = softkey_names.get(sk_id, f"unknown_{sk_id}")
+                available_softkeys.append(sk_name)
+
+        # Decode softkeysetclause: semicolon-separated per-state lists
+        # Each state: colon-separated softkey IDs
+        softkey_set_clause = row.get("softkeysetclause", "")
+        call_states: dict[str, list[str]] = {}
+        if softkey_set_clause:
+            state_parts = softkey_set_clause.split(";")
+            for i, state_data in enumerate(state_parts):
+                if i >= len(SOFTKEY_STATE_ORDER):
+                    break
+                state_name = SOFTKEY_STATE_ORDER[i]
+                keys: list[str] = []
+                if state_data:
+                    for sk_id in state_data.split(":"):
+                        sk_name = softkey_names.get(sk_id, f"unknown_{sk_id}")
+                        keys.append(sk_name)
+                call_states[state_name] = keys
+
+        return {
+            "name": name,
+            "description": description,
+            "base_template_pkid": base_pkid,
+            "available_softkeys": available_softkeys,
+            "call_states": call_states,
+        }

wxcli/migration/cucm/extractors/tier4.py

@@ -0,0 +1,173 @@
+"""Tier 4 feature gap extractor — recording profiles, remote destinations,
+transformation patterns, extension mobility device profiles.
+
+Wave 1: extract + flag only. No mappers or execution handlers.
+(from docs/prompts/tier4-feature-gap-extraction.md)
+"""
+
+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
+
+logger = logging.getLogger(__name__)
+
+RECORDING_PROFILE_TAGS = {"name": "", "recordingCssName": "", "recorderDestination": ""}
+REMOTE_DEST_PROFILE_TAGS = {"name": "", "description": "", "userId": ""}
+CALLING_PARTY_XFORM_TAGS = {
+    "pattern": "", "description": "", "callingSearchSpaceName": "",
+    "routePartitionName": "", "callingPartyTransformationMask": "",
+    "callingPartyPrefixDigits": "", "digitDiscardInstructionName": "",
+}
+CALLED_PARTY_XFORM_TAGS = {
+    "pattern": "", "description": "", "callingSearchSpaceName": "",
+    "routePartitionName": "", "calledPartyTransformationMask": "",
+    "calledPartyPrefixDigits": "", "digitDiscardInstructionName": "",
+}
+DEVICE_PROFILE_TAGS = {"name": "", "description": "", "product": "", "protocol": ""}
+_BLOCKED_PARTITION_SQL = """\
+SELECT n.dnorpattern, rp.name as partition_name, eu.userid
+FROM numplan n
+JOIN routepartition rp ON rp.pkid = n.fkroutepartition
+LEFT JOIN devicenumplanmap dnpm ON dnpm.fknumplan = n.pkid
+LEFT JOIN device d ON d.pkid = dnpm.fkdevice
+LEFT JOIN enduser eu ON eu.pkid = d.fkenduser
+WHERE LOWER(rp.name) LIKE '%intercept%'
+   OR LOWER(rp.name) LIKE '%block%'
+   OR LOWER(rp.name) LIKE '%out_of_service%'
+   OR LOWER(rp.name) LIKE '%oos%'
+"""
+
+_CFA_VOICEMAIL_SQL = """\
+SELECT n.dnorpattern, rp.name as partition_name,
+       cfwd.cfadestination, eu.userid
+FROM numplan n
+LEFT JOIN routepartition rp ON rp.pkid = n.fkroutepartition
+JOIN callforwarddynamic cfwd ON cfwd.fknumplan = n.pkid
+LEFT JOIN devicenumplanmap dnpm ON dnpm.fknumplan = n.pkid
+LEFT JOIN device d ON d.pkid = dnpm.fkdevice
+LEFT JOIN enduser eu ON eu.pkid = d.fkenduser
+WHERE cfwd.cfadestination IS NOT NULL
+  AND cfwd.cfadestination != ''
+  AND cfwd.cfavoicemailenabled = 't'
+  AND NOT EXISTS (
+      SELECT 1 FROM device d2
+      JOIN devicenumplanmap dnpm2 ON dnpm2.fkdevice = d2.pkid
+      WHERE dnpm2.fknumplan = n.pkid
+        AND d2.tkclass = 1
+        AND d2.tkstatus_registrationstate = 2
+  )
+"""
+
+
+class Tier4Extractor(BaseExtractor):
+    """Extract Tier 4 feature gap data from CUCM.
+
+    Extracts:
+    - Recording profiles (Item 1)
+    - Remote destination profiles / SNR (Item 2)
+    - Calling/Called party transformation patterns (Item 4)
+    - Extension Mobility device profiles (Item 6)
+    """
+
+    name = "tier4"
+
+    def __init__(self, connection: AXLConnection) -> None:
+        super().__init__(connection)
+        self.results: dict[str, list[dict[str, Any]]] = {}
+
+    def extract(self) -> ExtractionResult:
+        result = ExtractionResult(extractor=self.name)
+        total = 0
+        total += self._extract_type(
+            result, "recording_profiles",
+            "listRecordingProfile", {"name": "%"}, RECORDING_PROFILE_TAGS,
+        )
+        total += self._extract_type(
+            result, "remote_destination_profiles",
+            "listRemoteDestinationProfile", {"name": "%"}, REMOTE_DEST_PROFILE_TAGS,
+        )
+        total += self._extract_type(
+            result, "calling_party_transformations",
+            "listCallingPartyTransformationPattern", {"pattern": "%"},
+            CALLING_PARTY_XFORM_TAGS,
+        )
+        total += self._extract_type(
+            result, "called_party_transformations",
+            "listCalledPartyTransformationPattern", {"pattern": "%"},
+            CALLED_PARTY_XFORM_TAGS,
+        )
+        total += self._extract_type(
+            result, "device_profiles",
+            "listDeviceProfile", {"name": "%"}, DEVICE_PROFILE_TAGS,
+        )
+        total += self._extract_intercept_candidates(result)
+        result.total = total
+        return result
+
+    def _extract_type(
+        self,
+        result: ExtractionResult,
+        key: str,
+        method: str,
+        search_criteria: dict[str, str],
+        returned_tags: dict[str, str],
+    ) -> int:
+        try:
+            items = self.paginated_list(method, search_criteria, returned_tags)
+        except Exception as exc:
+            msg = f"{method} failed: {exc}"
+            logger.warning("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+            self.results[key] = []
+            return 0
+        self.results[key] = items
+        logger.info("[%s] %s: %d objects", self.name, key, len(items))
+        return len(items)
+
+    def _extract_intercept_candidates(self, result: ExtractionResult) -> int:
+        """Detect intercept-like configurations via SQL heuristics."""
+        seen: dict[str, dict[str, Any]] = {}
+        try:
+            rows = self.conn.execute_sql(_BLOCKED_PARTITION_SQL)
+            for row in rows:
+                dn = row.get("dnorpattern", "")
+                if not dn:
+                    continue
+                seen[dn] = {
+                    "userid": row.get("userid") or "",
+                    "dn": dn,
+                    "partition": row.get("partition_name") or "",
+                    "signal_type": "blocked_partition",
+                    "forward_destination": "",
+                    "voicemail_enabled": False,
+                }
+        except Exception as exc:
+            msg = f"Intercept blocked-partition SQL failed: {exc}"
+            logger.warning("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+        try:
+            rows = self.conn.execute_sql(_CFA_VOICEMAIL_SQL)
+            for row in rows:
+                dn = row.get("dnorpattern", "")
+                if not dn or dn in seen:
+                    continue
+                seen[dn] = {
+                    "userid": row.get("userid") or "",
+                    "dn": dn,
+                    "partition": row.get("partition_name") or "",
+                    "signal_type": "cfa_voicemail",
+                    "forward_destination": row.get("cfadestination") or "",
+                    "voicemail_enabled": True,
+                }
+        except Exception as exc:
+            msg = f"Intercept CFA-voicemail SQL failed: {exc}"
+            logger.warning("[%s] %s", self.name, msg)
+            result.errors.append(msg)
+        candidates = list(seen.values())
+        self.results["intercept_candidates"] = candidates
+        logger.info("[%s] intercept_candidates: %d objects", self.name, len(candidates))
+        return len(candidates)

wxcli/migration/cucm/extractors/users.py

@@ -0,0 +1,240 @@
+"""Users extractor — End Users.
+
+Extracts CUCM End Users with associated device references, directory info,
+and voicemail associations. Feeds user_mapper (03b §2), css_mapper
+(cross-ref #18), and voicemail_mapper (cross-ref #26).
+
+Sources:
+- 02b-cucm-extraction.md §2.2 (users extractor spec)
+- 03b-transform-mappers.md §2 (user_mapper field mapping)
+- 02-normalization-architecture.md cross-ref #3, #4, #18, #26
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from rich.console import Console
+
+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__)
+console = Console()
+
+# --- returnedTags constants (from 02b §2.2) ---
+
+USER_LIST_RETURNED_TAGS = {
+    'firstName': '',
+    'lastName': '',
+    'userid': '',
+    'mailid': '',
+}
+
+USER_GET_RETURNED_TAGS = {
+    'firstName': '',                     # Maps to Webex firstName
+    'lastName': '',                      # Maps to Webex lastName
+    'mailid': '',                        # Maps to Webex emails[] primary
+    'userid': '',                        # Fallback for emails[] if mailid empty
+    'telephoneNumber': '',               # User's primary phone number
+    'department': '',                    # Maps to Webex department
+    'title': '',                         # Maps to Webex title
+    'manager': '',                       # Maps to Webex manager/managerId
+    'directoryUri': '',                  # Informational — "Webex auto-assigns SIP address"
+    'userLocale': '',                    # Informational — "Not a People API field"
+    'selfService': '',                   # Voicemail pilot — "Mapped by voicemail_mapper"
+    'associatedDevices': '',             # Cross-ref #3: user_has_device
+    'enableCti': '',                     # CTI-enabled flag
+    'primaryExtension': '',              # Cross-ref #4: user_has_primary_dn
+    'callingSearchSpaceName': '',        # Cross-ref #18: user_has_css
+    'voiceMailProfile': '',              # Cross-ref #26: user_has_voicemail_profile
+}
+
+
+class UserExtractor(BaseExtractor):
+    """Extract CUCM End Users.
+
+    Two-step extraction:
+    1. listEndUser discovers all user PKIDs (summary fields only)
+    2. getEndUser per user retrieves the full field set including
+       associatedDevices, primaryExtension, CSS, and voicemail profile
+
+    Results stored in self.results['users'].
+
+    (from 02b §2.2)
+    """
+
+    name = "users"
+
+    def __init__(self, connection: AXLConnection) -> None:
+        super().__init__(connection)
+        self.results: dict[str, list[dict[str, Any]]] = {
+            'users': [],
+        }
+
+    def extract(self) -> ExtractionResult:
+        """Discover users via AXL listEndUser, then get full detail.
+
+        Falls back to executeSQLQuery if listEndUser is blocked (EPR error).
+        This happens on cloud-connected CUCMs and some LDAP-synced deployments.
+        """
+        try:
+            return self._extract_via_axl()
+        except Exception as exc:
+            exc_str = str(exc)
+            # EPR errors: cloud-connected CUCM or service not fully activated
+            # AttributeError: WSDL doesn't define EndUser operations (thin AXL)
+            # Fault: AXL service rejects the method
+            if any(s in exc_str for s in ("EPR", "Operation not found", "has no operation")):
+                logger.warning(
+                    "listEndUser AXL unavailable (%s) — falling back to SQL",
+                    exc,
+                )
+                return self._extract_via_sql()
+            raise
+
+    def _extract_via_axl(self) -> ExtractionResult:
+        """Standard AXL extraction: listEndUser → getEndUser."""
+        errors: list[str] = []
+        failed = 0
+
+        summary_list = self.paginated_list(
+            "listEndUser",
+            search_criteria={"firstName": "%"},
+            returned_tags=USER_LIST_RETURNED_TAGS,
+        )
+        total = len(summary_list)
+        logger.info("Found %d end users via listEndUser", total)
+
+        for i, user_summary in enumerate(summary_list, 1):
+            if i % 200 == 0:
+                console.print(f"    users: {i}/{total}...")
+            userid = user_summary.get("userid", "<unknown>")
+            try:
+                raw = self.get_detail("getEndUser", userid=userid)
+                if raw is None:
+                    failed += 1
+                    errors.append(f"getEndUser returned None for '{userid}'")
+                    continue
+                raw["associatedDevices"] = to_list(
+                    raw.get("associatedDevices"), "device"
+                )
+                self.results["users"].append(raw)
+            except Exception as exc:
+                failed += 1
+                errors.append(f"getEndUser failed for '{userid}': {exc}")
+
+        return ExtractionResult(
+            extractor=self.name, total=total, failed=failed, errors=errors,
+        )
+
+    def _extract_via_sql(self) -> ExtractionResult:
+        """SQL fallback when AXL EndUser operations are blocked.
+
+        Uses executeSQLQuery to read the enduser table directly. Joins to
+        enduserdevicemap + device for associatedDevices, and numplan for
+        primaryExtension. Produces dicts matching the AXL getEndUser shape
+        so downstream normalizers work identically.
+
+        Verified against live CUCM 15.0 (2026-03-23): executeSQLQuery works
+        even when listEndUser/getEndUser return EPR errors.
+        """
+        errors: list[str] = []
+
+        # Step 1: Get all active end users (exclude system/token users)
+        user_rows = self.conn.execute_sql(
+            "SELECT eu.pkid, eu.userid, eu.firstname, eu.lastname, "
+            "eu.mailid, eu.telephonenumber, eu.department, eu.title, "
+            "eu.manager, eu.directoryuri, eu.allowcticontrolflag "
+            "FROM enduser eu "
+            "WHERE eu.status = 1 AND eu.userid NOT LIKE 'Token_User_%'"
+        )
+        logger.info("Found %d end users via SQL", len(user_rows))
+
+        # Step 2: Get device associations (user → phone name)
+        # Try enduserdevicemap first (explicit associations), then fall back
+        # to device.fkenduser (ownerUserName). Both represent user→device links
+        # but enduserdevicemap is only populated when devices are added to a
+        # user's "Controlled Devices" list via GUI/updateEndUser.
+        device_rows = self.conn.execute_sql(
+            "SELECT eu.userid, d.name AS device_name "
+            "FROM enduser eu "
+            "JOIN device d ON d.fkenduser = eu.pkid "
+            "WHERE eu.status = 1 "
+            "UNION "
+            "SELECT eu.userid, d.name AS device_name "
+            "FROM enduser eu "
+            "JOIN enduserdevicemap edm ON eu.pkid = edm.fkenduser "
+            "JOIN device d ON edm.fkdevice = d.pkid "
+            "WHERE eu.status = 1"
+        )
+        user_devices: dict[str, list[str]] = {}
+        for row in device_rows:
+            uid = row.get("userid", "")
+            dname = row.get("device_name", "")
+            if uid and dname:
+                user_devices.setdefault(uid, []).append(dname)
+
+        # Step 3: Get primary extensions (line 1 of first physical phone)
+        # Uses device.fkenduser (ownerUserName) — same as step 2.
+        # Prefers physical phones (SEP*) over softphones (CSF*) for primary DN.
+        primary_dn_rows = self.conn.execute_sql(
+            "SELECT eu.userid, np.dnorpattern AS pattern, rp.name AS partition "
+            "FROM enduser eu "
+            "JOIN device d ON d.fkenduser = eu.pkid "
+            "JOIN devicenumplanmap dnmap ON d.pkid = dnmap.fkdevice "
+            "JOIN numplan np ON dnmap.fknumplan = np.pkid "
+            "LEFT JOIN routepartition rp ON np.fkroutepartition = rp.pkid "
+            "WHERE eu.status = 1 AND dnmap.numplanindex = 1 "
+            "AND d.name NOT LIKE 'CSF%'"
+        )
+        user_primary_dn: dict[str, dict[str, str | None]] = {}
+        for row in primary_dn_rows:
+            uid = row.get("userid", "")
+            if uid and uid not in user_primary_dn:
+                user_primary_dn[uid] = {
+                    "pattern": row.get("pattern"),
+                    "routePartitionName": row.get("partition"),
+                }
+
+        # Step 4: Build user dicts matching AXL getEndUser shape
+        for row in user_rows:
+            userid = row.get("userid", "")
+            user_dict: dict[str, Any] = {
+                "pkid": row.get("pkid"),
+                "firstName": row.get("firstname"),
+                "lastName": row.get("lastname"),
+                "mailid": row.get("mailid"),
+                "userid": userid,
+                "telephoneNumber": row.get("telephonenumber"),
+                "department": row.get("department"),
+                "title": row.get("title"),
+                "manager": row.get("manager"),
+                "directoryUri": row.get("directoryuri"),
+                "enableCti": row.get("allowcticontrolflag"),
+                "associatedDevices": user_devices.get(userid, []),
+                "primaryExtension": user_primary_dn.get(userid),
+                # These require AXL EndUser object — not available via SQL
+                "callingSearchSpaceName": None,
+                "voiceMailProfile": None,
+                "selfService": None,
+                "userLocale": None,
+                "_extracted_via": "sql",
+            }
+            self.results["users"].append(user_dict)
+
+        logger.info(
+            "End users via SQL: %d extracted, %d with devices, %d with primary DN",
+            len(user_rows),
+            sum(1 for u in self.results["users"] if u["associatedDevices"]),
+            sum(1 for u in self.results["users"] if u["primaryExtension"]),
+        )
+
+        return ExtractionResult(
+            extractor=self.name,
+            total=len(user_rows),
+            failed=0,
+            errors=errors,
+        )