PST फ़ाइल में संदेशों के साथ काम करना

Outlook PST फ़ाइलों में संदेश जोड़ें

एक संदेश को PST फ़ाइल में जोड़ें

नया PST फ़ाइल बनाएं और सबफ़ोल्डर जोड़ें दिखाता है कि PST फ़ाइल कैसे बनाएं और उसमें एक सबफ़ोल्डर जोड़ें। Aspose.Email के साथ आप बनाए या लोड किए गए PST फ़ाइल के सबफ़ोल्डरों में भी संदेश जोड़ सकते हैं। नीचे दिया गया कोड उदाहरण दर्शाता है कि नई PST फ़ाइल कैसे बनाएं, "Inbox" फ़ोल्डर जोड़ें, और फिर उस फ़ोल्डर में संदेश जोड़ें। PersonalStorage और FolderInfo क्लासेज़ इस कार्य को करने के लिए उपयोग किए जाते हैं।

उपयोग करें PersonalStorage.create फ़ाइल पथ और फ़ाइल फ़ॉर्मेट संस्करण को Unicode के रूप में निर्दिष्ट करके नई PST फ़ाइल शुरू करने की विधि।
PST फ़ाइल की रूट डायरेक्टरी में "Inbox" नाम का नया फ़ोल्डर बनाएं।
नए बनाए गए "Inbox" फ़ोल्डर में संदेश जोड़ें, उपयोग करके add_message विधि।
संदेश को लोड करें, उपयोग करके MapiMessage.load.

pst = PersonalStorage.create(dataDir + "AddMessagesToPst_out.pst", FileFormatVersion.UNICODE)

# Add new folder "Inbox"
inboxFolder = pst.root_folder.add_sub_folder("Inbox");

# Add message to Inbox Folder
inboxFolder.add_message(MapiMessage.load(dataDir + "MapiMsgWithPoll.msg"))

pst.dispose()

बेहतर प्रदर्शन के लिए PST फ़ाइलों में कई संदेश जोड़ें

PST में व्यक्तिगत संदेश जोड़ने से डिस्क पर अधिक I/O ऑपरेशन होते हैं और इसलिए प्रदर्शन धीमा हो सकता है। प्रदर्शन सुधारने के लिए, संदेशों को bulk मोड में PST में जोड़ा जा सकता है, जिससे I/O ऑपरेशनों को न्यूनतम किया जाए।

डिस्क से संदेश लोड करें और जोड़ें

यह add_messages मेथड आपको PST फ़ाइल में जोड़ने के लिए संदेशों की एक सीमा परिभाषित करने की अनुमति देता है। नीचे दिया गया कोड उदाहरण दिखाता है कि डिस्क से कई संदेशों को PST फ़ाइल में बेहतर प्रदर्शन के लिए कैसे जोड़ा जाए:

बनाकर एक फ़ंक्शन परिभाषित करें add_messages_in_bulk_mode PST फ़ाइलनाम और संदेशों वाले फ़ोल्डर के पैरामीटर के साथ।
उल्लेखित PST फ़ाइल को खोलें, प्रयोग करके PersonalStorage.from_file().
PST रूट फ़ोल्डर से सबफ़ोल्डर "myInbox" प्राप्त करें।
निर्दिष्ट फ़ोल्डर से संदेशों को bulk में जोड़ें, उपयोग करके folder.add_messages().
कॉल करें add_messages_in_bulk_mode() PST फ़ाइल और फ़ोल्डर नाम को तर्कों के रूप में लेकर।

from aspose.email.storage.pst import PersonalStorage, StandardIpmFolder, FileFormatVersion

def add_messages_in_bulk_mode(file_name, msg_folder_name):
    with PersonalStorage.from_file(file_name) as personal_storage:
        folder = personal_storage.root_folder.get_sub_folder("myInbox")
        folder.add_messages(message_collection(msg_folder_name))

# Add multiple messages from the specified folder to the PST file for improved performance
add_messages_in_bulk_mode("file.pst", "folder_with_messages")

उपयोग `MapiMessageEnumerator` बड़ी ऑपरेशन्स के लिए

बड़ी मात्रा में संदेश प्रोसेसिंग को सुगम बनाने के लिए, आप लागू कर सकते हैं MapiMessageEnumerator क्लास जो निर्दिष्ट फ़ोल्डर में संग्रहीत संदेशों को कुशलतापूर्वक इटरेट करता है। निम्नलिखित Python स्क्रिप्ट Aspose.Email लाइब्रेरी का उपयोग करके MAPI संदेशों को सूचीबद्ध करने और इटरेट करने के लिए एक संरचित दृष्टिकोण प्रदान करती है। यह दो हेल्पर क्लासेस को परिभाषित करती है:

MapiMessageEnumerator डायरेक्टरी से संदेश पढ़ने के लिए,
और MapiMessageCollection बैच ऑपरेशन्स के दौरान उन्हें प्रबंधित करने के लिए।

यह विधि MAPI संदेश फ़ाइलों के ट्रैवर्सल और हैंडलिंग को सरल बनाती है।

import os
from aspose.email.mapi import MapiMessage

# Define a class to enumerate through MAPI message files in a directory
class MapiMessageEnumerator:
    def __init__(self, path):
        self.files = os.listdir(path)
        self.position = -1

    def __next__(self):
        self.position += 1
        if self.position < len(self.files):
            return MapiMessage.from_file(os.path.join(self.path, self.files[self.position]))
        else:
            raise StopIteration

    def __iter__(self):
        return self

# Define a collection class for managing MAPI messages
class MapiMessageCollection:
    def __init__(self, path):
        self.path = path

    def __iter__(self):
        return MapiMessageEnumerator(self.path)


# Iterate through MAPI messages in a specific directory
msg_folder_name = "\\Files\\msg"

# Initialize a collection with the directory containing message files
message_collection = MapiMessageCollection(msg_folder_name)
for message in message_collection:
    # Process each MAPI message object as needed
    pass

दूसरे PST से संदेश जोड़ें

एक PST फ़ाइल से दूसरी में संदेश आयात करने के लिए, Aspose.Email प्रदान करता है FolderInfo.enumerate_mapi_messages() मेथड। निम्न कोड उदाहरण दर्शाता है कि कैसे एक PST फ़ाइल के "Inbox" फ़ोल्डर से संदेशों को दूसरी PST फ़ाइल में कॉपी किया जाए:

Outlook PST फ़ाइलों से संदेश प्राप्त करें

में Outlook PST फ़ाइलें पढ़ें, फ़ोल्डर और सबफ़ोल्डर जानकारी प्राप्त करें, हमने Outlook PST फ़ाइल लोड करने और उसके फ़ोल्डरों को ब्राउज़ करके फ़ोल्डर नाम और उनमें मौजूद संदेशों की संख्या प्राप्त करने पर चर्चा की। यह लेख बताता है कि Outlook PST फ़ाइलों से संदेशों तक कैसे पहुँचें और उन्हें निकालें: बुनियादी संदेश विवरण प्राप्त करें, फ़ोल्डर में आइटमों की संख्या गिनें, और प्रोसेसिंग या विश्लेषण के लिए एक विशिष्ट संख्या में संदेश निकालें।

बुनियादी संदेश जानकारी प्राप्त करें

निचे दिया गया कोड उदाहरण Aspose.Email लाइब्रेरी का उपयोग करके PST फ़ाइल में संग्रहीत MAPI संदेशों से प्रमुख जानकारी निकालने और प्रदर्शित करने का तरीका दर्शाता है। यह एक को प्रारंभ करता है PersonalStorage "Outlook.pst" फ़ाइल से ऑब्जेक्ट, रूट फ़ोल्डर की सामग्री प्राप्त करता है, और प्रत्येक संदेश पर इटरेट करता है। स्क्रिप्ट विषय, प्रेषक की जानकारी, प्राप्तकर्ता पते, डिलीवरी समय और संदेश बॉडी जैसी विवरण प्रिंट करता है, जिससे निर्दिष्ट PST फ़ाइल में प्रत्येक ईमेल का व्यापक अवलोकन मिलता है।

from aspose.email.storage.pst import *
from aspose.email.mapi import MapiMessage

pst = PersonalStorage.from_file("Outlook.pst")

folderInfo = pst.root_folder

messageInfoCollection = folderInfo.get_contents()

for messageInfo in messageInfoCollection:
   mapi = pst.extract_message(messageInfo)

   print("Subject: " + mapi.subject)
   print("Sender name: " + mapi.sender_name)
   print("Sender email address: " + mapi.sender_email_address)
   print("To: ", mapi.display_to)
   print("Cc: ", mapi.display_cc)
   print("Bcc: ", mapi.display_bcc)
   print("Delivery time: ", str(mapi.delivery_time))
   print("Body: " + mapi.body)

नेस्टेड फ़ोल्डरों का पुनरावर्ती पढ़ना

