Travailler avec les messages dans un fichier PST

Ajout de messages aux fichiers PST

Créer un nouveau fichier PST et ajouter des sous‑dossiers a montré comment créer un fichier PST et y ajouter un sous‑dossier. Avec Aspose.Email, vous pouvez ajouter des messages aux sous‑dossiers d’un fichier PST que vous avez créé ou chargé. Cet article ajoute deux messages depuis le disque au sous‑dossier Inbox d’un PST. Utilisez le PersonalStorage et FolderInfo classes pour ajouter des messages aux fichiers PST. Pour ajouter des messages au dossier Inbox d’un fichier PST :

  1. Créez une instance de la classe FolderInfo et chargez‑la avec le contenu du dossier Inbox.
  2. Ajoutez des messages depuis le disque au dossier Inbox en appelant le FolderInfo.addMessage() méthode. Le FolderInfo La classe expose le addMessages Méthode qui permet d’ajouter un grand nombre de messages au dossier, réduisant les opérations d’E/S vers le disque et améliorant les performances. Un exemple complet peut être trouvé ci-dessous, dans Ajout de messages en bloc.

Les extraits de code ci‑dessous montrent comment ajouter des messages à un sous‑dossier PST appelé Inbox.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java

// Create new PST
PersonalStorage personalStorage = PersonalStorage.create(dataDir, FileFormatVersion.Unicode);

// Add new folder "Inbox"
personalStorage.getRootFolder().addSubFolder("Inbox");

// Select the "Inbox" folder
FolderInfo inboxFolder = personalStorage.getRootFolder().getSubFolder("Inbox");

// Add some messages to "Inbox" folder
inboxFolder.addMessage(MapiMessage.fromFile(dataDir + "MapiMsgWithPoll.msg"));

Ajout de messages en bloc

Ajouter des messages individuels à un PST implique davantage d’opérations d’E/S vers le disque et peut donc ralentir les performances. Pour améliorer les performances, les messages peuvent être ajoutés au PST en mode bloc afin de minimiser les opérations d’E/S. Le addMessages(Iterable messages) La méthode vous permet de définir une plage de messages à ajouter au PST pour améliorer les performances et peut être utilisée dans les scénarios suivants. De plus, l’événement MessageAdded se produit lorsqu’un message est ajouté au dossier.

Chargement des messages depuis le disque

L’extrait de code suivant vous montre comment charger des messages depuis le disque.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
private static void addMessagesInBulkMode(String fileName, String msgFolderName) {
    try (PersonalStorage personalStorage = PersonalStorage.fromFile(fileName)) {
        FolderInfo folder = personalStorage.getRootFolder().getSubFolder("myInbox");
        folder.MessageAdded.add(new MessageAddedEventHandler() {
            public void invoke(Object sender, MessageAddedEventArgs e) {
                onMessageAdded(sender, e);
            }
        });
        folder.addMessages(new MapiMessageCollection(msgFolderName));
    }
}

static void onMessageAdded(Object sender, MessageAddedEventArgs e) {
    System.out.println(e.getEntryId());
    System.out.println(e.getMessage().getSubject());
}

Implémentation Iterable

L’extrait de code suivant vous montre comment créer une implémentation Iterable.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public class MapiMessageCollection implements Iterable<MapiMessage> {

    private final File folder;

    public MapiMessageCollection(String folder) {
        this.folder = new File(folder);
    }

    public Iterator<MapiMessage> iterator() {
        return new MapiMessageIterator(folder.listFiles());
    }
}

public class MapiMessageIterator implements Iterator<MapiMessage> {

    private Queue<String> queue = new LinkedList<String>();

    public MapiMessageIterator(File[] listOfFiles) {
        for (File file : listOfFiles) {
            queue.offer(file.getAbsolutePath());
        }
    }

    public boolean hasNext() {
        return !queue.isEmpty();
    }

    public MapiMessage next() {
        return MapiMessage.fromFile(queue.poll());
    }
}

Ajout de messages depuis un autre PST

