Džango uz klases balstītie skati: Ģenerisko skatu pielāgošanas apgūšana

Džango uz klases balstītie skati (CBV) nodrošina spēcīgu un atkārtoti lietojamu veidu tīmekļa lietojumprogrammu izstrādei. Ģeneriskie skati, kas ir CBV apakškopa, piedāvā iepriekš izstrādātus risinājumus parastiem uzdevumiem, piemēram, sarakstu attēlošanai, detalizētiem skatiem, objektu izveidei, atjaunināšanai un dzēšanai. Lai gan šie ģeneriskie skati ir neticami ērti, tie bieži vien prasa pielāgošanu, lai perfekti atbilstu jūsu lietojumprogrammas īpašajām vajadzībām. Šis visaptverošais ceļvedis pēta dažādas metodes Džango ģenerisko skatu pielāgošanai, dodot jums iespēju izstrādāt efektīvas un uzturamas tīmekļa lietojumprogrammas.

Džango uz klases balstīto skatu izpratne

Pirms iedziļināties pielāgošanā, atkārtosim CBV un ģenerisko skatu pamatus. Tradicionālie uz funkcijām balstītie skati (FBV) apstrādā HTTP pieprasījumus tieši vienā funkcijā. Savukārt CBV organizē skata loģiku klasēs, nodrošinot strukturētāku un uz objektu orientētu pieeju. Tas nodrošina labāku koda organizēšanu, atkārtotu izmantošanu un testējamību.

Ģeneriskie skati ir iepriekš izstrādāti CBV, kas paredzēti parasto tīmekļa izstrādes uzdevumu apstrādei. Tie manto no pamatklasēm, piemēram, View un TemplateView, un piedāvā specializētas funkcionalitātes. Parastie ģeneriskie skati ir:

• ListView: parāda objektu sarakstu.
• DetailView: parāda viena objekta detaļas.
• CreateView: apstrādā objekta izveidi, izmantojot formu.
• UpdateView: apstrādā objekta atjaunināšanu, izmantojot formu.
• DeleteView: apstrādā objekta dzēšanu.

Šie ģeneriskie skati nodrošina stabilu pamatu, taču reālās lietojumprogrammas bieži vien prasa to darbības pielāgošanu. Apskatīsim dažādas pielāgošanas metodes.

Pielāgošanas metodes

Ir vairāki veidi, kā pielāgot Džango ģeneriskos skatus, sākot no vienkāršiem atribūtu aizstāšanas līdz sarežģītākai metožu aizstāšanai. Atbilstošā metode ir atkarīga no nepieciešamā pielāgošanas līmeņa.

1. Atribūtu aizstāšana

Vienkāršākā pielāgošanas forma ietver ģeneriskā skata klases atribūtu aizstāšanu. Tas ir ideāli piemērots tādu pamata īpašību kā modelis, veidnes nosaukums vai konteksta objekta nosaukums modificēšanai.

Piemērs: ListView pielāgošana

Pieņemsim, ka vēlaties parādīt rakstu sarakstu, bet vēlaties izmantot pielāgotu veidni un citu konteksta objekta nosaukumu.

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')

Šajā piemērā mēs esam aizstājuši atribūtus model, template_name un context_object_name. Mēs arī esam aizstājuši metodi get_queryset, lai filtrētu rakstus un sakārtotu tos pēc publicēšanas datuma. Metode get_queryset nodrošina kontroli pār to, kuri objekti ir iekļauti saraksta skatā. Tas ir noderīgi filtrēšanas, kārtošanas un lappušu numerācijas ieviešanai.

2. Metožu aizstāšana

Metodes aizstāšana ļauj modificēt esošo metožu darbību ģeneriskā skata klasē. Tas nodrošina lielāku kontroli pār skata loģiku. Parastās metodes, kuras aizstāt, ir:

