Django 2.1 - Sending email

ईमेल भेज रहा हूं




django

ईमेल भेज रहा हूं

हालाँकि पाइथन smtplib मॉड्यूल के माध्यम से ईमेल भेजना अपेक्षाकृत आसान बनाता है, लेकिन Django इसके ऊपर कुछ प्रकाश आवरण प्रदान करता है। ये रैपर ईमेल भेजने को अतिरिक्त त्वरित बनाने के लिए प्रदान किए जाते हैं, जिससे विकास के दौरान ईमेल भेजने में आसानी होती है, और उन प्लेटफार्मों के लिए सहायता प्रदान की जाती है जो SMTP का उपयोग नहीं कर सकते हैं।

कोड django.core.mail मॉड्यूल में रहता है।

त्वरित उदाहरण

दो लाइनों में:

from django.core.mail import send_mail

send_mail(
    'Subject here',
    'Here is the message.',
    '[email protected]',
    ['[email protected]'],
    fail_silently=False,
)

EMAIL_HOST और EMAIL_PORT सेटिंग में निर्दिष्ट SMTP होस्ट और पोर्ट का उपयोग करके मेल भेजा जाता है। EMAIL_HOST_USER और EMAIL_HOST_PASSWORD सेटिंग्स, यदि सेट किया जाता है, तो SMTP सर्वर को प्रमाणित करने के लिए उपयोग किया जाता है, और EMAIL_USE_TLS और EMAIL_USE_SSL सेटिंग्स नियंत्रित करती हैं कि क्या सुरक्षित कनेक्शन का उपयोग किया जाता है।

ध्यान दें

django.core.mail साथ भेजे गए ईमेल का वर्ण सेट आपके DEFAULT_CHARSET सेटिंग के मान पर सेट किया जाएगा।

send_mail()

send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None) [source]

ईमेल भेजने का सबसे सरल तरीका django.core.mail.send_mail()

subject , message , from_email और recipient_list पैरामीटर आवश्यक हैं।

  • subject : एक स्ट्रिंग।
  • message : एक स्ट्रिंग।
  • from_email : एक स्ट्रिंग।
  • recipient_list : तार की एक सूची, प्रत्येक ईमेल पता। recipient_list प्रत्येक सदस्य को ईमेल संदेश के "To:" फ़ील्ड में अन्य प्राप्तकर्ता दिखाई देंगे।
  • fail_silently : एक बूलियन। जब यह False , तो send_mail() त्रुटि होने पर smtplib.SMTPException । संभावित अपवादों की सूची के लिए smtplib डॉक्स देखें, जो सभी smtplib.SMTPException उपवर्ग हैं।
  • auth_user : एसएमटीपी सर्वर को प्रमाणित करने के लिए उपयोग करने के लिए वैकल्पिक उपयोगकर्ता नाम। यदि यह प्रदान नहीं किया जाता है, तो Django EMAIL_HOST_USER सेटिंग के मूल्य का उपयोग करेगा।
  • auth_password : एसएमटीपी सर्वर को प्रमाणित करने के लिए उपयोग करने के लिए वैकल्पिक पासवर्ड। यदि यह प्रदान नहीं किया जाता है, तो Django EMAIL_HOST_PASSWORD सेटिंग के मूल्य का उपयोग करेगा।
  • connection : वैकल्पिक ईमेल का उपयोग मेल भेजने के लिए करता है। यदि अनिर्दिष्ट है, तो डिफ़ॉल्ट बैकएंड के एक उदाहरण का उपयोग किया जाएगा। अधिक विवरण के लिए ईमेल बैक पर प्रलेखन देखें।
  • html_message : यदि html_message प्रदान किया जाता है, तो परिणामी ईमेल पाठ के साथ message / सादे सामग्री प्रकार और html_message पाठ / html सामग्री प्रकार के रूप में message साथ एक मल्टीपार्ट / वैकल्पिक ईमेल होगा।

वापसी मूल्य सफलतापूर्वक वितरित संदेशों की संख्या होगी (जो 0 या 1 हो सकती है क्योंकि यह केवल एक संदेश भेज सकती है)।

send_mass_mail()

send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None) [source]

django.core.mail.send_mass_mail() का उद्देश्य सामूहिक django.core.mail.send_mass_mail() को संभालना है।

