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

Le Kit de développement logiciel (SDK) de fichier prend en charge les opérations d’étiquetage pour les fichiers .msg de 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 indiqué précédemment, l’instanciation de mip::FileEngine nécessite un objet de configuration, mip::FileEngineSettings. FileEngineSettings peut être utilisé pour transmettre des paramètres pour les paramètres personnalisés que l’application doit définir pour une instance particulière. La propriété de mip::FileEngineSettingsCustomSettings est utilisée pour définir l’indicateur de 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 la 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 ci-dessous pour définir enable_msg_file_type flag et utiliser le moteur de fichiers 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 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 directives d’utilisation suivantes, sous 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 ci-dessous, l’indicateur enable_msg_file_type est défini lors de la création du moteur de fichiers ; un fichier .msg peut ensuite être traité par des objets mip::FileHandler créés à l’aide du moteur de fichiers.

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 de fichier, reportez-vous aux concepts du gestionnaire de fichiers.

Remplacez les valeurs de remplacement dans le code source en utilisant les valeurs suivantes :

Texte de remplacement	Value
<id d’application>	L’ID d’application enregistré 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 sera une copie étiquetée du fichier d’entrée, par exemple : `c:\\Test\\message_labeled.msg`.
<label-id>	LabelId récupéré à l’aide `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 aucune erreur de build, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

Commentaires

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

Last updated on 2026-08-26