• get_queryset(): kontrolē skata izmantoto vaicājumu kopu.
• get_context_data(): pievieno datus veidnes kontekstam.
• form_valid(): apstrādā veiksmīgu formas iesniegšanu.
• form_invalid(): apstrādā nederīgu formas iesniegšanu.
• get_success_url(): nosaka URL, uz kuru pāradresēt pēc veiksmīgas formas iesniegšanas.
• get_object(): izgūst objektu skatiem DetailView, UpdateView un DeleteView

Piemērs: DetailView pielāgošana

Pieņemsim, ka vēlaties parādīt raksta detaļas, bet vēlaties arī iekļaut saistītos komentārus veidnes kontekstā.

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

Šeit mēs esam aizstājuši metodi get_context_data(), lai veidnes kontekstam pievienotu mainīgo comments. Tas ļauj viegli piekļūt saistītajiem komentāriem un tos parādīt veidnē article_detail.html.

3. Miksu izmantošana

Miksi ir atkārtoti lietojamas klases, kas nodrošina noteiktu funkcionalitāti. Tos var kombinēt ar ģeneriskajiem skatiem, lai pievienotu funkcijas, nemainot skata galveno loģiku. Džango nodrošina vairākus iebūvētus miksus, un jūs varat arī izveidot savus.

Piemērs: LoginRequiredMixin izmantošana

LoginRequiredMixin nodrošina, ka tikai pieteikušies lietotāji var piekļūt konkrētam skatam.

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/' # Replace with your desired success URL

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

Šajā piemērā mēs esam izmantojuši LoginRequiredMixin, lai ierobežotu piekļuvi ArticleCreateView tikai pieteikušajiem lietotājiem. Mēs arī esam aizstājuši metodi form_valid, lai automātiski iestatītu raksta autoru kā pašreizējo lietotāju. Tas demonstrē, kā miksus var kombinēt ar metožu aizstāšanu, lai panāktu sarežģītu pielāgošanu.

Pielāgotu miksu izveide

Jūs varat arī izveidot savus miksus, lai enkapsulētu atkārtoti lietojamu loģiku. Piemēram, jūs varētu izveidot miksu, kas automātiski iestata pašreizējo lietotāju kā modeļa instances autoru vai miksu, kas apstrādā atļauju pārbaudes.

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):
        # Replace with your desired redirection or error handling
        return redirect('permission_denied') # Or raise an exception

Šis AuthorRequiredMixin atļauj piekļuvi tikai darbiniekiem vai objekta autoram. Jūs varat izmantot šo miksu ar UpdateView vai DeleteView, lai nodrošinātu, ka tikai autorizēti lietotāji var modificēt vai dzēst objektus.

4. Veidnes pielāgošana

Lai gan iepriekš minētās metodes koncentrējas uz skata loģikas modificēšanu, veidnes pielāgošana ir ļoti svarīga datu attēlošanas kontrolei. Ģeneriskie skati izmanto veidnes, lai atveidotu HTML izvadi. Jūs varat pielāgot šīs veidnes, lai tās atbilstu jūsu lietojumprogrammas dizainam un zīmolam.

Veidņu nosaukumu konvencijas

Ģeneriskie skati ievēro konkrētas veidņu nosaukumu konvencijas. Piemēram:

• ListView: <app_name>/<model_name>_list.html (piem., articles/article_list.html)
• DetailView: <app_name>/<model_name>_detail.html (piem., articles/article_detail.html)
• CreateView/UpdateView: <app_name>/<model_name>_form.html (piem., articles/article_form.html)
• DeleteView: <app_name>/<model_name>_confirm_delete.html (piem., articles/article_confirm_delete.html)

Jūs varat aizstāt atribūtu template_name skata klasē, lai izmantotu citu veidni. Veidnē jūs varat piekļūt skata nodrošinātajiem datiem, izmantojot konteksta objektu. Noklusējuma konteksta objekta nosaukums parasti ir modeļa nosaukuma mazais burts (piem., article priekš Article). Jūs to varat mainīt, izmantojot atribūtu context_object_name.

