Documentation – עבודה עם קבצי אחסון Outlook

Java: צור PST חדש, הוסף תתי‑תיקיות והודעות

Mon, 01 Jan 0001 00:00:00 +0000

בנוסף לניתוח קובץ PST קיים, Aspose.Email מספקת את האמצעים ליצירת קובץ PST מאפס. מאמר זה מדגים כיצד ליצור קובץ Outlook PST ולהוסיף לו תת‑תיקייה.

השתמש ב- PersonalStorage מחלקה ליצירת קובץ PST במיקום מסוים על דיסק מקומי. ליצירת קובץ PST מההתחלה:

צור PST באמצעות ה‑ PersonalStorage.create() שיטה.
הוסף תיקיית משנה בשורש קובץ ה‑PST על ידי גישה לתיקיית Root ולאחר מכן קריאה ל‑ addSubFolder() שיטה.

קוד הדוגמה הבא מראה כיצד ליצור קובץ PST ולהוסיף תיקיית משנה בשם Inbox.

// Create new PST
try (PersonalStorage pst = PersonalStorage.create(path, FileFormatVersion.Unicode)) {
    // Add new folder "Test"
    pst.getRootFolder().addSubFolder("Inbox");
}

יצירת PST בגודל יותר מ‑2Gb באמצעות OutputStream

משתמשי Aspose.Email יכולים לייעל את מטמון ה‑PST הפנימי באמצעות הקונסטרוקטור של PersonalStorage:

blockSize - גודל הבלוק האופטימלי להרחבת מחסנית המטמון (בבתים).

PersonalStorage create(OutputStream stream, int blockSize, /*FileFormatVersion*/int version)

צמצום גודל ההודעה וגודל קובץ PST שנוצר

Aspose.Email מציע אפשרות לכווץ את תוכן הגוף, מה שיכול לסייע בצמצום גודל ההודעה. זה יכול להיות שימושי במיוחד בשליחת הודעות גדולות או בעבודה עם רוחב פס או אחסון מוגבל. למטרה זו, הספרייה מספקת את פרמטר הכיווץ המופיע בשיטות הבאות:

MapiMessageItemBase.setBodyContent(String content, /BodyContentType/int contentType, boolean compression) - מגדיר את תוכן הגוף.
MapiMessageItemBase.setBodyRtf(String content, boolean compression) - מקבל או מגדיר את טקסט ההודעה בפורמט RTF.

קטע הקוד למטה מציג כיצד להשתמש בכיווץ RTF בעת הגדרת גוף הודעת MAPI:

MapiMessage msg = new MapiMessage("from@doamin.com", "to@domain.com", "subject", "body");
// set the html body and keep it compressed
// this will reduce the message size
msg.setBodyContent(htmlBody, BodyContentType.Html, true);

יצירת PersonalStorage בהתבסס על זרם SeekableByteChannel

Aspose.Email for Java מאפשר לעבוד עם קבצי Personal Storage (PST) באמצעות java.nio.channels. הוא מאפשר ליצור מופע PersonalStorage באמצעות זרם SeekableByteChannel. קטע הקוד הבא מדגים כיצד ליצור מופע PersonalStorage בהתבסס על זרם FileChannel, להוסיף תיקיית משנה בשם "messageFolder" לתיקיית השורש, ולייבא הודעות מקבצים בתיקייה "messageFolder":

try (RandomAccessFile raf = new RandomAccessFile("test.pst", "rw")) {
    FileChannel channel = raf.getChannel();
    try (PersonalStorage pst = PersonalStorage.create(channel, FileFormatVersion.Unicode)) {
        FolderInfo messageFolder = pst.getRootFolder().addSubFolder("messageFolder");

        for (File f : new File("messageFolder").listFiles()) {
            messageFolder.addMessage(MapiMessage.load(f.getAbsolutePath()));
        }
    }
}

שינוי מחלקת מכולת תיקייה

לפעמים יש צורך לשנות את מחלקת התיקייה. דוגמה נפוצה היא כאשר הודעות מסוגים שונים (פגישות, הודעות וכד’) מתווספות לאותה תיקייה. במקרים כאלו, יש לשנות את מחלקת התיקייה עבור כל האלמנטים בתיקייה כדי שהצגתן תהיה נכונה. קטע הקוד הבא מראה כיצד לשנות את מחלקת המכולה של תיקייה ב‑PST למטרה זו.

try (PersonalStorage pst = PersonalStorage.fromFile("PersonalStorage1.pst")) {
    FolderInfo folder = pst.getRootFolder().getSubFolder("Inbox");

    folder.changeContainerClass("IPF.Note");
}

הוספת הודעות במצב הצטברות עם ביצועים משופרים

הוספת הודעות בודדות ל‑PST גוררת יותר פעולות קלט/פלט לדיסק ועלולה להאט את הביצועים. לשיפור ביצועים, ניתן להוסיף הודעות ל‑PST במצב הצטברות כדי למזער פעולות קלט/פלט. ה‑ addMessages(Iterable messages) שיטה מאפשרת להוסיף הודעות במצב הצטברות וניתן להשתמש בה במקרים הבאים. בנוסף, ה‑ MessageAdded אירוע מתרחש כאשר הודעה מתווספת לתיקייה.

הוספת הודעות מ‑PST אחר

כדי להוסיף הודעות מ‑PST אחר, השתמש ב‑ FolderInfo.enumerateMapiMessages() שיטה שמחזירה Iterable<MapiMessage>:

try (PersonalStorage srcPst = PersonalStorage.fromFile("source.pst", false)) {
    try (PersonalStorage destPst = PersonalStorage.fromFile("destination.pst")) {

        // Get the folder by name
        FolderInfo srcFolder = srcPst.getRootFolder().getSubFolder("SomeFolder");
        FolderInfo destFolder = destPst.getRootFolder().getSubFolder("SomeFolder");

        destFolder.MessageAdded.add(new MessageAddedEventHandler() {
            // Handles the MessageAdded event.
            public void invoke(Object sender, MessageAddedEventArgs e) {
                System.out.println("Added: " + e.getEntryId());
            }
        });
        destFolder.addMessages(srcFolder.enumerateMapiMessages());
    }
}

הוספת הודעות מספרייה

כדי להוסיף הודעות מספרייה, צור את getMessages(String pathToDir) שיטה שמחזירה Iterable<MapiMessage>:

// Read messages from directory.
static Iterable<MapiMessage> getMessages (String pathToDir)
{
    return Arrays.stream(listDirectory(pathToDir, "*.msg"))
            .map(MapiMessage::load).collect(Collectors.toList());
}

try ( PersonalStorage pst = PersonalStorage.fromFile("storage.pst")) {
    FolderInfo folder = pst.getRootFolder().getSubFolder("SomeFolder");
    folder.MessageAdded.add(new MessageAddedEventHandler() {
        // Handles the MessageAdded event.
        public void invoke(Object sender, MessageAddedEventArgs e) {
            System.out.println("Added: " + e.getEntryId());
        }
    });
    folder.addMessages(getMessages("MessageDirectory"));
}

Java: קרא והמר קובץ Outlook OST

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email מספק API לקריאת קובצי Microsoft Outlook OST. ניתן לטעון קובץ OST מהדיסק או מזרם לתוך מופע של PersonalStorage מחלקה לקבלת מידע על תכולתה, לדוגמה תיקיות, תתי‑תיקיות והודעות. Microsoft Outlook יוצר קובץ PST לאחסון הודעות כאשר נעשה שימוש בשרתים POP3 או IMAP להורדת הודעות. הוא יוצר קובץ OST כאשר השרת הוא Microsoft Exchange. OST תומך בגודל קבצים גדול יותר מאשר קבצי PST.

קריאת קובצי OST

תהליך קריאת קובץ OST עם Aspose.Email הוא בדיוק זהה לתהליך קריאת קובץ PST. אותו קוד יכול לקרוא קבצי PST ו-OST כאחד: פשוט ספק את שם הקובץ הנכון ל- PersonalStorage.fromFile() מתודה. הקוד הבא מראה כיצד לקרוא קבצי OST.

המרת OST ל‑PST

נסו זאת!

המרת אימיילים וארכיוני הודעות באופן מקוון בחינם יישום המרה של Aspose.Email.

