Démarrage rapide : Définir et obtenir une étiquette de confidentialité (C++)

Article
01/30/2024

Ce démarrage rapide vous montre utiliser davantage de SDK MIP File. À l’aide de l’une des étiquettes de confidentialité que vous avez listées dans le démarrage rapide précédent, vous utilisez un Gestionnaire de fichiers pour définir/obtenir l’étiquette sur un fichier. La classe du Gestionnaire de fichiers expose différentes opérations pour définir/obtenir des étiquettes, ou la protection, pour les types de fichiers pris en charge.

Prérequis

Si ce n’est déjà fait, veillez à satisfaire les prérequis suivants avant de poursuivre :

Suivez d’abord Démarrage rapide : Lister les étiquettes de confidentialité (C++), pour créer une solution Visual Studio de démarrage visant à lister les étiquettes de confidentialité d’une organisation. Ce démarrage rapide « Définir et obtenir une étiquette de confidentialité » repose sur le précédent.
Facultatif : passez en revue les Gestionnaires de fichiers dans les concepts du SDK MIP.

Implémenter une classe d’observateur pour surveiller les objets de gestionnaire File

Comme pour l’observateur que vous avez implémenté (pour le profil et le moteur File) dans le démarrage rapide de l’initialisation de l’application, vous devez désormais implémenter un classe d’observateur pour un objet de gestionnaire File.

Créez une implémentation de base pour un observateur de gestionnaire de profil File, en étendant la classe mip::FileHandler::Observer du SDK. L’observateur est instancié et utilisé ultérieurement pour surveiller les opérations du gestionnaire File.

Ouvrez la solution Visual Studio sur laquelle vous avez travaillé dans l’article précédent « Démarrage rapide : Lister des étiquettes de confidentialité (C++) ».
Ajoutez une nouvelle classe à votre projet, ce qui génère pour vous les fichiers header/.h et implementation/.cpp :
- Dans l’Explorateur de solutions, cliquez avec le bouton de droite sur le nœud du projet une nouvelle fois, puis sélectionnez Ajouter et Classe.
- Dans la boîte de dialogue Ajouter une classe :
  - Dans le champ Nom de la classe, entrez « filehandler_observer ». Notez que les deux champs Fichier .h et Fichier .cpp sont automatiquement renseignés en fonction du nom que vous entrez.
  - Lorsque vous avez terminé, cliquez sur le bouton OK.

Après la génération des fichiers .h et .cpp pour la classe, les deux fichiers sont ouverts sous les onglets du groupe d’éditeurs. Maintenant, mettez à jour chaque fichier pour implémenter votre nouvelle classe d’observateur :

Mettez à jour « filehandler_observer.h » en sélectionnant/supprimant la classe filehandler_observer générée. Ne supprimez pas les directives de préprocesseur générées à l’étape précédente (#pragma, #include). Ensuite, copiez/collez la source suivante dans le fichier, après les directives de préprocesseur existantes :

#include <memory>
#include "mip/file/file_engine.h"
#include "mip/file/file_handler.h"

class FileHandlerObserver final : public mip::FileHandler::Observer {
public:
   FileHandlerObserver() { }
   // Observer implementation
   void OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) override;
   void OnCreateFileHandlerFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;
   void OnCommitSuccess(bool committed, const std::shared_ptr<void>& context) override;
   void OnCommitFailure(const std::exception_ptr& error, const std::shared_ptr<void>& context) override;		
};

