Soumettre et approuver les éléments du catalogue

Une fois que votre document JSON des métadonnées d’envoi est prêt, utilisez la commande pac catalog submit pour le soumettre.

Utilisez le paramètre --path nécessaire pour faire référence au document JSON d’envoi du catalogue.

Si vous disposez déjà d’un package de type Package Deployer :

• Utilisez le paramètre --package-zip pour faire référence au package de type Package Deployer.
• Sinon, utilisez le paramètre --solution-zip pour faire référence à cette solution. La commande submit crée le package en arrière-plan.

Si vous souhaitez combiner l’interrogation du statut de votre demande d’envoi, utilisez le paramètre --poll-status. Sinon, utilisez la commande pac catalog status comme décrit dans Vérifier le statut des envois de catalogue.

pac catalog submit -p "BuildDemoSubmission.json" -sz "ContosoConference_1_0_0_1_managed.zip"
Creating package for catalog submit request...
Connected to... TestCatalog
Connected as user@domain
Tracking id for this submission is 0e6b119d-80f3-ed11-8849-000d3a0a2d9d

Qu’est-ce que Microsoft Power Platform CLI ?

La méthode statique SubmitCatalogApprovalRequest illustre l’utilisation du message mspcat_SubmitCatalogApprovalRequest. Cet exemple utilise les classes générées mspcat_SubmitCatalogApprovalRequestRequest et mspcat_SubmitCatalogApprovalRequestResponse à l’aide de la commande pac modelbuilder build.

Cet exemple de méthode renvoie une instance de la classe mspcat_SubmitCatalogApprovalRequestResponse, qui contient les propriétés CertificationRequestId et AsyncOperationId que vous pouvez utiliser pour vérifier le statut de l’envoi.

Le message mspcat_SubmitCatalogApprovalRequest exige que la propriété CatalogItemDefinitionpackageFile du fichier JSON d’envoi est définie pour préciser une URL de téléchargement d’un fichier de package de type Package Deployer.

/// <summary>
/// Submits a Catalog item for approval
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance.</param>
/// <param name="pathToSubmissionFile">The location of the submission file</param>
/// <returns>
///   mspcat_SubmitCatalogApprovalRequestResponse contains AsyncOperationId 
///   and CertificationRequestId
/// </returns>
static mspcat_SubmitCatalogApprovalRequestResponse SubmitCatalogApprovalRequest(
   IOrganizationService service,
   FileInfo pathToSubmissionFile)
{

   byte[] fileBytes = File.ReadAllBytes(pathToSubmissionFile.FullName);
   string encodedSubmissionFile = Convert.ToBase64String(fileBytes);


   var request = new mspcat_SubmitCatalogApprovalRequestRequest
   {
         EncodedApprovalRequest = encodedSubmissionFile
   };

   return (mspcat_SubmitCatalogApprovalRequestResponse)service.Execute(request);

}

Utiliser le SDK pour .NET Dataverse
Générer des classes à liaison anticipée pour le SDK pour .NET

La fonction Powershell SubmitCatalogApprovalRequest suivante démontre comment utiliser le message mspcat_SubmitCatalogApprovalRequest. Les résultats renvoyés sont une instance du type complexe mspcat_SubmitCatalogApprovalRequestResponse, qui contient les propriétés CertificationRequestId et AsyncOperationId que vous pouvez utiliser pour vérifier le statut de l’envoi.

Le message mspcat_SubmitCatalogApprovalRequest exige que la propriété CatalogItemDefinitionpackageFile du fichier JSON d’envoi est définie pour préciser une URL de téléchargement d’un fichier de package de type Package Deployer.

Cette fonction dépend des valeurs $baseURI et $baseHeaders définies avec la fonction Connect comme décrit dans Créer une fonction Connecter.

