Tutorial: Criar um fluxo de trabalho de atualização de status

Neste tutorial de ponta a ponta, você cria um fluxo de tarefas translítico que rastreia o status do projeto, grava atualizações de volta em um banco de dados e posta notificações de um relatório do Power BI no Microsoft Teams. A solução mantém um histórico completo de todas as atualizações de status, para que você possa acompanhar como o status do projeto foi alterado ao longo do tempo. Este tutorial demonstra como combinar escrita de retorno de dados com chamadas de API externas para estabelecer um fluxo completo de comunicação.

Neste tutorial, você aprenderá como:

Se você não tiver uma capacidade existente do Fabric, inicie uma avaliação do Fabric.

Pré-requisitos

• Power BI Desktop. Se você não tiver o Power BI Desktop instalado em seu dispositivo, siga as instruções em Obter o Power BI Desktop.
• Um canal do Microsoft Teams em que você tem permissão para adicionar webhooks de entrada.

Visão geral

Este tutorial cria uma solução de acompanhamento de projeto em que os usuários podem atualizar o status do projeto diretamente de um relatório do Power BI. Quando um usuário atualiza um status, o sistema:

1. Grava o novo status no banco de dados SQL, mantendo um histórico completo de todas as atualizações de status.
2. Envia uma notificação de cartão adaptável para o Microsoft Teams.
3. Atualiza o relatório para mostrar os dados atualizados.

Fluxo dos usuários

O fluxo de trabalho cria um loop de comentários contínuo entre os usuários do relatório:

1. Solicitar atualização de status via Teams a partir do relatório – um usuário seleciona um projeto no relatório e envia uma solicitação de atualização do status. A solicitação é posta no Teams com um link de volta para o relatório.

2. Receber notificação no Teams e abrir relatório — O proprietário do projeto vê a notificação no Teams e seleciona o link para abrir o relatório.

3. Atualizar o status no relatório — O proprietário do projeto seleciona o projeto, escolhe um novo status, adiciona anotações e seleciona o botão atualizar.

4. Veja a atualização em tempo real e envie notificação – o relatório é atualizado imediatamente para mostrar o novo status, e uma notificação é enviada para o Teams confirmando a alteração.

Arquitetura

A solução conecta esses componentes no Microsoft Fabric:

Os dados fluem em duas direções:

• Caminho de leitura: o Power BI lê do banco de dados SQL (via DirectQuery) ou Lakehouse (via Direct Lake) para exibir o status atual do projeto.
• Caminho de gravação de dados: quando um usuário seleciona um botão de função de dados, o Power BI chama a função de dados do usuário, que grava no banco de dados SQL e posta no Teams.

Criar um banco de dados SQL

Esse cenário usa dados de acompanhamento de projeto. Siga as etapas em Criar um banco de dados SQL no Fabric para criar um novo banco de dados SQL no workspace do Fabric.

Criar tabelas de banco de dados

1. No banco de dados SQL, abra uma nova janela de consulta.

2. Execute o seguinte script SQL para criar a tabela 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. Crie a tabela de atualizações de status para acompanhar as alterações de status ao longo do 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. Crie uma exibição que retorna o status mais recente para cada projeto:

   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. Inserir dados de projeto de exemplo:

   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. Inserir atualizações de status de exemplo:

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

Configurar uma biblioteca de variáveis

Uma biblioteca de variáveis armazena valores de configuração separadamente do código da função. Essa separação oferece um benefício fundamental: você pode atualizar valores como URLs de webhook ou links de relatório sem editar ou republicar suas funções de dados do usuário.

Por exemplo, se o canal do Teams for alterado ou você precisar apontar para um relatório diferente, atualize o valor da biblioteca de variáveis e a alteração entrará em vigor imediatamente — nenhuma alteração de código é necessária.

1. No workspace do Fabric, selecione + Novo item.

2. Role para baixo até a seção Desenvolver dados e selecione Biblioteca de variáveis.

