Share via

Praca z przepływami w chmurze przy użyciu kodu

  • Artykuł

Wszystkie przepływy są przechowywane w Dataverse i można zarządzać nimi przy użyciu zestawu Dataverse SDK dla programu .NET lub internetowego interfejsu API.

W tym artykule omówiono zarządzanie przepływami zawartymi na karcie Rozwiązania w usłudze Power Automate. Obecnie zarządzanie przepływami w obszarze Moje przepływy nie jest obsługiwane przez kod.

Interakcja z interfejsami API usługi Dataverse

Usługa Dataverse umożliwia dostęp do równoważnych funkcji za pomocą zestawu Dataverse SDK dla programu .NET lub internetowego interfejsu API.

Której metody należy użyć?

Najlepsza metoda zależy od technologii projektów i posiadanych umiejętności.

Jeśli do realizacji projektu jest używany program .NET, zaleca się użycie zestawu SDK. Zestaw SDK upraszcza proces developmentu, udostępniając opisany model obiektu i metody uwierzytelniania.

Więcej informacji: Korzystanie z usługi Organizacja

Jak nawiązać połączenie?

Sposób połączenia zależy od tego, czy jest korzystasz z zestawu Dataverse SDK dla platformy .NET czy internetowego interfejsu API.

Jeśli używasz zestawu SDK, należy połączyć się z aplikacją kliencką, aby uzyskać dostęp do wystąpienia usługi IOrganizationService. IOrganizationService to interfejs oferujący metody współpracy z usługą Dataverse.

Więcej informacji:

Tabela przepływu pracy

Przepływy w chmurze są przechowywane w tabeli Proces (przepływ pracy), która jest reprezentowana w internetowym interfejsie API jako element EntityType przepływu pracy

W poniższej tabeli opisano ważne kolumny tabeli przepływu pracy:

Nazwa logiczna Type opis
category Opcja wyboru Kategoria przepływu. Oto różne kategorie.
0 — klasyczne przepływy pracy usługi Dataverse.
1 — klasyczne sesje dialogowe usługi Dataverse.
2 — reguły biznesowe.
3 — klasyczne akcje usługi Dataverse.
4 — przepływy procesów biznesowych.
5 — nowoczesny przepływ (przepływy zautomatyzowane, błyskawiczne lub zaplanowane).
6 — przepływy pulpitu.
clientdata String Kodowany ciąg JSON definicji przepływu i jej connectionReferences.
createdby Lookup Użytkownik, który utworzył przepływ.
createdon DateTime Data utworzenia przepływu.
description String Podany przez użytkownika opis przepływu.
ismanaged Bool Wskazuje, czy przepływ został zainstalowany przy użyciu rozwiązania zarządzanego.
modifiedby Lookup Ostatni użytkownik, który zaktualizował przepływ.
modifiedon DateTime Czas ostatniej aktualizacji przepływu.
name String Nazwa wyświetlana nadana przepływowi przez Ciebie.
ownerid Lookup Użytkownik lub zespół, do którego należy przepływ.
statecode Opcja wyboru Stan przepływu. Dozwolone stany:
0 — wersja robocza (wył.)
1 — aktywowany (wł.)
2 — zawieszony.
type Opcja wyboru Wskazuje, czy przepływ to uruchomiony przepływ, czy szablon, którego można użyć do tworzenia więcej przepływów.
1 — definicja
2 — aktywacja
3 — szablon.
workflowid Identyfikator GUID Unikatowy identyfikator dla przepływu w chmurze we wszystkich importach.
workflowidunique Identyfikator GUID Unikatowy identyfikator dla tej instalacji przepływu.

Uwaga

W przypadku internetowego interfejsu API wartości wyszukiwania to właściwości nawigacji o pojedynczej wartości, które można rozwinąć, aby uzyskać szczegółowe informacje z rekordu pokrewnego.

Kolumny wyszukiwania mają także odpowiednie właściwości wyszukiwania identyfikatora GUID, które mogą być używane w zapytaniach. Właściwości wyszukiwania mają tę konwencję nazewnictwa: _<logical name>_value. W przypadku typu encji przepływu pracy w internetowym interfejsie API można odwoływać się do tych właściwości wyszukiwania: _createdby_value, _modifiedby_value i _ownerid_value.

Utwórz listę przepływów

Aby pobrać listę przepływów w chmurze, można wykonać zapytanie o tabelę przepływu pracy. Następujące zapytanie zwraca najpierw zautomatyzowany, błyskawiczny lub zaplanowany przepływy, które jest obecnie włączony:

Ta statyczna metoda OutputFirstActiveFlow wymaga uwierzytelnionego klienta, który implementuje usługę IOrganizationService. Korzysta on z metody IOrganizationService.RetrieveMultiple.

/// <summary>
/// Outputs the first active flow
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
public static void OutputFirstActiveFlow(IOrganizationService service)
{
   var query = new QueryExpression("workflow")
   {
         ColumnSet = new ColumnSet("category",
                                    "createdby",
                                    "createdon",
                                    "description",
                                    "ismanaged",
                                    "modifiedby",
                                    "modifiedon",
                                    "name",
                                    "ownerid",
                                    "statecode",
                                    "type",
                                    "workflowid",
                                    "workflowidunique"),
         Criteria = new FilterExpression(LogicalOperator.And)
         {
            Conditions = {
            {  new ConditionExpression(
               "category",
                     ConditionOperator.Equal,
                     5) }, // Cloud Flow
            {  new ConditionExpression(
                     "statecode",
                     ConditionOperator.Equal,
                     1) } // Active
         }
         },
         TopCount = 1 // Limit to one record
   };

   EntityCollection workflows = service.RetrieveMultiple(query);

   Entity workflow = workflows.Entities.FirstOrDefault();

   Console.WriteLine($"category: {workflow.FormattedValues["category"]}");
   Console.WriteLine($"createdby: {workflow.FormattedValues["createdby"]}");
   Console.WriteLine($"createdon: {workflow.FormattedValues["createdon"]}");
   // Description may be null
   Console.WriteLine($"description: {workflow.GetAttributeValue<string>("description")}");
   Console.WriteLine($"ismanaged: {workflow.FormattedValues["ismanaged"]}");
   Console.WriteLine($"modifiedby: {workflow.FormattedValues["modifiedby"]}");
   Console.WriteLine($"modifiedon: {workflow.FormattedValues["modifiedon"]}");
   Console.WriteLine($"name: {workflow["name"]}");
   Console.WriteLine($"ownerid: {workflow.FormattedValues["ownerid"]}");
   Console.WriteLine($"statecode: {workflow.FormattedValues["statecode"]}");
   Console.WriteLine($"type: {workflow.FormattedValues["type"]}");
   Console.WriteLine($"workflowid: {workflow["workflowid"]}");
   Console.WriteLine($"workflowidunique: {workflow["workflowidunique"]}");
}

Aby pobrać więcej rekordów, należy usunąć limit TopCount.

Wyjście

category: Modern Flow
createdby: SYSTEM
createdon: 5/20/2020 9:37 PM
description:
ismanaged: Unmanaged
modifiedby: Kiana Anderson
modifiedon: 5/6/2023 3:37 AM
name: When an account is updated -> Create a new record
ownerid: Monica Thomson
statecode: Activated
type: Definition
workflowid: d9e875bf-1c9b-ea11-a811-000d3a122b89
workflowidunique: c17af45c-10a1-43ca-b816-d9cc352718cf

Więcej informacji:

Tworzenie przepływu w chmurze

Wymagane właściwości przepływów zautomatyzowanych, błyskawicznych i zaplanowanych to: category, name, type, primaryentity i clientdata. Użyj wartości none dla właściwości primaryentity w przypadku tych typów przepływów.

Ta statyczna metoda wymaga uwierzytelnionego klienta, który implementuje usługę IOrganizationService. Korzysta on z metody IOrganizationService.Create.

