Lernprogramm: Erstellen eines Statusaktualisierungsworkflows

In diesem End-to-End-Lernprogramm erstellen Sie einen translytischen Aufgabenfluss, der Projektstatus nachverfolgt und Aktualisierungen von einem Power BI-Bericht an Microsoft Teams sendet. In diesem Lernprogramm wird veranschaulicht, wie Datenrückschreiben mit externen API-Aufrufen kombiniert werden, um einen vollständigen Kommunikationsworkflow zu erstellen.

In diesem Tutorial erfahren Sie, wie:

Wenn Sie über keine Fabric-Kapazität verfügen, starten Sie eine Fabric-Testversion.

Voraussetzungen

• Der Power BI Desktop. Wenn Power BI Desktop nicht auf Ihrem Gerät installiert ist, befolgen Sie die Anweisungen unter "Power BI Desktop abrufen".
• Ein Microsoft Teams-Kanal, in dem Sie über die Berechtigung zum Hinzufügen eingehender Webhooks verfügen.

Übersicht

In diesem Lernprogramm wird eine Projektverfolgungslösung erstellt, in der Benutzer den Projektstatus direkt aus einem Power BI-Bericht aktualisieren können. Wenn ein Benutzer einen Status aktualisiert, führt das System Folgendes aus:

1. Schreibt den neuen Status in die SQL-Datenbank.
2. Sendet eine Benachrichtigung über adaptive Karten an Microsoft Teams.
3. Aktualisiert den Bericht, um die aktualisierten Daten anzuzeigen.

Benutzerfluss

Der Workflow erstellt eine fortlaufende Feedbackschleife zwischen Berichtsbenutzern:

1. Anfordern einer Aktualisierung über Teams aus dem Bericht – Ein Benutzer wählt ein Projekt im Bericht aus und sendet eine Statusaktualisierungsanforderung. Die Anfrage wird an Teams gesendet, mit einem Link zum Bericht.

2. Erhalten Sie Benachrichtigungen in Teams, und öffnen Sie den Bericht – Der Projektbesitzer sieht die Benachrichtigung in Teams und wählt den Link aus, um den Bericht zu öffnen.

3. Updatestatus im Bericht – Der Projektbesitzer wählt das Projekt aus, wählt einen neuen Status aus, fügt Notizen hinzu und wählt die Schaltfläche "Aktualisieren" aus.

4. Echtzeitaktualisierung anzeigen und Benachrichtigungen senden — Der Bericht wird sofort aktualisiert, um den neuen Status anzuzeigen, und eine Benachrichtigung wird auf Teams veröffentlicht, die die Änderung bestätigt.

Architektur

Die Lösung verbindet diese Komponenten in Microsoft Fabric:

Die Daten fließen in zwei Richtungen:

• Lesepfad: Power BI liest aus der SQL-Datenbank (über DirectQuery) oder Lakehouse (über Direct Lake), um den aktuellen Projektstatus anzuzeigen.
• Schreibpfad: Wenn ein Benutzer eine Datenfunktionsschaltfläche auswählt, ruft Power BI die Benutzerdatenfunktion auf, die in die SQL-Datenbank schreibt und Beiträge in Teams sendet.

Erstellen einer SQL-Datenbank

In diesem Szenario werden Projektverfolgungsdaten verwendet. Führen Sie die Schritte unter Erstellen einer SQL-Datenbank in Fabric aus, um eine neue SQL-Datenbank in Ihrem Fabric-Arbeitsbereich zu erstellen.

Erstellen der Datenbanktabellen

1. Öffnen Sie in Ihrer SQL-Datenbank ein neues Abfragefenster.

2. Führen Sie das folgende SQL-Skript aus, um die Project-Tabelle zu erstellen:

   CREATE TABLE [Project] (
       [Project id] INT NOT NULL,
       [Project name] NVARCHAR(200) NOT NULL,
       [Product name] NVARCHAR(200),
       [Description] NVARCHAR(4000),
       [Priority] NVARCHAR(20),
       [Start date] DATE,
       [Target end date] DATE,
       [Budget] DECIMAL(18,2),
       [Project manager] NVARCHAR(100),
       [Department] NVARCHAR(100),
       [Created date] DATETIME2,
       [Created by] NVARCHAR(100),
       [Is active] BIT,
       CONSTRAINT PK_Project PRIMARY KEY NONCLUSTERED ([Project id])
   );
   

3. Erstellen Sie die Tabelle "Statusaktualisierungen", um Statusänderungen im Laufe der Zeit nachzuverfolgen:

   CREATE TABLE [Status updates] (
       [Update id] INT NOT NULL,
       [Project id] INT NOT NULL,
       [Status] NVARCHAR(50) NOT NULL,
       [Updated date] DATETIME2 NOT NULL,
       [Updated by] NVARCHAR(100) NOT NULL,
       [Notes] NVARCHAR(4000),
       CONSTRAINT PK_StatusUpdates PRIMARY KEY NONCLUSTERED ([Update id])
   );
   

4. Erstellen Sie eine Ansicht, die den aktuellen Status für jedes Projekt zurückgibt:

   CREATE VIEW [Project status] AS
   SELECT 
       p.[Project id],
       p.[Project name],
       COALESCE(ls.[Latest status], 'Not Started') AS [Latest status],
       ls.[Latest notes]
   FROM [Project] p
   LEFT JOIN (
       SELECT 
           [Project id],
           [Status] AS [Latest status],
           [Notes] AS [Latest notes],
           ROW_NUMBER() OVER (PARTITION BY [Project id] ORDER BY [Update id] DESC) AS RowNum
       FROM [Status updates]
   ) ls ON p.[Project id] = ls.[Project id] AND ls.RowNum = 1;
   

