SDK de archivo: procesamiento de archivos .msg de correo electrónico (C++)

El SDK de archivo admite operaciones de etiquetado para archivos .msg de manera idéntica a cualquier otro tipo de archivo, salvo que necesita la aplicación para habilitar la marca de característica MSG. Aquí se ve cómo establecer esta marca.

Como se ha explicado anteriormente, la creación de instancias de mip::FileEngine requiere un objeto de configuración, mip::FileEngineSettings. Se puede usar FileEngineSettings para pasar parámetros de configuración personalizada que la aplicación debe establecer para una instancia determinada. La propiedad CustomSettings de mip::FileEngineSettings se usa para establecer la marca de enable_msg_file_type a fin de habilitar el procesamiento de archivos .msg.

Requisitos previos

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

Pasos de implementación que son requisitos previos

  1. Abra la solución de Visual Studio que ha creado en el artículo anterior “Inicio rápido: inicialización de la aplicación cliente (C++)”.

  2. Cree un script de PowerShell para generar tokens de acceso, como se explica en la guía de inicio rápido "Mostrar etiquetas de confidencialidad ( C++ )".

  3. Implemente la clase Observer para supervisar mip::FileHandler como se explica en la guía de inicio rápido "mip::FileHandler".

Establecimiento de enable_msg_file_type y uso del SDK de archivo para etiquetar un archivo .msg

Agregue el código de construcción del motor de archivos siguiente para establecer enable_msg_file_type flag y use el motor de archivos para etiquetar un archivo .msg.

  1. Mediante el Explorador de soluciones, abra el archivo .cpp en el proyecto que contiene la implementación del método . El valor predeterminado es el mismo nombre que el proyecto que lo contiene, el cual ha especificado al crear el proyecto.

  2. Agregue las siguientes directivas #include y using debajo de las directivas existentes correspondientes, en la parte superior del archivo:

    #include "filehandler_observer.h" 
    #include "mip/file/file_handler.h" 
    #include <iostream>    
    using mip::FileHandler;   
    using std::endl;
    
  3. Quite la implementación de la función main() de la guía de inicio rápido anterior. Inserte el siguiente código dentro del cuerpo main(). Durante la creación del motor de archivos, debajo del siguiente bloque de código se establece la marca enable_msg_file_type y, luego, los objetos mip::FileHandler creados mediante el motor de archivos pueden procesar un archivo .msg.