एक Outlook PST फ़ाइल में नेस्टेड फ़ोल्डर हो सकते हैं। इन फ़ोल्डरों से और शीर्ष-स्तर फ़ोल्डरों से संदेश जानकारी प्राप्त करने के लिए, सभी फ़ोल्डरों को पढ़ने के लिए पुनरावर्ती विधि का उपयोग करें। नीचे दिया गया कोड स्निपेट दिखाता है कि कैसे Outlook PST फ़ाइल को पढ़ें और फ़ोल्डर और संदेश सामग्री को पुनरावर्ती रूप से प्रदर्शित करें:

PST फ़ोल्डर में कुल आइटम्स की संख्या प्राप्त करें

संदेश स्टोर में मौजूद कुल आइटमों (जैसे ईमेल, अपॉइंटमेंट, कार्य, संपर्क आदि) को प्राप्त करने के लिए, get_total_items_count() मेथड का उपयोग करें MessageStore क्लास। यह स्टोर के भीतर डेटा के आकार और मात्रा की जानकारी जल्दी से इकट्ठा करने का एक सुविधाजनक तरीका प्रदान करता है। नीचे दिया गया कोड स्निपेट दिखाता है कि PST फ़ाइल से कुल आइटमों की संख्या कैसे प्राप्त करें:

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

count = pst.store.get_total_items_count()

निश्चित संख्या में संदेश निकालें

PST फ़ाइल से निर्दिष्ट संख्या में संदेश निकालने के लिए, get_contents(start_index, count) मेथड का उपयोग करें FolderInfo क्लास। यह दो पैरामीटर लेता है:

start_index - शुरूआती संदेश का क्रमांक, उदाहरण के लिये 10वां;
count - पुनः प्राप्त करने वाले कुल संदेशों की संख्या।

एक बार में केवल आवश्यक संदेश उपसमुच्चय को पुनः प्राप्त करना बड़े ईमेल डेटा को प्रबंधित करने में उपयोगी हो सकता है। निम्न कोड उदाहरण इस सुविधा को लागू करने को दर्शाता है:

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

folder = pst.root_folder.get_sub_folder("Inbox")

# Extracts messages starting from 10th index top and extract total 100 messages
messages = folder.get_contents(10, 100)

PST फ़ाइलों में अटैचमेंट्स के साथ काम करें

पूरे संदेश को निकाले बिना अटैचमेंट निकालें

Python के लिए Aspose.Email आपको PST संदेशों से अटैचमेंट निकालने की अनुमति देता है, बिना पूरे संदेश को पहले निकाले। यह किया जा सकता है, उपयोग करके extract_attachments विधि PersonalStorage क्लास। निम्न कोड स्निपेट दिखाता है कि .msg फ़ाइलों को स्किप करते हुए अटैचमेंट्स को कैसे निकालें:

from aspose.email.storage.pst import PersonalStorage

# Open the PST file 
with PersonalStorage.from_file(data_dir + "my.pst") as personal_storage:
    # Get the "Inbox" subfolder from the root folder in the personal storage
    folder = personal_storage.root_folder.get_sub_folder("Inbox")

    # Iterate over each message entry ID in the Inbox folder
    for message_info in folder.enumerate_messages_entry_id():
        # Extract attachments for the current message
        attachments = personal_storage.extract_attachments(message_info)

        # Check if the message has any attachments
        if attachments.count > 0:
            # Iterate over each attachment in the list
            for attachment in attachments:
                # Ignore attachments that are message files (.msg)
                if attachment.long_file_name and attachment.long_file_name.endswith(".msg"):
                    continue
                # Save the attachment with its original file name
                attachment.save(data_dir + attachment.long_file_name)

फ़ाइलों को PST संदेशों में अटैचमेंट के रूप में जोड़ें

Microsoft Outlook ईमेल, कैलेंडर, कार्य, संपर्क और जर्नल एंट्रीज को प्रबंधित करने के लिए एक शक्तिशाली टूल है। इन मुख्य कार्यों के अलावा, यह PST फ़ोल्डरों में फाइलें जोड़ने की सुविधा भी देता है, जिससे उपयोगकर्ता संबंधित दस्तावेज़ों का व्यापक रिकॉर्ड रख सकते हैं। Aspose.Email PST फ़ोल्डर में फाइलें जोड़ने की प्रक्रिया को सरल बनाता है, जो संदेशों, संपर्कों, कार्यों और जर्नल एंट्रीज को संभालने के समान कार्य करता है।

निम्न कोड स्निपेट दिखाता है कि Aspose.Email के साथ दस्तावेज़ को PST फ़ोल्डर में कैसे जोड़ें:

from aspose.email.storage.pst import PersonalStorage, FileFormatVersion

# Create a new PST file
personal_storage = PersonalStorage.create(data_dir + "AddFilesToPst_out.pst", FileFormatVersion.UNICODE)

