Schnellstart: Festlegen und Abrufen einer Vertraulichkeitsbezeichnung (C++)

In dieser Schnellstartanleitung erfahren Sie, wie Sie mehr der MIP-Datei-SDKs verwenden. Mit einem der Vertraulichkeitslabels, die Sie im vorherigen Schnellstart aufgelistet haben, verwenden Sie einen Dateihandler, um die Bezeichnung für eine Datei festzulegen oder abzurufen. Die File-Handlerklasse macht verschiedene Vorgänge zum Festlegen/Abrufen von Bezeichnungen oder zum Schutz für unterstützte Dateitypen verfügbar.

Voraussetzungen

Falls noch nicht geschehen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllen, bevor Sie fortfahren:

• Schließen Sie zuerst den Schnellstart: Auflisten von Vertraulichkeitsbezeichnungen (C++) ab, in dem eine Visual Studio-Startprojektmappe zum Auflisten der Vertraulichkeitsbezeichnungen einer Organisation erstellt wird. Dieser Schnellstart „Festlegen und Abrufen von Vertraulichkeitsbezeichnungen“ baut auf dem vorherigen auf.
• Optional: Überprüfen von Dateihandlern in den MIP SDK-Konzepten .

Implementieren einer Beobachterklasse zum Überwachen des File-Handlerobjekts

Ähnlich wie der Beobachter, den Sie (für das Dateiprofil und das Modul) in der Schnellstartanleitung für die Anwendungsinitialisierung implementiert haben, implementieren Sie nun eine Beobachterklasse für ein File-Handler-Objekt.

Erstellen Sie eine grundlegende Implementierung für einen Dateihandlerbeobachter, indem Sie die SDK-Klasse mip::FileHandler::Observer erweitern. Der Beobachter wird instanziiert und später verwendet, um Dateihandlervorgänge zu überwachen.

1. Öffnen Sie die Visual Studio-Lösung, an der Sie im vorherigen Artikel "Schnellstart: Auflisten von Vertraulichkeitsbezeichnungen (C++)" gearbeitet haben.

2. Fügen Sie Ihrem Projekt eine neue Klasse hinzu, die sowohl die Header/.h- als auch die Implementierungs-/.cpp dateien für Sie generiert:

   • Klicken Sie im Projektmappen-Explorer erneut mit der rechten Maustaste auf den Projektknoten, wählen Sie "Hinzufügen" und dann "Klasse" aus.
   • Im Dialogfeld "Klasse hinzufügen ":
     • Geben Sie im Feld "Klassenname " "filehandler_observer" ein. Beachten Sie, dass sowohl die H-Datei als auch .cpp Dateifelder basierend auf dem eingegebenen Namen automatisch ausgefüllt werden.
     • Klicken Sie abschließend auf die Schaltfläche "OK ".

3. Nach dem Generieren der .h- und .cpp-Dateien für die Klasse werden beide Dateien in den Tabs der Editorgruppe geöffnet. Aktualisieren Sie nun jede Datei, um Ihre neue Beobachterklasse zu implementieren:

   • Aktualisieren Sie "filehandler_observer.h", indem Sie die generierte filehandler_observer Klasse auswählen/löschen. Entfernen Sie die vom vorherigen Schritt generierten Präprozessordirektiven nicht (#pragma, #include). Kopieren/fügen Sie dann die folgende Quelle nach vorhandenen Präprozessordirektiven in die Datei ein:

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

   • Aktualisieren Sie "filehandler_observer.cpp", indem Sie die generierte filehandler_observer Klassenimplementierung auswählen/löschen. Entfernen Sie die vom vorherigen Schritt generierten Präprozessordirektiven nicht (#pragma, #include). Kopieren/fügen Sie dann die folgende Quelle nach vorhandenen Präprozessordirektiven in die Datei ein:

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

4. Verwenden Sie optional F6 (Buildlösung), um eine Testkompilierung/Verknüpfung Ihrer Lösung auszuführen, um sicherzustellen, dass sie erfolgreich erstellt wird, bevor Sie fortfahren.

Hinzufügen von Logik zum Festlegen und Abrufen einer Vertraulichkeitsbezeichnung

Fügen Sie Logik zum Festlegen und Abrufen einer Vertraulichkeitsbezeichnung für eine Datei mithilfe des File-Modulobjekts hinzu.

1. Öffnen Sie im Projektmappen-Explorer die datei .cpp in Ihrem Projekt, die die Implementierung der main() Methode enthält. Standardmäßig wird derselbe Name wie das Projekt verwendet, das es enthält, das Sie während der Projekterstellung angegeben haben.

2. Fügen Sie am Anfang der Datei die folgenden #include und using direktiven unter den entsprechenden vorhandenen Direktiven hinzu:

   #include "filehandler_observer.h" 
   #include "mip/file/file_handler.h" 
   
   using mip::FileHandler;
   

3. Fügen Sie am Ende des main() Textkörpers unten system("pause"); und oben return 0; (wo Sie in der vorherigen Schnellstartanleitung aufgehört haben) den folgenden Code ein:

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

4. Suchen Sie am Ende von main() den Block zum Herunterfahren der Anwendung, den Sie im ersten Schnellstart erstellt haben, und heben Sie die Auskommentierung der Zeile für den Handler auf:

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

5. Ersetzen Sie die Platzhalterwerte im Quellcode wie folgt, indem Sie String-Konstanten verwenden.

   Platzhalter	Wert
   <Eingabedateipfad>	Der vollständige Pfad zu einer Testeingabedatei, z. B.: "c:\\Test\\Test.docx".
   <Inhalts-ID>	Ein lesbarer Bezeichner für den Inhalt. Beispiel: Verwenden Sie für eine Datei das Format Pfad\Dateiname: "c:\Test\Test.docx". für eine E-Mail, erwägen Sie subject:sender : "RE: Audit design:user1@contoso.com"
   <Bezeichnungs-ID>	Eine Vertraulichkeitsbezeichnungs-ID, die aus der Konsolenausgabe im vorherigen Schnellstart kopiert wird, z. B. "f42a3342-8706-4288-bd31-ebb85995028z"
   <Ausgabedateipfad>	Der vollständige Pfad zur Ausgabedatei, die eine beschriftete Kopie der Eingabedatei ist, z. B.: "c:\\Test\\Test_labeled.docx".

Erstellen und Testen der Anwendung

Erstellen und testen Sie Ihre Clientanwendung.

1. Verwenden Sie F6 (Lösung erstellen), um Ihre Clientanwendung zu erstellen. Wenn keine Buildfehler auftreten, verwenden Sie F5 (Debuggen starten), um Ihre Anwendung auszuführen.

2. Wenn Ihr Projekt erfolgreich erstellt und ausgeführt wird, fordert die Anwendung jedes Mal, wenn das SDK Ihre AcquireOAuth2Token() Methode aufruft, ein Zugriffstoken ein. Führen Sie wie zuvor in der Schnellstartanleitung "Vertraulichkeitsbezeichnungen auflisten" Ihr PowerShell-Skript aus, um das Token jedes Mal zu erwerben, wobei die für $authority und $resourceUrl angegebenen Werte verwendet werden.

   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 . . .
   

Sie können die Anwendung der Bezeichnung überprüfen, indem Sie die Ausgabedatei öffnen und die Informationsschutzeinstellungen des Dokuments visuell prüfen.