Lucrul cu fluxurile pentru cloud folosind cod

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

Acest articol tratează gestionarea fluxurilor incluse în fila *Soluții* . Power Automate În prezent, gestionarea fluxurilor în secțiunea *My Flows* nu este acceptată prin cod.

Interacționează cu API-urile Dataverse

Dataverse oferă capabilități echivalente utilizând fie SDK-ul pentru .NET, fie API-ul Web. Dataverse

Ce metodă ar trebui să folosesc?

Cea mai bună metodă depinde de tehnologia proiectului și de abilitățile pe care le aveți.

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

Mai multe informații: Utilizați serviciul Organizație

Cum să mă conectez?

Modul de conectare depinde de utilizarea SDK-ului pentru .NET sau a API-ului Web. Dataverse

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

Informații suplimentare:

Tabel de flux de lucru

Fluxurile în cloud sunt stocate în tabelul *Proces (Workflow)* care este reprezentat în API-ul Web ca *EntityType* de 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 clasice. Dataverse
1 - Dialoguri clasice. Dataverse
2 - Reguli de afaceri.
3 - Acțiuni clasice. Dataverse
4 - Fluxurile proceselor de afaceri.
5 - Modern Flow (fluxuri automatizate, instantanee sau programate).
6 - Fluxuri desktop.
clientdata Șir Un fișier JSON codificat în șiruri de caractere al definiției fluxului și al connectionReferences-ului său.
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-o 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 - Schiță (Dezactivat)
1 - Activat (Pornit)
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 în cloud în 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 și GUID-ul corespunzător proprietăți de căutare care pot fi folosite în interogări. Proprietățile de căutare au această convenție de denumire: _<logical name>_value. Pentru tipul de entitate flux de lucru din Web API, puteți face referire la aceste proprietăți de căutare: _createdby_value, _modifiedby_value și _ownerid_value.

Listați fluxurile

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

Această statică OutputFirstActiveFlow metoda necesită un client autentificat care implementează IOrganizationService. 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 recupera 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 automatizate, 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. 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: Crearea de rânduri de tabel folosind Serviciul de organizare

Toate fluxurile create în acest fel sunt setate la (Schiță sau „Dezactivat”). statecode0 Fluxul trebuie activat înainte de a putea fi utilizat.

Cea mai importantă proprietate este clientdata, care conține connectionReferences proprietatea pe care o folosește fluxul și definiția fluxului. Acestea sunt mapările pentru fiecare conexiune utilizată de flux. connectionReferences

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

Actualizarea unui flux în cloud

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

Această metodă statică necesită un client autentificat care implementează IOrganizationService. Folosește metoda IOrganizationService.Update pentru a actualiza descrierea unui flux ș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: Actualizarea și ștergerea rândurilor din tabel utilizând Serviciul de organizare > Actualizare de bază

Ștergeți un flux în cloud

Următoarele exemple arată cum se șterge înregistrarea fluxului de lucru care reprezintă un flux în cloud.

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

/// <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: Ștergerea unei înregistrări folosind SDK-ul

Obțineți toți utilizatorii cu care este partajat un flux în cloud

Folosește mesajul RetrieveSharedPrincipalsAndAccess pentru a obține o listă cu toți utilizatorii cu care este partajat un flux în 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

Partajarea sau anularea partajării unui flux în cloud

Partajați un flux în cloud ca pe orice altă înregistrare folosind mesajul. Dataverse GrantAccess Cu SDK-ul, utilizați clasa GrantAccessRequest iar cu API-ul Web utilizați acțiunea GrantAccess. Mai multe informații: Exemplu GrantAccess

Dacă doriți să modificați drepturile de acces pe care le acordați atunci când partajați o înregistrare, utilizați mesajul ModifyAccess . 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 partajarea unei înregistrări, utilizați mesajul RevokeAccess . 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ătorul exemplu static ExportSolution de metodă utilizează ExportSolutionRequest pentru a recupera un byte[] care conține fișierul ZIP al soluției negestionate 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 cu soluție, îl puteți importa folosind 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 în Dataverse, acest steag trebuie setat la true pentru a le importa. Altfel, ele nu sunt suprascrise.
PublishWorkflows Indică dacă fluxurile de lucru clasice sunt activate la import. Dataverse Această setare nu se aplică altor tipuri de fluxuri.
CustomizationFile Un fișier zip codificat în base 64 care conține soluția.

Metoda static ImportSolution sample arată cum se importă un fișier de soluție folosind 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. Clienții ar trebui să utilizeze în schimb API-urile web pentru **documentate anterior în acest articol**. Dataverse Power Automate

Alternativ, clienții pot utiliza conectorii de administrare: Power Automate Administrare sau Power Automate pentru administratori.

Clienții pot utiliza API-urile neacceptate pe propriul risc. api.flow.microsoft.com Aceste API-uri sunt supuse modificărilor, așadar pot apărea modificări importante.

Operațiuni ale clasei de entități folosind serviciul Organizație
Efectuați operațiuni folosind API-ul Web
Partajarea și atribuirea
Verificarea accesului în cod
Lucrați cu soluții folosind Dataverse SDK-ul

  • Last updated on