Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Important
- Il s’agit d’une fonctionnalité d’évaluation prête pour la production.
- Les versions préliminaires prêtes pour la production sont soumises à des conditions d’utilisation supplémentaires.
La fonctionnalité de saisie des notes de frais de l’agent de gestion du temps et des dépenses rassemble les fonctionnalités de Microsoft Dynamics 365 Project Operations, des applications financières et opérationnelles, de Microsoft Copilot Studio, de Microsoft Power Automate et de Microsoft Dataverse pour automatiser les flux de travail de traitement des dépenses à l’aide de l’IA. L’Expense Agen permet à votre système de traiter les reçus et de générer des lignes de dépenses et des rapports pour les utilisateurs afin de gagner du temps et de réduire les efforts manuels. Il utilise les connecteurs Microsoft Power Platform pour s’intégrer à Outlook, Microsoft Teams, aux calendriers des utilisateurs et à l’environnement des applications financières et opérationnelles via des entités virtuelles Dataverse.
La fonctionnalité de saisie des notes de frais de l’Agent de gestion du temps et des notes de frais comprend plusieurs flux, dont trois servent d’orchestrateurs principaux :
- Traiter les e-mails – Analyse un dossier de boîte aux lettres configuré toutes les heures et stocke les pièces jointes en tant qu’accusés de réception non joints dans Dynamics 365 Finance.
- Extraire les ID de reçu – Collecte les reçus récemment ajoutés et déclenche l’extraction des détails par l’assistant.
- Traiter la note de frais – Convertit les données de réception extraites en lignes de dépenses structurées et génère des rapports, en fonction de la configuration définie dans l’application.
L’agent prend également en charge l’intégration de Teams qui vous permet d’envoyer des cartes adaptatives pour l’examen et la soumission des dépenses.
L’agent s’appuie sur plusieurs connecteurs Power Platform. Ces connecteurs sont automatiquement référencés dans les flux Microsoft Power Automate fournis :
- Outlook (Office 365) – Accède à la boîte aux lettres partagée pour récupérer les accusés de réception.
- Dataverse (entités virtuelles) – S’intègre aux entités Dynamics 365 Finance and Operations.
- Microsoft Copilot Studio – Invoque des modèles d’IA pour extraire les informations de reçu.
- Microsoft Teams : envoie des cartes adaptatives pour les interactions utilisateur (si l’intégration de Teams est activée).
- Utilisateurs Microsoft 365 – Récupère les détails du calendrier de l’utilisateur (facultatif, si l’analyse des reçus tient compte du contexte).
L’installation et la configuration de la fonctionnalité de saisie des notes de frais de l’Agent de gestion du temps et des dépenses impliquent les étapes suivantes :
- Installez Copilot pour les applications de finance et d’opérations.
- Activez l’agent dans Dynamics 365 Finance and Operations.
- Créez un compte utilisateur de dépenses pour permettre à l'agent de s'exécuter.
- Attribuez des autorisations dans les applications Finance et Opérations et Dataverse.
- Configurez une boîte aux lettres partagée pour la collecte de reçus par e-mail.
- Configurez et paramétrez l’agent, manuellement ou à l’aide de Windows PowerShell.
- Activez l’intégration de Microsoft Teams (facultatif).
Chacune de ces étapes est décrite en détail dans les sections qui suivent.
Conditions préalables
Pour effectuer les étapes décrites dans cet article, vous devez disposer d’un accès administrateur système ou personnalisateur système dans le centre d’administration Power Platform, d’un accès administrateur système dans les applications Finance et opérations et d’un accès administrateur Exchange dans Microsoft 365 pour configurer la boîte aux lettres partagée. Si vous envisagez d’activer l’intégration de Teams, vous avez également besoin des autorisations requises dans le centre d’administration Teams.
Étape 1 : Installer Copilot pour les applications Finance et Opérations
La fonctionnalité de saisie des notes de frais de l’agent de gestion du temps et des dépenses est fournie dans le cadre du package Copilot pour les finances et les opérations . Une fois ce package installé dans votre environnement, toutes les ressources requises, y compris l’agent, les variables d’environnement et les flux Power Automate, sont automatiquement disponibles.
Pour en savoir plus sur l’activation de Copilot dans votre environnement, consultez la section Activer les fonctionnalités de Copilot dans les applications Finance et Opérations.
Étape 2 : Activer l’agent dans les applications Finance et Opérations
Pour activer l’agent dans les applications Finance et Opérations, procédez comme suit.
- Après avoir installé le package, activez la fonctionnalité de saisie des notes de frais de l’Agent de gestion des temps et des dépenses à partir de l’application Web des finances et des opérations.
- Accédez à la gestion des fonctionnalités et assurez-vous que la gestion des agents est activée.
- Allez dans Configuration de la gestion des >> dépenses, Paramètres > de gestion des dépenses, Agent de dépenses.
- Activez l’agent pour l’entité juridique actuelle et configurez la fréquence d’exécution comme quotidienne ou hebdomadaire. Vous pouvez également choisir de regrouper les dépenses par trajet ou par projet à l’aide du paramètre de groupe de dépenses par .
Étape 3 : Configurer l’utilisateur de l’agent
Créez un utilisateur d’agent de dépenses dédié pour vous assurer que l’agent fonctionne indépendamment de l’identité d’un employé. Cela permet d’améliorer la sécurité, la facilité de gestion et la maintenabilité à long terme. Bien qu’il soit possible d’utiliser un compte d’utilisateur existant avec des privilèges suffisants, l’utilisation d’une identité appartenant au système est l’approche préférée.
A. Créer l’utilisateur Microsoft Azure Active Directory (Azure AD DS)
- Accédez au portail Azure et créez un utilisateur sous Microsoft Entra ID.
B. Ajouter l’utilisateur à l’environnement Power Platform
- Accédez au Centre d’administration Power Platform et sélectionnez l’environnement approprié.
- Sélectionnez Voir tous les utilisateurs, puis Ajouter un utilisateur, puis sélectionnez l’utilisateur d’agent nouvellement créé.
Chapitre C. Attribuer les rôles requis dans le centre d’administration Power Platform
- Dans le même centre d’administration Power Platform, sélectionnez l’environnement.
- Localisez l’utilisateur de l’agent et sélectionnez Gérer les rôles.
- Attribuez les rôles suivants :
- Personnalisateur de système
- Rôle de l’Assistant IA Dépenses
- Rôle de configuration de l’agent Finance and Operations
Ces rôles permettent d’accéder aux composants Dataverse et Power Automate nécessaires au fonctionnement de l’agent.
D. Attribuer un rôle d’administrateur système dans les applications Finance et Opérations
- Dans le portail Finance and Operations , accédez à Utilisateurs de l’administration > système.
- Créez un nouvel enregistrement pour l'utilisateur agent.
- Attribuez le rôle Administrateur système .
- Sélectionnez Enregistrer pour conserver la configuration.
Étape 4 : Accorder les autorisations aux utilisateurs
Pour configurer et exécuter correctement la fonctionnalité de saisie des notes de frais de l’agent de gestion des temps et des dépenses, l’utilisateur de l’agent désigné doit disposer des autorisations suivantes :
Rôles financiers et opérationnels
- Administrateur système
Requis pour permettre à l’agent de créer et de gérer des entrées de dépenses dans l’environnement Finance et Opérations.
Rôles dans Dataverse
- Personnalisateur de système
- Rôle de l’Assistant IA Dépenses
- Rôle de configuration de l’agent Finance and Operations
Ces rôles permettent à l’agent d’interagir avec les flux Power Automate, les variables d’environnement et les entités virtuelles connectées à Dynamics 365 Finance.
Accès à la boîte aux lettres partagée
L’utilisateur de l’agent doit également disposer de l’autorisation Microsoft Graph Mail.Shared.Read qui permet à l’agent de lire les accusés de réception de la boîte aux lettres partagée configurée pendant l’exécution du flux.
Étape 5 : Configurer la boîte aux lettres partagée
La fonction de saisie des notes de frais de l’agent de gestion des temps et des dépenses utilise une boîte aux lettres partagée pour recevoir les e-mails de réception. Cette boîte aux lettres doit être créée et configurée dans le Centre d’administration Microsoft 365 par un utilisateur disposant du rôle Administrateur Exchange .
Pour créer et configurer la boîte aux lettres partagée, procédez comme suit.
- Accédez au Centre d’administration Microsoft 365 et connectez-vous avec un compte d’administrateur Exchange.
- Dans le volet de navigation de gauche, sélectionnez Boîtes aux lettres partagées Teams et groupes>.
Si vous ne le voyez pas immédiatement, sélectionnez Afficher tout pour développer la liste. - Sélectionnez Ajouter une boîte aux lettres partagée.
- Entrez un nom et une adresse e-mail pour la boîte aux lettres partagée.
Format recommandé :expenseagent@contoso.com - Sélectionnez Enregistrer les modifications. Il peut s’écouler quelques minutes avant que la gestion des membres ne soit disponible.
- Sous Étapes suivantes, choisissez Ajouter des membres à cette boîte aux lettres.
- Sélectionnez l’utilisateur de l’agent (et toute autre personne qui doit surveiller la boîte aux lettres), puis sélectionnez Ajouter et fermer.
Une fois la boîte aux lettres configurée, indiquez son adresse e-mail et le chemin d’accès au dossier (par défaut : Boîte de réception) en tant que variables d’environnement lors de la configuration de l’agent de dépenses.
Étape 6 : Configurer la fonction de saisie des notes de frais de l’agent de gestion des temps et des dépenses
Vous pouvez configurer la fonction de saisie des notes de frais de l’agent de gestion des temps et des dépenses à l’aide de l’une des deux options suivantes :
- Option 1 : Utilisation d’un script PowerShell (recommandé)
- Option 2 : Configuration manuelle à l’aide de Maker Portal (pas de PowerShell)
Option 1 : Utilisation du script PowerShell (recommandé)
La configuration manuelle de l’agent implique la création et la liaison de connexions, l’activation des flux Power Automate et la publication de la solution, un processus qui peut prendre du temps et être source d’erreurs. Vous pouvez utiliser un script PowerShell et un fichier de configuration (AgentConfig.json) pour automatiser la configuration.
Le script PowerShell automatise :
- Mise à jour des variables d’environnement requises.
- Liaison des connexions Power Platform aux références de connexion de solution.
- Activation de tous les flux Power Automate requis par l’agent de dépenses.
- Publication des assistants Copilot.
- Publication de la solution Dataverse.
Exemple de fichier de configuration (AgentConfig.json)
Avant d’exécuter le script, configurez le fichier avec des valeurs pertinentes pour votre environnement :
"modules": {
"Expense": {
"environmentVariables": {
"msdyn_ExpenseFnoInstanceUrl": "https://xxxxx.operations.dynamics.com",
"msdyn_ExpenseAgentOutlookFolderPath": "Inbox",
"msdyn_ExpenseAgentMailboxAddressId": "NA"
},
"connectors": [
{
"Name": "shared_commondataserviceforapps",
"id": "",
"connectionRefName": "msdyn_sharedcommondataserviceforapps_2c2d4",
"DisplayName": "Dataverse"
},
{
"Name": "shared_teams",
"id": "",
"connectionRefName": "msdyn_sharedteams_8ea9c",
"DisplayName": "Microsoft Teams"
},
{
"Name": "shared_office365",
"id": "",
"connectionRefName": "msdyn_sharedoffice365_9b471",
"DisplayName": "Office 365 Outlook"
},
{
"Name": "shared_office365users",
"id": "",
"connectionRefName": "msdyn_sharedoffice365users_909b9",
"DisplayName": "Office 365 Users"
},
{
"Name": "shared_microsoftcopilotstudio",
"id": "",
"connectionRefName": "msdyn_sharedmicrosoftcopilotstudio_26d9d",
"DisplayName": "Microsoft Copilot Studio"
}
],
"flows": [
"expense entry retry check",
"expense configuration",
"get expense outlook folder",
"generate expense report",
"send expense report adaptive card",
"process emails",
"extract unattached receipt ids for copilot invocation",
"extract unattached receipt output using dataverse plugin",
"generate expense line",
"generate expense line without project id and status id",
"identify project ids",
"user calender events",
"process expense report using copilot"
],
"agents":[
"msdyn_ExpenseEntryAgent",
"msdyn_ExpenseReportAgent"
]
}
}
}
Créer les connexions
Pour créer les connexions, procédez comme suit.
- Accédez au portail Power Apps Maker et sélectionnez votre environnement.
- Accédez à Connexions.
- Sélectionnez Nouvelle connexion et sélectionnez le connecteur approprié (par exemple, Outlook, Teams, etc.).
- Une fois créé, copiez l’ID de connexion et collez-le dans le fichier AgentConfig.json sous l’entrée de connecteur appropriée.
Exécuter le script
Une fois votre configuration prête, exécutez le script suivant après avoir inséré les variables d’environnement requises :
Param(
[Parameter(Mandatory=$true, HelpMessage="Dataverse environment id")]
[string]$environmentId = "",
[Parameter(Mandatory=$true, HelpMessage="Dataverse environment URL")]
[string]$dataverseUrl = "",
[Parameter(Mandatory=$true, HelpMessage="Config Module Name")]
[string]$ConfigModuleName = ""
)
# Install the required modules if not already installed
if (-not (Get-Module -ListAvailable -Name Microsoft.PowerApps.PowerShell)) {
Install-Module -Name Microsoft.PowerApps.PowerShell -AllowClobber -Scope CurrentUser
}
if (-not (Get-Module -ListAvailable -Name Microsoft.PowerApps.Administration.PowerShell)) {
Install-Module -Name Microsoft.PowerApps.Administration.PowerShell -AllowClobber -Scope CurrentUser
}
# Install the required modules if not already installed
if (-not (Get-Module -ListAvailable -Name Az.Accounts)) {
Install-Module -Name Az.Accounts -AllowClobber -Scope CurrentUser
}
# Import required modules
Import-Module Az.Accounts
Import-Module Microsoft.PowerApps.PowerShell
Import-Module Microsoft.PowerApps.Administration.PowerShell
# global variable declaration
$filter = '$filter'
# Function to authenticate interactively and retrieve an access token
function Get-AccessToken {
Write-Host "Authenticating interactively..." -ForegroundColor Green
# Retrieve the access token for the Dataverse environment
$accessToken = (Get-AzAccessToken -ResourceUrl "$dataverseUrl").Token
Write-Host "Access token retrieved successfully." -ForegroundColor Green
return $accessToken
}
# update the enviornment from user input
function Update-EnvironmentVariables {
param (
[string]$accessToken # Access token for authentication
)
write-host "Updating environment variables..." -ForegroundColor Yellow
foreach ($key in $environmentVariables.PSObject.Properties.Name) {
$value = $environmentVariables.$key
Write-Host "Updating environment variable: $key with value: $value" -ForegroundColor Yellow
# Get the environment variable definition
$envVarDefinition = Invoke-RestMethod -Method Get -Uri "$dataverseUrl/api/data/v9.2/environmentvariabledefinitions?$filter=schemaname eq '$key'" -Headers @{
Authorization = "Bearer $accessToken"
}
if ($envVarDefinition.value -ne $null) {
$envVarDefId = $envVarDefinition.value[0].environmentvariabledefinitionid
# Get the environment variable value record
$filterValue = [System.Web.HttpUtility]::UrlEncode("_environmentvariabledefinitionid_value eq $envVarDefId")
$envVarValue = Invoke-RestMethod -Method Get -Uri "$dataverseUrl/api/data/v9.2/environmentvariablevalues?$filter=$filterValue" -Headers @{
Authorization = "Bearer $accessToken"
}
if ($envVarValue.value -ne $null) {
$envVarValueId = $envVarValue.value[0].environmentvariablevalueid
# Update the environment variable value
Invoke-RestMethod -Method Patch -Uri "$dataverseUrl/api/data/v9.2/environmentvariablevalues($envVarValueId)" -Headers @{
Authorization = "Bearer $accessToken"
"Content-Type" = "application/json"
} -Body (@{ value = $value } | ConvertTo-Json -Depth 1)
} else {
Write-Host "Environment variable value not found for $key. Skipping..." -ForegroundColor Red
}
} else {
Write-Host "Environment variable definition not found for $key. Skipping..." -ForegroundColor Yellow
}
}
}
# Function to publish the solution
function Publish-Solution {
param (
[string]$accessToken
)
Write-Host "Publishing All" -ForegroundColor Yellow
# Construct the API endpoint for publishing the solution
$uri = "$dataverseUrl/api/data/v9.2/PublishAllXml"
# Make the API call
try {
Invoke-RestMethod -Method Post `
-Uri $uri `
-Headers @{
Authorization = "Bearer $accessToken"
"Content-Type" = "application/json"
}
Write-Host "Publish All - Success!" -ForegroundColor Green
} catch {
Write-Host "Failed to publish. Error: $($_.Exception)" -ForegroundColor Red
}
}
function Get-FlowGuidByName {
param (
[string]$accessToken, # Access token for authentication
[string]$flowName # Name of the flow to search for
)
Write-Host "Retrieving GUID for flow: $flowName" -ForegroundColor Yellow
# Construct the API endpoint with a filter for the flow name
$encodedFlowName = [System.Web.HttpUtility]::UrlEncode($flowName)
$uri = "$dataverseUrl/api/data/v9.2/workflows?$filter=name eq '$encodedFlowName'"
try {
# Make the API call
$response = Invoke-RestMethod -Method Get `
-Uri $uri `
-Headers @{
Authorization = "Bearer $accessToken"
"Content-Type" = "application/json"
}
# Check if the flow was found
if ($response.value.Count -gt 0) {
$flow = $response.value[0]
Write-Host "Flow found: $($flow.name) with GUID: $($flow.workflowid)" -ForegroundColor Green
return $flow.workflowid
} else {
Write-Host "No flow found with the name: $flowName" -ForegroundColor Red
return $null
}
} catch {
Write-Host "Failed to retrieve flow GUID. Error: $($_.Exception.Message)" -ForegroundColor Red
return $null
}
}
# Function to activate a Power Automate flow
function Activate-Flow {
param (
[string]$dataverseUrl, # Dataverse environment URL
[string]$accessToken, # Access token for authentication
[string]$flowId # GUID of the flow to activate
)
Write-Host "Activating flow: $flowId" -ForegroundColor Yellow
# Construct the request body
$body = @{
"statecode" = 1 # Activated
"statuscode" = 2 # Activated
} | ConvertTo-Json -Depth 1 -Compress
# Construct the API endpoint
$uri = "$dataverseUrl/api/data/v9.2/workflows($flowId)"
# Make the API call
try {
Invoke-RestMethod -Method Patch `
-Uri $uri `
-Headers @{
Authorization = "Bearer $accessToken"
"Content-Type" = "application/json"
} `
-Body $body
Write-Host "Flow activated successfully." -ForegroundColor Green
} catch {
Write-Host "Failed to activate flow. Error: $($_.Exception.Message)" -ForegroundColor Red
}
}
function Get-ConnectionRefIdFromLogicalName {
param (
[string]$accessToken,
[string]$connectionRefLogicalName
)
$uri = "$dataverseUrl/api/data/v9.2/connectionreferences?$filter=connectionreferencelogicalname eq '$connectionRefLogicalName'"
$response = Invoke-RestMethod -Method Get `
-Uri $uri `
-Headers @{
Authorization = "Bearer $accessToken"
"Content-Type" = "application/json"
}
if ($response -ne $null) {
write-host "Connection reference id found: $($response.value[0].connectionreferenceid) " -ForegroundColor Green
return $response.value[0].connectionreferenceid
}
else {
Write-Host "No connection reference found for logical name: $connectionRefLogicalName" -ForegroundColor Red
return $null
}
}
# Function to update a connection reference with a connection ID
function Update-ConnectionReference {
param (
[string]$accessToken,
[string]$connectionRefName,
[string]$connectionId
)
Write-Host "Connection Update for connection reference: $connectionRefName with connection ID: $connectionId" -ForegroundColor Yellow
$connectionRefId = Get-ConnectionRefIdFromLogicalName -accessToken $accessToken -connectionRefLogicalName $connectionRefName
if ($connectionRefId -eq $null) {
Write-Host "Connection reference not found for logical name: $connectionRefName" -ForegroundColor Red
return
}
else {
Write-Host "Connection reference ID: $connectionRefId" -ForegroundColor Green
}
$body = @{
"connectionid" = "$connectionId"
} | ConvertTo-Json -Depth 1
$uri = "$dataverseUrl/api/data/v9.2/connectionreferences($connectionRefId)"
write-host "Updating connection reference URI: $uri" -ForegroundColor Yellow
Invoke-RestMethod -Method Patch `
-Uri $uri `
-Headers @{
Authorization = "Bearer $accessToken"
"Content-Type" = "application/json"
} `
-Body $body
Write-Host "Connection reference updated successfully." -ForegroundColor Green
}
# Function iterate over connectionlist
function VerifyConnectorsExist {
param (
[array]$connectionList,
[string]$accessToken
)
$connectionNames = New-Object System.Collections.ArrayList
foreach ($connector in $connectors) {
$connectorName = $connector.Name
$connectorId = $connector.id
$connectionRefName = $connector.connectionRefName
# Write-Host "Verifying connector: $connectorName with id: $connectorId" -ForegroundColor Yellow
foreach ($connection in $connectionList) {
# Write-Host "Verifying connection: $connection" -ForegroundColor Yellow
$connectorNameFromList = $connection.ConnectorName
$connectionIdFromList = $connection.ConnectionId
$connectionNameFromList = $connection.ConnectionName
$statusesFromList = $connection.Statuses | ForEach-Object { $_.status }
Write-Host "connections connectorNameFromList: $connectorNameFromList with status: $statusesFromList and Id: $connectionIdFromList " -ForegroundColor Yellow
# Check if the name exists in the connection list and status is "Connected"
if ($connectorName -eq $connectorNameFromList -and $statusesFromList -contains "Connected") {
Write-Host "Connector $connectorName exists in the connection list with status 'Connected'." -ForegroundColor Green
# Check if the connector ID is not empty
if ($connectorId -ne "") {
Write-Host "Connector ID: $connectorId" -ForegroundColor Yellow
if ($connectionNameFromList -contains $connectorId) {
Write-Host "Matching connector ID found: $connectorId" -ForegroundColor Green
$connectionNames.Add(@($connectionNameFromList, $connectionRefName)) | Out-Null
$found = $true
break
}
} else {
Write-Host "Connector ID is empty for $connectorName. Using existing connection." -ForegroundColor Green
$connectionNames.Add(@($connectionNameFromList, $connectionRefName)) | Out-Null
$found = $true
break
}
}
}
if (-not $found) {
Write-Host "Connector $connectorName does not exist in the connection list or is not 'Connected'." -ForegroundColor Red
}
}
return $connectionNames
}
# Load configuration from JSON file
function Load-Configuration {
param (
[string]$configFilePath,
[string]$moduleName
)
if (-not (Test-Path $configFilePath)) {
Write-Host "Configuration file not found: $configFilePath" -ForegroundColor Red
throw "Configuration file not found."
}
$config = Get-Content -Path $configFilePath | ConvertFrom-Json
if (-not $config.modules.$moduleName) {
Write-Host "Module '$moduleName' not found in configuration." -ForegroundColor Red
throw "Module not found."
}
Write-Host "Configuration for module '$moduleName' loaded successfully." -ForegroundColor Green
return $config.modules.$moduleName
}
# check connections present
function Check-Connections {
param (
[string]$accessToken,
[string]$userId
)
Write-Host "Checking connections for environment id $environmentId" -ForegroundColor Yellow
# Get the list of existing connections
$connectionList = Get-PowerAppConnection -EnvironmentName $environmentId
# Verify if the connectors exist and are connected
$connectionOutput = VerifyConnectorsExist -connectionList $connectionList -accessToken $accessToken
if ($connectionOutput.Count -eq 0) {
Write-Host "No valid connections found. Please goto maker portal to create all the required connections." -ForegroundColor Red
exit(0)
} else {
if ($connectionOutput.Count -eq $connectors.Count) {
Write-Host "All the connectors are present" -ForegroundColor Green
} else {
Write-Host "$($connectionOutput.Count) out of $($connectors.Count) Present. Please goto maker portal to create all the required connections." -ForegroundColor Red
exit(0)
}
return $connectionOutput
}
}
function Link-ConnectionReferences {
param (
[string]$accessToken,
[array]$connectionOutput
)
foreach ($connection in $connectionOutput) {
$connectionName = $connection[0]
$connectionRefName = $connection[1]
Write-Host "connectionName $connectionName connectionRefName $connectionRefName." -ForegroundColor Yellow
# Update the connection reference with the connection ID
if ( $connectionRefName -ne "") {
Write-Host "Updating connection reference: $connectionRefName with connection ID: $connectionName" -ForegroundColor Yellow
Update-ConnectionReference -accessToken $accessToken -connectionRefName $connectionRefName -connectionId $connectionName
} else {
Write-Host "No connection reference found for logical name: $connectionRefName. Skipping the linkage" -ForegroundColor Yellow
}
}
}
function Activate-Flows {
param (
[string]$accessToken,
[array]$expenseAIFlows
)
foreach ($flowName in $expenseAIFlows) {
Write-Host "Retrieving GUID for flow: $flowName" -ForegroundColor Yellow
# Call the Get-FlowGuidByName function to get the flow GUID
$flowGuid = Get-FlowGuidByName -dataverseUrl $dataverseUrl -accessToken $accessToken -flowName $flowName
if ($flowGuid -ne $null) {
Write-Host "Flow Name: $flowName, Flow GUID: $flowGuid" -ForegroundColor Green
Activate-Flow -dataverseUrl $dataverseUrl -accessToken $accessToken -flowId $flowGuid
# Write-Host "Flow Name: $flowName, Flow GUID: $flowGuid Activated" -ForegroundColor Green
} else {
Write-Host "Flow Name: $flowName not found." -ForegroundColor Red
}
}
}
# Function to retrieve the Agent ID by name
function Get-AgentIdBySchemaName {
param (
[string]$dataverseUrl,
[string]$accessToken,
[string]$agentSchemaName
)
Write-Host "Retrieving agent ID for agent schema: $agentSchemaName" -ForegroundColor Yellow
# Construct the API endpoint to retrieve the bot
$uri = "$dataverseUrl/api/data/v9.2/bots?$filter=schemaname eq '$agentSchemaName'"
try {
# Make the API call
$response = Invoke-RestMethod -Method Get -Uri $uri -Headers @{
Authorization = "Bearer $accessToken"
"Content-Type" = "application/json"
}
if ($response.value.Count -gt 0) {
$agentId = $response.value[0].botid
Write-Host "Agent found: $agentSchemaName with ID: $agentId" -ForegroundColor Green
return $agentId
} else {
Write-Host "No agent found with the name: $agentSchemaName" -ForegroundColor Red
return $null
}
} catch {
Write-Host "Failed to retrieve agent ID. Error: $($_.Exception.Message)" -ForegroundColor Red
return $null
}
}
# Function to publish a PVA bot
function Publish-Agent {
param (
[string]$dataverseUrl,
[string]$accessToken,
[string]$agentId
)
Write-Host "Publishing agent with ID: $agentId" -ForegroundColor Yellow
# Construct the API endpoint for publishing the bot
$uri = "$dataverseUrl/api/data/v9.2/bots($agentId)/Microsoft.Dynamics.CRM.PvaPublish"
try {
# Make the API call
Invoke-RestMethod -Method Post -Uri $uri -Headers @{
Authorization = "Bearer $accessToken"
"Content-Type" = "application/json"
}
Write-Host "Agent published successfully!" -ForegroundColor Green
# Add 30 second delay to allow the publish process to complete
Start-Sleep -Seconds 30
} catch {
Write-Host "Failed to publish Agent. Error: $($_.Exception.Message)" -ForegroundColor Red
}
}
function Publish-Agents {
param (
[string]$accessToken,
[array]$agentSchemas
)
if (-not $agentSchemas -or $agentSchemas.Count -eq 0) {
Write-Host "No agent schemas provided. Skipping agent publishing." -ForegroundColor Yellow
return
}
foreach ($agentSchema in $agentSchemas) {
Write-Host "Publishing agent schema: $agentSchema" -ForegroundColor Yellow
try {
# Construct the API endpoint for publishing the agent schema
$agentId = Get-AgentIdBySchemaName -dataverseUrl $dataverseUrl -accessToken $accessToken -agentSchemaName $agentSchema
if ($agentId -ne $null) {
# Step 4: Publish the bot
Publish-Agent -dataverseUrl $dataverseUrl -accessToken $accessToken -agentId $agentId
} else {
Write-Host "Agent not found. Cannot proceed with publishing.Skipping the step" -ForegroundColor Yellow
}
}
catch {
Write-Host "An error occurred while publishing agent schema: $agentSchema. Error: $_" -ForegroundColor Red
}
}
}
# Main script execution
try {
# Step 0: Load Configuration
$configFilePath = ".\AgentConfig.json"
$moduleName = $ConfigModuleName # Change this to "Time" or "Approvals" as needed
$moduleConfig = Load-Configuration -configFilePath $configFilePath -moduleName $moduleName
$environmentVariables = $moduleConfig.environmentVariables
$connectors = $moduleConfig.connectors
$expenseAIFlows = $moduleConfig.flows
$agentSchemas = $moduleConfig.agents
# Step 1: Interactive login to Azure
Connect-AzAccount -UseDeviceAuthentication
$accessToken = Get-AccessToken
$userId = (Get-AzAccessToken).UserId
write-host "User ID: $userId" -ForegroundColor Yellow
# Step 2: Setup ennviornment variables
Update-EnvironmentVariables -accessToken $accessToken
Write-Host "Environment variables updated successfully!" -ForegroundColor Green
# Step 3: Check active connections
$connectionOutput = Check-Connections -accessToken $accessToken -userId $userId
# Step 4: Link connection references
Link-ConnectionReferences -accessToken $accessToken -connectionOutput $connectionOutput
# Step 5: Activate flows
Activate-Flows -accessToken $accessToken -expenseAIFlows $expenseAIFlows
# step 6: publish the agents
Publish-Agents -accessToken $accessToken -agentSchemas $agentSchemas
# Step 7: Publish the solution
Publish-Solution -accessToken $accessToken
Write-Host "Agent setup completed successfully!" -ForegroundColor Green
} catch {
Write-Host "An error occurred: $_" -ForegroundColor Red
}
Voici ce que va faire ce script :
- Définir des variables d’environnement
- Vérifier et lier les références de connexion
- Activer les flux Power Automate
- Publier les agents Copilot requis
- Publier la solution Dataverse
Une fois le script exécuté, la fonctionnalité de saisie des notes de frais de l’agent de gestion des temps et des dépenses est entièrement configurée et prête à l’emploi.
Option 2 : Configuration manuelle à l’aide de Maker Portal (pas de PowerShell)
Si vous préférez ne pas utiliser le script PowerShell, vous pouvez configurer manuellement la fonctionnalité Saisie des notes de frais de l’Agent de gestion du temps et des dépenses via le portail Power Apps Maker. Ce processus implique la mise à jour des variables d’environnement, l’activation des flux Power Automate et la publication de la solution.
1. Mettre à jour les variables d’environnement
Pour configurer l’agent, mettez à jour les variables d’environnement suivantes.
- Accédez au portail Power Apps Maker et sélectionnez votre environnement.
- Sélectionnez Solutions, puis ouvrez la Solution par défaut (ou la solution dans laquelle l’agent est installé).
- Accédez à Variables d’environnement et définissez les valeurs suivantes :
| Nom de la variable | Descriptif |
|---|---|
| Chemin d’accès au dossier Outlook de l’Assistant Dépenses | Chemin d’accès du dossier dans la boîte aux lettres partagée à surveiller (par défaut, Boîte de réception). |
| ID d’adresse de la boîte aux lettres partagée de l’Assistant Dépenses | Adresse e-mail de la boîte aux lettres partagée. Utilisez NA si vous utilisez la boîte aux lettres de l’utilisateur connecté. |
| URL de l’instance d’applications de finances et d’opérations | URL de l’environnement Finance and Operations (par exemple, https://xxxxx.operations.dynamics.com). |
2. Activer les flux Power Automate
La fonctionnalité de saisie des notes de frais de l’agent de gestion du temps et des notes de frais s’appuie sur les flux Power Automate suivants :
- vérification de la nouvelle tentative de saisie des dépenses
- Configuration des dépenses
- obtenir le dossier des prévisions de dépenses
- Générer une note de frais
- Envoyer une carte adaptive de rapport de dépenses
- Traiter les e-mails
- extraire les ID de réception non joints pour l’appel du copilote
- extraire la sortie d’un reçu non attaché à l’aide du plug-in Dataverse
- Générer une ligne de dépense
- générer une ligne de dépense sans ID de projet et ID de statut
- identifier les ID de projet
- Événements de calendrier utilisateur
- traiter la note de frais à l’aide de Copilot
Pour activer ces flux, procédez comme suit.
- Accédez à Power Automate et sélectionnez votre environnement.
- Sélectionnez Mes flux et recherchez chacune des fonctionnalités de saisie de dépenses des flux d’agent de temps et de dépenses dans la liste précédente.
- Pour chaque flux :
- Sélectionnez Modifier.
- Passez à l’ancien concepteur en désactivant le nouveau concepteur.
- Authentifiez toutes les connexions requises (jusqu’à ce que des coches vertes apparaissent).
- Sélectionnez Continuer → Enregistrer.
- Sélectionnez Activer pour activer le flux.
Répétez ce processus pour chacun des 13 flux répertoriés.
3. Publier la solution
Une fois toutes les variables et tous les flux configurés :
- Dans le portail Power Apps Maker, accédez à Solutions.
- Sélectionnez votre environnement et votre solution.
- Sélectionnez Publier toutes les personnalisations.
Une fois ces étapes terminées, la fonctionnalité de saisie des notes de frais de l’agent de gestion des temps et des dépenses est entièrement configurée et prête à l’emploi sans nécessiter de scripts.
Étape 7 : Activer la fonction de saisie des notes de frais de l’agent de gestion des temps et des dépenses
Pour activer la communication basée sur Teams à l'aide de la fonctionnalité Saisie des dépenses de l'agent Temps et Dépenses, vous devez ajouter le canal Microsoft Teams à l'agent via le portail Power Apps Maker. L’ajout du canal permet à l’agent d’envoyer des cartes adaptatives et de recevoir des entrées via Teams.
Activer le canal Microsoft Teams
Pour activer le canal Microsoft Teams, procédez comme suit.
- Accédez au portail Power Apps Maker et ouvrez l’onglet Agents .
- Sélectionnez Agent de saisie des dépenses.
- Dans la vue de l’agent, accédez à l’onglet Canaux et sélectionnez Microsoft Teams.
- Sélectionnez Ajouter un canal pour activer l’intégration de Teams. Pour en savoir plus, consultez la documentation Microsoft pour cette étape.
Configurer la disponibilité de l’application Teams
Pour configurer la disponibilité de l’application Teams, procédez comme suit.
- Une fois l’application Teams créée, sélectionnez Options de disponibilité.
- Choisissez de partager l’application avec :
- Utilisateurs spécifiques au sein de l’organisation
- Toute l’organisation
- Soumettez l’application pour approbation.
Publier dans le centre d’administration Teams
Pour publier dans le centre d’administration Teams, procédez comme suit.
- Accédez au Centre d’administration Teams.
- Publiez l’application pour une utilisation approuvée.
- Attribuez des stratégies de configuration d’application aux utilisateurs.
- Si nécessaire, mettez à jour les stratégies d’autorisation pour autoriser l’accès des agents en fonction des paramètres Teams de votre organisation.
Pour plus d’informations, consultez Ajouter un bot à Microsoft Teams.