Django ക്ലാസ്-അടിസ്ഥാനത്തിലുള്ള കാഴ്ചകൾ: ജെനറിക് വ്യൂ കസ്റ്റമൈസേഷനിൽ പ്രാവീണ്യം നേടുക

വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള ശക്തവും പുനരുപയോഗിക്കാവുന്നതുമായ മാർഗ്ഗം Django-യുടെ ക്ലാസ്-അടിസ്ഥാനത്തിലുള്ള കാഴ്ചകൾ (CBV) നൽകുന്നു. CBV-കളുടെ ഒരു ഉപവിഭാഗമായ ജെനറിക് കാഴ്ചകൾ, ലിസ്റ്റുകൾ പ്രദർശിപ്പിക്കുക, വിശദമായ കാഴ്ചകൾ, ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുക, അപ്‌ഡേറ്റ് ചെയ്യുക, ഇല്ലാതാക്കുക തുടങ്ങിയ സാധാരണ ജോലികൾക്ക് മുൻകൂട്ടി തയ്യാറാക്കിയ പരിഹാരങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു. ഈ ജെനറിക് കാഴ്ചകൾ വളരെ സൗകര്യപ്രദമാണെങ്കിലും, നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ പ്രത്യേക ആവശ്യങ്ങൾക്ക് അനുയോജ്യമായ രീതിയിൽ മാറ്റങ്ങൾ വരുത്തേണ്ടതുണ്ട്. കാര്യക്ഷമവും പരിപാലിക്കാൻ എളുപ്പമുള്ളതുമായ വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ നിങ്ങളെ സഹായിക്കുന്ന Django-യുടെ ജെനറിക് കാഴ്ചകൾ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റം വരുത്തുന്നതിനുള്ള വിവിധ സാങ്കേതിക വിദ്യകൾ ഈ സമഗ്ര ഗൈഡ് പര്യവേക്ഷണം ചെയ്യുന്നു.

Django-യുടെ ക്ലാസ്-അടിസ്ഥാനത്തിലുള്ള കാഴ്ചകൾ മനസ്സിലാക്കുക

ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റം വരുത്തുന്നതിലേക്ക് കടക്കുന്നതിന് മുമ്പ്, CBV-കളെയും ജെനറിക് കാഴ്ചകളെയും കുറിച്ചുള്ള അടിസ്ഥാനകാര്യങ്ങൾ നമുക്ക് ഓർക്കാം. പരമ്പരാഗത ഫംഗ്ഷൻ അടിസ്ഥാനത്തിലുള്ള കാഴ്ചകൾ (FBV) ഒരു ഫംഗ്ഷനുള്ളിൽ HTTP അഭ്യർത്ഥനകളെ നേരിട്ട് കൈകാര്യം ചെയ്യുന്നു. മറുവശത്ത്, CBV-കൾ കാഴ്ചയുടെ ലോജിക്കിനെ ക്ലാസുകളായി ക്രമീകരിക്കുന്നു, ഇത് കൂടുതൽ ഘടനാപരമായതും ഒബ്ജക്റ്റ് ഓറിയന്റഡ് സമീപനവും നൽകുന്നു. ഇത് മികച്ച കോഡിംഗ് ഓർഗനൈസേഷനും, പുനരുപയോഗക്ഷമതയും, ടെസ്റ്റ് ചെയ്യാനുള്ള എളുപ്പവും നൽകുന്നു.

സാധാരണ വെബ് ഡെവലപ്‌മെൻ്റ് ജോലികൾ കൈകാര്യം ചെയ്യാൻ രൂപകൽപ്പന ചെയ്ത മുൻകൂട്ടി നിർമ്മിച്ച CBV-കളാണ് ജെനറിക് കാഴ്ചകൾ. അവ View, TemplateView പോലുള്ള അടിസ്ഥാന ക്ലാസുകളിൽ നിന്ന് ഇൻഹെറിറ്റ് ചെയ്യുകയും പ്രത്യേക പ്രവർത്തനക്ഷമതകൾ നൽകുകയും ചെയ്യുന്നു. പൊതുവായ ജെനറിക് കാഴ്ചകളിൽ ഇവ ഉൾപ്പെടുന്നു:

• ListView: ഒബ്ജക്റ്റുകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്നു.
• DetailView: ഒരൊറ്റ ഒബ്ജക്റ്റിന്റെ വിശദാംശങ്ങൾ പ്രദർശിപ്പിക്കുന്നു.
• CreateView: ഒരു ഫോം ഉപയോഗിച്ച് ഒബ്ജക്റ്റ് ഉണ്ടാക്കുന്നത് കൈകാര്യം ചെയ്യുന്നു.
• UpdateView: ഒരു ഫോം ഉപയോഗിച്ച് ഒബ്ജക്റ്റ് അപ്‌ഡേറ്റ് ചെയ്യുന്നത് കൈകാര്യം ചെയ്യുന്നു.
• DeleteView: ഒബ്ജക്റ്റ് ഇല്ലാതാക്കുന്നത് കൈകാര്യം ചെയ്യുന്നു.

