Poradnik: tworzenie przepływu pracy dla aktualizacji statusu

W tym złożonym samouczku "od początku do końca" utworzysz przepływ zadań transakcyjno-analitycznych, który śledzi stan projektu, zapisuje aktualizacje z powrotem do bazy danych i umieszcza powiadomienia z raportu Power BI do Microsoft Teams. Rozwiązanie utrzymuje pełną historię wszystkich aktualizacji stanu, dzięki czemu można śledzić, jak stan projektu zmienił się wraz z upływem czasu. W tym samouczku pokazano, jak połączyć zapisywanie danych z zewnętrznymi wywołaniami interfejsu API w celu utworzenia kompletnego przepływu pracy komunikacji.

W tym poradniku nauczysz się, jak:

Jeśli nie masz istniejącej pojemności sieci Szkieletowej, uruchom wersję próbną usługi Fabric.

Wymagania wstępne

• Power BI Desktop. Jeśli na urządzeniu nie masz zainstalowanego programu Power BI Desktop, postępuj zgodnie z instrukcjami w temacie Pobieranie programu Power BI Desktop.
• Kanał Microsoft Teams, w którym masz uprawnienia na dodawanie przychodzących webhooków.

Przegląd

Ten samouczek tworzy rozwiązanie do śledzenia projektu, w którym użytkownicy mogą aktualizować stan projektu bezpośrednio z raportu usługi Power BI. Gdy użytkownik aktualizuje stan, system:

1. Zapisuje nowy stan w bazie danych SQL, zachowując pełną historię wszystkich aktualizacji stanu.
2. Wysyła powiadomienie o karcie adaptacyjnej do usługi Microsoft Teams.
3. Odświeża raport, aby wyświetlić zaktualizowane dane.

Przepływ użytkownika

Przepływ pracy tworzy pętlę ciągłego sprzężenia zwrotnego między użytkownikami raportu.

1. Żądanie aktualizacji za pośrednictwem aplikacji Teams z raportu — użytkownik wybiera projekt w raporcie i wysyła żądanie aktualizacji stanu. Żądanie zostaje opublikowane w aplikacji Teams z linkiem prowadzącym do raportu.

2. Otrzymywanie powiadomień w aplikacji Teams i otwieranie raportu — właściciel projektu widzi powiadomienie w aplikacji Teams i wybiera link, aby otworzyć raport.

3. Stan aktualizacji w raporcie — właściciel projektu wybiera projekt, wybiera nowy stan, dodaje notatki i wybiera przycisk aktualizacji.

4. Zobacz aktualizację i wyślij powiadomienie — raport pokazuje nowy stan oraz powiadomienie jest wysyłane do Teams potwierdzające zmianę.

Architecture

Rozwiązanie łączy te składniki w usłudze Microsoft Fabric:

Dane przepływa w dwóch kierunkach:

• Ścieżka do odczytu: usługa Power BI odczytuje z bazy danych SQL (za pośrednictwem zapytania bezpośredniego) lub lakehouse (za pośrednictwem usługi Direct Lake), aby wyświetlić bieżący stan projektu.
• Ścieżka zapisu: gdy użytkownik wybierze przycisk funkcji danych, usługa Power BI wywołuje funkcję danych użytkownika, która zapisuje dane w bazie danych SQL i publikuje w aplikacji Teams.

Tworzenie bazy danych SQL

W tym scenariuszu są używane dane śledzenia projektu. Wykonaj kroki opisane w temacie Tworzenie bazy danych SQL w sieci szkieletowej, aby utworzyć nową bazę danych SQL w obszarze roboczym usługi Fabric.

Tworzenie tabel bazy danych

1. W bazie danych SQL otwórz nowe okno zapytania.

2. Uruchom następujący skrypt SQL, aby utworzyć tabelę Project:

   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. Utwórz tabelę Aktualizacje stanu, aby śledzić zmiany stanu w czasie:

   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. Utwórz widok, który zwraca najnowszy stan dla każdego projektu:

   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. Wstaw przykładowe dane projektu:

   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. Wstaw przykładowe aktualizacje stanu:

   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');
   

