Aika- ja kuluagentin asennuksen ja asennuksen kulukirjausominaisuus (esiversio)

Tärkeää

• Tämä on tuotantovalmis esiversio-ominaisuus.
• Tuotantovalmiita esiversioita koskevat erilliset lisäkäyttöehdot.

Aika- ja kuluagentin kulujen kirjausominaisuus yhdistää Microsoft Dynamics 365 Project Operationsin, talous- ja toimintosovellusten, Microsoft Copilot Studion, Microsoft Power Automaten ja Microsoft Dataversen ominaisuudet kulujen käsittelyn työnkulkujen automatisoimiseksi tekoälyn avulla. Expense Agenin avulla järjestelmäsi voi käsitellä kuitteja ja luoda kulurivejä ja raportteja, jotta käyttäjät voivat säästää aikaa ja vähentää manuaalista työtä. Se käyttää Microsoft Power Platform -yhdistimiä integroidakseen Outlookin, Microsoft Teamsin, käyttäjäkalentereiden ja talous- ja toimintosovellusympäristön kanssa Dataversen näennäisentiteettien kautta.

Aika- ja kuluagentin kulukirjausominaisuus sisältää useita työnkulkuja, joista kolme toimii keskeisinä orkestroijina:

1. Käsittele sähköpostiviestit – Tarkistaa määritetyn postilaatikkokansion tunnin välein ja tallentaa liitteet liittämättöminä kuitteina Dynamics 365 Financessa.
2. Pura kuittitunnukset – Poimii äskettäin lisätyt kuitit ja käynnistää asiakaspalvelijan poimimaan tiedot.
3. Käsittele kuluraportti – Muuntaa poimitut vastaanottotiedot jäsennellyiksi kuluriveiksi ja luo raportteja sovelluksessa määritettyjen määritysten perusteella.

Agentti tukee myös Teams-integraatiota, jonka avulla voit lähettää mukautuvia kortteja kulujen tarkistamista ja lähettämistä varten.

Asiakaspalvelija on riippuvainen useista Power Platform -yhdistimistä. Näihin yhdistimiin viitataan automaattisesti annetuissa Microsoft Power Automate -työnkuluissa:

• Outlook (Office 365) – Käyttää jaettua postilaatikkoa kuittien hakemiseksi.
• Dataverse (virtuaaliset entiteetit) – Integroidaan Dynamics 365 Finance and Operations -entiteettien kanssa.
• Microsoft Copilot Studio – Kutsuu tekoälymalleja kuittitietojen poimimiseksi.
• Microsoft Teams – Lähettää mukautuvia kortteja käyttäjän vuorovaikutusta varten (jos Teams-integraatio on käytössä).
• Microsoft 365 -käyttäjät – Noutaa käyttäjäkalenterin tiedot (valinnainen, jos kuitin jäsentäminen on tilannekohtaista).

Aika- ja kuluasiamiehen kulukirjausominaisuuden asentaminen ja määrittäminen sisältää seuraavat vaiheet:

1. Asenna Copilot for finance and operations -sovellukset.
2. Aktivoi asiakaspalvelija Dynamics 365 Finance and Operationsissa.
3. Luo kulutili agentin tehtävien suorittamista varten.
4. Määritä käyttöoikeudet talous- ja toimintosovelluksissa ja Dataversessa.
5. Määritä jaettu postilaatikko sähköpostipohjaisen kuittien noutoa varten.
6. Määritä ja määritä agentti joko manuaalisesti tai Windows PowerShellin avulla.
7. Ota Microsoft Teams -integrointi käyttöön (valinnainen).

Jokainen näistä vaiheista on kuvattu yksityiskohtaisesti seuraavissa osissa.

Edellytykset

Tässä artikkelissa kuvattujen vaiheiden suorittaminen edellyttää, että sinulla on järjestelmänvalvojan tai järjestelmän mukauttajan käyttöoikeus Power Platform -hallintakeskuksessa, järjestelmänvalvojan käyttöoikeudet talous- ja toimintosovelluksissa ja Exchange-järjestelmänvalvojan käyttöoikeudet Microsoft 365:ssä, jotta voit määrittää jaetun postilaatikon. Jos aiot ottaa Teams-integroinnin käyttöön, tarvitset myös tarvittavat käyttöoikeudet Teams-hallintakeskuksessa.

Vaihe 1: Copilot for finance and operations -sovellusten asentaminen

Aika- ja kuluasiamiehen kulukirjausominaisuus toimitetaan osana Copilot for finance and operations -pakettia. Kun tämä paketti on asennettu ympäristöön, kaikki tarvittavat resurssit, kuten asiakaspalvelija, ympäristömuuttujat ja Power Automate -työnkulut, ovat käytettävissä automaattisesti.

