Rychlý start: Nastavení a získání popisku citlivosti (C++)

Článek
01/30/2024

V tomto rychlém startu se dozvíte, jak používat více sad SDK pro soubory MIP. Pomocí jednoho z popisků citlivosti, které jste uvedli v předchozím rychlém startu, použijete obslužnou rutinu souboru k nastavení nebo získání popisku v souboru. Třída obslužné rutiny File zveřejňuje různé operace pro nastavení/získání popisků nebo ochranu pro podporované typy souborů.

Předpoklady

Pokud jste to ještě neudělali, nezapomeňte před pokračováním dokončit následující požadavky:

Úplný rychlý start: Nejprve vypíše popisky citlivosti (C++), které vytvoří počáteční řešení sady Visual Studio, aby se vypsaly popisky citlivosti organizace. Tento rychlý start "Nastavit a získat popisek citlivosti" vychází z předchozího.
Volitelně: Zkontrolujte obslužné rutiny souborů v konceptech sady MIP SDK .

Implementace třídy pozorovatele pro monitorování objektu obslužné rutiny souboru

Podobně jako pozorovatel, který jste implementovali (pro profil souboru a modul) v rychlém startu inicializace aplikace, teď implementujete třídu pozorovatele pro objekt obslužné rutiny Souboru.

Vytvořte základní implementaci pro pozorovatele obslužné rutiny File rozšířením třídy sady SDK mip::FileHandler::Observer . Pozorovatel se vytvoří instance a později se použije k monitorování operací obslužné rutiny souboru.

Otevřete řešení sady Visual Studio, na které jste pracovali v předchozím článku Rychlý start: Výpis popisků citlivosti (C++).
Přidejte do projektu novou třídu, která za vás vygeneruje soubory header/.h i implementation/.cpp:
- V Průzkumník řešení znovu klikněte pravým tlačítkem myši na uzel projektu, vyberte Přidat a pak vyberte Třída.
- V dialogovém okně Přidat třídu :
  - Do pole Název třídy zadejte "filehandler_observer". Všimněte si, že pole souboru .h i souboru .cpp se automaticky vyplní na základě zadaného názvu.
  - Po dokončení klikněte na tlačítko OK .

Po vygenerování souborů .h a .cpp pro třídu se oba soubory otevřou na kartách Skupina editoru. Teď aktualizujte každý soubor tak, aby implementovali novou třídu pozorovatele:

Aktualizujte "filehandler_observer.h" tak, že vyberete nebo odstraníte vygenerovanou filehandler_observer třídu. Neodebíjejte direktivy preprocesoru generované předchozím krokem (#pragma, #include). Potom zkopírujte/vložte následující zdroj do souboru za všechny existující direktivy preprocesoru:

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

Aktualizujte "filehandler_observer.cpp" výběrem nebo odstraněním vygenerované filehandler_observer implementace třídy. Neodebíjejte direktivy preprocesoru generované předchozím krokem (#pragma, #include). Potom zkopírujte/vložte následující zdroj do souboru za všechny existující direktivy preprocesoru:

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

Volitelně můžete pomocí F6 (sestavit řešení) spustit testovací kompilaci nebo propojení vašeho řešení, abyste se ujistili, že se sestavení úspěšně sestaví, než budete pokračovat.

Přidání logiky pro nastavení a získání popisku citlivosti

Přidejte logiku pro nastavení a získání popisku citlivosti v souboru pomocí objektu File engine.

Pomocí Průzkumník řešení otevřete soubor .cpp v projektu, který obsahuje implementaci main() metody. Ve výchozím nastavení se použije stejný název jako projekt, který obsahuje, který jste zadali při vytváření projektu.
Do horní části souboru přidejte následující #include a using direktivy pod odpovídající existující direktivy:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Na konec main() textu níže system("pause"); a výše return 0; (kde jste skončili v předchozím rychlém startu) vložte následující kód:

// 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 konci main() vyhledejte blok vypnutí aplikace vytvořený v prvním rychlém startu a odkomentujte řádek obslužné rutiny:

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

Nahraďte zástupné hodnoty ve zdrojovém kódu následujícím způsobem pomocí řetězcových konstant:

Zástupný symbol	Hodnota
<input-file-path>	Úplná cesta k testovacímu vstupnímu souboru, například: `"c:\\Test\\Test.docx"`.
<content-identifier>	Identifikátor pro obsah čitelný člověkem. Například: u souboru zvažte cestu\název_souboru: `"c:\Test\Test.docx"` pro e-mail zvažte předmět:sender: `"RE: Audit design:user1@contoso.com"`
<label-id>	ID popisku citlivosti zkopírované z výstupu konzoly v předchozím rychlém startu, například: `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<output-file-path>	Úplná cesta k výstupnímu souboru, což bude označená kopie vstupního souboru, například: `"c:\\Test\\Test_labeled.docx"`.

Sestavení a otestování aplikace

Sestavte a otestujte klientskou aplikaci.

K sestavení klientské aplikace použijte klávesu F6 (Build Solution). Pokud nemáte žádné chyby sestavení, spusťte aplikaci pomocí klávesy F5 (spustit ladění).

Pokud se projekt sestaví a úspěšně spustí, aplikace vyzve k zadání přístupového tokenu pokaždé, když sada SDK volá vaši AcquireOAuth2Token() metodu. Stejně jako v předchozím rychlém startu "List sensitivity labels" (Popisky citlivosti) spusťte skript PowerShellu, abyste získali token pokaždé pomocí hodnot zadaných pro $authority a $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 . . .

Aplikaci popisku můžete ověřit tak, že otevřete výstupní soubor a vizuálně zkontrolujete nastavení ochrany informací v dokumentu.

Poznámka:

Pokud označujete dokument Office, ale nejste přihlášení pomocí účtu z tenanta Microsoft Entra, kde byl přístupový token získán (a popisky citlivosti jsou nakonfigurované), můžete být před otevřením označeného dokumentu vyzváni k přihlášení.

Sdílet prostřednictvím