ഈ ജെനറിക് കാഴ്ചകൾക്ക് ഒരു അടിത്തറയുണ്ട്, എന്നാൽ യഥാർത്ഥ ലോക ആപ്ലിക്കേഷനുകൾക്ക് അവയുടെ സ്വഭാവം മാറ്റേണ്ടതുണ്ട്. ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റം വരുത്തുന്നതിനുള്ള വിവിധ സാങ്കേതിക വിദ്യകൾ നമുക്ക് പര്യവേക്ഷണം ചെയ്യാം.

ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റം വരുത്തുന്നതിനുള്ള സാങ്കേതിക വിദ്യകൾ

Django-യുടെ ജെനറിക് കാഴ്ചകൾ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റം വരുത്തുന്നതിന് നിരവധി വഴികളുണ്ട്. ലളിതമായ ആട്രിബ്യൂട്ട് ഓവർറൈഡുകൾ മുതൽ കൂടുതൽ സങ്കീർണ്ണമായ രീതിയിലുള്ള ഓവർറൈഡിംഗ് വരെ ഇതിൽ ഉൾപ്പെടുന്നു. ആവശ്യമായ കസ്റ്റമൈസേഷന്റെ അളവിനെ ആശ്രയിച്ച് ഉചിതമായ സാങ്കേതികത തിരഞ്ഞെടുക്കാവുന്നതാണ്.

1. ആട്രിബ്യൂട്ട് ഓവർറൈഡിംഗ്

ജെനറിക് വ്യൂ ക്ലാസിന്റെ ആട്രിബ്യൂട്ടുകൾ മാറ്റിയെഴുതുന്നതാണ് ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റം വരുത്തുന്നതിനുള്ള ലളിതമായ മാർഗ്ഗം. മോഡൽ, ടെംപ്ലേറ്റ് നാമം അല്ലെങ്കിൽ കോൺടെക്സ്റ്റ് ഒബ്ജക്റ്റ് നാമം പോലുള്ള അടിസ്ഥാന പ്രോപ്പർട്ടികൾ മാറ്റുന്നതിന് ഇത് അനുയോജ്യമാണ്.

ഉദാഹരണം: ListView ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റിയെഴുതുന്നു

നിങ്ങൾക്ക് ലേഖനങ്ങളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നു എന്നിരിക്കട്ടെ, എന്നാൽ നിങ്ങൾക്ക് ഇഷ്ടമുള്ള ടെംപ്ലേറ്റും വ്യത്യസ്ത കോൺടെക്സ്റ്റ് ഒബ്ജക്റ്റ് നാമവും ഉപയോഗിക്കണം.

from django.views.generic import ListView
from .models import Article

class ArticleListView(ListView):
    model = Article
    template_name = 'articles/article_list.html'
    context_object_name = 'articles'

    def get_queryset(self):
        return Article.objects.filter(is_published=True).order_by('-publication_date')

ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ model, template_name, കൂടാതെ context_object_name ആട്രിബ്യൂട്ടുകൾ മാറ്റിയെഴുതി. ലേഖനങ്ങൾ ഫിൽട്ടർ ചെയ്യാനും പ്രസിദ്ധീകരണ തീയതി അനുസരിച്ച് ക്രമീകരിക്കാനും ഞങ്ങൾ get_queryset രീതി മാറ്റിയെഴുതിയിട്ടുണ്ട്. ലിസ്റ്റ് കാഴ്‌ചയിൽ ഏതൊക്കെ ഒബ്‌ജക്‌റ്റുകൾ ഉൾപ്പെടുത്തണമെന്ന് get_queryset രീതി നിങ്ങൾക്ക് നിയന്ത്രിക്കാൻ നൽകുന്നു. ഫിൽട്ടറിംഗ്, ഓർഡറിംഗ്, പേജിനേഷൻ എന്നിവ നടപ്പിലാക്കുന്നതിന് ഇത് ഉപയോഗപ്രദമാണ്.

2. രീതിയിലുള്ള ഓവർറൈഡിംഗ്

ജെനറിക് വ്യൂ ക്ലാസ്സിലെ നിലവിലുള്ള രീതികളുടെ സ്വഭാവം മാറ്റാൻ രീതിയിലുള്ള ഓവർറൈഡിംഗ് നിങ്ങളെ അനുവദിക്കുന്നു. ഇത് കാഴ്‌ചയുടെ യുക്തിയിൽ കൂടുതൽ നിയന്ത്രണം നൽകുന്നു. മാറ്റിയെഴുതാനുള്ള പൊതുവായ രീതികളിൽ ഇവ ഉൾപ്പെടുന്നു:

• get_queryset(): കാഴ്‌ച ഉപയോഗിക്കുന്ന ക്വറിസെറ്റിനെ നിയന്ത്രിക്കുന്നു.
• get_context_data(): ടെംപ്ലേറ്റ് കോൺടെക്സ്റ്റിലേക്ക് ഡാറ്റ ചേർക്കുന്നു.
• form_valid(): ഫോം വിജയകരമായി സമർപ്പിക്കുന്നത് കൈകാര്യം ചെയ്യുന്നു.
• form_invalid(): അസാധുവായ ഫോം സമർപ്പണം കൈകാര്യം ചെയ്യുന്നു.
• get_success_url(): ഫോം വിജയകരമായി സമർപ്പിച്ച ശേഷം റീഡയറക്‌ട് ചെയ്യേണ്ട URL നിർണ്ണയിക്കുന്നു.
• get_object(): DetailView, UpdateView, DeleteView എന്നിവയ്‌ക്കായുള്ള ഒബ്‌ജക്‌റ്റ് വീണ്ടെടുക്കുന്നു

ഉദാഹരണം: DetailView ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റിയെഴുതുന്നു

നിങ്ങൾക്ക് ഒരു ലേഖനത്തിന്റെ വിശദാംശങ്ങൾ പ്രദർശിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നു എന്നിരിക്കട്ടെ, എന്നാൽ ടെംപ്ലേറ്റ് കോൺടെക്സ്റ്റിൽ അനുബന്ധ കമന്റുകളും ഉൾപ്പെടുത്താൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നു.

from django.views.generic import DetailView
from .models import Article, Comment

class ArticleDetailView(DetailView):
    model = Article
    template_name = 'articles/article_detail.html'
    context_object_name = 'article'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['comments'] = Comment.objects.filter(article=self.object, is_approved=True)
        return context

ഇവിടെ, ടെംപ്ലേറ്റ് കോൺടെക്സ്റ്റിലേക്ക് ഒരു comments വേരിയബിൾ ചേർക്കാൻ ഞങ്ങൾ get_context_data() രീതി മാറ്റിയെഴുതിയിട്ടുണ്ട്. article_detail.html ടെംപ്ലേറ്റിൽ അനുബന്ധ കമന്റുകൾ എളുപ്പത്തിൽ ആക്സസ് ചെയ്യാനും പ്രദർശിപ്പിക്കാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

3. മിക്സിനുകൾ ഉപയോഗിക്കുന്നു

പ്രത്യേക പ്രവർത്തനം നൽകുന്ന പുനരുപയോഗിക്കാവുന്ന ക്ലാസുകളാണ് മിക്സിനുകൾ. കാഴ്‌ചയുടെ പ്രധാന യുക്തി മാറ്റാതെ തന്നെ ഫീച്ചറുകൾ ചേർക്കാൻ അവയെ ജെനറിക് കാഴ്‌ചകളുമായി സംയോജിപ്പിക്കാൻ കഴിയും. Django നിരവധി അന്തർനിർമ്മിത മിക്സിനുകൾ നൽകുന്നു, നിങ്ങൾക്ക് സ്വയം നിർമ്മിക്കാനും കഴിയും.

ഉദാഹരണം: LoginRequiredMixin ഉപയോഗിക്കുന്നു

LoginRequiredMixin ലോഗിൻ ചെയ്ത ഉപയോക്താക്കൾക്ക് മാത്രമേ ഒരു പ്രത്യേക കാഴ്‌ചയിലേക്ക് പ്രവേശിക്കാൻ കഴിയൂ എന്ന് ഉറപ്പാക്കുന്നു.

from django.views.generic import CreateView
from django.contrib.auth.mixins import LoginRequiredMixin
from .models import Article
from .forms import ArticleForm

class ArticleCreateView(LoginRequiredMixin, CreateView):
    model = Article
    form_class = ArticleForm
    template_name = 'articles/article_form.html'
    success_url = '/articles/' # നിങ്ങളുടെ ഇഷ്ടമുള്ള URL ഉപയോഗിച്ച് മാറ്റുക

    def form_valid(self, form):
        form.instance.author = self.request.user
        return super().form_valid(form)

ഈ ഉദാഹരണത്തിൽ, ലോഗിൻ ചെയ്ത ഉപയോക്താക്കൾക്ക് ArticleCreateView-ലേക്ക് പ്രവേശനം നിയന്ത്രിക്കുന്നതിന് ഞങ്ങൾ LoginRequiredMixin ഉപയോഗിച്ചു. ലേഖനത്തിന്റെ രചയിതാവിനെ നിലവിലെ ഉപയോക്താവായി സ്വയമേവ സജ്ജീകരിക്കുന്നതിന് ഞങ്ങൾ form_valid രീതി മാറ്റിയെഴുതിയിട്ടുണ്ട്. സങ്കീർണ്ണമായ കസ്റ്റമൈസേഷൻ നേടുന്നതിന് മിക്സിനുകൾ എങ്ങനെ രീതിയിലുള്ള ഓവർറൈഡിംഗുമായി സംയോജിപ്പിക്കാമെന്ന് ഇത് കാണിക്കുന്നു.

