Esercitazione: Creare un flusso di lavoro per l'aggiornamento dello stato

In questa esercitazione end-to-end si crea un flusso di attività transanalitica che tiene traccia dello stato del progetto e pubblica gli aggiornamenti di un report di Power BI su Microsoft Teams. Questa esercitazione illustra come combinare il writeback dei dati con le chiamate API esterne per creare un flusso di lavoro di comunicazione completo.

In questa esercitazione apprenderai a:

Se non si ha una capacità di Fabric già esistente, iniziare una prova di Fabric.

Prerequisiti

• Power BI Desktop. Se Power BI Desktop non è installato nel dispositivo, seguire le istruzioni in Ottenere Power BI Desktop.
• Un canale di Microsoft Teams in cui si dispone dell'autorizzazione per aggiungere webhook in ingresso.

Informazioni generali

Questa esercitazione crea una soluzione di rilevamento dei progetti in cui gli utenti possono aggiornare lo stato del progetto direttamente da un report di Power BI. Quando un utente aggiorna uno stato, il sistema:

1. Scrive il nuovo stato nel database SQL.
2. Invia una notifica di Adaptive Card a Microsoft Teams.
3. Aggiorna il report per visualizzare i dati aggiornati.

Flusso dell'utente

Il flusso di lavoro crea un ciclo di feedback continuo tra gli utenti del report:

1. Richiedere l'aggiornamento tramite il report di Teams : un utente seleziona un progetto nel report e invia una richiesta di aggiornamento dello stato. La richiesta invia a Teams un collegamento al report.

2. Ricevere una notifica in Teams e aprire il report : il proprietario del progetto visualizza la notifica in Teams e seleziona il collegamento per aprire il report.

3. Aggiornare lo stato nel report : il proprietario del progetto seleziona il progetto, sceglie un nuovo stato, aggiunge note e seleziona il pulsante aggiorna.

4. Visualizzare aggiornamenti in tempo reale e inviare notifiche — Il report viene aggiornato immediatamente per mostrare il nuovo stato e una notifica viene inviata a Teams, confermando la modifica.

Architettura

La soluzione connette questi componenti all'interno di Microsoft Fabric:

I dati vengono trasmessi in due direzioni:

• Percorso di lettura: Power BI legge dal database SQL (tramite DirectQuery) o Lakehouse (tramite Direct Lake) per visualizzare lo stato corrente del progetto.
• Percorso di scrittura: quando un utente seleziona un pulsante di funzione dati, Power BI chiama la funzione dati utente, che scrive nel database SQL e invia a Teams.

Creare un database SQL

Questo scenario usa i dati di rilevamento del progetto. Seguire la procedura descritta in Creare un database SQL in Infrastruttura per creare un nuovo database SQL nell'area di lavoro Infrastruttura.

Creare le tabelle di database

1. Nel database SQL aprire una nuova finestra di query.

2. Eseguire lo script SQL seguente per creare la tabella 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. Creare la tabella Aggiornamenti dello stato per tenere traccia delle modifiche dello stato nel tempo:

   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. Creare una visualizzazione che restituisca lo stato più recente per ogni progetto:

   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. Inserire dati di progetto di esempio:

   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. Inserire esempi di aggiornamenti di stato.

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

Configurare una libreria di variabili

Una libreria di variabili archivia i valori di configurazione separatamente dal codice della funzione. Questa separazione offre un vantaggio fondamentale: è possibile aggiornare valori come URL webhook o collegamenti di report senza modificare o ripubblicare le funzioni dei dati utente.

Ad esempio, se il canale di Teams cambia o è necessario puntare a un report diverso, aggiornare il valore della libreria delle variabili e la modifica diventa effettiva immediatamente. Non sono necessarie modifiche al codice.

1. Nello spazio di lavoro Fabric, selezionare + Nuovo elemento.

2. Scorrere verso il basso fino alla sezione Sviluppare dati e selezionare Libreria variabili.

3. Assegnare un nome alla libreria ProjectVariables di variabili e selezionare Crea.