Konfigurowanie biblioteki zmiennych

Biblioteka zmiennych przechowuje wartości konfiguracji oddzielnie od kodu funkcji. Ta separacja zapewnia kluczową korzyść: można aktualizować wartości, takie jak adresy URL webhooków lub linki raportów, bez konieczności edytowania lub ponownego publikowania funkcji danych użytkownika.

Jeśli na przykład kanał usługi Teams ulegnie zmianie lub musisz wskazać inny raport, zaktualizuj wartość biblioteki zmiennych, a zmiana zostanie natychmiast w życie — bez konieczności wprowadzania zmian w kodzie.

1. W obszarze roboczym Fabric wybierz pozycję + Nowy element.

2. Przewiń w dół do sekcji Opracowywanie danych i wybierz pozycję Biblioteka zmiennych.

3. Nazwij bibliotekę ProjectVariables zmiennych i wybierz pozycję Utwórz.

4. Wybierz pozycję + Nowa zmienna i dodaj następujące zmienne:

   Nazwa zmiennej	Typ	Opis
   TEAMS_WEBHOOK_URL	Sznurek	Przychodzący adres URL elementu webhook aplikacji Teams
   POWERBI_REPORT_URL	Sznurek	Adres URL raportu usługi Power BI (dodany po opublikowaniu)

5. Wybierz pozycję Zapisz po dodaniu każdej zmiennej.

Uzyskiwanie adresu URL elementu webhook usługi Teams

Wykonaj kroki opisane w temacie Tworzenie przychodzącego webhooka, aby utworzyć webhook dla kanału Teams. Po utworzeniu elementu webhook skopiuj adres URL i dodaj go do biblioteki zmiennych jako TEAMS_WEBHOOK_URL.

Tworzenie funkcji danych użytkownika

Utwórz element funkcji danych użytkownika, który obsługuje aktualizacje stanu i powiadomienia usługi Teams.

1. W obszarze roboczym usługi Fabric wybierz pozycję + Nowy element>Funkcje danych użytkowników.

2. Zastąp domyślny kod następującym kodem w języku Python:

   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. Skonfiguruj połączenia:

   • Wybierz pozycję Ustawienia lub panel połączeń.
   • Dodaj połączenie ProjectTrackingDb wskazujące na usługę Fabric SQL Database.
   • Dodaj połączenie ProjectVariables wskazujące bibliotekę zmiennych.

4. Wybierz pozycję Publikuj, aby wdrożyć funkcję.

Omówienie funkcji update_project_status

Funkcja update_project_status zapisuje nowy rekord stanu w bazie danych SQL i wysyła powiadomienie usługi Teams. Gdy użytkownik wybierze przycisk aktualizacji w raporcie, wystąpi następujący przepływ:

1. Usługa Power BI wywołuje funkcję — przycisk funkcji danych przekazuje parametry (identyfikator projektu, nowy stan, notatki itp.) do funkcji danych użytkownika.

2. Weryfikowanie danych wejściowych — funkcja weryfikuje format daty i sprawdza, czy wartość stanu jest jedną z dozwolonych opcji.

3. Zapytanie o bieżący stan — funkcja pobiera poprzedni stan i nazwę projektu z bazy danych.

4. Wstaw nowy rekord — nowy wiersz jest wstawiany do Status updates tabeli z nowym stanem, znacznikiem czasu i notatkami.

5. Wysyłanie powiadomienia Teams — funkcja _send_teams_update pomocnika publikuje kartę adaptacyjną do kanału Teams pokazującą zmianę stanu.

6. Wynik zwracany — funkcja zwraca komunikat o powodzeniu wyświetlany użytkownikowi przez usługę Power BI.

Omówienie funkcji request_status_update

Funkcja request_status_update wysyła powiadomienie usługi Teams z prośbą właściciela projektu o podanie aktualizacji stanu. Ta funkcja nie zapisuje w bazie danych — wysyła tylko komunikat.

1. Usługa Power BI wywołuje funkcję — przycisk funkcji danych przekazuje identyfikator projektu, nazwę osoby żądającego i komunikat do funkcji.

