Konfigurowanie agenta wydatków (wersja zapoznawcza)

Ważne

• Jest to gotowa do produkcji funkcja w wersji zapoznawczej.
• Gotowe do produkcji wersje zapoznawcze podlegają dodatkowym warunkom użytkowania.

Dotyczy aplikacji Dynamics 365 Project Operations zintegrowanej z systemem ERP i oprogramowaniem Dynamics 365 Project Operations dla produkcji

Agent wydatków łączy funkcje z oprogramowania Microsoft Dynamics 365 Project Operations, aplikacji finansowych i operacyjnych, Microsoft Copilot Studio, Power Automate i Dataverse w celu zautomatyzowania przepływów pracy przetwarzania wydatków przy użyciu sztucznej inteligencji. Ta funkcja pomaga zaoszczędzić czas i zmniejszyć nakład pracy ręcznej, umożliwiając systemowi przetwarzanie paragonów i generowanie wierszy wydatków i raportów wydatków dla użytkowników. Używa łączników platformy Microsoft Power Platform do integracji z programami Outlook, Microsoft Teams, kalendarzami użytkowników oraz środowiskiem aplikacji finansowych i operacyjnych za pośrednictwem encji wirtualnych usługi Dataverse.

Agent wydatków obejmuje wiele przepływów, z których trzy służą jako podstawowe orkiestratory:

• Przetwarzanie wiadomości e-mail — ten przepływ skanuje skonfigurowany folder skrzynki pocztowej co godzinę i przechowuje załączniki jako niedołączone paragony w usłudze Dynamics 365 Finance.
• Wyodrębnianie identyfikatorów paragonów — ten przepływ pobiera niedołączone paragony i wyzwala agenta w celu wyodrębnienia szczegółów paragonów i utworzenia niedołączonych wierszy wydatków.
• Przetwórz Raport Wydatków — ten proces konwertuje niepowiązane wiersze wydatków i generuje raporty wydatków na podstawie konfiguracji Grupuj raporty według, którą ustawiłeś w aplikacji dla każdej jednostki prawnej.

Ponadto agent integruje się z usługą Microsoft Teams, umożliwiając korzystanie z kart adaptacyjnych na potrzeby przeglądu i przesyłania raportów z wydatków.

Agent korzysta z kilku łączników platformy Microsoft Power Platform. Do tych łączników są automatycznie przywoływane w Power Automate przepływach, które są udostępniane.

• Outlook (Office 365) — ten łącznik uzyskuje dostęp do współdzielonej skrzynki pocztowej w celu wyodrębnienia paragonów.
• Dataverse (encje wirtualne) — ten łącznik integruje się z aplikacjami finansowymi i operacyjnymi za pośrednictwem encji wirtualnych.
• Microsoft Copilot Studio — ten łącznik wywołuje modele sztucznej inteligencji w celu wyodrębnienia informacji z paragonu.
• Microsoft Teams — ten łącznik wysyła karty adaptacyjne na potrzeby interakcji z użytkownikiem (jeśli integracja z usługą Teams jest włączona).
• Użytkownicy platformy Microsoft 365 — ten łącznik pobiera szczegóły kalendarza użytkownika (opcjonalnie, jeśli analizowanie paragonów uwzględnia kontekst).

Wymagania wstępne

1. Środowisko finansów i operacji: Potrzebujesz co najmniej wersji 10.0.44 (10.0.2263.175 i nowszej) lub 10.0.45 (10.0.0.2345.115 i nowsze) lub 10.0.46 (10.0.2428.69 i nowsze) środowiska finansowego i operacyjnego do zainstalowania agenta.
2. Role wymagane do skonfigurowania użytkownika agenta wydatków: Aby wykonać kroki opisane w tym artykule, musisz być administratorem systemu organizacji i mieć następujące role, aby skonfigurować użytkownika agenta wydatków na potrzeby instalowania agenta wydatków.

System	Role	Comments
centrum administracyjne platformy Power Platform	Administrator systemu	Przejdź do centrum administracyjnego platformy Power Platform. W lewym okienku przejdź do opcji Zarządzaj. Wybierz Środowisko, a następnie swoje środowisko. W sekcji Dostęp>Użytkownicy wybierz Zobacz wszystko. Wybierz użytkownika, wybierz opcję Zarządzaj rolami i dodaj rolę.
Finance and Operations	Administrator systemu	Otwórz adres URL aplikacji finansowych i operacyjnych w swoim środowisku. Wybierz kolejno opcje Moduł>Administrowaniesystemem>Użytkownicy i wybierz użytkownika. Wybierz kolejno pozycje Dodaj rolę — Administrator systemu.
Microsoft 365	Administrator programu Exchange i administrator użytkowników	Przejdź do centrum administracyjnego Microsoft 365. Przejdź do pozycji Użytkownicy>Aktywni użytkownicy> i wybierz użytkownika. Wybierz pozycję Zarządzaj rolami, a następnie w obszarze Role wybierz pozycję Administrator programu Exchange. Zapisz zmiany. Wykonaj te same kroki, aby dodać rolę Administrator użytkowników .
Centrum administracyjne aplikacji Teams	Administrator zespołów	Wymagane, jeśli planujesz włączyć integrację z usługą Microsoft Teams

Kroki konfigurowania agenta wydatków

Aby zainstalować i skonfigurować agenta wydatków, wykonaj następujące kroki:

1. Zainstaluj rozwiązanie Copilot dla aplikacji finansowych i operacyjnych.
2. Włącz funkcje agenta w swoim środowisku.
3. Utwórz użytkownika wydatków na potrzeby wykonywania agenta.
4. Skonfiguruj współdzieloną skrzynkę pocztową.
5. Skonfiguruj agenta wydatków.
6. Włącz agenta wydatków w usłudze Microsoft Teams (opcjonalnie — jeśli potrzebujesz integracji z usługą Microsoft Teams)

W poniższych sekcjach opisano szczegółowo każdy krok.

Krok 1: Zainstaluj Copilot dla aplikacji finansowych i operacyjnych

Agent wydatków jest dostępny w pakiecie Copilot dla aplikacji finansowych i operacyjnych. Po zainstalowaniu tego pakietu w środowisku automatycznie uzyskasz wszystkie wymagane zasoby, w tym agenta, zmienne środowiskowe i przepływy usługi Power Automate.

Aby zainstalować wymaganą aplikację, wykonaj następujące kroki:

