Início Rápido: Definir e obter um rótulo de sensibilidade (C++)

Este guia de início rápido mostra como utilizar mais funcionalidades dos SDKs de Ficheiros MIP. Ao usar uma das etiquetas de sensibilidade que mencionaste no quickstart anterior, utilizas um gestor de ficheiros para definir e colocar a etiqueta num ficheiro. A classe gestor de ficheiros expõe várias operações para definir e obter etiquetas, ou proteção, para tipos de ficheiros suportados.

Pré-requisitos

Se ainda não o fizeste, certifica-te de cumprir os seguintes pré-requisitos antes de continuar:

• Início rápido: Liste etiquetas de sensibilidade (C++). Conclua este guia de início rápido primeiro. Constrói uma solução inicial no Visual Studio que lista os rótulos de sensibilidade da organização. Este início rápido "Definir e obter uma etiqueta de sensibilidade" baseia-se no anterior.
• Opcionalmente: Reveja os conceitos de gestores de ficheiros no MIP SDK.

Implementar uma classe observador para monitorizar o objeto gestor de ficheiros

Tal como no observador que implementaste para o perfil de ficheiro e motor no quickstart de inicialização da aplicação, agora implementas uma classe observador para um objeto handler de ficheiros.

Crie uma implementação básica para um observador handler de ficheiros estendendo a classe do mip::FileHandler::Observer SDK. A aplicação instancia o observador e usa-o posteriormente para monitorizar as operações do gestor de ficheiros.

1. Abra a solução Visual Studio em que trabalhou no artigo anterior "Quickstart: Listar etiquetas de sensibilidade (C++)".

2. Adiciona uma nova turma ao teu projeto. Visual Studio gera tanto o cabeçalho/.h como os ficheiros de implementação/.cpp para si:

   • 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.
   • No diálogo Adicionar Classe :
     • No campo Nome da Turma , introduza "filehandler_observer". Observe que os campos de arquivo .h e arquivo .cpp são preenchidos automaticamente, com base no nome inserido.
     • Quando terminar, seleccione OK.

3. Depois de o Visual Studio gerar os ficheiros .h e .cpp para a classe, ambos os ficheiros são abertos em separadores do editor. Atualize cada ficheiro para implementar a sua nova classe observador:

   • Atualize "filehandler_observer.h", selecionando/eliminando 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/eliminando 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);
     }
     

4. Opcionalmente, use o F6 (Build Solution) para executar uma compilação de teste/link da sua solução e confirme que ela compila com sucesso antes de continuar.

Adicionar lógica para definir e obter uma etiqueta de sensibilidade

Use o objeto do motor de ficheiros para adicionar lógica que define e recebe uma etiqueta de sensibilidade num ficheiro.

1. No Explorador de Soluções, abra o ficheiro .cpp no seu projeto que contém a implementação do main() método. Por padrão, tem o mesmo nome do projeto que o contém, que especificou durante a criação do projeto.

2. Adicione as seguintes #include e using diretivas após as diretivas existentes correspondentes no topo do ficheiro:

   #include "filehandler_observer.h" 
   #include "mip/file/file_handler.h" 
   
   using mip::FileHandler;
   

3. No final do main() corpo, depois system("pause"); e antes return 0; de onde parou no quickstart 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 " << inputFilePath << endl;
        mip::LabelingOptions labelingOptions(mip::AssignmentMethod::PRIVILEGED);
        handler->SetLabel(engine->GetLabelById(labelId), labelingOptions, mip::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");
   

4. Perto do final de main(), encontre o bloco de encerramento da aplicação criado no primeiro quickstart e descomente a linha do handler:

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

5. Substitua os valores provisórios no código-fonte da seguinte forma, usando constantes de cadeia:

   Marcador de Posição	Valor
   <caminho de ficheiro de entrada>	O caminho completo para um ficheiro 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 ficheiro, use caminho\nome do ficheiro: "c:\Test\Test.docx" Para um email, use assunto:remetente: "RE: Audit design:user1@contoso.com"
   <ID de etiqueta>	Um ID de etiqueta de sensibilidade, copiado da saída da consola no Quickstart anterior, por exemplo: "f42a3342-8706-4288-bd31-ebb85995028z".
   <caminho do ficheiro de saída>	O caminho completo para o ficheiro de saída, que é uma cópia rotulada do ficheiro de entrada, por exemplo: "c:\\Test\\Test_labeled.docx".

Construir e testar a aplicação

Constrói e testa a tua aplicação cliente.

1. Usa o F6 (Build Solution) para construir a tua aplicação cliente. Se a compilação não tiver erros, use F5 (Iniciar depuração) para executar a sua aplicação.

2. Se o seu projeto for construído e executado com sucesso, a aplicação solicita um token de acesso sempre que o SDK chama o seu AcquireOAuth2Token() método. Como fez anteriormente no quickstart "Listar etiquetas de sensibilidade", execute o seu script PowerShell para adquirir o token cada vez com 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 . . .
   

Verifique a aplicação do rótulo abrindo o ficheiro de saída e inspecionando visualmente as definições de proteção de informação do documento.

Passos seguintes

• Exemplo de SDK de ficheiro MIP em C++