ഇഷ്ടമുള്ള മിക്സിനുകൾ ഉണ്ടാക്കുന്നു

പുനരുപയോഗിക്കാവുന്ന യുക്തികൾ ഉൾക്കൊള്ളാൻ നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം മിക്സിനുകളും ഉണ്ടാക്കാം. ഉദാഹരണത്തിന്, ഒരു മോഡൽ ഇൻസ്‌റ്റൻസിന്റെ രചയിതാവായി നിലവിലെ ഉപയോക്താവിനെ സ്വയമേവ സജ്ജീകരിക്കുന്ന ഒരു മിക്സിനോ അല്ലെങ്കിൽ അനുമതി പരിശോധനകൾ കൈകാര്യം ചെയ്യുന്ന ഒരു മിക്സിനോ നിങ്ങൾക്ക് ഉണ്ടാക്കാം.

from django.contrib.auth.mixins import UserPassesTestMixin

class AuthorRequiredMixin(UserPassesTestMixin):
    def test_func(self):
        return self.request.user.is_staff or (self.request.user == self.get_object().author)

    def handle_no_permission(self):
        # നിങ്ങളുടെ ഇഷ്ടമുള്ള റീഡയറക്ഷനോ എറർ കൈകാര്യം ചെയ്യലോ ഉപയോഗിച്ച് മാറ്റുക
        return redirect('permission_denied') # അല്ലെങ്കിൽ ഒരു എക്സെപ്ഷൻ ഉയർത്തുക

ഈ AuthorRequiredMixin സ്റ്റാഫ് അംഗങ്ങൾക്കോ ഒബ്ജക്റ്റിന്റെ രചയിതാവിനോ മാത്രമേ ആക്സസ് അനുവദിക്കൂ. അംഗീകൃത ഉപയോക്താക്കൾക്ക് മാത്രമേ ഒബ്ജക്റ്റുകൾ പരിഷ്കരിക്കാനോ ഇല്ലാതാക്കാനോ കഴിയൂ എന്ന് ഉറപ്പാക്കാൻ നിങ്ങൾക്ക് ഈ മിക്സിൻ UpdateView അല്ലെങ്കിൽ DeleteView എന്നിവയുമായി ഉപയോഗിക്കാം.

4. ടെംപ്ലേറ്റ് കസ്റ്റമൈസേഷൻ

മുകളിലുള്ള സാങ്കേതിക വിദ്യകൾ കാഴ്‌ചയുടെ യുക്തി മാറ്റുന്നതിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുമ്പോൾ, ഡാറ്റയുടെ അവതരണം നിയന്ത്രിക്കുന്നതിന് ടെംപ്ലേറ്റ് കസ്റ്റമൈസേഷൻ നിർണായകമാണ്. HTML ഔട്ട്പുട്ട് റെൻഡർ ചെയ്യാൻ ജെനറിക് കാഴ്‌ചകൾ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുന്നു. നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ രൂപകൽപ്പനയ്ക്കും ബ്രാൻഡിംഗിനും അനുയോജ്യമായ രീതിയിൽ ഈ ടെംപ്ലേറ്റുകൾ ഇഷ്ടാനുസൃതമാക്കാവുന്നതാണ്.

ടെംപ്ലേറ്റ് നാമകരണ രീതികൾ

ജെനറിക് കാഴ്‌ചകൾ പ്രത്യേക ടെംപ്ലേറ്റ് നാമകരണ രീതികൾ പിന്തുടരുന്നു. ഉദാഹരണത്തിന്:

• ListView: <app_name>/<model_name>_list.html (ഉദാഹരണത്തിന്, articles/article_list.html)
• DetailView: <app_name>/<model_name>_detail.html (ഉദാഹരണത്തിന്, articles/article_detail.html)
• CreateView/UpdateView: <app_name>/<model_name>_form.html (ഉദാഹരണത്തിന്, articles/article_form.html)
• DeleteView: <app_name>/<model_name>_confirm_delete.html (ഉദാഹരണത്തിന്, articles/article_confirm_delete.html)