datatuple एक टपल है जिसमें प्रत्येक तत्व इस प्रारूप में है:

(subject, message, from_email, recipient_list)

fail_silently , auth_user और auth_password में समान कार्य send_mail()

datatuple प्रत्येक अलग तत्व का परिणाम एक अलग ईमेल संदेश होता है। जैसे कि send_mail() में, एक ही recipient_list सभी ईमेल संदेशों के “एड्रेस”: फ़ील्ड में अन्य पते देखेंगे।

उदाहरण के लिए, निम्नलिखित कोड प्राप्तकर्ता के दो अलग-अलग संदेशों को दो अलग-अलग संदेश भेजेगा; हालाँकि, मेल सर्वर के केवल एक कनेक्शन को खोला जाएगा:

message1 = ('Subject here', 'Here is the message', '[email protected]', ['[email protected]', '[email protected]'])
message2 = ('Another Subject', 'Here is another message', '[email protected]', ['[email protected]'])
send_mass_mail((message1, message2), fail_silently=False)

वापसी मूल्य सफलतापूर्वक वितरित संदेशों की संख्या होगी।

send_mass_mail() बनाम send_mail()

send_mass_mail() और send_mail() बीच मुख्य अंतर यह है कि send_mail() हर बार निष्पादित होने पर मेल सर्वर से एक कनेक्शन खोलता है, जबकि send_mass_mail() अपने सभी संदेशों के लिए एक ही कनेक्शन का उपयोग करता है। यह send_mass_mail() थोड़ा अधिक कुशल बनाता है।

mail_admins()

mail_admins(subject, message, fail_silently=False, connection=None, html_message=None) [source]

django.core.mail.mail_admins() ADMINS सेटिंग में परिभाषित साइट व्यवस्थापक को एक ईमेल भेजने के लिए एक शॉर्टकट है।

mail_admins() EMAIL_SUBJECT_PREFIX सेटिंग के मान के साथ विषय को उपसर्ग करता है, जो डिफ़ॉल्ट रूप से "[Django] " है।

ईमेल का "से:" हेडर SERVER_EMAIL सेटिंग का मान होगा।

यह विधि सुविधा और पठनीयता के लिए मौजूद है।

यदि html_message प्रदान किया गया है, तो परिणामी ईमेल message साथ पाठ / सादे सामग्री प्रकार और html_message पाठ / html सामग्री प्रकार के रूप में message साथ एक मल्टीपार्ट / वैकल्पिक ईमेल होगा।

mail_managers()

mail_managers(subject, message, fail_silently=False, connection=None, html_message=None) [source]

django.core.mail.mail_managers() की तरह है, सिवाय इसके कि यह प्रबंधकों को एक ईमेल भेजता है, जैसा कि MANAGERS सेटिंग में परिभाषित किया गया है।

उदाहरण

यह john @ उदाहरण के लिए एक एकल ईमेल भेजता है com और jane @ उदाहरण com , उन दोनों के साथ "टू:" में दिखाई देगा:

send_mail(
    'Subject',
    'Message.',
    '[email protected]',
    ['[email protected]', '[email protected]'],
)

यह john @ उदाहरण के लिए एक संदेश भेजता है com और jane @ उदाहरण कॉम , उन दोनों के साथ एक अलग ईमेल प्राप्त कर रहा है:

datatuple = (
    ('Subject', 'Message.', '[email protected]', ['[email protected]']),
    ('Subject', 'Message.', '[email protected]', ['[email protected]']),
)
send_mass_mail(datatuple)

हेडर इंजेक्शन को रोकना

हेडर इंजेक्शन एक सुरक्षा शोषण है, जिसमें एक हमलावर आपके ईमेल से उत्पन्न होने वाले ईमेल संदेशों में "टू:" और "फ्रॉम:" को नियंत्रित करने के लिए अतिरिक्त ईमेल हेडर डालता है।

Django ईमेल फ़ंक्शन हेडर मानों में newlines के लिए मना करके हेडर इंजेक्शन के खिलाफ सभी की रक्षा करता है। यदि किसी भी subject , from_email या recipient_list में एक नई from_email (यूनिक्स, विंडोज या मैक शैली में) होती है, तो ईमेल फ़ंक्शन (जैसे send_mail() ) django.core.mail.BadHeaderError ( ValueError का एक उपवर्ग) django.core.mail.BadHeaderError और, इसलिए, होगा ईमेल न भेजें। ईमेल फ़ंक्शंस में पास करने से पहले सभी डेटा को मान्य करना आपकी ज़िम्मेदारी है।

