למד כיצד לבנות אפליקציית מנהל משימות תוך שימוש בעקרונות של CRUD ותצוגות מבוססות כיתה ב-Django.

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

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

מהן תצוגות מבוססות כיתות ב-Django?

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

ל-CBV יש מספר יתרונות, כגון ארגון קוד טוב יותר, שימוש חוזר קל יותר בקוד והיכולת להשתמש בירושה כדי ליצור וריאציות של תצוגות קיימות. CBVs מספקים גם שיטות מובנות כגון לקבל() ו הודעה() שיטות שאתה יכול לדרוס עבור התנהגויות מותאמות אישית.

instagram viewer

הקוד המשמש במאמר זה זמין כאן מאגר GitHub.

תצוגות מבוססות כיתה זמינות ב-Django

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

  1. תצוגת רשימה: תצוגה זו מציגה רשימה של אובייקטים שאוחזרו ממודל. לדוגמה, דף המפרט את כל הפוסטים הזמינים בבלוג ישתמש ב-a תצוגת רשימה.
  2. DetailView: תצוגה זו מציגה תצוגה מפורטת של אובייקט בודד שאוחזר ממודל. אתה יכול להשתמש ב- a DetailView כדי להציג את הפרטים של פוסטים ספציפיים באפליקציית בלוג.
  3. CreateView: תצוגה זו מעבדת טופס ליצירת אובייקט חדש ומטפלת בהגשת הטופס. לדוגמה, באפליקציית מנהל משימות, תשתמש בתצוגה זו ליצירת משימות חדשות.
  4. DeleteView: תצוגה זו מציגה דף אישור למחיקת אובייקט ומטפלת במחיקת העמוד.
  5. UpdateView: תצוגה זו מעבדת טופס לעדכון אובייקט קיים ומטפלת בהגשת הטופס.

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

בנו אפליקציית מנהל המשימות עם תצוגות מבוססות כיתה של Django

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

הגדר פרויקט ג'נגו

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

  1. התקן את Django שלך סביבה וירטואלית של Python עם הפקודה הזו:
    התקנת pip django
  2. צור פרויקט Django. הפקודה הבאה תיצור פרויקט בשם ליבת_פרויקט.
    django-admin startproject project_core .
  3. צור אפליקציה בשם מנהל משימות.
    python manage.py startapp task_manager
  4. אצלך settings.py הוסף את שם האפליקציה שלך ל- INSTALLED_APPS רשימה.
    INSTALLED_APPS = [
    'מנהל משימות',
    ]
  5. פתח את ה urls.py קובץ בספריית הפרויקט שלך והגדר את כתובות האתרים שלך מנהל משימות אפליקציה:
    מ django.urls יְבוּא נתיב, כולל
    urlpatterns = [
     נָתִיב('', כולל('task_manager.urls')),
    ]

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

בספריית האפליקציה שלך (או מנהל משימות תיקיה), פתח את שלך models.py קובץ וצור מודל עבור אפליקציית מנהל המשימות שלך. להלן דגם לדוגמה שתוכל להשתמש בו:

מ django.db יְבוּא דגמים
מעמדמְשִׁימָה(דגמים. דֶגֶם):
 כותרת = דגמים. CharField (max_length=200)
 תיאור = דגמים. שדה טקסט()
 הושלם = דגמים. BooleanField (ברירת מחדל=שֶׁקֶר)
 create_at = מודלים. DateTimeField (auto_now_add=נָכוֹן)

העבר את המודל שלך עם הפקודה הזו:

python manage.py העברת python manage.py && python manage.py

צור טופס Django עבור האפליקציה שלך

כדאי שיהיה לך טופס לטיפול לִיצוֹר ו עדכון פעולות. בספריית האפליקציה שלך, צור קובץ בשם forms.py. הנה דוגמה:

מ ג'נגו יְבוּא טפסים
מ .מודלים יְבוּא מְשִׁימָה
מעמדטופס משימה(טפסים. ModelForm):
מעמדמטא:
 מודל = משימה
 שדות = ['כותרת', 'תיאור', 'הושלם']
 ווידג'טים = {