int main()
{
    // Construct/initialize objects required by the application's profile object
    ApplicationInfo appInfo { "<application-id>",                    // ApplicationInfo object (App ID, name, version)
                              "<application-name>", 
                              "1.0" 
    };

    std::shared_ptr<mip::MipConfiguration> mipConfiguration = std::make_shared<mip::MipConfiguration>(mAppInfo,
				                                                                                       "mip_data",
                                                                                        			   mip::LogLevel::Trace,
                                                                                                       false);

    std::shared_ptr<mip::MipContext> mMipContext = mip::MipContext::Create(mipConfiguration);

    auto profileObserver = make_shared<ProfileObserver>();                      // Observer object
    auto authDelegateImpl = make_shared<AuthDelegateImpl>("<application-id>");  // Authentication delegate object (App ID)
    auto consentDelegateImpl = make_shared<ConsentDelegateImpl>();              // Consent delegate object

    // Construct/initialize profile object
    FileProfile::Settings profileSettings(mipContext,mip::CacheStorageType::OnDisk,authDelegateImpl,
        consentDelegateImpl,profileObserver);

    // Set up promise/future connection for async profile operations; load profile asynchronously
    auto profilePromise = make_shared<promise<shared_ptr<FileProfile>>>();
    auto profileFuture = profilePromise->get_future();
    try
    {
        mip::FileProfile::LoadAsync(profileSettings, profilePromise);
    }
    catch (const std::exception& e)
    {
        std::cout << "An exception occurred. Are the Settings and ApplicationInfo objects populated correctly?\n\n"<< e.what() << "'\n";
        system("pause");
        return 1;
    }

    auto profile = profileFuture.get();

    // Construct/initialize engine object
    FileEngine::Settings engineSettings(
                            mip::Identity("<engine-account>"),      // Engine identity (account used for authentication)
                            "<engine-state>",                       // User-defined engine state
                            "en-US");                               // Locale (default = en-US)

    //Set enable_msg_file_type flag as true
    std::vector<std::pair<string, string>> customSettings;
    customSettings.emplace_back(mip::GetCustomSettingEnableMsgFileType(), "true");
    engineSettings.SetCustomSettings(customSettings);

    // Set up promise/future connection for async engine operations; add engine to profile asynchronously
    auto enginePromise = make_shared<promise<shared_ptr<FileEngine>>>();
    auto engineFuture = enginePromise->get_future();
    profile->AddEngineAsync(engineSettings, enginePromise);
    std::shared_ptr<FileEngine> engine;

    try
    {
        engine = engineFuture.get();
    }
    catch (const std::exception& e)
    {
        cout << "An exception occurred... is the access token incorrect/expired?\n\n"<< e.what() << "'\n";
        system("pause");
        return 1;
    }

    //Set file paths
    string inputFilePath = "<input-file-path>"; //.msg file to be labeled
    string actualFilePath = inputFilePath;
    string outputFilePath = "<output-file-path>"; //labeled .msg file
    string actualOutputFilePath = outputFilePath;

    //Create a file handler for original file
    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);

    auto fileHandler = handlerFuture.get();

    //List labels available to the user    

    // Use mip::FileEngine to list all labels
    labels = mEngine->ListSensitivityLabels();

    // Iterate through each label, first listing details
    for (const auto& label : labels) {
        cout << label->GetName() << " : " << label->GetId() << endl;

        // get all children for mip::Label and list details
        for (const auto& child : label->GetChildren()) {
            cout << "->  " << child->GetName() << " : " << child->GetId() << endl;
        }
    }

    string labelId = "<labelId-id>"; //set a label ID to use

    // Labeling requires a mip::LabelingOptions object. 
    // Review API ref for more details. The sample implies that the file was labeled manually by a user.
    mip::LabelingOptions labelingOptions(mip::AssignmentMethod::PRIVILEGED);

    fileHandler->SetLabel(labelId, labelingOptions, mip::ProtectionSettings());

    // Commit changes, save as outputFilePath
    auto commitPromise = std::make_shared<std::promise<bool>>();
    auto commitFuture = commitPromise->get_future();

    if(fileHandler->IsModified())
    {
        fileHandler->CommitAsync(outputFilePath, commitPromise);
    }
    
    if (commitFuture.get()) {
        cout << "\n Label applied to file: " << outputFilePath << endl;
    }
    else {
        cout << "Failed to label: " + outputFilePath << endl;
        return 1;
    }

    // Create a new handler to read the label
    auto msgHandlerPromise = std::make_shared<std::promise<std::shared_ptr<FileHandler>>>();
    auto msgHandlerFuture = handlerPromise->get_future();

    engine->CreateFileHandlerAsync(inputFilePath,
                                    actualFilePath,
                                    true,
                                    std::make_shared<FileHandlerObserver>(),
                                    msgHandlerPromise);

    auto msgFileHandler = msgHandlerFuture.get();

    cout << "Original file: " << inputFilePath << endl;
    cout << "Labeled file: " << outputFilePath << endl;
    cout << "Label applied to file : " 
            << msgFileHandler->GetName() 
            << endl;
    
    // Application shutdown. Null out profile, engine, handler.
    // Application may crash at shutdown if resources aren't properly released.
    msgFileHandler = nullptr;
    fileHandler = nullptr;
    engine = nullptr;
    profile = nullptr;
    mipContext = nullptr;

    return 0;
}

Para obtener más información sobre las operaciones de archivo, vea Conceptos del controlador de archivo.

  1. Reemplace los valores de marcador de posición en el código fuente por los valores siguientes:

    Marcador Valor
    <application-id> El identificador de la aplicación tal como aparece registrado en el inquilino de Azure AD, por ejemplo: 0edbblll-8773-44de-b87c-b8c6276d41eb.
    <engine-account> La cuenta usada para la identidad del motor, por ejemplo: user@tenant.onmicrosoft.com.
    <engine-state> El estado de la aplicación definido por el usuario, por ejemplo: My engine state.
    <input-file-path> La ruta de acceso completa a un archivo de mensaje de entrada de prueba, por ejemplo: c:\\Test\\message.msg.
    <output-file-path> La ruta de acceso completa al archivo de salida, que será una copia con la etiqueta del archivo de entrada, por ejemplo: c:\\Test\\message_labeled.msg.
    <label-id> El elemento labelId recuperado mediante ListSensitivityLabels, por ejemplo: 667466bf-a01b-4b0a-8bbf-a79a3d96f720.

Compilar y probar la aplicación

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