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="Subject here",\n body=text_content,\n from_email="from@example.com",\n to=["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.
The following parameters are optional, and must be given as keyword arguments\nif used.
\nfail_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, auth_password and connection have the\nsame functions as in send_mail(). They must be given as keyword arguments\nif used.
Each separate element of datatuple results in a separate email message.\nAs in send_mail(), recipients in the same recipient_list will all see\nthe other addresses in the email messages' "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.
\n\nsend_mass_mail () ``vs ``send_mail ()Link to this heading#The main difference between send_mass_mail() and send_mail() is\nthat send_mail() opens a connection to the mail server each time it's\nexecuted, while send_mass_mail() uses a single connection for all of its\nmessages. This makes send_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.
\n\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)\nThis sends a message to john@example.com and jane@example.com, with\nthem both receiving a separate email:
datatuple = (\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 ValueError and,\nhence, will not send the email. It's your responsibility to validate all data\nbefore passing 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.
\nHere's an example view that takes a subject, message and from_email\nfrom the request's POST data, sends that to admin@example.com and redirects\nto "/contact/thanks/" when it's done:
from django.core.mail import 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 ValueError:\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 send_mass_mail() functions are actually\nthin wrappers that make use of the EmailMessage class.
Not all features of the EmailMessage class are available through the\nsend_mail() and related wrapper functions. If you wish to use advanced\nfeatures, such as BCC'ed recipients, file attachments, or multi-part email,\nyou'll need to create EmailMessage instances directly.
EmailMessage is responsible for creating the email message itself. The\nemail backend is then responsible for sending the\nemail.
For convenience, EmailMessage provides a send()\nmethod for sending a single email. If you need to send multiple messages, the\nemail backend API provides an alternative.
Ríomhphost teachtaire CuspóiríLink to this heading#The EmailMessage class is initialized with the following\nparameters. All parameters are optional and can be set at any time prior\nto calling the send() method.
The first four parameters can be passed as positional or keyword arguments,\nbut must be in the given order if positional arguments are used:
\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.
The following parameters must be given as keyword arguments if used:
\ncc: Liosta nó cúpla de sheoltaí faighteora a úsáidtear sa cheanntásc “Cc” agus an ríomhphost á sheoladh.
bcc: Liosta nó tuple seoltaí a úsáidtear sa cheanntásc “Bcc” 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.
attachments: A list of attachments to put on the message. Each can\nbe an instance of MIMEPart 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.
connection: An email backend instance.\nUse this parameter if you are sending the EmailMessage via\nsend() and you want to use the same connection for multiple\nmessages. If omitted, a new connection is created when send() is\ncalled. This parameter is ignored when using\nsend_messages().
Mar shampla:
\nfrom django.core.mail import EmailMessage\n\nemail = EmailMessage(\n subject="Hello",\n body="Body goes here",\n from_email="from@example.com",\n to=["to1@example.com", "to2@example.com"],\n bcc=["bcc@example.com"],\n reply_to=["another@example.com"],\n headers={"Message-ID": "foo"},\n)\nTá na modhanna seo a leanas ag an rang:
\nSends the message. If a connection was specified when the email was\nconstructed, that connection will be used. Otherwise, an instance of\nthe default backend will be instantiated and used. If the keyword\nargument fail_silently is True, exceptions raised while sending\nthe message will be quashed. An empty list of recipients will not raise\nan exception. It will return 1 if the message was sent\nsuccessfully, otherwise 0.
Constructs and returns a Python email.message.EmailMessage\nobject representing the message to be sent.
The keyword argument policy allows specifying the set of rules for\nupdating and serializing the representation of the message. It must be\nan email.policy.Policy object. Defaults to\nemail.policy.default. In certain cases you may want to use\nSMTP, SMTPUTF8 or a custom\npolicy. For example,\ndjango.core.mail.backends.smtp.EmailBackend uses the\nSMTP policy to ensure \\r\\n line endings as\nrequired by the SMTP protocol.
If you ever need to extend Django's EmailMessage class,\nyou'll probably want to override this method to put the content you\nwant into the Python EmailMessage object.
Returns a list of all the recipients of the message, whether they're\nrecorded in the to, cc or bcc attributes. This is another\nmethod you might need to override when subclassing, because the SMTP\nserver needs to be told the full list of recipients when the message\nis sent. If you add another way to specify recipients in your class,\nthey need to be returned from this method as well.
Creates a new attachment and adds it to the message. There are two ways\nto call attach():
You can pass it three arguments: filename, content and\nmimetype. filename is the name of the file attachment as it\nwill appear in the email, content is the data that will be\ncontained inside the attachment and mimetype is the optional MIME\ntype for the attachment. If you omit mimetype, the MIME content\ntype will be guessed from the filename of the attachment.
Mar shampla:
\nmessage.attach("design.png", img_data, "image/png")\nIf you specify a mimetype of message/rfc822,\ncontent can be a django.core.mail.EmailMessage or\nPython's email.message.EmailMessage or\nemail.message.Message.
Maidir 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ú.
\nOr for attachments requiring additional headers or parameters, you\ncan pass attach() a single Python\nMIMEPart object. This will be attached\ndirectly to the resulting message. For example, to attach an inline\nimage with a Content-ID:
import email.utils\nfrom email.message import MIMEPart\nfrom django.core.mail import EmailMultiAlternatives\n\nmessage = EmailMultiAlternatives(...)\nimage_data_bytes = ... # Load image as bytes\n\n# Create a random Content-ID, including angle brackets\ncid = email.utils.make_msgid()\ninline_image = email.message.MIMEPart()\ninline_image.set_content(\n image_data_bytes,\n maintype="image",\n subtype="png", # or "jpeg", etc. depending on the image type\n disposition="inline",\n cid=cid,\n)\nmessage.attach(inline_image)\n# Refer to Content-ID in HTML without angle brackets\nmessage.attach_alternative(f'… <img src="cid:{cid[1:-1]}"> …', "text/html")\nPython's email.contentmanager.set_content() documentation\ndescribes the supported arguments for MIMEPart.set_content().
Creates a new attachment using a file from your filesystem. Call it\nwith the path of the file to attach and, optionally, the MIME type to\nuse for the attachment. If the MIME type is omitted, it will be guessed\nfrom the filename. You can use it like this:
\nmessage.attach_file("/images/weather_map.png")\nFor MIME types starting with text/, binary data is handled\nas in attach().
A named tuple to store attachments to an email.
\nThe named tuple has the following indexes:
\n``ainm comhad ``
content
mimetype
It can be useful to include multiple versions of the content in an email; the\nclassic example is to send both text and HTML versions of a message. With\nDjango's email library, you can do this using the\nEmailMultiAlternatives class.
A 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.\nThis is 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
By default, the MIME type of the body parameter in an EmailMessage\nis "text/plain". It is good practice to leave this alone, because it\nguarantees that any recipient will be able to read the email, regardless of\ntheir mail client. However, if you are confident that your recipients can\nhandle an alternative content type, you can use the content_subtype\nattribute on the EmailMessage class to change the main content type.\nThe major type will always be "text", but you can change the subtype. For\nexample:
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.
send_messages(email_messages) sends a list of EmailMessage\nobjects. If the connection is not open, this call will implicitly open the\nconnection, and close the connection afterward. If the connection is already\nopen, it will be left open after mail has been sent.
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.
The keyword-only fail_silently argument controls how the backend should\nhandle errors. If fail_silently is True, exceptions during the email\nsending process will be silently ignored.
All 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 `.
\n\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"\nIf unspecified, the default timeout will be the one provided by\nsocket.getdefaulttimeout(), which defaults to None (no timeout).
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 the\nfile_path keyword when creating a connection with get_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.
\nThe 'locmem' backend stores messages in a special attribute of the\ndjango.core.mail module. The outbox attribute is created when the first\nmessage is sent. It's a list with an EmailMessage instance for each\nmessage that would be sent.
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.
\n\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.
\nCustom email backends should subclass BaseEmailBackend that is located in\nthe django.core.mail.backends.base module. A custom email backend must\nimplement the send_messages(email_messages) method. This method receives a\nlist of EmailMessage instances and returns the number of successfully\ndelivered messages. If your backend has any concept of a persistent session or\nconnection, you should also implement the open() and close() methods.\nRefer to smtp.EmailBackend for a reference implementation.
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.
\nFor example, if you have a function called get_notification_email() that\nreturns a list of EmailMessage objects representing some periodic\nemail you wish to send out, you could send these emails using a single call to\nsend_messages():
from 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 >= 1.4.5"\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