Pour ajouter des messages depuis un autre PST, utilisez le FolderInfo.enumerateMapiMessages() méthode qui renvoie Iterable. L’extrait de code suivant montre comment ajouter des messages depuis un autre PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
private static void bulkAddFromAnotherPst(String source) {
    // The path to the File directory.
    String dataDir = "data/";

    try (PersonalStorage pst = PersonalStorage.fromFile(source, false)) {
        try (PersonalStorage pstDest = PersonalStorage.fromFile(dataDir + "PersonalStorageFile1.pst")) {
            // Get the folder by name
            FolderInfo folderInfo = pst.getRootFolder().getSubFolder("Contacts");
            MessageInfoCollection ms = folderInfo.getContents();

            // Get the folder by name
            FolderInfo f = pstDest.getRootFolder().getSubFolder("myInbox");
            f.MessageAdded.add(new MessageAddedEventHandler() {
                public void invoke(Object sender, MessageAddedEventArgs e) {
                    onMessageAdded(sender, e);
                }
            });
            f.addMessages(folderInfo.enumerateMapiMessages());
            FolderInfo fi = pstDest.getRootFolder().getSubFolder("myInbox");
            MessageInfoCollection msgs = fi.getContents();
        }
    }
}

// Handles the MessageAdded event.
static void onMessageAdded(Object sender, MessageAddedEventArgs e) {
    System.out.println(e.getEntryId());
    System.out.println(e.getMessage().getSubject());
}

Obtenir les informations des messages d’un fichier PST Outlook

Dans Lire le fichier PST Outlook et obtenir les informations des dossiers et sous-dossiers, nous avons abordé le chargement d’un fichier PST Outlook et l’exploration de ses dossiers pour obtenir les noms de dossiers et le nombre de messages qu’ils contiennent. Cet article explique comment lire tous les dossiers et sous-dossiers du fichier PST et afficher les informations sur les messages, par exemple, l’objet, l’expéditeur et les destinataires. Le FolderInfo.getContents() méthode est utilisée pour afficher informations succinctes du message comme l’objet, l’expéditeur, les destinataires. En termes de performance, c’est l’option la plus adaptée pour obtenir les informations principales sur les messages. Pour extraire données complètes du message, le PersonalStorage.extractMessage() méthode est fournie. Le fichier PST Outlook peut contenir des dossiers imbriqués. Pour obtenir les informations des messages de ceux-ci ainsi que des dossiers de niveau supérieur, utilisez une méthode récursive pour lire tous les dossiers. L’extrait de code suivant montre comment lire un fichier PST Outlook et afficher le contenu des dossiers et des messages de façon récursive.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    // The path to the File directory.
    String dataDir = "data/";

    // Load the Outlook file
    String path = dataDir + "PersonalStorage.pst";

    try {

        // Load the Outlook PST file
        PersonalStorage personalStorage = PersonalStorage.fromFile(path);

        // Get the Display Format of the PST file
        System.out.println("Display Format: " + personalStorage.getFormat());

        // Get the folders and messages information
        FolderInfo folderInfo = personalStorage.getRootFolder();

        // Call the recursive method to display the folder contents
        displayFolderContents(folderInfo, personalStorage);
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
    }
}

// This is a recursive method to display contents of a folder
private static void displayFolderContents(FolderInfo folderInfo, PersonalStorage pst) {
    // Display the folder name
    System.out.println("Folder: " + folderInfo.getDisplayName());
    System.out.println("==================================");
    // Display information about messages inside this folder
    MessageInfoCollection messageInfoCollection = folderInfo.getContents();
    for (MessageInfo messageInfo : messageInfoCollection) {
        System.out.println("Subject: " + messageInfo.getSubject());
        System.out.println("Sender: " + messageInfo.getSenderRepresentativeName());
        System.out.println("Recipients: " + messageInfo.getDisplayTo());
        System.out.println("------------------------------");
    }

    // Call this method recursively for each subfolder
    if (folderInfo.hasSubFolders() == true) {
        for (FolderInfo subfolderInfo : folderInfo.getSubFolders()) {
            displayFolderContents(subfolderInfo, pst);
        }
    }
}

Extraction de messages à partir de fichiers PST

