Proton होमपेज

Sieve फ़िल्टर (ऐडवांस कस्टम फिल्टर)

पढ़ने का समय
13 मिनट
श्रेणी
ईमेल प्राप्त करें और पढ़ें

Proton Mail उपयोगकर्ताओं को टैग लगाकर या उन्हें फोल्डर में सॉर्ट करके ईमेल को अपने-आप फ़िल्टर करने के कई तरीके देता है। आम तौर पर, तीन तरीके हैं:

  1. ब्लॉक लिस्ट और अनुमति-प्राप्त लिस्ट में भेजने वालों को जोड़ना, ताकि वो हमेशा या कभी भी स्पैम फोल्डर में न जाएं;
  2. Proton Mail के इंटरैक्टिव इंटरफ़ेस का इस्तेमाल करके एक कस्टम फिल्टर बनाना;
  3. [सबसे ज़्यादा ऐडवांस] Sieve में कस्टम फ़िल्टर बनाना।

इन तरीकों में, Sieve में कस्टम फ़िल्टर बनाना सबसे ज़्यादा वर्सेटाइल है, लेकिन इसका इस्तेमाल करना भी मुश्किल है। इसीलिए, हम Sieve को कुछ तकनीकी अनुभव रखने वाले उपयोगकर्ताओं के लिए एक ऐडवांस सुविधा मानते हैं। ज़्यादातर उपयोगकर्ताओं के लिए, इंटरैक्टिव इंटरफेस ज़रूरी कस्टम फिल्टर बनाने के लिए काफी है।

विषय-सूची

Sieve क्या है?

Sieve एक प्रोग्रामिंग भाषा है जिसका इस्तेमाल ईमेल फ़िल्टर करने के लिए होता है। आप आसान नियम लिखकर Sieve में फिल्टर बना सकते हैं। उदाहरण के लिए, “Kyle के सारे संदेशों को हरा लेबल दो”। इन नियमों को जोड़कर एक बेहतरीन फ़िल्टरिंग सिस्टम बनाया जा सकता है।

आप Sieve नियम शुरू से लिख सकते हैं, इस लेख के उदाहरणों जैसे उदाहरणों से ले सकते हैं, या ऐसा सॉफ्टवेयर इस्तेमाल कर सकते हैं जो काम आसान बनाता है।

असल में, हम आपको इंटरैक्टिव इंटरफेस का इस्तेमाल करके Sieve फिल्टर बनाने का तरीका पहले ही दे चुके हैं, जो आपके डाले गए इनपुट का इस्तेमाल करके Sieve फिल्टर बनाता है। Sieve सीखने का एक और अच्छा तरीका ये है कि इंटरैक्टिव इंटरफेस का इस्तेमाल करके फिल्टर बनाएं और फिर उन्हें Sieve में बदलें, क्योंकि इंटरैक्टिव इंटरफेस खुद Sieve के एक हिस्से का इस्तेमाल करता है।

उदाहरण के लिए, इंटरैक्टिव इंटरफेस का इस्तेमाल करके बनाए गए नीचे दिए गए फ़िल्टर की तुलना करें…

(नई विंडो)


… Sieve एडिटर में देखे गए उसी फ़िल्टर के कोड के साथ:

(नई विंडो)

ये लेख आपको Sieve से परिचित कराएगा और समझाएगा कि अपने Sieve फ़िल्टर कैसे लिखें। अगर Sieve के इस्तेमाल के बारे में और जानकारी चाहिए, तो ऑनलाइन कई अन्य ट्यूटोरियल मदद कर सकते हैं। अगर Proton Mail में Sieve के बारे में कोई सवाल है जिसका जवाब इस पेज पे नहीं मिला, तो सहायता टीम से यहां संपर्क कर सकते हैं।\u00a0

शुरूआत

Sieve फिल्टर बनाना शुरू करने के लिए, mail.proton.me(नई विंडो) पे लॉगइन करें और Settings → All settings → Proton Mail → Filters → Add sieve filter पे जाएं।

(नई विंडो)

Sieve स्क्रिप्ट कमांड की सूची से बनी होती है। ज़्यादातर स्क्रिप्ट में ये require कमांड से शुरू होती है। require कमांड एक एक्सटेंशन लोड करता है जो कोई खास सुविधा देता है। उदाहरण के लिए, किसी संदेश को लेबल देने या फोल्डर में डालने के लिए, हमें fileinto कमांड चाहिए।

इस कमांड को लोड करने के लिए, हम बस ये लिखते हैं:

require "fileinto";

कई एक्सटेंशन लोड करने के लिए, आप सूची का इस्तेमाल कर सकते हैं:

require ["fileinto", "imap4flags"];

इस मामले में, imap4flags एक एक्सटेंशन लोड करता है जो मेल को पढ़ा हुआ मार्क करने की अनुमति देता है। require कमांड के बाद, अक्सर आप आने वाले संदेश पर कुछ टेस्ट करते हैं। ये if और किसी दूसरे कमांड जैसे address या header को जोड़कर किया जाता है।

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

require ["fileinto", "imap4flags"];
# I don't really like Spott
if address :is "from" "Spott.Tenerman@northpark.example.com"
{ 
    addflag "\\Seen";
    fileinto "enemies";
}

ध्यान रखें कि # चिन्ह किसी टिप्पणी को दर्शाता है और उसे Sieve स्क्रिप्ट का हिस्सा नहीं माना जाता। इसके अलावा, आपके सेट किए गए फोल्डर या लेबल (यहां enemies) आपके एनवायरनमेंट में मौजूद होने चाहिए: फोल्डर और लेबल बनाना आप यहां सीख सकते हैं। ये फ़िल्टर डालने के बाद, SAVE बटन दबाएं। अब आपका फ़िल्टर हर आने वाले ईमेल पे चलेगा।

बेशक, हो सकता है कि आप कई भेजने वालों के ईमेल एक ही फोल्डर में डालना चाहें। ऐसे में, आप address कमांड को स्ट्रिंग की सूची दे सकते हैं (स्ट्रिंग(नई विंडो) किरदारों की एक श्रृंखला होती है, इस मामले में ईमेल पता):

require ["fileinto", "imap4flags"];
# I don't really like Spott and Kyyyhel
if address :is "from" ["Spott.Tenerman@northpark.example.com", "Kyhel.Broski@northpark.example.com"]
{ 
    addflag "\\Seen";
    fileinto "enemies";
}

ध्यान रखें कि जब भी आप किसी टेस्ट कंडीशन को स्ट्रिंग दे सकते हैं, तो आम तौर पर सूची भी दे सकते हैं। फिर वो सूची में मौजूद किसी भी स्ट्रिंग को आज़माकर मैच ढूंढने की कोशिश करेगा। ये fileinto, addflag, वगैरह जैसे कमांड पे लागू नहीं होता।

लेकिन Sieve सिर्फ आपके मेलबॉक्स को दोबारा व्यवस्थित करने से ज़्यादा ताकतवर है। ये आपको जवाबी संदेश के साथ ईमेल अस्वीकार करने की भी अनुमति देता है:

require "reject";
# Reject mails that spell my name wrong
if header :contains "subject" "Kyhel"
{
    reject "My name is not Kyhel";
}

टेस्ट का इस्तेमाल करना

Sieve में टेस्ट जोड़ना

जैसा हमने शुरूआत सेक्शन में दिखाया था, आप आने वाले संदेशों पे if कमांड का इस्तेमाल करके टेस्ट कर सकते हैं, ताकि पता चले कि किसी ईमेल पे require कमांड लागू होगा या नहीं।

if कमांड के अलावा, कुछ दूसरे टेस्ट कमांड भी हैं जो आपको अपनी स्क्रिप्ट को आसान तरीके से व्यवस्थित करने की अनुमति देते हैं।

Else

else कमांड आपको कुछ करने की अनुमति देता है जब if कमांड ने अपने कार्य निभाए नहीं। इसका एक उदाहरण ये है:

require ["fileinto"];
# If the subject contains something incomprehensible, then put the mail into the kenny folder
if header :contains "subject" "mmph mmph"
{
    fileinto "Kenny";
} else { 
    fileinto "Understandable";
}

यहां, अगर विषय बिल्कुल mmph mmph है, तो ईमेल Kenny फोल्डर में ले जाया जाएगा। दूसरे मामले में (यानी जब विषय बिल्कुल mmph mmph नहीं है), ईमेल Understandable फोल्डर में ले जाया जाएगा।

Elsif