यदि किसी message में स्ट्रिंग की शुरुआत में हेडर होते हैं, हेडर बस ईमेल संदेश के पहले बिट के रूप में मुद्रित किए जाएंगे।

यहां एक उदाहरण दृश्य है जो अनुरोध के POST डेटा से एक subject , message और from_email लेता है, जो व्यवस्थापक @ उदाहरण को भेजता है कॉम और पुनर्निर्देशन "/ संपर्क / धन्यवाद /" जब यह किया जाता है:

from django.core.mail import BadHeaderError, send_mail
from django.http import HttpResponse, HttpResponseRedirect

def send_email(request):
    subject = request.POST.get('subject', '')
    message = request.POST.get('message', '')
    from_email = request.POST.get('from_email', '')
    if subject and message and from_email:
        try:
            send_mail(subject, message, from_email, ['[email protected]'])
        except BadHeaderError:
            return HttpResponse('Invalid header found.')
        return HttpResponseRedirect('/contact/thanks/')
    else:
        # In reality we'd use a form class
        # to get proper validation errors.
        return HttpResponse('Make sure all fields are entered and valid.')

EmailMessage वर्ग

Django के send_mail() और send_mass_mail() फ़ंक्शन वास्तव में पतले रैपर हैं जो EmailMessage क्लास का उपयोग करते हैं।

EmailMessage वर्ग की सभी सुविधाएँ send_mail() और संबंधित आवरण कार्यों के माध्यम से उपलब्ध नहीं हैं। यदि आप उन्नत सुविधाओं का उपयोग करना चाहते हैं, जैसे कि BCC'ed प्राप्तकर्ता, फ़ाइल अनुलग्नक, या बहु-भाग ईमेल, तो आपको सीधे EmailMessage इंस्टेंसेस बनाने की आवश्यकता होगी।

ध्यान दें

यह एक डिज़ाइन सुविधा है। send_mail() और संबंधित फ़ंक्शन मूल रूप से एकमात्र इंटरफ़ेस Django प्रदान किया गया था। हालांकि, उनके द्वारा स्वीकार किए गए मापदंडों की सूची धीरे-धीरे समय के साथ बढ़ रही थी। इसने ईमेल संदेशों के लिए अधिक ऑब्जेक्ट-ओरिएंटेड डिज़ाइन को स्थानांतरित करने और मूल कार्यों को केवल पीछे की संगतता के लिए बनाए रखने के लिए समझ में आया।

ईमेल संदेश स्वयं बनाने के लिए ईमेल संदेश जिम्मेदार है। ईमेल बैकेंड फिर ईमेल भेजने के लिए जिम्मेदार है।

सुविधा के लिए, EmailMessage एकल ईमेल भेजने के लिए एक सरल send() विधि प्रदान करता है। यदि आपको कई संदेश भेजने की आवश्यकता है, तो ईमेल बैकएंड एपीआई एक विकल्प प्रदान करता है

EmailMessage ऑब्जेक्ट्स

class EmailMessage [source]

