Snabbstart: Ange och hämta en känslighetsetikett (C++)

Artikel
01/30/2024

Den här snabbstarten visar hur du använder fler MIP-fil-SDK:er. Med någon av de känslighetsetiketter som du angav i föregående snabbstart använder du en filhanterare för att ange/hämta etiketten på en fil. Klassen Filhanterare exponerar olika åtgärder för att ange/hämta etiketter eller skydd för filtyper som stöds.

Förutsättningar

Om du inte redan har gjort det måste du slutföra följande krav innan du fortsätter:

Slutför snabbstart: Lista känslighetsetiketter (C++) först, som skapar en startlösning för Visual Studio, för att visa en organisations känslighetsetiketter. Snabbstarten "Ange och hämta en känslighetsetikett" bygger på den föregående.
Alternativt: Granska filhanterare i MIP SDK-begreppen .

Implementera en observatörsklass för att övervaka filhanterarobjektet

På samma sätt som den övervakare som du implementerade (för filprofilen och motorn) i snabbstarten för programinitiering implementerar du nu en observatörsklass för ett filhanterarobjekt.

Skapa en grundläggande implementering för en filhanterarobservatör genom att utöka SDK:ts mip::FileHandler::Observer klass. Övervakaren instansieras och används senare för att övervaka filhanteraråtgärder.

Öppna Visual Studio-lösningen som du arbetade med i föregående artikel "Snabbstart: Lista känslighetsetiketter (C++)."
Lägg till en ny klass i projektet, som genererar både huvud-/.h- och implementeringsfilerna/.cpp åt dig:
- I Solution Explorer högerklickar du på projektnoden igen, väljer Lägg till och väljer sedan Klass.
- I dialogrutan Lägg till klass:
  - I fältet Klassnamn anger du "filehandler_observer". Observera att både .h-filen och .cpp-filfälten fylls i automatiskt, baserat på det namn du anger.
  - När du är klar klickar du på ok-knappen .

När du har genererat .h- och .cpp-filerna för klassen öppnas båda filerna på flikarna Redigerargrupp. Uppdatera nu varje fil för att implementera din nya observatörsklass:

Uppdatera "filehandler_observer.h" genom att välja/ta bort den genererade filehandler_observer klassen. Ta inte bort de förprocessordirektiv som genererades av föregående steg (#pragma, #include). Kopiera/klistra sedan in följande källa i filen efter befintliga förprocessordirektiv:

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

Uppdatera "filehandler_observer.cpp" genom att välja/ta bort den genererade filehandler_observer klassimplementeringen. Ta inte bort de förprocessordirektiv som genererades av föregående steg (#pragma, #include). Kopiera/klistra sedan in följande källa i filen efter befintliga förprocessordirektiv:

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

Du kan också använda F6 (Build Solution) för att köra en testkompilering/länk för din lösning för att se till att den skapas korrekt innan du fortsätter.

Lägga till logik för att ange och hämta en känslighetsetikett

Lägg till logik för att ange och hämta en känslighetsetikett på en fil med hjälp av filmotorobjektet.

Använd Solution Explorer och öppna .cpp-filen i projektet som innehåller implementeringen av main() metoden. Det är som standard samma namn som det projekt som innehåller det, som du angav när projektet skapades.
Lägg till följande #include och using direktiv, under motsvarande befintliga direktiv, överst i filen:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

Mot slutet av brödtexten main() , nedanför system("pause"); och ovanför return 0; (där du slutade i föregående snabbstart), infogar du följande 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");

Mot slutet av main() hitta block för programavstängning som skapades i den första snabbstarten och avkommentera hanteringsraden:

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

Ersätt platshållarvärdena i källkoden som du följer med hjälp av strängkonstanter:

Platshållare	Värde
<input-file-path>	Den fullständiga sökvägen till en testindatafil, till exempel: `"c:\\Test\\Test.docx"`.
<content-identifier>	En identifierare som kan läsas av människor för innehållet. Exempelvis: För en fil bör du överväga path\filename: `"c:\Test\Test.docx"` för ett e-postmeddelande bör du överväga ämne:avsändare : `"RE: Audit design:user1@contoso.com"`
<etikett-ID>	Ett känslighetsetikett-ID som kopierades från konsolens utdata i föregående snabbstart, till exempel: `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<output-file-path>	Den fullständiga sökvägen till utdatafilen, som är en märkt kopia av indatafilen, till exempel: `"c:\\Test\\Test_labeled.docx"`.

Skapa och testa programmet

Skapa och testa klientprogrammet.

Använd F6 (Build Solution) för att skapa klientprogrammet. Om du inte har några byggfel använder du F5 (Starta felsökning) för att köra programmet.

Om projektet har skapats och körts frågar programmet efter en åtkomsttoken varje gång SDK:t anropar din AcquireOAuth2Token() metod. Precis som tidigare i snabbstarten "Lista känslighetsetiketter" kör du PowerShell-skriptet för att hämta token varje gång med hjälp av värdena för $authority och $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 . . .

Du kan verifiera etikettens program genom att öppna utdatafilen och visuellt granska dokumentets inställningar för informationsskydd.

Kommentar

Om du etiketterar ett Office-dokument, men inte är inloggad med ett konto från Microsoft Entra-klientorganisationen där åtkomsttoken hämtades (och känslighetsetiketter har konfigurerats), kan du uppmanas att logga in innan du kan öppna det märkta dokumentet.

Share via