elsif, else if का संकुचित रूप है। else कमांड की तरह, ये तब निष्पादित होगा जब if कंडीशन गलत हो, लेकिन तभी जब elsif कंडीशन सही हो। अगर elsif सही नहीं है, तो अगला elsif या else ब्लॉक निष्पादित होगा।

require ["fileinto", "imap4flags"];
# If the subject contains something incomprehensible, then put the mail into the kenny folder
if header :contains "subject" "mmph mmph"
{
    fileinto "Kenny";
# Kyhel sends me only speeches
} elsif address :is "from" "Kyhel.Broski@northpark.example.com" { 
    fileinto "Speeches";
} else { 
# otherwise the mail is important, so add a star.
    addflag "\\Flagged";
}

ध्यान रखें कि एक बार के चलने में if, elsif, या else ब्लॉक में से सिर्फ एक ही निष्पादित होगा।

Anyof

कभी-कभी, आपको कोई कमांड तब चलाना होता है जब कई टेस्ट में से कोई एक सफल हो जाए। इसके लिए, आप anyof कमांड का इस्तेमाल कर सकते हैं। ये anyof लिखकर, उसके बाद कोष्ठक ‘(’, आपके टेस्ट करने वाले स्टेटमेंट जो कॉमा से अलग हैं, और बंद कोष्ठक ‘)’ लगाकर किया जाता है।

require ["fileinto", "imap4flags"];
# Kenny either sends from kenny@northpark.example.com or puts "mmph mmph" in the subject.
   if anyof(address :is "from" "kenny@northpark.example.com", header :contains "subject" "mmph mmph")
{
    fileinto "Kenny";
}

ये स्क्रिप्ट उन संदेशों को, जो kenny@northpark.example.com से आते हैं या जिनकी विषय पंक्ति में mmph mmph होता है, फोल्डर Kenny. में डाल देगी

Allof

anyof की जोड़ी भी मौजूद है: allof। ये आपको कोई कमांड तभी चलाने की अनुमति देता है जब दी गई सारी शर्तें मैच करती हैं:

require ["fileinto", "imap4flags"];
# Kenny always sends me mails with mmph mmph
if allof(address :is "from" "Kenny@northpark.example.com", header :contains "subject" "mmph mmph")
{
    fileinto "Kenny";
}


ये स्क्रिप्ट उन संदेशों को Kenny फोल्डर में डाल देगी जो kenny@northpark.example.com से आते हैं और जिनके विषय में mmph mmph होता है।

Not

आखिर में, कभी-कभी आपको कोई कमांड तब लागू करना होता है जब कोई चीज़ मैच नहीं करती। स्टेटमेंट के आगे not जोड़ने से ये हो जाएगा:

require ["fileinto", "imap4flags"];
# If a subject line does not contain real guitar put it into the young people folder
if not header :contains "subject" "real guitar"
{
    fileinto "Young people";
}

जो इसके बराबर है:

require ["fileinto", "imap4flags"];
# The else part will be evaluated if the condition is not true
if header :contains "subject" "real guitar"
{
    # do nothing
} else {
    fileinto "Young people";
}

ये सारे ईमेल, जिनके विषय में real guitar नहीं होता, Young people फोल्डर में डाल देगा।

बेशक, इन सारे टेस्ट को एक साथ जोड़ना भी संभव है। उदाहरण के लिए, हो सकता है कि आप किसी ईमेल को तारांकित करना चाहें अगर वो Kenny से नहीं है और उसके विषय में mmph mmph नहीं है:

require ["fileinto", "imap4flags"];
if not anyof (    header :contains "subject" "mmph mmph", 
    address :is "from" "Kyhel.Broski@northpark.example.com" ) { 
    addflag "\\Flagged";
}

हैडर पर टेस्ट करना

address कमांड का इस्तेमाल करके आप पता हैडर पर टेस्ट कर सकते हैं, जैसे from, to, और sender हैडर। आप नीचे दिए गए फ़्लैग में से किसी एक का इस्तेमाल करके ईमेल पते के अलग-अलग हिस्से निकाल सकते हैं:

    \n
  • :localpart — @ चिन्ह (@) से पहले का हिस्सा
    • \n \n
  • :domain — @ चिन्ह (@) के बाद का हिस्सा
    • \n
  • :all — पूरा पता

नीचे दिया गया स्निपेट इस कमांड के इस्तेमाल को समझाता है:

require ["fileinto", "imap4flags"];
# Northpark people are made of paper, springfield are mostly yellow
if address :domain "from" "northpark.example.com"
{
    fileinto "PaperPeople";
} elsif address :domain "from" "springfield.example.com"{
    fileinto "YellowPeople";
}
if address :localpart "from" "chef"
{
    addflag "\\Flagged";
}

संक्षेप में, ये स्क्रिप्ट northpark.example.com डोमेन से भेजी गई सब चीज़ को PaperPeople में और springfield.example.com को YellowPeople में डाल देगी।

इसके अलावा, चाहे ईमेल किसी भी डोमेन से भेजा गया हो, अगर @ से पहले का हिस्सा chef के बराबर है (उदाहरण के लिए chef@example.com), तो संदेश फ़्लैग हो जाएगा। एक दिलचस्प इस्तेमाल ये भी है कि किसी एक पते पे भेजी गई सब चीज़ को अपने-आप एक फोल्डर में सेव कर लिया जाए:

require ["fileinto", "imap4flags"];
# Put support mail in a separate organized folder
if address :localpart "to" "support"
{
    fileinto "Support";
}

ऐडवांस

envelope कमांड आपको और टेस्ट करने की अनुमति देता है। आम तौर पर, address टेस्ट सिर्फ हैडर से मान निकालता है। हालांकि, SMTP सत्र में हैडर में मौजूद पते से अलग कोई from पता बताया जा सकता है।

Proton Mail हैडर इंटरफेस में, envelope-from, return-path हैडर के बराबर होता है और envelope-to, x-original-to हैडर के बराबर होता है।

envelope कमांड का इस्तेमाल करके आप एनवेलप से असली to: और from: पते निकाल सकते हैं। ध्यान रखें कि इन दोनों के अलावा कोई और फील्ड मौजूद नहीं है, इसलिए इस कमांड में sender मौजूद नहीं है। कृपया ध्यान रखें कि envelope एक एक्सटेंशन में है और इसलिए आपको पहले इस एक्सटेंशन को require करना होगा।

require ["fileinto", "imap4flags", "envelope"];
# Northpark people are made of paper, springfield are mostly purple
if envelope :domain "from" "northpark.example.com"
{
    fileinto "PaperPeople";
} elsif envelope :domain "from" "springfield.example.com"{
    fileinto "PurplePeople";
}
if envelope :localpart "from" "chef"
{
    addflag "\\Flagged";
}

दो मानों की जांच के लिए कंपैरेटर का इस्तेमाल करना

जब कोई टेस्ट दो मानों की जांच करता है, तो कंपैरेटर नाम के अलग-अलग फ़्लैग का इस्तेमाल करके ये बताना संभव है कि ये तुलना कैसे की जाएगी। पहले ही, हम दो कंपैरेटर इस्तेमाल कर चुके हैं: :is और :contains, जो जांचते हैं कि दी गई स्ट्रिंग खास मान के बिल्कुल बराबर है, और खास मान में दी गई स्ट्रिंग है, जैसा नीचे दिए गए टेस्ट में है।

require ["fileinto", "imap4flags"];
if not anyof (
    header :contains "subject" "mmph mmph", # the subject contains mmph mmph 
    address :is "from" "Kyhel.Broski@northpark.example.com" # the recipient is exactly Kyhel.Broski@northpark.example.com
) { 
    addflag "\\Flagged";
}

:matches कंपैरेटर का इस्तेमाल ज़्यादा खास फॉर्मैट तय करने के लिए भी हो सकता है। ये दोनों मानों की शुरू से अंत तक तुलना करेगा, बिल्कुल :is कंपैरेटर की तरह। हालांकि, :matches के मामले में, आपके तय किए गए मान में ? और * मान हो सकते हैं। सवाल चिन्ह एक किरदार से मैच करेगा, और तारा (वाइल्डकार्ड कहा जाता है) शून्य या उससे ज़्यादा किरदारों से मैच करेगा।

इस फॉर्मैट के साथ, आप ये टेस्ट बना सकते हैं:

require ["fileinto", "imap4flags"];
if header :matches "subject" "mmph*" { 
    addflag "\\Flagged";
}

इस उदाहरण में, टेस्ट सफल होगा अगर संदेश का विषय mmph से शुरू होता है और उसके बाद कोई भी किरदार या किरदार होते हैं। दूसरे शब्दों में, जब विषय ‘mmph’ से शुरू होगा तो ईमेल फ़्लैग होगा। ‘mmph mmph’ और ‘mmph mmph Hello’ दोनों मैच करेंगे; ‘Hello mmph’ और ‘Springfield sales’ नहीं करेंगे।