# Add a new folder to store files
folder = personal_storage.root_folder.add_sub_folder("Files")

# Add a file to the PST folder
folder.add_file(data_dir + "FileToBeAddedToPST.txt", "")

PST फ़ाइलों में संदेशों की खोज और फ़िल्टर

Personal Storage (PST) फ़ाइलों में बड़ी मात्रा में डेटा हो सकता है, और विशिष्ट मानदंडों से मेल खाने वाले डेटा को खोजने के लिए कई फ़िल्टरेशन को शामिल करना आवश्यक है। इसके साथ PersonalStorageQueryBuilder क्लास, Aspose.Email आपको परिभाषित खोज मानदंडों के आधार पर PST में विशिष्ट रिकॉर्ड खोजने में सक्षम बनाता है। आप प्रेषक, प्राप्तकर्ता, विषय, संदेश की महत्ता, अटैचमेंट की उपस्थिति, संदेश आकार, और यहां तक कि संदेश ID जैसे पैरामीटर का उपयोग करके संदेश खोज सकते हैं। अतिरिक्त रूप से, PersonalStorageQueryBuilder सबफ़ोल्डरों के भीतर खोज के लिए उपयोग किया जा सकता है। नीचे के भाग Outlook PST फ़ाइलों की खोज पर एक व्यापक गाइड प्रदान करते हैं।

Outlook संदेशों और फ़ोल्डरों की खोज

निम्न कोड स्निपेट दिखाता है कि आप कैसे उपयोग करें PersonalStorageQueryBuilder विभिन्न खोज मानदंडों के आधार पर PST में सामग्री खोजने के लिए क्लास। यह विशेष रूप से PST को निम्न के आधार पर खोजने को दर्शाता है:

संदेश महत्त्व।
संदेश वर्ग।
अटैचमेंट की उपस्थिति।
संदेश आकार।
न पढ़े गए संदेश।
अनपढ़ संदेश जिनमें अटैचमेंट हैं, और विशिष्ट सबफ़ोल्डर नाम वाले फ़ोल्डर।

from aspose.email.mapi import MapiMessageFlags
from aspose.email.storage.pst import PersonalStorage, PersonalStorageQueryBuilder, MapiImportance

with PersonalStorage.from_file(data_dir + "my.pst") as personal_storage:
    folder = personal_storage.root_folder.get_sub_folder("Inbox")
    builder = PersonalStorageQueryBuilder()

    # High importance messages
    builder.importance.equals(2)
    messages = folder.get_contents(builder.get_query())
    print("Messages with High Imp:", messages.count)

    builder = PersonalStorageQueryBuilder()
    builder.message_class.equals("IPM.Note")
    messages = folder.get_contents(builder.get_query())
    print("Messages with IPM.Note:", messages.count)

    builder = PersonalStorageQueryBuilder()
    # Messages with attachments AND high importance
    builder.importance.equals(2)
    builder.has_flags(MapiMessageFlags.HASATTACH)
    messages = folder.get_contents(builder.get_query())
    print("Messages with atts:", messages.count)

    builder = PersonalStorageQueryBuilder()
    # Messages with size > 15 KB
    builder.message_size.greater(15000)
    messages = folder.get_contents(builder.get_query())
    print("Messages size > 15 KB:", messages.count)

    builder = PersonalStorageQueryBuilder()
    # Unread messages
    builder.has_no_flags(MapiMessageFlags.READ)
    messages = folder.get_contents(builder.get_query())
    print("Unread:", messages.count)

    builder = PersonalStorageQueryBuilder()
    # Unread messages with attachments
    builder.has_no_flags(MapiMessageFlags.READ)
    builder.has_flags(MapiMessageFlags.HASATTACH)
    messages = folder.get_contents(builder.get_query())
    print("Unread msgs with atts:", messages.count)

    # Folder with name 'SubInbox'
    builder = PersonalStorageQueryBuilder()
    builder.folder_name.equals("SubInbox")
    folders = folder.get_sub_folders(builder.get_query())
    print("Folder having subfolder:", folders.count)

    builder = PersonalStorageQueryBuilder()
    # Folders with subfolders
    builder.has_subfolders()
    folders = folder.get_sub_folders(builder.get_query())
    print("Folders with subfolders:", folders.count)

केस‑इनसेंसिटिव मिलान के साथ खोज