1. W przeglądarce przejdź do centrum administracyjnego platformy Power Platform.
2. Z listy środowisk wybierz nazwę środowiska, w którym chcesz zainstalować aplikację.
3. Na stronie szczegółów środowiska (NIE z nawigacji po lewej stronie) przejdź do sekcji Zasoby i wybierz pozycję Aplikacje usługi Dynamics 365.
4. Na liście aplikacji usługi Dynamics 365 wyszukaj pozycję Copilot dla aplikacji finansowych i operacyjnych. Jeśli pakiet jest już zainstalowany, a ma dostępną aktualizację, kliknij przycisk Aktualizuj.
5. Jeśli aplikacja nie znajduje się na liście aplikacji usługi Dynamics 365, wybierz pozycję Zainstaluj aplikację, wybierz pozycję Copilot dla aplikacji finansowych i operacyjnych i postępuj zgodnie z monitami, aby ukończyć instalację.
6. Aplikacja Copilot for Finance and Operations powinna mieć wartość 1.0.3231.4 lub nowszą

Uwaga / Notatka

Więcej o włączania funkcji Copilot w swoim środowisku znajdziesz w temacie Włączanie możliwości usługi Copilot w aplikacjach finansowych i operacyjnych.

Napiwek

Aby sprawdzić, czy pakiet został pomyślnie zainstalowany, wykonaj następujące kroki:

1. Przejdź do portalu Power Apps Maker Portal > wybierz swoje środowisko > wybierz opcję Rozwiązania > Zobacz historię > wyszukaj i zaznacz środowisko msdyn_ExpenseAI > Szczegóły.
2. Zaznacz pole Wynik .
   1. Jeśli wynik ma wartość Powodzenie, pakiet został poprawnie zainstalowany.
   2. Jeśli wynik nie ma wartości Powodzenie, instalacja się nie powiodła.
3. Jeśli instalacja zakończy się niepowodzeniem, usuń msdyn_FnOCopilotAnchor (zobacz sekcję dezinstalacji) i ponownie zainstaluj narzędzie Copilot dla aplikacji finansowych i operacyjnych.

Krok 2: Włącz funkcje agenta w swoim środowisku

Po zainstalowaniu pakietu aplikacji Copilot for finance and operations, aktywuj agenta wydatków z poziomu środowiska Dataverse oraz środowiska finansów i operacji.

Włączanie funkcji w usłudze Dataverse

Włącz flagę funkcji Copilot w centrum administracyjnym platformy Power Platform. Aby włączyć flagę funkcji Copilot, wykonaj następujące kroki:

1. Przejdź do centrum administracyjnego platformy Power Platform.
2. Wybierz pozycję Środowiska> wybierz swoje środowisko >Ustawienia>Produkty> wybierz opcję Funkcje.
3. Upewnij się, że flaga funkcji Copilot jest włączona.

Włączanie funkcji w środowisku aplikacji do obsługi finansów i operacji

Aby aktywować agenta w aplikacjach finansowych i operacyjnych, wykonaj następujące kroki:

1. Zaloguj się do swojego środowiska aplikacji finansowych i operacyjnych.
2. Przejdź do obszaru Zarządzanie funkcjami, a następnie włącz funkcje Immersywna strona główna i Zarządzanie agentami.
3. Aby skonfigurować agenta wydatków (konfiguracja jest dokonywana dla podmiotu prawnego), przejdź do pozycji Zarządzanie wydatkami>Konfiguracja>Ogólne>Parametry zarządzania wydatkami.
4. Na karcie Agent wprowadzania wydatków skonfiguruj parametry, jak pokazano w poniższej tabeli.

Parametry	Wartość	Comments
Włączanie agenta wydatków dla bieżącego podmiotu prawnego	Tak	Przełącz na wartość Tak, aby włączyć agenta dla bieżącego podmiotu prawnego.
Częstotliwość	Dziennie lub Co tydzień	Skonfiguruj częstotliwość automatycznego tworzenia raportów z wydatków w organizacji.
Grupuj raporty według	Podróż lub Projekt	Konfigurowanie grupowania wydatków na podstawie projektu lub podróży.

Krok 3. Tworzenie użytkownika agenta do zarządzania wydatkami do realizacji zadań agenta

Utwórz dedykowanego użytkownika agenta wydatków, aby upewnić się, że agent będzie działał niezależnie od tożsamości pracownika. Takie podejście pomaga w zabezpieczaniu, zarządzaniu i długoterminowym utrzymaniu. Chociaż możesz użyć istniejącego konta użytkownika, które ma wymagane uprawnienia, użyj tożsamości należącej do systemu.

Tworzenie użytkownika agenta Expense w Microsoft Entra ID

1. Zaloguj się do witryny Azure Portal.
2. Wśród dostępnych usług platformy Azure wybierz pozycję Tożsamość Microsoft Entra.
3. W obszarze Tożsamość Microsoft Entra utwórz nowego użytkownika.
4. Wybierz kolejno opcje Dodaj>Użytkownik>Utwórz nowego użytkownika i wprowadź następujące dane szczegółowe.
   • Główna nazwa użytkownika
   • Wybieranie właściwej domeny
   • nazwa wyświetlana
   • Hasło
   • Oznaczanie konta jako włączonego
5. Aby wyświetlić szczegóły i ukończyć proces tworzenia użytkownika, wybierz pozycję Przejrzyj i utwórz, a następnie wybierz pozycję Utwórz.
6. Na stronie Użytkownik (Zarządzanie > Użytkownicy) wybierz użytkownika i stronę wyświetlania szczegółów.
7. Wybierz pozycję Edytuj właściwości, przejdź do karty Ustawienia i wypełnij odpowiednią lokalizację użycia.

Uwaga / Notatka

W zależności od zasad w organizacji może być konieczna zmianę hasła oraz skonfigurowanie uwierzytelniania wieloskładnikowego (MFA). Postępuj zgodnie z instrukcjami zmiany hasła i konfigurowania uwierzytelniania wieloskładnikowego.

Przypisywanie wymaganych licencji do użytkownika agenta wydatków

Aby pomyślnie zainstalować agenta wydatków, przypisz następujące licencje do użytkownika agenta wydatków:

• Licencja Dynamics 365 Teams Members
• Microsoft 365 Business Basic lub dowolna licencja obejmująca usługi Microsoft Teams i Outlook (na przykład Office 365 E5 z zespołami)
• Power Apps Premium

Aby przypisać licencje, wykonaj następujące kroki:

1. Zaloguj się do centrum administracyjnego platformy Microsoft 365 przy użyciu nazwy użytkownika, który ma dostęp do funkcji przypisywania licencji, czyli użytkownika z uprawnieniem Administrator licencji lub wyższym.
2. Wybierz kolejno opcje Rozliczenia>Licencje>Licencja Dynamics 365 Teams Members.
3. Wybierz pozycję +Przypisz licencje.
4. Wyszukaj użytkownika agenta wydatków utworzonego w poprzednim kroku.
5. Wybierz pozycję Przypisz, aby ukończyć przypisanie licencji.
6. Wykonaj kroki od 2 do 5 dla pozostałych licencji — Microsoft 365 Business Basic i Power Apps Premium.