3. Nomeie a biblioteca ProjectVariables de variáveis e selecione Criar.

4. Selecione + Nova variável e adicione as seguintes variáveis:

   Nome da variável	Tipo	Descrição
   TEAMS_WEBHOOK_URL	String	URL do webhook de entrada do Teams
   POWERBI_REPORT_URL	String	URL para seu relatório do Power BI (adicionado após a publicação)

5. Selecione Salvar depois de adicionar cada variável.

Obter uma URL de webhook do Teams

Siga as etapas em Criar um Webhook de entrada para criar um webhook para seu canal do Teams. Depois de criar o webhook, copie a URL e adicione-a à biblioteca de variáveis como TEAMS_WEBHOOK_URL.

Criar as funções de dados do usuário

Crie um item de funções de dados do usuário que lida com atualizações de status e notificações do Teams.

1. No workspace do Fabric, selecione + Novo item>Funções de Dados do Usuário.

2. Substitua o código padrão pelo seguinte código 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. Configure as conexões:

   • Selecione Configurações ou o painel de conexões.
   • Adicione conexão ProjectTrackingDb apontando para o Banco de Dados SQL do Fabric.
   • Adicione conexão ProjectVariables apontando para sua Biblioteca de Variáveis.

4. Selecione Publicar para implantar a função.

Entender a função update_project_status

A update_project_status função grava um novo registro de status no banco de dados SQL e envia uma notificação do Teams. Quando um usuário seleciona o botão atualizar no relatório, o seguinte fluxo ocorre:

1. O Power BI chama a função – o botão de função de dados passa parâmetros (ID do projeto, novo status, anotações etc.) para a função de dados do usuário.

2. Validar entradas – a função valida o formato de data e verifica se o valor do status é uma das opções permitidas.

3. Consultar o estado atual – A função recupera o status e o nome do projeto anteriores do banco de dados.

4. Inserir novo registro – uma nova linha é inserida na Status updates tabela com o novo status, carimbo de data/hora e anotações.

5. Enviar notificação do Teams – A função _send_teams_update auxiliar posta um Cartão Adaptável no canal do Teams mostrando a alteração de status.

6. Resultado de retorno – a função retorna uma mensagem de sucesso que o Power BI exibe ao usuário.

Compreender a função request_status_update

A request_status_update função envia uma notificação do Teams solicitando que um proprietário do projeto forneça uma atualização de status. Essa função não grava no banco de dados, apenas envia uma mensagem.

1. O Power BI chama a função – o botão de função de dados passa a ID do projeto, o nome do solicitante e a mensagem para a função.

2. Consultar detalhes do projeto – A função recupera o nome do projeto, o gerenciador de projetos e o status atual do banco de dados.

3. Enviar notificação do Teams – A função _send_status_request auxiliar posta um Cartão Adaptável no canal do Teams com os detalhes da solicitação e um botão Atualizar Status do Projeto que é vinculado novamente ao relatório.

4. Resultado de retorno – a função retorna uma mensagem de confirmação que o Power BI exibe ao usuário.

(Opcional) Configurar atalhos do Lakehouse para visões do Direct Lake

O Banco de Dados SQL do Fabric armazena todos os dados como tabelas Delta no OneLake, para que você possa criar um modelo semântico do Direct Lake diretamente nas tabelas do banco de dados SQL. No entanto, o Direct Lake não pode ler exibições de um banco de dados SQL , somente tabelas. Para usar uma exibição com o Direct Lake, crie atalhos para as tabelas do banco de dados SQL em um Lakehouse e defina a exibição lá.

Criar atalhos para as tabelas do banco de dados SQL

1. No workspace do Fabric, crie um novo Lakehouse e habilite esquemas.

2. No Lakehouse Explorer, clique com o botão direito do mouse em qualquer esquema (como dbo) e selecione Novo atalho de tabela.