Aspose.Email का उपयोग करके PersonalStorageQueryBuilder, आप ईमेल संदेशों के लिए खोज शर्तें निर्धारित कर सकते हैं जबकि केस-सेंसिटिविटी को अनदेखा करें, जिससे अधिक लचीला और उपयोगकर्ता‑मैत्रीपूर्ण खोज अनुभव मिलता है। निम्न कोड उदाहरण दर्शाता है कि कैसे एक PST फ़ाइल लोड करें, "Inbox" फ़ोल्डर तक पहुँचें, और प्रेषक जानकारी के आधार पर ईमेल खोजने के लिए केस‑अनसेंसिटिव खोज फ़िल्टर लागू करें। यह सुविधा ईमेल डेटा में विभिन्न कैपिटलाइज़ेशन से निपटने में विशेष रूप से मददगार है।

एकाधिक कीवर्ड्स का उपयोग करके विषय पंक्तियों की खोज करें

व्यक्तिगत स्टोरेज फ़ाइल (PST) या संदेश स्टोर से विशिष्ट संदेशों या आइटम्स को प्राप्त करें, लागू करके either(query1, query2) विधि PersonalStorageQueryBuilder क्लास। यह दो पैरामीटर लेता है जिससे आप दो अलग-अलग क्वेरीज़, query1 और query2, को संयोजित कर सकते हैं, और दो निर्दिष्ट शब्दों में से किसी एक से मेल खाने वाले संदेश विषय को खोज सकते हैं। नीचे दिया गया कोड नमूना देखें:

import aspose.email as ae

builder1 = ae.storage.pst.PersonalStorageQueryBuilder()
builder1.subject.contains("Review") # 'Review' is key word for the search

builder2 = ae.storage.pst.PersonalStorageQueryBuilder()
builder2.subject.contains("Error") # 'Error' is also key word for the search

builder = ae.storage.pst.PersonalStorageQueryBuilder()
# message subjects must contain 'Review' or 'Error' words
builder.either(builder1.get_query(), builder2.get_query())


pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

folder = pst.root_folder.get_sub_folder("Inbox")
messages = folder.get_contents(builder.get_query())

for message in messages:
    print(f"Message: {message.subject}")

विशिष्ट मानदंडों के आधार पर PST में ईमेल फ़िल्टर करें

निर्दिष्ट फ़िल्टर, जैसे विषय, प्रेषक, या तारीख, से मेल खाने वाले केवल संदेशों को प्राप्त करें, उपयोग करते हुए MailQuery क्लास। निम्नलिखित कोड नमूना दिखाता है कि कैसे Aspose.Email लाइब्रेरी का उपयोग करके PST फ़ाइल लोड करें और एक विशिष्ट फ़ोल्डर, इस मामले में "Inbox" फ़ोल्डर, के भीतर संदेशों को फ़िल्टर करें:

import aspose.email as ae

# Load the PST file and access a folder
pst = ae.PersonalStorage.from_file("sample.pst")
inbox = pst.root_folder.get_sub_folder("Inbox")

# Create a MailQuery to filter messages by subject
query_builder = ae.MailQueryBuilder()
query_builder.subject.contains("Invoice")

query = query_builder.get_query()

# Enumerate filtered messages
for info in inbox.enumerate_mapi_messages(query):
    print("Subject:", info.subject)

प्रकार के आधार पर संदेश प्राप्त करें

Aspose.Email MessageKind ओवरलोड आपको विशिष्ट प्रकार के संदेश प्राप्त करने की अनुमति देता है, जैसे केवल ईमेल, अपॉइंटमेंट या संपर्क। निम्नलिखित कोड नमूना दर्शाता है कि कैसे निर्दिष्ट फ़ोल्डर से विशिष्ट प्रकार के संदेशों तक पहुंचें और उन्हें फ़िल्टर करें:

import aspose.email as ae

# Load the PST and target folder
pst = ae.PersonalStorage.from_file("sample.pst")
inbox = pst.root_folder.get_sub_folder("Inbox")

# Retrieve only email messages (not calendar items, contacts, etc.)
for info in inbox.enumerate_mapi_messages(ae.MessageKind.MAPI_MESSAGE):
    print("Email Message:", info.subject)

बड़े PST फ़ाइलों के लिए संदेश पुनःप्राप्ति को पेजिनेट करें

जब आप बड़ी संख्या में संदेशों वाले फ़ोल्डरों के साथ काम कर रहे हों, आप पेजिनेशन का उपयोग करके संदेशों को समूहों में लोड कर सकते हैं। start_index और count पैरामीटर। निम्नलिखित कोड नमूना दिखाता है कि कैसे PST फ़ाइल से सभी संदेशों को एक साथ लोड करने के बजाय एक विशिष्ट रेंज के ईमेल संदेशों तक पहुंचें और उन्हें प्राप्त करें:

import aspose.email as ae

