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 Process (Workflow) care este reprezentat în API-ul web ca workflow EntityType

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 Boolean 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 Web API, valorile de căutare sunt proprietăți de navigare cu o singură valoare care poate fi extins pentru a obține detalii din înregistrarea aferentă.

Coloanele de căutare au, de asemenea, GUID-ul corespunzător proprietăți de căutare care poate fi folosit î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”:

Acest static OutputFirstActiveFlow metoda necesită un client autentificat care implementează IOrganizationService. Acesta folosește IOrganizationService.RetrieveMultiple metodă.

/// <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 TopCount limită.

Ieșire

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. Utilizare none pentru primaryentity pentru aceste tipuri de fluxuri.

Această metodă statică necesită un client autentificat care implementează IOrganizationService. Acesta folosește IOrganizationService.Create metodă.

/// <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 astfel 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 tabelului 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-ul, 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 iar 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-ul, utilizați Clasa ModifyAccessRequest și cu API-ul web utilizați Acțiunea ModifyAccess. Mai multe informații: Exemplu ModifyAccess

Pentru a anula accesul la o înregistrare, utilizați RevokeAccess mesajul. Cu SDK-ul, utilizați Clasa RevokeAccessRequest și cu API-ul web utilizați Acțiunea RevokeAccess. Mai multe informații: Revocarea accesului

Fluxuri de export

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 .

Următoarea metodă statică ExportSolution exemplu folosește ExportSolutionRequest pentru a prelua un byte[] conținând fișierul ZIP al soluției negestionate cu specificația Nume Unic.

/// <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 de soluție, îl puteți importa folosind mesajul ImportSolution .

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

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

Metoda static ImportSolution eșantion arată cum să importați un fișier de 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);
}

Întrebări frecvente

Dar API-ul de la api.flow.microsoft.com?

API-ul de la api.flow.microsoft.com nu este acceptat. În schimb, clienții ar trebui să utilizeze Dataverse API-urile web pentru Power Automate documentate anterior în acest articol.

În mod alternativ, clienții pot folosi conectorii de gestionare: Power Automate Management sau Power Automate pentru administratori.

Clienții pot folosi API-urile neacceptate pe api.flow.microsoft.com pe propriul risc. Aceste API-uri pot fi modificate, așa că pot apărea modificări nerespective.

Operațiuni de clasă de entitate folosind serviciul Organization
Efectuați operațiuni folosind API-ul Web
Partajarea și atribuirea
Se verifică accesul în cod
Lucrați cu soluții folosind Dataverse SDK