איך לשלוח מייל עם Django

בדרכי הדרכה זו, נלמד כיצד לשלוח מיילים באמצעות Django. נכסה איך להגדיר חיבורי SMTP של Django, איך להגדיר סיסמת אפליקציה לספק האימייל שלך, ואיך לשלוח מיילים דרך מסמך ה-Django. נבחן גם איך להגדיר טופס קשר עבור היישום שלך ב-Django, מה שיאפשר ללקוחותיך ליצור קשר עמך.

רוב יישומי האינטרנט משתמשים באימייל לניהול פעולות קרדינליות, כגון החזרת סיסמאות, הפעלת חשבון, קבלת משוב לקוחות, שליחת פרקטורים וקמפיינים שיווקיים. רוב המשימות הללו דורשות שירות מיוחד כמו SendGrid או Mailgun. אבל אם אינך מצפה שהאתר שלך יקבל כמות עצומה של מבקרים, בעצם תוכל להשיג הרבה דרך ספק האימייל האישי שלך.

שליחת מיילים באמצעות האימייל האישי שלך היא אפשרות הגיונית לפרויקטים קטנים או לניסויים, אז נלך בגישה זו כאן כדי לשמור על דברים פשוטים. עם זאת, זה לא רעיון טוב להשתמש בשירות האימייל האישי שלך עבור האתר הפרודוקטיבי שלך. תוכל ללמוד עוד על הגבלות שליחה של Gmail, או להתייחס למגבלות של ספק האימייל שלך.

הערה: הקוד המלא עבור הדרכה זו זמין ב-GitHub.

הבנת SMTP

SMTP (או פרוטוקול המילוי הפשוט) הוא קבוצת כללים לקביעת איך מיילים מועברים משולחים לנמענים. שרתי SMTP משתמשים בפרוטוקול זה לשליחה והעברת מיילים יוצאים. (שים לב שפרוטוקולים אחרים שולטים על איך מיילים נמצאיםמקבלים.)

שרת SMTP תמיד יש כתובת ייחודית, ונקודת מפתח ספציפית לשליחת הודעות, שבמקרה הרבה מכם היא 587. נראה איך הנקודת המפתח רלוונטית בעת שליחת מיילים עם Django.

מאחר ואנו נשתמש בGmail, הכתובת שאנו נעבוד איתה היא smtp.gmail.com, והנקודת המפתח תהיה 587.

עכשיו בואו נראה איך אפשר לשלוח מיילים עם Django.

יצירת פרויקט Django

כל פרויקט Django צריך להיות עם סביבת וירטואלית, מאחר שאנו לא רוצים להתעסק עם תלות הפרויקט. כדי ליצור אחת, הפעל את הפקודה הבאה:

python -m venv .venv

הערה: אם אתה לא מכיר בסביבות וירטואליות, וודא שבדקת את המדריך שלנו על סביבות וירטואליות ב-Python.

הפקודה לעיל יוצרת סביבה וירטואלית בשם .venv. כדי להפעיל את הסביבה הוירטואלית זו, אתה יכול להשתמש בהלך הבא:

source .venv/bin/activate

מאחר וDjango הוא חבילה שלישית, אתה חייב להתקין אותו עם pip:

pip install django

זה יתקין את הגרסה האחרונה של Django, שאפשר לבדוק עם pip freeze.

ליצירת פרויקט Django, תקרא את פקודת שורת הפקודה django-admin:

django-admin startproject EmailProject

עם הפקודה לעיל, אתה יוצר פרויקט Django בשם EmailProject, אך אתה יכול ליצור את הפרויקט בשם כזה שתרצה.

עכשיו, כנס לתיקייה הפרויקט והפעל את השרת:

cd EmailProject
python manage.py runserver

לאחר שהפעלת את שרת Django, גלה http://localhost:8000 בדפדפן שלך. תראה דף מיון גנרי עם הערות שיצאו לאחרונה לשדרוג Django.

שינוי מפריטי

