Add examples: group lifecycle policies, call records, org settings, online meetings

Author: Vadim

examples/entraid/groups/lifecycle_policies.py

@@ -0,0 +1,96 @@
+"""
+Group lifecycle policies — set group expiration, manage renewal,
+and enable auto-renewal for Microsoft 365 groups.
+
+M365 group expiration is a core governance feature. Without it,
+groups accumulate and never get cleaned up. This example shows:
+  - List existing lifecycle policies
+  - Add groups to a policy
+  - Remove groups from a policy
+  - Renew a group (keep alive)
+
+Requires delegated permission ``Group.ReadWrite.All``.
+
+https://learn.microsoft.com/en-us/graph/api/resources/grouplifecyclepolicy
+"""
+
+import sys
+
+from office365.graph_client import GraphClient
+from tests import test_client_id, test_client_secret, test_tenant
+
+
+def main():
+    client = GraphClient(tenant=test_tenant).with_client_secret(test_client_id, test_client_secret)
+
+    # -- Step 1: list existing lifecycle policies --
+    policies = client.group_lifecycle_policies.get().execute_query()
+    print(f"Group lifecycle policies: {len(policies)}\n")
+
+    for p in policies:
+        lifetime = p.group_lifetime_in_days or "?"
+        notification = p.alternate_notification_emails or "(none)"
+        managed = p.managed_group_types or []
+        print(f"  Lifetime: {lifetime:>3} days  "
+              f"notification: {notification:45s}  "
+              f"managed types: {managed}")
+
+    # -- Step 2: find groups not covered by any policy --
+    groups = (
+        client.groups.get()
+        .filter("resourceProvisioningOptions/Any(x:x eq 'Team') or mailEnabled eq true")
+        .select(["id", "displayName", "mail"])
+        .top(999)
+        .execute_query()
+    )
+
+    covered = set()
+    for p in policies:
+        gid = p.properties.get("groupId", "")
+        if gid:
+            covered.add(gid)
+        elif hasattr(p, "properties") and p.properties.get("groupIds"):
+            for gid in p.properties["groupIds"]:
+                covered.add(gid)
+
+    uncovered = [g for g in groups if g.id not in covered]
+    print(f"\nM365 groups: {len(groups)}")
+    print(f"Uncovered by lifecycle policy: {len(uncovered)}")
+
+    if uncovered:
+        print("\nFirst 5 groups without expiration:")
+        for g in uncovered[:5]:
+            print(f"  {g.display_name:40s}  {g.mail or '?'}")
+
+    # -- Step 3: create a lifecycle policy (commented) --
+    # policy = client.group_lifecycle_policies.add(
+    #     groupLifetimeInDays=180,
+    #     managedGroupTypes="All",
+    #     alternateNotificationEmails="admin@contoso.com",
+    # ).execute_query()
+    # print(f"\n✓ Lifecycle policy created")
+
+    # -- Step 4: add a group to the policy --
+    if policies and uncovered:
+        policy = policies[0]
+        group_id = uncovered[0].id
+        policy.add_group(group_id=group_id).execute_query()
+        print(f"\n✓ Added {uncovered[0].display_name} to lifecycle policy.")
+
+    # -- Step 5: renew a group (keep alive another period) --
+    if policies:
+        # Pick any group ID that was already managed
+        sample = next((p.properties.get("groupId", "") for p in policies if p.properties.get("groupId")), None)
+        if sample:
+            policies[0].renew_group(group_id=sample).execute_query()
+            print(f"✓ Renewed group {sample[:20]}.")
+
+    # -- Cleanup: remove a group from policy --
+    # policy.remove_group(group_id=group_id).execute_query()
+    # print("✓ Removed group from policy.")
+
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()

examples/entraid/tenant/organization.py