2. Szczegóły projektu zapytania — funkcja pobiera nazwę projektu, menedżera projektu i bieżący stan z bazy danych.

3. Wyślij powiadomienie Teams — funkcja pomocnicza _send_status_request publikuje kartę adaptacyjną w kanale Teams ze szczegółami żądania i przyciskiem Aktualizuj stan projektu, który prowadzi z powrotem do raportu.

4. Wynik zwracany — funkcja zwraca komunikat potwierdzający wyświetlany użytkownikowi przez usługę Power BI.

(Opcjonalnie) Skonfiguruj skróty Lakehouse dla widoków Direct Lake

Usługa Fabric SQL Database przechowuje wszystkie dane jako tabele delty w usłudze OneLake, dzięki czemu można utworzyć model semantyczny usługi Direct Lake bezpośrednio w tabelach bazy danych SQL. Jednak usługa Direct Lake nie może odczytywać widoków z bazy danych SQL — tylko tabel. Aby użyć widoku z usługą Direct Lake, utwórz skróty do tabel bazy danych SQL w usłudze Lakehouse, a następnie zdefiniuj tam widok.

Tworzenie skrótów do tabel bazy danych SQL

1. W obszarze roboczym Fabric utwórz nowy Lakehouse i włącz schematy.

2. W Eksploratorze usługi Lakehouse kliknij prawym przyciskiem myszy dowolny schemat (na przykład dbo) i wybierz pozycję Nowy skrót do tabeli.

3. W katalogu OneLake przejdź do bazy danych SQL i wybierz tabelę Project .

4. Powtórz polecenie, aby stworzyć skrót do tabeli Status updates.

Skróty zapewniają dostęp do odczytu do bazowych tabel delty bez duplikowania danych.

Tworzenie zmaterializowanego widoku jeziora

Utwórz zmaterializowany widok jeziora w usłudze Lakehouse, który oblicza najnowszy stan dla każdego projektu:

1. W usłudze Lakehouse wybierz pozycję Zarządzaj zmaterializowanymi widokami jeziora (wersja zapoznawcza).

2. Otwórz nowy notes za pomocą usługi Spark SQL.

3. Uruchom następujące zapytanie:

   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. Zaplanuj odświeżanie widoku, wybierając pozycję Harmonogramy>włączone i ustawiając częstotliwość.

Tworzenie raportu usługi Power BI

Możesz nawiązać połączenie z danymi przy użyciu trybu DirectQuery lub Direct Lake:

• Zapytanie bezpośrednie do usługi SQL Database: dane w czasie rzeczywistym obsługują funkcję zapisywania zwrotnego za pośrednictwem funkcji danych użytkownika.
• Direct Lake do tabel bazy danych SQL: Baza Danych SQL w Fabric przechowuje dane jako tabele Delta w OneLake, dzięki czemu Direct Lake ma możliwość bezpośredniego dostępu do tabel.
• Direct Lake via Lakehouse (dla widoków): Direct Lake nie może odczytać widoków z SQL Database. Aby używać widoków z Direct Lake, utwórz skróty do tabel bazy danych SQL w Lakehouse, a następnie zdefiniuj tam zmaterializowane widoki jeziora.

Opcja A: Nawiązywanie połączenia za pośrednictwem trybu DirectQuery

1. Otwórz program Power BI Desktop.

2. Wybierz Katalog OneLake.

3. Znajdź bazę danych SQL Fabric.

4. Wybierz Połącz z punktem końcowym SQL Analytics.

5. Wybierz tabele/widok Project, Status updates i Project status.

6. Po wyświetleniu monitu o tryb przechowywania wybierz pozycję DirectQuery.

Opcja B: Nawiązywanie połączenia za pośrednictwem usługi Direct Lake (na potrzeby wydajności analizy)

1. W usłudze Power BI wybierz pozycję Utwórz>katalog OneLake.

2. Znajdź swój Lakehouse.

3. Wybierz tabele skrótów (Project, Status updates) i zmaterializowany widok jeziora (project_status).

4. Edytuj model semantyczny w środowisku modelowania internetowego, aby dodać miary i relacje.

Utwórz tabelę obliczeniową Opcje stanu

