Utiliser les flux de cloud avec un code

  • Article

Tous les flux sont stockés dans Dataverse et vous pouvez utiliser le SDK Dataverse pour .NET ou l’API Web pour les gérer.

Cet article traite de la gestion des flux inclus sur l’onglet Solutions dans Power Automate. Actuellement, la gestion des flux sous Mes flux n’est pas prise en charge avec un code.

Interagir avec les API Dataverse

Dataverse fournit des fonctionnalités équivalentes en utilisant le SDK Dataverse pour .NET ou l’API Web.

Quelle méthode dois-je utiliser ?

La meilleure méthode dépend de la technologie du projet et des compétences dont vous disposez.

Si votre projet utilise .NET, nous vous recommandons d’utiliser le SDK. Le SDK simplifie votre expérience de développement en fournissant un modèle d’objet typé et des méthodes pour l’authentification.

Pour plus d’informations : Utiliser le service d’organisation

Comment se connecter ?

La méthode de connexion varie selon que vous utilisez le SDK Dataverse pour .NET ou l’API Web.

Avec le SDK, vous devez vous connecter à une application cliente pour obtenir l’accès à une instance IOrganizationService. IOrganizationService est une interface qui fournit des méthodes que vous pouvez utiliser pour interagir avec Dataverse.

Pour plus d’informations :

Table de flux de travail

Les flux de cloud sont stockés dans la Table de processus (flux de travail) qui est représentée dans l’API Web en tant que flux de travail EntityType

Le tableau suivant décrit les colonnes importantes de la table de flux de travail :

Nom logique Type Description
category Option Catégorie du flux. Voici les différentes catégories.
0 - Flux de travail Dataverse classiques.
1 - Boîtes de dialogue Dataverse classiques.
2 - Règles métier.
3 - Actions Dataverse classiques.
4 - Flux de processus métier.
5 - Flux modernes (flux automatisés, instantanés ou planifiés).
6 - Flux de bureau.
clientdata String JSON encodé sous forme de chaîne de la définition de flux et ses connectionReferences.
createdby Lookup Utilisateur ayant créé le flux.
createdon DateHeure Date de création du flux.
description String Description du flux donnée par l’utilisateur.
ismanaged Bool Indique si le flux a été installé via une solution gérée
modifiedby Lookup Dernier utilisateur ayant mis à jour le flux.
modifiedon DateHeure Dernière mise à jour du flux.
name String Nom complet que vous avez donné au flux.
ownerid Lookup Utilisateur ou équipe propriétaire du flux.
statecode Option Le statut du flux. Le statut peut être :
0 - Brouillon (désactivé)
1 - Activé
2 - Suspendu.
type Option Indique si le flux est en cours d’exécution, ou s’il s’agit d’un modèle pouvant être utilisé pour créer des flux supplémentaires.
1 - Définition,
2 - Activation
3 - Modèle.
workflowid Guid Identificateur unique d’un flux de cloud pour toutes les importations.
workflowidunique Guid Identificateur unique de cette installation du flux.

Note

Avec l’API Web, les valeurs de recherche sont des propriétés de navigation à valeur unique qui peuvent être développées pour obtenir des détails de l’enregistrement associé.

Les colonnes de recherche ont également des propriétés de recherche de GUID correspondantes qui peuvent être utilisées dans les requêtes. Les propriétés de recherche ont cette convention d’affectation de noms : _<logical name>_value. Pour le flux de travail entitytype dans l’API Web, vous pouvez référencer ces propriétés de recherche : _createdby_value, _modifiedby_value et _ownerid_value.

Lister les flux

Pour récupérer une liste de flux de cloud, vous pouvez interroger la table de flux de travail. La requête suivante retourne le premier flux automatisé, instantané ou planifié qui est actuellement activé :

Cette méthode statique OutputFirstActiveFlow nécessite un client authentifié qui implémente IOrganizationService. Il utilise la méthode 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"]}");
}

Pour récupérer d’autres enregistrements, supprimez la limite TopCount.

Sortie

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

Pour plus d’informations :

Créer un flux de cloud

Les propriétés requises pour les flux automatisés, instantanés et planifiés sont : category, name, type, primaryentity et clientdata. Utilisez none pour primaryentity pour ces types de flux.