Uwaga / Notatka

Więcej na temat sprawdzania i przypisywania licencji dowiedz się w temacie Używanie strony Aktywni użytkownicy do przypisywania lub anulowania przypisania licencji.

Dodawanie użytkownika do środowiska Power Platform

Aby dodać użytkownika do środowiska platformy Power Platform, wykonaj następujące kroki:

1. Zaloguj się do centrum administracyjnego platformy Power Platform, a następnie wybierz odpowiednie środowisko.

   Napiwek

   Ta strona zawiera informacje dotyczące identyfikatora środowiska dla usługi Dataverse, adresu URL środowiska dla usługi Dataverse oraz adresu URL aplikacji finansowych i operacyjnych. Zapisz te wartości do użycia w kolejnych sekcjach.

2. Przejdź do ustawienia Dostęp > Użytkownicy > Zobacz wszystko.

3. Wybierz pozycję Dodaj użytkownika, wprowadź nowo utworzonego użytkownika agenta, a następnie wybierz pozycję Dodaj.

4. Na stronie Zarządzanie rolami zabezpieczeń dodaj następujące role.

   • Rola agenta AI ds. wydatków
   • Menedżer konfiguracji agenta finansów i operacji
   • Konfigurator systemu

5. Aby potwierdzić przypisanie roli, wybierz pozycję Zapisz.

Te role zapewniają dostęp do składników usług Dataverse i Power Automate, których agent potrzebuje do działania.

Napiwek

Jeśli użytkownik już istnieje i musisz przypisać tylko role, przejdź do centrum administracyjnego platformy Power Platform i wybierz odpowiednie środowisko.

1. Przejdź do ustawienia Dostęp > Użytkownicy > Zobacz wszystko.
2. Wybierz utworzonego użytkownika agenta.
3. Wybierz pozycję Zarządzaj rolami i przypisz role.

Przypisywanie wymaganej roli w środowisku finansów i operacji

Aby przypisać rolę ExpenseAgentRole w środowisku finansów i operacji, wykonaj następujące kroki:

1. W środowisku finansowym i operacyjnym przejdź do pozycji Administrowanie systemem>Użytkownicy.
2. Utwórz rekord użytkownika dla użytkownika agenta.
3. Po utworzeniu użytkownika przejdź do sekcji role użytkownika, wybierz pozycję Przypisz role i wyszukaj pozycję ExpenseAgentRole.
4. Wybierz Zapisz.

Uwaga / Notatka

Rola ExpenseAgentRole jest dostępna w aplikacjach finansowych i operacyjnych w wersjach od 10.0.44 (10.0.2263.81) i 10.0.45 (10.0.2345.6) oraz w pakiecie Copilot dla aplikacji finansowych i operacyjnych w wersji 1.0.3121.1

Przypisywanie dostępu do współdzielonej skrzynki pocztowej

Użytkownik agenta musi mieć uprawnienie Mail.Read.Shared w aplikacji Microsoft Graph. To uprawnienie umożliwia agentowi odczytywanie potwierdzeń ze skonfigurowanej udostępnionej skrzynki pocztowej podczas wykonywania przepływu.

Aby przypisać dostęp do udostępnionej skrzynki pocztowej, wykonaj następujące kroki:

1. Przejdź do Eksploratora programu Microsoft Graph i zaloguj się przy użyciu utworzonego użytkownika agenta.
2. Wybierz ikonę użytkownika w prawym górnym rogu > wybierz pozycję Zgoda na uprawnienia.
3. Wybierz menu rozwijane Poczta> poszukaj uprawnienia Mail.Read.Shared> zaznacz pozycję Zgoda i kliknij przycisk Akceptuj.

Podsumowanie wymaganych ról dla utworzonego użytkownika agenta

Środowisko	Role	Comments
Dataverse	Rola agenta AI wydatków "Kierownik Konfiguracji Agenta Finansów i Operacji" Konfigurator systemu	Wymienione role umożliwiają agentowi interakcję z przepływami usługi Power Automate, zmiennymi środowiskowymi i encjami wirtualnymi połączonymi z usługą Dynamics 365 Finance
Finance and Operations	ExpenseAgentRole Użytkownik systemu	Ta rola jest wymagana, aby agent tworzył wpisy wydatków i nimi zarządzał w środowisku aplikacji finansowych i operacyjnych. Uwaga: Rola ExpenseAgentRole jest dostępna w aplikacjach finansowych i operacyjnych w wersjach od 10.0.44 (10.0.2263.81) i 10.0.45 (10.0.2345.6) oraz w pakiecie Copilot dla aplikacji finansowych i operacyjnych w wersji 1.0.3121.1
Dostęp do współdzielonej skrzynki pocztowej przy użyciu Eksploratora programu Graph	Mail.Read.Shared	Uprawnienie programu Microsoft Graph umożliwiające agentowi odczytywanie paragonów ze skonfigurowanej współdzielonej skrzynki pocztowej podczas wykonywania przepływu

Krok 4: Konfigurowanie współdzielonej skrzynki pocztowej

Agent wydatków używa współdzielonej skrzynki pocztowej do odbierania i przetwarzania wiadomości e-mail z paragonami. Użytkownik z rolą Administrator programu Exchange musi utworzyć i skonfigurować tę skrzynkę pocztową w Centrum administracyjnym platformy Microsoft 365.

Aby utworzyć i skonfigurować udostępnioną skrzynkę pocztową, wykonaj następujące kroki:

1. Zaloguj się do Centrum administracyjnego platformy Microsoft 365 przy użyciu konta administratora programu Exchange.

2. W lewym okienku wybierz Zespoły i grupy>Współdzielone skrzynki pocztowe.

   Napiwek

   Może być konieczne wybranie pozycji Pokaż wszystko , aby rozwinąć pełną listę.

3. Wybierz pozycję Dodaj udostępnioną skrzynkę pocztową.

4. Wprowadź nazwę i adres e-mail udostępnionej skrzynki pocztowej.

5. Wybierz Zapisz zmiany.

6. W obszarze Następne kroki wybierz pozycję Dodaj członków do tej współdzielonej skrzynki pocztowej. (Dostępność funkcji zarządzania członkami może potrwać kilka minut.)

7. Wybierz opcję Dodaj członków.

8. Wybierz utworzonego użytkownika agenta oraz innych użytkowników, którzy powinni monitorować skrzynkę pocztową, a następnie wybierz pozycję Dodaj.