Utwórz tabelę obliczeniową zawierającą wartości stanu fragmentatora przycisku. Uruchom ten skrypt TMDL w programie Power BI Desktop:

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" }
				    }
				)

Tworzenie miar pomocniczych

Utwórz tabelę obliczeniową do przechowywania miar obsługujących przyciski funkcji danych. Uruchom ten skrypt TMDL w programie Power BI Desktop:

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}

Te środki służą wielu celom:

Projektowanie raportu

Układ raportu prowadzi użytkowników przez przejrzysty przepływ pracy: wybierz projekt, wybierz nowy stan, dodaj notatki, a następnie wykonaj aktualizację.

Tworzenie tabeli projektu

1. Dodaj wizualizację Tabela , aby wyświetlić informacje o projekcie.

2. Dodaj następujące kolumny z danych:

   • Product name
   • Project name
   • Target end date
   • Description
   • Latest status (z tabeli Stan lub Stan projektu/widok)
   • Latest notes

3. Ustaw tytuł na 1) Wybierz projekt do zaktualizowania.

4. Sortuj według docelowej daty zakończenia rosnąco, aby najpierw wyświetlić nadchodzące terminy.

Tworzenie fragmentatora przycisku na potrzeby wyboru stanu

1. Dodaj wizualizację fragmentatora przycisku .

2. W polu Wartości dodaj wartość Status Options[Status].

3. W polu Etykieta dodaj FIRST(Status Options[Description]) , aby wyświetlić opis pod każdym stanem.

4. W okienku Format :

   • Ustaw Styl na Karty.
   • Ustaw orientację na poziomą.
   • Ustaw opcję Maksymalna liczba kafelków na 5 (po jednym dla każdego stanu).

5. Skonfiguruj formatowanie warunkowe tak, aby kolorować każdą kartę według Status Color pola.

6. Ustaw tytuł na 2) Wybierz nowy stan.

Dodawanie fragmentatorów wejściowych dla notatek

1. Dodaj kontrolkę wprowadzania danych dla użytkowników do wpisywania notatek dotyczących aktualizacji stanu.

2. Ustaw tytuł na 3) Dodaj uwagi dotyczące tej aktualizacji stanu.

3. Dodaj kolejny fragmentator danych wejściowych dla pola komunikatu używanego przez przycisk aktualizacji stanu żądania.

4. Ustaw tytuł na Lub wyślij wiadomość do kanału teams.

Dodawanie tabeli podglądu

1. Dodaj wizualny element Tabela z jedną kolumną zawierającą [Preview of status update] jako miarę.

2. Ustaw tytuł na Aktualizacja zapoznawcza.

Spowoduje to wyświetlenie użytkownikom, jak będzie wyglądało powiadomienie usługi Teams przed wysłaniem.

Dodawanie przycisków funkcji danych

Dodaj dwa przyciski: jeden do aktualizowania stanu i jeden do żądania aktualizacji stanu.

Przycisk Aktualizuj stan

1. Na karcie Wstawianie wybierz Przycisk>Funkcja Dane.

2. W okienku Format skonfiguruj tekst przycisku:

   • Ustaw Domyślny tekst jako miarę [Update status button text] dla dynamicznego etykietowania.
   • Ustaw pozycję Wyłączony tekst na tekst statyczny, taki jak "Wybierz projekt, nowy stan i dodaj notatki jako pierwsze".

3. W obszarze Akcja wybierz przycisk Formatowanie warunkowe (fx) obok pozycji Funkcja Dane. Zostanie otwarty katalog OneLake.

4. Znajdź i wybierz opublikowaną update_project_status funkcję.

   Po wybraniu funkcji okienko Format wyświetla jego obszar roboczy, zestaw funkcji i nazwę funkcji jako szczegóły tylko do odczytu.

5. Mapuj parametry funkcji:

   Parameter	Typ powiązania	Powiązana z
   projectId	Mierzenie	[Selected project id] Mierzenie
   newStatus	Krajalnica	Wizualizacja filtra przycisku (automatyczne czyszczenie włączone)
   updatedBy	Mierzenie	[Updated by] Mierzenie
   notes	Krajalnica	Wizualizacja fragmentatora danych wejściowych (włączono automatyczne czyszczenie)
   updatedDate	Mierzenie	[Updated date] Mierzenie

