Fichier SDK - Traiter les fichiers .msg par e-mail (C++)

Article
01/30/2024

Le fichier SDK prend en charge les opérations d’étiquetage des fichiers .msg d’une manière identique à tout autre type de fichier, sauf que le SDK a besoin de l’application pour activer l’indicateur de fonctionnalité MSG. Ici, nous allons voir comment définir cet indicateur.

Comme mentionné précédemment, l’instanciation de mip::FileEngine nécessite un objet de paramètre, mip::FileEngineSettings. FileEngineSettings peut être utilisé pour transmettre des paramètres pour des paramètres personnalisés que l’application doit définir pour une instance particulière. La propriété CustomSettings de mip::FileEngineSettings est utilisée pour définir l’indicateur de enable_msg_file_type pour permettre le traitement des fichiers .msg.

Prérequis

Si ce n’est déjà fait, veillez à satisfaire les prérequis suivants avant de poursuivre :

Suivez d’abord Démarrage rapide : Initialisation de l’application du SDK File (C++), pour créer une solution Visual Studio de démarrage. Ce démarrage rapide « Guide pratique : Traiter les fichiers .msg d’e-mails (C++) » s’appuie sur le précédent.
Passez en revue Démarrage rapide : Lister les étiquettes de confidentialité (C++).
Passez en revue Démarrage rapide : Définir/obtenir des étiquettes de confidentialité (C++).
Examinez les concepts Envoi de fichiers SDK MIP par e-mail.
Facultatif : passez en revue les Moteurs de fichiers dans les concepts du SDK MIP.
Facultatif : passez en revue les Gestionnaires de fichiers dans les concepts du SDK MIP.

Étapes d’implémentation préalables

Ouvrez la solution Visual Studio que vous avez créée dans l’article précédent, « Démarrage rapide : Initialisation de l’application cliente (C++) ».
Créez un script PowerShell pour générer des jetons d’accès, comme expliqué dans le démarrage rapide « Lister les étiquettes de confidentialité(C++) ».
Implémentez la classe de l’observateur pour surveiller mip::FileHandler comme expliqué dans le démarrage rapide « Définir/obtenir des étiquettes de confidentialité (C++) ».

Définir enable_msg_file_type et utiliser le SDK File pour étiqueter le fichier .msg

Ajoutez le code de construction du moteur File ci-dessous pour définir enable_msg_file_type flag et utiliser le moteur File pour étiqueter un fichier .msg.

À l’aide de l’Explorateur de solutions, ouvrez le fichier .cpp dans votre projet qui contient l’implémentation de la méthode main(). Par défaut, il a le même nom que le projet qui le contient et que vous avez spécifié lors de la création du projet.
Ajoutez les instructions #include et, à l’aide des directives ci-dessous, en haut du fichier, sous les directives existantes correspondantes :
```
#include "filehandler_observer.h" 
#include "mip/file/file_handler.h" 
#include <iostream>    
using mip::FileHandler;   
using std::endl;
```
Supprimez l’implémentation de la fonction main() à partir du démarrage rapide précédent. Dans le corps main(), insérez le code suivant. Dans le bloc de code ci-dessous, l’indicateur enable_msg_file_type est défini lors de la création du moteur File, un fichier .msg peut ensuite être traitée par des objets mip::FileHandler créés à l’aide du moteur 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;
}

Pour plus d’informations sur les opérations sur les fichiers, consultes les Concepts de gestionnaires de fichiers.

Remplacez les valeurs d’espace réservé dans le code source par les valeurs suivantes :

Paramètre substituable	Valeur
<application-id>	ID d’application enregistré auprès du locataire Microsoft Entra, par exemple : `0edbblll-8773-44de-b87c-b8c6276d41eb`.
<engine-account>	Compte utilisé pour l’identité du moteur, par exemple : `user@tenant.onmicrosoft.com`.
<engine-state>	État de l’application défini par l’utilisateur, par exemple : `My engine state`.
<input-file-path>	Chemin complet d’un fichier message d’entrée de test, par exemple : `c:\\Test\\message.msg`.
<output-file-path>	Chemin complet du fichier de sortie, qui sera une copie étiquetée du fichier d’entrée, par exemple : `c:\\Test\\message_labeled.msg`.
<label-id>	L’ID d’étiquette récupéré à l’aide de `ListSensitivityLabels`, par exemple : `667466bf-a01b-4b0a-8bbf-a79a3d96f720`.

Concevoir et tester l’application

Utilisez F6 (Créer une solution) pour créer votre application cliente. Si vous n’avez aucune erreur de build, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

Partager via

Fichier SDK - Traiter les fichiers .msg par e-mail (C++)

Prérequis

Étapes d’implémentation préalables

Définir enable_msg_file_type et utiliser le SDK File pour étiqueter le fichier .msg

Concevoir et tester l’application

Commentaires

Ressources supplémentaires