/// <summary>
/// Creates a cloud flow
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <returns>The workflowid</returns>
public static Guid CreateCloudFlow(IOrganizationService service)
{
   var workflow = new Entity("workflow")
   {
         Attributes = {
            {"category", new OptionSetValue(5) }, // Cloud flow
            {"name", "Sample flow name"},
            {"type", new OptionSetValue(1) }, //Definition
            {"description", "This flow reads some data from Dataverse." },
            {"primaryentity", "none" },
            {"clientdata", "{\"properties\":{\"connectionReferences\":{\"shared_commondataserviceforapps\":{\"impersonation\":{},\"runtimeSource\":\"embedded\",\"connection\":{\"name\":\"shared-commondataser-114efb88-a991-40c7-b75f-2693-b1ca6a0c\",\"connectionReferenceLogicalName\":\"crdcb_sharedcommondataserviceforapps_109ea\"},\"api\":{\"name\":\"shared_commondataserviceforapps\"}}},\"definition\":{\"$schema\":\"https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#\",\"contentVersion\":\"1.0.0.0\",\"parameters\":{\"$connections\":{\"defaultValue\":{},\"type\":\"Object\"},\"$authentication\":{\"defaultValue\":{},\"type\":\"SecureObject\"}},\"triggers\":{\"manual\":{\"metadata\":{\"operationMetadataId\":\"76f87a86-89b3-48b4-92a2-1b74539894a6\"},\"type\":\"Request\",\"kind\":\"Button\",\"inputs\":{\"schema\":{\"type\":\"object\",\"properties\":{},\"required\":[]}}}},\"actions\":{\"List_rows\":{\"runAfter\":{},\"metadata\":{\"operationMetadataId\":\"9725b30f-4a8e-4695-b6fd-9a4985808809\"},\"type\":\"OpenApiConnection\",\"inputs\":{\"host\":{\"apiId\":\"/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps\",\"connectionName\":\"shared_commondataserviceforapps\",\"operationId\":\"ListRecords\"},\"parameters\":{\"entityName\":\"accounts\",\"$select\":\"name\",\"$top\":1},\"authentication\":\"@parameters('$authentication')\"}}}}},\"schemaVersion\":\"1.0.0.0\"}" }
         }
   };

   return service.Create(workflow);
}

Więcej informacji: Tworzenie wierszy tabel przy użyciu usługi Organizacja

Kod statecode wszystkich utworzonych w ten sposób przepływów jest ustawiany na 0 (Wersja robocza lub „Wył.”). Przepływ musi zostać włączony, aby można go było używać.

Najważniejsza właściwość to clientdata, która zawiera odwołania connectionReferences używane przez przepływ, oraz definicja przepływu. Odwołania connectionReferences to mapowania do każdego połączenia używanego w przepływie.

{
  "properties": {
    "connectionReferences": {
      "shared_commondataserviceforapps": {
        "runtimeSource": "embedded",
        "connection": {},
        "api": { 
         "name": "shared_commondataserviceforapps" 
         }
      }
    },
    "definition": {
      "$schema": "https://schema.management.azure.com/providers/Microsoft.Logic/schemas/2016-06-01/workflowdefinition.json#",
      "contentVersion": "1.0.0.0",
      "parameters": {
        "$connections": { "defaultValue": {}, "type": "Object" },
        "$authentication": { "defaultValue": {}, "type": "SecureObject" }
      },
      "triggers": {
        "manual": {
          "metadata": {},
          "type": "Request",
          "kind": "Button",
          "inputs": {
            "schema": { "type": "object", "properties": {}, "required": [] }
          }
        }
      },
      "actions": {
        "List_rows": {
          "runAfter": {},
          "metadata": {},
          "type": "OpenApiConnection",
          "inputs": {
            "host": {
              "apiId": "/providers/Microsoft.PowerApps/apis/shared_commondataserviceforapps",
              "connectionName": "shared_commondataserviceforapps",
              "operationId": "ListRecords"
            },
            "parameters": {
              "entityName": "accounts",
              "$select": "name",
              "$top": 1
            },
            "authentication": "@parameters('$authentication')"
          }
        }
      }
    }
  },
  "schemaVersion": "1.0.0.0"
}

Aktualizacja przepływu w chmurze

Aby zaktualizować przepływ, ustaw tylko te właściwości, które chcesz zmienić.

Ta statyczna metoda wymaga uwierzytelnionego klienta, który implementuje usługę IOrganizationService. Używa ona metody IOrganizationService.Update do aktualizowania opisu przepływu i ustawiania właściciela.

/// <summary>
/// Updates a cloud flow
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="workflowid">The ID of the flow to update.</param>
/// <param name="systemuserid">The id of the user to assign the flow to.</param>
public static void UpdateCloudFlow(IOrganizationService service, Guid workflowid, Guid systemuserid) {

   var workflow = new Entity("workflow",workflowid)
   {
         Attributes = {

            {"description", "This flow will ensure consistency across systems." },
            {"ownerid", new EntityReference("systemuser",systemuserid)},
            {"statecode", new OptionSetValue(1) } //Turn on the flow.
         }
   };

   service.Update(workflow);
}

Więcej informacji: Aktualizowanie i usuwanie wierszy tabeli przy użyciu aktualizacji Organizacja > Podstawowa

Usuwanie przepływ w chmurze

Poniższe przykłady pokazują sposób usuwania rekordu przepływu pracy reprezentującego przepływ w chmurze.

Metoda statyczna DeleteCloudFlow powoduje usunięcie rekordu przepływu pracy.

