Dosya SDK'sı - E-posta .msg dosyalarını işleme (C++)

Makale
01/30/2024

Dosya SDK'sı, .msg dosyaları için etiketleme işlemlerini, SDK'nın MSG özellik bayrağını etkinleştirmek için uygulamaya ihtiyacı olması dışında, başka herhangi bir dosya türüyle aynı şekilde destekler. Burada bu bayrağın nasıl ayarlandığını göreceğiz.

Daha önce açıklandığı gibi örneği mip::FileEngine için bir ayar nesnesi mip::FileEngineSettingsgerekir: . FileEngine Ayarlar, uygulamanın belirli bir örnek için ayarlaması gereken özel ayarlara yönelik parametreleri geçirmek için kullanılabilir. CustomSettingsmip::FileEngineSettings özelliği , .msg dosyalarının işlenmesini etkinleştirmek için bayrağını ayarlamak için enable_msg_file_type kullanılır.

Ön koşullar

Henüz yapmadıysanız devam etmeden önce aşağıdaki önkoşulları tamamladığınızdan emin olun:

Tam Hızlı Başlangıç: İlk olarak başlangıç Visual Studio çözümü oluşturan Dosya SDK'sı uygulaması başlatma (C++). Bu "Nasıl yapılır - e-posta iletisi .msg dosyalarını işleme (C++)" hızlı başlangıcı öncekini temel alır.
Hızlı Başlangıç: Duyarlılık etiketlerini listeleme (C++) gözden geçirin.
Hızlı Başlangıç: Duyarlılık etiketlerini ayarlama/alma (C++) adımlarını gözden geçirin.
E-posta dosyaları MIP SDK'sı kavramlarını gözden geçirin.
İsteğe bağlı olarak: MIP SDK kavramlarındaki Dosya altyapılarını gözden geçirin.
İsteğe bağlı olarak: MIP SDK kavramlarındaki Dosya işleyicilerini gözden geçirin.

Önkoşul uygulama adımları

Önceki "Hızlı Başlangıç: İstemci uygulaması başlatma (C++)" makalesinde oluşturduğunuz Visual Studio çözümünü açın.
Hızlı Başlangıç "Duyarlılık etiketlerini listeleme (C++)" bölümünde açıklandığı gibi erişim belirteçleri oluşturmak için bir PowerShell betiği oluşturun.
Hızlı Başlangıç "Duyarlılık etiketlerini ayarlama/alma (C++)" bölümünde açıklandığı gibi izlemek mip::FileHandler için gözlemci sınıfını uygulayın.

.msg dosyasını etiketlemek için enable_msg_file_type ayarlayın ve Dosya SDK'sını kullanın

Bir .msg dosyasını etiketlemek için dosya altyapısını ayarlamak enable_msg_file_type flag ve kullanmak için aşağıdaki dosya altyapısı yapı kodunu ekleyin.

Çözüm Gezgini kullanarak, yönteminin uygulanmasını main() içeren projenizde .cpp dosyasını açın. Varsayılan olarak, proje oluşturma sırasında belirttiğiniz, onu içeren projeyle aynı ada sahiptir.

Aşağıdaki #include ve kullanma yönergelerini dosyanın en üstüne ilgili mevcut yönergelerin altına ekleyin:

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

önceki hızlı başlangıçtan main() işlev uygulamasını kaldırın. Gövdenin main() içine aşağıdaki kodu ekleyin. Aşağıdaki kod bloğu enable_msg_file_type bayrağı, dosya altyapısı oluşturma sırasında ayarlanır; daha sonra bir .msg dosyası, dosya altyapısı kullanılarak oluşturulan nesneler tarafından mip::FileHandler işlenebilir.

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

Dosya işlemleri hakkında daha fazla bilgi için Dosya İşleyicisi kavramlarına bakın.

Aşağıdaki değerleri kullanarak kaynak koddaki yer tutucu değerlerini değiştirin:

Yer tutucu	Değer
<uygulama kimliği>	Microsoft Entra kiracısıyla kaydedilen uygulama kimliği, örneğin: `0edbblll-8773-44de-b87c-b8c6276d41eb`.
<altyapı hesabı>	Altyapı kimliği için kullanılan hesap, örneğin: `user@tenant.onmicrosoft.com`.
<altyapı durumu>	Kullanıcı tanımlı uygulama durumu, örneğin: `My engine state`.
<input-file-path>	Bir test giriş iletisi dosyasının tam yolu, örneğin: `c:\\Test\\message.msg`.
<output-file-path>	Çıkış dosyasının tam yolu; giriş dosyasının etiketli bir kopyası olacaktır, örneğin: `c:\\Test\\message_labeled.msg`.
<label-id>	kullanılarak alınan `ListSensitivityLabels`labelId örneğin: `667466bf-a01b-4b0a-8bbf-a79a3d96f720`.

Uygulamayı derleme ve test etme

İstemci uygulamanızı derlemek için F6 (Derleme Çözümü) kullanın. Derleme hatanız yoksa, uygulamanızı çalıştırmak için F5 (Hata ayıklamayı başlat) kullanın.