Szybki start: ustawianie i uzyskiwanie etykiety poufności (C++)

W tym przewodniku szybkiego startu pokazano, jak korzystać z większej liczby zestawów SDK plików MIP. Korzystając z jednej z etykiet poufności wymienionych w poprzednim przewodniku Quickstart, menedżer plików służy do ustawiania/pobierania etykiety na pliku. Klasa obsługi plików uwidacznia różne operacje ustawiania/pobierania etykiet lub ochrony dla obsługiwanych typów plików.

Wymagania wstępne

Jeśli jeszcze tego nie zrobiono, przed kontynuowaniem upewnij się, że zostały spełnione następujące wymagania wstępne:

• Ukończ szybki start: najpierw wyświetl listę etykiet poufności (C++), które tworzy początkowe rozwiązanie programu Visual Studio, aby wyświetlić listę etykiet poufności organizacji. Ten przewodnik Szybkiego startu dotyczący konfigurowania i przypisywania etykiety poufności bazuje na poprzednim kroku.
• Opcjonalnie: Zapoznaj się z koncepcjami obsługi plików w zestawie MIP SDK.

Implementowanie klasy obserwatora w celu monitorowania obiektu programu obsługi plików

Podobnie jak w przypadku zaimplementowanego obserwatora (dla profilu plików i silnika) w przewodniku Szybkiego Startu, teraz implementujesz klasę obserwatora dla obiektu obsługi plików.

Utwórz podstawową implementację obserwatora programu obsługi plików, rozszerzając klasę zestawu SDK mip::FileHandler::Observer . Obserwator jest tworzony i używany później, do monitorowania operacji obsługi plików.

1. Otwórz rozwiązanie programu Visual Studio, nad którym pracowałeś w poprzednim artykule "Szybki start: Lista etykiet poufności (C++)".

2. Dodaj nową klasę do projektu, która generuje pliki header/.h i implementation/.cpp dla Ciebie:

   • W Eksploratorze rozwiązań ponownie kliknij prawym przyciskiem myszy węzeł projektu, wybierz polecenie Dodaj, a następnie wybierz pozycję Klasa.
   • W oknie dialogowym Dodawanie klasy :
     • W polu Nazwa klasy wprowadź "filehandler_observer". Zwróć uwagę, że zarówno plik h , jak i pola pliku .cpp są wypełniane automatycznie na podstawie wprowadzonej nazwy.
     • Po zakończeniu kliknij przycisk OK .

3. Po wygenerowaniu plików h i .cpp dla klasy oba pliki są otwierane na kartach Grupy edytora. Teraz zaktualizuj każdy plik, aby zaimplementować nową klasę obserwatora:

   • Zaktualizuj "filehandler_observer.h", wybierając/usuwając wygenerowaną filehandler_observer klasę. Nie usuwaj dyrektyw preprocesora wygenerowanych w poprzednim kroku (#pragma, #include). Następnie skopiuj/wklej następujące źródło do pliku po istniejących dyrektywach preprocesora:

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

   • Zaktualizuj "filehandler_observer.cpp", wybierając/usuwając implementację klasy filehandler_observer wygenerowanej. Nie usuwaj dyrektyw preprocesora wygenerowanych w poprzednim kroku (#pragma, #include). Następnie skopiuj/wklej następujące źródło do pliku po istniejących dyrektywach preprocesora:

     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. Opcjonalnie użyj F6 (Kompiluj rozwiązanie), aby uruchomić kompilowanie/łącze testowe rozwiązania, aby upewnić się, że kompilacja została pomyślnie skompilowana przed kontynuowaniem.

Dodaj logikę do ustawiania i pobierania etykiety poufności

Dodaj logikę do ustawiania i pobierania etykiety poufności dla pliku, używając obiektu silnika plików.

1. Za pomocą Eksploratora rozwiązań otwórz plik .cpp w projekcie zawierający implementację main() metody . Domyślnie ma taką samą nazwę jak projekt zawierający go, który został określony podczas tworzenia projektu.

2. Dodaj następujące dyrektywy #include i using poniżej odpowiednich istniejących dyrektyw na górze pliku.

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

3. Na końcu treści main(), poniżej system("pause"); i powyżej return 0; (gdzie zakończono w poprzednim przewodniku Szybki start) wstaw następujący kod:

   // 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. Pod koniec main() znajdź blok zamykania aplikacji utworzony w pierwszym przewodniku Szybki start i usuń komentarz z linii obsługi.

   // 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. Zastąp wartości zastępcze w kodzie źródłowym w następujący sposób, używając stałych ciągów znaków.

   Zastępczy element	Wartość
   <ścieżka pliku wejściowego>	Pełna ścieżka do pliku wejściowego testu, na przykład: "c:\\Test\\Test.docx".
   <identyfikator zawartości>	Czytelny dla człowieka identyfikator zawartości. Przykład: w przypadku pliku rozważ ścieżkę\nazwę pliku: "c:\Test\Test.docx" w przypadku wiadomości e-mail rozważ temat:sender: "RE: Audit design:user1@contoso.com"
   <label-id>	Identyfikator etykiety poufności skopiowany z danych wyjściowych konsoli w poprzednim przewodniku Szybki start, na przykład: "f42a3342-8706-4288-bd31-ebb85995028z".
   <ścieżka pliku wyjściowego>	Pełna ścieżka do pliku wyjściowego, który będzie oznakowaną kopią pliku wejściowego, na przykład: "c:\\Test\\Test_labeled.docx".

Kompilowanie i testowanie aplikacji

Skompiluj i przetestuj aplikację kliencą.

1. Użyj F6 (Kompiluj rozwiązanie) do stworzenia aplikacji klienckiej. Jeśli nie masz błędów kompilacji, użyj F5 (Rozpocznij debugowanie), aby uruchomić aplikację.

2. Jeśli Twój projekt się kompiluje i uruchamia bez błędów, aplikacja za każdym razem, gdy SDK wywołuje Twoją metodę AcquireOAuth2Token(), poprosi o token dostępu. Tak jak zrobiłeś to wcześniej w przewodniku Szybki start "Lista etykiet poufności", uruchom skrypt PowerShell, aby za każdym razem uzyskać token, używając wartości podanych dla $authority i $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 . . .
   

Aplikację etykiety można zweryfikować, otwierając plik wyjściowy i sprawdzając wizualnie ustawienia ochrony informacji dokumentu.