तारे का इस्तेमाल मान के बीच में भी किया जा सकता है और कई बार भी, जैसे:

require ["fileinto", "imap4flags"];
if header :matches "subject" "mmph *mmph *mmph" { 
    addflag "\\Flagged";
}

ये टेस्ट मैच करेगा अगर विषय ‘mmph ’ (स्पेस के साथ) से शुरू होता है, उसमें एक और ‘mmph ’ (स्पेस के साथ) होता है, और ‘mmph’ (स्पेस के बिना) पे खत्म होता है। मैच करने वाले विषय हैं ‘mmph mmph mmph’, ‘mmph mmph mmphmmph’ या ‘mmph is mmph and mmph’।

ये :matches कंपैरेटर पतों की तुलना के साथ बहुत काम आ सकता है। जैसा कि आप जानते होंगे, Proton Mail के कई डोमेन हैं: protonmail.com और proton.me। अगर आप जांचना चाहते हैं कि कोई संदेश Proton Mail उपयोगकर्ता से आ रहा है, तो ये स्क्रिप्ट इस्तेमाल कर सकते हैं:

require ["fileinto", "imap4flags"];
# Put support mail in a separate organized folder
if address :domain :matches "from" "protonmail.*"
{
    fileinto "Internal";
}

अगर किसी वजह से आपको किरदार * या ? को बिल्कुल मैच करना है, तो आप उन्हें आगे \\ जोड़कर कोट कर सकते हैं: \\* तारे से मैच करेगा और \\? सवाल चिन्ह से मैच करेगा।

ध्यान रखें कि हम regex एक्सटेंशन भी सपोर्ट करते हैं, जो :regex कंपैरेटर भी तय करता है। ये कंपैरेटर :matches का ज़्यादा सटीक रूप है, लेकिन बहुत जटिल है। और जानकारी के लिए, कृपया आधिकारिक दस्तावेज़(नई विंडो) पढ़ें।

कुछ मामलों में (जैसा आपको इस लेख के आगे देखने को मिलेगा), हो सकता है कि आप संख्यात्मक मानों की तुलना करना चाहें। relational पैकेज इसी इस्तेमाल के लिए बना है। ये पैकेज :value कंपैरेटर तय करता है जिसके बाद तुलना का टाइप आता है।

ये आपको जांचने की अनुमति देता है कि कोई मान दिए गए मान से बड़ा है (तुलना टाइप “gt” होने पर), बड़ा या बराबर है (“ge”), बराबर है (“eq”), छोटा या बराबर है (“le”) या छोटा है (“lt”)।

संख्यात्मक मानों की तुलना करते समय, comparator-i;ascii-numeric पैकेज भी बहुत उपयोगी है। ये स्क्रिप्ट इंटरप्रेटर को बताता है कि स्ट्रिंग का कंटेंट एक संख्या है, न कि एक साधारण स्ट्रिंग। इसे टेस्ट में :comparator “i;ascii-numeric” जोड़कर इस्तेमाल किया जा सकता है।

इन सब जानकारी के साथ, हम निम्न स्क्रिप्ट बना सकते हैं:

require ["fileinto", "relational", "comparator-i;ascii-numeric"];  
if header :value "ge" :comparator "i;ascii-numeric" "subject" "2"   
{    
 fileinto "Dummy example";
}

ये टेस्ट संदेश को Dummy example फोल्डर में ले जाएगा अगर विषय 2 से बड़ा या बराबर है। अगर विषय कोई संख्या नहीं, लेकिन लिखा हुआ टेक्स्ट है, तो टेस्ट असफल होगा। ऐसे में, ये उदाहरण बहुत बेवकूफी भरा लगता है, लेकिन इसे date जैसे दूसरे एक्सटेंशन के साथ जोड़कर इस्तेमाल करने के लिए है, जिसे हम इस लेख में आगे तय करेंगे।

Sieve में कॉन्टेक्स्ट के साथ तुलना

आप एक्सटेंशन का इस्तेमाल करके अपने खाते और आम तौर पर Proton Mail कॉन्टेक्स्ट से जुड़ी जानकारी भी एक्सेस कर सकते हैं। उदाहरण के लिए, आप जांच सकते हैं कि भेजने वाले का पता आपकी कॉन्टैक्ट सूची में है या नहीं।

अपनी कॉन्टैक्ट सूची एक्सेस करना

आप extlists एक्सटेंशन का इस्तेमाल करके अपनी कॉन्टैक्ट सूची एक्सेस कर सकते हैं। हैडर टेस्ट के साथ जोड़कर, आप जांच सकते हैं कि कोई कॉन्टैक्ट आपकी कॉन्टैक्ट सूची में है या नहीं।

require ["fileinto", "extlists"];  
# Checks that the sender is in your personal address book
if header :list "from" ":addrbook:personal?label=Family"   
{    
 fileinto "Known"; 
}

ये टेस्ट किसी संदेश को Known लेबल से फ़्लैग करेगा अगर भेजने वाला सूची :addrbook:personal?label=Family में मौजूद है। सूची को दो हिस्सों में बांटा जा सकता है। पहला, :addrbook:personal का मतलब है कि पता आपकी निजी एड्रेस बुक में है। दूसरा, label=Family सूची को और सीमित करता है, ये बताते हुए कि आपकी एड्रेस बुक में होने के अलावा, कॉन्टैक्ट का Family कॉन्टैक्ट ग्रुप से भी संबंध होना चाहिए। ज़रूरत पड़े तो, आप इस लेबल को दूसरे कॉन्टैक्ट ग्रुप में बदल सकते हैं। चाहें तो :addrbook:personal?label=Work इस्तेमाल कर सकते हैं, ऐसे में टेस्ट तभी सफल होगा जब भेजने वाला आपकी एड्रेस बुक और Work कॉन्टैक्ट ग्रुप, दोनों में हो।

ज़्यादा सामान्य तौर पर, कोई सूची Tag URI Scheme(नई विंडो) का पालन करती है, और आप अपने फिल्टर को सीमित करने के लिए अतिरिक्त पैरामीटर जोड़ सकते हैं। फिर आप इस सूची का इस्तेमाल इस तरह कर सकते हैं:

require ["fileinto", "extlists"];  
# replace :your:list:here by the list you want to use
if header :list "from" ":your:list:here"
{    
 # some actions... 
}

हमने चार अलग-अलग सूचियां दी हैं:

  • :addrbook:personal¹ जांचता है कि पता आपकी कॉन्टैक्ट सूची में है या नहीं। सूची label पैरामीटर स्वीकार करती है जो किसी खास कॉन्टैक्ट ग्रुप से मैच करता है। इस पैरामीटर को चार सब-वर्ज़न में बांटा जा सकता है:
    • :addrbook:personal?label=something उस कॉन्टैक्ट से मैच करेगी जो “something” कॉन्टैक्ट ग्रुप में है;
    • :addrbook:personal?label.starts-with=something उस कॉन्टैक्ट से मैच करेगी जो कम से कम एक ऐसे ग्रुप से संबंध रखता है जो “something” से शुरू होता है;
    • :addrbook:personal?label.ends-with=something उस कॉन्टैक्ट से मैच करेगी जो कम से कम एक ऐसे ग्रुप से संबंध रखता है जो “something” पे खत्म होता है;
    • :addrbook:personal?label.contains=something उस कॉन्टैक्ट से मैच करेगी जो कम से कम एक ऐसे ग्रुप से संबंध रखता है जिसमें “something” होता है।

आप मैच होने वाले ईमेल से जुड़ी क्रिप्टोग्राफिक जानकारी भी एक्सेस कर सकते हैं:

  • :addrbook:personal?keypinning=true उस कॉन्टैक्ट से मैच करेगी जिसके पास विश्वसनीय चाबी है। true को false में बदलने पर उस कॉन्टैक्ट से मैच होगा जिसके पास विश्वसनीय चाबी नहीं है;
  • :addrbook:personal?encryption=true उस कॉन्टैक्ट से मैच करेगी जिसके लिए एन्क्रिप्शन सक्षम है। true को false में बदलने पर उस कॉन्टैक्ट से मैच होगा जिसके लिए एन्क्रिप्शन सेटअप नहीं है या अक्षम है;
  • :addrbook:personal?signing=true उस कॉन्टैक्ट से मैच करेगी जिसके लिए साइनिंग सक्षम है। true को false में बदलने पर उस कॉन्टैक्ट से मैच होगा जिसके लिए साइनिंग अक्षम है।
  • :addrbook:myself¹ हर उस पते से मैच करती है जो आपके अपने हैं;
  • :addrbook:organization हर उस पते से मैच करती है जो उस संगठन के किसी सदस्य के हैं जिसके आप सदस्य हैं;
  • :incomingdefaults:inbox जांचती है कि पता आपकी अनुमति-प्राप्त लिस्ट में है या नहीं;
  • :incomingdefaults:spam जांचती है कि पता आपकी ब्लॉक लिस्ट में है या नहीं।

