Werken met berichten in een PST‑bestand

Berichten toevoegen aan PST‑bestanden

Maak een nieuw PST‑bestand en voeg submappen toe toonde hoe je een PST‑bestand maakt en er een submap aan toevoegt. Met Aspose.Email kun je berichten toevoegen aan submappen van een PST‑bestand dat je hebt gemaakt of geladen. Dit artikel voegt twee berichten van de schijf toe aan de Inbox‑submap van een PST. Gebruik de PersonalStorage en FolderInfo klassen om berichten toe te voegen aan PST‑bestanden. Om berichten toe te voegen aan de Inbox‑map van een PST‑bestand:

  1. Maak een instantie van de FolderInfo‑klasse en laad deze met de inhoud van de Inbox‑map.
  2. Voeg berichten van de schijf toe aan de Inbox‑map door de FolderInfo.addMessage() methode. De FolderInfo klasse exposeert de addMessages Methode die het mogelijk maakt een groot aantal berichten aan de map toe te voegen, waardoor I/O‑bewerkingen naar de schijf worden verminderd en de prestaties verbeteren. Een volledig voorbeeld is hieronder te vinden, in Bulkberichten toevoegen.

De onderstaande codefragmenten tonen hoe je berichten toevoegt aan een PST-submap genaamd 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"));

Bulkberichten toevoegen

Het toevoegen van individuele berichten aan een PST betekent meer I/O‑bewerkingen naar de schijf en kan daardoor de prestaties vertragen. Voor betere prestaties kunnen berichten in bulk‑modus aan de PST worden toegevoegd om I/O‑bewerkingen te minimaliseren. De addMessages(Iterable messages) De methode stelt je in staat een bereik van berichten te definiëren die aan de PST worden toegevoegd voor betere prestaties en kan worden gebruikt in de volgende scenario’s. Daarnaast treedt het MessageAdded‑event op wanneer een bericht aan de map wordt toegevoegd.

Berichten laden van schijf

De volgende codefragment toont hoe je berichten van de schijf laadt.

// 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());
}

Iterable-implementatie

De volgende codefragment toont hoe je een Iterable-implementatie maakt.

// 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());
    }
}

Berichten toevoegen uit een ander PST

Voor het toevoegen van berichten uit een ander PST, gebruik de FolderInfo.enumerateMapiMessages() methode die Iterable teruggeeft. De volgende codefragment toont hoe u berichten uit een ander PST kunt toevoegen.

// 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());
}

Berichtinformatie ophalen uit een Outlook‑PST‑bestand

In Outlook PST‑bestand lezen en map‑ en submapinformatie ophalen, we bespraken het laden van een Outlook‑PST‑bestand en het doorbladeren van de mappen om de mapnamen en het aantal berichten daarin te verkrijgen. Dit artikel legt uit hoe alle mappen en submappen in het PST‑bestand gelezen worden en de informatie over berichten wordt weergegeven, bijvoorbeeld onderwerp, afzender en ontvangers. De FolderInfo.getContents() methode wordt gebruikt om weer te geven korte berichtinformatie zoals onderwerp, afzender, ontvangers. Wat prestaties betreft, is dit de meest geschikte optie om primaire informatie over berichten te verkrijgen. Om extraheer volledige berichtgegevens, de PersonalStorage.extractMessage() methode wordt aangeboden. Het Outlook‑PST‑bestand kan geneste mappen bevatten. Om berichtinformatie uit deze mappen, evenals de bovenliggende mappen, te verkrijgen, gebruik een recursieve methode om alle mappen te lezen. De volgende codefragment toont hoe u een Outlook‑PST‑bestand leest en de map- en berichtinhoud recursief weergeeft.

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

Berichten extraheren uit PST‑bestanden

Dit artikel toont hoe Microsoft Outlook PST‑bestanden gelezen kunnen worden en berichten kunt extraheren. De berichten worden daarna opgeslagen op schijf in MSG‑formaat. Het artikel toont ook hoe u een specifiek aantal berichten extraheren uit een PST‑bestand. Gebruik een recursieve methode om door alle mappen (inclusief geneste mappen) te bladeren en roep de PersonalStorage.extractMessage() methode aan om Outlook‑berichten in een instantie van de MapiMessage klasse. Roep daarna de MapiMessage.save() methode om het bericht op te slaan op schijf of stream in MSG‑formaat. De volgende codefragment toont hoe u berichten uit een PST‑bestand extraheert.

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

Berichten direct vanuit PST naar stream opslaan

Om berichten uit een PST‑bestand direct naar een stream op te slaan, zonder de MsgInfo voor berichten te extraheren, gebruik de saveMessageToStream() methode. De volgende codefragment toont hoe u berichten direct vanuit een PST naar een stream kunt opslaan.

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

Extractie van n berichten uit een PST‑bestand