5. Beispielprojektdaten einfügen:

   INSERT INTO [Project] ([Project id], [Project name], [Product name], [Description], [Priority], [Start date], [Target end date], [Budget], [Project manager], [Department], [Created date], [Created by], [Is active])
   VALUES
   (1, 'Best Practices with Power BI - FabCon Atlanta', 'FabCon Atlanta', 'Session covering Power BI best practices for enterprise deployments', 'High', '2026-01-15', '2026-03-20', 5000.00, 'person1@somecompany.com', 'Developer Relations', '2026-01-15', 'Admin', 1),
   (2, 'Translytical Task Flows - Build', 'Microsoft Build', 'Deep dive into translytical workloads and real-time analytics patterns', 'Critical', '2026-02-01', '2026-05-19', 7500.00, 'person2@somecompany.com', 'Product Engineering', '2026-02-01', 'Admin', 1),
   (3, 'Advanced DAX Patterns - FabCon Barcelona', 'FabCon Barcelona', 'Workshop on complex DAX calculations and optimization techniques', 'High', '2026-03-01', '2026-09-15', 6000.00, 'person1@somecompany.com', 'Developer Relations', '2026-02-20', 'Admin', 1),
   (4, 'Semantic Modeling Deep Dive - Ignite', 'Microsoft Ignite', 'Comprehensive session on semantic model design and best practices', 'High', '2026-01-10', '2026-11-18', 8000.00, 'person2@somecompany.com', 'Product Engineering', '2026-01-10', 'Admin', 1),
   (5, 'Custom Visuals in Power BI - FabCon Atlanta', 'FabCon Atlanta', 'Hands-on lab for building custom visuals with the Power BI SDK', 'Medium', '2025-12-01', '2026-03-20', 4500.00, 'person1@somecompany.com', 'Developer Relations', '2025-12-01', 'Admin', 1),
   (6, 'TMDL for Version Control - Build', 'Microsoft Build', 'Session on using TMDL for semantic model source control and CI/CD', 'Critical', '2025-11-15', '2026-02-15', 5500.00, 'person2@somecompany.com', 'Product Engineering', '2025-11-15', 'Admin', 1),
   (7, 'Real-time Analytics with Power BI - Ignite', 'Microsoft Ignite', 'Showcase of Direct Lake and real-time streaming capabilities', 'High', '2026-02-10', '2026-11-18', 7000.00, 'person1@somecompany.com', 'Developer Relations', '2026-02-10', 'Admin', 1),
   (8, 'Semantic Modeling Workshop - FabCon Barcelona', 'FabCon Barcelona', 'Interactive workshop on building enterprise-grade semantic models', 'High', '2026-04-01', '2026-09-15', 6500.00, 'person2@somecompany.com', 'Product Engineering', '2026-02-25', 'Admin', 1);
   

6. Beispielstatusaktualisierungen einfügen:

   INSERT INTO [Status updates] ([Update id], [Project id], [Status], [Updated date], [Updated by], [Notes])
   VALUES
   (1, 1, 'Not Started', '2026-01-15', 'person1@somecompany.com', 'Session abstract submitted and approved'),
   (2, 1, 'In Progress', '2026-01-25', 'person1@somecompany.com', 'Outline completed, starting slide deck'),
   (3, 1, 'In Progress', '2026-02-10', 'person1@somecompany.com', 'Demo environment setup in progress'),
   (4, 1, 'In Progress', '2026-02-25', 'person1@somecompany.com', 'First draft of presentation complete, scheduling dry run'),
   (5, 2, 'Not Started', '2026-02-01', 'person2@somecompany.com', 'Session proposal accepted for Build'),
   (6, 2, 'In Progress', '2026-02-08', 'person2@somecompany.com', 'Research phase - gathering customer scenarios'),
   (7, 2, 'In Progress', '2026-02-15', 'person2@somecompany.com', 'Architecture diagrams drafted'),
   (8, 2, 'In Progress', '2026-02-24', 'person2@somecompany.com', 'Building demo lakehouse environment'),
   (9, 3, 'Not Started', '2026-02-20', 'person1@somecompany.com', 'Call for speakers submission pending review'),
   (10, 4, 'Not Started', '2026-01-10', 'person2@somecompany.com', 'Initial brainstorming session with PM team'),
   (11, 4, 'In Progress', '2026-01-20', 'person2@somecompany.com', 'Content outline approved by leadership'),
   (12, 4, 'In Progress', '2026-02-05', 'person2@somecompany.com', 'Sample semantic models being developed'),
   (13, 5, 'Not Started', '2025-12-01', 'person1@somecompany.com', 'Lab environment requirements documented'),
   (14, 5, 'In Progress', '2025-12-15', 'person1@somecompany.com', 'SDK samples being prepared'),
   (15, 5, 'On Hold', '2026-01-10', 'person1@somecompany.com', 'Paused - waiting on SDK v5 release for new features'),
   (16, 6, 'Not Started', '2025-11-15', 'person2@somecompany.com', 'Session planning initiated'),
   (17, 6, 'In Progress', '2025-12-01', 'person2@somecompany.com', 'GitHub Actions workflow samples created'),
   (18, 6, 'In Progress', '2026-01-15', 'person2@somecompany.com', 'Dry run completed with internal team'),
   (19, 6, 'Completed', '2026-02-15', 'person2@somecompany.com', 'Session delivered at internal summit, ready for Build'),
   (20, 7, 'Not Started', '2026-02-10', 'person1@somecompany.com', 'Topic approved for Ignite breakout session'),
   (21, 7, 'In Progress', '2026-02-18', 'person1@somecompany.com', 'Eventstream demo scenarios identified'),
   (22, 7, 'In Progress', '2026-02-26', 'person1@somecompany.com', 'Direct Lake performance benchmarks in progress'),
   (23, 8, 'Not Started', '2026-02-25', 'person2@somecompany.com', 'Workshop format and duration confirmed');
   