EmailMessage वर्ग को निम्नलिखित मापदंडों (दिए गए क्रम में, यदि स्थितिगत तर्क का उपयोग किया जाता है) के साथ आरंभ किया जाता है। सभी पैरामीटर वैकल्पिक हैं और इसे किसी भी समय पर send() विधि को कॉल करने से पहले सेट किया जा सकता है।

  • subject : ईमेल की विषय पंक्ति।
  • body : शरीर का पाठ। यह एक सादा पाठ संदेश होना चाहिए।
  • from_email : प्रेषक का पता। दोनों [email protected] और Fred <[email protected]> फॉर्म कानूनी हैं। यदि छोड़ा गया है, तो DEFAULT_FROM_EMAIL सेटिंग का उपयोग किया जाता है।
  • to : प्राप्तकर्ता के पते की सूची या टपल।
  • bcc : ईमेल भेजते समय "Bcc" हेडर में प्रयुक्त पते की सूची या टपल।
  • connection : एक ईमेल बैकएंड उदाहरण। यदि आप एक से अधिक संदेशों के लिए एक ही कनेक्शन का उपयोग करना चाहते हैं, तो इस पैरामीटर का उपयोग करें। यदि छोड़ दिया जाता है, तो एक नया कनेक्शन बनाया जाता है जब send() कहा जाता है।
  • attachments : मैसेज डालने के लिए अटैचमेंट की एक सूची। ये या तो MIMEBase उदाहरण हो सकते हैं, या (filename, content, mimetype) MIMEBase
  • headers : संदेश पर डालने के लिए अतिरिक्त हेडर का शब्दकोश। कुंजियाँ हेडर नाम हैं, मान हेडर मान हैं। यह ईमेल करने वाले पर निर्भर है कि हेडर के नाम और मान ईमेल संदेश के लिए सही प्रारूप में हैं। संबंधित विशेषता extra_headers
  • cc : ईमेल भेजते समय “Cc” हैडर में प्रयुक्त प्राप्तकर्ता पतों की एक सूची या टपल।
  • reply_to : ईमेल भेजते समय "उत्तर-प्रति" शीर्ष लेख में उपयोग किए गए प्राप्तकर्ता पते की एक सूची या टपल।

उदाहरण के लिए:

from django.core.mail import EmailMessage

email = EmailMessage(
    'Hello',
    'Body goes here',
    '[email protected]',
    ['[email protected]', '[email protected]'],
    ['[email protected]'],
    reply_to=['[email protected]'],
    headers={'Message-ID': 'foo'},
)

कक्षा में निम्नलिखित विधियाँ हैं:

  • send(fail_silently=False) संदेश भेजता है। यदि एक कनेक्शन निर्दिष्ट किया गया था जब ईमेल का निर्माण किया गया था, तो उस कनेक्शन का उपयोग किया जाएगा। अन्यथा, डिफ़ॉल्ट बैकएंड का एक उदाहरण त्वरित और उपयोग किया जाएगा। यदि कीवर्ड तर्क fail_silently जाता है। fail_silently से True , तो संदेश भेजते समय उठाए गए अपवादों को समाप्त कर दिया जाएगा। प्राप्तकर्ताओं की एक खाली सूची अपवाद नहीं उठाएगी।
  • message() एक django.core.mail.SafeMIMEText ऑब्जेक्ट (पायथन के MIMEText वर्ग का एक उपवर्ग) या एक django.core.mail.SafeMIMEMultipart ऑब्जेक्ट को संदेश भेजने के लिए रखता है। यदि आपको कभी भी EmailMessage वर्ग का विस्तार करने की आवश्यकता है, तो आप शायद इस विधि को ओवरराइड करना चाहेंगे जो सामग्री आप MIME ऑब्जेक्ट में डालना चाहते हैं।
  • recipients() संदेश के सभी प्राप्तकर्ताओं की सूची लौटाता है, चाहे वे cc , या bcc विशेषताओं में दर्ज किए गए हों। यह एक और तरीका है जिसे आपको उपवर्ग करते समय ओवरराइड करना पड़ सकता है, क्योंकि SMTP सर्वर को संदेश भेजे जाने पर प्राप्तकर्ताओं की पूरी सूची को बताने की आवश्यकता होती है। यदि आप अपनी कक्षा में प्राप्तकर्ताओं को निर्दिष्ट करने के लिए एक और तरीका जोड़ते हैं, तो उन्हें इस पद्धति से भी लौटाया जाना चाहिए।
  • attach() एक नई फ़ाइल अनुलग्नक बनाता है और इसे संदेश में जोड़ता है। कॉल attach() करने के दो तरीके attach() :

    • आप इसे एक एकल तर्क पास कर सकते हैं जो एक MIMEBase उदाहरण है। यह सीधे परिणामी संदेश में डाला जाएगा।
    • वैकल्पिक रूप से, आप attach() कर सकते attach() तीन तर्क: filename , content और mimetypefilename नाम फ़ाइल अटैचमेंट का नाम है जैसा कि ईमेल में दिखाई देगा, content वह डेटा है जो अटैचमेंट के अंदर समाहित होगी और mimetype अटैचमेंट के लिए वैकल्पिक MIME प्रकार है। यदि आप mimetype छोड़ देते हैं, तो MIME सामग्री प्रकार को अनुलग्नक के फ़ाइल नाम से अनुमान लगाया जाएगा।

      उदाहरण के लिए:

      message.attach('design.png', img_data, 'image/png')
      

      यदि आप message/rfc822 का एक मुख्य भाग निर्दिष्ट करते हैं, तो यह EmailMessage और email.message.Message को भी स्वीकार करेगा।

      text/ साथ शुरू होने वाले mimetype लिए, सामग्री को एक स्ट्रिंग होने की उम्मीद है। UTF-8 का उपयोग करके द्विआधारी डेटा को डिकोड किया जाएगा, और यदि वह विफल रहता है, तो MIME प्रकार को application/octet-stream बदल दिया जाएगा और डेटा को अपरिवर्तित रखा जाएगा।

      इसके अलावा, message/rfc822 अटैचमेंट अब RFC 2046 # सेक्शन message/rfc822 उल्लंघन में बेस 64-इनकोडेड नहीं होंगे, जिससे Evolution और Thunderbird में अटैचमेंट्स प्रदर्शित करने में समस्या हो सकती है।

  • attach_file() आपके फाइल सिस्टम से फाइल का उपयोग करके एक नया लगाव बनाता है। इसे संलग्न करने के लिए फ़ाइल के पथ के साथ कॉल करें और, वैकल्पिक रूप से, अनुलग्नक के लिए उपयोग करने के लिए MIME प्रकार। यदि MIME प्रकार छोड़ा जाता है, तो यह फ़ाइल नाम से अनुमान लगाया जाएगा। सबसे सरल उपयोग होगा:

    message.attach_file('/images/weather_map.png')
    

    MIME प्रकारों की शुरुआत text/ साथ होती है, बाइनरी डेटा को attach() रूप में नियंत्रित किया जाता है।