Cet article montre comment lire les fichiers PST de Microsoft Outlook et extraire des messages. Les messages sont ensuite enregistrés sur disque au format MSG. L’article montre également comment extraire un nombre spécifique de messages à partir d’un fichier PST. Utilisez une méthode récursive pour parcourir tous les dossiers (y compris les dossiers imbriqués) et appelez le PersonalStorage.extractMessage() méthode pour récupérer les messages Outlook dans une instance de MapiMessage classe. Ensuite, appelez le MapiMessage.save() méthode pour enregistrer le message sur disque ou dans un flux au format MSG. L’extrait de code suivant montre comment extraire des messages d’un fichier PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    // The path to the File directory.
    String dataDir = "data/";

    // Load the Outlook file
    String path = dataDir + "PersonalStorage.pst";

    try {
        // load the Outlook PST file
        PersonalStorage pst = PersonalStorage.fromFile(path);

        // get the Display Format of the PST file
        System.out.println("Display Format: " + pst.getFormat());

        // get the folders and messages information
        FolderInfo folderInfo = pst.getRootFolder();

        // Call the recursive method to extract msg files from each folder
        extractMsgFiles(folderInfo, pst);
    } catch (Exception ex) {
        System.out.println(ex.getMessage());
    }
}

// This is a recursive method to display contents of a folder
private static void extractMsgFiles(FolderInfo folderInfo, PersonalStorage pst) {
    // display the folder name
    System.out.println("Folder: " + folderInfo.getDisplayName());
    System.out.println("==================================");
    // loop through all the messages in this folder
    MessageInfoCollection messageInfoCollection = folderInfo.getContents();
    for (MessageInfo messageInfo : messageInfoCollection) {
        System.out.println("Saving message {0} ...." + messageInfo.getSubject());
        // get the message in MapiMessage instance
        MapiMessage message = pst.extractMessage(messageInfo);
        // save this message to disk in msg format
        message.save(message.getSubject().replace(":", " ") + ".msg");
        // save this message to stream in msg format
        ByteArrayOutputStream messageStream = new ByteArrayOutputStream();
        message.save(messageStream);
    }

    // Call this method recursively for each subfolder
    if (folderInfo.hasSubFolders() == true) {
        for (FolderInfo subfolderInfo : folderInfo.getSubFolders()) {
            extractMsgFiles(subfolderInfo, pst);
        }
    }
}

Enregistrement direct des messages du PST vers un flux

Pour enregistrer des messages d’un fichier PST directement vers un flux, sans extraire le MsgInfo des messages, utilisez le saveMessageToStream() méthode. L’extrait de code suivant montre comment enregistrer des messages directement du PST vers un flux.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";

// Load the Outlook file
String path = dataDir + "PersonalStorage.pst";

// Save message to MemoryStream
try (PersonalStorage personalStorage = PersonalStorage.fromFile(path)) {
    FolderInfo inbox = personalStorage.getRootFolder().getSubFolder("Inbox");
    for (MessageInfo messageInfo : inbox.enumerateMessages()) {
        try (ByteArrayOutputStream memeorystream = new ByteArrayOutputStream()) {
            personalStorage.saveMessageToStream(messageInfo.getEntryIdString(), memeorystream);
        }
    }
}

// Save message to file
try (PersonalStorage pst = PersonalStorage.fromFile(path)) {
    FolderInfo inbox = pst.getRootFolder().getSubFolder("Inbox");
    for (MessageInfo messageInfo : inbox.enumerateMessages()) {
        try (FileOutputStream fs = new FileOutputStream(new File(dataDir + messageInfo.getSubject() + ".msg"))) {
            pst.saveMessageToStream(messageInfo.getEntryIdString(), fs);
        }
    }
}

try (PersonalStorage pst = PersonalStorage.fromFile(path)) {
    FolderInfo inbox = pst.getRootFolder().getSubFolder("Inbox");

    // To enumerate entryId of messages you may use FolderInfo.EnumerateMessagesEntryId() method:
    for (String entryId : inbox.enumerateMessagesEntryId()) {
        try (ByteArrayOutputStream ms = new ByteArrayOutputStream()) {
            pst.saveMessageToStream(entryId, ms);
        }
    }
}

Extraction d’un nombre n de messages d’un fichier PST

L’extrait de code suivant montre comment extraire un nombre donné de messages d’un PST. Il suffit de fournir l’index du premier message et le nombre total de messages à extraire.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
FolderInfo inbox = personalStorage.getRootFolder().getSubFolder("Inbox");

// Extracts messages starting from 10th index top and extract total 100 messages
MessageInfoCollection messages = inbox.getContents(10, 100);

Obtenir le nombre total d’éléments d’un fichier PST

Aspose.Email fournit le GetTotalItemsCount() méthode du PersonalStorage.Store propriété. Elle renvoie le nombre total d’éléments de message contenus dans le PST.