9. Wybierz Zamknij.

Uwaga / Notatka

W następnym kroku użyjesz adresu e-mail udostępnionej skrzynki pocztowej. Po skonfigurowaniu udostępnionej skrzynki pocztowej należy podać jego adres e-mail i ścieżkę folderu (domyślnie ustawioną na Skrzynkę odbiorczą) jako zmienne środowiskowe podczas konfigurowania agenta czasu i wydatków. Aby uzyskać więcej informacji, zobacz Krok 5. Konfigurowanie agenta wydatków.

Krok 5: Konfigurowanie agenta wydatków

Dostępne są dwie opcje konfigurowania agenta wydatków:

• Opcja A: Używanie skryptu programu PowerShell (zalecane)
• Opcja B: Ręczne konfigurowanie w usłudze Power Apps (bez programu PowerShell)

Ważne

Przed kontynuowaniem instalacji agenta wydatków upewnij się, że agent został pomyślnie aprowizowany w programie Microsoft Copilot Studio.

Aby sprawdzić, czy agent został pomyślnie udostępniony, wykonaj następujące kroki:

1. Zaloguj się do programu Microsoft Copilot Studio i wybierz swoje środowisko.
2. Przejdź do pozycji Agenci i wyszukaj ExpenseAgent-Line (wersja zapoznawcza).
3. Sprawdź, czy przycisk Publikuj jest włączony.
4. Jeśli agent jest włączony, przejdź do instalacji. Jeśli agent jest wyłączony, poczekaj na zainicjowanie jego obsługi administracyjnej.
5. Powtórz te kroki, aby sprawdzić, czy Agent wprowadzania wydatków (wersja zapoznawcza) jest włączony.

Napiwek

Jeśli aprowizowanie aplikacji finansowej i operacyjnej Copilot trwa dłużej niż 5–6 godzin, odinstaluj i ponownie zainstaluj aplikację, aby rozwiązać potencjalne opóźnienia konfiguracji. Aby uzyskać więcej informacji, zobacz sekcję Odinstaluj agenta wydatków na końcu tego artykułu.

Opcja A: Używanie skryptu programu PowerShell (zalecane)

Ręczne konfigurowanie agenta obejmuje utworzenie i ustanowienie połączeń, włączenie przepływów usługi Power Automate i opublikowanie rozwiązania. Ten proces może być czasochłonny i podatny na błędy. Aby zautomatyzować konfigurację, użyj skryptu programu PowerShell po zaktualizowaniu wymaganych parametrów.

Skrypt programu PowerShell automatyzuje następujące zadania:

• Aktualizuje wymagane zmienne środowiskowe.
• Łączy połączenia platformy Microsoft Power Platform z odwołaniami do połączeń rozwiązania.
• Włącza wszystkie przepływy usługi Power Automate wymagane przez Agenta czasu i wydatku.
• Publikuje agentów Copilot.
• Publikuje rozwiązanie Dataverse.

Przed uruchomieniem skryptu należy utworzyć połączenia, ponieważ trzeba podać identyfikator połączenia dla każdego łącznika w pliku install.ps1. Aby utworzyć te połączenia, wykonaj następujące kroki przy użyciu utworzonego użytkownika agenta.

1. Zaloguj się do portalu twórcy usługi Power Apps przy użyciu nowo utworzonego użytkownika agenta i wybierz swoje środowisko.
2. W lewym okienku wybierz kolejno opcje Więcej i Połączenia.
3. Wybierz pozycję Nowe połączenie i wyszukaj przy użyciu nazwy połączenia z poniższej tabeli (na przykład Office 365 Outlook).
4. Z listy wybierz odpowiedni typ łącznika i utwórz łącznik.
5. Po utworzeniu połączenia zanotuj użytkownika, z którym utworzono połączenie. Najlepiej, aby był to utworzony użytkownik agenta z odnośnym identyfikatorem. Zaktualizuj ten identyfikator użytkownika w pliku instalacyjnym utworzonym w następnym kroku.
6. Powtórz kroki 3 i 4 dla każdego z pozostałych wymaganych połączeń wymienionych w poniższej tabeli.

Nazwa połączenia	Formaty adresów URL połączeń
Office 365 Outlook	https://make.powerapps.com/environments/environmentID/connections / shared_office365/connectionID/details
Użytkownicy Office 365	https://make.powerapps.com/environments/environmentID/connections / shared_office365users/connectionID/details
Microsoft Teams	https://make.powerapps.com/environments/environmentID/connections / shared_teams/connectionID/szczegóły
Microsoft Dataverse	https://make.powerapps.com/environments/environmentID/connections / shared_commondataserviceforapps/connectionID/details
Microsoft Copilot Studio (wersja zapoznawcza)	https://make.powerapps.com/environments/environmentID/connections / shared_microsoftcopilotstudio/connectionID/details

Informacje potrzebne do utworzenia pliku instalacyjnego

Aby utworzyć plik instalacyjny — install.ps1, podaj następujące informacje. (Aby uzyskać pomoc, zapoznaj się z poniższą tabelą).

Parametr	Inne szczegóły
Identyfikator środowiska Dataverse	Wprowadź identyfikator środowiska otrzymany z centrum administracyjnego platformy Power Platform. Przykładowa wartość: xxxx-xxxx-xxx-xxxxx-xxxxxxxxxx
URL do środowiska Dataverse	Wprowadź adres URL środowiska otrzymany z centrum administracyjnego platformy Power Platform. Uwaga: Upewnij się, że na początku jest ciąg znaków https://, a na końcu nie na ukośnika „/”. Przykładowa wartość: https://org123.crm.contoso.com
Adres URL wystąpienia aplikacji do obsługi finansów i operacji	Wprowadź szczegóły środowiska finansów i operacji w następującym formacie. Przykładowa wartość: https://org123.contoso.com Uwaga: Upewnij się, że na początku jest ciąg znaków https://, a na końcu nie ma ukośnika „/”.
OutlookFolderPath	Wprowadź ścieżkę folderu utworzoną we współdzielonej skrzynce pocztowej. Jeśli nie zostanie utworzony żaden inny folder, system domyślnie ustawi folder Skrzynka odbiorcza. Przykładowa wartość: Skrzynka odbiorcza Najlepszym rozwiązaniem jest utworzenie oddzielnego folderu do zarządzania wydatkami
Identyfikator adresu skrzynki pocztowej	Wprowadź adres e-mail nowo utworzonej udostępnionej skrzynki pocztowej Przykładowa wartość: expenseagent@contoso.com
Nazwa połączenia usługi Microsoft Dataverse Nazwa połączenia programu Microsoft Copilot Studio Nazwa połączenia programu Microsoft Office Outlook Nazwa połączenia użytkowników usługi Microsoft Office 365 Nazwa połączenia usługi Microsoft Teams	Dane wejściowe wszystkich nazw połączeń są takie same i jest to identyfikator e-mail utworzonego użytkownika agenta. Przykładowa wartość: createdexpenseagentuser@contoso.com

