Sada File SDK – Zpracování e-mailových .msg souborů (C++)

Sada File SDK podporuje operace popisování pro .msg soubory stejným způsobem jako jakýkoli jiný typ souboru, s tím rozdílem, že sada SDK potřebuje aplikaci k povolení příznaku funkce MSG. Tento stručný úvod ukazuje, jak tento příznak nastavit.

Jak je popsáno dříve, vytvoření instance mip::FileEngine vyžaduje mip::FileEngineSettings objekt nastavení. Aplikace používá FileEngineSettings k předání vlastních nastavení pro určitou instanci. Vlastnost CustomSettings objektu mip::FileEngineSettings nastaví příznak enable_msg_file_type tak, aby povolila zpracování souborů .msg.

Požadavky

Pokud jste to ještě neudělali, nezapomeňte před pokračováním dokončit následující požadavky:

Dokončení rychlého startu: Nejprve inicializace aplikace sady File SDK (C++), která vytvoří úvodní řešení sady Visual Studio. Tento rychlý start "How to - process email message .msg files (C++)" (Postupy – zpracování e-mailových zpráv .msg soubory (C++) vychází z předchozího.
Přezkoumejte Rychlý start: Seznam citlivostních štítků (C++)
Prohlédněte si rychlý start: Nastavení nebo získání štítků citlivosti (C++)
Projděte si koncepty e-mailových souborů MIP SDK.
Volitelně: Projděte si moduly souborů v konceptech sady MIP SDK .
Volitelně: Zkontrolujte obslužné rutiny souborů v konceptech sady MIP SDK .

Kroky implementace požadavků

Otevřete řešení sady Visual Studio, které jste vytvořili v předchozím článku Rychlý start: Inicializace klientské aplikace (C++).
Vytvořte skript PowerShellu pro generování přístupových tokenů, jak je vysvětleno v rychlém startu: Výpis popisků citlivosti (C++).
Implementujte třídu pozorovatele pro monitorovánímip::FileHandler, jak je vysvětleno v rychlém startu: Nastavení/získání popisků citlivosti (C++)

Nastavení enable_msg_file_type a použití sady File SDK k označení souboru .msg

Přidejte následující kód pro vytvoření souborového modulu, který nastaví příznak enable_msg_file_type a použije souborový modul k označení souboru .msg štítkem.

V Průzkumník řešení otevřete soubor .cpp v projektu, který obsahuje implementaci main() metody. Ve výchozím nastavení se použije stejný název jako projekt, který ho obsahuje a který jste zadali při vytváření projektu.

Do horní části souboru za odpovídající existující direktivy přidejte následující direktivy #include a `using`:

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

Odeberte implementaci funkce main() z předchozího rychlého průvodce. Vložte do main() těla následující kód. V následujícím bloku kódu je při vytváření souborového enginu nastaven příznak enable_msg_file_type. mip::FileHandler objekty vytvořené pomocí souborového stroje pak mohou zpracovat .msg soubor.

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

Další informace o operacích se soubory naleznete v části Koncepty obsluhy souborů.

Zástupné hodnoty ve zdrojovém kódu nahraďte následujícími hodnotami:

Zástupný text	Hodnota
<ID aplikace>	ID aplikace zaregistrované v tenantovi Microsoft Entra, například: `00001111-aaaa-2222-bbbb-3333cccc4444`.
<účet pro engine>	Účet použitý pro identitu modulu, například: `user@tenant.onmicrosoft.com`.
<stav motoru>	Stav uživatelem definované aplikace, například: `My engine state`.
<cesta k vstupnímu souboru>	Úplná cesta k souboru s testovací zprávou, například: `c:\\Test\\message.msg`.
<cesta k výstupnímu souboru>	Úplná cesta k výstupnímu souboru, což je označená kopie vstupního souboru, například: `c:\\Test\\message_labeled.msg`.
<identifikátor štítku>	ID štítku získané pomocí `ListSensitivityLabels`, například: `667466bf-a01b-4b0a-8bbf-a79a3d96f720`.

Sestavení a otestování aplikace

K sestavení klientské aplikace použijte klávesu F6 (Build Solution). Pokud nemáte chyby sestavení, spusťte aplikaci pomocí klávesy F5 (Spustit ladění).

Váš názor

Byla tato stránka užitečná?

Poslední aktualizace v 2026-09-21