4. Selezionare + Nuova variabile e aggiungere le variabili seguenti:

   Nome variabile	Tipo	Descrizione
   TEAMS_WEBHOOK_URL	String	URL webhook in ingresso del tuo Teams
   POWERBI_REPORT_URL	String	URL del report di Power BI (aggiunto dopo la pubblicazione)

5. Selezionare Salva dopo aver aggiunto ogni variabile.

Ottenere un URL webhook di Teams

Seguire la procedura descritta in Creare un webhook in ingresso per creare un webhook per il canale di Teams. Dopo aver creato il webhook, copiare l'URL e aggiungerlo alla libreria di variabili come TEAMS_WEBHOOK_URL.

Creare le funzioni dati utente

Creare un elemento delle funzioni dati utente che gestisce gli aggiornamenti dello stato e le notifiche di Teams.

1. Nella tua area di lavoro Fabric, seleziona + Nuovo elemento>Funzioni dati utente.

2. Sostituire il codice predefinito con il codice Python seguente:

   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. Configurare le connessioni:

   • Selezionare Impostazioni o il pannello connessioni.
   • Aggiungere il collegamento ProjectTrackingDb che indirizza al database SQL Fabric.
   • Aggiungere la connessione ProjectVariables che punta alla Libreria di Variabili.

4. Selezionare Pubblica per distribuire la funzione.

Informazioni sulla funzione update_project_status

La update_project_status funzione scrive un nuovo record di stato nel database SQL e invia una notifica di Teams. Quando un utente seleziona il pulsante di aggiornamento nel report, si verifica il flusso seguente:

1. Power BI chiama la funzione : il pulsante della funzione dati passa i parametri (ID progetto, nuovo stato, note e così via) alla funzione dati utente.

2. Convalida input : la funzione convalida il formato della data e verifica che il valore di stato sia una delle opzioni consentite.

3. Query sullo stato corrente : la funzione recupera lo stato precedente e il nome del progetto dal database.

4. Inserisci nuovo record : una nuova riga viene inserita nella Status updates tabella con il nuovo stato, il timestamp e le note.

5. Invia una notifica in Teams, la funzione di supporto _send_teams_update invia una scheda adattiva al canale di Teams, indicando il cambio di stato.

6. Risultato restituito : la funzione restituisce un messaggio di esito positivo visualizzato da Power BI all'utente.

Comprendere la funzione request_status_update

La request_status_update funzione invia una notifica di Teams che chiede al proprietario del progetto di fornire un aggiornamento dello stato. Questa funzione non scrive nel database, ma invia solo un messaggio.

1. Power BI chiama la funzione : il pulsante della funzione dati passa l'ID progetto, il nome del richiedente e il messaggio alla funzione.

2. Dettagli del progetto di query : la funzione recupera il nome del progetto, il project manager e lo stato corrente dal database.

3. Invia notifica di Teams : la funzione _send_status_request helper invia una scheda adattiva al canale teams con i dettagli della richiesta e un pulsante Aggiorna stato progetto che si collega di nuovo al report.

4. Risultato restituito : la funzione restituisce un messaggio di conferma visualizzato da Power BI all'utente.

(Facoltativo) Configurare i collegamenti Lakehouse per le visualizzazioni Direct Lake

Il database SQL di Infrastruttura archivia tutti i dati come tabelle Delta in OneLake, quindi è possibile creare un modello semantico Direct Lake direttamente nelle tabelle di database SQL. Tuttavia, Direct Lake non è in grado di leggere le viste da un database SQL, ma solo da tabelle. Per usare una vista con Direct Lake, creare collegamenti alle tabelle di database SQL in un Lakehouse e quindi definire la vista.

Creare scorciatoie alle tabelle di database SQL

1. Nell'area di lavoro Fabric, crea un nuovo Lakehouse e abilita gli schemi.

2. In Lakehouse Explorer fare clic con il pulsante destro del mouse su qualsiasi schema(ad esempio dbo) e selezionare Nuovo collegamento a tabella.

3. Nel catalogo OneLake, vai al database SQL e seleziona la tabella Project.

4. Ripetere per creare un collegamento per la Status updates tabella.

Le scorciatoie forniscono l'accesso in lettura alle tabelle Delta sottostanti senza duplicare i dati.

Creare una vista materializzata del lago