L’exemple de code suivant montre comment récupérer le nombre total d’éléments (messages, rendez-vous, contacts, etc.) stockés dans le fichier PST :

try (PersonalStorage pst = PersonalStorage.fromFile("my.pst", false)) {
    int count = pst.getStore().getTotalItemsCount();
}

Supprimer des éléments des fichiers PST

Ajouter des messages aux fichiers PST montrait comment ajouter des messages aux fichiers PST. Il est bien sûr également possible de supprimer des éléments (contenus) d’un fichier PST et il peut être souhaitable de supprimer des messages en masse. Les éléments d’un fichier PST peuvent être supprimés en utilisant le FolderInfo.deleteChildItem() méthode. L’API fournit également FolderInfo.deleteChildItems() méthode pour supprimer des éléments en masse du fichier PST.

Suppression de messages des fichiers PST

Cet article montre comment utiliser le FolderInfo classe pour accéder à des dossiers spécifiques dans un fichier PST. Pour supprimer des messages du sous-dossier Envoyés d’un fichier PST préalablement chargé ou créé :

  1. Créez une instance de la FolderInfo classe et chargez-le avec le contenu du sous-dossier envoyé.
  2. Supprimez les messages du dossier Envoyés en appelant le FolderInfo.deleteChildItem() méthode et en passant le MessageInfo.EntryId en tant que paramètre. L’extrait de code suivant montre comment supprimer des messages du sous-dossier Envoyés d’un fichier PST.
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/" + "Sub.pst";

// Load the Outlook PST file
PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir);

// Get the Sent items folder
FolderInfo folderInfo = personalStorage.getPredefinedFolder(StandardIpmFolder.SentItems);

MessageInfoCollection msgInfoColl = folderInfo.getContents();
for (MessageInfo msgInfo : msgInfoColl) {
    System.out.println(msgInfo.getSubject() + ": " + msgInfo.getEntryIdString());
    if (msgInfo.getSubject().equals("some delete condition")) {
        // Delete this item
        folderInfo.deleteChildItem(msgInfo.getEntryId());
        System.out.println("Deleted this message");
    }
}

Suppression de dossiers des fichiers PST

Vous pouvez supprimer un dossier PST en le déplaçant vers le dossier Éléments supprimés.

try (PersonalStorage pst = PersonalStorage.fromFile("test.pst")) {
    FolderInfo deletedItemsFolder = pst.getPredefinedFolder(StandardIpmFolder.DeletedItems);
    FolderInfo emptyFolder = pst.getRootFolder().getSubFolder("Empty folder");
    FolderInfo someFolder = pst.getRootFolder().getSubFolder("Some folder");
    pst.moveItem(emptyFolder, deletedItemsFolder);
    pst.moveItem(someFolder, deletedItemsFolder);
}

L’avantage de cette méthode est que le dossier supprimé peut être facilement récupéré.

FolderInfo someFolder = deletedItemsFolder.getSubFolder("Some folder");
pst.moveItem(someFolder, pst.getRootFolder());

Vous pouvez également supprimer définitivement un dossier du dossier Éléments supprimés, si nécessaire.

deletedItemsFolder.deleteChildItem(emptyFolder.getEntryId());

Le deleteChildItem() méthode peut être utilisée pour n’importe quel dossier si vous souhaitez supprimer immédiatement et définitivement un sous-dossier, en contournant le dossier Éléments supprimés.

FolderInfo someFolder = pst.getRootFolder().getSubFolder("Some folder");
pst.getRootFolder().deleteChildItem(someFolder.getEntryId());

Supprimer des éléments en masse d’un fichier PST

L’API Aspose.Email peut être utilisée pour supprimer des éléments en masse d’un fichier PST. Cela est réalisé en utilisant le deleteChildItems() méthode qui accepte une liste d’identifiants d’entrée (Entry ID) faisant référence aux éléments à supprimer. L’extrait de code suivant montre comment supprimer des éléments en masse d’un fichier PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/" + "Sub.pst";