תצטרך לשנות את קובץ ההגדרות לפני שתשלח הודעות אלקטרוניות, אז בואו נמצא את הקובץ הזה עם הפקודה tree:

הערה: לשם פשטות, אנו נשתמש רק בפקודות מערכת UNIX (macOS או Linux).

tree

הפקודה tree מדפיסה את מבנה הקבצים של תיקייה. במקרה זה, מאחר ואנו לא נותנים לה מסלול מדויק של תיקייה, נקבל משהו דומה למה שמופיע למטה אם אנו נמצאים בתיקיית השורש.

├── EmailProject
│   ├── asgi.py
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

1 directory, 6 files

הקובץ שנערוך באופן קבוע במהלך הדרכה זו הוא settings.py בתיקיית EmailProject.

settings.py מארח את כל ההתקנים של הפרויקט שתצטרך ומאפשר לך להגדיר משתנים מותאמים אישית. כפי שכתבו במדריך ה-Django, "קובץ ההגדרות הוא רק מודול Python עם משתנים ברמה המודול".

בואו נבחן את ההגדרות הנדרשות לשליחת מייל באמצעות Django. פתח את הקובץ EmailProject/settings.py והדבק את ההגדרות הבאות בתחתית הקובץ:

# EmailProject/settings.py

# Bottom of the file
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = ''
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = ''
EMAIL_HOST_PASSWORD = ''

בואו נפרק את הקוד למעלה על ידי ניתוח כל אחת מההגדרות האלה.

מאחז האימייל

ההגדרה EMAIL_BACKEND מכריזה על המאחז שהפרויקט שלנו ב-Django ישתמש בו לחיבור לשרת ה-SMTP.

משתנה זה מצביע על המחלקה smtp.EmailBackend שמקבלת את כל הפרמטרים הנחוצים לשליחת מייל. אני ממליץ בחום להסתכל על בנאי המחלקה ישירות בקוד המקור של Django. תהיה הפתעה מכמה הקוד הזה קריא.

הערה: למרות שהמחלקה הזו היא ה-EMAIL_BACKEND הברירת מחדל, נחוץ במובן מסוים להיות מפורשים בהגדרות Django.

כל ההגדרות האחרות של האימייל יהיו מבוססות על בנאי מחלקה EmailBackend.

מארח אימייל

ההגדרה EMAIL_HOST מתייחסת לפרמטר של שרת ה-SMTP שתשתמש בו. זה תלוי בספק האימייל שלך. להלן טבלה עם שרתי SMTP המתאימים לשלושה ספקים נפוצים:

Email provider	SMTP server host
Gmail	smtp.gmail.com
Outlook/Hotmail	smtp-mail.outlook.com
Yahoo	smtp.mail.yahoo.com

אנו משאירים את ההגדרה הזו ריקה לעת עתה מאחר ואנו נשתמש בקובץ .env מאוחר יותר כדי להימנע ממפתחות רגישים מקודדים קשה או קביעות מופרדות לאתר. אסור לך להגדיר רשומות ישירות בקוד.

אנו נשתמש ב-Django Environ כדי לפתור בעיה זו.

ממוקם אימייל

ההגדרה EMAIL_PORT חייבת להיות מוגדרת על 587 מכיוון שזהו היציאה הברירת מחדל עבור רוב שרתי SMTP. זה נכון גם עבור ספקי אימייל אישיים.

יציאה זו משמשת יחד עם הצפנת TLS כדי להבטיח את האבטחה של שליחת אימיילים.

שימוש ב-TLS באימייל

Transport Layer Security (TLS) היא פרוטוקול אבטחה המשמש ברחבי האינטרנט להצפנת התקשרות בין אפליקציות אינטרנט (Django) לשרתים (שרת SMTP).

במקור, הגדרנו את המשתנה EMAIL_USE_TLS על True. זה אומר ש-Django ישתמש ב-Transport Layer Security כדי להתחבר לשרת SMTP ולשלוח אימיילים. (זה נחוץ עבור ספקי אימייל אישיים.)

משתמש בשרת אימייל