वैकल्पिक सामग्री प्रकार भेजना

एक ईमेल में सामग्री के कई संस्करणों को शामिल करना उपयोगी हो सकता है; क्लासिक उदाहरण एक संदेश के पाठ और HTML दोनों संस्करणों को भेजने के लिए है। Django की ईमेल लाइब्रेरी के साथ, आप EmailMultiAlternatives वर्ग का उपयोग करके ऐसा कर सकते हैं। EmailMessage इस उपवर्ग में ईमेल में संदेश निकाय के अतिरिक्त संस्करणों को शामिल करने के लिए एक attach_alternative() विधि है। अन्य सभी तरीके (वर्ग आरंभीकरण सहित) सीधे EmailMessage से विरासत में मिले हैं।

पाठ और HTML संयोजन भेजने के लिए, आप लिख सकते हैं:

from django.core.mail import EmailMultiAlternatives

subject, from_email, to = 'hello', '[email protected]', '[email protected]'
text_content = 'This is an important message.'
html_content = '<p>This is an <strong>important</strong> message.</p>'
msg = EmailMultiAlternatives(subject, text_content, from_email, [to])
msg.attach_alternative(html_content, "text/html")
msg.send()

डिफ़ॉल्ट रूप से, एक EmailMessage में body पैरामीटर का MIME प्रकार "text/plain" । इसे अकेले छोड़ना अच्छा अभ्यास है, क्योंकि यह गारंटी देता है कि कोई भी प्राप्तकर्ता अपने मेल क्लाइंट की परवाह किए बिना ईमेल को पढ़ सकेगा। हालाँकि, यदि आप आश्वस्त हैं कि आपके प्राप्तकर्ता वैकल्पिक सामग्री प्रकार को संभाल सकते हैं, तो आप मुख्य सामग्री प्रकार को बदलने के लिए EmailMessage वर्ग पर content_subtype विशेषता का उपयोग कर सकते हैं। प्रमुख प्रकार हमेशा "text" , लेकिन आप उपप्रकार बदल सकते हैं। उदाहरण के लिए:

msg = EmailMessage(subject, html_content, from_email, [to])
msg.content_subtype = "html"  # Main content is now text/html
msg.send()

ईमेल का समर्थन करता है

ईमेल का वास्तविक भेजने को ईमेल बैकएंड द्वारा नियंत्रित किया जाता है।

