Partajați prin

Lucrul cu fluxurile pentru cloud folosind cod

  • Articol

Toate fluxurile sunt stocate în Dataverse și puteți folosi fie Dataverse SDK-ul pentru .NET, fie API-ul Web pentru a le gestiona.

Acest articol acoperă gestionarea fluxurilor incluse în fila Soluții în Power Automate. În prezent, gestionarea fluxurilor din Fluxurile mele nu este acceptată cu cod.

Interacționați cu Dataverse API-urile

Dataverse oferă capabilități echivalente folosind fie Dataverse SDK pentru .NET, fie API-ul web.

Ce metodă ar trebui să folosesc?

Cea mai bună metodă depinde de tehnologia proiectului și de competențe pe care îl aveți.

Dacă proiectul dvs. utilizează .NET, vă recomandăm să utilizați SDK-ul. SDK-ul vă simplifică experiența de dezvoltare, oferind un model de obiect tipat și metode de autentificare.

Mai multe informații: Utilizați serviciul Organizare

Cum să te conectezi?

Modul de conectare depinde dacă utilizați Dataverse SDK-ul pentru .NET sau Web API.

Cu SDK-ul, trebuie să vă conectați la o aplicație client pentru a obține acces la o IOrganizationService instanță. IOrganizationService este o interfață care oferă metode pe care le puteți utiliza pentru a interacționa cu Dataverse.

Informații suplimentare:

Tabelul fluxului de lucru

Fluxurile cloud sunt stocate în tabelul de proces (flux de lucru) care este reprezentat în API-ul web ca tip de entitate flux de lucru

Următorul tabel descrie coloanele importante din tabelul fluxului de lucru:

Nume logic Tipul Descriere
category Alegere Categoria fluxului. Iată diferitele categorii.
0 - Fluxuri de lucru Dataverse clasice.
1 - Dialoguri clasice Dataverse .
2 - Reguli de afaceri.
3 - Acțiuni Dataverse clasice.
4 - Fluxurile proceselor de afaceri.
5 - Flux modern (fluxuri automate, instant sau programate).
6 - Fluxuri desktop.
clientdata Șir Un JSON codificat în șir al definiției fluxului și referințelor de conexiune ale acestuia.
createdby Căutare Utilizatorul care a creat fluxul.
createdon DateTime Data la care a fost creat fluxul.
description Șir Descrierea fluxului furnizată de utilizator.
ismanaged Bool Indică dacă fluxul a fost instalat printr-un soluție gestionată.
modifiedby Căutare Ultimul utilizator care a actualizat fluxul.
modifiedon DateTime Ultima dată când fluxul a fost actualizat.
name Șir Numele afișat pe care l-ați dat fluxului.
ownerid Căutare Utilizatorul sau echipa care deține fluxul.
statecode Alegere Starea fluxului. Starea poate fi:
0 - Draft (Dezactivat)
1 - Activat (Activat)
2 - Suspendat.
type Alegere Indică dacă fluxul este un flux care rulează sau un șablon care poate fi utilizat pentru a crea mai multe fluxuri.
1 - Definiție,
2 - Activare
3 - Șablon.
workflowid GUID Identificatorul unic pentru un flux pentru cloud pentru toate importurile.
workflowidunique GUID Identificatorul unic pentru această instalare a fluxului.

Notă

Cu API-ul web, valorile de căutare sunt proprietăți de navigare cu o singură valoare care pot fi extinse pentru a obține detalii din înregistrarea aferentă.

De asemenea, coloanele de căutare au GUID proprietăți de căutare care pot fi utilizate în interogări. Proprietățile de căutare au această convenție de denumire: _<logical name>_value. Pentru tipul de entitate al fluxului de lucru din API-ul web, puteți face referire la aceste proprietăți de căutare: _createdby_value, _modifiedby_value și _ownerid_value.

Listați fluxurile

Pentru a prelua o listă de fluxuri cloud, puteți interoga tabelul fluxului de lucru. Următoarea interogare returnează primul flux automat, instantaneu sau programat care este în prezent „activat”:

Această metodă statică OutputFirstActiveFlow necesită un client autentificat care implementează IOrganizationService. Utilizează metoda 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"]}");
}

Pentru a prelua mai multe înregistrări, eliminați limita TopCount .

Rezultat

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

Informații suplimentare:

Creați un flux pentru cloud

