Cé go soláthraíonn Python comhéadan seolta ríomhphoist tríd an modúl: mod: smtplib, soláthraíonn Django cúpla fillteán éadrom air. Cuirtear na fillteáin seo ar fáil chun ríomhphost a sheoladh go tapa, chun cabhrú le seoladh ríomhphoist a thástáil le linn na forbartha, agus chun tacaíocht a sholáthar d'ardáin nach féidir leo SMTP a úsáid.
\nTá an cód ina gcónaí sa mhodúl django.core.mail.
Úsáid: func: send_mail le haghaidh seoladh ríomhphoist simplí. Mar shampla, chun teachtaireacht téacs simplí a sheoladh:
\nfrom django.core.mail import send_mail\n\nsend_mail(\n "Subject here",\n "Here is the message.",\n "from@example.com",\n ["to@example.com"],\n fail_silently=False,\n)\nNuair a bhíonn feidhmiúlacht bhreise seolta ríomhphoist ag teastáil, bain úsáid as: class: EmailMessage nó:class: EmailMultiAlternatives. Mar shampla, chun ríomhphost ilpháirteach a sheoladh a chuimsíonn leaganacha HTML agus téacs simplí le teimpléad ar leith agus ceanntásca saincheaptha, is féidir leat an cur chuige seo a leanas a úsáid:
\nfrom django.core.mail import EmailMultiAlternatives\nfrom django.template.loader import render_to_string\n\n# First, render the plain text content.\ntext_content = render_to_string(\n "templates/emails/my_email.txt",\n context={"my_variable": 42},\n)\n\n# Secondly, render the HTML content.\nhtml_content = render_to_string(\n "templates/emails/my_email.html",\n context={"my_variable": 42},\n)\n\n# Then, create a multipart email instance.\nmsg = EmailMultiAlternatives(\n "Subject here",\n text_content,\n "from@example.com",\n ["to@example.com"],\n headers={"List-Unsubscribe": "<mailto:unsub@example.com>"},\n)\n\n# Lastly, attach the HTML content to the email instance and send.\nmsg.attach_alternative(html_content, "text/html")\nmsg.send()\nSeoltar ríomhphost ag baint úsáide as an óstach SMTP agus an calafort a shonraítear sna socruithe:: EMAIL_HOST agus:setting: EMAIL_PORT. Úsáidtear socruithe an:SETTING: EMAIL_HOST_USER agus:setting: EMAIL_HOST_PASSWORD, má tá sé socraithe, chun fíordheimhniú chuig an bhfreastalaí SMTP, agus rialaíonn an:setting: EMAIL_USE_TLS agus:setting: EMAIL_USE_SSL an bhfuil nasc slán.
\n\nI bhformhór na gcásanna, is féidir leat ríomhphost a sheoladh ag baint úsáide as ``django.core.mail.send_mail () ``.
\nTeastaíonn na paraiméadair ábhar ``, `teachtaire, from_email` agus liosta_faighteannaithe.
from_email: teaghrán. Má tá None, úsáidfidh Django luach an socruithe:: DEFAULT_FROM_EMAIL.
recipient_list: Liosta teaghráin, seoladh ríomhphoist gach ceann acu. Feicfidh gach ball de recipient_list na faighteoirí eile sa réimse “Chun:” den teachtaireacht ríomhphoist.
fail_silently: Boolean. Nuair a bhíonn sé False`, ardóidh ``send_mail () ``an:exc: smtplib.smtpException má tharlaíonn earráid. Féach na docs: mod: smtplib le haghaidh liosta de na heisceachtaí féideartha, agus is fo-aicmí iad uile ceann de: exc: ~smtplib.smtpException.
auth_user: An t-ainm úsáideora roghnach le húsáid chun fíordheimhniú chuig an bhfreastalaí SMTP. Mura gcuirtear é seo ar fáil, úsáidfidh Django luach an socruithe: setting: EMAIL_HOST_USER.
auth_password: An pasfhocal roghnach le húsáid chun fíordheimhniú chuig an bhfreastalaí SMTP. Mura gcuirtear é seo ar fáil, úsáidfidh Django luach an socruithe:: EMAIL_HOST_PASSWORD.
nasc: An cúltaca roghnach ríomhphoist le húsáid chun an post a sheoladh. Mura bhfuil sé sonraithe, úsáidfear sampla den chúltaca réamhshocraithe. Féach an doiciméadú ar:ref: `Ríomhphost backends <topic-email-backends>`le haghaidh tuilleadh sonraí.
html_message: Má chuirtear html_message` ar fáil, beidh an ríomhphost mar thoradh air:: mimetype: multipart/alternative `r-phost le ``teachtaire` mar an cineál ábhair: mimetype: text/plain agus html_message mar an:mimetype: text/html cineál ábhair.
Is é an luach tuairisceáin líon na dteachtaireachtaí a sheachadadh go rathúil (ar féidir iad a bheith 0 nó 1 ós rud é nach féidir leis ach teachtaireacht amháin a sheoladh).
Tá sé beartaithe ag ``django.core.mail.send_mass_mail () ``ollseoladh ríomhphoist a láimhseáil.
\nIs é datatuple` tuple ina bhfuil gach eilimint sa fhormáid seo:
\n(subject, message, from_email, recipient_list)\nfail_silently, auth_user and auth_password have the same functions\nas in send_mail().
Each separate element of datatuple results in a separate email message.\nAs in send_mail(), recipients in the same\nrecipient_list will all see the other addresses in the email messages'\n"To:" field.
Mar shampla, chuirfeadh an cód seo a leanas dhá theachtaireacht éagsúla chuig dhá shraith éagsúla faighteoirí; áfach, ní osclófaí ach nasc amháin leis an bhfreastalaí ríomhphoist:
\nmessage1 = (\n "Subject here",\n "Here is the message",\n "from@example.com",\n ["first@example.com", "other@example.com"],\n)\nmessage2 = (\n "Another Subject",\n "Here is another message",\n "from@example.com",\n ["second@test.com"],\n)\nsend_mass_mail((message1, message2), fail_silently=False)\nIs é an luach tuairisceáin líon na dteachtaireachtaí a sheachadadh go rathúil.
\nsend_mass_mail () ``vs ``send_mail ()Link to this heading#The main difference between send_mass_mail() and\nsend_mail() is that\nsend_mail() opens a connection to the mail server\neach time it's executed, while send_mass_mail() uses\na single connection for all of its messages. This makes\nsend_mass_mail() slightly more efficient.
Is aicearra é ``django.core.mail.mail_admins () ``chun ríomhphost a sheoladh chuig riarthóirí an láithreáin, mar a shainmhínítear sa socrú: ADMINS.
\nRéamhshocraíonn mail_admins () ``an t-ábhar le luach an socrú: `EMAIL_SUBJECT_PREFIX`, arb é "[Django] “``de réir réamhshocraithe.
Is é ceannteideal “Ó:” an ríomhphoist luach an socruithe: setting: SERVER_EMAIL.
\nTá an modh seo ann le haghaidh áisiúlachta agus inléiteachta.
\nMá chuirtear html_message` ar fáil, beidh an ríomhphost mar thoradh air:: mimetype: multipart/alternative `r-phost le `teachtaire` mar an:mimetype: text/plain cineál ábhair agus html_message` mar an cineál ábhair: mimetype: text/html.
\nTá django.core.mail.mail_managers () ``díreach cosúil le ``mail_admins (), ach amháin go seolann sé ríomhphost chuig bainisteoirí an láithreáin, mar a shainmhínítear sa socrú: MANAGERS.
Seolann sé ríomhphost amháin chuig john@example.com agus jane@example.com, agus tá an bheirt acu le feiceáil sa “Chun:”:
\nsend_mail(\n "Subject",\n "Message.",\n "from@example.com",\n ["john@example.com", "jane@example.com"],\n)\nSeolann sé seo teachtaireacht chuig john@example.com agus jane@example.com, agus faigheann an bheirt acu ríomhphost ar leithligh:
\ndatatuple = (\n ("Subject", "Message.", "from@example.com", ["john@example.com"]),\n ("Subject", "Message.", "from@example.com", ["jane@example.com"]),\n)\nsend_mass_mail(datatuple)\nIs saothrú slándála é instealladh ceannteannair ina gcuireann ionsaitheoir ceannteidil ríomhphoist breise isteach chun an “Chun:” agus “Ó:” a rialú i dteachtaireachtaí ríomhphoist a ghineann do scripteanna.
\nThe Django email functions outlined above all protect against header injection\nby forbidding newlines in header values. If any subject, from_email or\nrecipient_list contains a newline (in either Unix, Windows or Mac style),\nthe email function (e.g. send_mail()) will raise\ndjango.core.mail.BadHeaderError (a subclass of ValueError) and, hence,\nwill not send the email. It's your responsibility to validate all data before\npassing it to the email functions.
Má tá ceanntásca i “teachtaireacht” ag tús an teaghrán, clófar na ceanntásca mar an chéad ghiotán den teachtaireacht ríomhphoist.
\nSeo dearcadh samplach a thógann ábhar ``, `teachtaireacht agus from_email ó shonraí POST an iarratais, seolann sé sin chuig admin@example.com agus a atreoraíonn sé chuig “/contact/thanks/” nuair a bheidh sé déanta:
from django.core.mail import BadHeaderError, send_mail\nfrom django.http import HttpResponse, HttpResponseRedirect\n\n\ndef send_email(request):\n subject = request.POST.get("subject", "")\n message = request.POST.get("message", "")\n from_email = request.POST.get("from_email", "")\n if subject and message and from_email:\n try:\n send_mail(subject, message, from_email, ["admin@example.com"])\n except BadHeaderError:\n return HttpResponse("Invalid header found.")\n return HttpResponseRedirect("/contact/thanks/")\n else:\n # In reality we'd use a form class\n # to get proper validation errors.\n return HttpResponse("Make sure all fields are entered and valid.")\nEmailMessageLink to this heading#Django's send_mail() and\nsend_mass_mail() functions are actually thin\nwrappers that make use of the EmailMessage class.
Not all features of the EmailMessage class are\navailable through the send_mail() and related\nwrapper functions. If you wish to use advanced features, such as BCC'ed\nrecipients, file attachments, or multi-part email, you'll need to create\nEmailMessage instances directly.
EmailMessage is responsible for creating the email\nmessage itself. The email backend is then\nresponsible for sending the email.
Ar mhaithe le áisiúlacht, soláthraíonn :class: ~django.core.mail.emailMessage modh ``send () ``chun ríomhphost amháin a sheoladh. <topics-sending-multiple-emails>Más gá duit teachtaireachtaí iolracha a sheoladh, soláthraíonn an cúltaca ríomhphoist API: ref: `rogha eile `.
\nRíomhphost teachtaire CuspóiríLink to this heading#Cuirtear an rang:class: ~django.core.mail.emailMessage a thionscnamh leis na paraiméadair seo a leanas (san ord tugtha, má úsáidtear argóintí seasaimh). Tá na paraiméadair go léir roghnach agus is féidir iad a shocrú ag am ar bith sula nglactar ar an modh ``send () `.
\n``corp ``: An téacs comhlachta. Ba chóir go mbeadh sé seo ná teachtaireacht téacs simplí.
from_email: Seoladh an tseoltóra. < fred@example.com >Tá an dá fhoirm fred@example.com agus ``"Fred ``dlíthiúil. Má fhágtar amach, úsáidtear an socrú:setting: DEFAULT_FROM_EMAIL.
bcc: Liosta nó tuple seoltaí a úsáidtear sa cheanntásc “Bcc” agus an ríomhphost á sheoladh.
<topic-email-backends>``nasc``: an:ref: cúltaca ríomhphost sampla. Úsáid an paraiméadar seo má tá an emailMessage á sheoladh agat trí ``send () ``agus gur mhaith leat an nasc céanna a úsáid le haghaidh teachtaireachtaí iolracha. Má fhágtar amach, cruthaítear nasc nua nuair a thugtar ``send () ``. <topics-sending-multiple-emails>Déantar neamhaird ar an bparaiméadar seo nuair a úsáidtear: ref: `send_messages () `.
attachments: A list of attachments to put on the message. These can\nbe instances of MIMEBase or\nEmailAttachment, or a tuple with attributes\n(filename, content, mimetype).
headers: Foclóir ceanntásca breise le cur ar an teachtaireacht. Is iad na heochracha ainm an ceanntásc, is iad luachanna na luachanna ceanntásc. Is faoin nglaoiteoir atá sé a chinntiú go bhfuil ainmneacha agus luachanna ceanntásc san fhormáid cheart do theachtaireacht ríomhphoist. Is é an tréith chomhfhreagrach ná extra_headers.
cc: Liosta nó cúpla de sheoltaí faighteora a úsáidtear sa cheanntásc “Cc” agus an ríomhphost á sheoladh.
reply_to: Liosta nó cúpla de sheoltaí faighteora a úsáidtear sa cheanntásc “Reply-To” agus an ríomhphost á sheoladh.
Mar shampla:
\nfrom django.core.mail import EmailMessage\n\nemail = EmailMessage(\n "Hello",\n "Body goes here",\n "from@example.com",\n ["to1@example.com", "to2@example.com"],\n ["bcc@example.com"],\n reply_to=["another@example.com"],\n headers={"Message-ID": "foo"},\n)\nTá na modhanna seo a leanas ag an rang:
\nSeolann send (fail_silently=False) ``an teachtaireacht. Má shonraíodh nasc nuair a tógadh an ríomhphost, úsáidfear an nasc sin. Seachas sin, déanfar sampla den chúltaca réamhshocraithe a thabhairt isteach agus a úsáid. Más é ``True an argóint eochairfhocal fail_silently, cuirfear deireadh leis na heisceachtaí a ardaítear agus an teachtaireacht á sheoladh. Ní ardóidh liosta folamh de na bhfaighteoirí eisceacht. Tabharfaidh sé ar ais 1 má sheoladh an teachtaireacht go rathúil, ar shlí eile 0.
Tógann message () ``réad ``Django.Core.Mail.SafeMeText (fo-aicme de Python's:Class: ~email.mime.text.mimeText aicme) nó réad Django.Core.Mail.SafeMeMultiPart ina bhfuil an teachtaireacht le seoladh. Más gá duit riamh an rang:class: ~django.core.mail.emailMessage a leathnú, is dócha go mbeidh tú ag iarraidh an modh seo a shárú chun an t-ábhar a theastaíonn uait a chur isteach sa réad MIME.
Tugann faighteoirí () ``liosta de fhaighteoirí uile na teachtaireachta, cibé acu a thaifeadtar sna tréithe ``, cc` nó bcc`. Is modh eile é seo b'fhéidir go gcaithfidh tú a shárú agus tú ag fo-aicmiú, toisc go gcaithfear liosta iomlán na bhfaighteoirí a insint don fhreastalaí SMTP nuair a sheoltar an teachtaireacht. Má chuireann tú bealach eile chun faighteoirí a shonrú i do rang, ní mór iad a thabhairt ar ais ón modh seo freisin.
Cruthaíonn attachment () ``ceangaltán nua comhad agus cuireann sé leis an teachtaireacht é. Tá dhá bhealach ann chun glaoch ar ``attachment ():
Is féidir leat argóint amháin a chur air argóint arb é a: class: ~email.mime.base.mimeBase sampla. Cuirfear é seo isteach go díreach sa teachtaireacht mar thoradh air.
De rogha air sin, is féidir leat trí argóint attachment () ``a rith: ``ainm comhaid, content` agus mimetype. Is é ainm comhad ``ainm an cheangaltán comhad mar a bheidh sé le feiceáil sa ríomhphost, ábhar na sonraí a bheidh taobh istigh den cheangaltán agus is é `mimetype an cineál MIME roghnach don cheangaltán. Má fhágann tú mimetype`, déanfar an cineál ábhair MIME a thuairim ó ainm comhaid an cheangaltáin.
Mar shampla:
\nmessage.attach("design.png", img_data, "image/png")\nMá shonraíonn tú mimetype` o:mimetype: teachtaireach/rfc822, glacfaidh sé freisin le: class: django.core.mail.emailMessage agus:py:class: email.message.message.
\nMaidir le mimetype` ag tosú le:mimetype: text/, táthar ag súil go mbeidh an t-ábhar ina shreang. Déanfar sonraí dénártha a dhíchódú ag baint úsáide as UTF-8, agus má theipeann air sin, athrófar an cineál MIME go: mimetype: application/octet-stream agus cuirfear na sonraí ceangailte gan athrú.
\nIna theannta sin, ní bheidh ceangaltáin:: mimetype: teachtairea/rfc822 base64-ionchódaithe a thuilleadh i sárú ar:rfc: 2046 #section -5.2.1, rud a d'fhéadfadh fadhbanna a bheith ina chúis le na ceangaltáin a thaispeáint in Evolution agus Thunderbird.
\nCruthaíonn ``attach_file () ``ceangaltán nua ag baint úsáide as comhad ó do chóras comhaid. Glaoigh air le cosán an chomhaid le ceangal agus, go roghnach, an cineál MIME le húsáid don cheangaltán. Má fhágtar an cineál MIME amach, déanfar é a thuairim ón ainm comhaid. Is féidir leat é a úsáid mar seo:
\nmessage.attach_file("/images/weather_map.png")\nMaidir le cineálacha MIME ag tosú le:mimetype: text/, láimhseáiltear sonraí dénártha mar atá i attachment ().
A named tuple to store attachments to an email.
\nThe named tuple has the following indexes:
\n``ainm comhad ``
content
mimetype
D'fhéadfadh sé a bheith úsáideach leaganacha iolracha den ábhar a áireamh i ríomhphost; is é an sampla clasaiceach ná leaganacha téacs agus HTML de theachtaireacht a sheoladh. Le leabharlann ríomhphoist Django, is féidir leat é seo a dhéanamh ag baint úsáide as an rang:class: ~django.core.mail.emailMultiAlternatives.
\nA subclass of EmailMessage that allows additional versions of the\nmessage body in the email via the attach_alternative() method. This\ndirectly inherits all methods (including the class initialization) from\nEmailMessage.
A list of EmailAlternative named tuples. This\nis particularly useful in tests:
self.assertEqual(len(msg.alternatives), 1)\nself.assertEqual(msg.alternatives[0].content, html_content)\nself.assertEqual(msg.alternatives[0].mimetype, "text/html")\nAlternatives should only be added using the attach_alternative()\nmethod, or passed to the constructor.
Ceangail léiriú malartach ar chomhlacht na teachtaireachta sa ríomhphost.
\nMar shampla, chun teaglaim téacs agus HTML a sheoladh, d'fhéadfá scríobh:
\nfrom django.core.mail import EmailMultiAlternatives\n\nsubject = "hello"\nfrom_email = "from@example.com"\nto = "to@example.com"\ntext_content = "This is an important message."\nhtml_content = "<p>This is an <strong>important</strong> message.</p>"\nmsg = EmailMultiAlternatives(subject, text_content, from_email, [to])\nmsg.attach_alternative(html_content, "text/html")\nmsg.send()\nReturns a boolean indicating whether the provided text is\ncontained in the email body and in all attached MIME type\ntext/* alternatives.
This can be useful when testing emails. For example:
\ndef test_contains_email_content(self):\n subject = "Hello World"\n from_email = "from@example.com"\n to = "to@example.com"\n msg = EmailMultiAlternatives(subject, "I am content.", from_email, [to])\n msg.attach_alternative("<p>I am content.</p>", "text/html")\n\n self.assertIs(msg.body_contains("I am content"), True)\n self.assertIs(msg.body_contains("<p>I am content.</p>"), False)\nA named tuple to store alternative versions of email content.
\nThe named tuple has the following indexes:
\ncontent
mimetype
De réir réamhshocraithe, is é an cineál MIME den pharaiméadar body in:class: ~django.core.mail.emailMessage "text/plain” ``. Is dea-chleachtas é seo a fhágáil ina n-aonar, toisc go ráthaíonn sé go mbeidh aon fhaighteoir in ann an ríomhphost a léamh, beag beann ar a gcliant ríomhphoist. Mar sin féin, má tá tú muiníneach gur féidir le d'fhaighteoirí cineál malartach ábhair a láimhseáil, is féidir leat an tréith ``content_subtype a úsáid ar an aic:class: ~django.core.mail.emailMessage chun an príomhchineál ábhair a athrú. Is é ``"téacs"` an príomhchineál i gcónaí, ach is féidir leat an fochineál a athrú. Mar shampla:
msg = EmailMessage(subject, html_content, from_email, [to])\nmsg.content_subtype = "html" # Main content is now text/html\nmsg.send()\nLáimhseálann an cúltaca ríomhphoist seoladh iarbhír ríomhphoist.
\nTá na modhanna seo a leanas ag an rang cúltaca ríomhphoist:
\nCruthaíonn ``open () ``nasc seolta ríomhphoist fadtréimhseolta.
Seolann ``send_messages (email_messages) ``liosta de:class: ~django.core.mail.emailMessage rudaí. Mura bhfuil an nasc oscailte, osclóidh an glao seo an nasc go hinchinneach, agus dúnfaidh an nasc ina dhiaidh sin. Má tá an nasc oscailte cheana féin, fágfar é ar oscailt tar éis an post a sheoladh.
Is féidir é a úsáid freisin mar bhainisteoir comhthéacs, a ghlaoidh go huathoibríoch ar open () ``agus ``close () de réir mar is gá:
from django.core import mail\n\nwith mail.get_connection() as connection:\n mail.EmailMessage(\n subject1,\n body1,\n from1,\n [to1],\n connection=connection,\n ).send()\n mail.EmailMessage(\n subject2,\n body2,\n from2,\n [to2],\n connection=connection,\n ).send()\nThe get_connection() function in django.core.mail returns an\ninstance of the email backend that you can use.
De réir réamhshocraithe, cuirfidh glao chuig get_connection () ``sampla den chúltaca ríomhphoist a shonraítear in:setting: `EMAIL_BACKEND ar ais. Má shonraíonn tú an argóint backend, cuirfear sampla den chúltaca sin.
Rialaíonn an argóint fail_silently` conas ba chóir don chúltaca earráidí a láimhseáil. Má tá fail_silently` Fíor, déanfar neamhaird go ciúin ar eisceachtaí le linn an phróisis seolta ríomhphoist.
\nAll other keyword arguments are passed directly to the constructor of the\nemail backend.
\nSeolann Django le roinnt cúltaca seolta ríomhphoist. Seachas an cúltaca SMTP (arb é an réamhshocrú), níl na cúltaca seo úsáideach ach le linn tástála agus forbartha. <topic-custom-email-backend>Má tá riachtanais speisialta seolta ríomhphoist agat, is féidir leat: ref: `scríobh do chúltaca ríomhphoist féin `.
\nIs é seo an cúltaca réamhshocraithe. Seolfar ríomhphost trí fhreastalaí SMTP.
\nAisghabtar an luach do gach argóint ón suíomh meaitseála más é None an argóint:
host: :socrú: EMAIL_HOST
port: :socrú: EMAIL_PORT
use_tls: :socrú: EMAIL_USE_TLS
use_ssl: :socrú: EMAIL_USE_SSL
timeout: :socrú: EMAIL_TIMEOUT
ssl_keyfile: :socrú: EMAIL_SSL_KEYFILE
ssl_certfile: :socrú: EMAIL_SSL_CERTFILE
Is é an cúltaca SMTP an chumraíocht réamhshocraithe a d'oidhreacht Django. Más mian leat é a shonrú go sainráite, cuir an méid seo a leanas i do shocruithe:
\nEMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"\nMura bhfuil sé sonraithe, is é an réamhshocraithe timeout an ceann a sholáthraí:func: socket.getdefaulttimeout () `, atá réamhshocraithe go ``None` (gan aon am out).
In ionad fíor-ríomhphoist a sheoladh amach ní scríobhann an cúltaca an chonsól ach na ríomhphoist a sheolfaí chuig an aschur caighdeánach. De réir réamhshocraithe, scríobhann cúltaca an chonsól chuig stdout. Is féidir leat réad difriúil cosúil le sruth a úsáid tríd an argóint eochairfhocal ``sruth` a sholáthar agus an nasc á thógáil.
Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:
\nEMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"\nNíl an cúltaca seo beartaithe le húsáid i dtáirgeadh - cuirtear ar fáil é mar áisiúlacht is féidir a úsáid le linn na forbartha.
\nThe file backend writes emails to a file. A new file is created for each new\nsession that is opened on this backend. The directory to which the files are\nwritten is either taken from the EMAIL_FILE_PATH setting or from\nthe file_path keyword when creating a connection with\nget_connection().
Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:
\nEMAIL_BACKEND = "django.core.mail.backends.filebased.EmailBackend"\nEMAIL_FILE_PATH = "/tmp/app-messages" # change this to a proper location\nNíl an cúltaca seo beartaithe le húsáid i dtáirgeadh - cuirtear ar fáil é mar áisiúlacht is féidir a úsáid le linn na forbartha.
\nStórálann an cúltaca 'locmem'` teachtaireachtaí i dtréith speisialta den mhodúl ``django.core.mail. Cruthaítear an tréith outbox nuair a sheoltar an chéad theachtaireacht. Is liosta é le sampla: class: ~django.core.mail.emailMessage do gach teachtaireacht a sheolfaí.
Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:
\nEMAIL_BACKEND = "django.core.mail.backends.locmem.EmailBackend"\nNíl an cúltaca seo beartaithe le húsáid i dtáirgeadh - cuirtear ar fáil é mar áisiúlacht is féidir a úsáid le linn forbartha agus tástála.
\n<topics-testing-email>Raitheoir tástála Django: ref: `úsáideann `an cúltaca seo go huathoibríoch le haghaidh tástála `.
\nMar a thugann an t-ainm le tuiscint nach ndéanann an cúltaca dummy aon rud le do theachtaireachtaí. Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:
\nEMAIL_BACKEND = "django.core.mail.backends.dummy.EmailBackend"\nNíl an cúltaca seo beartaithe le húsáid i dtáirgeadh - cuirtear ar fáil é mar áisiúlacht is féidir a úsáid le linn na forbartha.
\nMás gá duit conas a sheoltar ríomhphoist a athrú is féidir leat do chúltaca ríomhphoist féin a scríobh. Is é an socrú: SETTING: EMAIL_BACKEND i do chomhad socruithe ansin an cosán allmhairithe Python do do rang cúltaca.
\nBa chóir go mbeadh cúltaca ríomhphoist saincheaptha fo-aicme BaseMailBackend atá suite sa mhodúl django.core.mail.backends.base. Caithfidh cúltaca ríomhphoist saincheaptha an modh send_messages (email_messages) ``a chur i bhfeidhm. Faigheann an modh seo liosta de:class: `~django.core.mail.emailMessage` cásanna agus filleann sé líon na dteachtaireachtaí a sheachadadh go rathúil. Má tá aon choincheap maidir le seisiún nó nasc leanúnach ag do chúlcheann, ba cheart duit na modhanna `open () `agus ``close ()` a chur i bhfeidhm freisin. Féach ``SMTP.EmailBackend le haghaidh cur i bhfeidhm tagartha.
Is próiseas costasach é nasc SMTP a bhunú agus a dhúnadh (nó aon nasc líonra eile, ar an ábhar sin). Má tá a lán ríomhphoist agat le seoladh, bíonn sé ciallmhar nasc SMTP a athúsáid, seachas nasc a chruthú agus a scriosadh gach uair is mian leat ríomhphost a sheoladh.
\nTá dhá bhealach ann a insíonn tú do chúltaca ríomhphoist nasc a athúsáid.
\nAr dtús, is féidir leat an modh send_messages () ``a úsáid ar nasc. Tógann sé seo liosta de:class: `EmailMessage (nó fo-aicme) cásanna, agus seolann sé iad go léir ag baint úsáide as an nasc aonair sin. Mar thoradh air sin, déantar neamhaird ar haon:class: `nasc <EmailMessage>`atá socraithe ar theachtaireacht aonair.
\nMar shampla, má tá feidhm agat ar a dtugtar ``get_notification_email () ``a thugann liosta de:class: ~django.core.mail.emailmessage rudaí a léiríonn roinnt ríomhphoist tréimhsiúil is mian leat a sheoladh amach, d'fhéadfá na ríomhphoist seo a sheoladh ag úsáid glao amháin chuig send_messages:
\nfrom django.core import mail\n\nconnection = mail.get_connection() # Use default email connection\nmessages = get_notification_email()\nconnection.send_messages(messages)\nSa sampla seo, osclaíonn an glao chuig `send_messages () ``nasc ar an gcúltaca, seolann sé liosta na dteachtaireachtaí, agus ansin dúnann sé an nasc arís.
\nIs é an dara cur chuige ná na modhanna open () ``agus ``close () a úsáid ar an gcúltaca ríomhphoist chun an nasc a rialú de láimh. Ní osclóidh nó ní dhúnfaidh ``send_messages () ``an nasc de láimh má tá sé oscailte cheana féin, mar sin má osclaíonn tú an nasc de láimh, is féidir leat rialú a dhéanamh nuair a dhúntar é. Mar shampla:
from django.core import mail\n\nconnection = mail.get_connection()\n\n# Manually open the connection\nconnection.open()\n\n# Construct an email message that uses the connection\nemail1 = mail.EmailMessage(\n "Hello",\n "Body goes here",\n "from@example.com",\n ["to1@example.com"],\n connection=connection,\n)\nemail1.send() # Send the email\n\n# Construct two more messages\nemail2 = mail.EmailMessage(\n "Hello",\n "Body goes here",\n "from@example.com",\n ["to2@example.com"],\n)\nemail3 = mail.EmailMessage(\n "Hello",\n "Body goes here",\n "from@example.com",\n ["to3@example.com"],\n)\n\n# Send the two emails in a single call -\nconnection.send_messages([email2, email3])\n# The connection was already open so send_messages() doesn't close it.\n# We need to manually close the connection.\nconnection.close()\nTá amanna ann nuair nach dteastaíonn uait Django ríomhphoist a sheoladh ar chor ar bith. Mar shampla, agus tú ag forbairt láithreán gréasáin, is dócha nach dteastaíonn uait na mílte ríomhphost a sheoladh amach - ach b'fhéidir gur mhaith leat a bhailíochtú go seolfar ríomhphoist chuig na daoine cearta faoi na coinníollacha cearta, agus go mbeidh an t-ábhar ceart sna ríomhphoist sin.
\nIs é an bealach is éasca chun ríomhphost a chumrú d'fhorbairt áitiúil ná cúltaca ríomhphoist: ref: console <topic-email-console-backend>`a úsáid. Atreoraíonn an cúltaca seo gach ríomhphost chuig `stdout`, rud a ligeann duit ábhar an phoist a iniúchadh.
\nIs féidir le cúltaca rí <topic-email-file-backend>omhphoist: Ref: `comhad `a bheith úsáideach le linn na forbartha freisin - tugann an cúltaca seo ábhar gach nasc SMTP le comhad is féidir a iniúchadh ag do chuid fóillíochta.
\nCur chuige eile is ea freastalaí SMTP “buma” a úsáid a fhaigheann na ríomhphoist go háitiúil agus a thaispeánann iad chuig an teirminéal, ach nach seolann aon rud i ndáiríre. Soláthraíonn an pacáiste: pypi: aiosmtpd bealach chun é seo a chur i gcrích:
\npython -m pip install aiosmtpd\n\npython -m aiosmtpd -n -l localhost:8025\nCuirfidh an t-ordú seo tús le freastalaí SMTP íosta ag éisteacht ar chalafort 8025 de localhost. Priontáil an freastalaí seo chuig aschur caighdeánach gach ceanntáil ríomhphoist agus an corp Ní gá duit ansin ach an: setting: EMAIL_HOST agus:setting: EMAIL_PORT a shocrú dá réir. Le haghaidh plé níos mionsonraithe ar roghanna freastalaí SMTP, féach doiciméadú an mhodúil aiosmtpd.
\nLe haghaidh faisnéise maidir le haonad-tástáil ríomhphoist a sheoladh i d'iarratas, féach an ranna:ref: topics-testing-email den doiciméad tástála.
\n