വ്യത്യസ്ത ടെംപ്ലേറ്റ് ഉപയോഗിക്കാൻ കാഴ്‌ച ക്ലാസ്സിൽ നിങ്ങൾക്ക് template_name ആട്രിബ്യൂട്ട് മാറ്റിയെഴുതാം. ടെംപ്ലേറ്റിനുള്ളിൽ, കോൺടെക്സ്റ്റ് ഒബ്ജക്റ്റ് വഴി കാഴ്‌ച നൽകുന്ന ഡാറ്റ നിങ്ങൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയും. സ്ഥിരസ്ഥിതി കോൺടെക്സ്റ്റ് ഒബ്ജക്റ്റ് നാമം സാധാരണയായി മോഡൽ നാമത്തിന്റെ ചെറിയക്ഷരത്തിലുള്ള പതിപ്പാണ് (ഉദാഹരണത്തിന്, Article-ന് article). context_object_name ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് മാറ്റാനാകും.

ഉദാഹരണം: ഒരു ListView ടെംപ്ലേറ്റ് ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റിയെഴുതുന്നു

articles/article_list.html ടെംപ്ലേറ്റിൽ, ലേഖനങ്ങളുടെ ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്നതിന് articles കോൺടെക്സ്റ്റ് വേരിയബിളിലൂടെ (മുകളിൽ നൽകിയിട്ടുള്ള ArticleListView ഉദാഹരണത്തിൽ നിർവചിച്ചിരിക്കുന്നത് പോലെ) നിങ്ങൾക്ക് ആവർത്തിച്ച് പ്രവർത്തിപ്പിക്കാൻ കഴിയും.

<h1>ലേഖനങ്ങൾ</h1>

<ul>
  {% for article in articles %}
    <li><a href="{% url 'article_detail' article.pk %}">{{ article.title }}</a></li>
  {% endfor %}
</ul>

5. ഫോം കസ്റ്റമൈസേഷൻ (CreateView & UpdateView)

ഉപയോക്താവിന്റെ ഇൻപുട്ട് കൈകാര്യം ചെയ്യാൻ CreateView, UpdateView എന്നിവ Django ഫോമുകളെ ആശ്രയിക്കുന്നു. ഈ ഫോമുകൾ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റുന്നതിലൂടെ, പ്രദർശിപ്പിക്കുന്ന ഫീൽഡുകൾ, അവയുടെ മൂല്യനിർണ്ണയ നിയമങ്ങൾ, അവയുടെ രൂപം എന്നിവ നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

form_class ഉപയോഗിക്കുന്നു

കാഴ്‌ച ക്ലാസ്സിലെ form_class ആട്രിബ്യൂട്ട് ഉപയോഗിച്ച് ഉപയോഗിക്കേണ്ട ഫോം ക്ലാസ് നിങ്ങൾക്ക് വ്യക്തമാക്കാൻ കഴിയും. നിങ്ങൾ ഒരു ഫോം ക്ലാസ് വ്യക്തമാക്കിയില്ലെങ്കിൽ, കാഴ്‌ചയുമായി ബന്ധപ്പെട്ട മോഡലിനെ അടിസ്ഥാനമാക്കി Django സ്വയമേവ ഒരു ModelForm ഉണ്ടാക്കും.

ഫോം രീതികൾ മാറ്റിയെഴുതുന്നു

നിങ്ങളുടെ ഫോം ക്ലാസ്സിലെ രീതികൾ മാറ്റിയെഴുതി അതിന്റെ സ്വഭാവം ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റാവുന്നതാണ്. മാറ്റിയെഴുതാനുള്ള പൊതുവായ രീതികളിൽ ഇവ ഉൾപ്പെടുന്നു:

• __init__(): ഫോം ആരംഭിക്കുകയും അതിന്റെ ഫീൽഡുകൾ പരിഷ്കരിക്കുകയും ചെയ്യുക.
• clean(): ഒന്നിലധികം ഫീൽഡുകളിൽ ഇഷ്ടമുള്ള രീതിയിലുള്ള മൂല്യനിർണ്ണയം നടത്തുക.
• clean_<field_name>(): ഒരു പ്രത്യേക ഫീൽഡിനായി ഇഷ്ടമുള്ള രീതിയിലുള്ള മൂല്യനിർണ്ണയം നടത്തുക.

ഉദാഹരണം: ഒരു ലേഖന ഫോം ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റിയെഴുതുന്നു

from django import forms
from .models import Article

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'content', 'is_published']

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.fields['content'].widget = forms.Textarea(attrs={'rows': 5})

    def clean_title(self):
        title = self.cleaned_data['title']
        if len(title) < 5:
            raise forms.ValidationError("Title must be at least 5 characters long.")
        return title

ഈ ഉദാഹരണത്തിൽ, ഫോമിൽ ഏതൊക്കെ ഫീൽഡുകൾ ഉൾപ്പെടുത്തണം എന്ന് വ്യക്തമാക്കാൻ Meta ക്ലാസ്സിൽ fields ആട്രിബ്യൂട്ട് സജ്ജീകരിച്ച് ഞങ്ങൾ ArticleForm ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റി. content ഫീൽഡിന്റെ വിഡ്ജറ്റ് ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റാൻ ഞങ്ങൾ __init__() രീതിയും title ഫീൽഡിനായി ഇഷ്ടമുള്ള രീതിയിലുള്ള മൂല്യനിർണ്ണയം ചേർക്കാൻ clean_title() രീതിയും മാറ്റിയെഴുതിയിട്ടുണ്ട്.