De volgende codefragment toont hoe u een bepaald aantal berichten uit een PST kunt extraheren. Geef simpelweg de index van het eerste bericht en het totale aantal berichten op dat moet worden geëxtraheerd.

// 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);

Totale aantal items uit een PST‑bestand ophalen

Aspose.Email biedt de GetTotalItemsCount() methode van de PersonalStorage.Store eigenschap. Het retourneert het totale aantal berichtitems dat in de PST zit.

Het volgende codevoorbeeld toont hoe u het totale aantal items (berichten, afspraken, contactpersonen, enz.) dat in het PST‑bestand is opgeslagen, kunt opvragen:

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

Items verwijderen uit PST‑bestanden

Berichten toevoegen aan PST‑bestanden toonde hoe berichten aan PST‑bestanden toegevoegd kunnen worden. Het is uiteraard ook mogelijk om items (inhoud) uit een PST‑bestand te verwijderen en het kan wenselijk zijn om berichten in bulk te verwijderen. Items uit een PST‑bestand kunnen worden verwijderd met behulp van de FolderInfo.deleteChildItem() methode. De API biedt ook FolderInfo.deleteChildItems() methode om items in bulk uit het PST‑bestand te verwijderen.

Berichten verwijderen uit PST‑bestanden

Dit artikel toont hoe u de FolderInfo klasse om toegang te krijgen tot specifieke mappen in een PST‑bestand. Om berichten uit de verzonden submap van een eerder geladen of aangemaakt PST‑bestand te verwijderen:

  1. Maak een instantie van de FolderInfo klasse aan te roepen en te laden met de inhoud van de verzonden submap.
  2. Verwijder berichten uit de map Verzonden door de FolderInfo.deleteChildItem() methode en de MessageInfo.EntryId als parameter. De volgende codefragment toont hoe u berichten uit de map Verzonden van een PST‑bestand kunt verwijderen.
// 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");
    }
}

Mappen verwijderen uit PST‑bestanden

U kunt een PST‑map verwijderen door deze naar de map Verwijderde items te verplaatsen.

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

Het voordeel van deze methode is dat de verwijderde map gemakkelijk kan worden hersteld.

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

U kunt indien nodig ook een map permanent uit de map Verwijderde items verwijderen.

deletedItemsFolder.deleteChildItem(emptyFolder.getEntryId());

De deleteChildItem() methode kan voor elke map worden gebruikt als u een submap direct en permanent wilt verwijderen, waarbij de map Verwijderde items wordt overgeslagen.

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

Items in bulk verwijderen uit PST‑bestand

Aspose.Email‑API kan worden gebruikt om items in bulk uit een PST‑bestand te verwijderen. Dit wordt bereikt met de deleteChildItems() methode die een lijst met Entry‑ID‑items accepteert die verwijzen naar de te verwijderen items. De volgende codefragment toont hoe u items in bulk uit een PST‑bestand kunt verwijderen.

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

Enumereren en herstellen van soft‑verwijderde berichten uit PST

Het is mogelijk om permanent verwijderde berichten op te halen met Aspose.Email voor Java. De API maakt het mogelijk om soft‑verwijderde berichten in PST‑bestanden te enumereren. Soft‑verwijderde items zijn berichten die twee keer zijn verwijderd – eerst verplaatst naar de map Verwijderde items en daarna van daaruit verwijderd. Deze berichten zijn nog steeds herstelbaar en Aspose.Email biedt een handige manier om ze te benaderen. De PersonalStorage.findAndEnumerateSoftDeletedItems() methode geeft een collectie terug van RestoredItemEntry objecten. Elke entry bevat:

  • MapiMessage item — het herstelde bericht.
  • String FolderId - de identificatie van de map waartoe het bericht oorspronkelijk behoorde.

Het volgende codevoorbeeld toont hoe soft‑verwijderde (herstelbare) e‑mailitems in PST‑bestanden genoteerd kunnen worden:

// 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("-----------------------------------");
    }
}

Zoek berichten en mappen in een PST op criterium

Personal Storage (PST)-bestanden kunnen een enorme hoeveelheid data bevatten en zoeken naar data die aan een specifiek criterium voldoet in zulke grote bestanden vereist meerdere controlepunten in de code om de informatie te filteren. Met de PersonalStorageQueryBuilder klasse, Aspose.Email maakt het mogelijk om specifieke records in een PST te zoeken op basis van een opgegeven zoekcriterium. Een PST kan worden doorzocht op berichten op basis van zoekparameters zoals afzender, ontvanger, onderwerp, berichtbelang, aanwezigheid van bijlagen, berichtgrootte en zelfs bericht‑ID. De PersonalStorageQueryBuilder kan ook worden gebruikt om submappen te zoeken.

Berichten en mappen zoeken in PST