ईमेल बैकएंड वर्ग के निम्नलिखित तरीके हैं:

  • open() एक लंबे समय से रहने वाले ईमेल भेजने वाले कनेक्शन को त्वरित करता है।
  • close() वर्तमान ईमेल भेजने वाले कनेक्शन को बंद कर देता है।
  • send_messages(email_messages) EmailMessage ऑब्जेक्ट्स की एक सूची भेजता है। यदि कनेक्शन नहीं खुला है, तो यह कॉल स्पष्ट रूप से कनेक्शन को खोल देगा, और बाद में कनेक्शन को बंद कर देगा। यदि कनेक्शन पहले से ही खुला है, तो मेल भेजे जाने के बाद इसे खुला छोड़ दिया जाएगा।

इसका उपयोग एक संदर्भ प्रबंधक के रूप में भी किया जा सकता है, जो स्वचालित रूप से आवश्यकतानुसार open() और close() को कॉल करेगा:

from django.core import mail

with mail.get_connection() as connection:
    mail.EmailMessage(
        subject1, body1, from1, [to1],
        connection=connection,
    ).send()
    mail.EmailMessage(
        subject2, body2, from2, [to2],
        connection=connection,
    ).send()

ईमेल बैकएंड का एक उदाहरण प्राप्त करना

get_connection() फ़ंक्शन ईमेल बैकेंड का एक उदाहरण देता है जिसे आप उपयोग कर सकते हैं।

get_connection(backend=None, fail_silently=False, *args, **kwargs) [source]

डिफ़ॉल्ट रूप से, get_connection() कॉल get_connection() में निर्दिष्ट ईमेल बैकएंड का एक उदाहरण EMAIL_BACKEND । यदि आप backend तर्क निर्दिष्ट करते हैं, तो उस बैकएंड का एक उदाहरण त्वरित होगा।

fail_silently तर्क नियंत्रित करता है कि बैकएंड को त्रुटियों को कैसे संभालना चाहिए। यदि fail_silently सत्य है, तो ईमेल भेजने की प्रक्रिया के दौरान अपवादों को चुपचाप अनदेखा कर दिया जाएगा।

अन्य सभी तर्क सीधे ईमेल बैकएंड के कंस्ट्रक्टर को दिए जाते हैं।

Django जहाज कई ईमेल के साथ बैकएंड भेजते हैं। SMTP बैकएंड (जो कि डिफ़ॉल्ट है) के अपवाद के साथ, ये बैकेंड केवल परीक्षण और विकास के दौरान उपयोगी होते हैं। यदि आपके पास विशेष ईमेल भेजने की आवश्यकता है, तो आप अपना खुद का ईमेल बैकेंड लिख सकते हैं।

SMTP बैकएंड

class backends.smtp.EmailBackend(host=None, port=None, username=None, password=None, use_tls=None, fail_silently=False, use_ssl=None, timeout=None, ssl_keyfile=None, ssl_certfile=None, **kwargs)

यह डिफ़ॉल्ट बैकएंड है। ईमेल एक एसएमटीपी सर्वर के माध्यम से भेजा जाएगा।

प्रत्येक तर्क के लिए मान मिलान सेटिंग से पुनर्प्राप्त किया जाता है यदि तर्क None :

SMTP बैकएंड Django द्वारा विरासत में प्राप्त डिफ़ॉल्ट कॉन्फ़िगरेशन है। यदि आप इसे स्पष्ट रूप से निर्दिष्ट करना चाहते हैं, तो अपनी सेटिंग्स में निम्नलिखित डालें:

EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'

यदि अनिर्दिष्ट है, तो डिफ़ॉल्ट timeout socket.getdefaulttimeout() द्वारा प्रदान किया जाएगा, जो कि None (कोई टाइमआउट) के लिए डिफ़ॉल्ट है।

कंसोल बैकएंड

असली ईमेल भेजने के बजाय कंसोल बैकेंड सिर्फ उन ईमेल को लिखता है जो मानक आउटपुट पर भेजे जाएंगे। डिफ़ॉल्ट रूप से, कंसोल बैकेंड stdout को लिखता है। कनेक्शन का निर्माण करते समय stream कीवर्ड तर्क प्रदान करके आप एक अलग स्ट्रीम जैसी ऑब्जेक्ट का उपयोग कर सकते हैं।