ההגדרה EMAIL_HOST_USER היא כתובת האימייל האישית שלך. השאר את זה ריק לעת עתה, מאחר ואנו נשתמש ב-django-environ כדי להגדיר את כל הרשומות האלה.

סיסמא של שרת אימייל

הגדרת EMAIL_HOST_PASSWORD היא סיסמת האפליקציה שתשיג מחשבון האימייל שלך – התהליך שנעשה מייד לאחר סעיף זה.

אותו סיפור: השאר את ההגדרה ריקה, כי נשתמש במשתנים סביבתיים מאוחר יותר.

הכנת סיסמת אפליקציה ב-Gmail

כדי להשתמש בהגדרת EMAIL_HOST_PASSWORD תצטרך להפעיל את גישת האפליקציות הפחות בטוחות ולקבל סיסמת אפליקציה מכתובת האימייל האישית שלך.

אם לא תפעיל את גישת האפליקציות הפחות בטוחות, סביר שתקבל SMTPAuthenticationError, משום ש-Django אין דרך לעמוד בפרוטוקולי האבטחה של Google.

אפשר לבחור להשתמש בסיסמה הרגילה שלך, אך זה יהיה אף יותר מסוכן משימוש בסיסמת אפליקציה. הייעוץ שלי הוא ליצור חשבון Gmail חדש או להשתמש בכתובת אימייל "בדיקה".

לפי זה, אפשר לקבל סיסמת אפליקציה Gmail בשלבים הבאים. שים לב שאם אתה משתמש בחשבון קיים והפעלת 2 שלבי אימות, אפשר לדלג על שלבים 2 ו-3:

1. צור או התחבר לחשבון Gmail
2. עבור ל myaccount.google.com/lesssecureapps והפעל את אפשרות האפליקציות הפחות בטוחות.
   
3. הפעל אימות דו-שלבי מאחורי הקלטת סיסמת יישום.
   
4. עכשיו כשאימות דו-שלבי מופעל, הגיע הזמן לקבל סיסמת יישום. אפשר לעשות זאת על ידי הגעת לאזור האבטחה בחשבון הגוגל שלך, גלישה למטה אל סעיף "כניסה לגוגל", ולחיצה על סיסמאות יישום.
   

תצטרך להזין מחדש את הסיסמה שלך (סיסמת החשבון), לפני שתועבר לדף סיסמאות היישום.

ברגע שאתה שם, לחץ על בחר אפליקציה, כאן תבחר שם מותאם אישית לסיסמת היישום – כגון "שליחת מייל Django" – ואז לחץ על יצירה.

A new window will show up with a sixteen-character password. Copy it, because we’ll need it to configure our Django project.

אם אתה משתמש בספקי מייל אחרים, וודא שקראת את המדריכים הבאים:

• סיסמת יישום Yahoo
• סיסמת יישום Outlook או Hotmail

באמצעות Django Environ להסתיר מפתחות רגישים

אפילו אם אתה רק שולח מיילים בשלב הפיתוח, אסור לך לכתוב סיסמאות ישירות לתוך קוד המקור. זה הופך להיות חשוב עוד יותר כאשר משתמשים במערכת שליטה גרסאות יחד עם GitHub לאחסון הפרויקט שלך. אתה לא רוצה שאנשים יגישו לנתונים שלך.

בואו נראה כיצד נוכל למנוע זאת באמצעות Django-environ.

צור קובץ .env בתיקייה EmailProject (שם נמצא קובץ settings.py) עם הפקודה הבאה:

cd EmailProject/
ls

settings.py # הקובץ של ההגדרות חייב להיות כאן

touch .env

עכשיו, פתח את הקובץ .env והכנס את הזוגות מפתח-ערך הבאים:

EMAIL_HOST=smtp.gmail.com
EMAIL_HOST_USER=YourEmail@address
EMAIL_HOST_PASSWORD=YourAppPassword
RECIPIENT_ADDRESS=TheRecieverOfTheMails

לפרק את התוכן של הקובץ הזה:

• EMAIL_HOST: כתובת שרת ה-SMTP של ספק האימייל שלך. ראה את טבלת ספקי האימייל לעיל לעזרה מהירה. במקרה זה, אני משתמש ב-smtp.gmail.com, כתובת SMTP של Gmail.
• EMAIL_HOST_USER: כתובת האימייל שלך.
• EMAIL_HOST_PASSWORD: הסיסמא היישומית שהכנסת עכשיו. שים לב שזה לא כולל שום רווחים.
• RECIPIENT_ADDRESS: כתובת האימייל בה אתה תקבל את ההודעות. זוהי הגדרה מותאמת אישית שנוצרה מאוחר יותר כדי לשלוח את כל המיילים לאותו נמען.

כדי להשתמש במשתני הסביבה הללו, נצטרך להתקין Django-environ:

pip install django-environ

הערה: ודא שהסביבה הווירטואלית שלך פעילה.

עכשיו, פתח את הקובץ settings.py הממוקם בספרייה EmailProject והשתמש בקוד הבא:

# EmailProject/settings.py
# זה צריך להיות בתחילת הקובץ
import environ

env = environ.Env()
environ.Env.read_env()

# הגדרות קודמות ...
EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
EMAIL_HOST = env('EMAIL_HOST')
EMAIL_PORT = 587
EMAIL_USE_TLS = True
EMAIL_HOST_USER = env('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = env('EMAIL_HOST_PASSWORD')

# הגדרה מUSTOM. לדוא"ל
RECIPIENT_ADDRESS = env('RECIPIENT_ADDRESS')

קודם כל, אנו מייבאים את החבילה environ בחלק העליון של קובץ ההגדרות. זכור שכל הייבואים צריכים להיות בתחילת הקובץ.

לאחר מכן אנו יוצרים משתנה env שיכיל את כל זוגות המפתח-ערך הזמינים בקובץ .env.

הצהרת env('KEY') אומרת שאנו מחפשים את ערכו של המפתח הזה. ודא שקיים לך קובץ .env לפני שאתה ממשיך, כי אם משתנה סביבה כלשהו לא הוגדר, תקבל שגיאת Django ImproperlyConfigured.

שים לב ש-RECIPIENT_ADDRESS היא הגדרה מUSTOM שנשתמש בה לשליחת האימיילים לכתובת שנוכל לגשת אליה.

אל תשכח לכלול את הקובץ .env ב-.gitignore אם אתה משתמש ב-Git ו-GitHub. אפשר לעשות זאת פשוט על ידי פתיחתו והוספת השורה הבאה:

.env

1. שליחת מיילים בשפת Django Shell

לבסוף, נגיע לחלק המרגש בכתבה! הגיע הזמן לשלוח את המייל הראשון שלך ל-Django.

פתח תיבת מחשבון, הפעל את הסביבה הווירטואלית, והפעל:

python manage.py shell

זה ייצור פסקל עם כל ההגדרות של Django כבר מותאמות עבורנו. בתוך הפסקל החדש הזה, הדבק את הקוד הבא:

>>> from django.core.mail import send_mail
>>> from django.conf import settings
>>> send_mail(
...     subject='A cool subject',
...     message='A stunning message',
...     from_email=settings.EMAIL_HOST_USER,
...     recipient_list=[settings.RECIPIENT_ADDRESS])
1

אנו יכולים גם לעשות פסקל בודד ללא צורך לציין את הארגומנטים:

>>> send_mail('A cool subject', 'A stunning message', settings.EMAIL_HOST_USER, [settings.RECIPIENT_ADDRESS])
1

בואו נפרק את הקוד למעלה:

• אנו מייבאים את פונקציית Django send_mail.
• ואז אנו מייבאים את אובייקט settings אשר מכיל את כל ההגדרות גלובליות וההגדרות לפי אתר (אלו בתוך הקובץ settings.py).
• לבסוף, אנו מעבירים את כל הארגומנטים הנחוצים לפונקציית send_mail. פונקציה זו מחזירה את מספר המיילים שנשלחו, במקרה זה, 1.

שים לב כיצד אנו משתמשים באובייקט settings כדי לקבל את from_email (האימייל שאתה שולח ממנו) ואת recipient_list (ההגדרה ההתאמית RECIPIENT_ADDRESS שהגדרנו ב-.env).

עכשיו, אם אבדוק את תיבת הדואר שלי – כפי שקבעתי את המשתנה הסביבתי RECIPIENT_ADDRESS לכתובת האימייל שלי – אקבל את ההודעה שנשלחה על ידי Django.

2. בניית טופס קשר אוטומטי עם Django

בסעיף זה, נבנה טופס קשר אוטומטי עם טופסים Django והפונקציה הבנויה בבסיס send_mail. כמו כן, נוסיף פונקציה מUSTOM, send(), בתוך טופס הקשר כדי שיהיה קל יותר ליישם אותו בנוף.

נתחיל ביצירת אפליקציית הקשר. היכנס למדריך הבסיס של הפרויקט – בו manage.py ממוקם – והפעל:

python manage.py startapp contact

לאחר מכן, התקן אותו במשתנה INSTALLED_APPS שלך בתיקייה EmailProject/settings.py:

# EmailProject/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    ...

    # Custom
    'contact',
]