3. No Catálogo do OneLake, navegue até o banco de dados SQL e selecione a tabela Project.

4. Repita para criar um atalho para a Status updates tabela.

Os atalhos fornecem acesso de leitura às tabelas Delta subjacentes sem duplicar dados.

Criar uma exibição materializada do lago

Crie uma vista de lago materializada no Lakehouse, que computa o status mais recente para cada projeto.

1. No Lakehouse, selecione Gerenciar vistas materializadas do lago (versão prévia).

2. Abra um novo bloco de anotações com o Spark SQL.

3. Execute a seguinte consulta:

   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. Agende a atualização do modo de exibição selecionando Agendas>Ativadas e definindo a frequência.

Criar o relatório do Power BI

Você pode se conectar aos seus dados usando DirectQuery ou Direct Lake:

• DirectQuery para Banco de Dados SQL: os dados em tempo real dão suporte a write-back por meio de funções de dados do usuário.
• Tabelas do Direct Lake to SQL Database: o Banco de Dados SQL do Fabric armazena dados como tabelas Delta no OneLake, para que o Direct Lake possa ler tabelas diretamente.
• Direct Lake via Lakehouse (para exibições): o Direct Lake não pode ler exibições do Banco de Dados SQL. Para usar exibições com o Direct Lake, crie atalhos para as tabelas do banco de dados SQL em um Lakehouse e defina as exibições materializadas do lago lá.

Opção A: conectar-se via DirectQuery

1. Abra Power BI Desktop.

2. Selecione o catálogo do OneLake.

3. Localize o banco de dados SQL do Fabric.

4. Selecione Conectar ao endpoint de analítica SQL.

5. Selecione as tabelas/visão Project, Status updates e Project status.

6. Quando solicitado para o modo de armazenamento, selecione DirectQuery.

Opção B: conectar-se via Direct Lake (para desempenho de análise)

1. No serviço do Power BI, selecione Criar catálogo do>OneLake.

2. Encontre seu Lakehouse.

3. Selecione as tabelas de atalho (Project, Status updates) e a exibição materializada do lago (project_status).

4. Edite o modelo semântico na experiência de modelagem da Web para adicionar medidas e relações.

Criar a tabela calculada de Opções de Status

Crie uma tabela calculada que forneça os valores de status para a segmentação de botão. Execute este script TMDL no 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" }
				    }
				)

Criar medidas de suporte

Crie uma tabela calculada para manter as métricas que dão suporte aos botões de funcionalidades de dados. Execute este script TMDL no 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}

Essas medidas atendem a várias finalidades:

Criar o relatório

O layout do relatório orienta os usuários por meio de um fluxo de trabalho claro: selecione um projeto, escolha um novo status, adicione anotações e execute a atualização.

Criar a tabela do projeto

1. Adicione um visual de tabela para exibir informações do projeto.

2. Adicione estas colunas de seus dados:

   • Product name
   • Project name
   • Target end date
   • Description
   • Latest status (na tabela ou exibição de status ou status do Projeto)
   • Latest notes

3. Defina o título como 1) Escolha um projeto a ser atualizado.

4. Classificar por data final de destino em ordem crescente para mostrar primeiramente os próximos prazos.

Criar o seletor de botão para seleção de status

1. Adicione um visual de segmentação de botão.

2. No campo Valores , adicione Status Options[Status].

3. No campo Rótulo , adicione FIRST(Status Options[Description]) para mostrar a descrição abaixo de cada status.

4. No painel Formatar :

   • Definir Estilo como Cartões.
   • Defina a Orientação como Horizontal.
   • Defina blocos máximos como 5 (um para cada status).

5. Configure a formatação condicional para colorir cada cartão pelo Status Color campo.

6. Defina o título como 2) Escolha um novo status.

Adicionar segmentadores de entrada para anotações

1. Adicione um filtro de entrada para que os usuários possam inserir anotações sobre a atualização de status.