इस बैकएंड को निर्दिष्ट करने के लिए, निम्नलिखित को अपनी सेटिंग में रखें:

EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

यह बैकेंड उत्पादन में उपयोग के लिए नहीं है - यह एक सुविधा के रूप में प्रदान किया जाता है जिसे विकास के दौरान उपयोग किया जा सकता है।

फ़ाइल बैकएंड

फ़ाइल बैकएंड फ़ाइल में ईमेल लिखता है। इस बैकएंड पर खोले गए प्रत्येक नए सत्र के लिए एक नई फ़ाइल बनाई जाती है। जिस निर्देशिका में फाइलें लिखी जाती हैं, वह या तो EMAIL_FILE_PATH सेटिंग से ली जाती है या get_connection() साथ संबंध बनाते समय file_path कीवर्ड से।

इस बैकएंड को निर्दिष्ट करने के लिए, निम्नलिखित को अपनी सेटिंग में रखें:

EMAIL_BACKEND = 'django.core.mail.backends.filebased.EmailBackend'
EMAIL_FILE_PATH = '/tmp/app-messages' # change this to a proper location

यह बैकेंड उत्पादन में उपयोग के लिए नहीं है - यह एक सुविधा के रूप में प्रदान किया जाता है जिसे विकास के दौरान उपयोग किया जा सकता है।

इन-मेमोरी बैकएंड

'locmem' बैकएंड django.core.mail मॉड्यूल की एक विशेष विशेषता में संदेशों को django.core.mail है। पहला संदेश भेजे जाने पर outbox विशेषता बनाई जाती है। यह प्रत्येक संदेश के लिए एक EmailMessage संदेश के साथ एक सूची है जिसे भेजा जाएगा।

इस बैकएंड को निर्दिष्ट करने के लिए, निम्नलिखित को अपनी सेटिंग में रखें:

EMAIL_BACKEND = 'django.core.mail.backends.locmem.EmailBackend'

यह बैकेंड उत्पादन में उपयोग के लिए अभिप्रेत नहीं है - यह एक सुविधा के रूप में प्रदान किया जाता है जिसका उपयोग विकास और परीक्षण के दौरान किया जा सकता है।

डमी बैकेंड

जैसा कि नाम से पता चलता है कि डमी बैकेंड आपके संदेशों के साथ कुछ नहीं करता है। इस बैकएंड को निर्दिष्ट करने के लिए, निम्नलिखित को अपनी सेटिंग में रखें:

EMAIL_BACKEND = 'django.core.mail.backends.dummy.EmailBackend'

यह बैकेंड उत्पादन में उपयोग के लिए नहीं है - यह एक सुविधा के रूप में प्रदान किया जाता है जिसे विकास के दौरान उपयोग किया जा सकता है।

एक कस्टम ईमेल बैकएंड को परिभाषित करना

यदि आपको यह बदलने की आवश्यकता है कि ईमेल कैसे भेजे जाते हैं तो आप अपना ईमेल बैकेंड लिख सकते हैं। आपकी सेटिंग फ़ाइल में EMAIL_BACKEND सेटिंग तब आपके बैकएंड वर्ग के लिए पायथन आयात पथ है।

कस्टम ईमेल बैकएंड को BaseEmailBackend को BaseEmailBackend करना चाहिए जो कि django.core.mail.backends.base मॉड्यूल में स्थित है। एक कस्टम ईमेल बैकएंड को send_messages(email_messages) विधि को लागू करना चाहिए। इस विधि से EmailMessage इंस्टेंस की एक सूची प्राप्त होती है और सफलतापूर्वक वितरित संदेशों की संख्या वापस आती है। यदि आपके बैकएंड में लगातार सत्र या कनेक्शन की कोई अवधारणा है, तो आपको open() और close() तरीकों को भी लागू करना चाहिए। संदर्भ कार्यान्वयन के लिए smtp.EmailBackend संदर्भ लें।

कई ईमेल भेजे जा रहे हैं

SMTP कनेक्शन (या उस मामले के लिए कोई अन्य नेटवर्क कनेक्शन) स्थापित करना और बंद करना एक महंगी प्रक्रिया है। यदि आपके पास भेजने के लिए बहुत सारे ईमेल हैं, तो हर बार जब आप ईमेल भेजना चाहते हैं, तो कनेक्शन बनाने और नष्ट करने के बजाय, एक एसएमटीपी कनेक्शन का पुन: उपयोग करना समझ में आता है।