function SubmitCatalogApprovalRequest {
   param (
      [Parameter(Mandatory)]
      [System.IO.FileInfo]
      $pathToSubmissionFile
   )

   $uri = $baseURI + 'mspcat_SubmitCatalogApprovalRequest'

   $encodedApprovalRequest = [System.Convert]::ToBase64String([System.IO.File]::ReadAllBytes($pathToSubmissionFile.FullName))

   $body = @{
      EncodedApprovalRequest = $encodedApprovalRequest
   } | ConvertTo-Json

   $postHeaders = $baseHeaders.Clone()
   $postHeaders.Add('Content-Type', 'application/json')

   $results = Invoke-RestMethod `
      -Method Post `
      -Uri $uri `
      -Headers $postHeaders `
      -Body $body

   return   @{
      CertificationRequestId = $results.CertificationRequestId
      AsyncOperationId = $results.AsyncOperationId
   }

}

Utiliser l’API Web Microsoft Dataverse
Utiliser PowerShell et Visual Studio Code avec l’API web Dataverse

La commande pac catalog submit gère cela pour vous.

La méthode statique CatalogItemFromSolution montre comment créer un élément de catalogue à partir d’une solution en suivant les étapes décrites dans Processus. Le catalogItemSubmissionJsonString paramètre de cette fonction ne doit pas avoir de packageFile propriété définie car cette fonction l’ajoute.