2. Defina o título como 3) Adicione anotações para esta atualização de status.

3. Adicione outro filtro de entrada para o campo de mensagem usado pelo botão de atualização de status da solicitação.

4. Defina o título como Ou envie uma mensagem para o canal do Teams.

Adicionar a tabela de visualização

1. Adicione uma visualização Table com uma única coluna: a [Preview of status update] medida.

2. Defina o título como Visualizar atualização.

Isso mostra aos usuários como será a notificação do Teams antes de enviá-la.

Adicionar os botões de função de dados

Adicione dois botões: um para atualizar o status e outro para solicitar uma atualização de status.

Botão Atualizar status

1. Na guia Inserir, selecionea função Dados do >.

2. No painel Formatar , configure o texto do botão:

   • Defina o texto padrão como sua [Update status button text] medida para rotulagem dinâmica.
   • Defina o texto desabilitado como texto estático, como "Escolher um projeto, novo status e adicionar anotações primeiro".

3. Selecione sua função publicada update_project_status .

4. Mapeie os parâmetros de função:

   Parâmetro	Tipo de associação	Associado a
   projectId	Medida	[Selected project id] Medida
   newStatus	Cortador	Slicer de botão visual (auto-limpeza ativada)
   updatedBy	Medida	[Updated by] Medida
   notes	Cortador	Visual de filtro de entrada (auto-limpeza ativada)
   updatedDate	Medida	[Updated date] Medida

5. No painel Formatar em Ação, habilite Atualizar o relatório após o resultado bem-sucedido. Essa configuração atualiza automaticamente a página do relatório depois que a função é executada com êxito.

   Dica

   Habilite a limpeza automática para parâmetros do fatiador, assim o fatiador de botão e o texto de notas serão redefinidos após o usuário acionar a função.

Botão Solicitar atualização de status

1. Adicione outra botão>função de dados.

2. No painel Formatar , configure o texto do botão:

   • Defina o texto padrão como texto estático, como "Enviar mensagem do Teams para o canal".
   • Defina o texto desabilitado como "Escolha um projeto e digite uma mensagem primeiro".

3. Selecione sua função publicada request_status_update .

4. Mapeie os parâmetros de função:

   Parâmetro	Tipo de associação	Associado a
   projectId	Medida	[Selected project id] Medida
   requestedBy	Medida	[Updated by] Medida
   message	Cortador	Visual de filtro de entrada (auto-limpeza ativada)

5. Opcionalmente, habilite Atualizar o relatório após o resultado bem-sucedido no painel Formatar em Ação.

Configurar texto do botão dinâmico

Use texto dinâmico nos botões de função de dados para mostrar aos usuários exatamente qual ação ocorrerá quando eles selecionarem o botão. Em vez de um rótulo genérico como "Atualizar", o botão pode exibir texto específico do contexto, como "Atualizar o status da Sessão ABC para Em Andamento".

Para configurar o texto do botão dinâmico:

1. Crie uma medida que gere o rótulo do botão. Por exemplo, essa medida combina o nome do projeto selecionado e o novo status:

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

2. No painel Formatar para o botão de função de dados, expanda Botão>Texto.

3. Defina o texto padrão como sua medida dinâmica ([Update status button text]).

4. Defina o texto desabilitado como texto estático que informa aos usuários quais seleções são necessárias (por exemplo, "Escolher um projeto, novo status e adicionar anotações primeiro").

O botão exibe o texto desabilitado até que todos os parâmetros necessários tenham valores. Depois que o usuário faz suas seleções, o botão mostra o texto dinâmico que descreve a ação específica.

(Opcional) Adicionar um botão de detalhamento e uma página

Você pode adicionar uma página de detalhamento para mostrar o histórico completo de atualizações de status para um projeto selecionado.

1. Na guia Inserir , selecione Botão>Em Branco.