Piemērs: ListView veidnes pielāgošana

Veidnē articles/article_list.html jūs varat iterēt pār konteksta mainīgo articles (kā definēts iepriekšējā piemērā ArticleListView), lai parādītu rakstu sarakstu.

<h1>Raksti</h1>

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

5. Formas pielāgošana (CreateView & UpdateView)

CreateView un UpdateView paļaujas uz Džango formām, lai apstrādātu lietotāja ievadi. Šo formu pielāgošana ļauj kontrolēt parādītos laukus, to validācijas noteikumus un to izskatu.

form_class izmantošana

Jūs varat norādīt formas klasi, ko izmantot ar atribūtu form_class skata klasē. Ja nenorādāt formas klasi, Džango automātiski ģenerēs ModelForm, pamatojoties uz modeli, kas saistīts ar skatu.

Formas metožu aizstāšana

Jūs varat aizstāt metodes savā formas klasē, lai pielāgotu tās darbību. Parastās metodes, kuras aizstāt, ir:

• __init__(): inicializē formu un modificē tās laukus.
• clean(): veic pielāgotu validāciju pāri vairākiem laukiem.
• clean_<field_name>(): veic pielāgotu validāciju konkrētam laukam.

Piemērs: Raksta formas pielāgošana

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("Virsrakstam jābūt vismaz 5 simboliem.")
        return title

Šajā piemērā mēs esam pielāgojuši ArticleForm, iestatot atribūtu fields klasē Meta, lai norādītu, kuri lauki jāiekļauj formā. Mēs arī esam aizstājuši metodi __init__(), lai pielāgotu lauka content logrīku un metodi clean_title(), lai pievienotu pielāgotu validāciju laukam title.

6. Dinamiska formas apstrāde

Dažreiz jums ir dinamiski jāpielāgo forma, pamatojoties uz lietotāju vai citiem faktoriem. Jūs to varat panākt, aizstājot metodi get_form_kwargs() skata klasē. Šī metode ļauj nodot papildu atslēgvārdu argumentus formas konstruktoram.

Piemērs: Lietotāja pārsūtīšana uz formu

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/' # Replace with your desired success URL

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

Pēc tam savā ArticleForm jūs varat piekļūt lietotājam, izmantojot atslēgvārda argumentu user metodē __init__().

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'] # Only staff can publish

Šajā piemērā mēs pārsūtam pašreizējo lietotāju uz formu un dinamiski noņemam lauku is_published, ja lietotājs nav darbinieks. Tas demonstrē, kā jūs varat dinamiski pielāgot formu, pamatojoties uz lietotāja atļaujām.

Papildu pielāgošana: Skatu komplektu izmantošana

Sarežģītākām lietojumprogrammām, īpaši tām, kas ietver API, apsveriet iespēju izmantot Django REST Framework (DRF) skatu komplektus. Skatu komplekti apvieno saistītos skatus (piemēram, saraksts, izveide, izgūšana, atjaunināšana, dzēšana) vienā klasē, nodrošinot tīrāku un organizētāku veidu API galapunktu pārvaldībai.

Piemērs: Raksta ViewSet izveide

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

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

Šis vienkāršais ArticleViewSet nodrošina visas standarta CRUD (izveide, lasīšana, atjaunināšana, dzēšana) darbības rakstiem. Jūs varat pielāgot ViewSets, izmantojot līdzīgas metodes kā ģeneriskie skati, piemēram, aizstājot metodes, piemēram, get_queryset(), perform_create() un perform_update().

Vispārīgi apsvērumi ģenerisko skatu pielāgošanai

Pielāgojot ģeneriskos skatus globālai auditorijai, paturiet prātā šādus apsvērumus:

• Lokalizācija un internacionalizācija (L10n/I18n): Pārliecinieties, ka jūsu veidnes un formas atbalsta vairākas valodas un reģionālos formātus. Izmantojiet Džango iebūvētās i18n/l10n funkcijas.
• Laika joslas: Pareizi apstrādājiet laika joslu konvertēšanu, lai datumi un laiki tiktu parādīti lietotāja vietējā laikā. Izmantojiet Džango moduli timezone.
• Valūtas formatēšana: Formatējiet valūtas vērtības atbilstoši dažādiem reģioniem. Apsveriet iespēju izmantot bibliotēku, piemēram, babel, valūtas formatēšanai.
• Datumu un numuru formatēšana: Izmantojiet atbilstošus datumu un numuru formātus, pamatojoties uz lietotāja lokalizāciju.
• Pieejamība: Pārliecinieties, ka jūsu pielāgotie skati un veidnes ir pieejamas lietotājiem ar invaliditāti. Ievērojiet pieejamības vadlīnijas, piemēram, WCAG.
• Responsīvs dizains: Pārliecinieties, ka jūsu veidnes ir responsīvas un pielāgojas dažādiem ekrāna izmēriem un ierīcēm, ko izmanto lietotāji visā pasaulē.
• Kultūras jutīgums: Esiet uzmanīgi pret kultūras atšķirībām, veidojot savus skatus un veidnes. Izvairieties no attēlu vai valodas izmantošanas, kas varētu būt aizskaroša noteiktām kultūrām. Piemēram, krāsu asociācijām un simboliem var būt ļoti atšķirīgas nozīmes dažādās kultūrās.

Piemērs: Laika joslu apstrāde

Lai parādītu publicēšanas datumu lietotāja vietējā laika joslā, veidnē varat izmantot tagu timezone:

{% load tz %}

<p>Publicēts: {% timezone article.publication_date %}</p>

Pārliecinieties, ka jūsu Džango iestatījumu failā ir USE_TZ = True.

Labākā prakse ģenerisko skatu pielāgošanai

Ievērojiet šo labāko praksi, lai nodrošinātu, ka jūsu pielāgojumi ir uzturami un efektīvi:

• Saglabājiet vienkāršu: Izvairieties no pārmērīgas pielāgojumu sarežģīšanas. Izmantojiet vienkāršāko metodi, kas sasniedz vēlamo rezultātu.
• Dokumentējiet savu kodu: Pievienojiet komentārus, lai izskaidrotu savus pielāgojumus un to nepieciešamību.
• Rūpīgi testējiet: Rakstiet vienību testus, lai pārliecinātos, ka jūsu pielāgojumi darbojas pareizi.
• Gudri izmantojiet miksus: Izveidojiet atkārtoti lietojamus miksus, lai enkapsulētu parasto funkcionalitāti.
• Ievērojiet Džango konvencijas: Ievērojiet Džango kodēšanas stilu un nosaukumu konvencijas.
• Apsveriet drošību: Esiet informēti par iespējamām drošības ievainojamībām, pielāgojot skatus. Sanitarizējiet lietotāja ievadi un aizsargājiet pret parastiem uzbrukumiem, piemēram, Cross-Site Scripting (XSS) un SQL Injection.

Secinājums

Džango uz klases balstītie ģeneriskie skati nodrošina spēcīgu un elastīgu veidu tīmekļa lietojumprogrammu izstrādei. Apgūstot pielāgošanas metodes, kas aprakstītas šajā ceļvedī, jūs varat pielāgot ģeneriskos skatus savām īpašajām vajadzībām, izveidojot efektīvas, uzturamas un globāli pieejamas tīmekļa lietojumprogrammas. No vienkāršas atribūtu aizstāšanas līdz sarežģītai metožu aizstāšanai un miksu izmantošanai iespējas ir plašas. Atcerieties ņemt vērā globālos aspektus un labāko praksi, lai nodrošinātu, ka jūsu lietojumprogrammas apmierina daudzveidīgu starptautisko auditoriju.