6. W okienku Format w obszarze Akcja włącz opcję Odśwież raport po pomyślnym wyniku. To ustawienie automatycznie odświeża stronę raportu po pomyślnym wykonaniu funkcji.

   Wskazówka

   Włącz automatyczne czyszczenie parametrów fragmentatora, aby fragmentator przycisku i tekst notatek były zresetowane po wyzwoleniu funkcji przez użytkownika.

Przycisk Żądaj aktualizacji stanu

1. Dodaj kolejny Przycisk>funkcję Dane.

2. W okienku Format skonfiguruj tekst przycisku:

   • Ustaw tekst domyślny na tekst statyczny, taki jak "Wyślij wiadomość usługi Teams do kanału".
   • Ustaw pozycję Wyłączony tekst na "Wybierz projekt i wpisz najpierw komunikat".

3. W obszarze Akcja wybierz przycisk Formatowanie warunkowe (fx) obok pozycji Funkcja Dane. Zostanie otwarty katalog OneLake.

4. Znajdź i wybierz swoją opublikowaną request_status_update funkcję.

   Po wybraniu funkcji okienko Format wyświetla jego obszar roboczy, zestaw funkcji i nazwę funkcji jako szczegóły tylko do odczytu.

5. Mapuj parametry funkcji:

   Parameter	Typ powiązania	Powiązana z
   projectId	Mierzenie	[Selected project id] Mierzenie
   requestedBy	Mierzenie	[Updated by] Mierzenie
   message	Krajalnica	Wizualizacja fragmentatora danych wejściowych (włączono automatyczne czyszczenie)

6. Opcjonalnie włącz opcję Odśwież raport po pomyślnym wyniku w okienku Formatowanie w obszarze Akcja.

Konfigurowanie dynamicznego tekstu przycisku

Użyj dynamicznego tekstu na przyciskach funkcji danych, aby pokazać użytkownikom dokładnie, jaką akcję będzie miała miejsce po wybraniu przycisku. Zamiast etykiety ogólnej, takiej jak "Aktualizuj", przycisk może wyświetlać tekst specyficzny dla kontekstu, taki jak "Aktualizuj status sesji ABC do w trakcie realizacji".

Aby skonfigurować tekst przycisku dynamicznego:

1. Utwórz miarę, która generuje etykietę przycisku. Na przykład ta miara łączy wybraną nazwę projektu i nowy stan:

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

2. W okienku Format dla przycisku funkcji danych rozwiń Przycisk>Tekst.

3. Ustaw domyślny tekst na miarę dynamiczną ([Update status button text]).

4. Ustaw pozycję Wyłączony tekst na tekst statyczny, który informuje użytkowników, jakie opcje są wymagane (na przykład "Wybierz projekt, nowy stan i dodaj notatki najpierw").

Przycisk wyświetla wyłączony tekst, dopóki wszystkie wymagane parametry nie mają wartości. Gdy użytkownik dokona wyboru, przycisk wyświetli tekst dynamiczny opisujący określoną akcję.

(Opcjonalnie) Dodaj przycisk drill-through i stronę

Możesz dodać stronę drill-through, aby wyświetlić całą historię zmian statusu dla wybranego projektu.

1. Na karcie Wstawianie wybierz pozycję Przycisk>Pusty.

2. W okienku Format w obszarze Przycisk ustaw tekst:

   • Tekst domyślny: "Zobacz wszystkie aktualizacje stanu"
   • Wyłączony tekst: "Wybierz projekt, aby wyświetlić wszystkie aktualizacje stanu"

3. Pod Akcją, włącz akcję i ustaw:

   • Typ: Drillthrough
   • Miejsce docelowe: wybierz stronę historii stanu (utworzoną w następnych krokach)

4. Dodaj nową stronę i nadaj jej nazwę Historia aktualizacji stanu.

5. W okienku Format dla strony rozwiń węzeł Informacje o stronie i włącz przeglądanie szczegółowe. Dodaj Project[Product name] jako pole przeglądania szczegółowego.