@@ -0,0 +1,82 @@
+"""
+Organization settings — read and update tenant-wide configuration.
+
+Covers the most practical tenant settings:
+  - Read organization profile (name, technical contacts, privacy)
+  - List organization branding (sign-in page, logo, background)
+  - Read partner tenant relationships (permissions, delegations)
+
+Requires delegated permission ``Organization.Read.All``
+(``Organization.ReadWrite.All`` for updates).
+
+https://learn.microsoft.com/en-us/graph/api/resources/organization
+"""
+
+import sys
+
+from office365.graph_client import GraphClient
+from tests import test_client_id, test_client_secret, test_tenant
+
+
+def main():
+    client = GraphClient(tenant=test_tenant).with_client_secret(test_client_id, test_client_secret)
+
+    # -- Step 1: read organization profile --
+    orgs = client.organization.get().execute_query()
+    if not orgs:
+        print("(no organization data)")
+        return
+
+    org = orgs[0]
+    print("Organization details:\n")
+    print(f"  Display name:              {org.display_name or '?'}")
+    print(f"  Tenant ID:                 {org.id or '?'}")
+    print(f"  City:                      {org.city or '?'}")
+    print(f"  Country/region:            {org.country or '?'}")
+    print(f"  Postal code:               {org.postal_code or '?'}")
+    print(f"  State:                     {org.state or '?'}")
+    print(f"  Street:                    {org.street or '?'}")
+    print(f"  Tenant type:               {org.tenant_type or '?'}")
+
+    if org.verified_domains:
+        print(f"\n  Verified domains ({len(org.verified_domains)}):")
+        for d in org.verified_domains:
+            is_default = d.properties.get("isDefault", False)
+            is_initial = d.properties.get("isInitial", False)
+            print(f"    {d.properties.get('name', '?'):35s}  "
+                  f"{'default ' if is_default else ''}"
+                  f"{'initial' if is_initial else ''}")
+
+    # -- Step 2: notification contacts --
+    print(f"\n  Technical notification mails:       {org.technical_notification_mails or '(none)'}")
+    print(f"  Security/compliance notification:   {org.security_compliance_notification_mails or '(none)'}")
+    print(f"  Marketing notification:             {org.marketing_notification_emails or '(none)'}")
+    print(f"  Privacy contact:                    {org.privacy_notification_emails or '(none)'}")
+    print(f"  Privacy profile URL:                {org.privacy_profile_url or '(none)'}")
+
+    # -- Step 3: list organization branding --
+    try:
+        branding = org.branding.get().execute_query()
+        print(f"\n  Branding:")
+        print(f"    Locale:                       {branding.locale or '?'}")
+        print(f"    Background color:             {branding.background_color or '?'}")
+        print(f"    Sign-in page text:            {(branding.sign_in_page_text or '')[:60]}")
+        print(f"    Username hint:                {branding.username_hint or '?'}")
+        print(f"    Hide keep me signed in:       {branding.hide_keep_me_signed_in}")
+        print(f"    Custom logo:                  {'Yes' if branding.logo_id else 'No'}")
+    except Exception as e:
+        print(f"\n  Branding: {e}")
+
+    # -- Step 4: partner tenant relationships --
+    try:
+        partners = org.partner_tenant_relationships.get().execute_query()
+        print(f"\n  Partner tenant relationships: {len(partners)}")
+        for pt in partners:
+            print(f"    {pt.properties.get('partnerTenantId', '?'):40s}  "
+                  f"status={pt.properties.get('status', '?')}")
+    except Exception:
+        print(f"\n  (partner relationships not available)")
+
+
+if __name__ == "__main__":
+    main()

examples/teams/call_records.py

@@ -0,0 +1,89 @@
+"""
+Call records — Teams call quality analytics across the tenant.
+
+Rich data model: call → sessions → segments → endpoints.
+Useful for:
+  - Identifying poor-quality calls (jitter, packet loss, latency)
+  - Auditing direct routing call failures
+  - Reporting on call modalities (audio, video, screen share)
+
+Requires application permission ``CallRecords.Read.All``.
+
+https://learn.microsoft.com/en-us/graph/api/resources/callrecords-api-overview
+"""
+
+import sys
+
+from office365.graph_client import GraphClient
+from tests import test_client_id, test_client_secret, test_tenant
+
+
+def main():
+    client = GraphClient(tenant=test_tenant).with_client_secret(test_client_id, test_client_secret)
+
+    # -- Step 1: list recent call records --
+    records = client.communications.call_records.top(20).get().execute_query()
+    print(f"Call records: {len(records)}\n")
+
+    if not records:
+        print("(No call records — may need CallRecords.Read.All permission or recent calls)")
+        return
+
+    for r in records:
+        r_id = r.id or "?"
+        call_type = r.properties.get("type", "?")
+        modality = r.properties.get("modalities", [])
+        start = r.start_date_time
+        if hasattr(start, "strftime"):
+            start = start.strftime("%Y-%m-%d %H:%M")
+        end = r.end_date_time
+        if hasattr(end, "strftime"):
+            end = end.strftime("%Y-%m-%d %H:%M")
+
+        user_count = r.properties.get("participants_count", "?")
+        organizer = r.properties.get("organizer", {})
+        org_upn = "?"
+        if isinstance(organizer, dict):
+            u = organizer.get("user", {})
+            org_upn = u.get("userPrincipalName", "?") if isinstance(u, dict) else "?"
+
+        failure = r.properties.get("failureInfo", {})
+        failure_phase = failure.get("stage", "") if isinstance(failure, dict) else ""
+
+        print(f"  {r_id[:20]:20s}  type={call_type:15s}  modality={str(modality[:3]):10s}  "
+              f"users={user_count}  organizer={org_upn[:25]:25s}")
+        print(f"    start={start}  end={end}  failure={failure_phase or 'none'}")
+
+    # -- Step 2: drill into sessions for the most recent call --
+    if records:
+        print()
+        recent = records[0]
+        print(f"Drilling into call {recent.id[:20]}...")
+
+        sessions = recent.sessions.get().execute_query()
+        print(f"  Sessions: {len(sessions)}")
+
+        for s in sessions:
+            s_id = s.id[:15] if s.id else "?"
+            callee = s.properties.get("callee", {}).get("user", {}).get("userPrincipalName", "?")
+            caller = s.properties.get("caller", {}).get("user", {}).get("userPrincipalName", "?")
+            modality = s.properties.get("modalities", [])
+            print(f"    session {s_id}  caller={str(caller)[:25]:25s}  "
+                  f"callee={str(callee)[:25]:25s}  modality={str(modality[:3]):10s}")
+
+            # Segments within this session
+            segments = s.segments.get().execute_query()
+            for seg in segments:
+                seg_id = seg.properties.get("id", "?")[:10]
+                print(f"      segment {seg_id}")
+
+                # Endpoint quality data
+                endpoints = seg.properties.get("endpoints", [])
+                for ep in endpoints:
+                    name = ep.get("name", "?")
+                    ep_type = ep.get("@odata.type", "?")
+                    print(f"        endpoint={name}  type={str(ep_type).split('.')[-1][:20]}")
+
+
+if __name__ == "__main__":
+    main()

