Office365-REST-Python-Client 3.1.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

office365/migration/sharepoint/scanners/checked_out_files.py

@@ -0,0 +1,57 @@
+"""Checked-out files scan — the SMAT ``CheckedOutFiles`` report.
+
+Only checked-in content is migrated: a file a user has checked out is read as its
+last checked-in version, so uncommitted edits are lost. This ``ITEMS``-container
+report lists the files that are checked out and by whom, and raises a per-list
+warning (data-loss risk).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.smat import SiteScanRecord, site_url
+
+
+@dataclass
+class CheckedOutFilesRecord(SiteScanRecord):
+    """One row of the SMAT ``CheckedOutFiles-detail`` report."""
+
+    File: str | None = None
+    CheckedOutUser: str | None = None
+    ScanID: str | None = None
+
+
+class CheckedOutFilesScanner(BaseScanner[CheckedOutFilesRecord]):
+    """Reports checked-out files (SMAT ``CheckedOutFiles``) and warns per list."""
+
+    category = "file"
+    scan_name = "CheckedOutFiles"
+    record_type = CheckedOutFilesRecord
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        page: list[CheckedOutFilesRecord] = []
+        for item in target.entity:
+            file = getattr(item, "file", None)
+            if file is None or not file.check_out_type:
+                continue  # 0/None = not checked out
+            user = file.checked_out_by_user
+            page.append(
+                CheckedOutFilesRecord(
+                    SiteURL=site_url(target.location),
+                    File=item.properties.get("FileRef", ""),
+                    CheckedOutUser=(user.login_name or user.title) if user is not None else None,
+                    ScanID=report.scan_id or None,
+                )
+            )
+        if page:
+            self.records.extend(page)
+            self.flag(
+                report,
+                "warning",
+                target.location or "list",
+                f"{len(page)} checked-out file(s) — only the last checked-in version migrates",
+                "Ask users to check in their files before migrating",
+            )

office365/migration/sharepoint/scanners/file_versions.py

@@ -0,0 +1,56 @@
+"""File versions scan — the SMAT ``FileVersions`` report (files with version history).
+
+Version history grows a migration's runtime roughly linearly, so before migrating
+it is worth knowing which files carry versions. This ``ITEMS``-container report
+scan lists each file that has more than its current version, using the file's
+``MajorVersion``/``MinorVersion`` (loaded with the item's ``File`` expand).
+
+``VersionCount`` is ``major + minor`` — the current version level, a close
+approximation of version-history depth for major-only versioning. Site-level SMAT
+columns that only exist on-premises (``ContentDB*``, usage-logging) are ``None``
+and exported as ``n/a``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.smat import SiteScanRecord, site_url
+
+
+@dataclass
+class FileVersionsRecord(SiteScanRecord):
+    """One row of the SMAT ``FileVersions-detail`` report."""
+
+    VersionCount: int | None = None
+    File: str | None = None
+    ScanID: str | None = None
+
+
+class FileVersionsScanner(BaseScanner[FileVersionsRecord]):
+    """Reports files that have version history (SMAT ``FileVersions``)."""
+
+    category = "file"
+    scan_name = "FileVersions"
+    record_type = FileVersionsRecord
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        location = site_url(target.location)
+        for item in target.entity:
+            file = getattr(item, "file", None)
+            if file is None:
+                continue
+            major = file.major_version or 0
+            minor = file.minor_version or 0
+            if major <= 1 and minor == 0:
+                continue  # only the current version — no history
+            self.records.append(
+                FileVersionsRecord(
+                    SiteURL=location,
+                    VersionCount=major + minor,
+                    File=item.properties.get("FileRef", ""),
+                    ScanID=report.scan_id or None,
+                )
+            )

office365/migration/sharepoint/scanners/files.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from office365.migration.assessment.report import AssessmentReport
 from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.runtime.limits import hint
 
 
 class FileScanner(BaseScanner):
@@ -12,14 +13,16 @@ class FileScanner(BaseScanner):
     category = "file"
 
     def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        limit = self.options.limit("large_file_bytes")
         for item in target.entity:
             path = item.properties.get("FileRef", "")
             size = (item.file.length if getattr(item, "file", None) is not None else None) or 0
-            if size > self.options.large_file_bytes:
+            if size > limit.value:
                 self.flag(
                     report,
                     "warning",
                     path,
-                    f"File size {size / 1024 / 1024 / 1024:.1f}GB exceeds the size limit",
+                    hint(limit, value=size, context="file"),
                     "Use chunked upload or split the file",
+                    limit=limit,
                 )

office365/migration/sharepoint/scanners/large_excel_files.py

@@ -0,0 +1,56 @@
+"""Large Excel files scan — the SMAT ``LargeExcelFiles`` report.
+
+Excel workbooks larger than 10 MB can't open in the browser on the target — users
+are prompted to open them in the Excel client. This ``ITEMS``-container report
+lists the affected ``.xlsx``/``.xls``/``.xlsm``/``.xlsb`` files (SMAT reports the
+``.xlsx`` set; the common Excel extensions are included here).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.smat import SiteScanRecord, file_extension, site_url
+
+#: Excel workbook extensions included in the report.
+EXCEL_EXTENSIONS = frozenset({".xlsx", ".xls", ".xlsm", ".xlsb"})
+
+_MB = 1024 * 1024
+
+
+@dataclass
+class LargeExcelFilesRecord(SiteScanRecord):
+    """One row of the SMAT ``LargeExcelFiles-detail`` report."""
+
+    File: str | None = None
+    FileSizeinMB: float | None = None
+    ScanID: str | None = None
+
+
+class LargeExcelFilesScanner(BaseScanner[LargeExcelFilesRecord]):
+    """Reports Excel workbooks over the browser-open limit (SMAT ``LargeExcelFiles``)."""
+
+    category = "file"
+    scan_name = "LargeExcelFiles"
+    record_type = LargeExcelFilesRecord
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        limit = self.options.limit("large_excel_bytes")
+        location = site_url(target.location)
+        for item in target.entity:
+            if file_extension(item) not in EXCEL_EXTENSIONS:
+                continue
+            file = getattr(item, "file", None)
+            size = (file.length if file is not None else None) or 0
+            if size <= limit.value:
+                continue
+            self.records.append(
+                LargeExcelFilesRecord(
+                    SiteURL=location,
+                    File=item.properties.get("FileRef", ""),
+                    FileSizeinMB=round(size / _MB, 2),
+                    ScanID=report.scan_id or None,
+                )
+            )

office365/migration/sharepoint/scanners/large_lists.py

@@ -0,0 +1,58 @@
+"""Large list scan — the SPMT ``LIST_VIEW_EXCEED_LIMIT`` /
+``ITEM_COUNT_EXCEED_INDEX_LIMIT`` / ``ITEM_COUNT_EXCEED_LIMIT`` readiness checks.
+
+A ``LIST``-container scan over a list's item count, graded by the SharePoint
+limits (``office365.sharepoint.thresholds.Limits``):
+
+- over the list view threshold (5,000)   → info   (classic views throttle; migration is fine)
+- over the index-add threshold (20,000)  → warning (a column index can't be added)
+- over the per-list maximum (30M)        → blocker (migration fails)
+"""
+
+from __future__ import annotations
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.runtime.limits import hint
+
+#: (threshold field, severity, SPMT risk code, remediation) — checked in order.
+_CHECKS = (
+    ("max_list_items", "blocker", "ITEM_COUNT_EXCEED_LIMIT", "Split or archive the list before migrating"),
+    (
+        "index_threshold",
+        "warning",
+        "ITEM_COUNT_EXCEED_INDEX_LIMIT",
+        "Migrate without adding indexes, or split the list",
+    ),
+    (
+        "list_view_threshold",
+        "info",
+        "LIST_VIEW_EXCEED_LIMIT",
+        "Index the filtered/sorted columns or use the modern experience",
+    ),
+)
+
+
+class LargeListScanner(BaseScanner):
+    """Flags lists whose item count crosses the list view / index / max thresholds."""
+
+    category = "list"
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        lst = target.entity
+        count = lst.item_count or 0
+        location = target.location or (lst.title or "list")
+
+        for field, severity, risk_code, suggestion in _CHECKS:
+            limit = self.options.limit(field)
+            if count > limit.value:
+                self.flag(
+                    report,
+                    severity,
+                    location,
+                    hint(limit, value=count, context="list"),
+                    suggestion,
+                    risk_code=risk_code,
+                    limit=limit,
+                )
+                break

office365/migration/sharepoint/scanners/large_sites.py

@@ -90,7 +90,8 @@ class LargeSitesScanner(BaseScanner[LargeSitesRecord]):
         size_gb = (summary.storage_bytes or 0) / (1024**3) if summary.storage_bytes else None
         size_mb = round((summary.storage_bytes or 0) / (1024**2), 1) if summary.storage_bytes else None
         locked = summary.lock_state in {"NoAccess", "Locked"}
-        over = size_gb is not None and size_gb > self.options.large_site_threshold_gb
+        threshold = self.options.large_site_threshold_gb
+        over = size_gb is not None and threshold is not None and size_gb > threshold
 
         if summary.report_impacted_only and (locked or not over):
             return
@@ -109,12 +110,12 @@ class LargeSitesScanner(BaseScanner[LargeSitesRecord]):
         row.TotalItemCount = summary.item_count
         self.records.append(row)
 
-        if over and not summary.report_impacted_only:
+        if over and not summary.report_impacted_only and threshold is not None and size_gb is not None:
             self.flag(
                 report,
                 "warning",
                 summary.site_url or "site",
-                f"Site size {size_gb:.1f}GB exceeds the {self.options.large_site_threshold_gb:g}GB guidance — "
+                f"Site size {size_gb:.1f}GB exceeds the {threshold:g}GB guidance — "
                 "migration takes longer to schedule and run",
                 "Split the site collection, archive old content, or store large binaries externally",
             )

office365/migration/sharepoint/scanners/long_onedrive_urls.py

@@ -0,0 +1,52 @@
+"""Long OneDrive URLs scan — the SMAT ``LongOneDriveUrls`` report.
+
+OneDrive and SharePoint sync fail on file paths whose decoded URL exceeds the
+sync limit, so before a migration it is worth listing them. This ``ITEMS``
+container report measures each file's full URL (the tenant origin plus its
+server-relative path) against ``Limits.LONG_ONEDRIVE_URL``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.smat import SiteScanRecord, site_url
+
+
+@dataclass
+class LongOneDriveUrlsRecord(SiteScanRecord):
+    """One row of the SMAT ``LongOneDriveUrls-detail`` report."""
+
+    File: str | None = None
+    UrlLength: int | None = None
+    ScanID: str | None = None
+
+
+class LongOneDriveUrlsScanner(BaseScanner[LongOneDriveUrlsRecord]):
+    """Reports files whose full URL is over the OneDrive sync limit (SMAT ``LongOneDriveUrls``)."""
+
+    category = "file"
+    scan_name = "LongOneDriveUrls"
+    record_type = LongOneDriveUrlsRecord
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        limit = self.options.limit("long_onedrive_url")
+        location = site_url(target.location)
+        parts = urlsplit(target.location or "")
+        origin = f"{parts.scheme}://{parts.netloc}" if parts.scheme and parts.netloc else ""
+        for item in target.entity:
+            path = item.properties.get("FileRef", "")
+            url = f"{origin}{path}"
+            if len(url) <= limit.value:
+                continue
+            self.records.append(
+                LongOneDriveUrlsRecord(
+                    SiteURL=location,
+                    File=path,
+                    UrlLength=len(url),
+                    ScanID=report.scan_id or None,
+                )
+            )

office365/migration/sharepoint/scanners/lookup.py

@@ -0,0 +1,38 @@
+"""Lookup column scan — the SPMT ``LIST_VIEW_LOOKUP_EXCEED_LIMIT`` check.
+
+A ``FIELDS``-container scan: displaying/querying too many lookup, person/group,
+or managed-metadata columns trips the list view lookup threshold (8 joins
+blocked, 12 returned), so the list view (and some tooling) can fail.
+"""
+
+from __future__ import annotations
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.runtime.limits import hint
+
+_LOOKUP_TYPES = frozenset({"Lookup", "LookupMulti", "User", "UserMulti", "TaxonomyFieldType", "TaxonomyFieldTypeMulti"})
+
+
+class LookupColumnScanner(BaseScanner):
+    """Flags lists whose lookup/people/managed-metadata columns exceed the lookup threshold."""
+
+    category = "field"
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        lookups = [
+            field.properties.get("InternalName", "")
+            for field in target.entity
+            if field.properties.get("TypeAsString") in _LOOKUP_TYPES
+        ]
+        limit = self.options.limit("lookup_joins")
+        if len(lookups) > limit.value:
+            self.flag(
+                report,
+                "warning",
+                target.location,
+                hint(limit, value=len(lookups), context="list"),
+                "Reduce the lookup columns or raise the resource-throttling limit",
+                risk_code="LIST_VIEW_LOOKUP_EXCEED_LIMIT",
+                limit=limit,
+            )

office365/migration/sharepoint/scanners/paths.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from office365.migration.assessment.report import AssessmentReport
 from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.runtime.limits import hint
 
 
 class PathScanner(BaseScanner):
@@ -12,26 +13,30 @@ class PathScanner(BaseScanner):
     category = "path"
 
     def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        path_limit = self.options.limit("max_path_length")
+        name_limit = self.options.limit("max_name_length")
         for item in target.entity:
             path = item.properties.get("FileRef", "")
             name = item.properties.get("FileLeafRef", "")
 
-            if len(path) > self.options.max_path_length:
+            if len(path) > path_limit.value:
                 self.flag(
                     report,
                     "blocker",
                     path,
-                    f"Path length {len(path)} exceeds SharePoint limit of {self.options.max_path_length}",
+                    hint(path_limit, value=len(path), context="path"),
                     "Shorten folder names or restructure hierarchy",
+                    limit=path_limit,
                 )
 
-            if len(name) > self.options.max_name_length:
+            if len(name) > name_limit.value:
                 self.flag(
                     report,
                     "blocker",
                     path,
-                    f"File name length {len(name)} exceeds limit of {self.options.max_name_length}",
+                    hint(name_limit, value=len(name), context="file name"),
                     "Rename file before migration",
+                    limit=name_limit,
                 )
 
             bad = [c for c in name if c in self.options.invalid_chars]

office365/migration/sharepoint/scanners/permissions.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 from office365.migration.assessment.report import AssessmentReport
 from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.runtime.limits import hint
 
 
 class PermissionScanner(BaseScanner):
@@ -14,11 +15,28 @@ class PermissionScanner(BaseScanner):
 
     def run(self, target: ScanTarget, report: AssessmentReport) -> None:
         unique = sum(1 for i in target.entity if i.properties.get("HasUniqueRoleAssignments", False))
-        if unique > 0:
+        supported = self.options.limit("unique_scopes")
+        recommended = self.options.limit("recommended_unique_scopes")
+        if unique > supported.value:
+            self.flag(
+                report,
+                "blocker",
+                target.location,
+                hint(supported, value=unique, context="list"),
+                "Reduce the number of uniquely-permitted items before migrating",
+                risk_code="UNIQUE_PERMISSION_EXCEED_LIMIT",
+                limit=supported,
+            )
+        elif unique > 0:
+            over_recommended = unique > recommended.value
             self.flag(
                 report,
                 "warning",
                 target.location,
-                f"{unique} items have unique permissions",
+                hint(recommended, value=unique, context="list")
+                if over_recommended
+                else f"{unique} items have unique permissions",
                 "Set preserve_permissions=True in MigrationOptions (slower migration)",
+                risk_code="UNIQUE_PERMISSION_EXCEED_LIMIT",
+                limit=recommended if over_recommended else None,
             )

office365/migration/sharepoint/scanners/smat.py

@@ -0,0 +1,51 @@
+"""Shared SMAT detail-report scaffolding.
+
+Every SMAT ``<Scan>-detail.csv`` starts with the same site-collection context
+columns (``SiteId … DaysOfUsageData``). :class:`SiteScanRecord` declares that
+prefix once; each report scan subclasses it and appends its own columns (the
+dataclass fields ARE the report columns, base-first).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Any
+
+__all__ = ["SiteScanRecord", "file_extension", "site_url"]
+
+
+@dataclass
+class SiteScanRecord:
+    """The SMAT detail-report site-collection column prefix.
+
+    ``None`` renders as ``n/a`` (the report convention for unavailable data);
+    the ``ContentDB*`` and usage-logging columns only exist on-premises.
+    """
+
+    SiteId: str | None = None
+    SiteURL: str | None = None
+    SiteOwner: str | None = None
+    SiteAdmins: str | None = None
+    SiteSizeInMB: float | None = None
+    NumOfWebs: int | None = None
+    ContentDBName: str | None = None
+    ContentDBServerName: str | None = None
+    ContentDBSizeInMB: str | None = None
+    LastContentModifiedDate: datetime | None = None
+    TotalItemCount: int | None = None
+    Hits: int | None = None
+    DistinctUsers: str | None = None
+    DaysOfUsageData: str | None = None
+
+
+def file_extension(item: Any) -> str:
+    """The item's lower-cased extension including the dot (``""`` when none)."""
+    name = item.properties.get("FileLeafRef") or ""
+    _, dot, extension = name.rpartition(".")
+    return f".{extension.lower()}" if dot and extension else ""
+
+
+def site_url(location: str | None) -> str | None:
+    """Best-effort site/web URL from a scan location (``<web>/lists/<title>``)."""
+    return location.rsplit("/lists/", 1)[0] if location and "/lists/" in location else None

office365/migration/sharepoint/scanners/summary.py

@@ -34,4 +34,5 @@ class SiteScanSummary:
     item_count: int = 0
     last_modified: Any | None = None
     lock_state: str | None = None
+    web_template: str | None = None
     report_impacted_only: bool = False

office365/migration/sharepoint/scanners/thicket_folders.py

@@ -0,0 +1,38 @@
+"""Thicket folders scan — the SPMT ``THICKET_FOLDER_UNSUPPORTED`` risk.
+
+Folders whose name ends in ``_file`` or ``_files`` are treated as *thicket*
+folders — the hidden linked folder SharePoint creates to store the supporting
+content of an HTM file. SharePoint in Microsoft 365 can't create them, so a
+migration carrying such a folder fails. This ``ITEMS``-container scan flags each
+one so it can be renamed first.
+"""
+
+from __future__ import annotations
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+
+#: Folder-name suffixes SharePoint treats as thicket folders.
+_THICKET_SUFFIXES = ("_file", "_files")
+
+
+class ThicketFolderScanner(BaseScanner):
+    """Flags folders whose name ends in ``_file``/``_files``."""
+
+    category = "file"
+
+    def run(self, target: ScanTarget, report: AssessmentReport) -> None:
+        for item in target.entity:
+            if getattr(item, "file", None) is not None:
+                continue  # a file, not a folder
+            name = item.properties.get("FileLeafRef", "")
+            if not name.lower().endswith(_THICKET_SUFFIXES):
+                continue
+            self.flag(
+                report,
+                "blocker",
+                item.properties.get("FileRef", "") or name,
+                f"Thicket folder '{name}' isn't supported in SharePoint in Microsoft 365",
+                "Rename the folder so it no longer ends in '_file'/'_files'",
+                risk_code="THICKET_FOLDER_UNSUPPORTED",
+            )

office365/migration/sharepoint/scanners/unsupported_site_templates.py

@@ -0,0 +1,90 @@
+"""Unsupported site templates scan — the SMAT ``UnsupportedSiteTemplates`` report.
+
+A site collection created from an on-premises-only site definition (a Central
+Administration site, a My Site host, a meeting workspace, an Access services
+database, ...) has no Microsoft 365 equivalent, so it can't be migrated as-is.
+This ``SITE``-container report lists the collections whose root web template is
+in that legacy set.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from office365.migration.assessment.report import AssessmentReport
+from office365.migration.assessment.scanners.base import BaseScanner, ScanTarget
+from office365.migration.sharepoint.scanners.summary import SiteScanSummary
+from office365.sharepoint.webs.templates import WebTemplateType
+
+#: Templates with no Microsoft 365 equivalent — a collection built from one can't
+#: be migrated as-is. Held as template names (the part before ``#``) so the match
+#: is independent of the site-definition configuration id.
+_UNSUPPORTED_TEMPLATES = frozenset(
+    template.name_part.upper()
+    for template in (
+        WebTemplateType.CENTRAL_ADMIN,
+        WebTemplateType.TENANT_ADMIN,
+        WebTemplateType.SHAREPOINT_ONLINE_TENANT_ADMIN,
+        WebTemplateType.SHARED_SERVICES_ADMINISTRATION,
+        WebTemplateType.SHAREPOINT_PORTAL_SERVER_SITE,
+        WebTemplateType.SHAREPOINT_PORTAL_PERSONAL_SPACE,
+        WebTemplateType.PERSONALIZATION_SITE,
+        WebTemplateType.MY_SITE_HOST,
+        WebTemplateType.CONTENTS_AREA,
+        WebTemplateType.TOPIC_AREA,
+        WebTemplateType.NEWS_SITE,
+        WebTemplateType.NEWS_HOME,
+        WebTemplateType.SITE_DIRECTORY,
+        WebTemplateType.COMMUNITY_AREA,
+        WebTemplateType.COLLABORATION_PORTAL,
+        WebTemplateType.REPORT_CENTER,
+        WebTemplateType.PROFILES,
+        WebTemplateType.ACCESS_SERVICES,
+        WebTemplateType.ASSETS_WEB_DATABASE,
+        WebTemplateType.CHARITABLE_CONTRIBUTIONS_WEB_DATABASE,
+        WebTemplateType.CONTACTS_WEB_DATABASE,
+        WebTemplateType.ISSUES_WEB_DATABASE,
+        WebTemplateType.PROJECTS_WEB_DATABASE,
+        WebTemplateType.DOCUMENT_CENTER,
+        WebTemplateType.EXPRESS_TEAM_SITE,
+        WebTemplateType.EXPRESS_HOSTED_SITE,
+        WebTemplateType.MEETING_BASIC,
+        WebTemplateType.MEETING_BLANK,
+        WebTemplateType.MEETING_DECISION,
+        WebTemplateType.MEETING_SOCIAL,
+        WebTemplateType.MEETING_MULTIPAGE,
+        WebTemplateType.POWERPOINT_BROADCAST,
+        WebTemplateType.BUSINESS_INTELLIGENCE_CENTER,
+        WebTemplateType.VISIO_PROCESS_REPOSITORY,
+    )
+)
+
+
+@dataclass
+class UnsupportedSiteTemplatesRecord:
+    """One row of the SMAT ``UnsupportedSiteTemplates-detail`` report."""
+
+    URL: str | None = None
+    Template: str | None = None
+    ScanID: str | None = None
+
+
+class UnsupportedSiteTemplatesScanner(BaseScanner[UnsupportedSiteTemplatesRecord]):
+    """SITE-container scan: reports legacy site templates with no Microsoft 365 equivalent."""
+
+    category = "site"
+    scan_name = "UnsupportedSiteTemplates"
+    record_type = UnsupportedSiteTemplatesRecord
+
+    def run(self, target: ScanTarget[SiteScanSummary], report: AssessmentReport) -> None:
+        summary = target.entity
+        template = summary.web_template
+        if not template or template.split("#", 1)[0].upper() not in _UNSUPPORTED_TEMPLATES:
+            return
+        self.records.append(
+            UnsupportedSiteTemplatesRecord(
+                URL=summary.site_url,
+                Template=template,
+                ScanID=report.scan_id or None,
+            )
+        )