Seoladh ríomhphoistLink to this heading#

Samplaí gastaLink to this heading#

Úsáid: func: send_mail le haghaidh seoladh ríomhphoist simplí. Mar shampla, chun teachtaireacht téacs simplí a sheoladh:

from django.core.mail import send_mail

send_mail(
    "Subject here",
    "Here is the message.",
    "from@example.com",
    ["to@example.com"],
    fail_silently=False,
)

Nuair 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:

from django.core.mail import EmailMultiAlternatives
from django.template.loader import render_to_string

# First, render the plain text content.
text_content = render_to_string(
    "templates/emails/my_email.txt",
    context={"my_variable": 42},
)

# Secondly, render the HTML content.
html_content = render_to_string(
    "templates/emails/my_email.html",
    context={"my_variable": 42},
)

# Then, create a multipart email instance.
msg = EmailMultiAlternatives(
    "Subject here",
    text_content,
    "from@example.com",
    ["to@example.com"],
    headers={"List-Unsubscribe": "<mailto:unsub@example.com>"},
)

# Lastly, attach the HTML content to the email instance and send.
msg.attach_alternative(html_content, "text/html")
msg.send()

Seoltar 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.

``seol_mail () ``Link to this heading#

send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None)Link to this definition#

I bhformhór na gcásanna, is féidir leat ríomhphost a sheoladh ag baint úsáide as ``django.core.mail.send_mail () ``.

Teastaíonn na paraiméadair ábhar ``, `teachtaire, from_email` agus liosta_faighteannaithe.

• ``ábhar ``: Sreang.

• ``teachtaireacht ``: Sreang.

• 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).

``seol_mass_mail () ``Link to this heading#

send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None)Link to this definition#

Tá sé beartaithe ag ``django.core.mail.send_mass_mail () ``ollseoladh ríomhphoist a láimhseáil.

Is é datatuple` tuple ina bhfuil gach eilimint sa fhormáid seo:

(subject, message, from_email, recipient_list)

fail_silently, auth_user and auth_password have the same functions as in send_mail().

Each separate element of datatuple results in a separate email message. As in send_mail(), recipients in the same recipient_list will all see the 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:

message1 = (
    "Subject here",
    "Here is the message",
    "from@example.com",
    ["first@example.com", "other@example.com"],
)
message2 = (
    "Another Subject",
    "Here is another message",
    "from@example.com",
    ["second@test.com"],
)
send_mass_mail((message1, message2), fail_silently=False)

Is é an luach tuairisceáin líon na dteachtaireachtaí a sheachadadh go rathúil.

``mail_admins () ``Link to this heading#

mail_admins(subject, message, fail_silently=False, connection=None, html_message=None)Link to this definition#

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.

Ré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.

Tá an modh seo ann le haghaidh áisiúlachta agus inléiteachta.

Má 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.

``bainisteoirí poist () ``Link to this heading#

mail_managers(subject, message, fail_silently=False, connection=None, html_message=None)Link to this definition#

Tá 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.

SamplaíLink to this heading#

Seolann sé ríomhphost amháin chuig john@example.com agus jane@example.com, agus tá an bheirt acu le feiceáil sa “Chun:”:

send_mail(
    "Subject",
    "Message.",
    "from@example.com",
    ["john@example.com", "jane@example.com"],
)

Seolann sé seo teachtaireacht chuig john@example.com agus jane@example.com, agus faigheann an bheirt acu ríomhphost ar leithligh:

datatuple = (
    ("Subject", "Message.", "from@example.com", ["john@example.com"]),
    ("Subject", "Message.", "from@example.com", ["jane@example.com"]),
)
send_mass_mail(datatuple)

Instealladh ceannteidilLink to this heading#

Is 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.

The Django email functions outlined above all protect against header injection by forbidding newlines in header values. If any subject, from_email or recipient_list contains a newline (in either Unix, Windows or Mac style), the email function (e.g. send_mail()) will raise django.core.mail.BadHeaderError (a subclass of ValueError) and, hence, will not send the email. It's your responsibility to validate all data before 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.

Seo 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
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, ["admin@example.com"])
        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.")

An rang EmailMessageLink to this heading#

Django's send_mail() and send_mass_mail() functions are actually thin wrappers that make use of the EmailMessage class.

Not all features of the EmailMessage class are available through the send_mail() and related wrapper functions. If you wish to use advanced features, such as BCC'ed recipients, file attachments, or multi-part email, you'll need to create EmailMessage instances directly.

EmailMessage is responsible for creating the email message itself. The email backend is then responsible 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 `.

from django.core.mail import EmailMessage

email = EmailMessage(
    "Hello",
    "Body goes here",
    "from@example.com",
    ["to1@example.com", "to2@example.com"],
    ["bcc@example.com"],
    reply_to=["another@example.com"],
    headers={"Message-ID": "foo"},
)

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

Cúltaca ríomhphoistLink to this heading#

Láimhseálann an cúltaca ríomhphoist seoladh iarbhír ríomhphoist.

Tá na modhanna seo a leanas ag an rang cúltaca ríomhphoist:

• Cruthaíonn ``open () ``nasc seolta ríomhphoist fadtréimhseolta.

• Dúnann ``close () ``an nasc seolta ríomhphoist reatha.

• 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

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

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

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

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

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

from django.core import mail

connection = mail.get_connection()  # Use default email connection
messages = get_notification_email()
connection.send_messages(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",
    "from@example.com",
    ["to1@example.com"],
    connection=connection,
)
email1.send()  # Send the email

# Construct two more messages
email2 = mail.EmailMessage(
    "Hello",
    "Body goes here",
    "from@example.com",
    ["to2@example.com"],
)
email3 = mail.EmailMessage(
    "Hello",
    "Body goes here",
    "from@example.com",
    ["to3@example.com"],
)

# 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()

Ríomhphost a chumrú le haghaidh forbarthaLink to this heading#

Tá 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.

Is é 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.

Is 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.

Cur 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:

python -m pip install aiosmtpd

python -m aiosmtpd -n -l localhost:8025

Cuirfidh 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.

Le 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.