Aspose.Email מאפשר המרת קובץ OST ל‑PST בשורת קוד אחת. באופן דומה, ניתן ליצור קובץ OST מתוך קובץ PST באמצעות אותה שורת קוד עם ה- FileFormat enumerator. כעת, ה-API תומך בהמרת פורמטים של OST ל‑PST למעט OST 2013/2016. הקטע הקוד הבא מראה כיצד להמיר OST ל‑PST.

לביצוע פעולות נוספות עם קובצי OST, אנא הפנה לדפים הבאים:

המרת PST ל‑OST

המרה מ‑PST ל‑OST אינה נתמכת ב‑Aspose.Email מכיוון ש‑OST תמיד נוצר על‑ידי Outlook בעת הוספת חשבון וסנכרון עם שרת הדואר. ההבדל בין קבצי PST ל‑OST הוא ש‑PST זמין רק באופן מקומי, בעוד שתוכן ה‑OST זמין גם על שרת הדוא"ל. לכן אין צורך להמיר PST ל‑OST לשימוש מקומי. אך ניתן לייבא PST לחשבון קיים באמצעות אשף ה‑Import/Export ב‑Outlook.

Java: עבודה עם הודעות בקובץ PST

Mon, 01 Jan 0001 00:00:00 +0000

הוספת הודעות לקבצי PST

צור קובץ PST חדש והוסף תיקיות משנה הראה כיצד ליצור קובץ PST ולהוסיף לו תיקיית משנה. עם Aspose.Email ניתן להוסיף הודעות לתיקיות משנה של קובץ PST שיצרת או טענת. מאמר זה מוסיף שתי הודעות מהדיסק לתיקיית המשנה Inbox של PST. השתמש ב‑ PersonalStorage ו FolderInfo מחלקות להוספת הודעות לקבצי PST. כדי להוסיף הודעות לתיקיית Inbox של קובץ PST:

צור מופע של המחלקה FolderInfo וטען אותו בתכולת תיקיית Inbox.
הוסף הודעות מהדיסק לתיקיית Inbox באמצעות קריאה ל‑ FolderInfo.addMessage() מתודה. ה‑ FolderInfo המחלקה מציגה את addMessages שיטה המאפשרת להוסיף מספר גדול של הודעות לתיקייה, מה שמפחית פעולות קלט/פלט לדיסק ומשפר ביצועים. דוגמה מלאה ניתן למצוא למטה, ב הוספת הודעות גורפות.

קטעי הקוד למטה מראים כיצד להוסיף הודעות לתיקית משנה של PST בשם 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"));

הוספת הודעות גורפות

הוספת הודעות בודדות ל‑PST גורמת ליותר פעולות קלט/פלט לדיסק ולכן עשויה להאט את הביצועים. לשיפור הביצועים, ניתן להוסיף הודעות ל‑PST במצב גורף כדי למזער פעולות קלט/פלט. ה addMessages(Iterable messages) השיטה מאפשרת לך להגדיר טווח של הודעות שיתווספו ל‑PST לשיפור ביצועים וניתן להשתמש בה בתרחישים הבאים. בנוסף, אירוע MessageAdded מתרחש כאשר הודעה מתווספת לתיקייה.

טעינת הודעות מהדיסק

קטטע הקוד הבא מראה לך כיצד לטעון הודעות מהדיסק.

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

קטטע הקוד הבא מראה לך כיצד ליצור מימוש 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());
    }
}

הוספת הודעות מ‑PST אחר

להוספת הודעות מ‑PST אחר, השתמש ב‑ FolderInfo.enumerateMapiMessages() שיטה המחזירה Iterable. קטע הקוד הבא מראה כיצד להוסיף הודעות ממקבץ 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());
}

קבלת מידע על הודעות מקובץ Outlook PST

ב‑ קריאת קובץ Outlook PST וקבלת מידע על תיקיות ותיקיות משנה, דנו בטעינת קובץ Outlook PST ובדפדוף בתיקיות שלו כדי לקבל את שמות התיקיות ומספר ההודעות שבהם. מאמר זה מסביר כיצד לקרוא את כל התיקיות ותיקיות המשנה בקובץ PST ולהציג מידע על הודעות, לדוגמה נושא, שולח ונמענים. ה‑ FolderInfo.getContents() שיטה משמשת להצגת מידע קצר על הודעה כגון נושא, שולח, נמענים. מבחינת ביצועים, זו האפשרות המתאימה ביותר לקבלת מידע ראשוני על הודעות. כדי חילוץ נתוני ההודעה המלאים, ה‑ PersonalStorage.extractMessage() מסופקת שיטה. קובץ Outlook PST עשוי להכיל תיקיות מקוננות. כדי לקבל מידע על הודעות מהן, וכן מהתיקיות ברמה העליונה, השתמש בשיטה ריקורסיבית לקריאת כל התיקיות. קטע הקוד הבא מראה כיצד לקרוא קובץ Outlook 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 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);
        }
    }
}

חילוץ הודעות מקבצי PST

מאמר זה מראה כיצד לקרוא קבצי PST של Microsoft Outlook ו‑ לחצל הודעות. ההודעות נשמרות לאחר מכן לדיסק בפורמט MSG. המאמר גם מראה כיצד לחלץ מספר ספציפי של הודעות מקובץ PST. השתמש בשיטה ריקורסיבית לעבור על כל התיקיות (כולל תיקיות מקוננות) וקרא ל‑ PersonalStorage.extractMessage() שיטה לקבל הודעות Outlook לתוך מופע של MapiMessage מחלקה. לאחר ذلك, קרא ל‑ MapiMessage.save() שיטה לשמור את ההודעה אל דיסק או זרם בפורמט MSG. קטע הקוד הבא מראה כיצד לחלץ הודעות מקובץ 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);
        }
    }
}

שמירת הודעות ישירות מ‑PST ל‑Stream

כדי לשמור הודעות מקובץ PST ישירות ל‑stream, ללא חילוץ MsgInfo עבור ההודעות, השתמש ב‑ saveMessageToStream() שיטה. קטע הקוד הבא מראה כיצד לשמור הודעות ישירות מ‑PST ל‑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);
        }
    }
}

חילוץ n הודעות מקובץ PST

קטע הקוד הבא מראה כיצד לחלץ מספר מסוים של הודעות מ‑PST. פשוט ספק את האינדקס של ההודעה הראשונה ואת מספר ההודעות הכולל שברצונך לחלץ.

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

קבלת המספר הכולל של פריטים מקובץ PST

Aspose.Email מספקת את GetTotalItemsCount() שיטה של PersonalStorage.Store מאפיין. הוא מחזיר את המספר הכולל של פריטי הודעה הכלולים ב‑PST.

דוגמת הקוד הבאה מראה כיצד לאחזר את הספירה הכוללת של פריטים (הודעות, פגישות, אנשי קשר וכו’) המאוכסנים בקובץ PST:

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

מחיקת פריטים מקבצי PST

Add Messages to PST Files הראה כיצד להוסיף הודעות לקבצי PST. כמובן שניתן גם למחוק פריטים (תוכן) מקובץ PST ולעיתים רצוי למחוק הודעות במקצה. ניתן למחוק פריטים מקובץ PST באמצעות FolderInfo.deleteChildItem() שיטה. ה‑API גם מציע FolderInfo.deleteChildItems() שיטה למחיקת פריטים במקצה מתוך קובץ PST.

מחיקת הודעות מקבצי PST

מאמר זה מראה כיצד להשתמש ב‑ FolderInfo מחלקה לגישה לתיקיות ספציפיות בקובץ PST. למחיקת הודעות מתת‑תיקיית Sent של קובץ PST שכבר נטען או נוצר:

צור מופע של FolderInfo מחלקה וטעון אותה בתוכן של תת‑תיקיית Sent.
מחק הודעות מתיקיית Sent על ידי קריאה ל‑ FolderInfo.deleteChildItem() שיטה והעברת ה‑ MessageInfo.EntryId כפרמטר. קטע הקוד הבא מראה כיצד למחוק הודעות מתיקיית תת‑תיקיית Sent בקובץ 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");
    }
}

מחיקת תיקיות מקבצי PST

ניתן למחוק תיקיית PST על ידי העברתها לתיקיית הפריטים המחוקים.

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

היתרון של שיטה זו הוא שניתן לשחזר בקלות את התיקייה המחוקה.

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

אתה יכול גם להסיר לצמיתות תיקייה מתיקיית הפריטים המחוקים, אם יש צורך.

deletedItemsFolder.deleteChildItem(emptyFolder.getEntryId());