De volgende codefragment laat zien hoe je de PersonalStorageQueryBuilder klasse om inhoud in een PST te zoeken op basis van verschillende zoekcriteria. Bijvoorbeeld, het toont zoeken in een PST op basis van:

  • Berichtbelang.
  • Berichtklasse.
  • Aanwezigheid van bijlagen.
  • Berichtgrootte.
  • Berichtdatum.
  • Ongelezen berichten.
  • Ongelezen berichten met bijlagen, en
  • mappen met een specifieke submapnaam.
// 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());
}

Zoeken naar een tekenreeks in PST met de negeer-hoofdlettergevoeligheidsparameter

De volgende codefragment toont hoe u een tekenreeks in een PST kunt zoeken met de negeer-hoofdlettergevoeligheidsparameter.

// 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());
}

Zoeken naar berichtonderwerpen met meerdere trefwoorden in een PST‑bestand

U kunt gebruiken MailQueryBuilder.or methode om berichten te vinden waarvan het onderwerp ten minste één van de opgegeven woorden bevat, zoals hieronder weergegeven:

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

Gepagineerde ophalen van PST‑mapinhoud

Verbeter de prestaties van uw toepassing en de controle bij het navigeren door grote mappen. Haal mapinhoud op een gepagineerde manier op met de Aspose.Email‑overbelasting van de getContents methode. Deze methode - FolderInfo.getContents(MailQuery query, int startIndex, int count) - haalt een deelset op van berichten die voldoen aan de opgegeven query, beginnend vanaf een bepaald index en beperkt tot een aantal. Het volgende codevoorbeeld toont paginagegevens en verwerking van gefilterde berichten uit een PST‑map:

// 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());
        }
    }
}

Items verplaatsen naar andere mappen van een PST‑bestand

Aspose.Email maakt het mogelijk om items van een bronmap naar een andere map in hetzelfde Personal Storage (PST)-bestand te verplaatsen. Dit omvat:

  • Een opgegeven map naar een nieuwe bovenliggende map verplaatsen.
  • Een opgegeven bericht naar een nieuwe map verplaatsen.
  • De inhoud verplaatsen naar een nieuwe map.
  • Submappen verplaatsen naar een nieuwe bovenliggende map.

De volgende codefragment toont hoe u items zoals berichten en mappen van een bronmap naar een andere map in hetzelfde PST‑bestand verplaatst.

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

Bijwerken van berichteigenschappen in een PST-bestand

Het is soms nodig om bepaalde eigenschappen van berichten bij te werken, zoals het wijzigen van het onderwerp, het markeren van berichtprioriteit en soortgelijke zaken. Een bericht in een PST‑bestand bijwerken met zulke wijzigingen in de bericht‑eigenschappen kan worden gedaan met behulp van de FolderInfo.changeMessages methode. Dit artikel laat zien hoe je berichten in bulk kunt bijwerken in een PST‑bestand voor wijzigingen in de eigenschappen. Het volgende code‑fragment laat zien hoe je de eigenschappen van berichten in bulk‑modus bijwerkt voor meerdere berichten in een PST‑bestand.

// 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);

Aangepaste eigenschappen bijwerken in een PST‑bestand

Soms is het nodig om items te markeren die verwerkt zijn binnen het PST‑bestand. De Aspose.Email‑API maakt dit mogelijk met behulp van MapiProperty en MapiNamedProperty. De volgende methoden zijn hierbij nuttig.

  • constructor MapiNamedProperty(long propertyTag, String nameIdentifier, UUID propertyGuid, byte[] propertyValue)
  • constructor MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, byte[] propertyValue)
  • FolderInfo.changeMessages(MapiPropertyCollection updatedProperties) - wijzigt alle berichten in de map
  • PersonalStorage.changeMessage(String entryId, MapiPropertyCollection updatedProperties) - bericht‑eigenschappen wijzigen
// 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;
}

Bijlagen extraheren zonder volledig bericht te extraheren

De Aspose.Email‑API kan worden gebruikt om bijlagen uit PST‑berichten te extraheren zonder eerst het volledige bericht te extraheren. De ExtractAttachments methode van PersonalStorage kunnen hiervoor worden gebruikt. Het volgende code‑fragment laat zien hoe je bijlagen kunt extraheren zonder het volledige bericht te extraheren.

// 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());
                    }
                }
            }
        }
    }
}

Bestanden toevoegen aan PST

De kernfunctionaliteit van Microsoft Outlook is het beheren van e‑mails, agenda’s, taken, contacten en journaalvermeldingen. Daarnaast kunnen ook bestanden aan een PST‑map worden toegevoegd en houdt de resulterende PST een overzicht bij van de toegevoegde documenten. Aspose.Email biedt de mogelijkheid om bestanden op dezelfde manier aan een map toe te voegen, naast het toevoegen van berichten, contacten, taken en journaalvermeldingen aan een PST. Het volgende code‑fragment laat zien hoe je documenten aan een PST‑map toevoegt met behulp van 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);
}
Outlook OST‑bestand lezen en converteren Werken met contactpersonen in PST‑bestand