Creare una vista lake materializzata in Lakehouse che calcola lo stato più recente per ogni progetto:

1. In Lakehouse selezionare Gestisci viste lake materializzate (anteprima).

2. Aprire un nuovo notebook con Spark SQL.

3. Eseguire la query riportata di seguito:

   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. Pianificare l'aggiornamento della visualizzazione selezionando Pianificazioni>attiva e impostando la frequenza.

Creare il report di Power BI

È possibile connettersi ai dati usando DirectQuery o Direct Lake:

• DirectQuery al database SQL: i dati in tempo reale supportano la scrittura indietro tramite funzioni sui dati dell'utente.
• Tabelle del database SQL a Direct Lake: il Fabric SQL Database archivia i dati come tabelle Delta in OneLake, consentendo a Direct Lake di leggere direttamente le tabelle.
• Direct Lake tramite Lakehouse (per le viste): Direct Lake non è in grado di leggere le viste dal database SQL. Per usare le viste con Direct Lake, creare collegamenti alle tabelle di database SQL in un lakehouse e quindi definire viste lake materializzate in questa posizione.

Opzione A: Connettersi tramite DirectQuery

1. Apri Power BI Desktop.

2. Selezionare Catalogo OneLake.

3. Trova il tuo database SQL Fabric.

4. Selezionare Connetti all'endpoint di analisi SQL.

5. Selezionare le tabelle Project, Status updates e la vista Project status.

6. Quando viene richiesta la modalità di archiviazione, selezionare DirectQuery.

Opzione B: Connettersi tramite Direct Lake (per le prestazioni di analisi)

1. Nel servizio Power BI selezionare Crea>catalogo OneLake.

2. Trova il tuo Lakehouse.

3. Selezionare le tabelle di scelta rapida (Project, Status updates) e la vista lake materializzata (project_status).

4. Modificare il modello semantico nell'esperienza di modellazione Web per aggiungere misure e relazioni.

Creare la tabella calcolata Opzioni di stato

Creare una tabella calcolata che fornisca i valori di stato per il selettore pulsante. Esegui questo script TMDL in 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" }
				    }
				)

Creare misure di supporto

Creare una tabella calcolata per contenere le misure che supportano i pulsanti della funzione dati. Esegui questo script TMDL in 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}

Queste misure servono a più scopi:

Progettare il report

Il layout del report guida gli utenti attraverso un flusso di lavoro chiaro: selezionare un progetto, scegliere un nuovo stato, aggiungere note e quindi eseguire l'aggiornamento.

Creare la tabella del progetto

1. Aggiungere un oggetto visivo Tabella per visualizzare le informazioni sul progetto.

2. Aggiungere queste colonne dai dati:

   • Product name
   • Project name
   • Target end date
   • Description
   • Latest status (dalla tabella/vista Stato o Stato del progetto)
   • Latest notes

3. Impostare il titolo su 1) Selezionare un progetto da aggiornare.

4. Ordina per data di fine destinazione crescente per mostrare prima le scadenze imminenti.

Creare il slicer a pulsante per la selezione dello stato

1. Aggiungere un oggetto visivo slicer a pulsante.

2. Nel campo Valori aggiungere Status Options[Status].

3. Nel campo Etichetta aggiungere FIRST(Status Options[Description]) per visualizzare la descrizione sotto ogni stato.

4. Nel riquadro Formato :

   • Impostare Stile su Schede.
   • Impostare Orientamento su Orizzontale.
   • Impostare Max tiles su 5 (uno per ogni stato).

5. Configurare la formattazione condizionale per colorare ogni scheda in base al Status Color campo.

6. Impostare il titolo su 2) Selezionare un nuovo stato.

Aggiungi selettori di input per le note

1. Aggiungere un slicer di input che consenta agli utenti di immettere note sull'aggiornamento dello stato.

2. Impostare il titolo su 3) Aggiungere note per questo aggiornamento dello stato.

3. Aggiungere un altro filtro dei dati di input per il campo del messaggio usato dal pulsante di aggiornamento dello stato della richiesta.

4. Impostare il titolo su Oppure inviare un messaggio al canale teams.

Aggiungere la tabella di anteprima

