Lavorare con i messaggi in un file PST

Aggiunta di messaggi ai file PST

Crea un nuovo file PST e aggiungi sottocartelle ha mostrato come creare un file PST e aggiungere una sottocartella. Con Aspose.Email è possibile aggiungere messaggi alle sottocartelle di un file PST che hai creato o caricato. Questo articolo aggiunge due messaggi dal disco alla sottocartella Inbox di un PST. Usa il PersonalStorage e FolderInfo classi per aggiungere messaggi ai file PST. Per aggiungere messaggi alla cartella Inbox di un file PST:

  1. Crea un’istanza della classe FolderInfo e caricala con il contenuto della cartella Inbox.
  2. Aggiungi messaggi dal disco alla cartella Inbox chiamando il FolderInfo.addMessage() metodo. Il FolderInfo la classe espone il addMessages Metodo che consente di aggiungere un gran numero di messaggi alla cartella, riducendo le operazioni I/O al disco e migliorando le prestazioni. Un esempio completo può essere trovato di seguito, in Aggiunta di messaggi in batch.

Gli snippet di codice seguenti mostrano come aggiungere messaggi a una sottocartella PST chiamata 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"));

Aggiunta di messaggi in batch

Aggiungere messaggi individuali a un PST implica più operazioni I/O al disco e quindi può rallentare le prestazioni. Per migliorare le prestazioni, i messaggi possono essere aggiunti al PST in modalità batch per ridurre al minimo le operazioni I/O. Il addMessages(Iterable messages) Il metodo consente di definire un intervallo di messaggi da aggiungere al PST per migliorare le prestazioni e può essere utilizzato nei seguenti scenari. Inoltre, l’evento MessageAdded si verifica quando un messaggio viene aggiunto alla cartella.

Caricamento dei messaggi dal disco

Il seguente snippet di codice mostra come caricare i messaggi dal disco.

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

Implementazione Iterable

Il seguente snippet di codice mostra come creare un’implementazione 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());
    }
}

Aggiunta di messaggi da un altro PST

Per aggiungere messaggi da un altro PST, usa il FolderInfo.enumerateMapiMessages() metodo che restituisce Iterable. Il seguente frammento di codice mostra come aggiungere messaggi da un altro 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());
}

Ottieni informazioni sui messaggi da un file PST di Outlook

In Leggi il file Outlook PST e ottieni informazioni su cartelle e sottocartelle, abbiamo discusso del caricamento di un file PST di Outlook e della navigazione delle sue cartelle per ottenere i nomi delle cartelle e il numero di messaggi in esse. Questo articolo spiega come leggere tutte le cartelle e sottocartelle nel file PST e mostrare le informazioni sui messaggi, ad esempio oggetto, mittente e destinatari. Il FolderInfo.getContents() il metodo è usato per visualizzare informazioni sintetiche del messaggio come oggetto, mittente, destinatari. In termini di prestazioni, questa è l’opzione più adatta per ottenere informazioni primarie sui messaggi. Per extract dati completi del messaggio, il PersonalStorage.extractMessage() viene fornito il metodo. Il file PST di Outlook può contenere cartelle nidificate. Per ottenere le informazioni sui messaggi da queste e dalle cartelle di livello superiore, usa un metodo ricorsivo per leggere tutte le cartelle. Il seguente frammento di codice mostra come leggere un file PST di Outlook e visualizzare ricorsivamente il contenuto delle cartelle e dei messaggi.

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

Estrazione di messaggi da file PST

Questo articolo mostra come leggere i file PST di Microsoft Outlook e estrarre i messaggi. I messaggi vengono poi salvati su disco in formato MSG. L’articolo mostra anche come estrarre un numero specifico di messaggi da un file PST. Usa un metodo ricorsivo per esplorare tutte le cartelle (incluse quelle nidificate) e chiama il PersonalStorage.extractMessage() metodo per ottenere i messaggi Outlook in un’istanza di MapiMessage classe. Dopo, chiama il MapiMessage.save() metodo per salvare il messaggio su disco o stream in formato MSG. Il seguente frammento di codice mostra come estrarre i messaggi da un file 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);
        }
    }
}

Salvataggio diretto dei messaggi da PST a stream

Per salvare i messaggi da un file PST direttamente su stream, senza estrarre il MsgInfo per i messaggi, usa il saveMessageToStream() metodo. Il seguente frammento di codice mostra come salvare i messaggi direttamente da PST a stream.

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