/// <summary>
/// Deletes a workflow
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="workflowId">The id of the cloud flow to delete.</param>
public static void DeleteCloudFlow(IOrganizationService service, Guid workflowId) { 

service.Delete(entityName:"workflow",id: workflowId);

}

Więcej informacji: Usuwanie rekordu przy użyciu zestawu SDK

Uzyskiwanie listy wszystkich użytkowników, którym udostępniono przepływ w chmurze

Użyj komunikatu RetrieveSharedPrincipalsAndAccess, aby pobrać listę wszystkich użytkowników, dla których jest udostępniany przepływ w chmurze.

W przypadku zestawu SDK użyj klasy RetrieveSharedPrincipalsAndAccessRequest, a w przypadku internetowego interfejsu API — funkcji RetrieveSharedPrincipalsAndAccess.

Więcej informacji: Pobieranie podmiotów zabezpieczeń z dostępem do rekordu

Udostępnianie lub anulowanie udostępniania przepływu w chmurze

Udostępnij przepływ w chmurze tak jak każdy inny rekord Dataverse, używając komunikatu GrantAccess. W przypadku zestawu SDK użyj klasy GrantAccessRequest, a w przypadku internetowego interfejsu API — akcji GrantAccess. Więcej informacji: Przykład akcji GrantAccess

Aby zmienić prawa dostępu nadane podczas udostępniania rekordu, użyj komunikatu ModifyAccess. W przypadku zestawu SDK użyj klasy ModifyAccessRequest, a w przypadku internetowego interfejsu API — akcji ModifyAccess. Więcej informacji: Przykład akcji ModifyAccess

Aby anulować udostępnianie rekordu, użyj komunikatu RevokeAccess. W przypadku zestawu SDK użyj klasy RevokeAccessRequest, a w przypadku internetowego interfejsu API — akcji RevokeAccess. Więcej informacji: Cofanie dostępu

Eksportowanie przepływów

Jeśli przepływ jest częścią rozwiązania, można go wyeksportować, eksportując rozwiązanie zawierające przepływ przy użyciu komunikatu ExportSolution.

Statyczna metoda przykładowa ExportSolution poniżej używa parametru ExportSolutionRequest w celu pobrania elementu byte[] zawierającego pliku ZIP rozwiązania niezarządzanego o określonej nazwie UniqueName.

/// <summary>
/// Exports an unmanaged solution
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="solutionUniqueName">The uniquename of the solution.</param>
/// <returns></returns>
public static byte[] ExportSolution(
   IOrganizationService service, 
   string solutionUniqueName) 
{
   ExportSolutionRequest request = new() { 
         SolutionName = solutionUniqueName,
         Managed = false
   };

   var response = (ExportSolutionResponse)service.Execute(request);

   return response.ExportSolutionFile;
}

Importowanie przepływów

Jeśli masz plik ZIP rozwiązania, możesz go zaimportować, korzystając z komunikatu ImportSolution.

Podczas importowania przepływów należy ustawić następujące parametry:

Nazwa właściwości opis
OverwriteUnmanagedCustomizations Jeśli istnieją wystąpienia tych przepływów w usłudze Dataverse, tę flagę należy ustawić na wartość true, aby je zaimportować. W przeciwnym razie nie zostaną one zastąpione.
PublishWorkflows Wskazuje, czy klasyczne przepływy pracy usługi Dataverse zostaną aktywowane przy importowaniu. To ustawienie nie ma zastosowania do innych typów przepływów.
CustomizationFile Plik zip zakodowany algorytmem base-64, który zawiera rozwiązanie.

Statyczna metoda przykładowa ImportSolution pokazuje, jak zaimportować plik rozwiązania przy użyciu klasy ImportSolutionRequest

/// <summary>
/// Imports a solution.
/// </summary>
/// <param name="service">Authenticated client implementing the IOrganizationService interface</param>
/// <param name="solutionFile">The byte[] data representing a solution file. </param>
public static void ImportSolution(
   IOrganizationService service, 
   byte[] solutionFile) {

   ImportSolutionRequest request = new() { 
         OverwriteUnmanagedCustomizations = true,
         CustomizationFile = solutionFile
   };

   service.Execute(request);
}

Zobacz też

Operacje klasy encji przy użyciu usługi Organizacja
Wykonywanie operacji przy użyciu internetowego interfejsu API
Udostępnianie i przypisywanie
Sprawdzanie dostępu w kodzie
Praca z rozwiązaniami przy użyciu zestawu Dataverse SDK