1. Aggiungere un oggetto visivo Tabella con una singola colonna: la [Preview of status update] misura.

2. Impostare il titolo su Anteprima aggiornamento.

Questo mostra agli utenti l'aspetto della notifica di Teams prima di inviarla.

Aggiungere i pulsanti della funzione dati

Aggiungere due pulsanti: uno per l'aggiornamento dello stato e uno per richiedere un aggiornamento dello stato.

Pulsante di aggiornamento stato

1. Nella scheda Inserisci, selezionare Pulsante funzione dati>.

2. Nel riquadro Formato configurare il testo del pulsante:

   • Imposta Testo predefinito sulla tua [Update status button text] misura per l'etichettatura dinamica.
   • Imposta testo disabilitato su testo statico come "Seleziona un progetto, un nuovo stato e aggiungi le note".

3. Selezionare la funzione pubblicata update_project_status.

4. Mappare i parametri della funzione:

   Parametro	Tipo di collegamento	Associato a
   projectId	Misura	[Selected project id] Misura
   newStatus	Slicer	Oggetto visivo selezione pulsanti (cancellazione automatica abilitata)
   updatedBy	Misura	[Updated by] Misura
   notes	Slicer	Oggetto visivo filtro dei dati di input (deselezionato automaticamente)
   updatedDate	Misura	[Updated date] Misura

5. Nel riquadro Formato in Azione abilitare Aggiorna il report dopo l'esito positivo. Questa impostazione aggiorna automaticamente la pagina del report dopo l'esecuzione della funzione.

   Suggerimento

   Abilitare l'Auto-clear per i parametri del filtro dei dati, in modo che il pulsante del filtro e il testo delle note vengano reimpostati dopo che l'utente attiva la funzione.

Pulsante Richiedi aggiornamento dello stato

1. Aggiungere un'altra funzione Button>Data.

2. Nel riquadro Formato configurare il testo del pulsante:

   • Imposta testo predefinito su un testo statico come "Invia messaggio di Teams al canale".
   • Impostare Testo disabilitato su "Selezionare un progetto e digitare prima un messaggio".

3. Selezionare la funzione pubblicata request_status_update.

4. Mappare i parametri della funzione:

   Parametro	Tipo di collegamento	Associato a
   projectId	Misura	[Selected project id] Misura
   requestedBy	Misura	[Updated by] Misura
   message	Slicer	Oggetto visivo filtro dei dati di input (deselezionato automaticamente)

5. Facoltativamente, abilitare Aggiorna il report dopo l'esito positivo nel riquadro Formato in Azione.

Configurare il testo del pulsante dinamico

Usare il testo dinamico nei pulsanti della funzione dati per mostrare agli utenti esattamente l'azione che si verificherà quando selezionano il pulsante. Invece di un'etichetta generica come "Aggiorna", il pulsante può visualizzare testo specifico del contesto, ad esempio "Aggiorna lo stato di Session ABC to In Progress".

Per configurare il testo del pulsante dinamico:

1. Creare una misura per generare l'etichetta del pulsante. Ad esempio, questa misura combina il nome del progetto selezionato e il nuovo stato:

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

2. Nel riquadro Formato per il pulsante della funzione dati, espandi Pulsante>Testo.

3. Impostare Testo predefinito sulla misura dinamica ([Update status button text]).

4. Impostare Testo disabilitato come testo statico che indica agli utenti quali selezioni sono necessarie (ad esempio, "Selezionare un progetto, un nuovo stato e aggiungere le note prima").

Il pulsante visualizza il testo disabilitato fino a quando tutti i parametri obbligatori non hanno valori. Quando l'utente effettua le selezioni, il pulsante mostra il testo dinamico che descrive l'azione specifica.

(Facoltativo) Aggiungere un pulsante e una pagina drill-through

È possibile aggiungere una pagina di drill-through per visualizzare la cronologia completa degli aggiornamenti dello stato per un progetto selezionato.

1. Nella scheda Inserisci, selezionare Pulsante>Vuoto.

2. Nel riquadro Formato in Pulsante impostare il testo:

   • Testo predefinito: "Visualizza tutti gli aggiornamenti dello stato"
   • Testo disabilitato: "Selezionare un progetto per visualizzare tutti gli aggiornamenti dello stato"