examples/teams/online_meetings.py

@@ -0,0 +1,82 @@
+"""
+Online meetings — create Teams meetings with join links for
+scheduling automation.
+
+Creates a Teams meeting accessible via a generated join URL.
+Supports meeting settings (lobby, chat, recording), custom
+start/end time, and participant configuration.
+
+Useful for:
+  - Automated scheduling bots
+  - Meeting room booking systems
+  - CRM integrations that create Teams meetings
+
+Requires delegated permission ``OnlineMeetings.ReadWrite.All``.
+
+https://learn.microsoft.com/en-us/graph/api/resources/onlinemeeting
+"""
+
+import sys
+from datetime import datetime, timedelta, timezone
+
+from office365.graph_client import GraphClient
+from tests import test_client_id, test_client_secret, test_tenant
+
+
+def main():
+    client = GraphClient(tenant=test_tenant).with_client_secret(test_client_id, test_client_secret)
+
+    # -- Step 1: create a Teams meeting --
+    start = datetime.now(timezone.utc) + timedelta(days=1, hours=9)
+    end = start + timedelta(hours=1)
+
+    meeting = client.me.online_meetings.create(
+        startDateTime=start.isoformat(),
+        endDateTime=end.isoformat(),
+        subject="Project sync — SDK demo",
+        description="Weekly sync with demo team.",
+    ).execute_query()
+
+    print(f"Meeting created:\n")
+    print(f"  Subject:     {meeting.subject}")
+    print(f"  Join link:   {meeting.join_web_url}")
+    print(f"  Start:       {meeting.start_date_time.strftime('%Y-%m-%d %H:%M') if meeting.start_date_time else '?'}")
+    print(f"  End:         {meeting.end_date_time.strftime('%Y-%m-%d %H:%M') if meeting.end_date_time else '?'}")
+
+    # -- Step 2: create with lobby and chat settings --
+    meeting2 = client.me.online_meetings.create(
+        startDateTime=(start + timedelta(days=1)).isoformat(),
+        endDateTime=(end + timedelta(days=1)).isoformat(),
+        subject="All-hands with lobby control",
+        description="Lobby bypass disabled for external participants.",
+        lobbyBypassSettings={
+            "scope": "organization",
+            "isDialInBypassEnabled": False,
+        },
+        allowMeetingChat="enabled",
+        allowTranscription=True,
+    ).execute_query()
+
+    print(f"\nMeeting with lobby control:\n")
+    print(f"  Subject:     {meeting2.subject}")
+    print(f"  Join link:   {meeting2.join_web_url}")
+    print(f"  Chat:        {meeting2.allow_meeting_chat}")
+    print(f"  Transcript:  {meeting2.allow_transcription}")
+
+    # -- Step 3: get meeting details by join web URL --
+    fetched = client.me.online_meetings.get_by_join_web_url(
+        meeting2.join_web_url
+    ).execute_query()
+    print(f"\nFetched by join URL: {fetched.subject}")
+
+    # -- Step 4: list recent meetings (last 30 days) --
+    since = (datetime.now(timezone.utc) - timedelta(days=30)).isoformat()
+    recent = client.me.online_meetings.filter(f"startDateTime ge {since}").top(10).get().execute_query()
+    print(f"\nRecent meetings: {len(recent)}")
+    for m in recent:
+        start_str = m.start_date_time.strftime("%m-%d") if m.start_date_time else "?"
+        print(f"  {start_str}  {m.subject[:45]:45s}  {m.join_web_url}")
+
+
+if __name__ == "__main__":
+    main()