वेरिएबल एक्सटेंशन के साथ जोड़कर (जो अगले पैराग्राफ में बताया गया है), मैच होने वाले वेरिएबल बदल जाएंगे। मैच होने वाला वेरिएबल ${0} हमेशा तय की गई सूची में मौजूद आखिरी ईमेल पते को रखेगा। अगर सूची को नोट 1 से मार्क किया गया था, तो मैच होने वाला वेरिएबल ${1} डिस्प्ले नाम रखेगा।

उदाहरण के लिए, नीचे दी गई सूचियों के साथ, आप एक ऐसा फ़िल्टर बना सकते हैं जो आपके परिवार या व्हाइटलिस्ट में मौजूद किसी व्यक्ति के अलावा किसी और से मिले किसी भी ईमेल को मिटा देगा:

require "extlists";  
# checks that the sender is not in the contact group Family, whilelisted or yourself
if not anyof(
    header :list "from" ":addrbook:personal?label=Family", 
    header :list "from" ":incomingdefaults:inbox",
    header :list "from" ":addrbook:myself"
) {    
  discard; # permanently delete the email
}

अगर वो कंडीशन पूरी होती है, तो discard कार्य निष्पादित होगा। ये कार्य ईमेल को तुरंत और हमेशा के लिए मिटा देता है। आप discard की जगह fileinto कार्य का इस्तेमाल करके ईमेल को आसानी से कचरा फोल्डर में भी ले जा सकते हैं: fileinto “trash”;.

वेरिएबल बनाना

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

require ["reject", "variables"];
# First check who is the sender
if allof(
    address :is "from" "Kenny@northpark.example.com", 
    header :contains "subject" "mmph mmph"
) {
    # It's from Kenny!
    # Create the variable message containing 'mmph mmph'
    set "message" "mmph mmph";
} else {
    # Create the variable message containing 'Sorry, I don't want emails today!'
    set "message" "Sorry, I don't want emails today!";
}
# Then, reject the message
reject "${message}";

इस स्क्रिप्ट का मकसद किसी ईमेल को कस्टम संदेश के साथ अस्वीकार करना है। अगर असली ईमेल kenny से है और उसका विषय ‘mmph mmph’ है, तो ‘message’ नाम का वेरिएबल बनता है, जिसमें mmph mmph होता है। दूसरे मामले में, संदेश ‘Sorry, I don’t want emails today!’ से भर जाएगा। फिर, आखिरी कदम में हम इस वेरिएबल का इस्तेमाल reject कमांड में करते हैं।

Sieve नेटिव रूप से वेरिएबल तय नहीं करता, इसलिए वे variables एक्सटेंशन में तय होते हैं, जिसे आपकी स्क्रिप्ट की शुरूआत में require करना ज़रूरी है। वेरिएबल तय करने के दो तरीके हैं।

  • वेरिएबल की स्पष्ट रचना:

वेरिएबल बनाने के लिए set कार्य दिया गया है।

require "variables";
# Create a variable called "labelname" and containing the string "Work".
set "labelname" "Work";

पहली स्ट्रिंग आपके वेरिएबल का नाम है और दूसरी उसका मान है। इसलिए पिछला उदाहरण labelname नाम का वेरिएबल बनाता है जिसमें Work. शामिल है

एक बार वेरिएबल तय हो जाए, तो आप किसी स्ट्रिंग में नीचे दिया गया फॉर्मैट जोड़कर उसे बुला सकते हैं: ${name}, जहां name आपके वेरिएबल का नाम है। निष्पादित होने पर, ये वेरिएबल के मान से बदल जाएगा। (अगर आपने वेरिएबल तय नहीं किया है, तो ये खाली स्ट्रिंग से बदल जाएगा।) इसलिए, नीचे दी गई स्क्रिप्ट में:

require "variables";
require "fileinto";
# Create a variable called "labelname" and containing the string "Work".
set "labelname" "Work";
# Move the email in "${foldername}/${labelname}" which becomes after variable resolution "/Work";
fileinto "${foldername}/${labelname}";

आपका ईमेल /Work लेबल से टैग हो जाएगा। क्योंकि हमने पहले ही labelname वेरिएबल तय कर लिया है, इसलिए ये Work से बदल जाता है। हालांकि, foldername तय नहीं किया गया है, इसलिए वो सीधे हट जाता है।

  • वेरिएबल का अस्पष्ट असाइनमेंट:

वेरिएबल का सबसे दिलचस्प इस्तेमाल :matches टेस्ट के साथ होता है। आइए नीचे दिया गया उदाहरण लेते हैं, जहां ईमेल भेजने वाला test@proton.me है:

require "variables";
require "fileinto";
# do a matches test 
if header :matches "from" "*@*" {
    # The first * matches "test", the second "protonmail".  
    # Thus, the first matching variable contains "test"
    fileinto "${1}";
}

जब variables एक्सटेंशन के साथ इस्तेमाल किया जाता है, तो match ऑपरेशन का नतीजा वेरिएबल में स्टोर हो जाएगा। कई वेरिएबल संख्यात्मक नाम के साथ सेट किए जाएंगे। पहला, वेरिएबल 0 पूरे मैच को रखेगा (हमारे उदाहरण में वो पूरा पता होगा: test@proton.me)। फिर, पहला मैचिंग ग्रुप वेरिएबल 1 को दिया जाएगा (हमारे उदाहरण में वो test होगा), दूसरा मैचिंग ग्रुप दूसरे वेरिएबल को दिया जाएगा (proton.me), और ऐसे ही आखिरी मैचिंग ग्रुप तक।

हमारे उदाहरण में, fileinto कमांड निष्पादित होता है। स्थान ${1} पे तय है, जिसे वेरिएबल के रूप में पहचाना जाता है और इसलिए उसके मान से बदल जाता है, जैसा ऊपर निकाला गया: test।

ध्यान रखें कि :regex टेस्ट में वेरिएबल असाइन करना भी संभव है, रेगुलर एक्सप्रेशन मैचिंग ग्रुप का इस्तेमाल करके।

वेरिएबल बदलना

एक अच्छी संभावना वेरिएबल का बदलाव है। इसके लिए, set कीवर्ड को फ़्लैग के संयोजन के साथ इस्तेमाल किया जा सकता है जो वेरिएबल को असाइन करने से पहले उसके मान को बदलने के लिए इस्तेमाल होते हैं।

  • :lower वेरिएबल के मान को लोअर केस में बदल देगा;
  • :upper वेरिएबल के मान को अपर केस में बदल देगा;
  • :lowerfirst वेरिएबल के मान का पहला अक्षर लोअरकेस में बदल देगा;
  • :upperfirst वेरिएबल के मान का पहला अक्षर अपरकेस में बदल देगा;
  • :quotewildcard स्ट्रिंग में मौजूद किसी भी वाइल्डकार्ड को कोट कर देगा, ताकि उसे match स्टेटमेंट में शाब्दिक रूप से इस्तेमाल किया जा सके;
  • :length मान की लंबाई लौटाएगा।

ध्यान रखें कि आप तय किए गए वेरिएबल का फिर से इस्तेमाल किसी दूसरे set कार्य में भी कर सकते हैं। आइए अपने पिछले उदाहरणों को बेहतर बनाते हैं:

require "variables";
require "fileinto";
# Set labelname to WORK, and modify it to lowercase with the first letter in upper case 
set :lower :upperfirst "labelname" "WORK";
set :lower :upperfirst "foldername" "geneva";
# Create a variable that is a combination of foldername and labelname
set "location" "${foldername}/${labelname}";
fileinto "${location}";

एक-एक कदम से, फ़िल्टर तीन वेरिएबल बनाएगा। पहली set कमांड वेरिएबल labelname बनाएगी। वेरिएबल की सामग्री Work है। दरअसल, असली मान WORK को :lower और :upperfirst दोनों फ़्लैग का इस्तेमाल करके बदला जाता है, केस को पहले work और फिर Work में बदलते हुए।