לפני שנתקדם עם אפליקציית contact, נכוון את urlpatterns בתיקיית EmailProject/urls.py. לשם כך, היכנס לפונקציה django.urls.include וכלול את URL-ים הקשר בפרויקט הכולל. אל תדאגו; נקבע את URL-ים הקשר בהמשך:

# EmailProject/urls.py

from django.contrib import admin
from django.urls import path, include # New import

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('contact.urls')) # Include Contact URLs
]

טופס הקשר

היכנס לתיקיית contact וצור קובץ forms.py. זהו פרקטיות טובה להגדיר את כל הטפסים שלך בתוך קובץ forms.py, אך זה אינו חובה. זו הסיבה שDjango אינו כולל קובץ זה כברירת מחדל.

אפשר ליצור את קובץ הטפסים עם הפקודות הבאות:

cd ../contact/
# היית בתיקיית EmailProject
touch forms.py

פתח את הקובץ שבדיוק נוצר ובצע את הייבואים הבאים:

# contact/forms.py
from django import forms
from django.conf import settings
from django.core.mail import send_mail

לדג'נגו מודול הטופס מספק לנו את כל המחלקות והשדות הנחוצים ליצירת טופס הקשר שלנו. שוב אנו מייבאים את האובייקט settings ואת הפונקציה send_mail לשליחת האימיילים.

טופס הקשר שלנו יכיל מספר שדות וישתמש בשתי פונקציות מUSTOM: get_info(), שמעצב את המידע שנמסר על ידי המשתמש, וsend(), שתשלח את ההודעה.

בואו נראה איך זה מופקד בקוד:

# contact/forms.py
class ContactForm(forms.Form):

    name = forms.CharField(max_length=120)
    email = forms.EmailField()
    inquiry = forms.CharField(max_length=70)
    message = forms.CharField(widget=forms.Textarea)

    def get_info(self):
        """
        Method that returns formatted information
        :return: subject, msg
        """
        # Cleaned data
        cl_data = super().clean()

        name = cl_data.get('name').strip()
        from_email = cl_data.get('email')
        subject = cl_data.get('inquiry')

        msg = f'{name} with email {from_email} said:'
        msg += f'\n"{subject}"\n\n'
        msg += cl_data.get('message')

        return subject, msg

    def send(self):

        subject, msg = self.get_info()

        send_mail(
            subject=subject,
            message=msg,
            from_email=settings.EMAIL_HOST_USER,
            recipient_list=[settings.RECIPIENT_ADDRESS]
        )

זו מחלקה גדולה, אז בואו נפרק את מה שאנו עושים בכל חלק. קודם כל, אנו מגדירים ארבעה שדות שיהיו חובה לשלוח את ההודעה:

• name וenquiry הם CharFields המייצגים את השם והסיבה להודעת הקשר.
• email הוא EmailField המייצג את כתובת האימייל של האיש שמנסה ליצור איתך קשר. שים לב שהאימייל לא יישלח מכתובת האימייל של המשתמש, אלא מכתובת האימייל שקבעת לשליחת האימיילים בפרויקט Django שלך.
• message הוא עוד CharField עם היותר שאנו משתמשים בסמל Textarea. זה אומר שכאשר מציגים את הטופס, זה יצור תג <textarea> במקום תג <input> פשוט.

כשנכנסים לשיטות המותאמות אישית, אנו משתמשים רק בשיטה get_info לעיצוב המידע שנמסר על ידי המשתמש ומחזיר שני משתנים: subject, שהוא למעשה השדה inquiry, והmessage, שיהיה ההודעה האמיתית שנשלחה על ידי Django.

מצד שני, השיטה send() רק מקבלת את המידע המעוצב מהשיטה get_info ושולחת את ההודעה עם פונקציית send_mail.

למרות שהקטע הזה היה די גדול, תראו כיצד הפשטנו את תצוגת הצורך על ידי יישום כל ההנחיות לשליחה בContactForm עצמו.

תצוגת צורך

פתח את הקובץ contact/views.py והוסף את הייבואים הבאים:

# contact/views.py
from django.views.generic import FormView, TemplateView
from .forms import ContactForm
from django.urls import reverse_lazy

כפי שאפשר לראות, אנו נשתמש בדפארט כללי של דג'נגו, מה שמציל מאוד זמן כשעושים משימות פשוטות – למשל, כשמכינים טופס עם FormView או יוצרים תצוגה שמראה תבנית רק עם TemplateView.

כמו כן, אנו מייבאים את הContactForm שבנינו בסעיף הקודם ואת הפונקציה reverse_lazy המשמשת בעבודה עם class-based views.

נמשיך עם הנוערים, בואו נכתוב את ContactView:

# contact/views.py

class ContactView(FormView):
    template_name = 'contact/contact.html'
    form_class = ContactForm
    success_url = reverse_lazy('contact:success')

    def form_valid(self, form):
        # קורא לשיטת השליחה המותאמת
        form.send()
        return super().form_valid(form)

כפי שאפשר לראות, אנו בונים רובוט פשוט של FormView באמצעות הContactForm שיצרנו. אנו גם מקבעים את template_name ואת success_url. נכתוב את התבנית ה HTML ונקבע את הכתובות בהמשך.

השיטה form valid מאפשרת לנו לשלוח את הדואר האלקטרוני באמצעות השיטה ContactForm.send() רק אם כל השדות בטופס תקינים. זה משמעו שאם המשתמש מזין קלט לא תקין – כגון כתובת דואר אלקטרוני לא מעודדת – הודעה לא תשלח.

היישום של השיטה form_valid לעיל יהיה שקול למה שבא להלן בנוער מבוסס פונקציה:

# ראשון פונקציה מבוססת צופן ...

if request.method == 'POST':
    form = ContactForm(request.POST)
    if form.is_valid():
        form.send()
        return redirect('contact:success')
else:
    form = ContactForm())

סיום סעיף זה, אנו עומדים לכתוב ContactSucessView, שיציג הודעת ניצחון למשתמש. מאחר שכבר היינו מייבאים את המחלקה TemplateView, אנו זקוקים רק לבכורה ממנה ולהגדיר את התכונה template_name:

# contact/views.py
class ContactSuccessView(TemplateView):
    template_name = 'contact/success.html'

אפשר לבדוק את קובץ ה-views.py במאגר GitHub במקרה שיש לך דאגות.

כתובות URL של קשר

הגיע הזמן ליצור את תבניות ה-URL של האפליקציה contact. מאחר ש-Django אינו מעניק לנו את קובץ ה-urls.py כברירת מחדל, נצטרך ליצור אותו עם הפקודה הבאה (הקפידו להיות בתוך תיקיית ה-contact של האפליקציה):

