Soumettre et approuver les éléments du catalogue

Les personnes doivent soumettre leurs éléments de catalogue pour approbation et un administrateur doit les approuver avant que d’autres puissent les utiliser.

Pour soumettre un élément au catalogue, les éléments suivants sont nécessaires :

• Un package de solutions ou Package Deployer contenant l’élément que vous souhaitez soumettre.

• Un document JSON des métadonnées d’envoi.

  Utilisez la commande pac catalog create-submission pour obtenir un exemple de document JSON des métadonnées d’envoi. Vous devez modifier ce document et d’autres attributs d’envoi peuvent être ajoutés. Pour plus d’informations : Attributs d’envois

Attributs d’envois

Avant de pouvoir soumettre des éléments à un catalogue, vous devez préparer un document JSON qui décrit les éléments que vous souhaitez soumettre.

Pour vous aider, la commande pac catalog create-submission génère un exemple de fichier submission.json.

Vous devez modifier ce fichier pour soumettre un élément. Prenons un exemple :

{
  "modelVersion": "1.0.0.0",
  "operation": "CreateOrUpdate",
  "sourcePortal": 526430005,
  "businessJustification": "Power Platform custom connector for Conference API",
  "publisherDetails": {
    "publisherId": "ContosoConferencesTeam",
    "publisherDisplayName": "Catalog Conferences Team"
  },
  "catalogItemDefinition": {
    "id": "ContosoConferencesCustomConnector",
    "displayName": "Contoso Conference Custom Connector",
    "description": "Demo Custom connector to query Conference Speakers & Sessions",
    "offer": {
      "type": "Component_Collection",
      "deploymentType": "Normal",
      "engineeringName": {
        "firstName": "Jennifer",
        "lastName": "Wilkins",
        "email": "jwilkins@contoso.com",
        "phoneNumber": "555-111-1234"
      },
      "supportName": {
        "firstName": "Aidan",
        "lastName": "Hunt",
        "email": "ahunt@contoso.com",
        "phoneNumber": "555-111-1234"
      }
    }
  }
}

Découvrez les propriétés valides du fichier de soumission

Soumettre des éléments au catalogue

Les éléments envoyés au catalogue doivent être inclus dans un package de type Package Deployer. Un package de type Package Deployer contient un fichier zip de solution et quelques instructions facultatives à appliquer lors du déploiement du package. Si vous n’avez pas de package de type Package Deployer, vous pouvez en créer un pour la solution qui contient vos éléments.

PAC CLI

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 ?

SDK pour .NET

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

API web

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

Créer un package de déploiement de package à partir d’une solution non gérée

Lorsque vous utilisez le message mspcat_SubmitCatalogApprovalRequest avec le SDK pour .NET ou l’API web comme décrit dans Envoyer des éléments au catalogue, le fichier JSON d’envoi doit inclure une propriété CatalogItemDefinitionpackageFile définie pour préciser une URL dans le filesaslink pour télécharger un fichier de type Package Deployer. Vous n’avez pas besoin de le faire avec la commande pac catalog submit, car cette commande s’en charge pour vous.

Cette URL peut représenter tout emplacement où Dataverse peut télécharger un fichier sans aucune information d’identification, mais nous vous déconseillons de placer les fichiers sur un emplacement de téléchargement public. Au lieu de cela, vous pouvez utiliser la table Magasin d’envoi de package (mspcat_PackageStore) pour générer un package de type Package Deployer à l’aide d’une solution non gérée à partir de n’importe quel environnement de votre client. Ce processus génère un enregistrement dans cette table qui contient un package dans la colonne de fichier PackageFile (mspcat_PackageFile). Vous pouvez ensuite utiliser le GetFileSasUrl message pour obtenir une URL de signature d’accès partagé (SAS) afin d’activer le téléchargement anonyme du fichier dans un délai d’une heure. Étant donné que l’URL n’est valide que dans l’heure qui suit, ce processus doit être automatisé afin que l’accès au téléchargement du fichier n’expire pas.

Note

Cet exemple utilise la colonne mspcat_PackageStore.mspcat_packagefile, mais le message GetFileSasUrl peut fournir une URL SAS pour n’importe quelle colonne de fichier ou d’image Dataverse. En savoir plus sur l’accès limité aux fichiers Dataverse à l’aide de signatures d’accès partagé

Traiter

1. Créez un enregistrement Magasin d’envoi de package (mspcat_PackageStore) avec ces valeurs

   Column	active
   mspcat_name	Le nom de la solution non gérée
   mspcat_solutionuniquename	Le nom unique de la solution non gérée
   mspcat_intendeddeploymenttype	526430000 pour le déploiement Standard
   mspcat_operation	958090001 pour Créer un package

2. Mettez à jour la valeur statuscode de 958090003 pour Brouillon à 958090004 pour Envoyé.

   La mise à jour lance le processus.

3. Attendez que le statuscode devienne 958090001 pour Terminé(e).

4. Utilisez GetFileSasUrl pour obtenir une URL pour la colonne mspcat_PackageStore.mspcat_packagefile. Cela renvoie un objet GetFileSasUrlResponse.

5. Créez un objet JSON CatalogFileAsset définissant ces propriétés :

   Property	active
   name	GetFileSasUrlResponse.FileName
   filesaslink	GetFileSasUrlResponse.SasUrl

6. Définissez cela sur la propriété CatalogItemDefinitionpackageFile du fichier d’envoi JSON.

7. Utilisez la mspcat_SubmitCatalogApprovalRequest pour envoyer la soumission comme décrit dans la section Envoyer des éléments au catalogue

PAC CLI

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

SDK pour .NET

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>

API web

Cette New-CatalogItemFromSolution fonction PowerShell 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.

Cette New-CatalogItemFromSolution fonction PowerShell 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>

Vérifier le statut des envois de catalogues

Les options Choix/Options du code d’état de la table Demande d’approbation (mspcat_certificationrequest). Terminé (2) représente une soumission réussie.

active	Label
1	Soumis
526430001	InProgress
526430002	En attente de l’auteur de l’envoi
526430003	Déploiement en attente
526430008	Brouillon
526430009	Traitement
2	Traité
526430000	Abandonné
526430004	Rejetée
526430005	Contenu marketing
526430006	Demande en double
526430010	Échec de la validation préalable

PAC CLI

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 ?

SDK pour .NET

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

API web

La fonction PowerShell suivante Get-ApprovalRequest récupère les colonnes sélectionnées de la table Demande d’approbation (mspcat_certificationrequest) pour l’élément où le $trackingId paramètre 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

Approuver les envois de catalogue

Les envois de catalogue sont généralement approuvés dans l’application du gestionnaire de catalogue Power Platform.

PAC CLI

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

SDK pour .NET

Cette méthode statique ResolveApproval montre comment résoudre une demande d’envoi de catalogue à l’aide du mspcat_ResolveApproval message. Cet exemple utilise la mspcat_ResolveApprovalRequest classe 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);
}

API web

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

Étapes suivantes

Vérifier la référence du document de soumission d’élément de catalogue

Rédiger un document de soumission