/// <summary>
/// Processes a solution and returns the catalog item ID
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance</param>
/// <param name="solutionName">The name of the solution</param>
/// <param name="solutionUniqueName">The unique name of the solution</param>
/// <param name="catalogItemSubmissionJsonString">The string containing the submission json file</param>
/// <returns>Catalog Item ID</returns>
/// <exception cref="Exception"></exception>
static string CatalogItemFromSolution(
    IOrganizationService service,
    string solutionName,
    string solutionUniqueName,
    string catalogItemSubmissionJsonString
    )
{
    Entity packageStoreRecord = new("mspcat_packagestore")
    {
        Attributes = {
            {"mspcat_name", solutionName},
            {"mspcat_solutionuniquename", solutionUniqueName},
            {"mspcat_intendeddeploymenttype", new OptionSetValue(526430000)}, // Standard
            {"mspcat_operation", new OptionSetValue(958090001)} //Create Package
        }
    };

    Guid packageStoreRecordId = service.Create(packageStoreRecord);
    Console.WriteLine($"Created package store record with ID {packageStoreRecordId}");

    packageStoreRecord.Attributes.Clear(); //Don't send values again

    packageStoreRecord.Id = packageStoreRecordId;
    int statusCodeValue = 958090004; // Submitted

    string statusReason; // Set in the loop
    packageStoreRecord["statuscode"] = new OptionSetValue(statusCodeValue);

    service.Update(packageStoreRecord); //Set status to Submitted
    Console.WriteLine("Updated package store record status to Submitted");
    // Columns to retrieve while polling the package store record
    ColumnSet packageStoreColumns = new("statuscode");

    do
    {
        Task.Delay(10000).Wait(); //Wait 10 seconds between polling

        // Retrieve the record
        packageStoreRecord = service.Retrieve(
            "mspcat_packagestore",
            packageStoreRecord.Id,
            packageStoreColumns);

        // Get the status code value
        statusCodeValue = packageStoreRecord
            .GetAttributeValue<OptionSetValue>("statuscode").Value;

        statusReason = packageStoreRecord
            .FormattedValues["statuscode"];

        Console.WriteLine($" - Package store record status is {statusReason}");

        // Continue while statusCodeValue is Submitted, Pending, or Running
    } while (statusCodeValue.Equals(958090004) ||
             statusCodeValue.Equals(1) ||
             statusCodeValue.Equals(958090000));

    // If it isn't Completed, throw an exception
    if (!statusCodeValue.Equals(958090001))
    {
        statusReason = packageStoreRecord
            .FormattedValues["statuscode"];

        // 958090002 is 'Failed'
        throw new Exception($"Package submission {statusReason}");
    }
    Console.WriteLine($"Package submission {statusReason}");

    // If successful, retrieve the details about the file to download
    GetFileSasUrlRequest getFileSasUrlRequest = new()
    {
        Target = new EntityReference("mspcat_packagestore", packageStoreRecord.Id),
        FileAttributeName = "mspcat_packagefile"
    };

    var getFileSasUrlResponse = (GetFileSasUrlResponse)service
        .Execute(getFileSasUrlRequest);
    FileSasUrlResponse getFileSasUrlResponseResult = getFileSasUrlResponse.Result;
    Console.WriteLine($"Retrieved SAS URL for {getFileSasUrlResponseResult.FileName}");

    // Add the packageFile to the catalog item submission
    var catalogItemSubmissionJsonObject = JsonNode.Parse(catalogItemSubmissionJsonString).AsObject();

    var packageFile = new JsonObject
    {
        ["name"] = getFileSasUrlResponseResult.FileName,
        ["filesaslink"] = getFileSasUrlResponseResult.SasUrl
    };

    // Add the packageFile to the catalog item submission
    catalogItemSubmissionJsonObject["catalogItemDefinition"]["packageFile"] = packageFile;

    catalogItemSubmissionJsonString = catalogItemSubmissionJsonObject.ToJsonString();

    string encodedSubmissionJson = Convert
        .ToBase64String(Encoding.UTF8.GetBytes(catalogItemSubmissionJsonString));

    var submitCatalogApprovalRequest = new mspcat_SubmitCatalogApprovalRequestRequest
    {
        EncodedApprovalRequest = encodedSubmissionJson
    };

    var submitCatalogApprovalResponse = (mspcat_SubmitCatalogApprovalRequestResponse)service
        .Execute(submitCatalogApprovalRequest);
    
    Guid certificationRequestId = submitCatalogApprovalResponse.CertificationRequestId;

    Console.WriteLine($"Submitted catalog approval request with ID {certificationRequestId}");

    // Approval must be in either InProgress or Submitted to be processed

    // Columns to retrieve while polling the certification request record
    ColumnSet certificationRequestColumns = new("statuscode", "mspcat_application");
    Entity certificationRequestRecord;

    do
    {
        Task.Delay(10000).Wait(); //Wait 10 seconds between polling

        // Retrieve the record
        certificationRequestRecord = service.Retrieve(
           "mspcat_certificationrequest",
           certificationRequestId,
           certificationRequestColumns);

        // Get the status code value
        statusCodeValue = certificationRequestRecord
            .GetAttributeValue<OptionSetValue>("statuscode").Value;

        statusReason = packageStoreRecord
            .FormattedValues["statuscode"];

        Console.WriteLine($" - Approval Request status is {statusReason}");

        // Continue while statusCodeValue is:
    } while (statusCodeValue.Equals(526430002) || // Waiting On Submitter,
             statusCodeValue.Equals(526430003) || // Pending Deployment,
             statusCodeValue.Equals(526430008) || // Draft
             statusCodeValue.Equals(526430009));  // Processing

    // If it isn't Submitted or InProgress, throw an exception
    if (!(statusCodeValue.Equals(1) || statusCodeValue.Equals(526430001)))
    {
        string statusreason = certificationRequestRecord
            .FormattedValues["statuscode"];

        throw new Exception($"Certification request {statusreason}");
    }


    // Approve the request
    mspcat_ResolveApprovalRequest resolveApprovalRequest = new()
    {
        Target = new EntityReference("mspcat_certificationrequest", certificationRequestId),
        requestsuccess = true, //Approve the request
        message = "Approved by CatalogItemFromSolution function"
    };

    // mspcat_ResolveApprovalResponse has no properties to return
    service.Execute(resolveApprovalRequest);
    Console.WriteLine("Approved the certification request");

    // Get the Catalog Item
    EntityReference catalogItemReference = certificationRequestRecord
            .GetAttributeValue<EntityReference>("mspcat_application");

    Entity catalogItem = service.Retrieve(
        "mspcat_applications",
        catalogItemReference.Id,
        new ColumnSet("mspcat_tpsid"));

    string tpsid = catalogItem.GetAttributeValue<string>("mspcat_tpsid");
    Console.WriteLine($"Returning Catalog Item ID: {tpsid}");

    return tpsid;
}