pwd
# /path/to/project/EmailProject/contact
touch urls.py

פתח את הקובץ והגדר את המשתנים app_name ו-urlpatterns:

from django.urls import path
from .views import ContactView, ContactSuccessView

app_name = 'contact'

urlpatterns = [
    path('', ContactView.as_view(), name="contact"),
    path('success/', ContactSuccessView.as_view(), name="success"),
]

אנו משתמשים ב-path כדי לכלול את הנתיב והתצוגה המתאימים לקונפיגורציה ה-URL של האפליקציה. כשאנו מגדירים את המשתנה app_name כ-'contact', זה אומר שה-namespacing של ה-URL של האפליקציה ייראה כך:

contact:name_of_path
# For ContactView
contact:contact
# For ContactSuccessView
contact:success

הערה: מה שאנו מכנים מרחב שמות בתבניות Django ובתצוגות הוא מה שאנו קוראים ל-URL באופן דינאמי.

אפשר ללמוד עוד על מתריץ URL של Django בתיעוד הרשמי.התיעוד הרשמי.

כתיבת תבניות

תבניות Django הן הדרך המועדפת להצגת נתונים דינמיים, באמצעות HTML וסימנים מיוחדים ששפת התבניות של Django מעניקה לנו.

בשביל האפליקציה הספציפית הזו, אנחנו נשתמש בשלוש תבניות:

• base.html: כל התבניות האחרות יירשו ממנה. זה יכיל את כל שלד ה-HTML שכל התבניות חייבות להחזיק, כמו גם קישורים ל-Bootstrap.
• contact.html: מציג את טופס הצור קשר.
• success.html: מציג הודעת הצלחה.

בואו נתחיל ביצירת מבנה התבניות של האפליקציה לצור קשר (ודא שאתה בתוך תיקיית האפליקציה לצור קשר):

mkdir -p templates/contact/
cd templates/contact
touch base.html contact.html success.html

הפקודות לעיל יוצרות את המבנה התבנית הטיפוסי של אפליקציה Django משומשת חוזרת – appname/templates/appname – ואת קבצי התבנית העץ שציינתי קודם.

ככה צריך להראות עכשיו מבנה הקבצים של האפליקציה:

.
├── admin.py
├── apps.py
├── forms.py
├── __init__.py
├── migrations
│   └── __init__.py
├── models.py
├── templates
│   └── contact
│       ├── base.html
│       ├── contact.html
│       └── success.html
├── tests.py
├── urls.py
└── views.py

בואו נצלול לתוך התוכן של תבנית base.html:

<!-- contact/templates/contact/base.html -->

<!DOCTYPE html>
<html lang="en">

  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Django Email Send</title>
    <link href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" rel="stylesheet"
      integrity="sha384-wEmeIV1mKuiNpC+IOBjI7aAzPcEZeedi5yW5f2yOq55WWLwNGmvvx4Um1vskeMj0" crossorigin="anonymous" />
  </head>

  <body>
    {% block body %}

    {% endblock %}
    <script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/js/bootstrap.bundle.min.js"
      integrity="sha384-p34f1UUtsS3wqzfto5wAAmdvj+osOnFyQFpp4Ua3gs/ZVWx6oOypYoCJhGGScy+8" crossorigin="anonymous">
    </script>
  </body>

</html>

כפי שאפשר לראות, זהו הסירוגין הפשוט של קובץ HTML המכיל קישורים לBootstrap 5. זה מאפשר לנו להתאים את האפליקציה שלנו לצורך קישוריות ללא שימוש בקבצי CSS.

תג {% block name-of-block %} מאפשר לנו להגדיר מיקום תחליף ש"תבניות ילדים" ישתמשו בו. השימוש בתג זה הופך ארכיטקטורת תבנית למשימה קלה.

לפני שניכנס לטופסים, תצטרך להתקין את החבילה Django crispy forms שמאפשרת לנו להתאים אותם בקלות:

pip install django-crispy-forms