2. No painel Formatar , em Botão, defina o texto:

   • Texto padrão: "Ver todas as atualizações de status"
   • Texto desabilitado: "Escolha um projeto para ver todas as atualizações de status"

3. Em Ação, habilite a ação e defina:

   • Tipo: Detalhamento
   • Destino: selecione sua página de histórico de status (criada nas próximas etapas)

4. Adicione uma nova página e nomeie-a como histórico de atualização de status.

5. No painel Formatar da página, expanda Informações da página e habilite Drillthrough. Adicione Project[Product name] como o campo de detalhamento.

6. Adicione visuais para exibir o histórico de status:

   • Cartão: Contagem total de atualizações de status
   • Fatiador de botões: detalhamento por status
   • Tabela: Todas as atualizações de status (ID da atualização, data atualizada, status, anotações, atualizadas por)
   • Gráfico de linhas: atualizar a atividade ao longo do tempo

7. Adicione um botão Voltar para que os usuários possam retornar à página principal do relatório. Na guia Inserir , selecione Botão>Voltar.

Publicar o relatório

1. Salve seu relatório e publique-o no serviço do Power BI.

2. Copie a URL do relatório e adicione-a à biblioteca de variáveis como POWERBI_REPORT_URL.

Testar o fluxo de trabalho

Testar o fluxo de atualização de status da solicitação

Depois de publicado, você pode usar o fluxo de tarefas translytical para solicitar uma atualização de status:

1. Escolha um projeto para atualizar – selecione uma linha de projeto na tabela para definir o contexto do filtro.

2. Ou envie uma mensagem para o canal do Teams – Digite uma mensagem no campo de entrada (por exemplo, "Podemos obter uma atualização sobre isso?").

3. Selecione o botão Enviar mensagem das equipes para o canal.

4. Uma confirmação de solicitação enviada é exibida quando a ação é concluída com êxito.

5. Verifique o canal do Teams para obter o Cartão Adaptável de Atualização de Status do Projeto com os detalhes da solicitação.

6. O proprietário do projeto pode selecionar Atualizar o Status do Projeto no Cartão Adaptável para abrir o relatório e atualizar seu status.

Teste o fluxo do status de atualização

Depois de publicado, você pode usar o fluxo de tarefas translytical para atualizar um status do projeto:

1. Escolha um projeto para atualizar – selecione uma linha de projeto na tabela para definir o contexto do filtro.

2. Qual é o novo status? - Use o fatiador de botão para selecionar um novo status (por exemplo, Em Andamento).

3. Adicionar anotações para esta atualização de status – insira anotações no seletor de entrada (por exemplo, "Começou a gravar demo").

4. Selecione o botão Atualizar para gravar a alteração de status novamente no lakehouse e enviar uma notificação do Teams.

5. Uma confirmação de solicitação enviada é exibida quando a ação é concluída com êxito.

6. Verifique o canal do Teams para obter o Cartão Adaptável de Atualização de Status do Projeto com os detalhes de alteração de status.

Conteúdo relacionado

Fluxos de tarefas transanalíticas

• Entender fluxos de tarefas translyticais
• Tutorial: Criar um fluxo de tarefas translytical
• Criar um botão de função de dados no Power BI

Visuais de relatório

• Criar botões em relatórios do Power BI
• Usar o visual da segmentação de botão
• Usar o visual do slicer de dados

Funções DAX

• Função SELECTEDVALUE (DAX)
• Função USERPRINCIPALNAME (DAX)

Dados de estrutura

• Visão geral das funções de dados do usuário
• Criar funções de dados do usuário
• Conectar funções de dados do usuário a fontes de dados
• Criar e gerenciar bibliotecas de variáveis
• Visão geral do Banco de Dados SQL do Fabric
• Visão geral do Lakehouse
• Visão geral do Direct Lake
• Visão geral das vistas materializadas do lago

Equipes da Microsoft

• Criar um webhook de entrada no Teams
• Cartões Adaptáveis