Einrichten einer Variablenbibliothek

In einer Variablenbibliothek werden Konfigurationswerte getrennt vom Funktionscode gespeichert. Diese Trennung bietet einen wichtigen Vorteil: Sie können Werte wie Webhook-URLs oder Berichtslinks aktualisieren, ohne Ihre Benutzerdatenfunktionen zu bearbeiten oder erneut zu veröffentlichen.

Wenn sich Ihr Teams-Kanal beispielsweise ändert oder Sie auf einen anderen Bericht verweisen müssen, aktualisieren Sie den Wert der Variablenbibliothek, und die Änderung wird sofort wirksam – es sind keine Codeänderungen erforderlich.

1. Wählen Sie im Fabric-Arbeitsbereich +Neues Element aus.

2. Scrollen Sie nach unten zum Abschnitt " Daten entwickeln ", und wählen Sie "Variable"-Bibliothek aus.

3. Benennen Sie die Variablebibliothek, ProjectVariables und wählen Sie "Erstellen" aus.

4. Wählen Sie +Neue Variable aus, und fügen Sie die folgenden Variablen hinzu:

   Variablenname	Typ	Beschreibung
   TEAMS_WEBHOOK_URL	String	Ihre eingehende Teams-Webhook-URL
   POWERBI_REPORT_URL	String	URL zu Ihrem Power BI-Bericht (nach der Veröffentlichung hinzugefügt)

5. Wählen Sie "Speichern" aus, nachdem Sie jede Variable hinzugefügt haben.

Abrufen einer Teams-Webhook-URL

Führen Sie die Schritte unter Erstellen eines eingehenden Webhooks aus, um einen Webhook für Ihren Teams-Kanal zu erstellen. Kopieren Sie nach dem Erstellen des Webhooks die URL und fügen Sie diese als TEAMS_WEBHOOK_URL in Ihre Variablenbibliothek ein.

Erstellen der Benutzerdatenfunktionen

Erstellen Sie ein Benutzerdatenfunktionen-Element, das Statusaktualisierungen und Teams-Benachrichtigungen verarbeitet.

1. Wählen Sie im Fabric-Arbeitsbereich +Neue Element>benutzerdatenfunktionen aus.