Tworzenie pliku skryptu instalacji

Utwórz plik skryptu instalacji, kopiując następujący kod. Wstaw wymagane zmienne środowiskowe do skryptu, a następnie uruchom skrypt przy użyciu programu PowerShell.

Uwaga / Notatka

Umieść plik skryptu instalacji na pulpicie lokalnym. Nie przechowuj go w usłudze One Drive.

Utwórz plik skryptu programu PowerShell przy użyciu następującego kodu. Zaktualizuj wymienione parametry przed uruchomieniem skryptu.

Napiwek

Kiedy Wymagane = $true, PowerShell wyświetla monit o interaktywne wprowadzenie parametrów, dzięki czemu nie trzeba ich aktualizować bezpośrednio w pliku skryptu.

Jeśli chcesz uniknąć ręcznego wprowadzania danych wejściowych i chcesz wstępnie zdefiniować parametry w skrygcie instalacji, ustaw opcję Obowiązkowe = $false w sekcji Param następującego przykładowego kodu.

Skopiuj następujący kod do pliku skryptu instalacji i zapisz go jako "Install.ps1". Zaktualizuj zmienne w odpowiednich polach parametrów w sekcji param. Należy zaktualizować 10 zmiennych.

Napiwek

Użyj poprzedniej tabeli jako materiału referencyjnego i zastąp wszystkie przykładowe wartości odpowiednimi danymi.

#requires -Version 7
Param(

   [Parameter(Mandatory=$true, HelpMessage="Dataverse environment id")]
   [string]$DataverseEnvironmentId = "xxxx-xxxx-xxxx-xxx-xxxxxxxxxx", 

   [Parameter(Mandatory=$true, HelpMessage="Dataverse environment URL")]
   [string]$DataverseUrl = "https://org123.crm.dynamics.com",

   [Parameter(Mandatory=$true, HelpMessage="Finance and Operations instance URL")]
   [string]$D365FinanceAndOperationsUrl = "https://org123.operations.dynamics.com",

   [Parameter(Mandatory=$true, HelpMessage="OutlookFolderPath")]
   [string]$OutlookFolderPath = "Inbox",

   [Parameter(Mandatory=$true, HelpMessage="Mailbox Address Id")]
   [string]$MailboxAddressId = "expenseagent@contoso.com",

   [Parameter(Mandatory=$true, HelpMessage="Microsoft Dataverse connection name")]
   [string]$MicrosoftDataverseConnectionName = "createdexpenseagentuser@contoso.com",

   [Parameter(Mandatory=$true, HelpMessage="Microsoft Copilot Studio connection name")]
   [string]$MicrosoftCopilotStudioConnectionName = "createdexpenseagentuser@contoso.com",
   
   [Parameter(Mandatory=$true, HelpMessage="Microsoft Office Outlook connection name")]
   [string]$Office365OutlookConnectionName = "createdexpenseagentuser@contoso.com",

   [Parameter(Mandatory=$true, HelpMessage="Microsoft Office 365 Users connection name")]
   [string]$Office365UsersConnectionName = "createdexpenseagentuser@contoso.com",

   [Parameter(Mandatory=$true, HelpMessage="Microsoft Teams connection name")]
   [string]$MicrosoftTeamsConnectionName = "createdexpenseagentuser@contoso.com",

   [Parameter(Mandatory=$false, HelpMessage="Checks for bot Sync Errors and if there is provisioning required before Agent publish step")]
   [boolean]$CheckBotSyncStatusAndProvisionBots = $false

)

$flows = @(
    "expense entry retry check",
    "expense configuration",
    "get expense outlook folder",
    "generate expense report",
    "send expense report adaptive card",
    "auto match expenses",
    "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 calendar events",
    "process expense report using copilot",
    "invoke expense agent for receipt processing"
)


$agents = @(
    "msdyn_ExpenseEntryAgent",
    "msdyn_ExpenseReportAgent"
)


# Check PS version
if ($PSVersionTable.PSVersion.Major -lt 7) {
    Write-Error 'This script requires at least PowerShell version 7' -ErrorAction Stop
}

# Install the required modules if not already installed or if the version is not 1.0.40
if (-not (Get-Module -ListAvailable -Name Microsoft.PowerApps.PowerShell | Where-Object { $_.Version -ge [Version]"1.0.40" })) {
    Write-Host "Microsoft.PowerApps.PowerShell version 1.0.40 not found. Installing..." -ForegroundColor Yellow
    Install-Module -Name Microsoft.PowerApps.PowerShell -RequiredVersion 1.0.40 -Force -AllowClobber -Scope CurrentUser
} else {
    Write-Host "Microsoft.PowerApps.PowerShell version 1.0.40 is already installed." -ForegroundColor Green
}

if (-not (Get-Module -ListAvailable -Name Microsoft.PowerApps.Administration.PowerShell | Where-Object { $_.Version -ge [Version]"2.0.147" })) {
    Install-Module -Name Microsoft.PowerApps.Administration.PowerShell -RequiredVersion 2.0.147 -Force -AllowClobber -Scope CurrentUser
}

# Install the required modules if not already installed
if (-not (Get-Module -ListAvailable -Name Az.Accounts | Where-Object { $_.Version -ge [Version]"5.0.1"})) {
    Install-Module -Name Az.Accounts -RequiredVersion 5.0.1 -Force -AllowClobber -Scope CurrentUser
}

# Import required modulesds
Import-Module Az.Accounts
Import-Module Microsoft.PowerApps.PowerShell
Import-Module Microsoft.PowerApps.Administration.PowerShell

# global variable declaration
$filter = '$filter'


function Get-AccessToken {
    # Retrieve the access token for the Dataverse environment
    $accessToken = (Get-AzAccessToken -ResourceUrl "$DataverseUrl" -AsSecureString).Token
    Write-Host "Access token for $userId retrieved successfully." -ForegroundColor Green
    return $accessToken
}

function Get-AccessTokenPlainText {
    param(
        [Parameter(Mandatory=$true, HelpMessage="Access token for authentication")]
        [securestring]$accessToken
    )
    # Retrieve the access token for the PVA environment
    $token = [Runtime.InteropServices.Marshal]::PtrToStringAuto(
    [Runtime.InteropServices.Marshal]::SecureStringToBSTR($accessToken))
    return $token
}