try (PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir)) {
    // Get Inbox SubFolder from Outlook file
    FolderInfo inbox = personalStorage.getRootFolder().getSubFolder("Inbox");

    // Create instance of PersonalStorageQueryBuilder
    PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();

    queryBuilder.getFrom().contains("someuser@domain.com");
    MessageInfoCollection messages = inbox.getContents(queryBuilder.getQuery());
    List<String> deleteList = new ArrayList<String>();
    for (MessageInfo messageInfo : messages) {
        deleteList.add(messageInfo.getEntryIdString());
    }

    // delete messages having From = "someuser@domain.com"
    inbox.deleteChildItems(deleteList);
}

Énumérer et récupérer les messages supprimés doucement du PST

Il est possible de récupérer les messages définitivement supprimés avec Aspose.Email pour Java. Son API permet d’énumérer les messages supprimés doucement dans les fichiers PST. Les éléments supprimés doucement sont des messages qui ont été supprimés deux fois — d’abord déplacés dans le dossier Éléments supprimés, puis retirés de celui-ci. Ces messages restent récupérables, et Aspose.Email fournit un moyen pratique d’y accéder. Le PersonalStorage.findAndEnumerateSoftDeletedItems() méthode renvoie une collection de RestoredItemEntry objets. Chaque entrée contient :

  • MapiMessage item — le message récupéré.
  • String FolderId - l’identifiant du dossier d’origine du message.

L’exemple de code suivant montre comment énumérer les éléments d’e-mail supprimés doucement (récupérables) dans les fichiers PST :

// Load the PST file
try (PersonalStorage pst = PersonalStorage.fromFile(fileName)) {
    // Enumerate soft-deleted items
    for (RestoredItemEntry entry : pst.findAndEnumerateSoftDeletedItems()) {
        MapiMessage message = entry.getItem();
        String folderId = entry.getFolderId();
        
        System.out.println("Subject: " + message.getSubject());
        System.out.println("Deleted from Folder ID: " + folderId);
        System.out.println("-----------------------------------");
    }
}

Recherche de messages et dossiers dans un PST selon un critère

Les fichiers de stockage personnel (PST) peuvent contenir une énorme quantité de données et la recherche de données répondant à un critère spécifique dans de si gros fichiers nécessite plusieurs points de contrôle dans le code pour filtrer l’information. Avec le PersonalStorageQueryBuilder classe, Aspose.Email rend possible la recherche d’enregistrements spécifiques dans un PST selon des critères de recherche spécifiés. Un PST peut être recherché pour des messages en fonction de paramètres tels que l’expéditeur, le destinataire, l’objet, l’importance du message, la présence de pièces jointes, la taille du message, voire l’ID du message. Le PersonalStorageQueryBuilder peut également être utilisé pour rechercher des sous-dossiers.

Recherche de messages et dossiers dans le PST

L’extrait de code suivant montre comment utiliser le PersonalStorageQueryBuilder classe pour rechercher le contenu dans un PST selon différents critères de recherche. Par exemple, elle montre la recherche dans un PST basée sur :

  • Importance du message.
  • Classe du message.
  • Présence de pièces jointes.
  • Taille du message.
  • Date du message.
  • Messages non lus.
  • Messages non lus avec pièces jointes, et
  • dossiers avec un nom de sous-dossier spécifique.
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";