'כותרת': צורות. TextInput (attrs={'מעמד': 'בקרת צורה',}),
'תיאור': צורות. Textarea (attrs={'מעמד': 'בקרת צורה',}),
'הושלם': צורות. CheckboxInput (attrs={'מעמד': 'טופס-בדיקת קלט'}),
 }

לקוד למעלה יש מחלקה שנקראת טופס משימה שמגדיר את השדות והווידג'טים של הטופס. זה גם מציין את הדגם לשימוש.

צור תצוגות ג'נגו עבור כל פעולת CRUD

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

ייבא את המודולים והחבילות הדרושים

פתח את views.py קובץ ובצע את הייבוא ​​הבא:

מ django.views.generic יְבוּא ListView, DetailView, CreateView, UpdateView, DeleteView
מ django.urls יְבוּא הפוך_עצלן
מ .מודלים יְבוּא מְשִׁימָה
מ טפסים יְבוּא טופס משימה

הקוד לעיל מייבא חמישה CBVs. זה גם מייבא הפוך_עצלן כדי להפנות את המשתמש לכתובת URL שצוינה לאחר שליחת טופס. לבסוף, הוא מייבא את מְשִׁימָה דגם, ואת טופס משימה נוצר קודם לכן.

צור תצוגה לרשימת אובייקטי מודל

לאפליקציית מנהל משימות צריכה להיות דף המפרט את כל המשימות שנוצרו על ידי המשתמש. כדי ליצור תצוגה עבור זה, עליך להשתמש ב- תצוגת רשימה. הנה דוגמה:

מעמדTaskListView(תצוגת רשימה):
 מודל = משימה
 template_name = 'task_manager/task_list.html'
 context_object_name = 'משימות'

התצוגה שלמעלה מגדירה שלוש תכונות שהן:

  1. דֶגֶם: תכונה זו מגדירה באיזה דגם להשתמש בתצוגה הספציפית הזו.
  2. שם התבנית: תכונה זו אומרת ל-Django איזו תבנית לעבד לדפדפן.
  3. context_object_name: תכונה זו מגדירה את השם המאפשר לתבנית לגשת לרשימת האובייקטים במודל.

רוב ה-CBVs יכילו את שלוש התכונות הללו.

צור תצוגה כדי לטפל בפרטי משימה

לכל משימה שמשתמש יוצר צריך להיות דף המציג את הפרטים שלה. ה-CBV האידיאלי לטפל בזה הוא DetailVew. הנה דוגמה פשוטה:

מעמדTaskDetailView(תצוגה מפורטת):
 מודל = משימה
 template_name = 'task_manager/task_detail.html'

צור תצוגה ליצירת משימות

צור תצוגה כדי לטפל ביצירה או הוספה של משימות חדשות. זה לִיצוֹר חלק מפעולות ה-CRUD, וההשקפה הנכונה לכך היא CreateView. הנה איך להשתמש בו:

מעמדTaskCreateView(CreateView):
 מודל = משימה
 form_class = TaskForm
 template_name = 'task_manager/task_form.html'
 success_url = reverse_lazy('רשימת מטלות')

הקוד למעלה מציג שתי תכונות חדשות: form_class ו success_url.

ה form_class attribute אומר לתצוגה באיזו מחלקת טופס לעבד ולהשתמש עבור הפעולות שלה.

ה success_url מפרט כיצד להפנות את המשתמש לאחר שליחת הטופס. הוא משתמש ב- הפוך_עצלן פונקציה שלוקחת את השם של נתיב כתובת URL.

צור תצוגה לעריכת משימות

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

מעמדTaskUpdateView(UpdateView):
 מודל = משימה
 form_class = TaskForm
 template_name = 'task_manager/task_form.html'
 success_url = reverse_lazy('רשימת מטלות')

התצוגה לעיל דומה ל- TaskCreateView נוצר קודם לכן. ההבדל היחיד הוא השימוש ב- UpdateView.

צור תצוגה לטיפול בפעולות מחיקה

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

מעמדTaskDeleteView(DeleteView):
 מודל = משימה
 template_name = 'task_manager/task_confirm_delete.html'
 success_url = reverse_lazy('רשימת מטלות')

