Inicio rápido: Establecimiento y obtención de una etiqueta de confidencialidad (C++)

Esta guía de inicio rápido te muestra cómo usar más SDK de archivos de MIP. Al usar una de las etiquetas de confidencialidad que enumeraste en la guía de inicio rápido anterior, usas un controlador de archivos para establecer y recuperar la etiqueta de un archivo. La clase de controlador de archivos expone varias operaciones para establecer y obtener etiquetas, o protección, para los tipos de archivo admitidos.

Prerrequisitos

Si aún no lo ha hecho, asegúrese de completar los siguientes requisitos previos antes de continuar:

  • Inicio rápido: Listar etiquetas de confidencialidad (C++). Complete primero esta guía de inicio rápido. Crea una solución básica de Visual Studio que enumera las etiquetas de confidencialidad de una organización. Esta guía de inicio rápido "Establecer y obtener una etiqueta de confidencialidad" se basa en la anterior.
  • Opcional: Revisar los conceptos de los controladores de archivos en el SDK de MIP.

Implementación de una clase de observador para supervisar el objeto de controlador de archivos

Al igual que con el observador que implementaste para el perfil del archivo y el motor en la guía de inicio rápido de inicialización de la aplicación, ahora implementas una clase de observador para un objeto manejador de archivos.

Cree una implementación básica para un observador del controlador de archivos mediante la extensión de la clase del mip::FileHandler::Observer SDK. La aplicación crea una instancia del observador y la usa más adelante para supervisar las operaciones del controlador de archivos.

  1. Abra la solución de Visual Studio en la que ha trabajado en el artículo anterior "Inicio rápido: Enumerar etiquetas de confidencialidad (C++)".

  2. Agregue una nueva clase al proyecto. Visual Studio genera los archivos header/.h e implementation/.cpp automáticamente:

    • En el Explorador de soluciones, haga clic con el botón derecho en el nodo del proyecto de nuevo, seleccione Agregar y, a continuación, seleccione Clase.
    • En el cuadro de diálogo Agregar clase:
      • En el campo Nombre de clase, escriba "filehandler_observer". Tenga en cuenta que tanto el archivo .h como los campos de archivo .cpp se rellenan automáticamente, en función del nombre que escriba.
      • Cuando haya terminado, seleccione Aceptar.

  3. Después de Visual Studio genera los archivos .h y .cpp para la clase , ambos archivos se abren en las pestañas del editor. Actualice cada archivo para implementar la nueva clase de observador:

    • Actualice "filehandler_observer.h", seleccionando o eliminando la clase generada filehandler_observer . No quite las directivas de preprocesador generadas por el paso anterior (#pragma, #include). Después, copie y pegue el siguiente código en el archivo, después de las directivas de preprocesador 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;		
};

    • Actualice "filehandler_observer.cpp", seleccionando o eliminando la implementación de clase generada filehandler_observer . No quite las directivas de preprocesador generadas por el paso anterior (#pragma, #include). Después, copie y pegue el siguiente código en el archivo, después de las directivas de preprocesador 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 F6 (Compilar solución) para ejecutar un vínculo o compilación de prueba de la solución y confirme que se compila correctamente antes de continuar.

Adición de lógica para establecer y obtener una etiqueta de confidencialidad

Utilice el objeto del motor de archivos para agregar lógica que establezca y obtenga una etiqueta de confidencialidad en un archivo.

  1. En Explorador de soluciones, abra el archivo .cpp en el proyecto que contiene la implementación del main() método . El valor predeterminado es el mismo nombre que el proyecto que lo contiene, que especificó durante la creación del proyecto.

  2. Agregue las siguientes directivas #include y using después de las directivas correspondientes ya existentes en la parte superior del archivo:

    #include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 

using mip::FileHandler;

  3. Hacia el final del cuerpo main(), después de system("pause"); y antes de return 0;, donde lo dejó en la guía de inicio rápido anterior, inserte el siguiente 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. Hacia el final de main(), busque el bloque de cierre de la aplicación creado en la primera guía de inicio rápido y descomente la línea del controlador:

    // 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. Reemplace los valores de marcador de posición en el código fuente de la siguiente manera, mediante constantes de cadena:

    Marcador de posición Valor
    <ruta-del-archivo-de-entrada> Ruta de acceso completa a un archivo de entrada de prueba, por ejemplo: "c:\\Test\\Test.docx".
    <identificador de contenido> Identificador legible por humanos para el contenido. Por ejemplo:
    • Para un archivo, utilice path\filename: "c:\Test\Test.docx"
    • Para un correo electrónico, use subject:sender: "RE: Audit design:user1@contoso.com"
    <etiqueta-id> Identificador de etiqueta de confidencialidad, copiado de la salida de la consola en el inicio rápido anterior, por ejemplo: "f42a3342-8706-4288-bd31-ebb85995028z".
    <ruta del archivo de salida> Ruta de acceso completa al archivo de salida, que es una copia etiquetada del archivo de entrada, por ejemplo: "c:\\Test\\Test_labeled.docx".

Crear y probar la aplicación

Compile y pruebe la aplicación cliente.

  1. Use F6 (Compilar solución) para compilar la aplicación cliente. Si la compilación no tiene errores, use F5 (Iniciar depuración) para ejecutar la aplicación.

  2. Si el proyecto se compila y se ejecuta correctamente, la aplicación solicita un token de acceso cada vez que el SDK llama al AcquireOAuth2Token() método . Tal como hizo antes en la guía de inicio rápido "Enumerar etiquetas de confidencialidad", ejecute el script de PowerShell para obtener el token cada vez con los valores proporcionados para $authority y $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 . . .

Para comprobar la aplicación de etiqueta, abra el archivo de salida e inspeccione visualmente la configuración de protección de la información del documento.

Nota:

Si va a etiquetar un documento de Office pero no ha iniciado sesión con una cuenta del inquilino de Microsoft Entra que emitió el token de acceso (y se configuran las etiquetas de confidencialidad), es posible que se le pida que inicie sesión antes de que pueda abrir el documento etiquetado.

Pasos siguientes

  • Last updated on