Trabalhando com mensagens em um arquivo PST

Adicionando Mensagens a Arquivos PST

Criar um Novo Arquivo PST e Adicionar Subpastas Mostrou como criar um arquivo PST e adicionar uma subpasta a ele. Com o Aspose.Email você pode adicionar mensagens a subpastas de um arquivo PST que criou ou carregou. Este artigo adiciona duas mensagens do disco à subpasta Inbox de um PST. Use o PersonalStorage e FolderInfo Classes para adicionar mensagens a arquivos PST. Para adicionar mensagens à pasta Inbox de um arquivo PST:

  1. Crie uma instância da classe FolderInfo e carregue-a com o conteúdo da pasta Inbox.
  2. Adicione mensagens do disco à pasta Inbox chamando o FolderInfo.addMessage() método. O FolderInfo A classe expõe o addMessages Método que permite adicionar um grande número de mensagens à pasta, reduzindo as operações de I/O ao disco e melhorando o desempenho. Um exemplo completo pode ser encontrado abaixo, em Adicionando Mensagens em Lote.

Os trechos de código abaixo mostram como adicionar mensagens a uma subpasta PST chamada 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"));

Adicionando Mensagens em Lote

Adicionar mensagens individuais a um PST implica mais operações de I/O ao disco e, portanto, pode diminuir o desempenho. Para melhorar o desempenho, as mensagens podem ser adicionadas ao PST em modo em lote para minimizar as operações de I/O. O addMessages(Iterable messages) O método permite definir um intervalo de mensagens a ser adicionado ao PST para melhorar o desempenho e pode ser usado nos seguintes cenários. Além disso, o evento MessageAdded ocorre quando uma mensagem é adicionada à pasta.

Carregando Mensagens do Disco

O trecho de código a seguir mostra como carregar mensagens do 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());
}

Implementação de Iterable

O trecho de código a seguir mostra como criar a Implementação de 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());
    }
}

Adicionando Mensagens de Outro PST

Para adicionar mensagens de outro PST, use o FolderInfo.enumerateMapiMessages() método que retorna Iterable. O trecho de código a seguir mostra como adicionar mensagens de outro 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());
}

Obter Informações de Mensagens de um Arquivo PST do Outlook

Em Ler Arquivo PST do Outlook e Obter Informações de Pastas e Subpastas, discutimos como carregar um arquivo PST do Outlook e navegar por suas pastas para obter os nomes das pastas e o número de mensagens nelas. Este artigo explica como ler todas as pastas e subpastas do arquivo PST e exibir as informações sobre mensagens, por exemplo, assunto, remetente e destinatários. O FolderInfo.getContents() método é usado para exibir informação resumida da mensagem como assunto, remetente, destinatários. Em termos de desempenho, esta é a opção mais adequada para obter informações primárias sobre mensagens. Para extrair dados completos da mensagem, o PersonalStorage.extractMessage() método é fornecido. O arquivo PST do Outlook pode conter pastas aninhadas. Para obter informações de mensagem destas, bem como das pastas de nível superior, use um método recursivo para ler todas as pastas. O trecho de código a seguir mostra como ler um arquivo PST do Outlook e exibir recursivamente o conteúdo das pastas e das mensagens.

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

Extraindo Mensagens de Arquivos PST

Este artigo mostra como ler arquivos PST do Microsoft Outlook e extrair mensagens. As mensagens são então salvas em disco no formato MSG. O artigo também mostra como extrair um número específico de mensagens de um arquivo PST. Use um método recursivo para navegar por todas as pastas (incluindo pastas aninhadas) e chamar o PersonalStorage.extractMessage() método para obter mensagens do Outlook em uma instância do MapiMessage classe. Depois disso, chame o MapiMessage.save() método para salvar a mensagem tanto em disco quanto em fluxo no formato MSG. O trecho de código a seguir mostra como extrair mensagens de um arquivo 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);
        }
    }
}

Salvando Mensagens Diretamente do PST para Fluxo

Para salvar mensagens de um arquivo PST diretamente para um fluxo, sem extrair o MsgInfo das mensagens, use o saveMessageToStream() método. O trecho de código a seguir mostra como salvar mensagens diretamente do PST para um fluxo.

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