Mettez à jour « filehandler_observer.cpp » en sélectionnant/supprimant l’implémentation de la classe filehandler_observer générée. Ne supprimez pas les directives de préprocesseur générées à l’étape précédente (#pragma, #include). Ensuite, copiez/collez la source suivante dans le fichier, après les directives de préprocesseur existantes :

void FileHandlerObserver::OnCreateFileHandlerSuccess(const std::shared_ptr<mip::FileHandler>& fileHandler, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
   promise->set_value(fileHandler);
}

void FileHandlerObserver::OnCreateFileHandlerFailure(const std::exception_ptr & error, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<std::shared_ptr<mip::FileHandler>>>(context);
   promise->set_exception(error);
}

void FileHandlerObserver::OnCommitSuccess(bool committed, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<bool>>(context);
   promise->set_value(committed);
}

void FileHandlerObserver::OnCommitFailure(const std::exception_ptr & error, const std::shared_ptr<void>& context) {
   auto promise = std::static_pointer_cast<std::promise<bool>>(context);
   promise->set_exception(error);
}

Utilisez éventuellement F6 (Générer la solution) pour exécuter une compilation/liaison de test de votre solution afin de vous assurer qu’elle est correctement générée avant de continuer.

Ajouter une logique pour définir et obtenir une étiquette de confidentialité

Ajouter une logique pour définir et obtenir une étiquette de confidentialité sur un fichier avec l’objet de moteur de fichiers.

À l’aide de l’Explorateur de solutions, ouvrez le fichier .cpp dans votre projet qui contient l’implémentation de la méthode main(). Par défaut, il a le même nom que le projet qui le contient et que vous avez spécifié lors de la création du projet.
Ajoutez les instructions #include et using, sous les directives existantes correspondantes, en haut du fichier :
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Vers la fin du corps main(), en dessous de system("pause"); et au-dessus de return 0; (là où vous vous êtes arrêté dans le précédent Démarrage rapide), insérez le code suivant :

// Set up async FileHandler for input file operations
string inputFilePath = "<input-file-path>";
string actualFilePath = "<content-identifier>";
std::shared_ptr<FileHandler> handler;
try
{
     auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
     auto handlerFuture = handlerPromise->get_future();
     engine->CreateFileHandlerAsync(
          inputFilePath,
          actualFilePath,                       
          true, 
          std::make_shared<FileHandlerObserver>(), 
          handlerPromise);
     handler = handlerFuture.get();
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid input file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}

// Set a label on input file
try
{
     string labelId = "<label-id>";
     cout << "\nApplying Label ID " << labelId << " to " << filePathIn << endl;
     mip::LabelingOptions labelingOptions(mip::AssignmentMethod::PRIVILEGED);
     handler->SetLabel(engine->GetLabelById(labelId), labelingOptions, new ProtectionSettings());
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid label ID?\n\n" << e.what() << "'\n";
     system("pause");
     return 1; 
}

// Commit changes, save as a different/output file
string filePathOut = "<output-file-path>";
try
{
 	cout << "Committing changes" << endl;
     auto commitPromise = std::make_shared<std::promise<bool>>();
     auto commitFuture = commitPromise->get_future();
     handler->CommitAsync(filePathOut, commitPromise);
 	if (commitFuture.get()) {
 		cout << "\nLabel committed to file: " << filePathOut << endl;
 	}
 	else {
 		cout << "Failed to label: " + filePathOut << endl;
 		return 1;
 	}
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid commit file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}
system("pause");

// Set up async FileHandler for output file operations
actualFilePath = "<content-identifier>";
try
{
     auto handlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
     auto handlerFuture = handlerPromise->get_future();
     engine->CreateFileHandlerAsync(
          filePathOut,
          actualFilePath,
          true,
          std::make_shared<FileHandlerObserver>(),
          handlerPromise);

     handler = handlerFuture.get();
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid output file path?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}

// Get the label from output file
try
{
     cout << "\nGetting the label committed to file: " << filePathOut << endl;
     auto label = handler->GetLabel();
     cout << "Name: " + label->GetLabel()->GetName() << endl;
     cout << "Id: " + label->GetLabel()->GetId() << endl;
}
catch (const std::exception& e)
{
     cout << "An exception occurred... did you specify a valid label ID?\n\n" << e.what() << "'\n";
     system("pause");
     return 1;
}
system("pause");

Vers la fin de main(), recherchez le bloc d’arrêt d’application créé dans le premier démarrage rapide et supprimez les marques de commentaire de la ligne de gestionnaire :

// Application shutdown. Null out profile and engine, call ReleaseAllResources();
// Application may crash at shutdown if resources aren't properly released.
profile = nullptr;
engine = nullptr;
handler = nullptr;
mipContext = nullptr;

Remplacez les valeurs d’espace réservé du code source que vous venez de coller comme suit, en utilisant des constantes de chaîne :

Paramètre substituable	Valeur
<input-file-path>	Chemin complet d’un fichier d’entrée de test, par exemple : `"c:\\Test\\Test.docx"`.
<content-identifier>	Identificateur lisible par l’homme pour le contenu. Par exemple : pour un fichier, envisagez path\filename : `"c:\Test\Test.docx"` pour un courrier électronique, envisagez subject:sender : `"RE: Audit design:user1@contoso.com"`
<label-id>	ID d’étiquette de confidentialité, copié à partir de la sortie de la console dans le démarrage rapide précédent, par exemple : `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<output-file-path>	Chemin complet du fichier de sortie, qui sera une copie étiquetée du fichier d’entrée, par exemple : `"c:\\Test\\Test_labeled.docx"`.

Concevoir et tester l’application

Générez et testez votre application cliente.

Utilisez F6 (Créer une solution) pour créer votre application cliente. Si vous n’avez aucune erreur de build, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

Si votre projet est généré et exécuté correctement, l’application demande un jeton d’accès chaque fois que le kit de développement logiciel (SDK) appelle votre méthode AcquireOAuth2Token(). Comme vous l’avez fait précédemment dans le démarrage rapide « Lister les étiquettes de confidentialité », exécutez votre script PowerShell pour obtenir le jeton à chaque fois, en utilisant les valeurs fournies pour $authority et $resourceUrl.

Run the PowerShell script to generate an access token using the following values, then copy/paste it below:

Sensitivity labels for your organization:
Non-Business : 87ba5c36-17cf-14793-bbc2-bd5b3a9f95cz
Public : 83867195-f2b8-2ac2-b0b6-6bb73cb33afz
General : f42a3342-8706-4288-bd31-ebb85995028z
Confidential : 074e457c-5848-4542-9a6f-34a182080e7z
Highly Confidential : f55c2dea-db0f-47cd-8520-a52e1590fb6z
Press any key to continue . . .

Applying Label ID 074e457c-5848-4542-9a6f-34a182080e7z to c:\Test\Test.docx
Committing changes

Label committed to file: c:\Test\Test_labeled.docx
Press any key to continue . . .

Getting the label committed to file: c:\Test\Test_labeled.docx
Name: Confidential
Id: 074e457c-5848-4542-9a6f-34a182080e7z
Press any key to continue . . .

Vous pouvez vérifier l’application de l’étiquette en ouvrant le fichier de sortie et en inspectant visuellement les paramètres de protection des informations du document.

Remarque

Si vous étiquetez un document Office, mais que vous n’êtes pas connecté avec un compte du locataire Microsoft Entra où le jeton d’accès a été obtenu (et les étiquettes de confidentialité configurées), vous pouvez être invité à vous connecter avant d’ouvrir le document étiqueté.

Partager via