Estrazione di n messaggi da un file PST

Il seguente frammento di codice mostra come estrarre un determinato numero di messaggi da un PST. Basta fornire l’indice del primo messaggio e il numero totale di messaggi da estrarre.

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

Ottieni il numero totale di elementi da un file PST

Aspose.Email fornisce il GetTotalItemsCount() metodo del PersonalStorage.Store proprietà. Restituisce il numero totale di messaggi contenuti nel PST.

Il seguente esempio di codice mostra come recuperare il conteggio totale degli elementi (messaggi, appuntamenti, contatti, ecc.) archiviati nel file PST:

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

Elimina elementi da file PST

Add Messages to PST Files ha mostrato come aggiungere messaggi ai file PST. È, naturalmente, anche possibile eliminare elementi (contenuti) da un file PST e può essere desiderabile eliminare messaggi in blocco. Gli elementi di un file PST possono essere eliminati usando il FolderInfo.deleteChildItem() metodo. L’API fornisce anche FolderInfo.deleteChildItems() metodo per eliminare elementi in blocco dal file PST.

Eliminazione di messaggi da file PST

Questo articolo mostra come usare il FolderInfo classe per accedere a cartelle specifiche in un file PST. Per eliminare i messaggi dalla sottocartella Inviati di un file PST precedentemente caricato o creato:

  1. Crea un’istanza di FolderInfo classe e caricala con i contenuti della sottocartella Inviati.
  2. Elimina i messaggi dalla cartella Inviati chiamando il FolderInfo.deleteChildItem() metodo e passando il MessageInfo.EntryId come parametro. Il seguente frammento di codice mostra come eliminare messaggi dalla sottocartella Inviati di un file 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");
    }
}

Eliminazione di cartelle da file PST

Puoi eliminare una cartella PST spostandola nella cartella Elementi eliminati.

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

Il vantaggio di questo metodo è che la cartella eliminata può essere facilmente recuperata.

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

Puoi anche rimuovere definitivamente una cartella dalla cartella Elementi eliminati, se necessario.

deletedItemsFolder.deleteChildItem(emptyFolder.getEntryId());

Il deleteChildItem() il metodo può essere usato per qualsiasi cartella se si desidera eliminare immediatamente e definitivamente una sottocartella, bypassando la cartella Elementi eliminati.

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

Elimina elementi in blocco da un file PST

L’API Aspose.Email può essere usata per eliminare elementi in blocco da un file PST. Questo è ottenuto usando il deleteChildItems() metodo che accetta un elenco di elementi Entry ID riferiti agli oggetti da eliminare. Il seguente frammento di codice mostra come eliminare elementi in blocco da un file 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);
}

Enumerare e recuperare messaggi soft-deleted da PST

È possibile recuperare messaggi eliminati definitivamente con Aspose.Email per Java. La sua API consente di enumerare i messaggi eliminati (soft-deleted) nei file PST. Gli elementi soft-deleted sono messaggi che sono stati cancellati due volte - prima spostati nella cartella Elementi eliminati e poi rimossi da essa. Questi messaggi sono ancora recuperabili, e Aspose.Email fornisce un modo conveniente per accedervi. Il PersonalStorage.findAndEnumerateSoftDeletedItems() il metodo restituisce una collezione di RestoredItemEntry oggetti. Ogni voce contiene:

  • MapiMessage item — il messaggio recuperato.
  • String FolderId - l’identificatore della cartella a cui il messaggio apparteneva originariamente.

Il seguente esempio di codice dimostra come enumerare gli elementi email eliminati (recuperabili) nei file 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("-----------------------------------");
    }
}

Cerca messaggi e cartelle in un PST per criterio

I file di archiviazione personale (PST) possono contenere una grande quantità di dati e la ricerca di dati che soddisfano criteri specifici in file così grandi richiede l’inserimento di più punti di controllo nel codice per filtrare le informazioni. Con il PersonalStorageQueryBuilder classe, Aspose.Email consente di cercare record specifici in un PST basandosi su criteri di ricerca specificati. Un PST può essere cercato per messaggi in base a parametri di ricerca quali mittente, destinatario, oggetto, importanza del messaggio, presenza di allegati, dimensione del messaggio e persino ID del messaggio. Il PersonalStorageQueryBuilder può anche essere usato per cercare sottocartelle.

Ricerca di messaggi e cartelle in PST