2. Ersetzen Sie den Standardcode durch den folgenden Python-Code:

   import fabric.functions as fn
   import logging
   from datetime import datetime
   
   udf = fn.UserDataFunctions()
   
   
   @udf.connection(argName="sqlDb", alias="ProjectTrackingDb")
   @udf.connection(argName="varLib", alias="ProjectVariables")
   @udf.function()
   def update_project_status(
       sqlDb: fn.FabricSqlConnection,
       varLib: fn.FabricVariablesClient,
       projectId: int,
       newStatus: str,
       updatedBy: str,
       notes: str,
       updatedDate: str
   ) -> str:
       """
       Updates the status of a project by inserting a new record 
       into the Status updates table and sends a Teams notification.
       """
       logging.info(f"Updating status for Project ID: {projectId}")
   
       # Parse and validate the date
       try:
           parsed_date = datetime.fromisoformat(updatedDate)
       except ValueError:
           raise fn.UserThrownError(
               f"Invalid date format. Use ISO format: '2026-02-27T14:30:00'",
               {"providedDate": updatedDate}
           )
   
       # Validate status value
       valid_statuses = ['Not Started', 'In Progress', 'On Hold', 'Completed', 'Cancelled']
       if newStatus not in valid_statuses:
           raise fn.UserThrownError(
               f"Invalid status. Must be one of: {', '.join(valid_statuses)}",
               {"providedStatus": newStatus}
           )
   
       connection = sqlDb.connect()
       cursor = connection.cursor()
   
       try:
           # Get the previous status
           cursor.execute("""
               SELECT TOP 1 [Status] 
               FROM [Status updates] 
               WHERE [Project id] = ? 
               ORDER BY [Update id] DESC
           """, (projectId,))
           prev_row = cursor.fetchone()
           previous_status = prev_row[0] if prev_row else "Not Started"
   
           # Get the next Update ID
           cursor.execute("SELECT ISNULL(MAX([Update id]), 0) + 1 FROM [Status updates]")
           next_update_id = cursor.fetchone()[0]
   
           # Verify the project exists
           cursor.execute("SELECT [Project name] FROM [Project] WHERE [Project id] = ?", (projectId,))
           project_row = cursor.fetchone()
   
           if not project_row:
               raise fn.UserThrownError(f"Project with ID {projectId} not found.")
   
           project_name = project_row[0]
   
           # Insert the new status update
           cursor.execute("""
               INSERT INTO [Status updates] 
               ([Update id], [Project id], [Status], [Updated date], [Updated by], [Notes])
               VALUES (?, ?, ?, ?, ?, ?)
           """, (next_update_id, projectId, newStatus, parsed_date, updatedBy, notes))
   
           connection.commit()
   
           # Send Teams notification
           _send_teams_update(varLib, project_name, previous_status, newStatus, updatedBy, notes)
   
           return f"Status updated for '{project_name}': {previous_status} → {newStatus}"
   
       except Exception as e:
           connection.rollback()
           raise
       finally:
           cursor.close()
           connection.close()
   
   
   def _send_teams_update(varLib, project_name, previous_status, new_status, updated_by, notes):
       """Helper function to send Teams notification."""
       import requests
       import json
   
       variables = varLib.getVariables()
       webhook_url = variables.get("TEAMS_WEBHOOK_URL")
       report_url = variables.get("POWERBI_REPORT_URL")
   
       if not webhook_url:
           return
   
       adaptive_card = {
           "type": "message",
           "attachments": [{
               "contentType": "application/vnd.microsoft.card.adaptive",
               "content": {
                   "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
                   "type": "AdaptiveCard",
                   "version": "1.4",
                   "body": [
                       {
                           "type": "TextBlock",
                           "size": "Large",
                           "weight": "Bolder",
                           "text": "📋 Project Status Update"
                       },
                       {
                           "type": "FactSet",
                           "facts": [
                               {"title": "Project:", "value": project_name},
                               {"title": "Status:", "value": f"{previous_status} → {new_status}"},
                               {"title": "Updated By:", "value": updated_by}
                           ]
                       },
                       {
                           "type": "TextBlock",
                           "text": f"**Notes:** {notes}" if notes else "",
                           "wrap": True
                       }
                   ],
                   "actions": [
                       {"type": "Action.OpenUrl", "title": "View Project", "url": report_url}
                   ] if report_url else []
               }
           }]
       }
   
       requests.post(webhook_url, headers={"Content-Type": "application/json"}, 
                     data=json.dumps(adaptive_card), timeout=30)
   
   
   @udf.connection(argName="sqlDb", alias="ProjectTrackingDb")
   @udf.connection(argName="varLib", alias="ProjectVariables")
   @udf.function()
   def request_status_update(
       sqlDb: fn.FabricSqlConnection,
       varLib: fn.FabricVariablesClient,
       projectId: int,
       requestedBy: str,
       message: str
   ) -> str:
       """
       Sends a Teams notification requesting a status update for a project.
       """
       logging.info(f"Requesting status update for Project ID: {projectId}")
   
       connection = sqlDb.connect()
       cursor = connection.cursor()
   
       try:
           # Get project details
           cursor.execute("""
               SELECT [Project name], [Project manager] 
               FROM [Project] 
               WHERE [Project id] = ?
           """, (projectId,))
           project_row = cursor.fetchone()
   
           if not project_row:
               raise fn.UserThrownError(f"Project with ID {projectId} not found.")
   
           project_name = project_row[0]
           project_manager = project_row[1]
   
           # Get current status
           cursor.execute("""
               SELECT TOP 1 [Status], [Updated date]
               FROM [Status updates] 
               WHERE [Project id] = ? 
               ORDER BY [Update id] DESC
           """, (projectId,))
           status_row = cursor.fetchone()
           current_status = status_row[0] if status_row else "Not Started"
           last_updated = status_row[1].strftime("%Y-%m-%d") if status_row else "Never"
   
           # Send Teams notification
           _send_status_request(varLib, project_name, project_manager, 
                               current_status, last_updated, requestedBy, message)
   
           return f"Status update requested for '{project_name}' from {project_manager}"
   
       finally:
           cursor.close()
           connection.close()
   
   
   def _send_status_request(varLib, project_name, project_manager, current_status, 
                           last_updated, requested_by, message):
       """Helper function to send status update request via Teams."""
       import requests
       import json
   
       variables = varLib.getVariables()
       webhook_url = variables.get("TEAMS_WEBHOOK_URL")
       report_url = variables.get("POWERBI_REPORT_URL")
   
       if not webhook_url:
           return
   
       adaptive_card = {
           "type": "message",
           "attachments": [{
               "contentType": "application/vnd.microsoft.card.adaptive",
               "content": {
                   "$schema": "http://adaptivecards.io/schemas/adaptive-card.json",
                   "type": "AdaptiveCard",
                   "version": "1.4",
                   "body": [
                       {
                           "type": "TextBlock",
                           "size": "Large",
                           "weight": "Bolder",
                           "text": "📢 Status Update Requested"
                       },
                       {
                           "type": "FactSet",
                           "facts": [
                               {"title": "Project:", "value": project_name},
                               {"title": "Owner:", "value": project_manager},
                               {"title": "Current Status:", "value": current_status},
                               {"title": "Last Updated:", "value": last_updated},
                               {"title": "Requested By:", "value": requested_by}
                           ]
                       },
                       {
                           "type": "TextBlock",
                           "text": f"**Message:** {message}" if message else "",
                           "wrap": True
                       }
                   ],
                   "actions": [
                       {"type": "Action.OpenUrl", "title": "Update Status", "url": report_url}
                   ] if report_url else []
               }
           }]
       }
   
       requests.post(webhook_url, headers={"Content-Type": "application/json"}, 
                     data=json.dumps(adaptive_card), timeout=30)
   

3. Konfigurieren Sie die Verbindungen:

   • Wählen Sie "Einstellungen" oder den Bereich "Verbindungen" aus.
   • Fügen Sie der Fabric-SQL-Datenbank eine Verbindung ProjectTrackingDb hinzu.
   • Fügen Sie die Verbindung ProjectVariables zu Ihrer Variablenbibliothek hinzu.

4. Wählen Sie "Veröffentlichen" aus, um die Funktion bereitzustellen.

Verstehen der Funktion update_project_status

Die update_project_status Funktion schreibt einen neuen Statusdatensatz in die SQL-Datenbank und sendet eine Teams-Benachrichtigung. Wenn ein Benutzer die Schaltfläche "Aktualisieren" im Bericht auswählt, tritt der folgende Ablauf auf:

1. Power BI ruft die Funktion auf – Die Datenfunktion übergibt Parameter (Projekt-ID, neuer Status, Notizen usw.) an die Benutzerdatenfunktion.

2. Überprüfen von Eingaben – Die Funktion überprüft das Datumsformat und überprüft, ob der Statuswert eine der zulässigen Optionen ist.

3. Aktuellen Status abfragen – Die Funktion ruft den vorherigen Status und den Projektnamen aus der Datenbank ab.

4. Neuen Datensatz einfügen – Eine neue Zeile wird in die Status updates Tabelle mit dem neuen Status, dem Zeitstempel und den Notizen eingefügt.

5. Teams-Benachrichtigung senden – Die Hilfsfunktion _send_teams_update stellt eine adaptive Karte in Ihrem Teams-Kanal mit der Statusänderung bereit.