ה deleteChildItem() שיטה זו ניתנת לשימוש עבור כל תיקייה אם ברצונך למחוק מיידית ובצורה קבועה תיקיית משנה, תוך עקיפת תיקיית הפריטים המחוקים.

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

מחיקת פריטים במקצה מתוך קובץ PST

ניתן להשתמש ב‑Aspose.Email API למחיקת פריטים במקצה מתוך קובץ PST. זה מתבצע באמצעות ה‑ deleteChildItems() שיטה שמקבלת רשימה של פריטי Entry ID המתייחסים לפריטים שברצונך למחוק. קטע הקוד הבא מראה כיצד למחוק פריטים במקצה מתוך קובץ 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);
}

סיוג ושחזור הודעות שנמחקו רך מ‑PST

ניתן לאחזר הודעות מנוחות שנמחקו לצמיתות באמצעות Aspose.Email for Java. ה‑API שלו מאפשר למנות הודעות שנמחקו רך בקבצי PST. פריטים שנמחקו רך הם הודעות שנמחקו פעמיים - תחילה הועברו לתיקיית פריטים מחוקים ואז הוסרו משם. הודעות אלה עדיין ניתנות לשחזור, ו‑Aspose.Email מציע דרך נוחה לגשת אליהן. ה‑ PersonalStorage.findAndEnumerateSoftDeletedItems() השיטה מחזירה אוסף של RestoredItemEntry אובייקטים. כל ערך מכיל:

MapiMessage item — ההודעה המשוחזרת.
String FolderId - המזהה של התיקייה שאליה המקורית ההודעה השתייכה.

דוגמת הקוד הבאה מדגימה כיצד למנות פריטי אימייל שנמחקו באופן רך (ניתנים לשחזור) בקבצי 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("-----------------------------------");
    }
}

חיפוש הודעות ותיקיות ב‑PST לפי קריטריון

קובצי Personal Storage (PST) יכולים להכיל כמות עצומה של נתונים וחיפוש אחר נתונים העונים על קריטריונים ספציפיים בקבצים גדולים כאלה דורש לכלול נקודות בדיקה מרובות בקוד כדי לסנן את המידע. עם ה‑ PersonalStorageQueryBuilder מחלקה, Aspose.Email מאפשר לחפש רשומות ספציפיות ב‑PST על בסיס קריטריונים מוגדרים. ניתן לחפש הודעות ב‑PST לפי פרמטרי חיפוש כגון שולח, נמען, נושא, חשיבות הודעה, קיום קבצים מצורפים, גודל הודעה ואף מזהה הודעה. ה‑ PersonalStorageQueryBuilder גם ניתן להשתמש בו לחיפוש תיקיות משנה.

חיפוש הודעות ותיקיות ב‑PST

קטעת הקוד הבא מראה לך כיצד להשתמש ב- PersonalStorageQueryBuilder מחלקה לחיפוש תוכן ב‑PST בהתבסס על קריטריונים שונים. לדוגמה, מציג חיפוש 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/";

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

חיפוש מחרוזת ב‑PST עם פרמטר ההתעלמות מרגישות לאותיות

קטע הקוד הבא מראה כיצד לחפש מחרוזת ב‑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/";

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

חיפוש נושאי הודעות לפי מילות מפתח מרובות בקובץ PST

אתה יכול להשתמש ב MailQueryBuilder.or שיטה למציאת הודעות עם נושא המכיל לפחות אחד מהמילים המוגדרות כפי שמוצג למטה:

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

שליפה מדורגת של תוכן תיקיית PST

שפר את ביצועי האפליקציה והשליטה בעת ניווט בתיקיות גדולות. שלוף את תוכן התיקייה בצורה מדורגת באמצעות העמסת Aspose.Email של getContents שיטה. שיטה זו - FolderInfo.getContents(MailQuery query, int startIndex, int count) - מאחזר תת‑קבוצה של הודעות המתאימות לשאילתה המוגדרת, מתחיל מאינדקס מסוים ומוגבל במספר. דוגמת הקוד הבאה מדגימה שליפה בעמודים ועיבוד של הודעות מסוננות מתיקיית 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());
        }
    }
}

העברת פריטים לתיקיות אחרות בקובץ PST

Aspose.Email מאפשר להעביר פריטים מתיקייה מקור לתיקייה אחרת באותו קובץ אחסון אישי (PST). זה כולל:

העברת תיקייה ספציפית לתיקיית אב חדשה.
העברת הודעה ספציפית לתיקייה חדשה.
העברת התוכן לתיקייה חדשה.
העברת תיקיות משנה לתיקיית אב חדשה.

קטע הקוד הבא מראה כיצד להעביר פריטים כגון הודעות ותיקיות מתיקייה מקור לתיקייה אחרת באותו קובץ 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);
}

עדכון מאפייני הודעה בקובץ PST

לעיתים יש צורך לעדכן תכונות מסוימות של הודעות כגון שינוי הנושא, סימון חשיבות ההודעה וכדומה. עדכון הודעה בקובץ PST עם שינויים אלו בתכונות ההודעה ניתן לבצע באמצעות FolderInfo.changeMessages מתודה. מאמר זה מציג כיצד לעדכן הודעות במצב גורף בקובץ PST עבור שינויי תכונות. קוד הדוגמה הבא מראה כיצד לעדכן תכונות של הודעות במצב גורף למספר הודעות בקובץ 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);

עדכון תכונות מותאמות אישית בקובץ PST

לעיתים יש צורך לסמן פריטים שעובדו בתוך קובץ PST. API של Aspose.Email מאפשר לבצע זאת באמצעות MapiProperty ו‑MapiNamedProperty. השיטות הבאות מסייעות למימוש זאת.

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

חילוץ קבצים מצורפים ללא חילוץ ההודעה המלאה

ניתן להשתמש ב‑API של Aspose.Email כדי לחלץ קבצים מצורפים מהודעות PST ללא חילוץ ההודעה המלאה תחילה. ה‑ ExtractAttachments מתודה של PersonalStorage יכולים לשמש לכך. קוד הדוגמה הבא מראה כיצד לחלץ קבצים מצורפים בלי לחלץ את ההודעה המלאה.

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

הוספת קבצים ל‑PST

הפונקציונליות המרכזית של Microsoft Outlook היא ניהול אימיילים, לוחות שנה, משימות, אנשי קשר ורשומות ביומן. בנוסף, ניתן להוסיף קבצים לתיקיית PST וה‑PST שנוצר מתעד את המסמכים שנוספו. Aspose.Email מספקת אפשרות להוסיף קבצים לתיקייה באותו האופן בנוסף להוספת הודעות, אנשי קשר, משימות ורשומות ביומן ל‑PST. קוד הדוגמה הבא מראה כיצד להוסיף מסמכים לתיקיית PST בעזרת 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);
}

Java: עבודה עם אנשי קשר בקובץ PST

Mon, 01 Jan 0001 00:00:00 +0000

קריאת מספר אנשי קשר בפורמט VCard

דוגמת הקוד למטה מציגה כיצד לקרוא קובץ VCF, לבדוק אם הוא מכיל מספר אנשי קשר, ואם כן, לטעון את אנשי הקשר מהקובץ לרשימת אובייקטים מסוג VCardContact. הקוד משתמש בשיטות הבאות:

isMultiContacts(InputStream stream) - בודק האם זרם המקור מכיל מרובה אנשי קשר.
loadAsMultiple(String filePath, Charset encoding) - טוען רשימת אנשי קשר מקובץ מרובה אנשי קשר.
loadAsMultiple(InputStream stream, Charset encoding) - טוען רשימת אנשי קשר מזרם מרובה אנשי קשר.

try (InputStream stream = new FileInputStream("test.vcf")) {
    if (VCardContact.isMultiContacts(stream)) {
        List<VCardContact> contacts = VCardContact.loadAsMultiple(stream, Charset.forName("utf-8"));
    }
}

הוספת איש קשר ל‑PST

צור PST חדש, הוסף תתי‑תיקיות והודעות הודגם כיצד ליצור קובץ PST ולהוסיף אליו תת‑תיקייה. עם Aspose.Email אתה יכול להוסיף MapiContact לתיקיית המשנה Contacts של קובץ PST שיצרת או שטענת. להלן השלבים להוספה MapiContact ל‑PST:

צור MapiContact אובייקט.
הגדר את MapiContact מאפיינים באמצעות קונסטרוקטורים ושיטות שונות.
צור PST באמצעות ה‑ PersonalStorage.create() שיטה.
צור תיקייה מוגדרת מראש (Contacts) ברמת השורש של קובץ PST על‑ידי גישה לתיקיית השורש ולאחר מכן קריאה ל‑ addMapiMessageItem() שיטה.

קטע הקוד למטה מציג כיצד ליצור MapiContact ואז הוסף אותו לתיקיית אנשי הקשר של קובץ PST שנוצר זה עתה.

שמירת מידע אנשי קשר מקובץ PST בפורמט MSG

מאמר זה מציג כיצד לגשת למידע אנשי קשר מקובץ Microsoft Outlook PST ולשמור את אנשי הקשר לדיסק בפורמט MSG. לשם כך, השתמש ב‑ PersonalStorage ו MapiContact מחלקות לקבלה והצגה של מידע איש הקשר.

לצורך קבלת מידע על איש קשר:

טען את קובץ PST ב‑ PersonalStorage מחלקה.
עיין בתיקיית אנשי הקשר.
קבל את תוכן תיקיית אנשי הקשר כדי לקבל את איסוף ההודעות.
עבור על איסוף ההודעות.
קרא PersonalStorage.extractMessage() ולאחר מכן toMapiMessageItem() שיטה לקבלת מידע איש הקשר ב‑ MapiContact מחלקה.
השתמש MapiContact מאפיינים לגישה למידע איש הקשר.
הפעל את PersonalStorage.extractMessage() שיטה לקבלת מידע איש הקשר ב‑ MapiMessage מחלקה.
הפעל את MapiMessage.save() שיטה לשמירת איש הקשר לדיסק בפורמט MSG.

להלן קוד לדוגמה שמחזיר את כל מידע אנשי הקשר מהקובץ PST ושומרו בדיסק בפורמט MSG.

שמירת מידע יצירת קשר מ‑Outlook PST לדיסק בפורמט vCard

מאמר זה מציג כיצד לגשת למידע יצירת קשר מקובץ PST של Microsoft Outlook ולשמור את יצירת הקשר לדיסק בפורמט vCard (VCF). הוא משתמש ב‑ PersonalStorage ו MapiContact מחלקות לקבלת פרטי יצירת קשר.

להלן השלבים לקבלת מידע אנשי הקשר:

טען את קובץ PST ב‑ PersonalStorage מחלקה.
עיין בתיקיית אנשי הקשר.
קבל את תוכן תיקיית אנשי הקשר כדי לקבל את איסוף ההודעות.
עבור על איסוף ההודעות.
הפעל את PersonalStorage.extractMessage() שיטה לקבלת מידע איש הקשר ב‑ MapiContact מחלקה.
השתמש במאפייני ה‑ MapiContact מחלקה לגישה למידע איש הקשר.

התוכנית למטה טוענת קובץ PST מהדיסק ושומרת את כל אנשי הקשר בפורמט vCard (VCF). קבצי VCF יכולים לאחר מכן לשמש בכל תוכנה אחרת שיכולה לטעון קובץ vCard סטנדרטי. אם תפתח כל קובץ VCF ב‑Microsoft Outlook, הוא יראה כמו בתמונת המסך למטה.

|| | :- | |איור: vCard שנשמר עם Aspose.Email|

Java: עבודה עם פריטי יומן בקובץ PST

Mon, 01 Jan 0001 00:00:00 +0000

הוספת MapiCalendar ל‑PST

צור PST חדש, הוסף תתי‑תיקיות והודעות הודגם כיצד ליצור קובץ PST ולהוסיף לו תת‑תיקייה. עם Aspose.Email ניתן להוסיף MapiCalendar לתיקיית היומן של קובץ PST שיצרת או טעית.

להלן השלבים להוספה MapiCalendar ל‑PST:

צור MapiCalendar אובייקט.
הגדר את MapiCalendar תכונות באמצעות קונסטרוקטור ושיטות.
צור PST באמצעות ה‑ PersonalStorage.create() שיטה.
צור תיקייה מוגדרת מראש (Calendar) בשורש קובץ PST על ידי גישה לתיקיית השורש ולאחר מכן קריאה ל‑ addMapiMessageItem() שיטה.

קטע הקוד למטה מציג כיצד ליצור MapiCalendar ואז הוספתו לתיקיית היומן של קובץ PST חדש שנוצר.

שמירת פריטי יומן מ‑Outlook PST לדיסק בפורמט ICS

מאמר זה מציג כיצד לגשת לפריטי יומן מקובץ Outlook PST ולשמור את היומן לדיסק בפורמט ICS. הוא משתמש ב‑ PersonalStorage ו MapiCalendar מחלקות לקבלת מידע על היומן.

להלן השלבים לשמירת פריטי היומן:

טען את קובץ PST ב‑ PersonalStorage מחלקה.
עיון בתיקיית היומן.
קבל את תוכן תיקיית היומן כדי לקבל את אוסף ההודעות.
עבור על איסוף ההודעות.
הפעל את PersonalStorage.extractMessage() שיטה לקבלת מידע איש הקשר ב‑ MapiCalendar מחלקה.
הפעל את MapiCalendar.save() מתודה לשמירת פריט היומן לדיסק בפורמט ICS.

התוכנית שלהלן טוענת קובץ PST מהדיסק ושומרת את כל פריטי היומן בפורמט ICS. קבצי ה‑ICS ניתנים לשימוש בכל תוכנה אחרת שיכולה לטעון קובץ יומן סטנדרטי בפורמט ICS. אם תפתח קובץ ICS כלשהו ב‑Microsoft Outlook, הוא יראה כמו המסך שלמטה.

|| | :- | |איור: פריט יומן שנשמר באמצעות Aspose.Email|

חילוץ פריטי יומן מקובץ PST

מחלקת MapiCalendar מייצגת פריט יומן בתבנית MAPI של Microsoft Outlook. חילוץ הודעה מקובץ PST והמרתה לפריט הודעת MAPI. קוד הדוגמה הבא מחלץ פריט יומן מקובץ PST וממירו לאובייקט MapiCalendar להמשך טיפול או עיבוד:

MapiCalendar cal = (MapiCalendar) pst.extractMessage(messageInfo).toMapiMessageItem();

שמירת פריטי יומן בפורמט ICS עם חותמת זמן מקורית

השתמש בקוד למעלה כדי לחלץ פריט יומן מקובץ PST ולאחר מכן לציין אפשרויות נוספות לשמירתו כ‑ICS עם חותמת זמן מקורית באמצעות setKeepOriginalDateTimeStamp שיטה של MapiCalendarIcsSaveOptions מחלקה:

MapiCalendar cal = (MapiCalendar) pst.extractMessage(messageInfo).toMapiMessageItem();

if (cal != null) {
    MapiCalendarIcsSaveOptions so = new MapiCalendarIcsSaveOptions();
    so.setKeepOriginalDateTimeStamp(true);
    cal.save("cal.ics", so);
}

שינוי/מחיקת מופעים מרצפים

Java: עבודה עם MapiTask ב‑PST

Mon, 01 Jan 0001 00:00:00 +0000

הוספת MapiTask ל‑PST

צור PST חדש, הוסף תתי‑תיקיות והודעות הודגם כיצד ליצור קובץ PST ולהוסיף לו תת‑תיקייה. עם Aspose.Email ניתן להוסיף MapiTask לתת‑תיקיית המשימות של קובץ PST שיצרת או טעית.

להלן השלבים להוספת MapiTask ל‑PST:

צור MapiTask אובייקט.
הגדר את MapiTask מאפיינים באמצעות קונסטרוקטור ושיטות שונות.
צור PST באמצעות ה‑ PersonalStorage.create() שיטה.
צור תיקייה מוגדרת מראש (Tasks) בשורש קובץ PST על ידי גישה לתיקיית Root ולאחר מכן קריאה ל‑ addMapiMessageItem() שיטה.

קטע הקוד למטה מציג כיצד ליצור MapiTask ואז הוספתו לתיקיית המשימות של קובץ PST חדש שנוצר.

Java: עבודה עם MapiJournal ב‑PST

Mon, 01 Jan 0001 00:00:00 +0000

הוספת MapiJournal ל‑PST

צור PST חדש, הוסף תתי‑תיקיות והודעות הראה כיצד ליצור קובץ PST ולהוסיף לו תיקיית משנה. עם Aspose.Email ניתן להוסיף MapiJournal לתיקיית המשנה Journal של קובץ PST שיצרת או שטענת. להלן השלבים להוספת MapiJournal ל‑PST:

צור MapiJournal אובייקט.
הגדר את MapiJournal תכונות באמצעות קונסטרוקטור ושיטות.
צור PST באמצעות ה‑ PersonalStorage.create() שיטה.
צור תיקייה מוגדרת מראש (Journals) בשורש קובץ ה‑PST על ידי גישה לתיקיית השורש ולאחר מכן קריאה ל‑ addMapiMessageItem() שיטה.

קטע הקוד למטה מציג כיצד ליצור MapiJournal וגם להוסיף אותו לתיקיית Journal של קובץ PST חדש שנוצר.

הוספת קבצים מצורפים ל‑MapiJournal

ניתן גם להוסיף קבצים מצורפים לפריטי יומן MAPI. הקוד למטה מראה איך.

Java: עבודה עם MapiNote ב‑PST

Mon, 01 Jan 0001 00:00:00 +0000

הוספת MapiNote ל‑PST

צור PST חדש, הוסף תתי‑תיקיות והודעות הודגם כיצד ליצור קובץ PST ולהוסיף לו תת‑תיקייה. עם Aspose.Email ניתן להוסיף MapiNote לתת‑תיקיית ההערות של קובץ PST שיצרת או טעית.

להלן השלבים להוספת MapiNote ל‑PST:

צור תבנית MapiNote באמצעות Microsoft Outlook ושמור אותה כקובץ MSG.
טען הודעת MSG שנשמרה לתוך MapiMessage אובייקט.
צור MapiNote אובייקט וטען את תבנית ההודעה MSG.
הגדר את MapiNote מאפיינים באמצעות שיטות שונות.
צור PST באמצעות ה‑ PersonalStorage.create() שיטה.
צור תיקייה מוגדרת מראש (Notes) בשורש קובץ PST על‑ידי גישה לתיקיית השורש ולאחר מכן קריאה ל‑ addMapiMessageItem() שיטה.

קטע הקוד למטה מציג כיצד ליצור MapiNote ואז הוספתו לתיקיית ההערות של קובץ PST חדש שנוצר.

Java: פיצול ומיזוג קבצי PST

Mon, 01 Jan 0001 00:00:00 +0000

API של Aspose.Email מספק יכולת לפצל קובץ PST יחיד למספר קבצי PST בגודל רצוי. הוא יכול גם למזג מספר קבצי PST לקובץ PST אחד. ניתן לעקוב אחרי פעולות הפיצול והמיזוג של PSTs על ידי הוספת אירועים לפעולות אלו.

פצל ומזג קבצי PST

דוגמאות הקוד הבאות ממחישות כיצד לפצל קובץ PST גדול לחלקים קטנים מרובים של קבצי PST.

מיזוג מספר PSTs לקובץ PST אחד

דוגמת הקוד הבאה מראה כיצד ניתן למזג מספר קבצי PST לקובץ PST גדול יחיד.

נסו זאת!

מזג ושילב מספר קבצי אימייל לאחד עם החינמי Aspose.Email Merger App.

מזג תיקיות מקובץ PST אחר

API של Aspose.Email מאפשר מיזוג תיקיות מלאות מקובץ PST אחר ל‑PST יעד, כך שנוצר PST בגודל גדול.

פצל PST בהתבסס על קריטריון מוגדר

שיטות עזר

Java: עבודה עם מאפייני הגנת סיסמה של PST

Mon, 01 Jan 0001 00:00:00 +0000

Microsoft Outlook מאפשר למשתמשים להגן בסיסמא על קבצי PST כדי להגביל את הגישה אליהם. Aspose.Email יכול לזהות הגנה בסיסמא על קובץ PST. מאמר זה מציג כיצד לבדוק אם PST מוגן בסיסמא וכן כיצד לבדוק אם הסיסמא שהוגדרה נכונה.

בדוק הגנת סיסמה

ה MapiPropertyTag.PR_PST_PASSWORD ערך מתוך ה‑ MapiPropertyTag מחלקה משמשת לבדוק אם קובץ מוגן בסיסמא.

גיבוש CRC-32 של מחרוזת הסיסמא נשמר במאפיין PidTagPstPassword (תג = 0x67ff0003) ב‑ MessageStore. אם מאפיין זה קיים ולא אפסי, אז ה‑PST מוגן בסיסמא.

קטע הקוד הבא מראה כיצד לבדוק אם קובץ PST מוגן בסיסמא והאם המחרוזת הנתונה היא סיסמא תקפה עבור ה‑PST.

קטע הקוד למטה מציג שתי פונקציות, הראשונה בודקת האם PST מוגן בסיסמא, והשנייה מציגה כיצד לבדוק האם סיסמא שסופקה נכונה או לא.

הסר/אפס את מאפייני PR_PST_PASSWORD

הסרת ה‑ PR_PST_PASSWORD לא ניתן לבצע את המאפיין מאחר שמאפיינים אחרים הוסרו ממאגר ההודעות. במקום זאת, עלינו לקבוע את ערכו של אפס (0) כדי להסירו. המאפיין "Store" של מחלקת PST מאפשר גישה למאפייני האחסון של PST במקום למאפייני MessageStoreProperties של PST במקרה זה.

הגדר/שנה סיסמא ל‑PST

קטע הקוד הבא מראה כיצד להגדיר סיסמא על קבצי PST.

אימות סיסמה עבור קבצי PST מוגנים בסיסמא

Aspose.Email מאפשר למפתחים לבדוק אם קובץ PST מוגן בסיסמא ואם הסיסמא הנתונה נכונה או לא. לשם כך, ה‑API מספק את PersonalStorage.Store.IsPasswordProtected מאפיין ו‑ PersonalStorage.Store.IsPasswordValid() מתודה. ה‑ PersonalStorage.Store.IsPasswordProtected מאפיין מחזיר true אם קובץ PST מוגן בסיסמא ו‑false אם אינו מוגן. ה‑ PersonalStorage.Store.IsPasswordValid() מתודה שלוקחת את מחרוזת הסיסמא כפרמטר ומחזירה true אם הסיסמא נכונה ו‑false אם היא שגויה.

קטע הקוד הבא מדגים את השימוש ב‑ PersonalStorage.Store.IsPasswordProtected מאפיין ו‑ PersonalStorage.Store.IsPasswordValid() שיטה.

קוד לדוגמא

פלט קונסול

האחסון מוגן בסיסמא - True הסיסמא תקפה - True

Java: קריאת קובץ Outlook PST וקבלת מידע על תיקיות ותיקיות משנה

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email for Java מאפשר לך לקרוא קבצי Microsoft Outlook PST. ניתן לטעון קובץ PST מהדיסק או מזרם למופע של PersonalStorage מחלקה וקבלת המידע על תוכנה, לדוגמה, תיקיות, תיקיות משנה והודעות.

טעינת קובץ PST

קובץ Outlook PST ניתן לטעון למופע של PersonalStorage מחלקה. קטע קוד לטעינת קובץ PST מוצג למטה:

הצגת מידע על תיקיות

לאחר טעינת קובץ ה‑PST לתוך PersonalStorage מחלקה, ניתן לקבל מידע על שם התצוגה של הקובץ, תיקיית השורש, תיקיות המשנה ומספר ההודעות. קטע הקוד הבא מציג את שם קובץ ה‑PST, תיקיות ומספר ההודעות בתיקיות:

קבל רק תיקיות שהוגדרו על ידי המשתמש

קבצי PST/OST עשויים להכיל תיקיות שהמשתמש יצר. Aspose.Email מספק את היכולת לגשת רק לתיקיות שהוגדרו על ידי המשתמש באמצעות PersonalStorageQueryBuilder.OnlyFoldersCreatedByUser מאפיין. ניתן להגדיר את ה‑ PersonalStorageQueryBuilder.OnlyFoldersCreatedByUser הגדרת המאפיין ל‑true כדי לקבל רק תיקיות שהוגדרו על ידי המשתמש. קטע הקוד הבא מדגים את השימוש ב‑ PersonalStorageQueryBuilder.OnlyFoldersCreatedByUser כדי לקבל תיקיות שהוגדרו על ידי המשתמש.

בדיקת האם התיקייה נמצאת בתיקייה מוגדרת מראש

כאשר פותחים ובודקים את התיקיות בתוך קובץ PST (Personal Storage Table), ניתן לבדוק האם כל תיקייה היא מסוג תיקייה מוגדרת מראש או תיקיית משנה של תיקייה מוגדרת מראש, ולקבל מידע על כל תיקייה.

