Fichier SDK - Traiter les fichiers .msg par e-mail (C#)

Le fichier SDK prend en charge les opérations d’étiquetage des fichiers .msg d’une 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 mentionné précédemment, l’instanciation de IFileEngine nécessite un objet de paramètre, FileEngineSettings. FileEngineSettings peut être utilisé pour transmettre des paramètres pour des paramètres personnalisés que l’application doit définir pour une instance particulière. La propriété CustomSettings de FileEngineSettings est utilisée pour définir l’indicateur de enable_msg_file_type pour permettre le traitement des fichiers .msg.

Prérequis

Si ce n’est déjà fait, veillez à satisfaire les prérequis suivants avant de poursuivre :

• Suivez d’abord Démarrage rapide : Initialisation des SDK File (C#), pour créer une solution Visual Studio de démarrage. Ce démarrage rapide « Guide pratique : Traiter les fichiers .msg d’e-mails (C#) » s’appuie sur le précédent.
• Examinez les concepts Envoi de fichiers SDK MIP par e-mail.
• Facultatif : passez en revue les Moteurs de fichiers dans les concepts du SDK MIP.
• Facultatif : passez en revue les Gestionnaires de fichiers dans les concepts du SDK MIP.

Définir enable_msg_file_type et utiliser le SDK File pour étiqueter le fichier .msg

Dans la continuation du démarrage rapide sur l’initialisation de l’application d’API de fichier, modifiez le code de construction du moteur File pour définir enable_msg_file_type flag, puis utilisez le moteur File pour étiqueter un fichier .msg.

1. Ouvrez la solution Visual Studio que vous avez créée dans l’article précédent, « Démarrage rapide : Initialisation du SDK File (C#) ».

2. Dans l’Explorateur de solutions, ouvrez le fichier .cs dans votre projet qui contient l’implémentation de la méthode Main(). Par défaut, il a le même nom que le projet qui le contient et que vous avez spécifié lors de la création du projet.

3. Supprimez l’implémentation de la fonction Main() à partir du démarrage rapide précédent. Dans le corps Main(), 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 File, un fichier .msg peut ensuite être traitée par des objets IFileHandler créés à l’aide du moteur File.

   static void Main(string[] args)
   {
       // Initialize Wrapper for File SDK operations.
       MIP.Initialize(MipComponent.File);
   
       // Create ApplicationInfo, setting the clientID from Azure AD App Registration as the ApplicationId.
       ApplicationInfo appInfo = new ApplicationInfo()
       {
               ApplicationId = clientId,
               ApplicationName = appName,
               ApplicationVersion = "1.0.0"
       };
   
       // Instantiate the AuthDelegateImpl object, passing in AppInfo.
       AuthDelegateImplementation authDelegate = new AuthDelegateImplementation(appInfo);
   
       MipContext mipContext = MIP.CreateMipContext(appInfo,"mip_data",LogLevel.Trace,null,null);
   
       // Initialize and instantiate the File Profile.
       // Create the FileProfileSettings object.
       // Initialize file profile settings to create/use local state.
       var profileSettings = new FileProfileSettings(mipContext, 
                                   CacheStorageType.OnDiskEncrypted, 
                                   new ConsentDelegateImplementation());
   
       // Load the Profile async and wait for the result.
       var fileProfile = Task.Run(async () => await MIP.LoadFileProfileAsync(profileSettings)).Result;
   
       // Create a FileEngineSettings object, then use that to add an engine to the profile.
       var customSettings = new List<KeyValuePair<string, string>>();
       customSettings.Add(new KeyValuePair<string, string>("enable_msg_file_type", "true"));
   
       // Create a FileEngineSettings object, then use that to add an engine to the profile.
       var engineSettings = new FileEngineSettings("user1@tenant.com", authDelegate, "", "en-US");
       engineSettings.Identity = new Identity("user1@tenant.com");
       //set custom settings for the engine
       engineSettings.CustomSettings = customSettings;
   
       //Add fileEngine to profile
       var fileEngine = Task.Run(async () => await fileProfile.AddEngineAsync(engineSettings)).Result;
   
       //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
       var fileHandler = Task.Run(async () => await fileEngine.CreateFileHandlerAsync(inputFilePath, 
                                                                   actualFilePath, 
                                                                   true)).Result;
   
       // List labels available to the user and use one of them to label the MSG file.
   
       foreach (var label in fileEngine.SensitivityLabels)
       {
           Console.WriteLine(string.Format("{0} - {1}", label.Name, label.Id));
   
           if (label.Children.Count > 0)
           {
               foreach (Label child in label.Children)
               {
                   Console.WriteLine(string.Format("\t{0} - {1}", child.Name, child.Id));
               }
           }
       }
   
       string labelId = "<label-id>"; //label retrieved using file engine
   
       LabelingOptions labelingOptions = new LabelingOptions()
       {
           AssignmentMethod = options.AssignmentMethod
       };
   
       fileHandler.SetLabel(labelId, labelingOptions, new ProtectionSettings());
   
       // Commit changes, save as outputFilePath
       var result = Task.Run(async () => await fileHandler.CommitAsync(outputFilePath)).Result;
   
       // Create a new handler to read the labeled file metadata
       var handlerModified = Task.Run(async () => await fileEngine.CreateFileHandlerAsync(outputFilePath, 
                                                                       actualOutputFilePath, 
                                                                       true)).Result;
   
       Console.WriteLine(string.Format("Original file: {0}", inputFilePath));
       Console.WriteLine(string.Format("Labeled file: {0}", outputFilePath));
       Console.WriteLine(string.Format("Label applied to file: {0}", 
           handlerModified.Label.Name));
       Console.WriteLine("Press a key to continue.");
       Console.ReadKey();
   
       // Application Shutdown
       fileHandler = null;
       handlerModified = null;
       fileEngine = null;
       fileProfile = null;
       mipContext = null;
   }
   
   

   Pour plus d’informations sur les opérations sur les fichiers, consultes les Concepts de gestionnaires de fichiers.

4. Remplacez les valeurs d’espace réservé dans le code source par les valeurs suivantes :

   Paramètre substituable	Valeur
   <input-file-path>	Chemin complet d’un fichier 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>	L’ID d’étiquette récupéré à l’aide du moteur File, par exemple : 667466bf-a01b-4b0a-8bbf-a79a3d96f720.

Concevoir et tester l’application

Utilisez F6 (Créer une solution) pour créer votre application cliente. Si vous n’avez aucune erreur de build, utilisez F5 (Démarrer le débogage) pour exécuter votre application.

    Original file: C:\Test.msg
    Labeled file: C:\Test_Labeled.msg
    Label applied to file: Confidential    
    Press a key to continue.