Il seguente frammento di codice mostra come utilizzare il PersonalStorageQueryBuilder classe per cercare contenuti in un PST basandosi su diversi criteri di ricerca. Ad esempio, mostra la ricerca di un PST basata su:

  • Importanza del messaggio.
  • Classe del messaggio.
  • Presenza di allegati.
  • Dimensione del messaggio.
  • Data del messaggio.
  • Messaggi non letti.
  • Messaggi non letti con allegati, e
  • cartelle con nome specifico di sottocartella.
// 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());
}

Ricerca di una stringa in PST con il parametro Ignora maiuscole/minuscole

Il seguente frammento di codice mostra come cercare una stringa in un PST con il parametro di ignorare le maiuscole.

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

Ricerca degli oggetti dei messaggi per più parole chiave in un file PST

Puoi usare MailQueryBuilder.or metodo per trovare messaggi con un oggetto contenente almeno una delle parole specificate come mostrato di seguito:

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

Recupero paginato dei contenuti della cartella PST

Migliora le prestazioni della tua applicazione e il controllo durante la navigazione di cartelle di grandi dimensioni. Recupera il contenuto delle cartelle in modo paginato utilizzando la sovraccarico di Aspose.Email del getContents metodo. Questo metodo - FolderInfo.getContents(MailQuery query, int startIndex, int count) - recupera un sottoinsieme di messaggi che corrispondono alla query specificata, a partire da un indice dato e limitato da un conteggio. Il seguente esempio di codice dimostra il recupero paginato e l’elaborazione di messaggi filtrati da una cartella 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());
        }
    }
}

Spostare gli elementi in altre cartelle del file PST

Aspose.Email consente di spostare elementi da una cartella di origine a un’altra cartella nello stesso file di archiviazione personale (PST). Questo include:

  • Spostamento di una cartella specificata in una nuova cartella principale.
  • Spostamento di un messaggio specificato in una nuova cartella.
  • Spostamento del contenuto in una nuova cartella.
  • Spostamento di sottocartelle in una nuova cartella principale.

Il seguente frammento di codice mostra come spostare elementi come messaggi e cartelle da una cartella di origine a un’altra cartella nello stesso file 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);
}

Aggiornamento delle proprietà del messaggio in un file PST

Talvolta è necessario aggiornare alcune proprietà dei messaggi come modificare l’oggetto, contrassegnare l’importanza del messaggio e altre similari. Aggiornare un messaggio in un file PST, con tali modifiche alle proprietà del messaggio, può essere fatto usando il FolderInfo.changeMessages metodo. Questo articolo mostra come aggiornare i messaggi in blocco in un file PST per modifiche alle proprietà. Il seguente frammento di codice mostra come aggiornare le proprietà dei messaggi in modalità bulk per più messaggi in un file 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);

Aggiornamento delle proprietà personalizzate in un file PST

Talvolta è necessario contrassegnare gli elementi processati all’interno del file PST. L’API di Aspose.Email consente di farlo usando MapiProperty e MapiNamedProperty. I seguenti metodi sono utili per raggiungere questo scopo.

  • constructor MapiNamedProperty(long propertyTag, String nameIdentifier, UUID propertyGuid, byte[] propertyValue)
  • constructor MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, byte[] propertyValue)
  • FolderInfo.changeMessages(MapiPropertyCollection updatedProperties) - cambia tutti i messaggi nella cartella
  • PersonalStorage.changeMessage(String entryId, MapiPropertyCollection updatedProperties) - modifica le proprietà del messaggio
// 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;
}

Estrai allegati senza estrarre l’intero messaggio

L’API di Aspose.Email può essere usata per estrarre gli allegati dai messaggi PST senza estrarre prima l’intero messaggio. Il ExtractAttachments metodo di PersonalStorage può essere usato per farlo. Il seguente frammento di codice mostra come estrarre gli allegati senza estrarre l’intero messaggio.

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

Aggiunta di file al PST

La funzionalità chiave di Microsoft Outlook è gestire email, calendari, attività, contatti e voci di diario. Inoltre, è possibile aggiungere file a una cartella PST e il PST risultante conserva la traccia dei documenti aggiunti. Aspose.Email offre la possibilità di aggiungere file a una cartella allo stesso modo di aggiungere messaggi, contatti, attività e voci di diario al PST. Il seguente frammento di codice mostra come aggiungere documenti a una cartella PST usando 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);
}
Leggi e Converti il file Outlook OST Lavorare con i contatti in un file PST