שוב, crispy_forms היא אפליקציה Django ואנו צריכים לכלול אותה ברשימה INSTALLED_APPS:

# config/settings.py

INSTALLED_APPS = [
    ...

    # אפליקציות שלישוניות
    'crispy_forms',

    # אפליקציות מUSTOM
    'contact',
]

# מציין את הממשק הקדמי שהאפליקציה Django crispy forms משתמשת בו
CRISPY_TEMPLATE_PACK = 'bootstrap4'

אנו משתמשים בחבילת תבנית של Bootstrap 4, משום שמחלקות הטופס של Bootstrap תואמות בין הגרסה הרביעית לחמישית (בעת הכתיבה).

עכשיו, בואו נעבוד על תבנית contact.html:

<!-- contact/templates/contact/contact.html -->

{% extends 'contact/base.html' %}
{% load crispy_forms_tags %}

{% block body %}
<div class="mx-auto my-4 text-center">
    <h1>Contact Us</h1>
</div>
<div class="container">
    <form action="" method="post">
        {% csrf_token %}
        {{ form | crispy }}
    <button class="btn btn-success my-3" type="submit">Send message</button>
    </form>
</div>
{% endblock %}

שימו לב כיצד הרחבנו את התבנית הבסיסית והשתמשנו במיקום המציין המסמך. זה מה שהופך את שפת התבניות של דג'נגו ליעילה כל כך, שכן היא מאפשרת לנו לחסוך המון בהעתקה והדבקה של HTML.

כשמדובר בטופס, אנו משתמשים בשיטה "post", מה שאומר שContactView שלנו יעבד את הנתונים שניתנו על ידי המשתמש ולאחר מכן ישלח את המייל אם הטופס תקף.

ה{% csrf_token %} חובה בכל טופס בגלל סיבות אבטחה. במדריך של דג'נגו יש דף מיוחד על אימות CSRF ועל הסיבות להשתמש בהם כשעובדים עם טפסים.

אנו נשפץ את הטופס עם תג התבנית crispy, וזו הסיבה שטענו את תגי התבניות של crispy עם {% load crispy_forms_tags %}.

לבסוף, בואו נכתוב את תבנית success.html:

{% extends 'contact/base.html' %}

{% block body %}
<div class="mx-auto my-4 text-center">
    <h1 class="fw-bolder text-success">We sent your message</h1>
    <p class="my-5">You can send another in the <a href="{% url 'contact:contact' %}">contact page</a></p>
</div>
{% endblock %}

כפי שאפשר לראות, זו הודעת הצלחה פשוטה המכילה קישור לטופס הקשור במקרה שהמשתמש רצה לשלוח מסר נוסף.

בואו נפעיל את השרת שוב ונבקר בhttp://localhost:8000 (הקפידו להפעיל את .venv ולהיות בתיקיית הבסיס של הפרויקט):

python manage.py runserver

התמונה שלהלן מראה איך נראה הטופס הקשור הסופי.

וזו תמונה של הודעת ההצלחה.

והנה תמונה של המייל בתיבת המייל.

לסיכום

מזל טוב! למדתם איך לשלוח מיילים עם Django וכיצד לבנות טופס קשר של Django גם כן.

יש הרבה דרכים לשלוח מיילים עם Django. בדרכת המדריך הזו, עשיתם זאת עם כתובת האימייל האישית שלכם, אבל אני רוצה שתבדקו כלים אחרים ותשלבו אותם בפרויקטים שלכם.

בדרכת המדריך הזו עסקנו במה שבאמצעות:

• איך להגדיר את ההגדרות של Django לשרת מיילים
• איך להשתמש בחשבון אימייל אישי לשלוח מיילים בפרויקט קטן
• איך להשתמש בקבצים .env לשימוש בנתונים רגישים בפרויקט Django
• איך לבנות טופס קשר אוטומטי

לקבלת מידע נוסף על Django, עיינו ב"לבנות אפליקציה לשתף תמונות עם Django".

שאלות ותשובות נפוצות על איך לשלוח אימייל עם Django