6. Rückgabeergebnis – Die Funktion gibt eine Erfolgsmeldung zurück, die Power BI dem Benutzer anzeigt.

Verstehen der Funktion request_status_update

Die request_status_update Funktion sendet eine Teams-Benachrichtigung, in der ein Projektbesitzer aufgefordert wird, eine Statusaktualisierung bereitzustellen. Diese Funktion schreibt nicht in die Datenbank – sie sendet nur eine Nachricht.

1. Power BI ruft die Funktion auf – Die Datenfunktionsschaltfläche übergibt die Projekt-ID, den Anforderernamen und die Nachricht an die Funktion.

2. Abfrageprojektdetails – Die Funktion ruft den Projektnamen, den Projektmanager und den aktuellen Status aus der Datenbank ab.

3. Teams-Benachrichtigung senden – Die Hilfsfunktion _send_status_request stellt eine adaptive Karte in Ihrem Teams-Kanal mit den Anforderungsdetails und einer Schaltfläche " Projektstatus aktualisieren " bereit, die mit dem Bericht verknüpft ist.

4. Rückgabeergebnis – Die Funktion gibt eine Bestätigungsmeldung zurück, die Power BI dem Benutzer anzeigt.

(Optional) Einrichten von Lakehouse-Verknüpfungen für Direct Lake-Ansichten

In der Fabric SQL-Datenbank werden alle Daten als Delta-Tabellen in OneLake gespeichert, sodass Sie ein Direct Lake-Semantikmodell direkt in den SQL-Datenbanktabellen erstellen können. Direct Lake kann jedoch keine Ansichten aus einer SQL-Datenbank lesen – nur Tabellen. Um eine Ansicht mit Direct Lake zu verwenden, erstellen Sie Verknüpfungen zu den SQL-Datenbanktabellen in einem Lakehouse, und definieren Sie die Ansicht dort.

Erstellen Sie Verknüpfungen zu SQL-Datenbanktabellen

1. Erstellen Sie in Ihrem Fabric-Arbeitsbereich ein neues Lakehouse und aktivieren Sie Schemas.

2. Klicken Sie im Lakehouse-Explorer mit der rechten Maustaste auf ein beliebiges Schema (z. B. dbo), und wählen Sie "Neue Tabellenverknüpfung" aus.

3. Navigieren Sie im OneLake-Katalog zu Ihrer SQL-Datenbank, und wählen Sie die Project Tabelle aus.

4. Wiederholen Sie diesen Vorgang, um einen Shortcut für die Status updates-Tabelle zu erstellen.

Die Tastenkombinationen bieten Lesezugriff auf die zugrunde liegenden Delta-Tabellen, ohne Daten zu duplizieren.

Erstellen einer materialisierten Seeansicht

Erstellen Sie einen materialisierten Seeblick im Lakehouse, der den neuesten Status für jedes Projekt berechnet:

1. Wählen Sie im Lakehouse die Option "Materialisierte Seeansicht verwalten" (Vorschau) aus.

2. Öffnen Sie ein neues Notizbuch mit Spark SQL.

3. Führen Sie die folgende Abfrage aus:

   CREATE MATERIALIZED LAKE VIEW IF NOT EXISTS dbo.project_status AS
   SELECT 
       p.`Project id` AS ProjectId,
       p.`Project name` AS ProjectName,
       COALESCE(ls.LatestStatus, 'Not Started') AS LatestStatus,
       ls.LatestNotes
   FROM dbo.Project p
   LEFT JOIN (
       SELECT 
           `Project id` AS ProjectId,
           `Status` AS LatestStatus,
           `Notes` AS LatestNotes,
           ROW_NUMBER() OVER (PARTITION BY `Project id` ORDER BY `Update id` DESC) AS RowNum
       FROM dbo.`Status updates`
   ) ls ON p.`Project id` = ls.ProjectId AND ls.RowNum = 1;
   

4. Planen Sie die Aktualisierung der Ansicht, indem Sie "Zeitpläne>ein" auswählen und die Häufigkeit festlegen.

Erstellen des Power BI-Berichts

Sie können eine Verbindung mit Ihren Daten herstellen, indem Sie entweder DirectQuery oder Direct Lake verwenden:

• DirectQuery für SQL-Datenbank: Echtzeitdaten ermöglichen Rückschreibvorgänge durch benutzerdefinierte Datenfunktionen.
• Direct Lake zu SQL-Datenbanktabellen: Fabric SQL-Datenbank speichert Daten als Delta-Tabellen in OneLake, sodass Direct Lake Tabellen direkt lesen kann.
• Direct Lake via Lakehouse (für Ansichten):Direct Lake kann keine Ansichten aus der SQL-Datenbank lesen. Um Ansichten mit Direct Lake zu verwenden, erstellen Sie Verknüpfungen zu den SQL-Datenbanktabellen in einem Lakehouse, und definieren Sie dort materialisierte Seeansichten.

Option A: Verbinden über DirectQuery

1. Öffnen Sie Power BI Desktop.

2. Wählen Sie den OneLake-Katalog aus.

3. Suchen Sie Ihre Fabric SQL-Datenbank.

4. Wählen Sie "Mit SQL-Analyseendpunkt verbinden" aus.

5. Wählen Sie die Tabellen/Ansicht Project, Status updates und Project status aus.

6. Wenn Sie zur Eingabe des Speichermodus aufgefordert werden, wählen Sie DirectQuery aus.

Option B: Verbinden über Direct Lake (zur Analyseleistung)

1. Wählen Sie im Power BI-Dienst "OneLake-Katalog erstellen>"aus.

2. Finden Sie Ihr Lakehouse.

3. Wählen Sie die Verknüpfungstabellen (Project, Status updates) und die materialisierte Seeansicht (project_status).

4. Bearbeiten Sie das semantische Modell in der Webmodellierungsoberfläche, um Measures und Beziehungen hinzuzufügen.