Extraindo n Mensagens de um Arquivo PST

O trecho de código a seguir mostra como extrair um determinado número de mensagens de um PST. Basta informar o índice da primeira mensagem e o número total de mensagens a ser extraído.

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

Obter Número Total de Itens de um Arquivo PST

Aspose.Email fornece o GetTotalItemsCount() método do PersonalStorage.Store propriedade. Ela retorna o número total de itens de mensagem contidos no PST.

O exemplo de código a seguir mostra como recuperar a contagem total de itens (mensagens, compromissos, contatos, etc.) armazenados no arquivo PST:

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

Excluir Itens de Arquivos PST

Adicionar Mensagens a Arquivos PST mostrou como adicionar mensagens a arquivos PST. É, claro, também possível excluir itens (conteúdos) de um arquivo PST e pode ser desejável excluir mensagens em massa. Itens de um arquivo PST podem ser excluídos usando o FolderInfo.deleteChildItem() método. A API também fornece FolderInfo.deleteChildItems() método para excluir itens em massa do arquivo PST.

Excluindo Mensagens de Arquivos PST

Este artigo mostra como Usar o FolderInfo classe para acessar pastas específicas em um arquivo PST. Para excluir mensagens da subpasta Enviados de um arquivo PST previamente carregado ou criado:

  1. Crie uma instância do FolderInfo classe e carregue‑a com o conteúdo da subpasta Enviados.
  2. Exclua mensagens da pasta Enviados chamando o FolderInfo.deleteChildItem() método e passando o MessageInfo.EntryId como parâmetro. O trecho de código a seguir mostra como excluir mensagens da subpasta Enviados de um arquivo 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");
    }
}

Excluindo Pastas de Arquivos PST

Você pode excluir uma pasta PST movendo‑a para a pasta Itens Excluídos.

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

A vantagem deste método é que a pasta excluída pode ser facilmente recuperada.

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

Você também pode remover permanentemente uma pasta da pasta Itens Excluídos, se necessário.

deletedItemsFolder.deleteChildItem(emptyFolder.getEntryId());

O deleteChildItem() método pode ser usado para quaisquer pastas se você quiser excluir imediatamente e permanentemente uma subpasta, contornando a pasta Itens Excluídos.

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

Excluir Itens em Massa de um Arquivo PST

A API Aspose.Email pode ser usada para excluir itens em massa de um arquivo PST. Isso é conseguido usando o deleteChildItems() método que aceita uma lista de itens Entry ID referentes aos itens a serem excluídos. O trecho de código a seguir mostra como excluir itens em massa de um arquivo 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);
}

Enumerar e Recuperar Mensagens Suavemente Excluídas do PST

É possível recuperar mensagens excluídas permanentemente com Aspose.Email para Java. Sua API permite enumerar mensagens suavemente excluídas em arquivos PST. Itens suavemente excluídos são mensagens que foram excluídas duas vezes — primeiro movidas para a pasta Itens Excluídos e depois removidas de lá. Essas mensagens ainda são recuperáveis, e Aspose.Email fornece uma forma conveniente de acessá‑las. O PersonalStorage.findAndEnumerateSoftDeletedItems() método retorna uma coleção de RestoredItemEntry objetos. Cada entrada contém:

  • MapiMessage item — a mensagem recuperada.
  • String FolderId - o identificador da pasta onde a mensagem originalmente pertencia.

O exemplo de código a seguir demonstra como enumerar itens de e‑mail suavemente excluídos (recuperáveis) em arquivos 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("-----------------------------------");
    }
}

Pesquisar Mensagens e Pastas em um PST por Critério

Arquivos de Armazenamento Pessoal (PST) podem conter uma enorme quantidade de dados e pesquisar por dados que atendam a um critério específico em arquivos tão grandes requer incluir múltiplos pontos de verificação no código para filtrar a informação. Com o PersonalStorageQueryBuilder classe, Aspose.Email torna possível pesquisar registros específicos em um PST com base em critérios de pesquisa especificados. Um PST pode ser pesquisado por mensagens usando parâmetros de pesquisa como remetente, destinatário, assunto, importância da mensagem, presença de anexos, tamanho da mensagem e até ID da mensagem. O PersonalStorageQueryBuilder também pode ser usado para pesquisar subpastas.

