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

Tento rychlý průvodce vám ukáže, jak více využívat SDK pro MIP soubory. 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ů.

Požadavky

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

Nejprve dokončete Úvod: Seznam popisků citlivosti (C++), který vytvoří počáteční řešení ve Visual Studiu pro výpis popisků citlivosti organizace. Tento rychlý průvodce "Nastavit a získat popisek citlivosti" navazuje na předchozí.
Volitelně: Zkontrolujte obslužné rutiny souborů v konceptech sady MIP SDK .

Implementace třídy pozorovatele pro sledování objektu správce souboru

Podobně jako pozorovatel, který jste implementovali (pro profil souboru a modul) v rychlém průvodci inicializací aplikace, nyní implementujete třídu pozorovatele pro objekt obslužné rutiny souboru.

Vytvořte základní implementaci pro pozorovatele obslužné rutiny souborů rozšířením třídy SDK mip::FileHandler::Observer. Pozorovatel je vytvořen a později použit k monitorování operací obslužné rutiny souborů.

Otevřete řešení Visual Studio, na kterém jste pracovali v předchozím článku Úvod: Seznam popisků citlivosti (C++).
Přidejte do projektu novou třídu, která za vás vygeneruje soubory header/.h i implementace/.cpp:
- V Průzkumníku ř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 se automaticky vyplní pole souboru .h i .cpp 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 Skupiny 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 po všech existujících direktivách 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 tak, že vyberete nebo odstraníte vygenerovanou filehandler_observer implementaci třídy. Neodebíjejte direktivy preprocesoru generované předchozím krokem (#pragma, #include). Potom zkopírujte/vložte následující zdroj do souboru po všech existujících direktivách 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řidat logiku pro nastavení a získání štítku citlivosti

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

Pomocí Průzkumníka řešení otevřete soubor .cpp v projektu, který obsahuje implementaci main() metody. V rámci výchozího nastavení se použije stejný název jako projekt, který ho obsahuje a 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;
```

Ke konci main() textu, pod system("pause"); a nad 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:

Placeholder	Hodnota
<input-file-path>	Úplná cesta k testovacímu vstupnímu souboru, například: `"c:\\Test\\Test.docx"`.
<identifikátor obsahu>	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"`
<identifikátor štítku>	ID popisku citlivosti zkopírované z výstupu konzoly v předchozím rychlém startu, například: `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<cesta k výstupnímu souboru>	Ú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 průvodci rychlým startem "List sensitivity labels" spusťte skript PowerShell, abyste pokaždé získali token pomocí hodnot poskytnutý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í.

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-04-20