दूसरी set कमांड एक दूसरा वेरिएबल foldername नाम से बनाएगी, जिसमें स्ट्रिंग Geneva होगी। दरअसल, :lower और :upperfirst फ़्लैग इस्तेमाल हुए थे।

आखिर में, location वेरिएबल बनाया जाता है। मान “${foldername}/${labelname}” में दो वेरिएबल हैं: foldername और labelname। इसलिए sieve इंटरप्रेटर इन वेरिएबल को उनके मानों से बदल देगा: Work और Geneva।

आखिर में, location वेरिएबल का इस्तेमाल fileinto कमांड के आर्गुमेंट के रूप में होता है। इसलिए, ईमेल उस फोल्डर में ले जाया जाएगा जिसका नाम location वेरिएबल के मान के बराबर है: Work/Geneva।

कंपैरेटर मैच होने वाले वेरिएबल पर भी लागू हो सकते हैं:

require "variables";
require "fileinto";
if address :all :matches "from" "*@*" {
    set :lower :upperfirst "fileintovar" "${1}";
    fileinto "${fileintovar}";
}

यहां, अगर ईमेल भेजने वाला test@proton.me है, तो उसे Test लेबल से फ़्लैग किया जाएगा।

वेरिएबल का मान बदलने का एक और तरीका vnd.proton.eval एक्सटेंशन का इस्तेमाल है। ये एक्सटेंशन नया फ़्लैग :eval तय करता है, जो आपको कुछ आसान गणनाएं करने की अनुमति देगा:

require "variables";
require "fileinto";
require "vnd.proton.eval";
# do a match test on the sender address
if header :matches "from" "*" {
    # create a variable called length, containing the length of the first     
    # matching variable
    set :length "length" "${1}"; 
    # Create a variable called fileintovar containing the result of the expression written below
    set :eval "fileintovar" "${length} * 25 - 1 / 8+3";
    fileinto "${fileintovar}";
}

इस उदाहरण में, और अब भी ये मानते हुए कि ईमेल test@proton.me से आ रहा है, ईमेल 478 मान से फ़्लैग होगा। दरअसल, पहले मैचिंग वेरिएबल की लंबाई 19 है, और 19 * 25 – 1 / 8 + 3 का नतीजा ऊपर की तरफ राउंड करके 478 हो जाता है।

ये पहले बेकार लग सकता है, लेकिन ये एक्सटेंशन दूसरे ऑपरेशनों के साथ जोड़ने पे ज़्यादा मायने रखता है।

Sieve में दूसरे फील्ड के मुकाबले तुलना

खास हैडर पे मैच करना भी संभव है। उदाहरण के लिए, लिस्टों को भेजे गए सारे संदेश (अक्सर वो मार्केटिंग संदेश या न्यूज़लेटर होते हैं) एक जगह डालने के लिए, आप ये कर सकते हैं:

require "fileinto";
# Filter all lists into the same folder
if exists "list-unsubscribe"
{
    fileinto "advertisements";
}

सोशल मीडिया के ईमेल को उनके अपने फोल्डर में सॉर्ट करने के लिए, आप ये लिख सकते हैं:

require "fileinto";
# Filter all lists into the same folder
if anyof(exists "x-facebook", exists "x-linkedin-id") {
    fileinto "social";
} elsif exists "list-unsubscribe"
{
    fileinto "advertisements";
}

ध्यान रखें कि हम इस्तेमाल करते हैं:

anyof(exists "x-facebook", exists "x-linkedin-id")

इसकी जगह नहीं:

exists ["x-facebook", "x-linkedin-id"]

क्योंकि बाद वाला जांचता है कि x-facebook और x-linkedin-id दोनों सेट किए गए हैं या नहीं।

असल में देखने के लिए कि किसी हैडर में क्या मान है, आप header टेस्ट इस्तेमाल कर सकते हैं:

require "fileinto";
# Put all mails that have been sent without TLS/SSL into the same folder
if header :is "x-pm-transfer-encryption" "none" {
    fileinto "unencrypted";
}

:is ऑपरेशन के अलावा, जो बिल्कुल सटीक मैच करता है, header कमांड :matches भी सपोर्ट करता है, जो वाइल्डकार्ड का इस्तेमाल करके मैच करता है (उदाहरण के लिए “*@*.com” किसी भी ऐसे ईमेल पते से मैच करेगा जो dot com पे खत्म होता है), और :contains कमांड, जो जांचता है कि हैडर में दी गई स्ट्रिंग है या नहीं।

Sieve फिल्टर डिज़ाइन करने के लिए, किसी ईमेल के हैडर निकालना काम का हो सकता है। Proton Mail वेब इंटरफेस में ऐसा करने के लिए, More (∨) → View headers पे जाएं। एक नई विंडो खुलेगी जिसमें ईमेल के सारे हैडर होंगे।

(नई विंडो)

Sieve में संदेश के साइज़ से फ़िल्टर करना

बड़े ईमेल को छोटे ईमेल से अलग तरीके से ट्रीट करना संभव है। उदाहरण के लिए, हो सकता है कि आप बड़े ईमेल फ़्लैग करना चाहें, ताकि मेलबॉक्स की जगह बचाने के लिए उन्हें मिटा सकें। ये नीचे दिए गए तरीके से किया जा सकता है:

require ["imap4flags"];
# Flag emails that probably have large attachments (> 2 MiB)
if size :over 2M # you can also use 2097152 if you want, they are synonymous
{
    addflag "\\Flagged";
}
# Automatically mark as read really small messages. They can't have much content anyway...
if size :under 1000
{
    addflag "\\Seen";
}

जैसा कि आप देख सकते हैं, अगर आप बड़े साइज़ बताना चाहें तो यूनिट उपलब्ध हैं, इसके लिए संख्या के ठीक बाद उस अक्षर को जोड़ें जो अपेक्षित यूनिट से मेल खाता है। तीन यूनिट उपलब्ध हैं: K एक kibioctet (या 1024 बाइट) के लिए, M एक mebioctet (या 1 048 576 बाइट) के लिए और G एक gibioctet (या 1 073 741 824 बाइट) के लिए।

कृपया ध्यान रखें कि इस मामले में “over” का मतलब बड़ा है, और “under” का मतलब छोटा है। इसका मतलब है कि अगर किसी संदेश का साइज़ बिल्कुल 1000 बाइट है, तो न तो

size :under 1000

और न ही

size :over 1000

मैच करेगा।

ध्यान रखें कि Sieve फिल्टर की असली सामग्री तक एक्सेस नहीं होती और वो सिर्फ एन्क्रिप्ट किया हुआ साइज़ दिखाते हैं।

संदेशों पे ऐडवांस कार्य करना

आप Sieve में किसी संदेश के लिए अलग-अलग प्रतिक्रियाएं निष्पादित कर सकते हैं। हमने पिछले सेक्शन में fileinto, addflag, discard, और reject कार्य पेश किए थे। यहां हम और ऐडवांस कार्य पेश करेंगे।

वेकेशन संदेश और तारीख़ टेस्ट

ऑटोमैटिक-जवाब वाली खासियत को Sieve में vacation कमांड से दोहराया जा सकता है। दरअसल, आपकी सेटिंग में मौजूद ऑटोमैटिक-जवाब वाली खासियत भी ये काम करने के लिए Sieve पे ही निर्भर करती है। लेकिन स्क्रिप्ट के अंदर vacation विकल्पों का इस्तेमाल करके आप अपने ऑटोमैटिक-जवाब को कस्टम बनाने के और भी कई मौके पा सकते हैं। मसलन, शर्तों के हिसाब से खास संदेश तैयार कर सकते हैं। नोट: सेटिंग में मौजूद ऑटोमैटिक-जवाब वाली खासियत की तरह ही, vacation कार्य सिर्फ पैसे वाले प्लैन में उपलब्ध है।

vacation कमांड हर उस व्यक्ति को वेकेशन जवाब भेजता है जो आपसे संपर्क करने की कोशिश करता है। अक्सर इसे खास समय-अवधि में जवाब भेजने के लिए currentdate या date टेस्ट के साथ जोड़ा जाता है।

मान लें कि मैं 14 जुलाई 2017 से 14 अगस्त 2017 तक कोलोराडो समय के हिसाब से छुट्टी पे जा रहा हूं। ऑटोरिस्पॉन्डर सेट करने के लिए मैं नीचे दिया गया Sieve कोड इस्तेमाल कर सकता हूं:

require ["date", "vacation", "relational"];
if allof(currentdate :zone "US/Mountain" :value "ge" "date" "2017-07-14",
 currentdate :zone "US/Mountain" :value "le" "date" "2017-08-14")
{
    vacation "Queue you guys, I'm going on vacation.";
}

