---
title: "Seoladh ríomhphoist"
version: 5.2
locale: ga
source: https://docs.djangoproject.com/ga/5.2/topics/email/
canonical: https://djangodocs.dev/ga/5.2/topics/email/
---
# Seoladh ríomhphoist

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.

Tá an cód ina gcónaí sa mhodúl `django.core.mail`.

## Samplaí gasta

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

> **Note**
>
> Socrófar an tacar carachtair ríomhphoist a sheoltar le `django.core.mail` ar luach do shuíomh: DEFAULT\_CHARSET.

## seol\_mail () \`\`

#### `send_mail(subject, message, from_email, recipient_list, fail_silently=False, auth_user=None, auth_password=None, connection=None, html_message=None)`

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 () \`\`

#### `send_mass_mail(datatuple, fail_silently=False, auth_user=None, auth_password=None, connection=None)`

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()`](#django.core.mail.send_mail).

Each separate element of `datatuple` results in a separate email message.
As in [`send_mail()`](#django.core.mail.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.

### ```send_mass_mail () ``vs ``send_mail ()```

The main difference between [`send_mass_mail()`](#django.core.mail.send_mass_mail) and
[`send_mail()`](#django.core.mail.send_mail) is that
[`send_mail()`](#django.core.mail.send_mail) opens a connection to the mail server
each time it's executed, while [`send_mass_mail()`](#django.core.mail.send_mass_mail) uses
a single connection for all of its messages. This makes
[`send_mass_mail()`](#django.core.mail.send_mass_mail) slightly more efficient.

## mail\_admins () \`\`

#### `mail_admins(subject, message, fail_silently=False, connection=None, html_message=None)`

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 () \`\`

#### `mail_managers(subject, message, fail_silently=False, connection=None, html_message=None)`

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í

Seolann sé ríomhphost amháin chuig [john@example.com](mailto:john@example.com) agus [jane@example.com](mailto: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](mailto:john@example.com) agus [jane@example.com](mailto: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 ceannteidil

Is saothrú slándála é [instealladh ceannteannair](http://www.nyphp.org/phundamentals/8_Preventing-Email-Header-Injection.html) 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()`](#django.core.mail.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](mailto: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 `EmailMessage`

Django's [`send_mail()`](#django.core.mail.send_mail) and
[`send_mass_mail()`](#django.core.mail.send_mass_mail) functions are actually thin
wrappers that make use of the [`EmailMessage`](#django.core.mail.EmailMessage) class.

Not all features of the [`EmailMessage`](#django.core.mail.EmailMessage) class are
available through the [`send_mail()`](#django.core.mail.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`](#django.core.mail.EmailMessage) instances directly.

> **Note**
>
> This is a design feature. [`send_mail()`](#django.core.mail.send_mail) and
> related functions were originally the only interface Django provided.
> However, the list of parameters they accepted was slowly growing over
> time. It made sense to move to a more object-oriented design for email
> messages and retain the original functions only for backwards
> compatibility.

[`EmailMessage`](#django.core.mail.EmailMessage) is responsible for creating the email
message itself. The [email backend](#topic-email-backends) 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 .

### `Ríomhphost teachtaire` Cuspóirí

#### `class EmailMessage`

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

- ábhar : Líne ábhair an ríomhphoist.
- 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](mailto: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.
- : Liosta nó feadán de sheoltaí faighteora.
- `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
  be instances of [`MIMEBase`](https://docs.python.org/3/library/email.mime.html#email.mime.base.MIMEBase) or
  [`EmailAttachment`](#django.core.mail.EmailAttachment), or a tuple with attributes
  `(filename, content, mimetype)`.

  > **Changed in Django 5.2**
  >
  > Support for [`EmailAttachment`](#django.core.mail.EmailAttachment) items of
  > `attachments` was added.
- `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:

```
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"},
)
```

Tá na modhanna seo a leanas ag an rang:

- Seolann ```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:

    ```
    message.attach("design.png", img_data, "image/png")
    ```

    Má shonraíonn tú mimetype\` o:mimetype: teachtaireach/rfc822, glacfaidh sé freisin le: class: django.core.mail.emailMessage agus:py:class: email.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ú.

    Ina 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](https://bugzilla.gnome.org/show_bug.cgi?id=651197) agus [Thunderbird](https://bugzilla.mozilla.org/show_bug.cgi?id=333880).
- Cruthaí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:

  ```
  message.attach_file("/images/weather_map.png")
  ```

  Maidir le cineálacha MIME ag tosú le:mimetype: text/, láimhseáiltear sonraí dénártha mar atá i `attachment ()`.

#### `class EmailAttachment`

> **New in Django 5.2**

A named tuple to store attachments to an email.

The named tuple has the following indexes:

- ainm comhad \`\`
- `content`
- `mimetype`

### Cineálacha eile ábhair a sheoladh

#### Leaganacha ábhar iolracha

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.

#### `class EmailMultiAlternatives`

A subclass of [`EmailMessage`](#django.core.mail.EmailMessage) that allows additional versions of the
message body in the email via the [`attach_alternative()`](#django.core.mail.EmailMultiAlternatives.attach_alternative) method. This
directly inherits all methods (including the class initialization) from
[`EmailMessage`](#django.core.mail.EmailMessage).

#### `alternatives`

A list of [`EmailAlternative`](#django.core.mail.EmailAlternative) named tuples. This
is particularly useful in tests:

```
self.assertEqual(len(msg.alternatives), 1)
self.assertEqual(msg.alternatives[0].content, html_content)
self.assertEqual(msg.alternatives[0].mimetype, "text/html")
```

Alternatives should only be added using the [`attach_alternative()`](#django.core.mail.EmailMultiAlternatives.attach_alternative)
method, or passed to the constructor.

> **Changed in Django 5.2**
>
> In older versions, `alternatives` was a list of regular tuples,
> as opposed to [`EmailAlternative`](#django.core.mail.EmailAlternative) named
> tuples.

#### `attach_alternative(content, mimetype)`

Ceangail léiriú malartach ar chomhlacht na teachtaireachta sa ríomhphost.

Mar shampla, chun teaglaim téacs agus HTML a sheoladh, d'fhéadfá scríobh:

```
from django.core.mail import EmailMultiAlternatives

subject = "hello"
from_email = "from@example.com"
to = "to@example.com"
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()
```

#### `body_contains(text)`

> **New in Django 5.2**

Returns a boolean indicating whether the provided `text` is
contained in the email `body` and in all attached MIME type
`text/*` alternatives.

This can be useful when testing emails. For example:

```
def test_contains_email_content(self):
    subject = "Hello World"
    from_email = "from@example.com"
    to = "to@example.com"
    msg = EmailMultiAlternatives(subject, "I am content.", from_email, [to])
    msg.attach_alternative("<p>I am content.</p>", "text/html")

    self.assertIs(msg.body_contains("I am content"), True)
    self.assertIs(msg.body_contains("<p>I am content.</p>"), False)
```

#### `class EmailAlternative`

> **New in Django 5.2**

A named tuple to store alternative versions of email content.

The named tuple has the following indexes:

- `content`
- `mimetype`

#### Nuashonrú an cineál ábhair réamhshocrai

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])
msg.content_subtype = "html"  # Main content is now text/html
msg.send()
```

## Cúltaca ríomhphoist

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

### Sampla de chúltaca ríomhphoist a fháil

The [`get_connection()`](#django.core.mail.get_connection) function in `django.core.mail` returns an
instance of the email backend that you can use.

#### `get_connection(backend=None, fail_silently=False, **kwargs)`

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.

All other keyword arguments are passed directly to the constructor of the
email backend.

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

#### Cúltaca 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)`

Is é seo an cúltaca réamhshocraithe. Seolfar ríomhphost trí fhreastalaí SMTP.

Aisghabtar 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
- ainm úsáideora : :setting: EMAIL\_HOST\_USER
- pasfhocal : :socrú: EMAIL\_HOST\_PASSWORD
- `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:

```
EMAIL_BACKEND = "django.core.mail.backends.smtp.EmailBackend"
```

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

#### Cúltaca consól

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:

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

Ní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.

#### Cúltaca comhad

The file backend writes emails to a file. A new file is created for each new
session that is opened on this backend. The directory to which the files are
written is either taken from the [`EMAIL_FILE_PATH`](/ga/5.2/ref/settings/#std-setting-EMAIL_FILE_PATH) setting or from
the `file_path` keyword when creating a connection with
[`get_connection()`](#django.core.mail.get_connection).

Chun an cúltaca seo a shonrú, cuir an méid seo a leanas i do shocruithe:

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

Ní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.

#### Cúlcheann in-chuimhne

Stó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:

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

Ní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.

\<topics-testing-email\>Raitheoir tástála Django: ref: úsáideann an cúltaca seo go huathoibríoch le haghaidh tástála .

#### Cúltaca dummy

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

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

Ní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.

### Cúlcheann ríomhphoist saincheaptha a shainiú

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

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

### Seoladh ríomhphoist iliom

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.

Tá dhá bhealach ann a insíonn tú do chúltaca ríomhphoist nasc a athúsáid.

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

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

```
from django.core import mail

connection = mail.get_connection()  # Use default email connection
messages = get_notification_email()
connection.send_messages(messages)
```

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

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

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 forbartha

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:

```shell
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](https://aiosmtpd.readthedocs.io/en/latest/).

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.