Eine berechnete Tabelle für die Statusoptionen erstellen

Erstellen Sie eine berechnete Tabelle, die die Statuswerte für den Button-Slicer bereitstellt. Führen Sie dieses TMDL-Skript in Power BI Desktop aus:

createOrReplace

	table 'Status Options'

		column Status
			summarizeBy: none
			isNameInferred
			sourceColumn: [Status]
			sortByColumn: 'Sort Order'

		column Description
			summarizeBy: none
			isNameInferred
			sourceColumn: [Description]

		column 'Sort Order'
			isHidden
			formatString: 0
			summarizeBy: sum
			isNameInferred
			sourceColumn: [Sort Order]

		column 'Status Color'
			summarizeBy: none
			isNameInferred
			sourceColumn: [Status Color]

		partition 'Status Options' = calculated
			mode: import
			source =
				DATATABLE(
				    "Status", STRING,
				    "Description", STRING,
				    "Sort Order", INTEGER,
				    "Status Color", STRING,
				    {
				        { "Not Started", "Project has been created but work has not begun", 1, "#808080" },
				        { "In Progress", "Active work is being performed on the project", 2, "#0078D4" },
				        { "On Hold", "Project is paused pending resources, decisions, or dependencies", 3, "#FFB900" },
				        { "Completed", "All project deliverables have been finished", 4, "#107C10" },
				        { "Cancelled", "Project has been terminated and will not be completed", 5, "#D13438" }
				    }
				)

Erstellen von unterstützenden Maßnahmen

Erstellen Sie eine berechnete Tabelle, um die Kennzahlen aufzunehmen, die die Schaltflächen der Datenfunktionen unterstützen. Führen Sie dieses TMDL-Skript in Power BI Desktop aus:

createOrReplace

	table 'Translytical task flow'

		/// Generates a preview of the Teams notification that will be sent when the user updates the status. Shows a warning if required selections are missing.
		measure 'Preview of status update' = ```
				VAR _ProjectId = SELECTEDVALUE(Project[Project id], 0)
				VAR _ProjectName = SELECTEDVALUE(Project[Project name], "")
				VAR _PreviousStatus = [Latest Status]
				VAR _NewStatus = SELECTEDVALUE('Status Options'[Status], "N/A")
				VAR _UpdatedBy = [Updated by]
				VAR _UpdatedDate = FORMAT(NOW(), "YYYY-MM-DD HH:mm")
				VAR _NL = UNICHAR(10)
				RETURN 
				IF(_ProjectId = 0 || _NewStatus = "N/A",
				    "⚠️ Select a project and new status to preview",
				    "📋 Teams Notification Preview" & _NL &
				    "━━━━━━━━━━━━━━━━━━━━" & _NL &
				    "Project: " & _ProjectName & _NL &
				    "Status: " & _PreviousStatus & " → " & _NewStatus & _NL &
				    "Updated By: " & _UpdatedBy & _NL &
				    "Date: " & _UpdatedDate & _NL &
				    "Notes: See above" & _NL &
				    "━━━━━━━━━━━━━━━━━━━━" & _NL &
				    "📨 This will be sent to Teams"
				)
				```

		/// Returns the email address of the current user. Used to track who made each status update.
		measure 'Updated by' = USERPRINCIPALNAME()

		/// Returns the most recent notes for the selected project. Only evaluates when a project is in scope.
		measure 'Latest notes' =
				IF(ISINSCOPE(Project[Project name]),
				LASTNONBLANKVALUE('Status updates'[Update id], MAX('Status updates'[Notes])),
				BLANK())

		/// Returns the most recent status for the selected project by finding the last non-blank status value.
		measure 'Latest status' =
				IF(HASONEVALUE(Project[Project id]),
				LASTNONBLANKVALUE('Status updates'[Update id], MAX('Status updates'[Status])),
				BLANK())

		/// Returns the Project ID when a single project is selected. Used as a parameter for the update_project_status and request_status_update functions.
		measure 'Selected project id' = SELECTEDVALUE(Project[Project id])
			formatString: 0

		/// Returns today's date in ISO format. Used as the timestamp for status updates.
		measure 'Updated date' = FORMAT(TODAY(), "yyyy-mm-dd")

		/// Provides dynamic text for the update button showing the selected project and new status.
		measure 'Update status button text' = "Update the status of " & SELECTEDVALUE(Project[Project name]) & " to " & SELECTEDVALUE('Status Options'[Status])

		column Value
			isHidden
			formatString: 0
			summarizeBy: sum
			isNameInferred
			sourceColumn: [Value]

		partition 'Translytical task flow' = calculated
			mode: import
			source = {1}

Diese Maßnahmen dienen mehreren Zwecken:

Entwerfen des Berichts

Das Berichtslayout führt Benutzer durch einen klaren Workflow: Wählen Sie ein Projekt aus, wählen Sie einen neuen Status aus, fügen Sie Notizen hinzu, und führen Sie dann die Aktualisierung aus.

Erstellen der Projekttabelle

1. Fügen Sie eine Visuelle Tabelle hinzu, um Projektinformationen anzuzeigen.

2. Fügen Sie diese Spalten aus Ihren Daten hinzu:

   • Product name
   • Project name
   • Target end date
   • Description
   • Latest status (aus der Tabelle "Status" oder "Projektstatus" /"Ansicht")
   • Latest notes

3. Legen Sie den Titel auf 1) Wählen Sie ein projekt aus, das aktualisiert werden soll.

4. Sortieren Sie nach Ziel-Enddatum aufsteigend, um anstehende Stichtage zuerst anzuzeigen.

Erstellen des Schaltflächenschnitts für die Statusauswahl

1. Fügen Sie ein Button-Slicer-Visual hinzu.

2. Fügen Sie im Feld Status Options[Status]" hinzu.

