SDK de archivo: Procesar archivos .msg de correo electrónico (C++)
El SDK de archivo admite las operaciones de etiquetado de los archivos .msg de una manera idéntica a cualquier otro tipo de archivo, excepto que el SDK necesita la aplicación para habilitar la marca de características MSG. Aquí, veremos cómo establecer esta marca.
Como se ha comentado anteriormente, la creación de instancias de mip::FileEngine
requiere un objeto de configuración, mip::FileEngineSettings
. FileEngineSettings se puede usar para pasar parámetros para la configuración personalizada que la aplicación debe establecer para una instancia determinada. La propiedad CustomSettings
de mip::FileEngineSettings
se usa para establecer la marca de enable_msg_file_type
para habilitar el procesamiento de archivos .msg.
Requisitos previos
Si todavía no lo ha hecho, complete los siguientes requisitos previos antes de continuar:
- Complete primero Inicio rápido: Inicialización de aplicaciones cliente del SDK de archivo (C++), que compila una solución de inicio de Visual Studio. Este inicio rápido "Procesamiento de archivos .msg de mensajes de correo electrónico" se basa en el anterior.
- Revise Inicio rápido: Enumerar etiquetas de confidencialidad (C++).
- Revise Inicio rápido: Establecimiento/obtención de las etiquetas de confidencialidad (C++).
- Revise los conceptos del SDK de MIP de archivos de correo electrónico.
- Opcional: Revise los conceptos sobre motores de archivo en el SDK de MIP.
- Opcionalmente: Revise los conceptos sobre controladores de archivos en el SDK de MIP.
Pasos de implementación de requisitos previos
Abra la solución de Visual Studio que creó en el artículo anterior "Inicio rápido:Iinicialización de la aplicación cliente (C++)".
Cree un script de PowerShell para generar tokens de acceso como se explica en Inicio rápido "Enumerar etiquetas de confidencialidad (C++)".
Implemente la clase de observador para supervisar
mip::FileHandler
como se explica en Inicio rápido "Establecimiento/obtención de las etiquetas de confidencialidad (C++)".
Establecimiento de enable_msg_file_type y uso del SDK de archivo para etiquetar el archivo .msg
Agregue el código de construcción del motor de archivos a continuación para establecer enable_msg_file_type flag
y usar el motor de archivo para etiquetar un archivo .msg.
Con el Explorador de soluciones, abra el archivo .cpp del proyecto que contiene la implementación del método
main()
. De manera predeterminada, tiene el mismo nombre que el proyecto que lo contiene, que especificó al crear el proyecto.Agregue las siguientes directivas #include y using, debajo de las directivas existentes correspondientes, en la parte superior del archivo:
#include "filehandler_observer.h" #include "mip/file/file_handler.h" #include <iostream> using mip::FileHandler; using std::endl;
Elimine la implementación de la función
main()
que se quitará del inicio rápido anterior. Dentro del cuerpo demain()
, inserte el código siguiente. En el bloque de código siguiente, se establece la marcaenable_msg_file_type
durante la creación del motor de archivos; un archivo .msg puede entonces ser procesado por los objetosmip::FileHandler
creados usando el motor de archivo.
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;
}
Para más información sobre las operaciones de archivo, consulte Conceptos del controlador de archivos.
Reemplace los valores de marcador de posición del código fuente por los valores siguientes:
Marcador Valor <application-id> El identificador de la aplicación tal y como está registrado con el inquilino de Microsoft Entra, por ejemplo: 0edbblll-8773-44de-b87c-b8c6276d41eb
.<engine-account> La cuenta usada para la identidad del motor, por ejemplo: user@tenant.onmicrosoft.com
.<engine-state> Estado de aplicación definido por el usuario, por ejemplo: My engine state
.<input-file-path> La ruta completa a un archivo de mensaje de entrada de prueba, por ejemplo: c:\\Test\\message.msg
.<output-file-path> Ruta completa al archivo de salida, que será una copia etiquetada del archivo de entrada, por ejemplo: c:\\Test\\message_labeled.msg
.<label-id> labelId recuperado con ListSensitivityLabels
, por ejemplo:667466bf-a01b-4b0a-8bbf-a79a3d96f720
.
Compilar y probar la aplicación
Presione F6 (Compilar solución) para compilar la aplicación cliente. Si no hay errores de compilación, presione F5 (Iniciar depuración) para ejecutar la aplicación.