ה FolderInfo.getPredefinedType(boolean getForTopLevelParent) השיטה משמשת לבדוק האם התיקייה היא מ‑ StandardIpmFolder.

אם הפרמטר ‘getForTopLevelParent’ הוא true, השיטה מחזירה ערך enum של StandardIpmFolder לתיקיית האב ברמה העליונה. זה קובע האם התיקייה הנוכחית היא תיקיית משנה של תיקייה מוגדרת מראש. אם הפרמטר ‘getForTopLevelParent’ הוא false, היא מחזירה ערך enum של StandardIpmFolder לתיקייה הנוכחית.

String fileName = "my.pst";

try (PersonalStorage pst = PersonalStorage.fromFile(fileName)) {
    checkFolders(pst.getRootFolder().getSubFolders());
}

private void checkFolders(FolderInfoCollection folders) {
    for (FolderInfo folder : folders) {
        System.out.println("Display Name: " + folder.getDisplayName());

        // Determines whether the current folder is a predefined folder
        int folderType = folder.getPredefinedType(false);
        String answer = folderType == StandardIpmFolder.Unspecified ? "No" : "Yes, " + folderType;
        System.out.println("Is StandardIpmFolder?: " + answer);

        // Determines whether the current folder is a subfolder of a predefined folder
        if (folderType == StandardIpmFolder.Unspecified) {
            folderType = folder.getPredefinedType(true);
            answer = folderType == StandardIpmFolder.Unspecified ? "No" : "Yes, " + folderType;
            System.out.println("Is subfolder from StandardIpmFolder parent?: " + answer);
        }

        System.out.println();

        checkFolders(folder.getSubFolders());
    }
}

קבל או הוסף תיקיית RSS Feeds סטנדרטית בקובץ PST

Aspose.Email מאפשר לקבל הפנייה לתיקייה המוגדרת מראש המוחזקת ערוצי RSS. זה יכול להיות שימושי אם ברצונך לגשת ולטפל בתוכנו של ערוצי RSS המאוחסנים בקובץ Outlook PST בצורה תכנותית. העבר את ערך RssFeeds ל‑ StandardIpmFolder enum.

דוגמת הקוד הבאה מראה כיצד לקבל תיקיית RSS Feeds:

try (PersonalStorage pst = PersonalStorage.fromFile("my.pst", false)) {
    FolderInfo rssFolder = pst.getPredefinedFolder(StandardIpmFolder.RssFeeds);
}

הדוגמה בקוד למטה מציגה כיצד להוסיף תיקיית RSS Feeds:

try (PersonalStorage pst = PersonalStorage.create("my.pst", FileFormatVersion.Unicode)) {
    FolderInfo rssFolder = pst.createPredefinedFolder("RSS Feeds", StandardIpmFolder.RssFeeds);
}

פירוש תיקיות חיפוש

קבצי PST/OST עשויים להכיל תיקיות בעלות אפשרות חיפוש בנוסף לסוגי התיקיות הרגילים. Aspose.Email מספק את FolderKind ממחולל להגדרת ההודעות מתיקיות חיפוש כאלה עם EnumerateFolders ו GetSubFolders שיטות.

אחזור מידע על תיקיית האב מ‑MessageInfo

קוד הדוגמה הבא מראה כיצד לאחזר מידע על תיקיית האב מ‑ MessageInfo.

API לניווט בקובץ PST

API הניווט מאפשר לחלץ את כל פריטי ה‑PST במידת האפשר, מבלי לזרוק חריגות, אפילו אם חלק מהנתונים של הקובץ המקורי פגומים. השלבים הבאים מראים כיצד להשתמש ב‑API זה.

השתמש PersonalStorage קונסטרוקטור ו‑ טעינה שיטה במקום שיטת fromFile.

הקונסטרוקטור מאפשר להגדיר שיטת קולבק.

try (PersonalStorage currentPst = new PersonalStorage(new TraversalExceptionsCallback() {
    public void invoke(TraversalAsposeException exception, String itemId) {
        // Exception handling code.
    }
})) {
    //
}

חריגות טעינה וניווט יהיו זמינות דרך שיטת הקולבק.

ה טעינה השיטה מחזירה ’true’ אם הקובץ נטען בהצלחה והמשך הניווט אפשרי. אם הקובץ פגום ואין אפשרות לניווט, מחזירה ‘false’.

if (currentPst.load(inputStream))

זה מאפשר לפתוח ולנווט גם בקבצי PST פגומים מבלי לזרוק חריגות. גם חריגות וגם פריטים פגומים יטופלו על ידי שיטת הקולבק.

try (PersonalStorage pst = new PersonalStorage(new TraversalExceptionsCallback() {
    public void invoke(TraversalAsposeException exception, String itemId) {
        // Exception handling code.
    }
})) {
    if (pst.load("test.pst")) {
        getAllMessages(pst, pst.getRootFolder());
    }
}

private static void getAllMessages(PersonalStorage pst, FolderInfo folder) {
    for (String messageEntryId : folder.enumerateMessagesEntryId()) {
        MapiMessage message = pst.extractMessage(messageEntryId);
    }
    for (FolderInfo subFolder : folder.getSubFolders()) {
        getAllMessages(pst, subFolder);
    }
}

Java: קריאת קבצי PST/OST פגומים

Mon, 01 Jan 0001 00:00:00 +0000

קריאת קבצי PST/OST פגומים

לעיתים לא ניתן לקרוא את ה‑PST/OST עקב בעיות מסוימות. לדוגמה, ייתכן שחלק מחסמי הנתונים פגומים. במקרים כאלה, בדרך כלל מתרחשות חריגות בעת קריאה ל‑ EnumerateFolders, EnumerateMessages, GetContents, GetSubfolders, וכו׳. עם זאת, הודעות או תיקיות בודדות עשויות להישאר שלמות באחסון.

משתמשי Aspose.Email יכולים למצוא מזהי פריטים בצורה היררכית. בנוסף, ניתן לחלץ פריטים לפי מזהים. לשם כך, הספרייה מציעה את השיטות הבאות:

PersonalStorage.findMessages(String parentEntryId) - מוצא את המזהים של הודעות עבור התיקייה.
PersonalStorage.findSubfolders(String parentEntryId) - מוצא את המזהים של תת‑תיקיות עבור התיקייה.

הערה, שלמרות היתרונות, קיימים אחסונים פגומים שלא ניתן לקרוא גם באמצעות שיטות אלה.

קטע הקוד הבא מציג את השימוש בשיטות אלו לקריאת קבצי PST/OST פגומים:

try (PersonalStorage pst = PersonalStorage.fromFile(fileName)) {
    exploreCorruptedPst(pst, pst.getRootFolder().getEntryIdString());
}

public static void exploreCorruptedPst(PersonalStorage pst, String rootFolderId) {
    Iterable<String> messageIdList = pst.findMessages(rootFolderId);

    for (String messageId : messageIdList) {
        try {
            MapiMessage msg = pst.extractMessage(messageId);
            System.out.println("- " + msg.getSubject());
        } catch (Exception e) {
            System.out.println("Message reading error. Entry id: " + messageId);
        }
    }

    Iterable<String> folderIdList = pst.findSubfolders(rootFolderId);

    for (String subFolderId : folderIdList) {
        if (subFolderId != rootFolderId) {
            try {
                FolderInfo subfolder = pst.getFolderById(subFolderId);
                System.out.println(subfolder.getDisplayName());
            } catch (Exception e) {
                System.out.println("Message reading error. Entry id: " + subFolderId);
            }

            exploreCorruptedPst(pst, subFolderId);
        }
    }
}

חילוץ פריטי PST מקבצים פגומים

ה-API לניווט מאפשר לחלץ את כל הפריטים ב‑PST ככל האפשר, מבלי לזרוק חריגות, גם אם חלק מהנתונים של הקובץ המקורי פגומים.

השתמש ב- PersonalStorage(TraversalExceptionsCallback callback) קונסטרוקטור ו- load(String fileName) מתודה במקום ה- fromFile שיטה.

הקונסטרוקטור מאפשר להגדיר שיטת קולבק.

TraversalExceptionsCallback exceptionsCallback = new TraversalExceptionsCallback() {
    @Override
    public void invoke(TraversalAsposeException exception, String itemId) {
        /* Exception handling  code. */
    }
};

try (PersonalStorage pst = new PersonalStorage(exceptionsCallback)) { }