function update-EnvironmentVaribleValue {
        param (
        [string]$accessToken,
        [string]$env_key,
        [string]$env_value   # Access token for authentication
    )

    try 
    {
        # Get the environment variable definition
        $envVarDefinition = Invoke-RestMethod -Method Get -Uri "$DataverseUrl/api/data/v9.2/environmentvariabledefinitions?$filter=schemaname eq '$env_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 = $env_value } | ConvertTo-Json -Depth 1)
                Write-Host "Environment variable updated with name $env_key and value $env_value" -ForegroundColor Green
            } else {
                Write-Host "Environment variable value not found for $env_key. Skipping..." -ForegroundColor Red
            }
        } 
        else {
            Write-Host "Environment variable definition not found for $env_key. Skipping..." -ForegroundColor Yellow
        }
  }
  catch {
        Write-Host "Failed to update environment variable $env_key. Error: $($_)" -ForegroundColor Red
        throw $_  # Re-throw the error to stop the script if this step is critical
    }

}

function update_EnvironmentVariablesForExpense {
        param (
        [string]$accessToken   # Access token for authentication
    )

    write-host "Updating environment variables..." -ForegroundColor Yellow

    try 
    {
        update-EnvironmentVaribleValue -accessToken $accessToken -env_key "msdyn_ExpenseFnoInstanceUrl" -env_value $D365FinanceAndOperationsUrl
        update-EnvironmentVaribleValue -accessToken $accessToken -env_key "msdyn_ExpenseAgentOutlookFolderPath" -env_value $OutlookFolderPath
        update-EnvironmentVaribleValue -accessToken $accessToken -env_key "msdyn_ExpenseAgentMailboxAddressId" -env_value $MailboxAddressId
        
    }
    Catch {
        Write-Host "Failed to update environment variables. Error: $($_)" -ForegroundColor Red -ErrorAction Stop
    }
}

# 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
    )

    # 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 Get-ConnectionId {
    param (
        [string]$userProvidedName,
        [string]$providerName
    )

    try {
        $matchedConnectionId = $null
        # Added -ErrorAction Stop to ensure the catch block is triggered on failure
        $connections = Get-PowerAppConnection -EnvironmentName $DataverseEnvironmentId -ConnectorNameFilter $providerName -ErrorAction Stop
        
        foreach ($con in $connections) {
            if (($con.ConnectionName -eq $userProvidedName) -or ($con.DisplayName -eq $userProvidedName)) {
                $matchedConnectionId = $con.ConnectionName
                break
            }
        }

        if ($null -eq $matchedConnectionId) {
            # Use 'throw' to create a terminating error that the calling function can catch
            throw "Unable to find connection '$userProvidedName' for provider '$providerName'."
        }

        return $matchedConnectionId
    }
    catch {
        # Catch any errors from Get-PowerAppConnection or the 'throw' statement above
        Write-Error "Failed to get connection ID for '$userProvidedName'. Error: $_"
        throw # Re-throw the error to stop the script if this step is critical
    }
}

function Get-ConnectionReferenceId {
    param(
        [string]$connectionReferenceLogicalName,
        [securestring]$accessToken
    )

    try {
        $uri = "$DataverseUrl/api/data/v9.2/connectionreferences?$filter=connectionreferencelogicalname eq '$connectionReferenceLogicalName'"
        
        # Added -ErrorAction Stop for clarity, though Invoke-RestMethod often terminates on HTTP errors
        $response = Invoke-RestMethod -Method Get -Uri $uri -Authentication Bearer -Token $accessToken -ContentType 'application/json' -ErrorAction Stop
            
        if ($null -eq $response -or $response.value.Count -eq 0) {
            throw "Connection reference not found for logical name '$connectionReferenceLogicalName'."
        }

        $connectionReferenceDisplayName = $response.value[0].connectionreferencedisplayname
        $connectionReferenceId = $response.value[0].connectionreferenceid

        Write-Host "updating connection $connectionReferenceDisplayName for logical name $connectionReferenceLogicalName)"
        return $connectionReferenceId
    }
    catch {
        Write-Error "Failed to get connection reference ID for '$connectionReferenceLogicalName'. Error: $_"
        throw # Re-throw to notify the calling function
    }
}

function Set-ConnectionReferenceConnection {
    param (
        [string]$connectionReferenceLogicalName,
        [string]$userProvidedConnectionName,
        [string]$providerName,
        [securestring]$accessToken
    )

    try {

        # These functions will now throw terminating errors if they fail
        $connectionReferenceId = Get-ConnectionReferenceId -connectionReferenceLogicalName $connectionReferenceLogicalName -accessToken $accessToken
        $connectionId = Get-ConnectionId -userProvidedName $userProvidedConnectionName -providerName $providerName

        $body = @{
            "connectionid" = "$connectionId"
        } | ConvertTo-Json -Depth 1

        $uri = "$DataverseUrl/api/data/v9.2/connectionreferences($connectionReferenceId)"
        # Write-Host "Updating connection reference URI: $uri with connection id $connectionId"

        Invoke-RestMethod -Method Patch -Uri $uri -Authentication Bearer -Token $accessToken -ContentType 'application/json' -Body $body -ErrorAction Stop
    
        Write-Host "Connection reference updated successfully." -ForegroundColor Green
    }
    catch {
        # This block will catch errors from any of the functions called within the try block
        Write-Error "Failed to set connection reference for '$connectionReferenceLogicalName'. Error: $_"
        throw
    }
}

function Activate-Flows {
    param (
        [string]$accessToken,
        [array]$expenseAIFlows
    )

    foreach ($flowName in $expenseAIFlows) {
         Write-Host "Activating 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
            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: $($_)" -ForegroundColor Red
        return $null
    }
}

function Check-BotSyncErrors {
        param (
        [string]$DataverseUrl,
        [string]$accessToken,
        [string]$botId
    )

    Write-Host "Retrieving Sync Status for bot ID: $botId" -ForegroundColor Yellow

    # Construct the API endpoint to retrieve the bot
    $uri = "$DataverseUrl/api/data/v9.2/bots($botId)"
    try {
        # Make the API call
        $response = Invoke-RestMethod -Method Get -Uri $uri -Headers @{
            Authorization = "Bearer $accessToken"
            "Content-Type" = "application/json"
        }

        if ($null -ne $response.synchronizationstatus) {
            # Parse the JSON string in synchronizationstatus
            $syncStatusObj = $response.synchronizationstatus | ConvertFrom-Json
            $state = $syncStatusObj.currentSynchronizationState.state
            $provisioningStatus = $syncStatusObj.currentSynchronizationState.provisioningStatus

            Write-Host "Synchronization State: $state" -ForegroundColor Green
            Write-Host "Provisioning Status: $provisioningStatus" -ForegroundColor Green

            if ( $state -contains "Error" -or $provisioningStatus -contains "Error") {
                Write-Host "Bot has synchronization errors." -ForegroundColor Red
                return 0
            } else {
                if ( $state -eq "Synchronized" -or $state -eq 'Synchronizing' -and ($provisioningStatus -eq  "Provisioned" -or $provisioningStatus -eq  "ProvisionedWithoutRegistration")) {
                    Write-Host "Bot synchronization is done." -ForegroundColor Yellow
                    return 1
                } else {
                    Write-Host "Bot synchronization is in progress." -ForegroundColor Green
                    return 2
                }
            }
        } else {
            Write-Host "No synchronization status found for bot ID: $botId" -ForegroundColor Red
            return $null
        }
    } catch {
        Write-Host "Failed to retrieve agent ID. Error: $($_)" -ForegroundColor Red
        return $null
    }
}