vacation कमांड के वैकल्पिक आर्गुमेंट में से एक हैं आर्गुमेंट :handle और :days। डिफॉल्ट रूप से, Sieve timeout कहलाने वाली खास दिनों की संख्या के भीतर उसी भेजने वाले को कई बार जवाब नहीं देगा। इससे आपको अनजाने में कई ऑटोमैटिक ईमेल भेजने से बचाया जाता है।

टाइमआउट को कंट्रोल करने के लिए, आप :days पैरामीटर इस्तेमाल कर सकते हैं। :days आर्गुमेंट वो अवधि बताने के लिए इस्तेमाल होता है जिस दौरान पते रखे जाते हैं और उनका जवाब नहीं दिया जाता, और ये हमेशा दिनों में बताया जाता है। कभी-कभी, आपकी Sieve स्क्रिप्ट में कई vacation कमांड होते हैं, और आपको ये पक्का करना होता है कि उनमें से हर एक कम से कम एक बार जवाब भेजे (अगर नियम मैच करता है)। ऐसे मामले में :handle विकल्प इस्तेमाल किया जा सकता है। :handle का आर्गुमेंट एक स्ट्रिंग है जो भेजे जा रहे जवाब के टाइप की पहचान करती है।

ये कैसे काम करता है, ये देखने के लिए, मान लें कि आप एक शिक्षक हैं। शिक्षकों को अक्सर ईमेल से होमवर्क असाइनमेंट मिलते हैं। उन्हें उनके अपने फोल्डर में सॉर्ट करना काम का है। इसके अलावा, आप डेडलाइन के बाद आने वाली कोई भी सबमिशन अस्वीकार कर सकते हैं।

ऐसे मामले में हो सकता है कि आप handle इस्तेमाल करना चाहें ताकि ज़रूरत पड़ने पे जवाब भेजे जाएं:

require ["date", "vacation", "reject", "fileinto", "relational"];
if header :contains "subject" "Homework assignment 1"
{
    # remind people not to forget the attachments
    if size :under 5000
    {
        vacation :handle "Homework assignment 1 - missing attachment" "Your message size is really low. Please make sure you didn't forget to add the homework as an attachment.";
    }
   
    # check if the student made the deadline
    if  currentdate :zone "US/Mountain" :value "le" "date" "2017-06-12"
    {
        fileinto "Homework Assignment 1";
    } else {
        reject "Too late, you missed the deadline.";
    }
}
if header :contains "subject" "Homework assignment 2"
{
    # remind people not to forget the attachments
    if size :under 5000
    {
        vacation :handle "Homework assignment 2 - missing attachment" "Your message size is really low. Please make sure you didn't forget to add the homework as an attachment.";
    }
   
    # check if the student made the deadline
    if  currentdate :zone "US/Mountain" :value "le" "date" "2017-06-12"
    {
        fileinto "Homework Assignment 2";
    } else {
        reject "Too late, you missed the deadline.";
    }
}

यहां वेकेशन जवाब के लिए अनुमति प्राप्त सारे आर्गुमेंट हैं, उस क्रम में सूचीबद्ध जिस क्रम में आर्गुमेंट दिए जाने चाहिए:

  • :days वो दिनों की संख्या है जिसके लिए वेकेशन संदेश भेजने के बाद ऑटोरिस्पॉन्डर को उसी भेजने वाले को जवाब भेजने से बचना चाहिए
  • :subject एक उपसर्ग है (डिफॉल्ट रूप से auto) जिसे ऑटोरिस्पॉन्डर को भेजने वाले को जवाब देने के लिए इस्तेमाल करना चाहिए। उदाहरण के लिए, “Homework Assignment 2” को “late: Homework Assignment 2” के साथ जवाब मिलेगा अगर :subject “late” दिया गया हो।
  • :mime बताता है कि जवाब की पहली लाइन किसी खास फॉर्मैट का इस्तेमाल कर रही है। इससे भेजने वाले को html संदेशों के साथ जवाब देने की अनुमति मिलती है। उदाहरण के लिए, html जवाब लिखने के लिए, :mime आर्गुमेंट दें और जवाब की पहली लाइन में Content-Type : text/html लिखें।
  • :handle एक स्ट्रिंग है जो भेजे जा रहे जवाब के टाइप की पहचान करती है।

कृपया ध्यान रखें कि :zone पैरामीटर, जो currentdate में है, एक वैकल्पिक पैरामीटर है और अगर वो सेट नहीं है, तो सर्वर का स्थानीय समय इस्तेमाल होगा (Proton Mail के मामले में जेनेवा, स्विट्ज़रलैंड)।