Cette méthode statique nécessite un client authentifié qui implémente IOrganizationService. Elle utilise la méthode 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);
}

Pour plus d’informations, voir : Créer des lignes de table à l’aide du service d’organisation

Le statecode de tous les flux créés de cette manière est défini sur 0 (Brouillon ou Désactivé). Le flux doit être activé avant de pouvoir être utilisé.

La propriété la plus importante est clientdata, qui contient le paramètre connectionReferences utilisé par le flux et la définition du flux. connectionReferences sont les mappages à chaque connexion utilisée par le 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"
}

Mettre à jour un flux de cloud

Pour mettre à jour un flux, définissez uniquement les propriétés que vous souhaitez modifier.

Cette méthode statique nécessite un client authentifié qui implémente IOrganizationService. Elle utilise la méthode IOrganizationService.Update pour mettre à jour une description de flux et définir le propriétaire.

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

Pour plus d’informations : Mettre à jour et supprimer des lignes de table à l’aide du service d’organisation > Mise à jour de base

Supprimer un flux de cloud

Les exemples suivants montrent comment supprimer l’enregistrement de flux de travail qui représente un flux de cloud.

La méthode statique DeleteCloudFlow supprime un enregistrement de flux de travail.

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

}

Pour plus d’informations : Supprimer un enregistrement à l’aide du SDK

Obtenir tous les utilisateurs avec qui un flux de cloud est partagé

Utilisez le message RetrieveSharedPrincipalsAndAccess pour obtenir une liste de tous les utilisateurs avec lesquels un flux de cloud est partagé.

Avec le SDK, utilisez la Classe RetrieveSharedPrincipalsAndAccessRequest, et avec l’API Web, utilisez la Fonction RetrieveSharedPrincipalsAndAccess.

Pour plus d’informations : Obtenir les principaux avec accès à un enregistrement

Partager ou annuler le partage d’un flux de cloud

Partagez un flux de cloud comme tout autre enregistrement Dataverse en utilisant le message GrantAccess. Avec le SDK, utilisez la Classe GrantAccessRequest et, avec l’API Web, utilisez l’Action GrantAccess. Pour plus d’informations : Exemple GrantAccess

Si vous souhaitez modifier les droits d’accès que vous accordez lorsque vous partagez un enregistrement, utilisez le message ModifyAccess. Avec le SDK, utilisez la Classe ModifyAccessRequest et, avec l’API Web, utilisez l’Action ModifyAccess. Pour plus d’informations : Exemple ModifyAccess

Pour annuler le partage d’un enregistrement, utilisez le message RevokeAccess. Avec le SDK, utilisez la Classe RevokeAccessRequest et, avec l’API Web, utilisez l’Action RevokeAccess. Pour plus d’informations : Révocation de l’accès

Exporter les flux

Lorsqu’un flux fait partie d’une solution, vous pouvez l’exporter en exportant la solution contenant le flux à l’aide du message ExportSolution.

L’exemple de méthode statique ExportSolution ci-dessous utilise ExportSolutionRequest pour récupérer un byte[] contenant le fichier ZIP de la solution non gérée avec le UniqueName spécifié.

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

Importer des flux

Lorsque vous disposez d’un fichier ZIP de solution, vous pouvez l’importer en utilisant le message ImportSolution.

Lorsque vous importez des flux, vous devez définir les paramètres suivants :

Nom de la propriété Description
OverwriteUnmanagedCustomizations S’il y a des instances de ces flux dans Dataverse, cet indicateur doit être défini sur true pour les importer. Sinon, elles ne seront pas remplacées.
PublishWorkflows Indique si des flux de travail Dataverse classiques seront activés lors de l’importation. Ce paramètre ne s’applique pas à d’autres types de flux.
CustomizationFile Un fichier zip de base encodé 64 contenant la solution.

L’exemple de méthode statique ImportSolution montre comment importer un fichier de solution en utilisant 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);
}

Voir aussi

Opérations de classe d’entité utilisant le service d’organisation
Effectuer des opérations à l’aide de l’API web
Partage et attribution
Vérification de l’accès dans le code
Travailler avec les solutions en utilisant le SDK Dataverse