Szybki start: ustawianie i uzyskiwanie etykiety wrażliwości (C++)

Artykuł
11/27/2021
Czas czytania: 6 min

W tym przewodniku Szybki start pokazano, jak korzystać z większej liczby zestawów SDK plików MIP. Za pomocą jednej z etykiet wrażliwości wymienionych w poprzednim przewodniku Szybki start można ustawić/pobrać etykietę pliku za pomocą programu obsługi plików. Klasa obsługi plików udostępnia różne operacje ustawienia/uzyskiwania etykiet lub ochrony dla obsługiwanych typów plików.

Wymagania wstępne

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

Pełny przewodnik Szybki start: Najpierw twórz etykiety wrażliwości (C++), które tworzy rozwiązanie startowe Visual Studio, aby wyświetlić etykiety wrażliwości organizacji. Ten przewodnik Szybki start "Ustaw i uzyskaj etykietę wrażliwości" opiera się na poprzedniej.
Opcjonalnie: Przegląd programów obsługi plików w pojęciach zestawu SDK miP.

Implementowanie klasy obserwatorów w celu monitorowania obiektu obsługi plików

Podobnie jak w przypadku pliku zaimplementowanego przez Ciebie (dla profilu pliku i aparatu) w przewodniku Szybki start inicjowania aplikacji, teraz implementuje się klasę analogiczną do obiektu obsługi plików.

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

Otwórz Visual Studio(-a), nad którym pracowaliśmy w poprzednim artykule "Szybki start: etykiety wrażliwości listy (C++)".
Dodaj do projektu nową klasę, która wygeneruje dla Ciebie zarówno pliki nagłówka/.h, jak i implementacji/.cpp:
- W Eksploratorze rozwiązańkliknij ponownie prawym przyciskiem myszy węzeł projektu, wybierz pozycję Dodaj, a następnie wybierz pozycję Klasa.
- W oknie dialogowym Dodawanie zajęć:
  - W polu Nazwa zajęć wprowadź tekst "filehandler_observer". Zwróć uwagę, że zarówno pola pliku h, jak i pola pliku cpp są automatycznie wypełniane na podstawie wprowadzeniu nazwy.
  - Po zakończeniu kliknij przycisk OK.

Po wygenerowaniu plików h i cpp dla zajęć oba pliki są otwierane na kartach Grupy Redaktora. Teraz zaktualizuj każdy plik, aby wdrożyć swoją nową klasę obserwatorów:

Zaktualizuj "filehandler_observer.h", wybierając/usuwając wygenerowaną filehandler_observer klasę. Nie usuwaj użytkowników przedprocesowych wygenerowanych w poprzednim kroku (na przykład #pragma, #include). Następnie skopiuj/wklej do pliku następujące źródło po jakiejkolwiek istniejącej zaraz przedprocesorowi.

#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 wygenerowaną filehandler_observer implementację klasy. Nie usuwaj użytkowników przedprocesowych wygenerowanych w poprzednim kroku (na przykład #pragma, #include). Następnie skopiuj/wklej do pliku następujące źródło po jakiejkolwiek istniejącej zaraz przedprocesorowi.

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

Opcjonalnie użyj klawisza F6(kompilacjarozwiązania), aby uruchomić testowe zestawienie/link do rozwiązania, aby upewnić się, że będzie ono pomyślnie kompilowane przed kontynuowaniem.

Dodawanie logiki w celu ustawienia i uzyskania etykiety wrażliwości

Dodaj logikę, aby ustawić i uzyskać etykietę wrażliwości na plik przy użyciu obiektu Aparat plików.

Za pomocą Eksploratorarozwiązań otwórz plik cpp w projekcie zawierającym implementację metody. Domyślna nazwa jest taka sama jak nazwa projektu zawierającego projekt, która jest określona podczas tworzenia projektu.

U góry pliku dodaj następujące dane i zgodnie z odpowiednimi #includeusing wytycznymi:

#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;

Na końcu treści, poniżej i powyżej (miejsca, w którym ten szybki start został wcześniej main()system("pause");return 0; wyłączony), 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");

Na końcu znajdź blok zamykania aplikacji utworzony w pierwszym przewodniku szybkiego startu i main() wyłącz obsługę wiersza programu 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;

Zamień wartości zastępcze w kodzie źródłowym na następujące wartości, używając stałych ciągów:

Symbol zastępczy	Wartość
<input-file-path>	Pełna ścieżka do pliku wprowadzania testowego, na przykład: `"c:\\Test\\Test.docx"` .
<identyfikator zawartości>	Czytelny dla człowieka identyfikator zawartości. Na przykład: dla pliku przejmij pod uwagę ścieżkę \nazwa_pliku: `"c:\Test\Test.docx"` w przypadku wiadomości e-mail rozważ temat:nadawca: `"RE: Audit design:user1@contoso.com"`
<label-id>	Identyfikator etykiety wrażliwości skopiowany z danych wyjściowych konsoli w poprzednim przewodniku Szybki start, na przykład: `"f42a3342-8706-4288-bd31-ebb85995028z"` .
<output-file-path>	Pełna ścieżka do pliku wyjściowego, który będzie kopią pliku wejściowego oznaczoną etykietą, na przykład: `"c:\\Test\\Test_labeled.docx"` .

Tworzenie i testowanie aplikacji

Skompilowanie i testowanie aplikacji klienckiej.

Do tworzenia aplikacji klienckiej użyj klawisza F6(build solution). Jeśli nie występują błędy kompilacji, użyj klawisza F5(Rozpocznijdebugowanie), aby uruchomić aplikację.

Jeśli projekt pomyślnie tworzy i uruchamia się, aplikacja monituje o token dostępu, za każdym razem, gdy zestaw SDK wywołuje AcquireOAuth2Token() metodę. Tak jak wcześniej na pasku Szybki start "Lista etykiet wrażliwości", uruchom skrypt programu PowerShell, aby za każdym razem uzyskać token, używając wartości podanych dla poleceń $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 . . .

Możesz sprawdzić aplikację etykiety, otwierając plik wyjściowy i przeglądając wizualnie ustawienia ochrony informacji w dokumencie.

Uwaga

Jeśli dokument programu Office jest oznaczony etykietą, ale nie loguje się przy użyciu konta z dzierżawy usługi Azure Active Directory (AD), w której uzyskano token dostępu (i skonfigurowano etykiety wrażliwości), może zostać wyświetlony monit o zalogowanie się przed otwarciem oznaczonego dokumentu.

Szybki start: ustawianie i uzyskiwanie etykiety wrażliwości (C++)

Oceń swoje doświadczenia

Wymagania wstępne

Implementowanie klasy obserwatorów w celu monitorowania obiektu obsługi plików

Dodawanie logiki w celu ustawienia i uzyskania etykiety wrażliwości

Tworzenie i testowanie aplikacji