6. Dodaj wizualizacje, aby wyświetlić historię stanu:

   • Karta: łączna liczba aktualizacji stanu
   • Fragmentator przycisku: Podział według stanu
   • Tabela: wszystkie aktualizacje stanu (identyfikator aktualizacji, data aktualizacji, stan, uwagi, zaktualizowane przez)
   • Wykres liniowy: aktualizacja aktywności w czasie

7. Dodaj przycisk Wstecz , aby użytkownicy mogli wrócić do strony głównej raportu. Na karcie Wstawianie wybierz pozycję Przycisk>Wstecz.

Publikowanie raportu

1. Zapisz raport i opublikuj go w usłudze Power BI.

2. Skopiuj adres URL raportu i dodaj go do biblioteki zmiennych jako POWERBI_REPORT_URL.

Testowanie przepływu pracy

Testowanie przepływu aktualizacji stanu żądania

Po opublikowaniu można użyć przepływu zadań translitycznych w celu zażądania aktualizacji stanu:

1. Wybierz projekt do zaktualizowania — wybierz wiersz projektu w tabeli, aby ustawić kontekst filtru.

2. Możesz też wysłać komunikat do kanału teams — wprowadź komunikat we fragmentatorze danych wejściowych (na przykład "Czy możemy uzyskać aktualizację na ten temat?").

3. Wybierz przycisk Wyślij wiadomość zespołu na kanał.

4. Pojawi się komunikat Potwierdzenie przesłania żądania, gdy działanie zostanie pomyślnie zakończone.

5. Sprawdź kanał usługi Teams pod kątem karty adaptacyjnej aktualizacji stanu projektu , aby uzyskać szczegółowe informacje o żądaniu.

6. Właściciel projektu może wybrać pozycję Aktualizuj stan projektu na karcie adaptacyjnej, aby otworzyć raport i zaktualizować ich stan.

Przetestuj przepływ statusu aktualizacji

Po opublikowaniu można użyć przepływu zadań translitycznych w celu zaktualizowania stanu projektu:

1. Wybierz projekt do zaktualizowania — wybierz wiersz projektu w tabeli, aby ustawić kontekst filtru.

2. Jaki jest nowy stan? — Użyj fragmentatora przycisku, aby wybrać nowy stan (na przykład W toku).

3. Dodaj uwagi dotyczące tej aktualizacji stanu — wprowadź notatki we slicerze danych wejściowych (na przykład "Zacząłem nagrywać prezentację").

4. Wybierz przycisk Aktualizuj, aby zapisać zmianę stanu ponownie w lakehouse i wysłać powiadomienie w Teams.

5. Pojawi się komunikat Potwierdzenie przesłania żądania, gdy działanie zostanie pomyślnie zakończone.

6. Sprawdź kanał usługi Teams pod kątem karty adaptacyjnej aktualizacji stanu projektu , aby uzyskać szczegółowe informacje o zmianie stanu.

Treści powiązane

Przepływy zadań translytycznych

• Omówienie przepływów zadań translitycznych
• Samouczek: tworzenie przepływu zadań translitycznych
• Utwórz przycisk funkcji danych w Power BI

Wizualizacje raportów

• Tworzenie przycisków w raportach usługi Power BI
• Używanie wizualizacji fragmentatora przycisku
• Użyj wizualizacji fragmentatora danych wejściowych

Funkcje DAX

• Funkcja SELECTEDVALUE (DAX)
• Funkcja USERPRINCIPALNAME (DAX)

Dane sieci szkieletowej

• Omówienie funkcji danych użytkownika
• Tworzenie funkcji danych użytkownika
• Łączenie funkcji danych użytkownika ze źródłami danych
• Tworzenie bibliotek zmiennych i zarządzanie nimi
• Omówienie usługi Fabric SQL Database
• Omówienie usługi Lakehouse
• Omówienie usługi Direct Lake
• Zmaterializowane widoki jeziora — omówienie

Microsoft Teams

• Utwórz przychodzący webhook w usłudze Teams
• Karty Adaptacyjne