Comparteix a través de

Treballar amb fluxos de núvol mitjançant codi

  • Article

Tots els fluxos s'emmagatzemen i Dataverse podeu utilitzar l'SDK per a .NET o l'API Dataverse web per administrar-los.

En aquest article s'explica la gestió dels fluxos inclosos a la pestanya Solucions a Power Automate. Actualment, l'administració de fluxos a Els meus fluxos no s'admet amb codi.

Interactuar amb Dataverse les API

Dataverse proporciona capacitats equivalents mitjançant l'SDK per a .NET o l'API Dataverse web.

Quin mètode he d'utilitzar?

El millor mètode depèn de la tecnologia del projecte i de les habilitats que tinguis.

Si el vostre projecte utilitza .NET, us recomanem que utilitzeu l'SDK. L'SDK simplifica la vostra experiència de desenvolupament proporcionant un model d'objectes escrit i mètodes per autenticar-se.

Més informació: Utilitzar el servei de l'organització

Com connectar-se?

La manera de connectar-se depèn de si utilitzeu l'SDK per a .NET o l'API Dataverse web.

Amb l'SDK, heu de connectar-vos amb una aplicació client per accedir a una instància IOrganizationService . IOrganizationService és una interfície que proporciona mètodes que podeu utilitzar per interactuar Dataverse.

Més informació:

Taula de flux de treball

Els fluxos al núvol s'emmagatzemen a la taula Procés (flux de treball) que es representa a l'API web com a EntityType del flux de treball

La taula següent descriu les columnes importants de la taula de flux de treball:

Nom lògic Type Descripció
category Elecció La categoria del flux. Aquí teniu les diferents categories.
0 - Fluxos de treball clàssics Dataverse .
1 - Diàlegs clàssics Dataverse .
2 - Normes de negoci.
3 - Accions clàssiques Dataverse .
4 - Fluxos de processos de negoci.
5 - Flux modern (fluxos automatitzats, instantanis o programats).
6 - Fluxos d'escriptori.
clientdata String Un JSON codificat per cadena de la definició de flux i el seu connectionReferences.
createdby Cerca L'usuari que ha creat el flux.
createdon Data/hora La data en què es va crear el flux.
description String La descripció del flux proporcionada per l'usuari.
ismanaged Bool Indica si el flux s'ha instal·lat mitjançant una solució administrada.
modifiedby Cerca L'últim usuari que ha actualitzat el flux.
modifiedon Data/hora L'última vegada que es va actualitzar el flux.
name String El nom de visualització que heu donat al flux.
ownerid Cerca L'usuari o l'equip propietari del flux.
statecode Elecció L'estat del flux. L'estat pot ser:
0 - Esborrany (desactivat)
1 - Activat (activat)
2 -Suspès.
type Elecció Indica si el flux és un flux en execució o una plantilla que es pot utilitzar per crear més fluxos.
1 -Definició
2 -Activació
3 -Plantilla.
workflowid GUID Identificador únic d'un flux de núvol en totes les importacions.
workflowidunique GUID L'identificador únic d'aquesta instal·lació del flux.

Nota

Amb l'API web, els valors de cerca són propietats de navegació d'un sol valor que es poden ampliar per obtenir detalls del registre relacionat.

Les columnes de cerca també tenen les propietats de cerca GUID corresponents que es poden utilitzar a les consultes. Les propietats de cerca tenen aquesta convenció de nomenclatura: _<logical name>_value. Per al tipus d'entitat de flux de treball a l'API web, podeu fer referència a aquestes propietats de cerca: _createdby_value, _modifiedby_value, i _ownerid_value.

Enumeració dels fluxos

Per recuperar una llista de fluxos de núvol, podeu consultar la taula de fluxos de treball. La consulta següent retorna el primer flux automatitzat, instantani o planificat que està actualment "activat":

Aquest mètode estàtic OutputFirstActiveFlow requereix un client autenticat que implementi el IOrganizationService. Utilitza el mètode 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"]}");
}

Per recuperar més registres, suprimiu el límit TopCount .

Sortida

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

Més informació:

Crea un flux de núvol