חריגות טעינה וניווט יהיו זמינות דרך שיטת הקולבק.

המתודה load מחזירה ’true’ אם הקובץ נטען בהצלחה והניווט המשך אפשרי. אם הקובץ פגום ולא ניתן לבצע ניווט, מוחזרת ‘false’.

if (currentPst.load(inputStream))

קוד הדוגמה הבא מציג כיצד ליישם את API הניווט בקבצי PST בפרויקט:

public static void main(String[] args) {
    TraversalExceptionsCallback exceptionsCallback = new TraversalExceptionsCallback() {
        @Override
        public void invoke(TraversalAsposeException exception, String itemId) {
            /* Exception handling  code. */
        }
    };

    try (PersonalStorage pst = new PersonalStorage(exceptionsCallback)) {
        if (pst.load("test.pst")) {
            getAllMessages(pst, pst.getRootFolder());
        }
    }
}

private static void getAllMessages(PersonalStorage pst, FolderInfo folder) {
    for (String messageEntryId : folder.enumerateMessagesEntryId()) {
        MapiMessage message = pst.extractMessage(messageEntryId);
    }
    for (FolderInfo subFolder : folder.getSubFolders()) {
        getAllMessages(pst, subFolder);
    }
}

Java: הוספת MapiDistributionList ל‑PST

Mon, 01 Jan 0001 00:00:00 +0000

צור PST חדש, הוסף תתי‑תיקיות והודעות הודגם כיצד ליצור קובץ PST ולהוסיף אליו תת‑תיקייה. עם Aspose.Email אתה יכול להוסיף MapiDistributionList לתיקיית אנשי הקשר של קובץ PST שיצרת או טעית.

על מנת להגדיר את ה‑EntryId עבור MapiDistributionListMember, יש להמיר את ה‑base64String באמצעות Apache Commons Codec.

טעינת MapidistributionList מקובץ

הקוד שלהלן טוען רשימת הפצה MAPI מקובץ.

יצירת MapiDistributionList חדש והוספתו לתיקיית אנשי הקשר

להלן השלבים להוספת MapiDistributionList ל‑PST:

יצירת PST חדש.
הוספת תיקיית אנשי הקשר ל‑PST.
יצירת אנשי קשר לדוגמה.
יצירת רשימת הפצה על בסיס אנשי הקשר שנוצרו.
הוספת רשימת ההפצה ל‑PST.

קטע הקוד למטה מציג כיצד ליצור MapiDistributionList ואז הוסף אותו לתיקיית אנשי הקשר של קובץ PST שנוצר זה עתה.

יצירת רשימת הפצה חד‑פעמית

לרשימת הפצה זו, אין צורך באנשי קשר נפרדים.

Java: עבודה עם קבצי PST גדולים

Mon, 01 Jan 0001 00:00:00 +0000

עיבוד קבצי Personal Storage Table (PST) גדולים עלול להפחית את הביצועים ולהגדיל את השימוש בזיכרון. Aspose.Email עבור Java מציע מספר טכניקות ו-API המאפשרים למפתחים לגשת, לעבד ולנהל את נתוני תיבת הדוא"ל ביעילות מבלי להעמיס על משאבי המערכת.

השתמש בשיטות איטרטיביות לניווט בתיקיות ובהודעות

כאשר עוברים על תיקיות והודעות, עדיף להשתמש בשיטות שמחזירות Iterable. זה מצמצם עומס זיכרון ומשפר את הביצועים.

try (PersonalStorage pst = PersonalStorage.fromFile("storage.pst")) {
    for (FolderInfo folder : pst.getRootFolder().enumerateFolders()) {
        for (MessageInfo messageInfo : folder.enumerateMessages()) {
            // Process message
        }
    }
}

השתמש ב-MessageInfo למאפייני הודעה בסיסיים

אם אתה צריך רק פרטי הודעה בסיסיים, השתמש ב MessageInfo במקום לטעון את ההודעה המלאה. זה מהיר יותר וצורך פחות זיכרון.

for (MessageInfo messageInfo : folder.enumerateMessages()) {
    System.out.println("Subject: " + messageInfo.getSubject());
    System.out.println("To: " + messageInfo.getDisplayTo());
    System.out.println("Importance: " + messageInfo.getImportance());
    System.out.println("Message Class: " + messageInfo.getMessageClass());
}

הימנע מחילוץ הודעות מלאות אלא אם הכרחי

לא להשתמש ב‑ ExtractMessage או EnumerateMapiMessages מתודות לכל ההודעות אלא אם אתה צריך את כל המאפיינים.

במקום זאת, שקול:

a) אחזור מזהי הודעות

השתמש enumerateMessagesEntryId כדי לקבל את כל מזהי ההודעות בתיקייה. לאחר מכן ניתן לחלץ באופן סלקטיבי תכונות, הודעות או קבצים מצורפים.

for (String id : folder.enumerateMessagesEntryId()) {
    // Retrieve a property using ID (extractProperty),
    // Extract a MapiMessage (extractMessage),
    // Extract message attachments (extractAttachments),
    // Save message to a stream (saveMessageToStream).
}

b) חילוץ תכונה בודדת

השתמש ExtractProperty אם אתה צריך רק תכונה ספציפית שחסרה ב‑ MessageInfo.

for (String msgId : folder.enumerateMessagesEntryId()) {
    String transportMessageHeaders =
        pst.extractProperty(
            org.apache.commons.codec.binary.Base64.decodeBase64(msgId),
            KnownPropertyList.TRANSPORT_MESSAGE_HEADERS.getTag()
        ).getString();
}

c) חילוץ קבצים מצורפים בלבד

אם נדרש רק קבצים מצורפים, השתמש ב‑ ExtractAttachments.

for (String msgId : folder.enumerateMessagesEntryId()) {
    MapiAttachmentCollection attachments = pst.extractAttachments(msgId);
}

השתמש בקריטריוני חיפוש כדי לסנן הודעות

סינון הודעות באמצעות קריטריוני חיפוש מצמצם את מספר ההודעות הטעונות ומשפר ביצועים.

try (PersonalStorage pst = PersonalStorage.fromFile("storage.pst")) {

    PersonalStorageQueryBuilder builder = new PersonalStorageQueryBuilder();
    // Unread messages
    builder.hasNoFlags(MapiMessageFlags.MSGFLAG_READ);

    for (FolderInfo folder : pst.getRootFolder().enumerateFolders()) {
        MessageInfoCollection unread = folder.getContents(builder.getQuery());
    }
}

שמירת הודעות ל‑Stream

במקום לחלץ ולשמור הודעות אחת אחת, השתמש ב‑ SaveMessageToStream לשיפור ביצועים.

for (String id : folder.enumerateMessagesEntryId()) {
    try (OutputStream fos  = new FileOutputStream("message.msg")) {
        pst.saveMessageToStream(id, fos);
    }
}

השתמש במתודות בקבוצות כשניתן

כשאתה צריך להוסיף או מחיקה פריטים מרובים, עדיפות למתודות בקבוצות על פני פעולות פרטניות. זה מצמצם עומס ומשפר ביצועים.

Java: קרא קובץ OLM של Outlook for Mac וקבל מידע על תיקיות ותיקיות משנה

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email for Java מאפשר לך לקרוא קובצי OLM של Outlook for Mac. ניתן לטעון קובץ OLM מהדיסק למופע של ה‑ OlmStorage מחלקה וקבלת המידע על תוכנה, לדוגמה, תיקיות, תיקיות משנה והודעות.

פתיחת קבצי פורמט OLM

קבצי פורמט OLM ניתן לפתוח בשתי דרכים:

בהשתמש בבונה
בהשתמש בשיטה הסטטית FromFile

קיימים הבדלים בהתנהגות בין השיטות הללו. ראה את הקטע למטה.

פתיחת קבצים באמצעות הבונה

כדי לפתוח קובץ, קרא לבוני של ה‑ OlmStorage מחלקה והעבר את שם הקובץ המלא או הזרם כארגומנט אליה:

OlmStorage olm = new OlmStorage("fileName");

פתיחת קבצים באמצעות השיטה הסטטית FromFile

כדי לפתוח קובץ, השתמש בשיטה סטטית fromFile והעבר את שם הקובץ המלא כארגומנט אליו:

OlmStorage olm = OlmStorage.fromFile("fileName");

פתיחת קבצים באמצעות השיטה הסטטית FromStream