הגדר את כתובות האתרים של האפליקציה שלך

בספריית האפליקציה שלך, צור א urls.py קובץ והגדר את דפוסי כתובת האתר שלך כך:

מ django.urls יְבוּא נָתִיב
מ .צפיות יְבוּא TaskListView, TaskDetailView, TaskCreateView, TaskUpdateView, TaskDeleteView
urlpatterns = 
 נָתִיב('', TaskListView.as_view(), name='רשימת מטלות'),
 נָתִיב('לִיצוֹר/', TaskCreateView.as_view(), name='משימה_צור'),
 נָתִיב('משימות//', TaskDetailView.as_view(), name='פרט_משימה'),
 נָתִיב('משימות//update/', TaskUpdateView.as_view(), name='עדכון_משימה'),
 נָתִיב('משימות//delete/', TaskDeleteView.as_view(), name='משימה_מחק'),
]

דפוסי כתובת האתר שלמעלה דומים לכתובות URL שנוצרו עם תצוגות מבוססות פונקציות. ההבדל הוא ה as_view() פונקציה המצורפת בסוף כל שם תצוגה.

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

צור תבניות לצפיות שלך

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

בספריית האפליקציה שלך, צור ארבע תבניות HTML. כדאי גם ליצור base.html קוֹבֶץ. אתה יכול עצב את תבניות ה-Django שלך עם Bootstrap לחסוך זמן.

תבנית רשימת משימות

תבנית זו צריכה לכלול קוד המפרט את כל המשימות במודל. דוגמה שלדית לקוד היא זו:

{% מרחיב את 'base.html' %}
{% block content %}
<מֶרְכָּז>
<h1>המשימות שלךh1>
<אhref="{% url 'task_create' %}">הוסף משימהא>
 {% עבור משימה במשימות %}
<div>
<div>
<h5>{{ task.title }}h5>
<ע>{{ task.description|truncatechars: 50 }}ע>
<ע>
<חָזָק>הושלם:חָזָק>
 {% if task.completed %}כן{% else %}לא{% endif %}
ע>
<אhref="{% url 'task_detail' task.pk %}">
 קרא עוד
א>
<אhref="{% url 'task_delete' task.pk %}">
 מחק משימה
א>
div>
div>
 {% ריק %}
<h3>עדיין אין משימות.h3>
<אhref="{% url 'task_create' %}">הוסף משימהא>
 {% endfor %}
מֶרְכָּז>
{% endblock %}

עם כמה שיעורי Bootstrap, אתה יכול לגרום לדף שלך להיראות כך:

תבנית פירוט משימה

דף זה אמור להציג את הפרטים המלאים של כל משימה שנוצרה. להלן תבנית לדוגמה שבה תוכל להשתמש:

{% מרחיב את 'base.html' %}
{% block content %}
<h1>{{ task.title }}h1>
<ע>{{ task.description }}ע>
<ע>הושלם: {% if task.completed %}כן{% else %}לא{% endif %}ע>
<אhref="{% url 'task_update' task.pk %}">ערוך משימהא>
<אhref="{% url 'task_delete' task.pk %}">מחק משימהא>
{% endblock %}

בהתאם לגישת הסגנון שלך, הדף שלך צריך להיראות כך:

תבנית טופס משימה

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

{% מרחיב את 'base.html' %}
{% block content %}
<h1>צור משימהh1>
<טופסשיטה="הודעה">
 {% csrf_token %}
 {{ form.as_p }}
<לַחְצָןסוּג="שלח">להציללַחְצָן>
טופס>
{% endblock %}

התבנית תיראה כך:

מחק תבנית משימה

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

{% מרחיב את 'base.html' %}
{% block content %}
<h1>אשר את המחיקהh1>
<ע>האם אתה בטוח שברצונך למחוק את "{{ object.title }}"?ע>
<טופסשיטה="הודעה">
 {% csrf_token %}
<לַחְצָןסוּג="שלח">לִמְחוֹקלַחְצָן>
<אhref="{% url 'task_list' %}">לְבַטֵלא>
טופס>
{% endblock %}

עם כמה Bootstrap, הדף שלך צריך להיראות כך:

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

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