File SDK - Elaborare file con estensione msg di posta elettronica (C++)

Articolo
01/30/2024

File SDK supporta le operazioni di etichettatura per i file con estensione msg in modo identico a qualsiasi altro tipo di file, ad eccezione del fatto che l'SDK necessita dell'applicazione per abilitare il flag di funzionalità MSG. In questa sezione verrà illustrato come impostare questo flag.

Come illustrato in precedenza, la creazione di istanze di mip::FileEngine richiede un oggetto impostazione, mip::FileEngineSettings. FileEngine Impostazioni può essere usato per passare i parametri per le impostazioni personalizzate che l'applicazione deve impostare per una determinata istanza. CustomSettings la proprietà di mip::FileEngineSettings viene utilizzata per impostare il flag per enable_msg_file_type per abilitare l'elaborazione dei file con estensione msg.

Prerequisiti

Se non è già stato fatto, assicurarsi di completare i prerequisiti seguenti prima di continuare:

Completare la guida introduttiva: Inizializzazione dell'applicazione File SDK (C++), che crea prima una soluzione visual Studio iniziale. Questa guida introduttiva "How to - process email message .msg files (C++)" si basa su quella precedente.
Vedere Avvio rapido: Elencare le etichette di riservatezza (C++).
Vedere Avvio rapido: Impostare/ottenere etichette di riservatezza (C++).
Esaminare i concetti relativi a MIP SDK per i file di posta elettronica.
Facoltativamente: esaminare i motori di file nei concetti di MIP SDK .
Facoltativamente: esaminare i gestori di file nei concetti di MIP SDK .

Passaggi di implementazione dei prerequisiti

Aprire la soluzione di Visual Studio creata nell'articolo precedente "Avvio rapido: Inizializzazione dell'applicazione client (C++)".
Creare uno script di PowerShell per generare token di accesso come illustrato in Avvio rapido "Elencare le etichette di riservatezza (C++)".
Implementare la classe observer per il monitoraggio mip::FileHandler come illustrato in Avvio rapido "Impostare/ottenere etichette di riservatezza (C++)".

Impostare enable_msg_file_type e usare File SDK per etichettare il file con estensione msg

Aggiungere il codice di costruzione del motore di file seguente per impostare enable_msg_file_type flag e usare il motore di file per etichettare un file con estensione msg.

Usando Esplora soluzioni, aprire il file con estensione cpp nel progetto che contiene l'implementazione del main() metodo . Per impostazione predefinita, il nome del progetto che lo contiene è stato specificato durante la creazione del progetto.

Aggiungere i #include e le direttive using seguenti, sotto le direttive esistenti corrispondenti, all'inizio del file:

#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 
#include <iostream>    
using mip::FileHandler;   
using std::endl;

Rimuovere l'implementazione della main() funzione dalla guida introduttiva precedente. All'interno del main() corpo inserire il codice seguente. Nel flag di blocco enable_msg_file_type di codice seguente viene impostato durante la creazione del motore di file, un file con estensione msg può quindi essere elaborato da mip::FileHandler oggetti creati usando il motore di file.

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

Per altri dettagli sulle operazioni sui file, vedere i concetti relativi al gestore file.

Sostituire i valori segnaposto nel codice sorgente usando i valori seguenti:

Segnaposto	Valore
<application-id>	ID applicazione registrato con il tenant di Microsoft Entra, ad esempio: `0edbblll-8773-44de-b87c-b8c6276d41eb`.
<engine-account>	L'account usato per l'identità del motore, ad esempio : `user@tenant.onmicrosoft.com`.
<stato del motore>	Stato dell'applicazione definito dall'utente, ad esempio: `My engine state`.
<input-file-path>	Percorso completo di un file di messaggio di input di test, ad esempio: `c:\\Test\\message.msg`.
<output-file-path>	Percorso completo del file di output, che sarà una copia etichettata del file di input, ad esempio : `c:\\Test\\message_labeled.msg`.
<label-id>	LabelId recuperato tramite `ListSensitivityLabels`, ad esempio : `667466bf-a01b-4b0a-8bbf-a79a3d96f720`.

Compilare e testare l'applicazione

Usare F6 (Compila soluzione) per compilare l'applicazione client. Se non sono presenti errori di compilazione, usare F5 (Avvia debug) per eseguire l'applicazione.