Snelstart: Een gevoeligheidslabel instellen en krijgen (C++)

In deze Snelstart ziet u hoe u meer MIP-bestands-SDK's kunt gebruiken. Met een van de gevoeligheidslabels die u in de vorige Quickstart hebt vermeld, gebruikt u een bestands handler om het label in te stellen/op te halen in een bestand. In de klasse Bestands handler worden verschillende bewerkingen voor het instellen/verkrijgen van labels of beveiliging voor ondersteunde bestandstypen belichten.

Vereisten

Als u dat nog niet hebt gedaan, moet u de volgende vereisten voltooien voordat u verdergaat:

• Snelstart voltooien: Eerst de gevoeligheidslabels voor lijst (C++), waarmee een starter-Visual Studio wordt gebouwd, om de gevoeligheidslabels van een organisatie op te geven. Dit 'Set and get a sensitivity label' Quickstart is gebaseerd op het vorige.
• Desgewenst: Bestands handlers controleren in de MIP SDK-concepten.

Een waarnemerklasse implementeren om het object Bestands handler te controleren

Net als de waarnemer die u hebt geïmplementeerd (voor het bestandsprofiel en de engine) in de Quickstart-initialisatie van toepassing, implementeert u nu een waarnemerklasse voor een bestands handler-object.

Maak een basisuitvoering voor een bestandsbegeleider door de klasse van de SDK uit te mip::FileHandler::Observer breiden. De waarnemer wordt ge instantiated en later gebruikt om de bewerkingen van bestands handler te controleren.

1. Open de Visual Studio oplossing waar u aan hebt gewerkt in het vorige artikel 'Snelstart: gevoeligheidslabels voor lijst (C++)'.

2. Voeg een nieuwe klas toe aan uw project, die zowel de header/.h- als de implementatie-/.cpp-bestanden voor u genereert:

   • Klik in de Solution Explorernogmaals met de rechtermuisknop op het project knooppunt, selecteer Toevoegenen selecteer vervolgens Klas.
   • In het dialoogvenster Klas toevoegen:
     • Voer in het veld Klasnaam 'filehandler_observer' in. U ziet dat zowel het .h-bestand als de .cpp-bestandsvelden automatisch worden ingevuld op basis van de naam die u hebt ingevuld.
     • Wanneer u klaar bent, klikt u op de knop OK.

3. Nadat de .h- en .cpp-bestanden voor de klas zijn gegenereerd, worden beide bestanden geopend op de tabbladen editorgroep. Werk nu elk bestand bij om uw nieuwe waarnemerklasse te implementeren:

   • Werk 'filehandler_observer.u' bij door de gegenereerde klas te filehandler_observer selecteren/te verwijderen. Verwijder de preprocessorrichtlijnen die zijn gegenereerd door de vorige stap (#pragma, #include). Kopieer/plak vervolgens de volgende bron in het bestand, na bestaande preprocessorrichtlijnen:

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

   • Werk 'filehandler_observer.cpp' bij door de gegenereerde klasse-implementatie te filehandler_observer selecteren/te verwijderen. Verwijder de preprocessorrichtlijnen die zijn gegenereerd door de vorige stap (#pragma, #include). Kopieer/plak vervolgens de volgende bron in het bestand, na bestaande preprocessorrichtlijnen:

     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. Gebruik desgewenst F6(Build Solution)om een test compilatie/koppeling van uw oplossing uit te voeren, om ervoor te zorgen dat de oplossing goed wordt gemaakt voordat u doorgaat.

Logica toevoegen om een gevoeligheidslabel in te stellen en te krijgen

Voeg logica toe om een gevoeligheidslabel voor een bestand in te stellen en op te halen met behulp van het bestands-engineobject.

1. Open met Solution Explorerhet CPP-bestand in uw project dat de implementatie van de methode bevat. De naam wordt standaard ingesteld op dezelfde naam als het project dat het bevat, dat u hebt opgegeven tijdens het maken van een project.

2. Voeg de volgende #include en using richtlijnen, onder de bijbehorende bestaande richtlijnen, boven aan het bestand toe:

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

3. Voeg aan het einde van de body, onder en boven (waar u was gebleven in de vorige main()system("pause"); Quickstart), de volgende code return 0; in:

   // 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. Tegen het einde van het zoekblok voor het afsluiten van de toepassing dat is gemaakt in de eerste quickstart en de main() handlerregel los te maken:

   // 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. Vervang de tijdelijke aanduidingen in de broncode die u als volgt gebruikt, met behulp van tekenreeksconstanten:

   Tijdelijke aanduiding	Waarde
   <invoerbestandspad>	Het volledige pad naar een testinvoerbestand, bijvoorbeeld: "c:\\Test\\Test.docx" .
   <inhoudsaanduiding>	Een door de mens gelezen id voor de inhoud. Bijvoorbeeld: voor een bestand, overweeg pad\bestandsnaam: "c:\Test\Test.docx" voor een e-mail, overweeg onderwerp:afzender: "RE: Audit design:user1@contoso.com"
   <label-id>	Een gevoeligheidslabel-id, gekopieerd van de consoleuitvoer in de vorige Quickstart, bijvoorbeeld: "f42a3342-8706-4288-bd31-ebb85995028z" .
   <uitvoerbestandspad>	Het volledige pad naar het uitvoerbestand, dat een gelabelde kopie van het invoerbestand is, bijvoorbeeld: "c:\\Test\\Test_labeled.docx" .

De toepassing maken en testen

Bouw en test uw clienttoepassing.

1. Gebruik F6(Build Solution)om uw clienttoepassing te maken. Als u geen buildfouten hebt, gebruikt u F5(Foutopsporingstarten) om de toepassing uit te voeren.

2. Als uw project wordt gebouwd en uitgevoerd, wordt in de toepassing om een toegangs token gevraagd, telkens wanneer de SDK uw methode AcquireOAuth2Token() aanroept. Voer uw PowerShell-script uit om het token elke keer te verkrijgen, met behulp van de waarden die zijn opgegeven voor $authority en $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 . . .
   

U kunt de toepassing van het label controleren door het uitvoerbestand te openen en de instellingen voor informatiebeveiliging van het document visueel te controleren.