# Function to provision a PVA bot
function Provision-Agent {
    param (
        [string]$DataverseUrl,
        [string]$accessToken,
        [string]$agentId
    )

    # Construct the API endpoint for publishing the bot
    $uri = "$DataverseUrl/api/data/v9.2/bots($agentId)/Microsoft.Dynamics.CRM.PvaProvision"

    try {
        # Make the API call
        Invoke-RestMethod -Method Post -Uri $uri -Headers @{
            Authorization = "Bearer $accessToken"
            "Content-Type" = "application/json"
        }

        Write-Host "Agent Provisioning successfully!" -ForegroundColor Green
        # Add 30 second delay to allow the publish process to complete
        Start-Sleep -Seconds 30
        return $true
    } catch {
        Write-Host "Failed to Provision Agent. Error: $($_.Exception.Message)" -ForegroundColor Red
    }
    return $false
}


# 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) {
                    # check for sync errors
                    if ($CheckBotSyncStatusAndProvisionBots) {
                        $syncStatus = Check-BotSyncErrors -dataverseUrl $DataverseUrl -accessToken $accessToken -botId $agentId
                        if (0 -eq $syncStatus) {
                            Write-Host "Agent has sync errors. Skipping the publish process. Please check the bot: $agentId details" -ForegroundColor Red
                            continue
                        } elseif (2 -eq $syncStatus) {
                            Write-Host "Agent synchronization is still in progress. reprovisioning the agent." -ForegroundColor Yellow
                            if (Provision-Agent -dataverseUrl $DataverseUrl -accessToken $accessToken -agentId $agentId -eq $false) {
                                Write-Host "Agent reprovisioning failed. Skipping the publish process. Please check the bot: $agentId details" -ForegroundColor Red
                                continue
                            }
                        } else {
                            Write-Host "Agent synchronization is done. Proceeding to publish." -ForegroundColor Green
                        }
                    }
                    # 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 {

    $expenseAIFlows = $flows
    $agentSchemas = $agents

    # Step 1: Interactive login to Azure
    Connect-AzAccount -UseDeviceAuthentication
    $accessToken = Get-AccessToken
    $accessTokenPlainText = Get-AccessTokenPlainText -accessToken $accessToken

    # Step 2: Setup ennviornment variables
    update_EnvironmentVariablesForExpense -accessToken $accessTokenPlainText 
    Write-Host "Environment variables updated successfully!" -ForegroundColor Green

    # Step 3: Check active connections
    Set-ConnectionReferenceConnection -userProvidedConnectionName $MicrosoftDataverseConnectionName -providerName "/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps" -connectionReferenceLogicalName "msdyn_sharedcommondataserviceforapps_2c2d4" -accessToken $accessToken

    Set-ConnectionReferenceConnection -userProvidedConnectionName $MicrosoftCopilotStudioConnectionName -providerName "/providers/Microsoft.PowerApps/apis/shared_microsoftcopilotstudio" -connectionReferenceLogicalName "msdyn_sharedmicrosoftcopilotstudio_26d9d" -accessToken $accessToken

    Set-ConnectionReferenceConnection -userProvidedConnectionName $Office365OutlookConnectionName -providerName "/providers/Microsoft.PowerApps/apis/shared_office365" -connectionReferenceLogicalName "msdyn_sharedoffice365_9b471" -accessToken $accessToken

    Set-ConnectionReferenceConnection -userProvidedConnectionName $MicrosoftTeamsConnectionName -providerName "/providers/Microsoft.PowerApps/apis/shared_teams" -connectionReferenceLogicalName "msdyn_sharedteams_8ea9c" -accessToken $accessToken

    Set-ConnectionReferenceConnection -userProvidedConnectionName $Office365UsersConnectionName -providerName "/providers/Microsoft.PowerApps/apis/shared_office365users" -connectionReferenceLogicalName "msdyn_sharedoffice365users_909b9" -accessToken $accessToken
    

    # Step 4: Activate flows
    Activate-Flows -accessToken $accessTokenPlainText -expenseAIFlows $expenseAIFlows

    # step 5: publish the agents
    Publish-Agents -accessToken $accessTokenPlainText -agentSchemas $agentSchemas

    # Step 6: Publish the solution 
    Publish-Solution -accessToken $accessTokenPlainText

    Write-Host "Agent setup completed successfully!" -ForegroundColor Green

} catch {
    Write-Host "An error occurred: $_" -ForegroundColor Red
}

Aby wyzwolić plik programu PowerShell, wykonaj następujące kroki:

1. Otwórz program PowerShell (wymagana minimalna wersja — PowerShell 7).
2. Przejdź do lokalizacji, w której zapisałeś plik. (Użyj polecenia cd <lokalizacja pliku>).
3. Zainicjuj skrypt instalacji. (Użyj polecenia „.\Install.ps1”).
4. Postępuj zgodnie z instrukcjami, aby zalogować się na platformie Azure.
5. Po zalogowaniu może być konieczne autoryzowanie jeszcze raz. (Użyj utworzonego użytkownika agenta z odnośnym identyfikatorem).

Poczekaj na całkowite uruchomienie skryptu i poszukaj komunikatu Instalacja agenta została ukończona pomyślnie!

Uwaga / Notatka

Powyższy skrypt wykonuje następujące akcje:

• Ustawia zmienne środowiskowe.
• Weryfikuje i łączy referencje połączeń.
• Włącza przepływy usługi Power Automate.
• Publikuje agentów Copilot wymaganych.
• Publikuje rozwiązanie Dataverse.

Po pomyślnym wykonaniu skryptu agent wydatków jest w pełni skonfigurowany i gotowy do użycia.

Opcja B: Ręczne konfigurowanie w usłudze Power Apps (bez programu PowerShell)