Proprietățile necesare pentru fluxurile automate, instantanee și programate sunt: category, name, type, primaryentity și clientdata. Utilizați none pentru primaryentity pentru aceste tipuri de fluxuri.

Această metodă statică necesită un client autentificat care implementează IOrganizationService. Utilizează metoda 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);
}

Mai multe informații: Creați rânduri de tabel utilizând serviciul de organizare

statecode tuturor fluxurilor create în acest fel sunt setate la 0 (Ciornă sau „Dezactivat”). Fluxul trebuie să fie activat înainte de a putea fi utilizat.

Cea mai importantă proprietate este clientdata, care conține connectionReferences pe care le folosește fluxul și definiția a fluxului. connectionReferences sunt mapările la fiecare conexiune pe care o folosește fluxul.

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

Actualizați un flux pentru cloud

Pentru a actualiza un flux, setați numai proprietățile pe care doriți să le modificați.

Această metodă statică necesită un client autentificat care implementează IOrganizationService. Utilizează metoda IOrganizationService.Update pentru a actualiza o descriere a fluxului și a seta proprietarul.

/// <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);
}

Mai multe informații: Actualizați și ștergeți rândurile de tabel folosind Serviciul de organizare > Actualizare de bază

Ștergeți un flux pentru cloud

Următoarele exemple arată cum să ștergeți înregistrarea fluxului de lucru care reprezintă un flux pentru cloud.

Metoda DeleteCloudFlow statică șterge o înregistrare a fluxului de lucru.

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

}

Mai multe informații: Ștergeți o înregistrare folosind SDK-ul

Obțineți toți utilizatorii cărora li se partajează un flux pentru cloud

Utilizați RetrieveSharedPrincipalsAndAccess mesajul pentru a obține o listă cu toți utilizatorii cărora le este partajat un flux pentru cloud.

Cu SDK, utilizați Clasa RetrieveSharedPrincipalsAndAccessRequest, iar cu API-ul web utilizați Funcția RetrieveSharedPrincipalsAndAccess.

Mai multe informații: Obțineți directori cu acces la o înregistrare

Distribuiți sau anulați distribuirea unui flux pentru cloud

Distribuiți o flux pentru cloud ca orice altă Dataverse înregistrare folosind mesajul GrantAccess . Cu SDK-ul, utilizați GrantAccessRequest Class și cu API-ul web utilizați Acțiunea GrantAccess. Mai multe informații: Exemplu de GrantAccess

Dacă doriți să modificați drepturile de acces pe care le acordați atunci când partajați o înregistrare, utilizați ModifyAccess mesajul. Cu SDK, utilizați ModifyAccessRequest Class iar cu API-ul web utilizați ModifyAccess Action. Mai multe informații: Exemplu ModifyAccess

Pentru a anula distribuirea unei înregistrări, utilizați RevokeAccess mesajul. Cu SDK-ul, utilizați clasa RevokeAccessRequest și cu API-ul web utilizați acțiunea RevokeAccess. Informații suplimentare: Revocarea accesului

Fluxuri de export

Atunci când un flux face parte dintr-o soluție, îl puteți exporta exportând soluția care conține fluxul utilizând mesajul ExportSolution .

Metoda exemplu static ExportSolution de mai jos utilizează ExportSolutionRequest pentru a regăsi un byte[] fișier ZIP care conține soluția negestionată cu UniqueName specificat.

/// <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;
}

Fluxuri de import

Când aveți un fișier ZIP soluție, îl puteți importa utilizând mesajul ImportSolution .

Când importați fluxuri, trebuie să setați următorii parametri:

Numele proprietății Descriere
OverwriteUnmanagedCustomizations Dacă există instanțe ale acestor fluxuri Dataverse, acest marcaj trebuie setat pentru a true le importa. În caz contrar, acestea nu vor fi suprascrise.
PublishWorkflows Indică dacă fluxurile de lucru clasice Dataverse vor fi activate la import. Această setare nu se aplică altor tipuri de fluxuri.
CustomizationFile Un fișier zip de bază codificat 64 care conține soluția.

Metoda eșantionului static ImportSolution arată cum se importă un fișier soluție utilizând clasa 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);
}

Operațiuni pe clase de entitate utilizând serviciul Organizație
Efectuați operațiuni utilizând API-ul web
Partajarea și atribuirea
Verificarea accesului în cod
Lucrați cu soluții utilizând SDK-ul Dataverse