Lisätietoja Copilotin käyttöönotosta ympäristössä on kohdassa Copilot-ominaisuuksien ottaminen käyttöön talous- ja toimintosovelluksissa.

Vaihe 2: Asiakaspalvelijan aktivointi talous- ja toimintosovelluksissa

Voit aktivoida asiakaspalvelijan talous- ja toimintosovelluksissa seuraavasti.

1. Kun olet asentanut paketin, aktivoi aika- ja kuluasiamiehen kulukirjausominaisuus talous- ja toimintoverkkosovelluksesta.
2. Siirry kohtaan Ominaisuuksien hallinta ja varmista, että asiakaspalvelijan hallinta on käytössä.
3. Siirry kohtaan Kulujen hallinnan > asetukset > Kulujen hallinnan parametrit > Kuluagentti.
4. Ota asiakaspalvelija käyttöön nykyiselle yritykselle ja määritä suoritustiheydeksi joko päivittäin tai viikoittain. Voit myös ryhmitellä kulut matkan tai projektin mukaan käyttämällä Kuluryhmä - asetusta.

Vaihe 3: Määritä asiakaspalvelijan käyttäjä

Luo oma kuluagenttikäyttäjä varmistaaksesi, että asiakaspalvelija toimii työntekijän henkilöllisyydestä riippumatta. Tämä auttaa parantamaan turvallisuutta, hallittavuutta ja pitkäaikaista ylläpidettävyyttä. Vaikka on mahdollista käyttää olemassa olevaa käyttäjätiliä, jolla on riittävät oikeudet, järjestelmän omistaman käyttäjätiedon käyttäminen on suositeltava tapa.

V. Luo käyttäjä Microsoft Azure Active Directory (Azure AD DS)

1. Siirry Azure-portaaliin ja luo uusi käyttäjä Microsoft Entra ID -kohdassa.

B. Lisää käyttäjä Power Platform -ympäristöön

1. Siirry Power Platform -hallintakeskukseen ja valitse sopiva ympäristö.
2. Valitse Näytä kaikki käyttäjät, sitten Lisää käyttäjä ja valitse juuri luotu asiakaspalvelijan käyttäjä.

C. Tarvittavien roolien määrittäminen Power Platform -hallintakeskuksessa

1. Valitse ympäristö samassa Power Platform -hallintakeskuksessa.
2. Etsi asiakaspalvelijan käyttäjä ja valitse Roolien hallinta.
3. Määritä seuraavat roolit:
   • Järjestelmän mukauttaja
   • Kulujenhallinnan tekoälyagentin rooli
   • Finance and Operationsin asiakaspalvelijan määritysrooli

Nämä roolit tarjoavat käyttöoikeuden Dataverse- ja Power Automate -komponentteihin, joita asiakaspalvelija tarvitsee toimiakseen.

D. Järjestelmänvalvojan roolin määrittäminen talous- ja toimintosovelluksissa

1. Siirry Finance and Operations -portaalissa kohtaan Järjestelmänhallinnan > käyttäjät.
2. Luo uusi käyttäjätietue asiakaspalvelijakäyttäjälle.
3. Määritä järjestelmänvalvojan rooli.
4. Valitse Tallenna , jos haluat säilyttää määrityksen.

Vaihe 4: Myönnä käyttöoikeudet

Aika- ja kuluasiamiehen kulukirjausominaisuuden määrittäminen ja suorittaminen onnistuu, kun määritetylle asiakaspalvelijan käyttäjälle on myönnettävä seuraavat käyttöoikeudet:

Talous- ja toimintoroolit

• Järjestelmänvalvoja
  Vaaditaan, jotta asiakaspalvelija voi luoda ja hallita kulutapahtumia Finance and Operations -ympäristössä.

Dataverse-roolit

• Järjestelmän mukauttaja
• Kulujenhallinnan tekoälyagentin rooli
• Finance and Operationsin asiakaspalvelijan määritysrooli

Näiden roolien avulla asiakaspalvelija voi olla vuorovaikutuksessa Dynamics 365 Financeen yhdistettyjen Power Automate -työnkulkujen, ympäristömuuttujien ja virtuaalisten entiteettien kanssa.

Jaetun postilaatikon käyttö

Agenttikäyttäjällä on myös oltava Microsoft Graph -käyttöoikeus Mail.Shared.Read , jonka avulla agentti voi lukea kuittauksia määritetystä jaetusta postilaatikosta työnkulun suorittamisen aikana.

Vaihe 5: Määritä jaettu postilaatikko

Aika- ja kuluasiamiehen kulukirjausominaisuus käyttää jaettua postilaatikkoa vastaanottosähköpostien vastaanottamiseen. Käyttäjän on luotava ja määritettävä tämä postilaatikko Microsoft 365 -hallintakeskus käyttäjän toimesta, jolla on Exchange-järjestelmänvalvojan rooli.

