Guia de início rápido: definir e obter um rótulo de sensibilidade (C++)

Artigo
01/30/2024

Este Guia de início rápido mostra como usar mais dos SDKs de arquivo MIP. Usando um dos rótulos de sensibilidade listados no Guia de início rápido anterior, você usa um manipulador de arquivos para definir/obter o rótulo em um arquivo. A classe File handler expõe várias operações para definir/obter rótulos ou proteção para tipos de arquivo suportados.

Pré-requisitos

Se ainda não o fez, certifique-se de que preenche os seguintes pré-requisitos antes de continuar:

Guia de início rápido completo : liste rótulos de sensibilidade (C++) primeiro, que cria uma solução inicial do Visual Studio, para listar os rótulos de sensibilidade de uma organização. Este Guia de início rápido "Definir e obter um rótulo de sensibilidade" baseia-se no anterior.
Opcionalmente: revise os manipuladores de arquivos nos conceitos do MIP SDK .

Implementar uma classe de observador para monitorar o objeto File handler

Semelhante ao observador que você implementou (para o perfil File e o mecanismo) no Guia de início rápido de inicialização do aplicativo, agora você implementa uma classe de observador para um objeto do manipulador de arquivos.

Crie uma implementação básica para um observador do manipulador de arquivos, estendendo a classe do mip::FileHandler::Observer SDK. O observador é instanciado e usado posteriormente para monitorar as operações do manipulador de arquivos.

Abra a solução do Visual Studio em que você trabalhou no artigo anterior "Guia de início rápido: listar rótulos de sensibilidade (C++)".
Adicione uma nova classe ao seu projeto, que gera os arquivos header/.h e implementation/.cpp para você:
- No Gerenciador de Soluções, clique com o botão direito do mouse no nó do projeto novamente, selecione Adicionar e, em seguida, selecione Classe.
- Na caixa de diálogo Adicionar classe:
  - No campo Nome da classe, digite "filehandler_observer". Observe que os campos de arquivo .h e arquivo .cpp são preenchidos automaticamente, com base no nome inserido.
  - Quando terminar, clique no botão OK .

Depois de gerar os arquivos .h e .cpp para a classe, ambos os arquivos são abertos nas guias Grupo de Editores. Agora atualize cada arquivo para implementar sua nova classe de observador:

Atualize "filehandler_observer.h", selecionando/excluindo a classe gerada filehandler_observer . Não remova as diretivas de pré-processador geradas pela etapa anterior (#pragma, #include). Em seguida, copie/cole a seguinte fonte no arquivo, após quaisquer diretivas de pré-processador existentes:

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

Atualize "filehandler_observer.cpp", selecionando/excluindo a implementação da classe gerada filehandler_observer . Não remova as diretivas de pré-processador geradas pela etapa anterior (#pragma, #include). Em seguida, copie/cole a seguinte fonte no arquivo, após quaisquer diretivas de pré-processador existentes:

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

Opcionalmente, use F6 (Build Solution) para executar uma compilação/link de teste da sua solução, para garantir que ela seja compilada com êxito antes de continuar.

Adicionar lógica para definir e obter um rótulo de sensibilidade

Adicione lógica para definir e obter um rótulo de sensibilidade em um arquivo, usando o objeto File engine.

Usando o Gerenciador de Soluções, abra o arquivo de .cpp em seu projeto que contém a main() implementação do método. O padrão é o mesmo nome do projeto que o contém, que você especificou durante a criação do projeto.
Acrescentar o seguinte #include e using as diretivas, abaixo das diretivas correspondentes existentes, no topo do ficheiro:
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;
```

No final do corpo, abaixo system("pause"); e acima return 0; (onde você parou no Guia de main() início rápido anterior), insira o seguinte código:

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

No final de localizar o bloco de desligamento do aplicativo criado no primeiro início rápido e descomente a linha do main() manipulador:

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

Substitua os valores de espaço reservado no código-fonte da seguinte forma, usando constantes de cadeia de caracteres:

Marcador de Posição	Valor
<caminho do arquivo de entrada>	O caminho completo para um arquivo de entrada de teste, por exemplo: `"c:\\Test\\Test.docx"`.
<identificador de conteúdo>	Um identificador legível por humanos para o conteúdo. Por exemplo: Para um arquivo, considere caminho\nome do arquivo: `"c:\Test\Test.docx"` Para um e-mail, considere Assunto:Remetente : `"RE: Audit design:user1@contoso.com"`
<ID do rótulo>	Um ID de rótulo de sensibilidade, copiado da saída do console no Guia de início rápido anterior, por exemplo: `"f42a3342-8706-4288-bd31-ebb85995028z"`.
<caminho do arquivo de saída>	O caminho completo para o arquivo de saída, que será uma cópia rotulada do arquivo de entrada, por exemplo: `"c:\\Test\\Test_labeled.docx"`.

Crie e teste o aplicativo

Crie e teste seu aplicativo cliente.

Use F6 (Build Solution) para criar seu aplicativo cliente. Se você não tiver erros de compilação, use F5 (Iniciar depuração) para executar seu aplicativo.

Se o projeto for compilado e executado com êxito, o aplicativo solicitará um token de acesso, sempre que o SDK chamar seu AcquireOAuth2Token() método. Como fez anteriormente no Guia de início rápido "Listar rótulos de sensibilidade", execute o script do PowerShell para adquirir o token sempre, usando os valores fornecidos para $authority e $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 . . .

Você pode verificar a aplicação do rótulo, abrindo o arquivo de saída e inspecionando visualmente as configurações de proteção de informações do documento.

Nota

Se você estiver rotulando um documento do Office, mas não estiver conectado usando uma conta do locatário do Microsoft Entra onde o token de acesso foi obtido (e os rótulos de confidencialidade estiverem configurados), você poderá ser solicitado a entrar antes de abrir o documento rotulado.

Partilhar via

Guia de início rápido: definir e obter um rótulo de sensibilidade (C++)

Pré-requisitos

Implementar uma classe de observador para monitorar o objeto File handler

Adicionar lógica para definir e obter um rótulo de sensibilidade

Crie e teste o aplicativo

Comentários

Recursos adicionais