# Load the PST and access the target folder
pst = ae.PersonalStorage.from_file("sample.pst")
inbox = pst.root_folder.get_sub_folder("Inbox")

# Retrieve messages from index 0 to 9
for info in inbox.enumerate_mapi_messages(0, 10):
    print("Paged Message:", info.subject)

Outlook PST सामग्री को अपडेट और व्यवस्थित करें

फ़ोल्डरों के बीच संदेशों को स्थानांतरित करें

Aspose.Email यह संभव बनाता है कि स्रोत फ़ोल्डर से वस्तुओं को उसी पर्सनल स्टोरेज (PST) फ़ाइल में दूसरी फ़ोल्डर में ले जाया जाए। इसमें शामिल हैं:

निर्दिष्ट फ़ोल्डर को नए पैरेंट फ़ोल्डर में ले जाना।
निर्दिष्ट संदेशों को एक नए फ़ोल्डर में ले जाना।
सामग्री को नई फ़ोल्डर में ले जाना।
उप-फ़ोल्डरों को नए पैरेंट फ़ोल्डर में ले जाना।

निम्नलिखित कोड स्निपेट दिखाता है कि कैसे स्रोत फ़ोल्डर से संदेश और फ़ोल्डर जैसी वस्तुओं को उसी PST फ़ाइल में दूसरी फ़ोल्डर में ले जाया जाए।

संदेश गुणों को अपडेट करें

कभी-कभी संदेशों के कुछ गुणों को संशोधित करने की आवश्यकता होती है, जैसे विषय बदलना, संदेश की महत्त्वता को चिह्नित करना आदि। PST फ़ाइल में इन गुणों को अपडेट करने के लिए आप उपयोग कर सकते हैं FolderInfo.change_messages Aspose.Email for Python द्वारा प्रदान किया गया मेथड। यह लेख संदेश गुणों को बड़े पैमाने पर अपडेट करने की प्रक्रिया को दर्शाता है, जिससे PST फ़ाइल में कई संदेशों पर स्वचालित समायोजन संभव होते हैं। नीचे एक कोड स्निपेट है जो विभिन्न संदेश गुणों पर बड़े पैमाने पर अपडेट करने का तरीका दिखाता है।

from aspose.email.storage.pst import PersonalStorage, PersonalStorageQueryBuilder
from aspose.email.mapi import MapiPropertyTag, MapiProperty, MapiPropertyCollection

pst_file_path = data_dir + "ya4demia04vb.pst"

# Load the Outlook PST file
with PersonalStorage.from_file(pst_file_path) as personal_storage:
    # Get the required subfolder
    inbox = personal_storage.root_folder.get_sub_folder("Inbox")

    # Find messages having From = "someuser@domain.com"
    query_builder = PersonalStorageQueryBuilder()
    query_builder.from_address.contains("someuser@domain.com")

    # Get contents from query
    messages = inbox.get_contents(query_builder.get_query())

    # Save (MessageInfo, EntryIdString) in a list
    change_list = [message_info.entry_id_string for message_info in messages]

    # Compose the new properties
    updated_properties = MapiPropertyCollection()
    updated_properties.add(
        MapiPropertyTag.SUBJECT_W,
        MapiProperty(MapiPropertyTag.SUBJECT_W, "New Subject".encode("utf-16le"))
    )
    updated_properties.add(
        MapiPropertyTag.IMPORTANCE,
        MapiProperty(MapiPropertyTag.IMPORTANCE, bytearray([0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]))
    )

    # Update messages having From = "someuser@domain.com" with new properties
    inbox.change_messages(change_list, updated_properties)

कस्टम MAPI गुणों को संशोधित करें

कभी-कभी आपको PST फ़ाइल में प्रोसेस किए गए आइटम्स को पहचानने और MARK करने की आवश्यकता हो सकती है। Aspose.Email API इस कार्य के लिए एक समाधान प्रदान करता है, उपयोग करके MapiProperty और MapiNamedProperty क्लासेस। ये क्लासेस आपको प्रोसेस किए गए आइटम्स को कस्टम प्रॉपर्टीज़ असाइन करके लेबल करने में सक्षम बनाते हैं। नीचे, आप उन मेथड्स को पाएँगे जो इस मार्किंग प्रक्रिया को पूरा करने में विशेष रूप से उपयोगी हैं:

MapiNamedProperty(long propertyTag, string nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
MapiNamedProperty(long propertyTag, long nameIdentifier, UUID propertyGuid, bytearray[] propertyValue)
FolderInfo.change_messages(MapiPropertyCollection updatedProperties) - फ़ोल्डर में सभी संदेशों को बदलता है
PersonalStorage.change_message(string entryId, MapiPropertyCollection updatedProperties) - संदेश गुण बदलता है

from uuid import UUID
from aspose.email.storage.pst import PersonalStorage
from aspose.email.mapi import MapiNamedProperty, MapiPropertyCollection
from aspose.email.mapi import MapiPropertyType, MapiProperty, MapiPropertyTag

def generate_named_property_tag(index, data_type):
    return (((0x8000 | index) << 16) | data_type) & 0x00000000FFFFFFFF

def run():
    # Load the Outlook file
    pst_file_path = data_dir + "my.pst"

    with PersonalStorage.from_file(pst_file_path) as personal_storage:
        test_folder = personal_storage.root_folder.get_sub_folder("Inbox")

        # Create the collection of message properties for adding or updating
        new_properties = MapiPropertyCollection()

        # Normal, Custom, and PidLidLogFlags named properties
        mapi_property = MapiProperty(
            MapiPropertyTag.ORG_EMAIL_ADDR_W,
            "test_address@org.com".encode("utf-16le")
        )
        named_property1 = MapiNamedProperty(
            generate_named_property_tag(0, MapiPropertyType.LONG),
            "ITEM_ID",
            UUID("00000000-0000-0000-0000-000000000000"),
            bytearray([0x7B, 0x00, 0x00, 0x00])
        )
        named_property2 = MapiNamedProperty(
            generate_named_property_tag(1, MapiPropertyType.LONG),
            0x0000870C,
            UUID("0006200A-0000-0000-C000-000000000046"),
            bytearray([0x00, 0x00, 0x00, 0x00])
        )
        new_properties.add(named_property1.tag, named_property1)
        new_properties.add(named_property2.tag, named_property2)
        new_properties.add(mapi_property.tag, mapi_property)
        test_folder.change_messages(test_folder.enumerate_messages_entry_id(), new_properties)

# Usage
run()

Outlook PST फ़ाइलों से संदेशों और फ़ोल्डरों को हटाएँ

Outlook PST फ़ाइलों की सामग्री का प्रबंधन अक्सर अनावश्यक संदेशों, फ़ोल्डरों या कई आइटम्स को एक साथ हटाने में शामिल होता है। Aspose.Email for Python via .NET PST फ़ाइल से संदेशों और फ़ोल्डरों को हटाने के लिए कुशल मेथड प्रदान करता है, चाहे आपको व्यक्तिगत ईमेल हटाने की जरूरत हो, FolderInfo.delete_child_item() मेथड, या बड़े पैमाने पर हटाने करें, FolderInfo.delete_child_items() मेथड, बेहतर फ़ाइल प्रबंधन के लिए।

PST फ़ाइलों से संदेश हटाएँ

Aspose.Email प्रदान करता है FolderInfo क्लास जिसका उपयोग PST फ़ाइल में विशिष्ट फ़ोल्डरों तक पहुँचने के लिए किया जाता है। नीचे दिया गया कोड नमूना दर्शाता है कि कैसे इस क्लास का उपयोग करके पहले लोड या बनाए गए PST फ़ाइलों के Sent उपफ़ोल्डर से संदेशों तक पहुंचें और उन्हें हटाएं। विशेष रूप से, यह संदेशों की संख्या प्राप्त करता है और "Sent Items" फ़ोल्डर में पहला आइटम हटाता है।

एक PST ऑब्जेक्ट को निर्दिष्ट निर्देशिका में स्थित "Outlook.pst" फ़ाइल को खोलकर प्रारंभ किया जाता है, उपयोग करके PersonalStorage.from_file().
Sent Items फ़ोल्डर को उपयोग करके एक्सेस किया जाता है pst.get_predefined_folder(StandardIpmFolder.SENT_ITEMS).
फिर, कोड "Sent Items" फ़ोल्डर की सामग्री प्राप्त करता है, उपयोग करके folder.get_contents(), उन्हें गिनता है, और इस फ़ोल्डर में कुल संदेशों की संख्या प्रिंट करता है।
कोड "Sent Items" फ़ोल्डर में पहला संदेश msgsColl[0] के साथ एक्सेस करता है और इसे उपयोग करके हटाता है folder.delete_child_item(msgInfo.entry_id). यह फ़ंक्शन संदेश के एंट्री आईडी का उपयोग करके उसे फ़ोल्डर से हटाता है।

डिलीट करने के बाद, कोड फिर से "Sent Items" फ़ोल्डर में संदेशों की गिनती करता है और अपडेटेड काउंट प्रिंट करता है।

PST फ़ाइलों से वस्तुएँ हटाएँ

कई मैसेजिंग सिस्टम्स या ईमेल क्लाइंट्स में, प्रत्येक आइटम (जैसे ईमेल, अपॉइंटमेंट, या टास्क) को एक अनूठा पहचानकर्ता, जिसे एंट्री आईडी कहा जाता है, असाइन किया जाता है। delete_item(entry_id) विधि FolderInfo क्लास इस एंट्री आईडी को पैरामीटर के रूप में लेती है और संदेश स्टोर से संबंधित आइटम को हटाती है। संदेश स्टोर से एक आइटम को डिलीट करने के लिए नीचे दिया गया कोड उपयोग करें:

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

pst.delete_item(entry_id)

बड़े पैमाने पर आइटम्स हटाएँ

Aspose.Email API का उपयोग करके PST फ़ाइल से वस्तुओं को बल्क में हटाया जा सकता है। यह उपयोग करके प्राप्त किया जाता है delete_child_items() मेथड जो डिलीट किए जाने वाले आइटम्स के एंट्री आईडी की सूची को स्वीकार करता है। निम्नलिखित कोड स्निपेट दिखाता है कि कैसे PST फ़ाइल से आइटम्स को बड़े पैमाने पर डिलीट किया जाए।

PST फ़ाइलों से फ़ोल्डर हटाएँ

Outlook PST फ़ाइलों में ऐसे फ़ोल्डर हो सकते हैं जो अब आवश्यक नहीं हैं। Aspose.Email for Python via .NET आपको इन फ़ोल्डरों को या तो Deleted Items फ़ोल्डर में स्थानांतरित करके (पुनः प्राप्ति योग्य बनाकर) या स्थायी रूप से हटाकर डिलीट करने की अनुमति देता है। नीचे दिए गए उदाहरण दोनों तरीकों को दर्शाते हैं।

फ़ोल्डर को Deleted Items में ले जाएँ (सॉफ्ट डिलीट)

यह move_item विधि PersonalStorage क्लास फ़ोल्डरों को बाद में पुनर्प्राप्त करने की अनुमति देता है, क्योंकि वे स्थायी रूप से नहीं हटाए जाते बल्कि Deleted Items फ़ोल्डर में स्थानांतरित होते हैं। नीचे दिया गया कोड स्निपेट दिखाता है कि इस मेथड को एक पायथन प्रोजेक्ट में कैसे लागू किया जाए:

import aspose.email as ae

pst = ae.storage.pst.PersonalStorage.from_file("my.pst")

deleted_items_folder = pst.get_predefined_folder(ae.storage.pst.StandardIpmFolder.DELETED_ITEMS)
empty_folder = pst.root_folder.get_sub_folder("Empty folder")
some_folder = pst.root_folder.get_sub_folder("Some folder")
pst.move_item(empty_folder, deleted_items_folder)
pst.move_item(some_folder, deleted_items_folder)

इस विधि का लाभ यह है कि हटाए गए फ़ोल्डर को आसानी से पुनः प्राप्त किया जा सकता है।

Deleted Items से फ़ोल्डर को पुनर्स्थापित करें

यह move_item यदि कोई फ़ोल्डर गलती से हटाया गया हो, तो यह मेथड उसे Deleted Items से वापस उसकी मूल लोकेशन में ले जाकर पुनर्स्थापित करने की अनुमति देता है।

some_folder = pst.root_folder.get_sub_folder("Some folder")
pst.move_item(some_folder, pst.root_folder)

Deleted Items से फ़ोल्डर को स्थायी रूप से हटाएँ

यह delete_child_item यदि आप किसी सबफ़ोल्डर को तुरंत और स्थायी रूप से Deleted Items फ़ोल्डर को बायपास करके हटाना चाहते हैं, तो यह मेथड किसी भी फ़ोल्डर के लिए उपयोग किया जा सकता है। नीचे दिया गया कोड नमूना दिखाता है कि कैसे फ़ोल्डर को Deleted Items से पूरी तरह हटाया जाए, जिससे पुनर्स्थापना असंभव हो जाए:

deleted_items_folder.delete_child_item(empty_folder.entry_id)

फ़ोल्डर को तुरंत स्थायी रूप से हटाएँ

यदि किसी फ़ोल्डर को Deleted Items में स्थानांतरित किए बिना हटाया जाना चाहिए, तो delete_child_item मेथड तुरंत और स्थायी हटाने को सुनिश्चित करता है।

some_folder = pst.root_folder.get_sub_folder("Some folder")
pst.root_folder.delete_child_item(some_folder.entry_id)

क्षतिग्रस्त PST/OST फ़ाइलों को पढ़ना PST फ़ाइल पासवर्ड सुरक्षा प्रबंधन