Kit de développement logiciel (SDK) de fichier - Traiter les fichiers de messagerie .msg (C++)

Le Kit de développement logiciel (SDK) file prend en charge les opérations d’étiquetage pour les fichiers .msg de la même manière que tout autre type de fichier, sauf que le KIT de développement logiciel (SDK) a besoin de l’application pour activer l’indicateur de fonctionnalité MSG. Ce guide de démarrage rapide montre comment définir cet indicateur.

Comme indiqué précédemment, l’instanciation mip::FileEngine nécessite l’objet mip::FileEngineSettings settings. L’application utilise FileEngineSettings pour passer des paramètres personnalisés pour une instance particulière. La propriété CustomSettings de mip::FileEngineSettings définit l’indicateur enable_msg_file_type afin de permettre le traitement des fichiers .msg.

Prérequis

Si ce n’est déjà fait, veillez à remplir les conditions préalables suivantes avant de continuer :

Démarrage rapide complet : Initialisation d’une application sdk de fichiers (C++), qui génère d’abord une solution de démarrage Visual Studio. Ce guide de démarrage rapide « Guide pratique pour traiter les fichiers de courrier électronique .msg (C++) » s’appuie sur le précédent.
Consulter le guide de démarrage rapide : Répertorier les étiquettes de confidentialité (C++).
Consultez le guide de démarrage rapide : Définir/obtenir des étiquettes de confidentialité (C++)
Passez en revue les concepts du Kit de développement logiciel (SDK) MIP des fichiers de messagerie .
Si vous le souhaitez, consultez les concepts relatifs aux moteurs de fichiers dans le SDK MIP.
Si vous le souhaitez , passez en revue les gestionnaires de fichiers dans les concepts du Kit de développement logiciel (SDK) MIP .

Étapes d’implémentation requises

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 guide de démarrage rapide : Répertorier les étiquettes de confidentialité (C++).
Implémentez une classe d’observateur pour surveiller mip::FileHandler, comme expliqué dans le guide de démarrage rapide : Définir/obtenir des étiquettes de confidentialité (C++) .

Définissez enable_msg_file_type et utilisez le Kit de développement logiciel (SDK) file pour étiqueter .msg fichier

Ajoutez le code de construction du moteur de fichiers suivant pour définir l’indicateur enable_msg_file_type et utiliser le moteur de fichiers pour étiqueter un fichier .msg.

Dans Explorateur de solutions, ouvrez le fichier .cpp dans votre projet qui contient l’implémentation de la main() méthode. Il a par défaut le même nom que le projet qui le contient, que vous avez spécifié lors de la création du projet.

Ajoutez les #include et les directives d’utilisation suivantes après les directives existantes correspondantes, en haut du fichier :

#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 main() corps, insérez le code suivant. Dans le bloc de code suivant, la création du moteur de fichiers définit l’indicateur enable_msg_file_type . mip::FileHandler les objets créés à l’aide du moteur de fichiers peuvent ensuite traiter un fichier .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>(appInfo,
				                                                                                       "mip_data",
                                                                                        			   mip::LogLevel::Trace,
                                                                                                       false,
                                                                                                       mip::CacheStorageType::OnDisk);

    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(mMipContext, mip::CacheStorageType::OnDisk,
        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)
                            authDelegateImpl,                       // Token acquisition implementation
                            "<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
    auto labels = engine->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);

    // Resolve the label ID to a mip::Label, then apply it.
    auto label = engine->GetLabelById(labelId);
    fileHandler->SetLabel(label, 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 = msgHandlerPromise->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->GetLabel()->GetLabel()->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;
    mMipContext->ShutDown();
    mMipContext = nullptr;

    return 0;
}

Pour plus d’informations sur les opérations de fichier, consultez les concepts du gestionnaire de fichiers.

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

Texte de remplacement	Value
<id d’application>	ID d’application inscrit auprès du locataire Microsoft Entra, par exemple : `00001111-aaaa-2222-bbbb-3333cccc4444`.
<engine-account>	Compte utilisé pour l’identité du moteur, par exemple : `user@tenant.onmicrosoft.com`.
<état du moteur>	État de l’application définie par l’utilisateur, par exemple : `My engine state`.
<chemin du fichier d'entrée>	Chemin complet d’un fichier de message d’entrée de test, par exemple : `c:\\Test\\message.msg`.
<output-file-path>	Chemin complet du fichier de sortie, qui est 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 (Build Solution) pour générer votre application cliente. Si vous n’avez pas d’erreurs de build, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-09-21