Sortie

Le résultat de cette fonction doit ressembler à ce qui suit :

Created package store record with ID 46f662aa-2137-ef11-8409-6045bdd3aec3
Updated package store record status to Submitted
 - Package store record status is Submitted
 - Package store record status is Pending
 - Package store record status is Running
 - Package store record status is Running
 - Package store record status is Completed
Package submission Completed
Retrieved SAS URL for <solutionName>_1_0_0_0.zip
Submitted catalog approval request with ID b932c7c8-2137-ef11-8409-6045bdd3aec3
 - Approval Request status is Completed
Approved the certification request
Returning Catalog Item ID: <solutionUniqueName>

Cette fonction PowerShell New-CatalogItemFromSolution montre comment créer un article de catalogue à partir d’une solution en suivant les étapes décrites dans Processus. Le catalogItemSubmissionJsonString paramètre de cette fonction ne doit pas avoir de packageFile propriété définie car cette fonction l’ajoute.

Cette fonction PowerShell New-CatalogItemFromSolution dépend des variables et fonctions suivantes :

• Les valeurs $baseURI et $baseHeaders définies avec la fonction Connect comme décrit dans Créer une fonction Connecter.
• Les fonctions New-Record, Update-Record et Get-Record décrites dans Créer des fonctions pour les opérations de table
• La fonction Get-FileSasUrl décrite dans Accorder un accès limité aux fichiers Dataverse avec des signatures d’accès partagées

.SYNOPSIS
Creates a new catalog item from a solution and submits it for approval.

.DESCRIPTION
The `New-CatalogItemFromSolution` function automates the process of creating a new catalog item from a specified solution and submitting it for approval. It performs the following steps:
1. Validates the existence of the solution.
2. Creates a package store record.
3. Submits the package for approval.
4. Monitors the approval status.
5. Retrieves the SAS URL for the package file.
6. Submits the catalog item for certification.

.PARAMETER solutionName
The name of the solution.

.PARAMETER solutionUniqueName
The unique name of the solution.

.PARAMETER catalogItemSubmissionJsonString
The JSON string containing the catalog item submission details.