כדי לפתוח קובץ באמצעות השיטה הסטטית fromStream, העבר שם זרם כארגומנט אליו:

קריאת קובץ OLM

קטטע הקוד הבא מראה לך כיצד לטעון את קובץ OLM ולקבל את תוכנו.

קבלת תיקיות

כדי לאחזר תיקיות מקובץ OLM (Outlook for Mac), טען אותו עם ה‑ OlmStorage קודם כל המחלקה, ולאחר מכן השתמש באחת מהשיטות הבאות בהתאם לצרכיך:

getFolder(String name, boolean ignoreCase) - מקבל את התיקייה לפי שם.
getFolders() - מקבל את היררכיית התיקיות/אוסף התיקיות.
getFolderHierarchy() - מקבל את היררכיית התיקיות.

דוגמת הקוד למטה תראה לך כיצד לקבל תיקייה מקובץ OLM:

// Get the folder by name
OlmStorage olm = OlmStorage.fromFile("fileName");

try {

    OlmFolder inbox = olm.getFolder("inbox", true);

} finally {

    olm.dispose();

}

כאשר משתמשים ב‑ fromFile שיטה לפתיחת קובץ OLM, ה‑ getFolderHierarchy() יחזיר null. במצב זה, קרא ל‑ getFolders() שיטה במפורש לקבלת רשימת התיקיות בקובץ OLM.

קבלת נתיב תיקייה

גם תוכל לקבל את נתיב התיקייה של תיקיות בקובץ OML. Aspose.Email מספקת OlmFolder.Path מאפיין המחזיר את נתיב התיקייה. קטע הקוד הבא מדגים את השימוש ב‑ OlmFolder.Path מאפיין לקבלת נתיבי התיקיות בקובץ OML.

ספירת מספר הפריטים בתיקייה

אתה גם יכול לספור את מספר הפריטים בתיקייה. Aspose.Email מספקת OlmFolder.MessageCount מאפיין המחזיר את מספר הפריטים בתיקייה. קטע הקוד הבא מדגים את השימוש ב‑ OlmFolder.MessageCount מאפיין לקבלת מספר הפריטים בתיקיות של קובץ OML.

איטרציית הודעות מתיקייה נתונה

Aspose.Email מספקת API לעבודה עם אחסוני OLM ולחילוץ הודעות מתיקייה נתונה. ה OlmFolder ו OlmMessageInfo המחלקות מייצגות מידע קצר על תיקייה והודעה באחסון בהתאמה. ה OlmFolder המחלקה מספקת את השיטות הבאות:

OlmFolder.getSubFolder(String subfolderName, boolean ignoreCase) - מקבל את תיקיית המשנה לפי שם.
OlmFolder.enumerateMapiMessages() - חשוף את האיטרטור, התומך באיטרציה של MapiMessages בתיקייה הנוכחית.
OlmFolder.enumerateMessages() - חשוף את האיטרטור, התומך באיטרציה של OlmMessageInfo בתיקייה הנוכחית.
OlmFolder.enumerateMessages(int startIndex, int count) - חשוף את האיטרטור, התומך באיטרציה של OlmMessageInfo בטווח נתון.
OlmFolder.enumerateMessages(MailQuery query) - חשוף את האיטרטור, התומך באיטרציה של OlmMessageInfo לפי קריטריוני חיפוש.

דוגמות הקוד למטה ידגימו את השימוש בשיטות אלו:

 // Enumerates all messages in a given folder

OlmStorage olm = OlmStorage.fromFile("fileName");

try {

    OlmFolder inbox = olm.getFolder("inbox", true);

   for (OlmMessageInfo messageInfo : inbox.enumerateMessages()) {

        System.out.println(messageInfo.getSubject());

   }

} finally {

    olm.dispose();

}

// Enumerates a range of messages in a given folder

OlmStorage olm = OlmStorage.fromFile("fileName");

try {

    OlmFolder inbox = olm.getFolder("inbox", true);

   int startIndex = 10;

   int count = 100;

   for (OlmMessageInfo messageInfo : inbox.enumerateMessages(startIndex, count)) {

        System.out.println(messageInfo.getSubject());

   }

} finally {

    olm.dispose();

}

// Enumerates messages by search criteria

OlmStorage olm = OlmStorage.fromFile("fileName");

try {

    OlmFolder inbox = olm.getFolder("inbox", true);

    MailQueryBuilder mailQueryBuilder = new MailQueryBuilder();

    mailQueryBuilder.getSubject().contains("invitation");

    mailQueryBuilder.getFrom().contains("Mark");

   for (OlmMessageInfo messageInfo : inbox.enumerateMessages(mailQueryBuilder.getQuery())) {

        System.out.println(messageInfo.getSubject());

   }

} finally {

    olm.dispose();

}

// Enumerates all messages and the extraction of some of them

OlmStorage olm = OlmStorage.fromFile("fileName");

try {

    OlmFolder inbox = olm.getFolder("inbox", true);

   for (OlmMessageInfo messageInfo : inbox.enumerateMessages()) {

       if (messageInfo.hasAttachments()) {

            MapiMessage msg = olm.extractMapiMessage(messageInfo);

       }

   }

} finally {

    olm.dispose();

}

חילוץ הודעות מ‑OLM לפי מזהים

לפעמים נדרשת חילוץ הודעות נבחרות על ידי מזהים. לדוגמה, האפליקציה שלך מאחסנת מזהים במאגר נתונים ומחלצת הודעה לפי דרישה. זוהי הדרך היעילה למנוע סריקה של כל האחסון בכל פעם כדי למצוא הודעה ספציפית לחילוץ. כדי ליישם תכונה זו עבור קבצי OLM, Aspose.Email מספקת את השיטות והמחלקות הבאות:

EntryId מאפיין של OlmMessageInfo מחלקה - מקבלת את מזהה כניסת ההודעה.
מוגד extractMapiMessage(String id) שיטה של OlmStorage מחלקה - מקבלת את ההודעה מ‑OLM.

דוגמת הקוד למטה מדגימה כיצד לחלץ הודעות מ‑OLM לפי מזהים:

for (OlmMessageInfo msgInfo : olmFolder.enumerateMessages()) {
    MapiMessage msg = storage.extractMapiMessage(msgInfo.getEntryId());
}

הערה: מזהה ההודעה הוא ייחודי בתוך קובץ האחסון. מזהים נוצרו על ידי Aspose.Email ולא ניתן להשתמש בהם בספריות או אפליקציות עיבוד OLM של צד שלישי.

חילוץ פריטי OLM מקבצים פגומים

Aspose.Email מספקת API לחיפוש שמאפשר לחלץ את כל הפריטים של OLM ככל האפשר, ללא זריקת חריגות, אפילו אם חלק מהנתונים של הקובץ המקורי פגומים.

השתמש ב- OlmStorage(TraversalExceptionsCallback callback) קונסטרוקטור ו- load(String fileName) מתודה במקום ה- fromFile שיטה.

הקונסטרוקטור מאפשר להגדיר שיטת קולבק.

OlmStorage olm = new OlmStorage(new TraversalExceptionsCallback() {
    public void invoke(TraversalAsposeException exception, String itemId) {
        /* Exception handling  code. */
    }
});

חריגות טעינה וניווט יהיו זמינות דרך שיטת הקולבק.

TraversalExceptionsCallback exceptionsCallback = new TraversalExceptionsCallback() {
    public void invoke(TraversalAsposeException exception, String itemId) {
        /* Exception handling  code. */
    }
};
try (OlmStorage olm = new OlmStorage(exceptionsCallback)) {
    if (olm.load(fileName)) {
        List<OlmFolder> folderHierarchy = olm.getFolders();
        extractItems(olm, folderHierarchy);
    }
}

private static void extractItems(OlmStorage olm, List<OlmFolder> folders) {
    for (OlmFolder folder : folders) {
        if (folder.hasMessages()) {
            System.out.println(folder);

            for (MapiMessage msg : olm.enumerateMessages(folder)) {
                System.out.println(msg.getSubject());
            }
        }

        if (folder.getSubFolders().size() > 0) {
            extractItems(olm, folder.getSubFolders());
        }
    }
}

קבלת תאריך שינוי הודעה

ה OlmMessageInfo.getModifiedDate מאפיין שמאפשר לקבל את תאריך השינוי של ההודעה.

for (OlmMessageInfo messageInfo : inboxFolder.enumerateMessages()) {
    Date modifiedDate = messageInfo.getModifiedDate();
}