6. ഡൈനാമിക് ഫോം കൈകാര്യം ചെയ്യൽ

ചില സമയങ്ങളിൽ ഉപയോക്താവിനെയോ മറ്റ് ഘടകങ്ങളെയോ അടിസ്ഥാനമാക്കി ഫോം ഡൈനാമിക്കായി ക്രമീകരിക്കേണ്ടി വന്നേക്കാം. വ്യൂ ക്ലാസ്സിൽ get_form_kwargs() രീതി മാറ്റിയെഴുതി ഇത് നേടാനാകും. ഫോമിന്റെ കൺസ്ട്രക്ടറിലേക്ക് കൂടുതൽ കീവേർഡ് ആർഗ്യുമെന്റുകൾ കൈമാറാൻ ഈ രീതി നിങ്ങളെ അനുവദിക്കുന്നു.

ഉദാഹരണം: ഉപയോക്താവിനെ ഫോമിലേക്ക് കൈമാറുന്നു

from django.views.generic import CreateView
from .models import Article
from .forms import ArticleForm

class ArticleCreateView(CreateView):
    model = Article
    form_class = ArticleForm
    template_name = 'articles/article_form.html'
    success_url = '/articles/' # നിങ്ങളുടെ ഇഷ്ടമുള്ള URL ഉപയോഗിച്ച് മാറ്റുക

    def get_form_kwargs(self):
        kwargs = super().get_form_kwargs()
        kwargs['user'] = self.request.user
        return kwargs

തുടർന്ന്, നിങ്ങളുടെ ArticleForm-ൽ, __init__() രീതിയിലുള്ള user കീവേർഡ് ആർഗ്യുമെന്റ് വഴി നിങ്ങൾക്ക് ഉപയോക്താവിനെ ആക്സസ് ചെയ്യാൻ കഴിയും.

from django import forms
from .models import Article

class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'content', 'is_published']

    def __init__(self, *args, **kwargs):
        self.user = kwargs.pop('user', None)
        super().__init__(*args, **kwargs)
        if self.user and not self.user.is_staff:
            del self.fields['is_published'] # സ്റ്റാഫിന് മാത്രമേ പ്രസിദ്ധീകരിക്കാൻ കഴിയൂ

ഈ ഉദാഹരണത്തിൽ, ഞങ്ങൾ നിലവിലെ ഉപയോക്താവിനെ ഫോമിലേക്ക് കൈമാറുകയും ഉപയോക്താവ് ഒരു സ്റ്റാഫ് അംഗമല്ലെങ്കിൽ is_published ഫീൽഡ് ഡൈനാമിക്കായി നീക്കം ചെയ്യുകയും ചെയ്യുന്നു. ഉപയോക്താവിന്റെ അനുമതികളെ അടിസ്ഥാനമാക്കി നിങ്ങൾക്ക് എങ്ങനെ ഫോം ഡൈനാമിക്കായി ക്രമീകരിക്കാമെന്ന് ഇത് കാണിക്കുന്നു.

വിപുലമായ കസ്റ്റമൈസേഷൻ: വ്യൂസെറ്റുകൾ ഉപയോഗിക്കുന്നു

കൂടുതൽ സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകൾക്കായി, പ്രത്യേകിച്ച് API-കളിൽ ഉൾപ്പെടുന്നവയിൽ, Django REST ഫ്രെയിംവർക്കിന്റെ (DRF) വ്യൂസെറ്റുകൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക. വ്യൂസെറ്റുകൾ അനുബന്ധ കാഴ്‌ചകളെ (ഉദാഹരണത്തിന്, ലിസ്റ്റ്, ഉണ്ടാക്കുക, വീണ്ടെടുക്കുക, അപ്‌ഡേറ്റ് ചെയ്യുക, ഇല്ലാതാക്കുക) ഒരു ക്ലാസ്സായി സംയോജിപ്പിക്കുന്നു, ഇത് API എൻഡ്‌പോയിന്റുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള വൃത്തിയുള്ളതും കൂടുതൽ ചിട്ടയായതുമായ മാർഗ്ഗം നൽകുന്നു.

ഉദാഹരണം: ഒരു ArticleViewSet ഉണ്ടാക്കുന്നു

from rest_framework import viewsets
from .models import Article
from .serializers import ArticleSerializer

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