.EXAMPLE
New-CatalogItemFromSolution `
   -solutionName "MySolution" `
   -solutionUniqueName "my_solution" `
   -catalogItemSubmissionJsonString '{"catalogItemDefinition":{...}}'

This example creates a new catalog item from the solution named "MySolution" with the unique name "my_solution" and submits it for approval using the provided JSON string.

.NOTES
Ensure that the `Get-Records`, `New-Record`, `Update-Record`, `Get-Record`, and `Get-FileSasUrl` functions are defined and accessible in your environment.
The function uses specific status codes and operations that should be defined in your system.

function New-CatalogItemFromSolution {
   param(
      [Parameter(Mandatory)]
      [string]
      $solutionName,
      [Parameter(Mandatory)]
      [string]
      $solutionUniqueName,
      [Parameter(Mandatory)]
      [string]
      $catalogItemSubmissionJsonString
   )
   $statusCodeLabelName = 'statuscode@OData.Community.Display.V1.FormattedValue'

   $solutionQuery = "?`$filter=uniquename eq '$solutionUniqueName'&`$select=solutionid"
   $solutionCollection = (Get-Records `
         -setName 'solutions' `
         -query $solutionQuery).value

   if (!$solutionCollection.Count -eq 1) {
      throw "Solution with unique name $solutionUniqueName does not exist"
   }

   $packageStoreRecord = @{
      mspcat_name                   = $solutionName
      mspcat_solutionuniquename     = $solutionUniqueName
      mspcat_intendeddeploymenttype = 526430000 # Standard
      mspcat_operation              = 958090001 # Create Package
   }

   $packageId = New-Record `
      -setName 'mspcat_packagestores' `
      -body $packageStoreRecord
   
   Write-Host ('Created package store record with ID ' + $packageId)

   # Set statuscode to Submitted
   $packageStoreRecord = @{
      statuscode = 958090004
   }

   Update-Record `
      -setName 'mspcat_packagestores' `
      -id $packageId `
      -body $packageStoreRecord | Out-Null

   Write-Host  'Updated package store record status to Submitted'

   do {
      Start-Sleep -Seconds 10

      $packageStore = Get-Record `
         -setName 'mspcat_packagestores' `
         -id $packageId `
         -query '?$select=statuscode,mspcat_processingmessage'
      
      $statusCodeValue = $packageStore.statuscode
      $statusCodeLabel = $packageStore.$statusCodeLabelName

      Write-Host (' - Package store record status is ' + $statusCodeLabel)

   } while ($statusCodeValue -eq 958090004 -or # Submitted
      $statusCodeValue -eq 1 -or # Pending
      $statusCodeValue -eq 958090000) # Running
   
   if ($statusCodeValue -ne 958090001) {

      # 958090002 is 'Failed'
      throw "Package submission $statusCodeLabel"
   }

   # If successful, retrieve the details about the file to download

   $fileSasUrlResponse = Get-FileSasUrl `
      -setName 'mspcat_packagestores' `
      -id $packageId `
      -columnName 'mspcat_packagefile'

   Write-Host ('Retrieved SAS URL for ' + $fileSasUrlResponse.FileName)

   $catalogItemSubmission = $catalogItemSubmissionJsonString | ConvertFrom-Json

   $packageFile = @{
      name        = $fileSasUrlResponse.FileName
      filesaslink = $fileSasUrlResponse.SasUrl
   }

   $catalogItemSubmission.catalogItemDefinition.packageFile = $packageFile

   $catalogItemSubmissionJsonString = $catalogItemSubmission | ConvertTo-Json -Depth 10

   $encodedCatalogItemSubmission = [System.Convert]::ToBase64String([System.Text.Encoding]::UTF8.GetBytes($catalogItemSubmissionJsonString))

   
   $body = @{
      EncodedApprovalRequest = $encodedCatalogItemSubmission 
   } | ConvertTo-Json

   $postHeaders = $baseHeaders.Clone()
   $postHeaders.Add('Content-Type', 'application/json')

   $results = Invoke-RestMethod `
      -Method Post `
      -Uri ($baseURI + 'mspcat_SubmitCatalogApprovalRequest') `
      -Headers $postHeaders `
      -Body $body
   
   $certificationRequestId = $results.CertificationRequestId

   Write-Host ('Submitted catalog approval request with ID ' + $certificationRequestId)

   # Approval must be in either InProgress or Submitted to be processed

   do {
      Start-Sleep -Seconds 10
   
      # Retrieve the record
      $approvalRequestRecord = Get-Record `
         -setName 'mspcat_certificationrequests' `
         -id $certificationRequestId `
         -query '?$select=statuscode'

      # Get the status code value
      $statusCodeValue = $approvalRequestRecord.statuscode
      $statusCodeLabel = $approvalRequestRecord.$statusCodeLabelName
   
      Write-Host (' - Approval request status is ' + $statusCodeLabel)

   } while ($statusCodeValue -eq 526430002 -or # Waiting On Submitter
      $statusCodeValue -eq 526430003 -or # Pending Deployment
      $statusCodeValue -eq 526430008 -or # Draft
      $statusCodeValue -eq 526430009) # Processing
   
   # If statuscode isn't Submitted or InProgress, throw an exception
   if (!($statusCodeValue -eq 1 -or $statusCodeValue -eq 526430001)) {
      throw "Certification request $statusCodeLabel"
   }

   # Approve the request
   ResolveApproval `
      -certificationRequestId $certificationRequestId `
      -requestsuccess $true `
      -message 'Approved by script'

   Write-Host 'Approved the certification request'

   # Get the Catalog Item

   $query = '?$select=mspcat_certificationrequestid'
   $query += '&$expand=mspcat_Application($select=mspcat_tpsid)'

   $approvalRequestRecord = Get-Record `
         -setName 'mspcat_certificationrequests' `
         -id $certificationRequestId `
         -query $query

   $tpsid = $approvalRequestRecord.mspcat_Application.mspcat_tpsid

   Write-Host ('Returning Catalog Item ID:' + $tpsid)

   return $tpsid
}

Sortie

Le résultat de cette fonction doit ressembler à ce qui suit :

Created package store record with ID 46f662aa-2137-ef11-8409-6045bdd3aec3
Updated package store record status to Submitted
 - Package store record status is Submitted
 - Package store record status is Pending
 - Package store record status is Running
 - Package store record status is Running
 - Package store record status is Completed
Package submission Completed
Retrieved SAS URL for <solutionName>_1_0_0_0.zip
Submitted catalog approval request with ID b932c7c8-2137-ef11-8409-6045bdd3aec3
 - Approval Request status is Completed
Approved the certification request
Returning Catalog Item ID: <solutionUniqueName>

Utilisez la commande pac catalog status pour vérifier le statut des envois de catalogues.

pac catalog status --tracking-id 0e6b119d-80f3-ed11-8849-000d3a0a2d9d --type submit
Connected to... TestCatalog
Connected as user@domain
Status of the Submit request: Submitted

Qu’est-ce que Microsoft Power Platform CLI ?

La méthode statique GetApprovalRequest suivante récupère les colonnes sélectionnées à partir de la table Demande d’approbation (mspcat_certificationrequest) pour l’élément où le paramètre trackingId correspond à la clé primaire de l’enregistrement.

/// <summary>
/// Retrieves an Approval Request with selected columns
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance.</param>
/// <param name="trackingId">The ID of the approval request</param>
/// <returns>The approval request record</returns>
static Entity GetApprovalRequest(IOrganizationService service, Guid trackingId)
{
    ColumnSet columns = new("createdby",
        "createdon",
        "modifiedby",
        "modifiedon",
        "mspcat_autoapproved",
        "mspcat_certstartdate",
        "mspcat_codereview",
        "mspcat_dropcontainsmultiplepackages",
        "mspcat_functionalvalidation",
        "mspcat_internalreview",
        "mspcat_isvduration",
        "mspcat_marketingonlychange",
        "mspcat_packagedeployment",
        "mspcat_publisher",
        "mspcat_requestname",
        "mspcat_requestsource",
        "mspcat_requestsaccesstotspevents",
        "mspcat_requestssecurestoreaccess",
        "mspcat_stagename",
        "mspcat_totalduration",
        "ownerid",
        "statecode",
        "statuscode");

    return service.Retrieve("mspcat_certificationrequest", trackingId, columns);
}

Utiliser le SDK pour .NET Dataverse

La fonction PowerShell Get-ApprovalRequest suivante récupère les colonnes sélectionnées de la table Demande d’approbation (mspcat_certificationrequest) pour l’élément dont le paramètre $trackingId correspond à la clé primaire de l’enregistrement.

Cette fonction dépend de la fonction Get-Record comme décrit dans Créer des fonctions pour les opérations de table.

function Get-ApprovalRequest{
   param(
      [Parameter(Mandatory)]
      [guid]
      $trackingId
   )

   $columns = @(
         '_createdby_value',
         '_modifiedby_value',
         '_mspcat_publisher_value',
         '_ownerid_value',
         'createdon',
         'modifiedon',
         'mspcat_autoapproved',
         'mspcat_certstartdate',
         'mspcat_codereview',
         'mspcat_dropcontainsmultiplepackages',
         'mspcat_functionalvalidation',
         'mspcat_internalreview ',
         'mspcat_isvduration',
         'mspcat_marketingonlychange',
         'mspcat_packagedeployment',
         'mspcat_requestname',
         'mspcat_requestsource',
         'mspcat_requestsaccesstotspevents',
         'mspcat_requestssecurestoreaccess',
         'mspcat_stagename',
         'mspcat_totalduration',
         'statecode',
         'statuscode'
      )

      $selectcolumns = '?$select=' + ($columns -join ',')

      return Get-Record `
         -setName 'mspcat_certificationrequests' `
         -id $trackingId `
         -query $selectcolumns
}

Utiliser l’API Web Microsoft Dataverse
Utiliser PowerShell et Visual Studio Code avec l’API web Dataverse

Il n’y a pas de commande PAC CLI pour effectuer cette opération.

Cette méthode ResolveApproval statique montre comment résoudre une demande de soumission de catalogue à l’aide du message mspcat_ResolveApproval. Cet exemple utilise la classe mspcat_ResolveApprovalRequest générée par la commande pac modelbuilder build.

/// <summary>
/// Resolves a catalog submission approval
/// </summary>
/// <param name="service">The authenticated IOrganizationService instance.</param>
/// <param name="certificationRequestId">The ID of the certification request.</param>
/// <param name="requestsuccess">The decision to approve or reject the request.</param>
/// <param name="message">Information for the submitter about the resolution</param>
static void ResolveApproval(
   IOrganizationService service,
   Guid certificationRequestId,
   bool requestsuccess,
   string message)
{

   mspcat_ResolveApprovalRequest request = new()
   {
         Target = new EntityReference("mspcat_certificationrequest", certificationRequestId),
         requestsuccess = requestsuccess,
         message = message
   };

   // mspcat_ResolveApprovalResponse has no properties to return
   service.Execute(request);
}

Cette fonction ResolveApproval PowerShell montre comment résoudre une demande d’envoi de catalogue à l’aide de l’action mspcat_ResolveApproval.

Cette fonction dépend des valeurs $baseURI et $baseHeaders définies avec la fonction Connect comme décrit dans Créer une fonction Connect.

<#
.SYNOPSIS
   This function resolves an approval request.

.DESCRIPTION
   mspcat_ResolveApproval is an action bound to the mspcat_certificationrequests table.

.PARAMETER certificationRequestId
   This is a mandatory GUID parameter that represents the ID of the certification request.

.PARAMETER requestsuccess
   This is a mandatory Boolean parameter that indicates the decision to approve or reject the request..

.PARAMETER message
   This is a mandatory string parameter that contains information for the submitter about the resolution.

.EXAMPLE
   ResolveApproval `
      -certificationRequestId "<Guid>" `
      -requestsuccess $true `
      -message "Request processed successfully."

.NOTES
   The function does not return any value.
   Any output from the Invoke-RestMethod cmdlet is sent to Out-Null.
#>
function ResolveApproval {
   param (
      [Parameter(Mandatory)]
      [guid]
      $certificationRequestId,
      [Parameter(Mandatory)]
      [bool]
      $requestsuccess,
      [Parameter(Mandatory)]
      [string]
      $message
   )

   $uri = $baseURI + "mspcat_certificationrequests($certificationRequestId)"
   $uri += "/Microsoft.Dynamics.CRM.mspcat_ResolveApproval"

   $body = @{
      requestsuccess = $requestsuccess
      message        = $message
   } | ConvertTo-Json

   $postHeaders = $baseHeaders.Clone()
   $postHeaders.Add('Content-Type', 'application/json')

   Invoke-RestMethod `
      -Method Post `
      -Uri $uri `
      -Headers $postHeaders `
      -Body $body | Out-Null
}

Utiliser l’API Web Microsoft Dataverse
Utiliser PowerShell et Visual Studio Code avec l’API web Dataverse