3. Fügen Sie im Feld FIRST(Status Options[Description])" hinzu, um die Beschreibung unter jedem Status anzuzeigen.

4. Im Bereich "Format ":

   • Stil auf Karten einstellen.
   • Ausrichtung aufhorizontal festlegen.
   • Legen Sie max. Kacheln auf 5 fest (eine für jeden Status).

5. Konfigurieren Sie die bedingte Formatierung so, dass jede Karte nach dem Feld gefärbt wird Status Color .

6. Legen Sie den Titel auf 2) Wählen Sie einen neuen Status aus.

Hinzufügen von Eingabefiltern für Notizen

1. Fügen Sie einen Eingabedatenschnitt hinzu, damit Benutzer Notizen zur Statusaktualisierung eingeben können.

2. Legen Sie den Titel auf 3) Fügen Sie Notizen für diese Statusaktualisierung hinzu.

3. Fügen Sie einen weiteren Eingabeschnitt für das Nachrichtenfeld hinzu, das von der Schaltfläche zum Aktualisieren des Anforderungsstatus verwendet wird.

4. Legen Sie den Titel auf Oder eine Nachricht an den Teams-Kanal senden fest.

Hinzufügen der Vorschautabelle

1. Fügen Sie eine Tabellenvisualisierung mit einer einzelnen Spalte hinzu: das [Preview of status update] Measure.

2. Legen Sie den Titel auf "Vorschauaktualisierung" fest.

Dies zeigt Benutzern, wie ihre Teams-Benachrichtigung aussieht, bevor sie sie senden.

Hinzufügen der Datenfunktionsschaltflächen

Fügen Sie zwei Schaltflächen hinzu: eine zum Aktualisieren des Status und eine zum Anfordern einer Statusaktualisierung.

Schaltfläche "Status aktualisieren"

1. Wählen Sie auf der Registerkarte Einfügen die Optionen Schaltfläche> und Datenfunktion aus.

2. Konfigurieren Sie im Bereich "Format " den Schaltflächentext:

   • Bestimmen Sie Standardtext als [Update status button text] Maß für die dynamische Beschriftung.
   • Legen Sie deaktivierten Text auf statischen Text wie "Projekt auswählen, neuen Status und zuerst Notizen hinzufügen" fest.

3. Wählen Sie Ihre veröffentlichte Funktion aus update_project_status .

4. Ordnen Sie die Funktionsparameter zu:

   Parameter	Bindungstyp	Gebunden an
   projectId	Maßnahme	[Selected project id] Messen
   newStatus	Schneidemaschine	Visuelles Schaltflächen-Slicer (automatisches Löschen aktiviert)
   updatedBy	Maßnahme	[Updated by] Messen
   notes	Schneidemaschine	Visuelle Eingabeschnittanzeige (automatisches Löschen aktiviert)
   updatedDate	Maßnahme	[Updated date] Maßnahme

5. Aktivieren Sie im Format-Bereich unter Aktion die Option Bericht nach erfolgreicher Durchführung aktualisieren. Diese Einstellung aktualisiert die Berichtsseite automatisch, nachdem die Funktion erfolgreich ausgeführt wurde.

   Tipp

   Aktivieren Sie Auto-Löschen für Slicer-Parameter, sodass der Button-Slicer und der Notizentext zurückgesetzt werden, nachdem der Benutzer die Funktion ausgelöst hat.

Schaltfläche 'Statusaktualisierung anfordern'

1. Fügen Sie eine weitere Schaltfläche>Datenfunktion hinzu.

2. Konfigurieren Sie im Bereich "Format " den Schaltflächentext:

   • Legen Sie Den Standardtext auf statischen Text wie "Teams-Nachricht an Kanal senden" fest.
   • Setzen Sie den deaktivierten Text auf "Wählen Sie zuerst ein Projekt aus und geben Sie dann eine Nachricht ein".

3. Wählen Sie Ihre veröffentlichte request_status_update Funktion aus.

4. Ordnen Sie die Funktionsparameter zu:

   Parameter	Bindungstyp	Verknüpft mit
   projectId	Maßnahme	[Selected project id] Messen
   requestedBy	Maßnahme	[Updated by] Messen
   message	Schneidemaschine	Visuelle Eingabeschnittanzeige (automatische Löschung aktiviert)

5. Aktivieren Sie optional "Bericht aktualisieren" nach erfolgreichem Ergebnis im Bereich "Format " unter "Aktion".

Konfigurieren von dynamischem Schaltflächentext

Verwenden Sie dynamischen Text auf Ihren Datenfunktionsschaltflächen, um Benutzern genau zu zeigen, welche Aktion beim Auswählen der Schaltfläche ausgeführt wird. Anstelle einer generischen Bezeichnung wie "Aktualisieren" kann die Schaltfläche kontextspezifischen Text wie "Update the status of Session ABC to In Progress" anzeigen.

So konfigurieren Sie dynamischen Schaltflächentext:

1. Erstellen Sie ein Measure, das die Schaltflächenbezeichnung generiert. Mit dieser Maßnahme werden beispielsweise der ausgewählte Projektname und der neue Status kombiniert.

   Update status button text = 
       "Update the status of " & SELECTEDVALUE(Project[Project name]) & " to " & SELECTEDVALUE('Status Options'[Status])
   

2. Im Bereich Format für die Schaltfläche Datenfunktion erweitern Sie Schaltfläche> und Text.

3. Legen Sie Standardtext auf Ihre dynamische Maßnahme ([Update status button text]) fest.

4. Legen Sie deaktivierten Text auf statischen Text fest, der Benutzern angibt, welche Auswahl erforderlich ist (z. B. "Projekt auswählen, neuer Status und zuerst Notizen hinzufügen").