zone पैरामीटर टाइमज़ोन ऑफसेट स्वीकार करता है, जो “+0100” रूप की स्ट्रिंग होती हैं और जिनका मतलब UTC+1 होता है, साथ ही ICANN डेटाबेस के असली टाइमज़ोन भी स्वीकार करता है (देखें https://en.wikipedia.org/wiki/List_of_tz_database_time_zones(नई विंडो))। आखिरी विकल्प अक्सर और ज़्यादा उपयोगी होता है (हालांकि यह स्टैंडर्ड Sieve नहीं है) क्योंकि इसमें हर टाइमज़ोन का डेलाइट सेविंग समय भी शामिल होता है।

आप साधारण :is/ :contains/ :matches पैरामीटर का इस्तेमाल करके तारीख़ों की तुलना कर सकते हैं। उदाहरण के लिए, नीचे दिया गया Sieve कमांड जुलाई 2017 की किसी भी तारीख़ से मैच करता है:

currentdate :zone "US/Mountain" :matches "date" "2017-07-??"

लेकिन ज़्यादातर मामलों में :value पैरामीटर बहुत ज़्यादा काम का होता है।

आखिरी पैरामीटर जो आपको देना है वो फॉर्मैट है। फॉर्मैट ये भी कोड करता है कि आप तारीख़ के किस हिस्से की तुलना करना चाहते हैं। दिए गए उदाहरण में, हमने date फॉर्मैट इस्तेमाल किया है। सपोर्टेड सारे फॉर्मैट हैं:

  • year, “0000” से “9999” फॉर्मैट में कोड किया गया साल
  • month, “01” से “12” के रूप में कोड किया गया महीना
  • day, “01” से “31” के रूप में कोड किया गया दिन
  • date, yyyy-mm-dd के रूप में कोड किया गया
  • hour, “00” से “23” के रूप में कोड किया गया घंटा
  • minute, “00” से “59” के रूप में कोड किया गया मिनट
  • second, “00” से “60” के रूप में कोड किया गया सेकेंड (60 एक लीप सेकेंड(नई विंडो) है, जो सिर्फ 23:59:60 पे होता है जब भी वैज्ञानिक ज़रूरी समझते हैं)
  • time, hh:mm:ss के रूप में समय
  • iso8601, ISO8601 मानक के हिसाब से तारीख़ और समय, उदाहरण के लिए: 2005-08-15T15:52:01+00:00
  • std11, RFC2822 मानक के हिसाब से तारीख़ और समय, उदाहरण के लिए: Mon, 15 Aug 2005 15:52:01 +0000
  • zone, +/-zzzz फॉर्मैट में टाइमज़ोन ऑफ़सेट, उदाहरण के लिए +0000 या -1200
  • julian, 17 नवंबर 1858 UTC के बाद से दिनों की संख्या
  • weekday, रवि को 0 मानकर शुरू होने वाला हफ़्ते का दिन और शनि को 6 तक

आखिर में, currentdate का इस्तेमाल करने की जगह हैडर से तारीख़ निकालना भी संभव है। ये date कमांड currentdate की तरह ही काम करता है, सिवाय इसके कि इसे फॉर्मैट स्ट्रिंग से पहले एक अतिरिक्त स्ट्रिंग चाहिए: हैडर नाम। उदाहरण के लिए:

date :zone "US/Mountain" :matches "received" "date" "2017-07-??"

कृपया ध्यान रखें कि हैडर ज़रूरी नहीं कि सटीक हों: भेजने वाला उन्हें अपनी मर्ज़ी से बदल सकता है और इसलिए वो भरोसेमंद नहीं होते।

विचारणीय बातें:

  1. ऑटोरिस्पॉन्डर ऑटोमैटिक रूप से बने संदेशों का जवाब नहीं देता, जैसे मेल सूचियां, किसी दूसरे ऑटोरिस्पॉन्डर से भेजे गए ईमेल, या noreply पते से भेजे गए संदेश।
  2. ऑटोरिस्पॉन्डर एक ही ईमेल पते को कई बार संदेश नहीं भेजेगा, सिवाय उस स्थिति में जब vacation कमांड का :handle अलग हो।

समय खत्म होने को संभालना

Proton Mail की एक अनोखी खासियत भेजे गए संदेशों पे समय खत्म होने का समय सेट करने की क्षमता है, जिस बिंदु पे संदेश प्राप्तकर्ता के मेलबॉक्स से मिटा दिया जाएगा।

आप समय खत्म होने का समय जोड़कर अपने आने वाले संदेशों को संभालने के लिए भी इस खासियत का इस्तेमाल कर सकते हैं:

require "vnd.proton.expire"; 
# permanently delete all incoming and outgoing emails after 10 days
expire "day" "10";

ऊपर दी गई स्क्रिप्ट 10 दिन बाद कोई भी मिला ईमेल मिटा देगी। ये वाली थोड़ी ज़्यादा है, क्योंकि ये सारे ईमेल पे लागू होती है। इसकी जगह, आपको शायद कोई कंडीशन इस्तेमाल करनी चाहिए ताकि स्क्रिप्ट सिर्फ ईमेल के किसी खास समूह पे लागू हो। उदाहरण के लिए, आप किसी ऐसे व्यक्ति से मिले किसी भी संदेश को समय खत्म कर सकते हैं जो आपके कॉन्टैक्ट में नहीं है:

require ["extlists", "vnd.proton.expire"];
# permanently delete after 10 days any email not from me or from someone in my address book.
if not anyof(
    header :list "from" ":addrbook:personal",
    header :list "from" ":addrbook:myself"
) {
 expire "day" "10";
}

नोट: अगर बताया गया समय खत्म होने का समय 730 दिनों से ज़्यादा है, तो वो अपने-आप 730 दिनों पे सीमित हो जाएगा।

Sieve की सीमाएं

Sieve की कुछ सीमाएं हैं जिन पे आपको ध्यान देना चाहिए।

  • भेजे गए संदेशों को हाथ से या फ़िल्टर से इनबॉक्स/ड्राफ्ट में ले जाया नहीं जा सकता। वे हमेशा Sent फोल्डर में और उपयोगकर्ता या फ़िल्टर द्वारा लागू किए गए फोल्डर/लेबल में रहेंगे।
  • मिले हुए संदेशों को हाथ से या फ़िल्टर से ड्राफ्ट/Sent में ले जाया नहीं जा सकता।
  • ड्राफ्ट को हाथ से या फ़िल्टर से इनबॉक्स/Sent में ले जाया नहीं जा सकता।
  • स्पैम में मौजूद संदेशों — या प्रोसेसिंग के दौरान स्पैम में डाले गए संदेशों — के लिए हम ऑटो-रिस्पॉन्डर/वेकेशन संदेश नहीं भेजते। अगर आपको ऐसी खासियत चाहिए, तो कस्टम फोल्डर जोड़ने के बारे में सोचें — उदाहरण के लिए mySpam — और उसके लिए सूचनाएं अक्षम कर दें।
  • ऑटोरिस्पॉन्डर/वेकेशन-संदेश सीमाएं

रेगुलर एक्सप्रेशन सपोर्ट पर नोट

Sieve का Proton का क्रियान्वयन Sieve ईमेल फ़िल्टरिंग मानक का पालन करता है, जिसमें सिर्फ बहुत कम रेगुलर एक्सप्रेशन सपोर्ट शामिल है। कुछ आम रेगुलर एक्सप्रेशन शॉर्टहैंड सिंटैक्स, जैसे \b (शब्द सीमा), \w (शब्द किरदार), \W (गैर-शब्द किरदार), और \d (अंक), Sieve में सपोर्टेड नहीं हैं। इसके नतीजे के रूप में, फिल्टर में इन शॉर्टहैंड किरदारों का इस्तेमाल उन्हें चुपचाप असफल कर सकता है। ये सीमा Sieve मानक की अपनी वजह से है, जो प्लैटफॉर्म के बीच सरलता और अनुकूलता को प्राथमिकता देता है। पूरी जानकारी के लिए, Sieve Regular Expressions Draft RFC देखें।

सपोर्टेड कार्यों और टेस्ट की सूची

पैकेज

Sieve नीचे दिए गए एक्सटेंशन सपोर्ट करता है। और जानकारी के लिए आप आधिकारिक दस्तावेज़ देख सकते हैं।

Date

    \n
  • इस्तेमाल: date
    • \n
  • Description: (नई विंडो)तारीख़ की जानकारी जांचने का एक तरीका देता है।
  • दस्तावेज़ीकरण: https://tools.ietf.org/html/rfc5260(नई विंडो)
  • Implementation: डिफॉल्ट कंपैरेटर i;ascii-numeric है और i;ascii-casemap नहीं। दरअसल, date casemap कंपैरेटर के साथ काम का नहीं है।
  • See: वेकेशन संदेश और तारीख़ टेस्ट

Envelope

FileInto

    \n
  • इस्तेमाल: fileinto
    • \n
  • Description: संदेश पे लेबल लागू करता है या उसे फोल्डर में ले जाता है।
  • दस्तावेज़ीकरण: https://tools.ietf.org/html/rfc5228#section-4.1(नई विंडो)
  • Implementation: स्लैश फोल्डर का पूरा रास्ता दर्शाते हैं और अगर किसी लेबल के नाम में स्लैश हो, तो उन्हें एस्केप करना ज़रूरी है। नीचे दिए गए विकल्प सपोर्टेड हैं:
    • “Work“: ये ‘Work’ नाम का लेबल या फोल्डर है
    • “Work/Project1“: ये ‘Work’ फोल्डर में मौजूद सब-फोल्डर ‘Project1’ है
    • “Work/Project1/Docs“: ये ‘Work’ फोल्डर में मौजूद सब-फोल्डर ‘Project1’ के अंदर मौजूद सब-फोल्डर ‘Docs’ है
    • “Work/Misc\\/Others“: ये ‘Work’ फोल्डर में मौजूद सब-फोल्डर ‘Misc/Others’ है
  • See: शुरूआत

Imap4flags

    \n
  • इस्तेमाल: imap4flags
    • \n
  • Description: संदेश पे फ़्लैग लागू करता है।
  • दस्तावेज़ीकरण: https://tools.ietf.org/html/rfc5232(नई विंडो)
  • Implementation: वेरिएबल-लिस्ट पैरामीटर सपोर्टेड नहीं हैं। इसकी जगह variables एक्सटेंशन इस्तेमाल करें।
  • See: शुरूआत

Reject

Vacation

Variables

Relational

    \n
  • इस्तेमाल: relational
    • \n
  • Description: रिलेशनल मैच ऑपरेटर देता है।
    • \n
  • दस्तावेज़ीकरण: https://tools.ietf.org/html/rfc5231
    • \n

Regex

    \n
  • इस्तेमाल: regex
    • \n
  • Description: regex मैच ऑपरेटर देता है।
    • \n
  • दस्तावेज़ीकरण: https://tools.ietf.org/id/draft-ietf-sieve-regex-01.html
    • \n

Ascii numeric comparator

Externally Stored Lists

    \n
  • इस्तेमाल: extlists
    • \n
  • Description: कॉन्टैक्ट सूचियों तक एक्सेस देता है।
  • दस्तावेज़ीकरण: https://tools.ietf.org/html/rfc6134(नई विंडो)
  • Implementation: नीचे दी गई सूचियां सपोर्टेड हैं
    • addrbook:personal : निजी कॉन्टैक्ट सूची। नीचे दिए गए क्वेरी सपोर्टेड हैं:
      • label[.starts-with / .ends-with / .contains]=<group: string>: कॉन्टैक्ट ग्रुप के मुकाबले ऑपरेशन;
      • keypinning=<value: true / false> कॉन्टैक्ट की सार्वजनिक चाबी की परिभाषा;
      • encryption=<value: true / false> कॉन्टैक्ट का डिफॉल्ट एन्क्रिप्शन;
      • signing=<value: true / false>  कॉन्टैक्ट का डिफॉल्ट हस्ताक्षर।
    • :addrbook:myself मौजूदा उपयोगकर्ता के पते;
    • :addrbook:organization मौजूदा संगठन के सदस्यों के पते;
    • :incomingdefaults:inbox अनुमति-प्राप्त लिस्ट
    • :incomingdefaults:spam ब्लॉक लिस्ट
  • See: अपनी कॉन्टैक्ट सूची एक्सेस करना

Eval

    \n
  • इस्तेमाल: vnd.proton.eval
    • \n
  • Description: स्ट्रिंग में दिए गए आसान अंकगणितीय फ़ंक्शन की जांच करता है।
  • Documentation: वेरिएबल बदलना

Include

    \n
  • इस्तेमाल: include
    • \n
  • Description: sieve वर्कफ़्लो को संभालता है।
  • दस्तावेज़ीकरण: https://tools.ietf.org/html/rfc6609(नई विंडो)
  • Implementation: सिर्फ return नोड सपोर्टेड है।

Expiration

टेस्ट

Currentdate

    \n
  • इस्तेमाल:
    • \n
currentdate [":zone" <time-zone: string>] [COMPARATOR] [MATCH-TYPE] <date-part: string> <key-list: string-list>

Date

    \n
  • इस्तेमाल:
    • \n
date [":zone" <time-zone: string> / ":originalzone"] [MATCH-TYPE] <header-name: string> <date-part: string> <key-list: string-list

HasFlag

    \n
  • इस्तेमाल:
    • \n
hasflag [MATCH-TYPE] [COMPARATOR] <list-of-flags: string-list>
  • Description: जांचता है कि किसी खास संदेश में कोई खास फ़्लैग है या नहीं।
    • \n
  • पैकेज: imap4flags
    • \n
  • See: शुरूआत

Envelope

    \n
  • इस्तेमाल:
    • \n
envelope [COMPARATOR] [ADDRESS-PART] [MATCH-TYPE] <envelope-part: string-list> <key-list: string-list>

Address·

    \n
  • इस्तेमाल:
    • \n
address [COMPARATOR] [ADDRESS-PART] [MATCH-TYPE] <header-list: string-list> <key-list: string-list>
    \n
  • विवरण: जांचता है कि पते के रूप में पार्स किए गए तय किए गए हैडर(s) तय की गई key(s) से मैच करते हैं या नहीं।
    • \n \n
  • पैकेज: <default>
    • \n
  • See: Sieve में पतों के मुकाबले तुलना

Header

    \n
  • इस्तेमाल:
    • \n
header [COMPARATOR] [MATCH-TYPE] <header-names: string-list> <key-list: string-list>

HasExpiration

    \n
  • इस्तेमाल:
    • \n
hasexpiration
  • Description: जांचता है कि संदेश का समय खत्म होने का समय सेट है या नहीं।
    • \n
  • पैकेज: vnd.proton.expire
    • \n

Exists

    \n
  • इस्तेमाल:
    • \n
exists <header-names: string-list>

Expiration

    \n
  • इस्तेमाल:
    • \n
expiration :comparator "i;ascii-numeric" [MATCH-TYPE] <unit: "day" / "minute" / "second"> <key-list: string-list>
  • Description: संदेश के समय खत्म होने के समय की तुलना दी गई की(यों) से करता है। अगर ये ऐसे संदेश पे चलाया जाता है जिसका समय खत्म नहीं होता, तो टेस्ट असफल होगा।
    • \n
  • पैकेज: vnd.proton.expire
    • \n

Size

    \n
  • इस्तेमाल:
    • \n
size <":over" / ":under"> <limit: number>

String

    \n
  • इस्तेमाल:
    • \n
string [MATCH-TYPE] [COMPARATOR] <source: string-list> <key-list: string-list>
  • Description: जांचता है कि सोर्स स्ट्रिंग में से कोई एक किसी की से मैच करती है या नहीं।
    • \n
  • पैकेज: variables
    • \n

Anyof

    \n
  • इस्तेमाल:
    • \n
anyof <tests: test-list>
  • Description: उसे दिए गए टेस्ट पे लॉजिकल OR करता है।
    • \n
  • पैकेज: <default>
    • \n
  • See: शुरूआत

Allof

    \n
  • इस्तेमाल:
    • \n
allof <tests: test-list>
  • Description: उसे दिए गए टेस्ट पे लॉजिकल AND करता है।
    • \n
  • पैकेज: <default>
    • \n
  • See: शुरूआत

Not

    \n
  • इस्तेमाल:
    • \n
not <test: test>
  • Description: दिए गए टेस्ट के नतीजे को उल्टा कर देता है।
    • \n
  • पैकेज: <default>
    • \n
  • See: शुरूआत

True

    \n
  • इस्तेमाल:
    • \n
true
  • Description: हमेशा मैच करता है।
    • \n
  • पैकेज: <default>
    • \n

False

    \n
  • इस्तेमाल:
    • \n
false
  • Description: कभी मैच नहीं करता।
    • \n
  • पैकेज: <default>
    • \n

एक्शन

Require

    \n
  • इस्तेमाल:
    • \n
require <packages: string-list>
  • Description: तय किया गया एक्सटेंशन लोड करता है ताकि उसके तरीकों या बदलावों का इस्तेमाल किया जा सके।
    • \n
  • पैकेज: <default>
    • \n
  • See: शुरूआत

FileInto

    \n
  • इस्तेमाल:
    • \n
fileinto <folder: string>
  • Description: प्रोसेस हो रहे संदेश को किसी खास फोल्डर में ले जाता है।
    • \n
  • पैकेज: fileinto
    • \n
  • See: शुरूआत

Addflag

    \n
  • इस्तेमाल:
    • \n
addflag <list-of-flags: string-list>
  • Description: प्रोसेस हो रहे संदेश में तय किया गया फ़्लैग जोड़ता है।
    • \n
  • पैकेज: imap4flags
    • \n
  • See: शुरूआत

Removeflag

    \n
  • इस्तेमाल:
    • \n
removeflag <list-of-flags: string-list>
  • Description: प्रोसेस हो रहे संदेश से तय किए गए फ़्लैग हटाता है।
    • \n
  • पैकेज: imap4flags
    • \n

Setflag

    \n
  • इस्तेमाल:
    • \n
setflag <list-of-flags: string-list>
  • Description: सारे फ़्लैग हटाता है और प्रोसेस हो रहे संदेश पे तय किए गए फ़्लैग सेट करता है।
    • \n
  • पैकेज: imap4flags
    • \n

Stop

    \n
  • इस्तेमाल:
    • \n
stop
  • Description: सारे Sieve फिल्टर की प्रोसेसिंग रोक देता है। बाद के Sieve फिल्टर नहीं चलेंगे।
    • \n
  • पैकेज: <default>
    • \n

Return

    \n
  • इस्तेमाल:
    • \n
return
  • Description: मौजूदा Sieve फिल्टर की प्रोसेसिंग रोक देता है। बाद के Sieve फिल्टर फिर भी चलेंगे।
    • \n
  • पैकेज: include
    • \n

Set

    \n
  • इस्तेमाल:
    • \n
set [MODIFIER] <name: string> <value: string>
  • Description: दिए गए नाम और दिए गए मान को जोड़कर नए वेरिएबल बनाता है।
    • \n
  • पैकेज: variables
    • \n
  • See: वेरिएबल बनाना

Discard

    \n
  • इस्तेमाल:
    • \n
discard
  • Description: इस Sieve फिल्टर के अंत में संदेश को फेंक देता है। फेंकने के बाद, कोई दूसरा sieve फिल्टर नहीं चलेगा।
    • \n
  • पैकेज: <default>
    • \n

Keep

    \n
  • इस्तेमाल:
    • \n
keep
  • Description: आखिरी discard कमांड को वापस ले लेता है। ये सिर्फ तभी असर करेगा जब वो उसी Sieve फिल्टर में हो। अगर कोई discard निष्पादित नहीं हुआ है, तो इससे कुछ नहीं होगा।
    • \n
  • पैकेज: <default>
    • \n

Reject

    \n
  • इस्तेमाल:
    • \n
reject <reason: string>

Expire

    \n
  • इस्तेमाल:
    • \n
expire <unit: "day" / "minute" / "second"> <value: string>

Unexpire

    \n
  • इस्तेमाल:
    • \n
unexpire
  • Description: संदेश का समय खत्म होने का समय हटा देता है।
    • \n
  • पैकेज: vnd.proton.expire
    • \n

Vacation

    \n
  • इस्तेमाल:
    • \n
vacation [":days" number] [":subject" string] [":mime"] [":handle" string] <reason: string>

Valid External List

    \n
  • इस्तेमाल:
    • \n
valid_ext_list <ext-list-names: string-list>
  • Description: जांचता है कि दी गई सारी एक्सटर्नल सूचियां सपोर्टेड और मान्य हैं या नहीं।
    • \n
  • पैकेज: extlists
    • \n

क्या आपको वह नहीं मिला जो आप ढूंढ रहे थे?

मदद लें
सामान्य संपर्कcontact@proton.me
मीडिया संपर्कmedia@proton.me
कानूनी संपर्कlegal@proton.me
साझेदारी संपर्कpartners@proton.me