एक कनेक्शन का पुन: उपयोग करने के लिए ईमेल बैकएंड को बताने के दो तरीके हैं।

सबसे पहले, आप send_messages() विधि का उपयोग कर सकते हैं। send_messages() EmailMessage इंस्टेंस (या उपवर्ग) की एक सूची लेता है, और उन सभी को एकल कनेक्शन का उपयोग करके भेजता है।

उदाहरण के लिए, यदि आपके पास get_notification_email() नामक एक फ़ंक्शन है, जो आपके द्वारा भेजे जाने वाले कुछ आवधिक ईमेल का प्रतिनिधित्व करने वाले EmailMessage ऑब्जेक्ट्स की एक सूची देता है, तो आप इन ईमेलों को send_messages के लिए एक कॉल का उपयोग करके भेज सकते हैं:

from django.core import mail
connection = mail.get_connection()   # Use default email connection
messages = get_notification_email()
connection.send_messages(messages)

इस उदाहरण में, send_messages() कॉल बैकएंड पर एक कनेक्शन खोलता है, संदेशों की सूची भेजता है और फिर कनेक्शन को फिर से बंद कर देता है।

दूसरा तरीका ईमेल बैकएंड पर open() और close() तरीकों का उपयोग करना है ताकि कनेक्शन को मैन्युअल रूप से नियंत्रित किया जा सके। send_messages() मैन्युअल रूप से कनेक्शन को खोलने या बंद नहीं करेगा यदि यह पहले से ही खुला है, इसलिए यदि आप मैन्युअल रूप से कनेक्शन खोलते हैं, तो आप इसे बंद होने पर नियंत्रित कर सकते हैं। उदाहरण के लिए:

from django.core import mail
connection = mail.get_connection()

# Manually open the connection
connection.open()

# Construct an email message that uses the connection
email1 = mail.EmailMessage(
    'Hello',
    'Body goes here',
    '[email protected]',
    ['[email protected]'],
    connection=connection,
)
email1.send() # Send the email

# Construct two more messages
email2 = mail.EmailMessage(
    'Hello',
    'Body goes here',
    '[email protected]',
    ['[email protected]'],
)
email3 = mail.EmailMessage(
    'Hello',
    'Body goes here',
    '[email protected]',
    ['[email protected]'],
)

# Send the two emails in a single call -
connection.send_messages([email2, email3])
# The connection was already open so send_messages() doesn't close it.
# We need to manually close the connection.
connection.close()

विकास के लिए ईमेल कॉन्फ़िगर करना

ऐसे समय होते हैं जब आप नहीं चाहते कि Django ईमेल भेजे। उदाहरण के लिए, एक वेबसाइट विकसित करते समय, आप संभवतः हजारों ईमेल नहीं भेजना चाहते हैं - लेकिन आप यह सत्यापित करना चाहते हैं कि ईमेल सही परिस्थितियों में सही लोगों को भेजे जाएंगे, और उन ईमेलों में सही सामग्री होगी ।

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

file ईमेल बैकएंड भी विकास के दौरान उपयोगी हो सकता है - यह बैकएंड प्रत्येक SMTP कनेक्शन की सामग्री को एक ऐसी फ़ाइल में डंप करता है जिसका निरीक्षण आपके अवकाश पर किया जा सकता है।

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

python -m smtpd -n -c DebuggingServer localhost:1025

यह कमांड लोकलहोस्ट के पोर्ट 1025 पर सुनने वाला एक साधारण एसएमटीपी सर्वर शुरू करेगा। यह सर्वर बस मानक आउटपुट को सभी ईमेल हेडर और ईमेल बॉडी पर प्रिंट करता है। फिर आपको केवल EMAIL_HOST और EMAIL_PORT तदनुसार सेट करना EMAIL_HOST । SMTP सर्वर विकल्पों की अधिक विस्तृत चर्चा के लिए, smtpd मॉड्यूल के लिए पायथन प्रलेखन देखें।

अपने आवेदन में ईमेल भेजने की इकाई-परीक्षण के बारे में जानकारी के लिए, परीक्षण दस्तावेज़ के ईमेल सेवा अनुभाग देखें।