Les propietats necessàries per als fluxos automatitzats, instantanis i programats són: category, name, type,, primaryentity i clientdata. Utilitzeu-lo none per a primaryentity aquest tipus de fluxos.

Aquest mètode estàtic requereix un client autenticat que implementi el IOrganizationService. Utilitza el mètode 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);
}

Més informació: Crear files de taula mitjançant el servei de l'organització

Els fluxos statecode creats d'aquesta manera s'estableixen a 0 (Esborrany o 'Desactivat'). El flux s'ha d'habilitar abans de poder utilitzar-lo.

La propietat més important és la clientdata, que conté el connectionReferences que utilitza el flux, i la definició del flux. Són connectionReferences les assignacions a cada connexió que utilitza el flux.

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

Actualitzar un flux de núvol

Per actualitzar un flux, definiu només les propietats que voleu canviar.

Aquest mètode estàtic requereix un client autenticat que implementi el IOrganizationService. Utilitza el mètode IOrganizationService.Update per actualitzar una descripció de flux i definir el propietari.

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

Més informació: Actualitzar i suprimir files de taula mitjançant l'actualització bàsica del servei > d'organització

Suprimir un flux de núvol

Els exemples següents mostren com suprimir el registre de flux de treball que representa un flux de núvol.

El mètode estàtic DeleteCloudFlow suprimeix un registre de flux de treball.

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

}

Més informació: Suprimir un registre mitjançant l'SDK

Obtenir tots els usuaris amb els quals es comparteix un flux de núvol

Utilitzeu el RetrieveSharedPrincipalsAndAccess missatge per obtenir una llista de tots els usuaris amb els quals es comparteix un flux de núvol.

Amb l'SDK, utilitzeu la classe RetrieveSharedPrincipalsAndAccessRequest i amb l'API web utilitzeu la funció RetrieveSharedPrincipalsAndAccess.

Més informació: Obtenir entitats amb accés a un registre

Compartir o deixar de compartir un flux de núvol

Compartiu un flux de núvol com qualsevol altre Dataverse registre que utilitzi el GrantAccess missatge. Amb l'SDK, utilitzeu la classe GrantAccessRequest i amb l'API web utilitzeu l'acció GrantAccess. Més informació: Exemple de GrantAccess

Si voleu canviar els drets d'accés que concediu quan compartiu un registre, utilitzeu el ModifyAccess missatge. Amb l'SDK, utilitzeu la classe ModifyAccessRequest i amb l'API web utilitzeu l'acció ModifyAccess. Més informació: ModifyExemple d'accés

Per deixar de compartir un registre, utilitzeu el RevokeAccess missatge. Amb l'SDK, utilitzeu la classe RevokeAccessRequest i amb l'API web utilitzeu l'acció RevokeAccess. Més informació: Revocació d'accés

Fluxos d'exportació

Quan un flux forma part d'una solució, podeu exportar-lo exportant la solució que conté el flux mitjançant el ExportSolution missatge.

El mètode d'exemple estàtic ExportSolution següent utilitza ExportSolutionRequest per recuperar un byte[] fitxer ZIP que conté la solució no administrada amb l'UniqueName especificat.

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

Fluxos d'importació

Quan teniu un fitxer ZIP de solució, podeu importar-lo mitjançant el ImportSolution missatge.

Quan importeu fluxos, heu de definir els paràmetres següents:

Nom de la propietat Descripció
OverwriteUnmanagedCustomizations Si hi ha instàncies existents d'aquests fluxos Dataverse, aquest indicador s'ha de definir com a true per importar-los. En cas contrari, no se sobreescriuran.
PublishWorkflows Indica si els fluxos de treball clàssics Dataverse s'activaran en importar. Aquesta opció de configuració no s'aplica a altres tipus de fluxos.
CustomizationFile Un fitxer zip codificat en base 64 que conté la solució.

El mètode d'exemple estàtic ImportSolution mostra com importar un fitxer de solució mitjançant la classe 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);
}

Operacions de classe d'entitat mitjançant el servei de l'organització
Realitzar operacions mitjançant l'API web
Compartir i assignar
Verificació de l'accés en codi
Treballar amb solucions mitjançant l'SDK Dataverse