try (PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir + "Outlook.pst")) {
    FolderInfo folder = personalStorage.getRootFolder().getSubFolder("Inbox");
    PersonalStorageQueryBuilder builder = new PersonalStorageQueryBuilder();

    // High importance messages
    builder.getImportance().equals((int) MapiImportance.High);
    MessageInfoCollection messages = folder.getContents(builder.getQuery());
    System.out.println("Messages with High Imp:" + messages.size());

    builder = new PersonalStorageQueryBuilder();
    builder.getMessageClass().equals("IPM.Note");
    messages = folder.getContents(builder.getQuery());
    System.out.println("Messages with IPM.Note:" + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Messages with attachments AND high importance
    builder.getImportance().equals((int) MapiImportance.High);
    builder.hasFlags(MapiMessageFlags.MSGFLAG_HASATTACH);
    messages = folder.getContents(builder.getQuery());
    System.out.println("Messages with atts: " + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Messages with size > 15 KB
    builder.getMessageSize().greater(15000);
    messages = folder.getContents(builder.getQuery());
    System.out.println("messags size > 15Kb:" + messages.size());

    java.util.Calendar c = java.util.Calendar.getInstance();

    builder = new PersonalStorageQueryBuilder();
    // Messages by Current Date
    // (Note that queries by date are not supported for Calendar Items in the Appointments folder)
    builder.getSentDate().on(c.getTime(), DateComparisonType.ByDate);
    messages = folder.getContents(builder.getQuery());
    System.out.println("Messages by Current Date: " + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Messages between Dates
    // (Note that queries by date are not supported for Calendar Items in the Appointments folder)
    c.set(2020,  0, 1, 0, 0, 0);
    builder.getSentDate().since(c.getTime());
    c.set(2021,  0, 1, 0, 0, 0);
    builder.getSentDate().before(c.getTime());
    messages = folder.getContents(builder.getQuery());
    System.out.println("Messages between Dates: " + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Unread messages
    builder.hasNoFlags(MapiMessageFlags.MSGFLAG_READ);
    messages = folder.getContents(builder.getQuery());
    System.out.println("Unread:" + messages.size());

    builder = new PersonalStorageQueryBuilder();
    // Unread messages with attachments
    builder.hasNoFlags(MapiMessageFlags.MSGFLAG_READ);
    builder.hasFlags(MapiMessageFlags.MSGFLAG_HASATTACH);
    messages = folder.getContents(builder.getQuery());
    System.out.println("Unread msgs with atts: " + messages.size());

    // Folder with name of 'SubInbox'
    builder = new PersonalStorageQueryBuilder();
    builder.getFolderName().equals("SubInbox");
    FolderInfoCollection folders = folder.getSubFolders(builder.getQuery());
    System.out.println("Folder having subfolder: " + folders.size());

    builder = new PersonalStorageQueryBuilder();
    // Folders with subfolders
    builder.hasSubfolders();
    folders = folder.getSubFolders(builder.getQuery());
    System.out.println(folders.size());
}

Recherche d’une chaîne dans le PST avec le paramètre d’ignorance de la casse

L’extrait de code suivant montre comment rechercher une chaîne dans un PST avec le paramètre d’ignorance de la casse.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";

try (PersonalStorage personalStorage = PersonalStorage.create(dataDir + "CaseSensitivity.pst", FileFormatVersion.Unicode)) {
    FolderInfo folderinfo = personalStorage.createPredefinedFolder("Inbox", StandardIpmFolder.Inbox);
    folderinfo.addMessage(MapiMessage.fromMailMessage(MailMessage.load("Sample.eml")));
    PersonalStorageQueryBuilder builder = new PersonalStorageQueryBuilder();
    // IgnoreCase is True
    builder.getFrom().contains("automated", true);
    MailQuery query = builder.getQuery();
    MessageInfoCollection coll = folderinfo.getContents(query);
    System.out.println(coll.size());
}

Recherche d’objets de messages par mots-clés multiples dans un fichier PST

Vous pouvez utiliser MailQueryBuilder.or méthode pour trouver des messages dont l’objet contient au moins un des mots spécifiés comme indiqué ci-dessous :

PersonalStorageQueryBuilder builder1 = new PersonalStorageQueryBuilder();
builder1.getSubject().contains("Review"); // 'Review' is key word for the search

PersonalStorageQueryBuilder builder2 = new PersonalStorageQueryBuilder();
builder2.getSubject().contains("Error"); // 'Error' is also key word for the search

PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();
queryBuilder.or(builder1.getQuery(), builder2.getQuery()); // message subjects must contain 'Review' or 'Error' words

try (PersonalStorage storage = PersonalStorage.fromFile("example.pst"))
{
    FolderInfo folderInfo = storage.getRootFolder().getSubFolder("Inbox");
    MessageInfoCollection messageInfos = folderInfo.getContents(queryBuilder.getQuery());

    for (MessageInfo messageInfo : messageInfos)
    {
        System.out.println(messageInfo.getSubject());
    }
}

Récupération paginée du contenu des dossiers PST

Améliorez les performances de votre application et le contrôle lors de la navigation dans de grands dossiers. Récupérez le contenu des dossiers de manière paginée en utilisant la surcharge Aspose.Email de la getContents méthode. Cette méthode - FolderInfo.getContents(MailQuery query, int startIndex, int count) - récupère un sous-ensemble de messages correspondant à la requête spécifiée, à partir d’un indice donné et limité par un nombre. L’exemple de code suivant montre la récupération paginée et le traitement des messages filtrés d’un dossier PST :

// Load the PST file
try (PersonalStorage pst = PersonalStorage.fromFile(fileName)) {
    // Access a specific subfolder
    FolderInfo folder = pst.getRootFolder().getSubFolder("Inbox");

    // Build a query to filter messages by sender address
    PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();
    queryBuilder.getFrom().contains("report-service", true);

    // Define the page size
    int pageSize = 5;

    // Retrieve and process messages in pages
    for (int pageIndex = 0; pageIndex < 6; pageIndex++) {
        int startIndex = pageIndex * pageSize;

        // Get a page of messages
        MessageInfoCollection messages = folder.getContents(queryBuilder.getQuery(), startIndex, pageSize);

        for (MessageInfo messageInfo : messages) {
            // Output basic info about each message
            System.out.println("Subject: " + messageInfo.getSubject() + ", Sender: " + messageInfo.getSenderRepresentativeName());
        }
    }
}

Déplacer des éléments vers d’autres dossiers du fichier PST

Aspose.Email permet de déplacer des éléments d’un dossier source vers un autre dossier dans le même fichier de stockage personnel (PST). Cela comprend :

  • Déplacement d’un dossier spécifié vers un nouveau dossier parent.
  • Déplacement d’un message spécifié vers un nouveau dossier.
  • Déplacement du contenu vers un nouveau dossier.
  • Déplacement des sous-dossiers vers un nouveau dossier parent.

L’extrait de code suivant montre comment déplacer des éléments tels que des messages et des dossiers d’un dossier source vers un autre dossier dans le même fichier PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
try (PersonalStorage personalStorage = PersonalStorage.fromFile("test.pst")) {
    FolderInfo inbox = personalStorage.getPredefinedFolder(StandardIpmFolder.Inbox);
    FolderInfo deleted = personalStorage.getPredefinedFolder(StandardIpmFolder.DeletedItems);
    FolderInfo subfolder = inbox.getSubFolder("Subfolder");

    // Move folder and message to the Deleted Items
    personalStorage.moveItem(subfolder, deleted);
    MessageInfoCollection contents = subfolder.getContents();
    personalStorage.moveItem(contents.get(0), deleted);

    // Move all inbox subfolders and subfolder contents to the Deleted Items
    inbox.moveSubfolders(deleted);
    subfolder.moveContents(deleted);
}

Mise à jour des propriétés des messages dans un fichier PST

Il arrive parfois qu’il soit nécessaire de mettre à jour certaines propriétés des messages, comme changer le sujet, marquer l’importance du message, etc. Mettre à jour un message dans un fichier PST avec de telles modifications de propriétés peut être réalisé à l’aide du FolderInfo.changeMessages méthode. Cet article montre comment mettre à jour en masse les messages dans un fichier PST pour les modifications des propriétés. Le fragment de code suivant montre comment mettre à jour les propriétés des messages en mode groupe pour plusieurs messages dans un fichier PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/" + "Sub.pst";

// Load the Outlook PST file
PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir);

// Get Requierd Subfolder
FolderInfo inbox = personalStorage.getRootFolder().getSubFolder("Inbox");

// find messages having From = "someuser@domain.com"
PersonalStorageQueryBuilder queryBuilder = new PersonalStorageQueryBuilder();
queryBuilder.getFrom().contains("someuser@domain.com");

// Get Contents from Query
MessageInfoCollection messages = inbox.getContents(queryBuilder.getQuery());

// Save (MessageInfo,EntryIdString) in List
List<String> changeList = new ArrayList<String>();
for (MessageInfo messageInfo : messages) {
    changeList.add(messageInfo.getEntryIdString());
}

// Compose the new properties
MapiPropertyCollection updatedProperties = new MapiPropertyCollection();
updatedProperties.add(MapiPropertyTag.PR_SUBJECT_W, new MapiProperty(MapiPropertyTag.PR_SUBJECT_W, "New Subject".getBytes(Charset.forName("utf-16le"))));
updatedProperties.add(MapiPropertyTag.PR_IMPORTANCE, new MapiProperty(MapiPropertyTag.PR_IMPORTANCE, BitConverter.getBytesInt64(2)));

// update messages having From = "someuser@domain.com" with new properties
inbox.changeMessages(changeList, updatedProperties);

Mise à jour des propriétés personnalisées dans un fichier PST

Il arrive parfois qu’il soit nécessaire de marquer les éléments traités dans le fichier PST. L’API Aspose.Email permet de le faire à l’aide de MapiProperty et MapiNamedProperty. Les méthodes suivantes sont utiles pour cela.

  • constructor MapiNamedProperty(long propertyTag, String nameIdentifier, UUID propertyGuid, byte[] propertyValue)
  • constructor MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, byte[] propertyValue)
  • FolderInfo.changeMessages(MapiPropertyCollection updatedProperties) - changes all messages in folder
  • PersonalStorage.changeMessage(String entryId, MapiPropertyCollection updatedProperties) - change message properties
// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
public static void run() {
    // The path to the File directory.
    String dataDir = "data/" + "Sub.pst";

    try (PersonalStorage personalStorage = PersonalStorage.fromFile(dataDir)) {
        FolderInfo testFolder = personalStorage.getRootFolder().getSubFolder("Inbox");

        // Create the collection of message properties for adding or updating
        MapiPropertyCollection newProperties = new MapiPropertyCollection();

        // Normal, Custom and PidLidLogFlags named property
        MapiProperty property = new MapiProperty(MapiPropertyTag.PR_ORG_EMAIL_ADDR_W, "test_address@org.com".getBytes(Charset.forName("utf-16le")));
        MapiProperty namedProperty1 = new MapiNamedProperty(generateNamedPropertyTag(0L, MapiPropertyType.PT_LONG), "ITEM_ID", UUID.randomUUID(),
                BitConverter.getBytesInt64(123));
        MapiProperty namedProperty2 = new MapiNamedProperty(generateNamedPropertyTag(1L, MapiPropertyType.PT_LONG), 0x0000870C,
                UUID.fromString("0006200A-0000-0000-C000-000000000046"), BitConverter.getBytesInt64(0));
        newProperties.add(namedProperty1.getTag(), namedProperty1);
        newProperties.add(namedProperty2.getTag(), namedProperty2);
        newProperties.add(property.getTag(), property);
        testFolder.changeMessages(testFolder.enumerateMessagesEntryId(), newProperties);
    }
}

private static long generateNamedPropertyTag(long index, int dataType) {
    return (((0x8000 | index) << 16) | (long) dataType) & 0x00000000FFFFFFFFL;
}

Extraire les pièces jointes sans extraire le message complet

L’API Aspose.Email peut être utilisée pour extraire les pièces jointes des messages PST sans extraire d’abord le message complet. Le ExtractAttachments méthode de PersonalStorage peut être utilisé pour cela. Le fragment de code suivant montre comment extraire les pièces jointes sans extraire le message complet.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";

try (PersonalStorage personalstorage = PersonalStorage.fromFile(dataDir + "Outlook.pst")) {
    FolderInfo folder = personalstorage.getRootFolder().getSubFolder("Inbox");

    for (String messageInfo : folder.enumerateMessagesEntryId()) {
        MapiAttachmentCollection attachments = personalstorage.extractAttachments(messageInfo);

        if (attachments.size() != 0) {
            for (MapiAttachment attachment : attachments) {
                if (attachment.getLongFileName() != null && !attachment.getLongFileName().isEmpty()) {
                    if (attachment.getLongFileName().contains(".msg")) {
                        continue;
                    } else {
                        attachment.save(dataDir + "Attachments/" + attachment.getLongFileName());
                    }
                }
            }
        }
    }
}

Ajout de fichiers au PST

La fonctionnalité clé de Microsoft Outlook est la gestion des e‑mails, calendriers, tâches, contacts et entrées de journal. De plus, des fichiers peuvent également être ajoutés à un dossier PST et le PST résultant conserve la trace des documents ajoutés. Aspose.Email offre la possibilité d’ajouter des fichiers à un dossier de la même manière que l’ajout de messages, contacts, tâches et entrées de journal au PST. Le fragment de code suivant montre comment ajouter des documents à un dossier PST à l’aide d’Aspose.Email.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-Java
// The path to the File directory.
String dataDir = "data/";

try (PersonalStorage personalStorage = PersonalStorage.create(dataDir + "Ps1_out.pst", FileFormatVersion.Unicode)) {
    FolderInfo folder = personalStorage.getRootFolder().addSubFolder("Files");

    // Add Document.doc file with the "IPM.Document" message class by default.
    folder.addFile(dataDir + "attachment_1.doc", null);
}
Lire et convertir le fichier Outlook OST Travailler avec les contacts dans un fichier PST