3. In Azione abilitare l'azione e impostare:

   • Tipo: Drillthrough
   • Destinazione: selezionare la pagina della cronologia dello stato (creata nei passaggi successivi)

4. Aggiungere una nuova pagina e denominarla Cronologia aggiornamenti stato.

5. Nel riquadro Formato per la pagina, espandere Informazioni sulla pagina e abilitare Drillthrough. Aggiungere Project[Product name] come campo drill-through.

6. Aggiungere oggetti visivi per visualizzare la cronologia dello stato:

   • Carta: numero totale di aggiornamenti dello stato
   • Suddivisore dei pulsanti: Suddivisione per stato
   • Tabella: tutti gli aggiornamenti dello stato (ID aggiornamento, Data aggiornata, Stato, Note, Aggiornato da)
   • Grafico a linee: aggiornare l'attività nel tempo

7. Aggiungere un pulsante Indietro in modo che gli utenti possano tornare alla pagina principale del report. Nella scheda Inserisci seleziona Pulsante>Indietro.

Pubblicare il report

1. Salvare il report e pubblicarlo nel servizio Power BI.

2. Copiare l'URL del report e aggiungerlo alla libreria di variabili come POWERBI_REPORT_URL.

Testare il flusso di lavoro

Testare il flusso di aggiornamento dello stato della richiesta

Dopo la pubblicazione, è possibile usare il flusso di attività translitica per richiedere un aggiornamento dello stato:

1. Selezionare un progetto da aggiornare : selezionare una riga di progetto nella tabella per impostare il contesto di filtro.

2. In alternativa, inviare un messaggio al canale teams : immettere un messaggio nel filtro dei dati di input, ad esempio "È possibile ottenere un aggiornamento in questo caso?".

3. Selezionare il pulsante Invia messaggio di Teams al canale.

4. Quando l'azione viene completata correttamente, viene visualizzata una richiesta di conferma inviata .

5. Controlla il canale di Teams per l'Adaptive Card Aggiornamento dello stato del progetto con i dettagli della richiesta.

6. Il proprietario del progetto può selezionare Aggiorna stato progetto nella scheda adattiva per aprire il report e aggiornare il relativo stato.

Testare il flusso di stato dell'aggiornamento

Dopo la pubblicazione, è possibile usare il flusso di attività translitica per aggiornare lo stato di un progetto:

1. Selezionare un progetto da aggiornare : selezionare una riga di progetto nella tabella per impostare il contesto di filtro.

2. Qual è il nuovo stato? - Utilizzare il selettore a pulsante per selezionare un nuovo stato (ad esempio, In corso).

3. Aggiungere note per questo aggiornamento dello stato: immettere le note nel cursore di input, ad esempio "Started to record demo".

4. Selezionare il pulsante Aggiorna per scrivere indietro la modifica dello stato nel lakehouse e inviare una notifica su Teams.

5. Quando l'azione viene completata correttamente, viene visualizzata una richiesta di conferma inviata .

6. Controllare il canale Teams per la scheda adattiva Aggiornamento dello Stato del Progetto con i dettagli della modifica dello stato.

Contenuti correlati

Flussi di attività translitiche

• Comprendere i flussi di attività translitiche
• Esercitazione: Creare un flusso di attività translitica
• Creare un pulsante della funzione dati in Power BI

Visualizzazioni del report

• Creare pulsanti nei report di Power BI
• Usare il slicer a pulsanti
• Usare l'oggetto visivo filtro dei dati di input

Funzioni DAX

• Funzione SELECTEDVALUE (DAX)
• Funzione USERPRINCIPALNAME (DAX)

Dati dell'infrastruttura

• Panoramica delle funzioni dati utente
• Creare funzioni dati utente
• Connettere le funzioni relative ai dati degli utenti alle origini dati
• Creare e gestire librerie di variabili
• Panoramica del database SQL Fabric
• Panoramica di Lakehouse
• Panoramica di Direct Lake
• Panoramica delle viste sul lago materializzate

Microsoft Teams

• Creare un webhook in arrivo in Teams
• Adaptive Cards