Jeśli nie chcesz używać skryptu programu PowerShell, możesz ręcznie skonfigurować agenta wydatków za pomocą usługi Power Apps. Ten proces obejmuje aktualizowanie zmiennych środowiskowych, włączanie przepływów Power Automate i publikowanie rozwiązania.

Aktualizacja zmiennych środowiskowych

Aby zaktualizować zmienne środowiskowe, wykonaj następujące kroki:

1. Zaloguj się do Power Apps i wybierz środowisko.

2. Wybierz pozycję Rozwiązania, a następnie otwórz pozycję Rozwiązanie domyślne (lub rozwiązanie, w którym zainstalowano agenta).

3. Przejdź do pozycji Zmienne środowiskowe i ustaw następujące wartości.

   Nazwa zmiennej	Opis
   Ścieżka folderu programu Outlook agenta wydatków	Określ ścieżkę folderu do monitorowania we współdzielonej skrzynce pocztowej (domyślnie Skrzynka odbiorcza).
   Identyfikator adresu udostępnionej skrzynki pocztowej agenta wydatków	Określ adres e-mail współdzielonej skrzynki pocztowej. Aby użyć skrzynki pocztowej zalogowanego użytkownika, wprowadź NA.
   Adres URL wystąpienia programu Finance and Operations	Określ adres URL środowiska aplikacji finansowych i operacyjnych (na przykład https://org123.contoso.com).

Włączanie przepływów usługi Power Automate

Agent wydatków korzysta z następujących przepływów usługi Power Automate:

• Sprawdzanie ponownej próby wprowadzenia wydatków
• Konfiguracja wydatków
• Pobieranie folderu wydatków z programu Outlook
• Generowanie raportu wydatków
• Wysyłanie karty adaptacyjnej raportu z wydatków
• Automatyczne dopasowywanie wydatków
• Przetwarzaj wiadomości e-mail
• Wyodrębnianie niedołączonych identyfikatorów paragonów dla wywołania pomocnika
• Wyodrębnianie danych wyjściowych niedołączonych paragonów przy użyciu wtyczki usługi Dataverse
• Generowanie wiersza wydatków
• Generowanie wiersza wydatków bez identyfikatora projektu ani identyfikatora stanu
• Wykrywanie identyfikatorów projektów
• Zdarzenia kalendarza użytkownika
• Przetwarzanie raportu wydatków za pomocą pomocnika
• Wywoływanie agenta wydatków na potrzeby przetwarzania paragonów

Aby włączyć przepływy, wykonaj następujące kroki:

1. Zaloguj się do Power Automate i wybierz środowisko.

2. Wybierz pozycję Moje przepływy.

3. Dla każdego z 15 przepływów na poprzedniej liście wykonaj następujące kroki:

   1. Znajdź przepływ.
   2. Wybierz Edytuj.
   3. Przełącz się do widoku Stary projektant poprzez wyłączenie opcji Nowy projektant.
   4. Uwierzytelnij wszystkie wymagane połączenia (poczekaj, aż pojawią się zielone znaczniki wyboru).
   5. Wybierz Kontynuuj, a następnie wybierz Zapisz.
   6. Wybierz opcję Włącz, aby włączyć przepływ.

Publikowanie rozwiązania

Po zakończeniu konfigurowania wszystkich zmiennych środowiskowych i przepływów wykonaj następujące kroki, aby opublikować rozwiązanie.

1. W usłudze Power Apps przejdź do pozycji Rozwiązania.
2. Wybierz środowisko i rozwiązanie.
3. Wybierz Publikuj wszystkie dostosowania.

Po wykonaniu tych kroków agent wydatków jest w pełni skonfigurowany i gotowy do użycia.

Krok 6. Włączanie agenta wydatków w usłudze Microsoft Teams (opcjonalnie)

Aby włączyć komunikację opartą na platformie Teams dla agenta do rozliczania wydatków, dodaj kanał Teams do agenta w Power Apps. Agent może następnie wysyłać karty adaptacyjne za pośrednictwem usługi Teams.

Włączanie kanału aplikacji Teams

Aby włączyć kanał usługi Teams, wykonaj następujące kroki:

1. Zaloguj się do aplikacji Copilot Studio i wybierz odpowiednie środowisko.
2. Na karcie Agenci wybierz pozycję Agent wprowadzania wydatków.
3. W widoku agenta na karcie Kanały wybierz pozycję Teams i Microsoft 365 Copilot.
4. Wybierz pozycję Dodaj kanał, aby włączyć integrację z usługą Teams, i wykonaj kroki opisane w sekcji Konfigurowanie dostępności aplikacji Teams, aby określić, komu ma zostać udostępniona aplikacja.

Więcej się dowiesz w temacie Otwieranie panelu konfiguracji dla kanału usługi Teams i platformy Microsoft 365.

Konfigurowanie dostępności aplikacji Teams

Aby skonfigurować dostępność aplikacji Teams, wykonaj następujące kroki:

1. Po utworzeniu aplikacji Teams wybierz pozycję Opcje dostępności.

2. Określ, komu chcesz udostępnić aplikację:

   • Określeni użytkownicy w organizacji
   • Cała organizacja

3. Prześlij aplikację do zatwierdzenia.

Publikowanie aplikacji w centrum administracyjnym usługi Teams

Aby opublikować aplikację w centrum administracyjnym usługi Teams, wykonaj następujące kroki:

1. Zaloguj się w Centrum administracyjnym Teams.
2. Przejdź do aplikacji Teams i zarządzaj aplikacjami>. Wyszukaj hasło „wydatki” i wybierz aplikację Agent wprowadzania wydatków mającą status zablokowania.
3. Wybierz Publikuj, aby odblokować aplikację. Po pomyślnym zakończeniu akcji publikowania upewnij się, że stan aplikacji zmieni się na odblokowany.

Więcej informacji:Łączenie i konfiguracja agenta dla aplikacji Teams i Microsoft 365.

Po wykonaniu tych kroków agent wydatków jest gotowy do użycia.

Uwaga / Notatka

Możesz również przekazać opinię na temat wierszy wydatków generowanych przez agentów i raportów, używając ikon kciuka w górę i kciuka w dół oraz wyskakujących okienek opinii w środowisku dynamics 365 Finance.

Odinstalowywanie agenta wydatków

Aby odinstalować agenta wydatków, wykonaj następujące kroki:

1. Zaloguj się do portalu twórców usługi Microsoft Power Apps.
2. Wybierz pozycję Rozwiązania, wyszukaj środowisko msdyn_ExpenseAI, kliknij wielokropek i kliknij polecenie Usuń.
3. Wyszukaj środowisko msdyn_FnOCopilotAnchor i usuń rozwiązanie.