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

File SDK, .msg dosyaları için etiketleme işlemlerini diğer dosya türleriyle aynı şekilde destekler, ancak SDK'nın MSG özellik bayrağını etkinleştirmek için uygulamanın etkinleştirilmesine ihtiyacı vardır. Burada bu bayrağı nasıl ayarlayacağımızı göreceğiz.

Daha önce tartışıldığı gibi, mip::FileEngine örneklendirilmesi mip::FileEngineSettings adlı bir ayar nesnesi gerektirir. FileEngineSettings, bir uygulamanın belirli bir örnek için ayarlaması gereken özel ayarlar için parametrelerin geçirilmesinde kullanılabilir. CustomSettings özelliği, mip::FileEngineSettings için bayrak ayarlamak ve .msg dosyalarının işlenmesini etkinleştirmek için kullanılır.

Önkoşullar

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

Önkoşul uygulama adımları

  1. Önceki "Hızlı Başlangıç: İstemci uygulaması başlatma (C++)" makalesinde oluşturduğunuz Visual Studio çözümünü açın.

  2. 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.

  3. 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 amacıyla dosya motorunu ayarlamak ve kullanmak için aşağıdaki dosya motoru yapı kodunu ekleyin.

  1. Çözüm Gezgini'ni kullanarak, projenizde yönteminin uygulanmasını main() içeren .cpp dosyasını açın. Proje oluşturma sırasında belirlediğiniz isim, varsayılan olarak projeyle aynı olup onu içeren yapıdadır.

  2. 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;

  3. Önceki hızlı başlangıçtan main() işlevinin uygulanmasını kaldırın. main() gövdesine aşağıdaki kodu ekleyin. Aşağıdaki kod bloğunda enable_msg_file_type bayrağı, dosya motoru oluşturulurken ayarlanır; ardından, bir .msg dosyası dosya motoru kullanılarak oluşturulan mip::FileHandler nesneleriyle 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 ayrıntı için Dosya İşleyici kavramlarına bakın.

  1. 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ı> Motorun 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.
    <girdi dosya yolu> Bir test girdi mesaj dosyasının tam yolu, örneğin: c:\\Test\\message.msg.
    <çıkış dosyası yolu> Çıktı dosyasının tam yolu, giriş dosyasının etiketlenmiş bir kopyası olacak, örneğin: c:\\Test\\message_labeled.msg.
    <label-id> kullanılarak alınan labelId ListSensitivityLabels örneğin: 667466bf-a01b-4b0a-8bbf-a79a3d96f720.

Uygulamayı derleme ve test etme

F6'yı (Çözümü Derle) kullanarak istemci uygulamanızı derleyin. Derleme hatalarınız yoksa, uygulamanızı çalıştırmak için F5 (Hata ayıklamayı başlat) tuşuna basın.

  • Last updated on