Die Schaltfläche zeigt den deaktivierten Text an, bis alle erforderlichen Parameter Werte enthalten. Sobald der Benutzer seine Auswahl getroffen hat, zeigt die Schaltfläche den dynamischen Text an, der die jeweilige Aktion beschreibt.

(Optional) Fügen Sie eine Drillthrough-Schaltfläche und -Seite hinzu

Um den vollständigen Verlauf der Statusaktualisierungen für ein ausgewähltes Projekt anzuzeigen, können Sie eine Drillthrough-Seite hinzufügen.

1. Wählen Sie auf der Registerkarte "Einfügen" dieSchaltfläche>" aus.

2. Legen Sie im Bereich "Format " unter "Schaltfläche" den Text fest:

   • Standardtext: "Alle Statusaktualisierungen anzeigen"
   • Deaktivierter Text: "Wählen Sie ein Projekt aus, um alle Statusaktualisierungen anzuzeigen"

3. Aktivieren Sie unter "Aktion" die Aktion, und legen Sie Folgendes fest:

   • Typ: Drillthrough
   • Ziel: Wählen Sie Ihre Statusverlaufsseite aus (in den nächsten Schritten erstellt)

4. Fügen Sie eine neue Seite hinzu, und nennen Sie ihn den Statusaktualisierungsverlauf.

5. Im Format-Bereich der Seite erweitern Sie Seiteninformationen und aktivieren Sie Drillthrough. Fügen Sie Project[Product name] als Drillthrough-Feld hinzu.

6. Fügen Sie visuelle Elemente hinzu, um den Statusverlauf anzuzeigen:

   • Karte: Gesamtanzahl der Statusaktualisierungen
   • Button-Slicer: Aufschlüsselung nach Status
   • Tabelle: Alle Statusaktualisierungen (Update-ID, Aktualisierungsdatum, Status, Notizen, Aktualisiert von)
   • Liniendiagramm: Aktualisieren der Aktivität im Laufe der Zeit

7. Fügen Sie eine Schaltfläche " Zurück " hinzu, damit Benutzer zur Hauptberichtsseite zurückkehren können. Wählen Sie auf der Registerkarte "Einfügen" die Schaltfläche "Zurück">aus.

Veröffentlichen des Berichts

1. Speichern Sie Ihren Bericht, und veröffentlichen Sie ihn im Power BI-Dienst.

2. Kopieren Sie die Berichts-URL und fügen Sie sie Ihrer Variablenbibliothek als POWERBI_REPORT_URL hinzu.

Testen des Workflows

Teste den Prozess zur Aktualisierung des Anforderungsstatus

Nach der Veröffentlichung können Sie den translytischen Aufgabenfluss verwenden, um eine Statusaktualisierung anzufordern:

1. Wählen Sie ein zu aktualisierenes Projekt aus – Wählen Sie eine Projektzeile in der Tabelle aus, um den Filterkontext festzulegen.

2. Oder senden Sie eine Nachricht an den Teams-Kanal – Geben Sie eine Nachricht im Eingabeschnitt ein (z. B. "Können wir ein Update dazu erhalten?").

3. Wählen Sie die Schaltfläche " Teams-Nachricht an Kanal senden " aus.

4. Eine Bestätigung über die eingereichte Anfrage erscheint, wenn die Aktion erfolgreich abgeschlossen wurde.

5. Überprüfen Sie in Ihrem Teams-Kanal die Adaptive Card 'Projektstatusaktualisierung' mit den Anforderungsdetails.

6. Der Projektbesitzer kann " Projektstatus aktualisieren" in der adaptiven Karte auswählen, um den Bericht zu öffnen und seinen Status zu aktualisieren.

Testen des Aktualisierungsablaufs

Nach der Veröffentlichung können Sie den translytischen Aufgabenfluss verwenden, um einen Projektstatus zu aktualisieren:

1. Wählen Sie ein zu aktualisierenes Projekt aus – Wählen Sie eine Projektzeile in der Tabelle aus, um den Filterkontext festzulegen.

2. Was ist der neue Status? - Verwenden Sie den Schaltflächenschnitt, um einen neuen Status auszuwählen (z. B. "In Bearbeitung").

3. Hinzufügen von Notizen für diese Statusaktualisierung – Geben Sie Notizen in den Eingabeschnitt ein (z. B. "Zum Aufzeichnen einer Demo gestartet").

4. Wählen Sie die Schaltfläche "Aktualisieren " aus, um die Statusänderung zurück in das Seehaus zu schreiben und eine Teams-Benachrichtigung zu senden.

5. Eine Bestätigung des Antrags erscheint, wenn die Aktion erfolgreich abgeschlossen wurde.

6. Überprüfen Sie Ihren Teams-Kanal auf die adaptive Karte "Projektstatusaktualisierung " mit den Statusänderungsdetails.

Verwandte Inhalte

Translytische Aufgabenflüsse

• Translytische Aufgabenflüsse verstehen
• Tutorial: Erstellung eines translytischen Aufgabenflusses
• Erstellen einer Datenfunktionsschaltfläche in Power BI

Visuelle Berichte

• Erstellen von Schaltflächen in Power BI-Berichten
• Verwenden Sie das Schaltflächenslicer-Visual
• Verwenden des visuellen Eingabeschnitts

DAX-Funktionen

• SELECTEDVALUE-Funktion (DAX)
• USERPRINCIPALNAME-Funktion (DAX)

Fabric-Daten

• Übersicht über Benutzerdatenfunktionen
• Erstellen von Benutzerdatenfunktionen
• Verbinden von Benutzerdatenfunktionen mit Datenquellen
• Erstellen und Verwalten von Variablenbibliotheken
• Übersicht über die Fabric SQL-Datenbank
• Lakehouse-Übersicht
• Übersicht über den Direct Lake
• Materialisierte Seeansichten Übersicht

Microsoft Teams

• Erstellen eines eingehenden Webhooks in Teams
• Adaptive Karten