ഈ ലളിതമായ ArticleViewSet ലേഖനങ്ങൾക്കായി എല്ലാ സാധാരണ CRUD (Create, Read, Update, Delete) പ്രവർത്തനങ്ങളും നൽകുന്നു. get_queryset(), perform_create(), perform_update() തുടങ്ങിയ രീതികൾ മാറ്റിയെഴുതുന്നത് പോലെ ജെനറിക് കാഴ്‌ചകൾക്ക് സമാനമായ സാങ്കേതിക വിദ്യകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് വ്യൂസെറ്റുകൾ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റിയെഴുതാം.

ജെനറിക് വ്യൂ കസ്റ്റമൈസേഷനായുള്ള ആഗോള പരിഗണനകൾ

ഒരു ആഗോള പ്രേക്ഷകർക്കായി ജെനറിക് കാഴ്‌ചകൾ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റുമ്പോൾ, ഇനിപ്പറയുന്ന കാര്യങ്ങൾ ഓർമ്മിക്കുക:

• പ്രാദേശികവൽക്കരണവും അന്തർദ്ദേശീയവൽക്കരണവും (L10n/I18n): നിങ്ങളുടെ ടെംപ്ലേറ്റുകളും ഫോമുകളും ഒന്നിലധികം ഭാഷകളെയും പ്രാദേശിക ഫോർമാറ്റുകളെയും പിന്തുണയ്ക്കുന്നുവെന്ന് ഉറപ്പാക്കുക. Django-യുടെ അന്തർനിർമ്മിത i18n/l10n ഫീച്ചറുകൾ ഉപയോഗിക്കുക.
• സമയ മേഖലകൾ: ഉപയോക്താവിന്റെ പ്രാദേശിക സമയം കാണിക്കുന്നതിന് സമയ മേഖല മാറ്റങ്ങൾ ശരിയായി കൈകാര്യം ചെയ്യുക. Django-യുടെ timezone മൊഡ്യൂൾ ഉപയോഗിക്കുക.
• കറൻസി ഫോർമാറ്റിംഗ്: വ്യത്യസ്ത പ്രദേശങ്ങൾക്ക് അനുയോജ്യമായ രീതിയിൽ കറൻസി മൂല്യങ്ങൾ ഫോർമാറ്റ് ചെയ്യുക. കറൻസി ഫോർമാറ്റിംഗിനായി babel പോലുള്ള ലൈബ്രറി ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.
• തീയതിയും സംഖ്യാ ഫോർമാറ്റിംഗും: ഉപയോക്താവിന്റെ ലൊക്കേലിനെ അടിസ്ഥാനമാക്കി ഉചിതമായ തീയതിയും സംഖ്യാ ഫോർമാറ്റുകളും ഉപയോഗിക്കുക.
• പ്രവേശനക്ഷമത: നിങ്ങളുടെ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റിയെഴുതിയ കാഴ്‌ചകളും ടെംപ്ലേറ്റുകളും വൈകല്യമുള്ള ഉപയോക്താക്കൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുക. WCAG പോലുള്ള പ്രവേശനക്ഷമതാ മാർഗ്ഗനിർദ്ദേശങ്ങൾ പാലിക്കുക.
• റെസ്‌പോൺസീവ് ഡിസൈൻ: നിങ്ങളുടെ ടെംപ്ലേറ്റുകൾ റെസ്‌പോൺസീവ് ആണെന്നും ലോകമെമ്പാടുമുള്ള ഉപയോക്താക്കൾ ഉപയോഗിക്കുന്ന വിവിധ സ്ക്രീൻ വലുപ്പങ്ങളുമായി പൊരുത്തപ്പെടുന്നുണ്ടെന്നും ഉറപ്പാക്കുക.
• സാംസ്കാരിക സംവേദനക്ഷമത: നിങ്ങളുടെ കാഴ്‌ചകളും ടെംപ്ലേറ്റുകളും രൂപകൽപ്പന ചെയ്യുമ്പോൾ സാംസ്കാരികപരമായ വ്യത്യാസങ്ങൾ ശ്രദ്ധിക്കുക. ചില സംസ്കാരങ്ങൾക്ക് непприятие തോന്നുന്ന ചിത്രങ്ങളോ ഭാഷയോ ഉപയോഗിക്കുന്നത് ഒഴിവാക്കുക. ഉദാഹരണത്തിന്, വർണ്ണ ബന്ധങ്ങൾക്കും ചിഹ്നങ്ങൾക്കും സംസ്കാരങ്ങളിൽ വളരെ വ്യത്യസ്തമായ അർത്ഥങ്ങളുണ്ടാകാം.

ഉദാഹരണം: സമയ മേഖലകൾ കൈകാര്യം ചെയ്യുന്നു

ഉപയോക്താവിന്റെ പ്രാദേശിക സമയ മേഖലയിൽ ഒരു പ്രസിദ്ധീകരണ തീയതി പ്രദർശിപ്പിക്കുന്നതിന്, നിങ്ങളുടെ ടെംപ്ലേറ്റിൽ timezone ടാഗ് ഉപയോഗിക്കാം:

{% load tz %}

<p>പ്രസിദ്ധീകരിച്ചത്: {% timezone article.publication_date %}</p>

നിങ്ങളുടെ Django ക്രമീകരണ ഫയലിൽ USE_TZ = True എന്ന് ഉറപ്പാക്കുക.

ജെനറിക് വ്യൂ കസ്റ്റമൈസേഷനായുള്ള മികച്ച രീതികൾ

നിങ്ങളുടെ കസ്റ്റമൈസേഷനുകൾ പരിപാലിക്കാനും കാര്യക്ഷമമാക്കാനും ഈ മികച്ച രീതികൾ പിന്തുടരുക:

• ലളിതമായി സൂക്ഷിക്കുക: നിങ്ങളുടെ കസ്റ്റമൈസേഷനുകൾ കൂടുതൽ സങ്കീർണ്ണമാക്കുന്നത് ഒഴിവാക്കുക. ആവശ്യമുള്ള ഫലം നേടുന്ന ഏറ്റവും ലളിതമായ സാങ്കേതികത ഉപയോഗിക്കുക.
• നിങ്ങളുടെ കോഡ് രേഖപ്പെടുത്തുക: നിങ്ങളുടെ കസ്റ്റമൈസേഷനുകളും അവ ആവശ്യമായി വന്നതിന്റെ കാരണവും വിശദീകരിക്കാൻ കമന്റുകൾ ചേർക്കുക.
• ശരിയായി പരീക്ഷിക്കുക: നിങ്ങളുടെ കസ്റ്റമൈസേഷനുകൾ ശരിയായി പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതുക.
• മിക്സിനുകൾ വിവേകത്തോടെ ഉപയോഗിക്കുക: പൊതുവായ പ്രവർത്തനങ്ങൾ ഉൾക്കൊള്ളാൻ പുനരുപയോഗിക്കാവുന്ന മിക്സിനുകൾ ഉണ്ടാക്കുക.
• Django-യുടെ കൺവെൻഷനുകൾ പിന്തുടരുക: Django-യുടെ കോഡിംഗ് ശൈലിയും നാമകരണ രീതികളും പാലിക്കുക.
• സുരക്ഷ പരിഗണിക്കുക: കാഴ്‌ചകൾ ഇഷ്ടമുള്ള രീതിയിൽ മാറ്റുമ്പോൾ ഉണ്ടാകാവുന്ന സുരക്ഷാ അപകടങ്ങളെക്കുറിച്ച് ബോധവാന്മാരായിരിക്കുക. ഉപയോക്താവിന്റെ ഇൻപുട്ട് ശുദ്ധീകരിക്കുക, ക്രോസ്-സൈറ്റ് സ്ക്രിപ്റ്റിംഗ് (XSS), SQL ഇൻജക്ഷൻ പോലുള്ള സാധാരണ ആക്രമണങ്ങളിൽ നിന്ന് സംരക്ഷിക്കുക.

ഉപസംഹാരം

വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കുന്നതിനുള്ള ശക്തവും ഫ്ലെക്സിബിളുമായ മാർഗ്ഗം Django-യുടെ ക്ലാസ് അടിസ്ഥാനത്തിലുള്ള ജെനറിക് കാഴ്‌ചകൾ നൽകുന്നു. ഈ ഗൈഡിൽ വിവരിച്ചിട്ടുള്ള കസ്റ്റമൈസേഷൻ സാങ്കേതിക വിദ്യകളിൽ പ്രാവീണ്യം നേടുന്നതിലൂടെ, കാര്യക്ഷമവും, പരിപാലിക്കാൻ എളുപ്പമുള്ളതും, ആഗോളതലത്തിൽ ആക്സസ് ചെയ്യാവുന്നതുമായ വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ നിങ്ങൾക്ക് ജെനറിക് കാഴ്‌ചകൾ നിങ്ങളുടെ പ്രത്യേക ആവശ്യങ്ങൾക്കനുസരിച്ച് മാറ്റാനാകും. ലളിതമായ ആട്രിബ്യൂട്ട് ഓവർറൈഡുകൾ മുതൽ സങ്കീർണ്ണമായ രീതിയിലുള്ള ഓവർറൈഡിംഗും മിക്സിൻ ഉപയോഗവും വരെ സാധ്യതകൾ വളരെ വലുതാണ്. നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ വൈവിധ്യമാർന്ന അന്താരാഷ്ട്ര പ്രേക്ഷകരെ തൃപ്തിപ്പെടുത്തുന്നുവെന്ന് ഉറപ്പാക്കാൻ ആഗോള വീക്ഷണങ്ങളും മികച്ച രീതികളും ഓർമ്മിക്കുക.