Procurando Mensagens e Pastas no PST

O trecho de código a seguir mostra como usar o PersonalStorageQueryBuilder classe para buscar conteúdos em um PST com base em diferentes critérios de pesquisa. Por exemplo, mostra a pesquisa em um PST baseada em:

  • Importância da mensagem.
  • Classe da mensagem.
  • Presença de anexos.
  • Tamanho da mensagem.
  • Data da mensagem.
  • Mensagens não lidas.
  • Mensagens não lidas com anexos, e
  • pastas com nome de subpasta específico.
// 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());
}

Procurando uma String no PST com o Parâmetro de Ignorar Maiúsculas/Minúsculas

O trecho de código a seguir mostra como pesquisar uma string no PST com o parâmetro de ignorar maiúsculas/minúsculas.

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

Procurando Assuntos de Mensagens por Múltiplas Palavras‑Chave em um Arquivo PST

Você pode usar MailQueryBuilder.or método para encontrar mensagens com um assunto que contenha ao menos uma das palavras especificadas, como mostrado abaixo:

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

Recuperação Paginada de Conteúdos de Pastas PST

Melhore o desempenho da sua aplicação e o controle ao navegar por pastas grandes. Recupere o conteúdo da pasta de forma paginada usando a sobrecarga do Aspose.Email do getContents método. Este método - FolderInfo.getContents(MailQuery query, int startIndex, int count) - recupera um subconjunto de mensagens que correspondem à consulta especificada, iniciando de um índice dado e limitado por uma contagem. O exemplo de código a seguir demonstra a recuperação paginada e o processamento de mensagens filtradas de uma pasta 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());
        }
    }
}

Mover Itens para Outras Pastas do Arquivo PST

Aspose.Email torna possível mover itens de uma pasta de origem para outra pasta no mesmo arquivo de Armazenamento Pessoal (PST). Isso inclui:

  • Movendo uma pasta especificada para uma nova pasta pai.
  • Movendo uma mensagem especificada para uma nova pasta.
  • Movendo o conteúdo para uma nova pasta.
  • Movendo subpastas para uma nova pasta pai.

O trecho de código a seguir mostra como mover itens, como mensagens e pastas, de uma pasta de origem para outra pasta no mesmo arquivo 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);
}

Atualizando Propriedades de Mensagens em um Arquivo PST

Às vezes é necessário atualizar certas propriedades de mensagens, como alterar o assunto, marcar a importância da mensagem e similares. Atualizar uma mensagem em um arquivo PST, com tais mudanças nas propriedades da mensagem, pode ser feito usando o FolderInfo.changeMessages método. Este artigo mostra como atualizar mensagens em massa em um arquivo PST para alterações nas propriedades. O trecho de código a seguir mostra como atualizar propriedades de mensagens em modo em lote para várias mensagens em um arquivo 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);

Atualizando propriedades personalizadas em um arquivo PST

Às vezes é necessário marcar itens que foram processados dentro do arquivo PST. A API Aspose.Email permite fazer isso usando MapiProperty e MapiNamedProperty. Os métodos a seguir são úteis para alcançar isso.

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

Extrair anexos sem extrair a mensagem completa

A API Aspose.Email pode ser usada para extrair anexos de mensagens PST sem extrair a mensagem completa primeiro. O ExtractAttachments método de PersonalStorage pode ser usado para isso. O trecho de código a seguir mostra como extrair anexos sem extrair a mensagem completa.

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

Adicionando arquivos ao PST

A funcionalidade principal do Microsoft Outlook é gerenciar e‑mails, calendários, tarefas, contatos e entradas de diário. Além disso, arquivos também podem ser adicionados a uma pasta PST e o PST resultante mantém registro dos documentos adicionados. O Aspose.Email oferece a possibilidade de adicionar arquivos a uma pasta da mesma forma que se adicionam mensagens, contatos, tarefas e entradas de diário ao PST. O trecho de código a seguir mostra como adicionar documentos a uma pasta PST usando o 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);
}
Ler e Converter Arquivo OST do Outlook Trabalhando com Contatos em Arquivo PST