Voit luoda ja määrittää jaetun postilaatikon seuraavasti.

1. Siirry Microsoft 365 -hallintakeskus ja kirjaudu sisään Exchange-järjestelmänvalvojan tilillä.
2. Valitse vasemmanpuoleisessa siirtymisruudussa Teams & Groups > Shared -postilaatikot.
   Jos et näe sitä heti, laajenna luettelo valitsemalla Näytä kaikki .
3. Valitse Lisää jaettu postilaatikko.
4. Kirjoita jaetun postilaatikon nimi ja sähköpostiosoite.
   Suositeltu muoto:expenseagent@contoso.com
5. Valitse Tallenna muutokset. Voi kestää muutaman minuutin, ennen kuin jäsenhallinta tulee saataville.
6. Valitse Seuraavat vaiheet -kohdassa Lisää jäseniä tähän postilaatikkoon.
7. Valitse asiakaspalvelijan käyttäjä (ja kaikki muut, joiden pitäisi valvoa postilaatikkoa) ja valitse sitten Lisää ja sulje.

Kun postilaatikko on määritetty, anna sen sähköpostiosoite ja kansiopolku (oletus: Saapuneet) ympäristömuuttujina, kun määrität kuluagenttia.

Vaihe 6: Määritä aika- ja kuluasiamiehen kulukirjausominaisuus

Voit määrittää aika- ja kuluasiamiehen kulukirjausominaisuuden käyttämällä jompaakumpaa seuraavista vaihtoehdoista:

• Vaihtoehto 1: PowerShell-komentosarjan käyttäminen (suositus)
• Vaihtoehto 2: Manuaalinen asennus tekijäportaalin avulla (ei PowerShelliä)

Vaihtoehto 1: PowerShell-komentosarjan käyttäminen (suositus)

Asiakaspalvelijan määrittäminen manuaalisesti edellyttää yhteyksien luomista ja linkittämistä, Power Automate -työnkulkujen käyttöönottoa ja ratkaisun julkaisemista, mikä voi olla aikaa vievä ja virhealtis prosessi. Voit automatisoida asennuksen PowerShell-komentosarjan ja määritystiedoston (AgentConfig.json) avulla.

PowerShell-komentosarja automatisoi:

• Tarvittavien ympäristömuuttujien päivittäminen.
• Power Platform -yhteyksien linkittäminen ratkaisun yhteysviittauksiin.
• Kaikkien kuluagentin edellyttämien Power Automate -työnkulkujen käyttöönotto.
• Copilot-agenttien julkaiseminen.
• Dataverse-ratkaisun julkaiseminen.

Esimerkki kokoonpanotiedostosta (AgentConfig.json)

Ennen kuin suoritat komentosarjan, määritä tiedosto ympäristöösi liittyvillä arvoilla:

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

Yhteyksien luominen

Luo yhteydet seuraavasti.

1. Siirry Power Apps Maker -portaaliin ja valitse ympäristösi.
2. Siirry kohtaan Yhteydet.
3. Valitse Uusi yhteys ja valitse sopiva liitin (esimerkiksi Outlook, Teams jne.).
4. Kun yhteys on luotu, kopioi se ja liitä se AgentConfig.json tiedostoon asianmukaisen liitinmerkinnän alle.

Suorita komentosarja

Kun määritys on valmis, suorita seuraava komentosarja, kun olet lisännyt tarvittavat ympäristömuuttujat:

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
}

Käsikirjoitus:

• Aseta ympäristömuuttujat
• Tarkista ja linkitä yhteysviittaukset
• Ota Power Automate -työnkulut käyttöön
• Julkaise tarvittavat Copilot-agentit
• Dataverse-ratkaisun julkaiseminen

Kun komentosarja on suoritettu onnistuneesti, aika- ja kuluasiamiehen kulukirjausominaisuus on täysin määritetty ja käyttövalmis.

Vaihtoehto 2: Manuaalinen asennus tekijäportaalin avulla (ei PowerShelliä)

Jos et halua käyttää PowerShell-komentosarjaa, voit määrittää aika- ja kuluagentin kulukirjausominaisuuden manuaalisesti Power Apps Maker -portaalin kautta. Tämä prosessi sisältää ympäristömuuttujien päivittämisen, Power Automate -työnkulkujen käyttöönoton ja ratkaisun julkaisemisen.

1. Päivitä ympäristömuuttujat

Määritä agentti päivittämällä seuraavat ympäristömuuttujat.

1. Siirry Power Apps Maker -portaaliin ja valitse ympäristösi.
2. Valitse Ratkaisut ja avaa sitten oletusratkaisu (tai ratkaisu, johon agentti on asennettu).
3. Siirry kohtaan Ympäristömuuttujat ja määritä seuraavat arvot:

Muuttujan nimi	Kuvaus
Kuluagentin Outlook-kansion polku	Jaetun postilaatikon kansiopolku, jota valvotaan (oletus on Saapuneet).
Kustannusagentin jaetun postilaatikon osoite-ID	Jaetun postilaatikon sähköpostiosoite. Käytä NA:ta , jos käytät kirjautuneen käyttäjän postilaatikkoa.
Finance and Operations -ilmentymän URL-osoite	Finance and Operations -ympäristön URL-osoite (esimerkiksi https://xxxxx.operations.dynamics.com).

2. Power Automate -työnkulkujen käyttöönotto

Aika- ja kuluagentin kulukirjausominaisuus perustuu seuraaviin Power Automate -työnkulkuihin:

• Kulumerkinnän uudelleenyrityksen tarkistus
• kulujen määritys
• kulujen Outlook-kansion noutaminen
• Luo kuluraportti
• Lähetä kuluraportin mukautuva kortti
• Käsittele sähköposteja
• Poimi liittämättömät kuittitunnukset Copilotin kutsua varten
• Poimi liittämätön kuitin tuloste Dataverse-laajennuksen avulla
• Luo kulurivi
• Luo kulurivi ilman projektitunnusta ja tilatunnusta
• tunnistaa projektitunnukset
• Käyttäjäkalenterin tapahtumat
• Kuluraportin käsitteleminen Copilotin avulla

Ota nämä työnkulut käyttöön noudattamalla seuraavia ohjeita.

1. Siirry Power Automateen ja valitse ympäristösi.
2. Valitse Omat työnkulut ja etsi kukin Aika- ja kuluagentti-työnkulkujen kulumerkintäominaisuus edellisestä luettelosta.
3. Jokaiselle virralle:
   • Valitse Muokkaa.
   • Vaihda vanhaan suunnitteluohjelmaan kytkemällä uusi suunnittelija pois päältä.
   • Todenna kaikki tarvittavat yhteydet (kunnes vihreät valintamerkit tulevat näkyviin).
   • Valitse Jatka → Tallenna.
   • Valitse Ota käyttöön ottaaksesi prosessin käyttöön.

Toista tämä prosessi kullekin luetellulle 13 työnkululle.

3. Julkaise ratkaisu

Kun kaikki muuttujat ja työnkulut on määritetty:

1. Siirry Power Apps Maker -portaalissa kohtaan Ratkaisut.
2. Valitse ympäristö ja ratkaisu.
3. Valitse Julkaise kaikki mukautukset.

Kun olet suorittanut nämä vaiheet, aika- ja kuluasiamiehen kulukirjausominaisuus on täysin määritetty ja valmis käytettäväksi ilman komentosarjoja.

Vaihe 7: Ota aika- ja kuluasiamiehen kulukirjausominaisuus käyttöön

Jos haluat ottaa käyttöön Teams-pohjaisen viestinnän aika- ja kuluagentin kulukirjausominaisuuden avulla, sinun on lisättävä Microsoft Teams -kanava asiakaspalvelijaan Power Apps Maker -portaalin kautta. Kanavan lisäämisen avulla asiakaspalvelija voi lähettää mukautuvia kortteja ja vastaanottaa syötteitä Teamsin kautta.

Microsoft Teams -kanavan ottaminen käyttöön

Ota Microsoft Teams -kanava käyttöön seuraavasti.

1. Siirry Power Apps Maker -portaaliin ja avaa Asiakaspalvelijat-välilehti .
2. Valitse Kulumerkintöjen agentti.
3. Siirry asiakaspalvelijanäkymässä Kanavat-välilehteen ja valitse Microsoft Teams.
4. Ota Teams-integrointi käyttöön valitsemalla Lisää kanava . Lisätietoja on kohdassa Tämän vaiheen Microsoft-dokumentaation tarkasteleminen.

Teams-sovelluksen käytettävyyden määrittäminen

Voit määrittää Teams-sovelluksen käytettävyyden seuraavasti.

1. Kun Teams-sovellus on luotu, valitse Käytettävyysasetukset.
2. Valitse sovelluksen jakaminen seuraaville laitteille:
   • Tietyt käyttäjät organisaatiossa
   • Koko organisaatio
3. Lähetä sovellus hyväksyttäväksi.

Julkaise Teams-hallintakeskuksessa

Voit julkaista Teams-hallintakeskuksessa seuraavasti.

1. Siirry Teams-hallintakeskukseen.
2. Julkaise sovellus hyväksyttyä käyttöä varten.
3. Määritä sovellusten asennuskäytännöt käyttäjille.
4. Päivitä tarvittaessa käyttöoikeuskäytännöt , jotta asiakaspalvelijan käyttö sallitaan organisaatiosi Teams-asetusten perusteella.

Lisätietoja on artikkelissa Botin lisääminen Microsoft Teamsiin.