Soláthraíonn tuairimí rang-bhunaithe ionsuite Django go leor feidhmiúlachta, ach b'fhéidir gur mhaith leat cuid de a úsáid ar leithligh. Mar shampla, b'fhéidir gur mhaith leat dearcadh a scríobh a léiríonn teimpléad chun an freagra HTTP a dhéanamh, ach ní féidir leat:class: ~django.views.generic.base.templateView a úsáid; b'fhéidir nach gcaithfidh tú teimpléad a rinneadh ach ar POST `, le GET` ag déanamh rud éigin eile go hiomlán. Cé go bhféadfá: class: ~django.template.response.templateResponse a úsáid go díreach, is dócha go mbeidh cód dúblach mar thoradh air seo.
\nAr an gcúis seo, soláthraíonn Django roinnt meascáin freisin a sholáthraíonn feidhmiúlacht níos scoite. Tá rindreáil teimpléad, mar shampla, ionfhabhtaithe in:class: ~Django.Views.Generic.Base.TemplateResponseMixin. Tá doiciméadú tagartha Django: doc: `doiciméadú iomlán de na meascáin go lé@@</ref/class-based-views/mixins> ir'.
\nCuirtear dhá mheascán lárnach ar fáil a chuidíonn le comhéadan comhsheasmhach a sholáthar chun oibriú le teimpléid i dtuairimí rangbhunaithe.
\nTemplateResponseMixinEvery built in view which returns a\nTemplateResponse will call the\nrender_to_response()\nmethod that TemplateResponseMixin provides. Most of the time this\nwill be called for you (for instance, it is called by the get() method\nimplemented by both TemplateView and\nDetailView); similarly, it's unlikely\nthat you'll need to override it, although if you want your response to\nreturn something not rendered via a Django template then you'll want to do\nit. For an example of this, see the JSONResponseMixin example.
Glaonn ``render_to_response () ``féin: meth: ~django.views.generic.base.templateResponseMixin.get_template_names, a fhéachfaidh suas:attr: ~Django.Views.Generic.Base.TemplateResponseMixin.Template_Names ar an radharc rang-bhunaithe; dhá mixins eile (:class: ~Django.Views.Generic.Detail.SingleObjectTemplateResponseMixin agus:class: ~Django.Views.Generic.List.MultipleObjectTemplateResponseMixin) athsháraigh é seo chun réamhshocruithe níos solúbtha a sholáthar agus tú ag déileáil le rudaí iarbhír.
\nContextMixinEvery built in view which needs context data, such as for rendering a\ntemplate (including TemplateResponseMixin above), should call\nget_context_data() passing\nany data they want to ensure is in there as keyword arguments.\nget_context_data() returns a dictionary; in ContextMixin it\nreturns its keyword arguments, but it is common to override this to add\nmore members to the dictionary. You can also use the\nextra_context attribute.
Féachaimis ar an gcaoi a ndéantar dhá cheann de thuairimí cineálacha aicmbunaithe Django a thógtar as meascáin a sholáthraíonn feidhmiúlacht scoite. Déanfaimid breithniú:class: ~django.views.generic.detail.detailView, a thugann dearcadh “mionsonraithe” ar réad, agus:class: ~django.views.generic.list.listView, a thabharfaidh liosta rudaí, de ghnáth ó shuíomh ceisteanna, agus iad a leathanaigh roghnach. Tabharfaidh sé seo ceithre mheascáin in aithne dúinn a sholáthraíonn feidhmiúlacht úsáideach eatarthu agus iad ag obair le réad Django amháin, nó le rudaí iolracha.
\nTá meascáin ann freisin leis na tuairimí eagarthóireachta cineálacha (:class: ~django.views.generic.edit.formView, agus na radhairc samhail-shonrach: class: ~django.views.generic.edit.createView, :class: ~django.views.generic.edit.updateView agus:class: ~django.views.generic.Edit.deleteView), agus sna tuairimí cineálacha dáta-bhunaithe. Tá siad seo clúdaithe sa doiciméadú tagartha: 'mixin tagartha'</ref/class-based-views/mixins>.
\nChun mionsonraí réada a thaispeáint, ní mór dúinn dhá rud a dhéanamh go bunúsach: ní mór dúinn breathnú suas ar an réad agus ansin caithfimid a:class: ~django.template.Response.TemplateResponse le teimpléad oiriúnach, agus an réad sin mar chomhthéacs.
\nTo get the object, DetailView\nrelies on SingleObjectMixin,\nwhich provides a\nget_object()\nmethod that figures out the object based on the URL of the request (it\nlooks for pk and slug keyword arguments as declared in the\nURLConf, and looks the object up either from the\nmodel attribute\non the view, or the\nqueryset\nattribute if that's provided). SingleObjectMixin also overrides\nget_context_data(),\nwhich is used across all Django's built in class-based views to supply\ncontext data for template renders.
To then make a TemplateResponse,\nDetailView uses\nSingleObjectTemplateResponseMixin, which\nextends TemplateResponseMixin, overriding\nget_template_names() as\ndiscussed above. It actually provides a fairly sophisticated set of options,\nbut the main one that most people are going to use is\n<app_label>/<model_name>_detail.html. The _detail part can be changed\nby setting\ntemplate_name_suffix\non a subclass to something else. (For instance, the generic edit views use _form for create and\nupdate views, and _confirm_delete for delete views.)
ListView: ag obair le go leor rudaí DjangoLink to this heading#Leanann liostaí rudaí thart ar an bpatrún céanna: teastaíonn liosta rudaí (leathanaithe b'fhéidir) uainn, de ghnáth a:class: ~django.db.models.query.querySet, agus ansin ní mór dúinn a dhéanamh a:class: ~django.template.response.templateResponse le teimpléad oiriúnach ag baint úsáide as an liosta rudaí sin.
\nChun na rudaí a fháil, úsáideann :class: ~Django.Views.Generic.List.ListView: Class: ~Django.Views.Generic.List.MultipleObjectMixin, a sholáthraíonn an bheath:meth: ~Django.Views.Generic.List.MultipleObjectMixin.get_QuerySet agus:meth: ~django..S.Generic.List.MultipleObjectMixin.Paginate_QuerySet. Murab ionann agus la:class: ~django.views.generic.detail.singleObjectMixin, ní gá codanna den URL a chur amach chun an tacar ceisteanna a oibriú leis, mar sin úsáideann an réamhshocraithe:attr: ~Django.Views.Generic.List.MultipleObjectMixin.QuerySet nó:attr: ~Django.Views.Generic.List.MultipleObjectMixin.QuerySet nó:attr: ~Django.Views.Generic.Generic.List.MultipleObjectMixin.QuerySet nó: attr: ~django.views.Generic.Generic.List.MultipleObjectMixin.Tréith IC.List.MultipleObjectMixin.Model ar an rang amharc. Cúis choitianta chun athrú: meth: ~django.views.generic.list.multipleObjectMixin.get_querySet anseo ná na rudaí a athrú go dinimiciúil, mar shampla ag brath ar an úsáideoir reatha nó poist a eisiamh sa todhchaí do bhlag.
\nMultipleObjectMixin also overrides\nget_context_data() to\ninclude appropriate context variables for pagination (providing\ndummies if pagination is disabled). It relies on object_list being\npassed in as a keyword argument, which ListView arranges for\nit.
<django.views.generic.list.MultipleObjectTemplateResponseMixin><app_label><model_name>Chun a dhéanamh a:class: ~django.template.Response.TemplateResponse, :class: ListView ansin úsáideas:class: ~django.views.generic.list.multipleObjectTemplateResponseMiXin; mar le:class: ~django.views.generic.detail.singleObjectTemplateResponseMixin thuas, Sáraíonn sé seo get_template_names () ``chun: meth: `raon roghanna `a sholáthar, agus is é an ceann is coitianta a úsáidtear ná/_list.html``, agus an chuid _list á ghlacadh arís ó:attr: ~django.views.generic.list. MultipleObjectTemplateResponseMixin.Template_Name_Suffix tréith. (Úsáideann na tuairimí cineálacha dáta-bhunaithe iarmhairtí mar _archive, _archive_year` agus mar sin de chun teimpléid éagsúla a úsáid do na tuairimí speisialaithe liosta dáta-bhunaithe.)
Anois chonaic muid conas a úsáideann tuairimí cineálacha aicmbunaithe Django na meascáin a chuirtear ar fáil, féachaimis ar bhealaí eile is féidir linn iad a chur le chéile. Táimid fós ag cur le chéile iad le tuairimí rang-bhunaithe ionsuite, nó tuairimí cineálacha eile bunaithe ar rang, ach tá raon fadhbanna níos annamh ann is féidir leat a réiteach ná mar a sholáthraíonn Django as an mbosca.
\n\nSingleObjectMixin le ViewLink to this heading#Más mian linn dearcadh rang-bhunaithe a scríobh nach bhfreagraíonn ach do POST `, déanfaimid fo-class:class: ~django.views.generic.base.view agus scríobhfaimid modh post () sa fho-rang. Mar sin féin más mian linn go n-oibreoidh ár bpróiseáil ar réad áirithe, a aithnítear ón URL, beidh muid ag iarraidh an fheidhmiúlacht a sholáthraí:class: ~django.views.generic.detail.singleObjectMixin.
We'll demonstrate this with the Author model we used in the generic\nclass-based views introduction.
views.pyfrom django.http import HttpResponseForbidden, HttpResponseRedirect\nfrom django.urls import reverse\nfrom django.views import View\nfrom django.views.generic.detail import SingleObjectMixin\nfrom books.models import Author\n\n\nclass RecordInterestView(SingleObjectMixin, View):\n """Records the current user's interest in an author."""\n\n model = Author\n\n def post(self, request, *args, **kwargs):\n if not request.user.is_authenticated:\n return HttpResponseForbidden()\n\n # Look up the author we're interested in.\n self.object = self.get_object()\n # Actually record interest somehow here!\n\n return HttpResponseRedirect(\n reverse("author-detail", kwargs={"pk": self.object.pk})\n )\nGo praiticiúil is dócha gur mhaith leat an spéis i siopa luach eochair a thaifeadadh seachas i mbunachar sonraí coibhneasta, mar sin tá an beagán sin fágtha againn amach. Is é an t-aon chuid den dearcadh a chaithfidh a bheith buartha fao:class: ~django.views.generic.detail.singleObjectMixin an áit ar mhaith linn breathnú suas ar an údar atá suim againn ann, rud a dhéanann sé le glao ar ``self.get_object () ``. Tugann an mixin aire dúinn gach rud eile.
\nIs féidir linn é seo a cheangal isteach inár URLanna go héasca go leor:
\nurls.pyfrom django.urls import path\nfrom books.views import RecordInterestView\n\nurlpatterns = [\n # ...\n path(\n "author/<int:pk>/interest/",\n RecordInterestView.as_view(),\n name="author-interest",\n ),\n]\nTabhair faoi deara an grúpa ainmnithe pk`, a úsáideann: meth: ~django.views.generic.detail.singleObjectMixin.get_Object chun an sampla ``Author ``a fheiceáil suas. D'fhéadfá slag a úsáid freisin, nó aon cheann de na gnéithe eile de:class: ~Django.Views.Generic.Detail.SingleObjectMixin.
\nSingleObjectMixin le ``ListView ``Link to this heading#ListView provides built-in\npagination, but you might want to paginate a list of objects that are\nall linked (by a foreign key) to another object. In our publishing\nexample, you might want to paginate through all the books by a\nparticular publisher.
Bealach amháin chun é seo a dhéanamh ná: class: ListView a chomhcheangal la:class: ~django.views.generic.detail.singleObjectMixin, ionas gur féidir leis an tacar ceisteanna don liosta leathanaigh leabhar crochadh as an foilsitheoir a aimsítear mar an réad aonair. D'fhonn é seo a dhéanamh, ní mór dúinn dhá cheist éagsúla a bheith againn:
\nBook le húsáid ag:class: ~Django.Views.Generic.List.ListView<backwards-related-objects>Ós rud é go bhfuil rochtain againn ar an Foilsitheoir ``a gcuid leabhair ba mhaith linn a liostáil, déanaimid ``get_queryset ()` a shárú agus úsáidimid an Publisher`:ref: `bainisteoir eochair eachtrach ar ais `.
Publisher queryset for use in get_object()Beidh muid ag brath ar chur i bhfeidhm réamhshocraithe get_object () ``chun an réad ceart ``Publisher a fháil. Mar sin féin, ní mór dúinn argóint queryset a rith go sainráite mar ar shlí eile ghlaoigh cur i bhfeidhm réamhshocraithe get_object () ```get_queryset () a bhfuil athbhreithnithe againn chun rudaí Book a thabhairt ar ais in ionad Publisher cinn.
Anois is féidir linn ``PublisherDetailView ``nua a scríobh:
\nfrom django.views.generic import ListView\nfrom django.views.generic.detail import SingleObjectMixin\nfrom books.models import Publisher\n\n\nclass PublisherDetailView(SingleObjectMixin, ListView):\n paginate_by = 2\n template_name = "books/publisher_detail.html"\n\n def get(self, request, *args, **kwargs):\n self.object = self.get_object(queryset=Publisher.objects.all())\n return super().get(request, *args, **kwargs)\n\n def get_context_data(self, **kwargs):\n context = super().get_context_data(**kwargs)\n context["publisher"] = self.object\n return context\n\n def get_queryset(self):\n return self.object.book_set.all()\nTabhair faoi deara conas a shocraímid self.object laistigh de get () ``ionas gur féidir linn é a úsáid arís níos déanaí i ``get_context_data () agus get_queryset () ``. Mura socraíonn tú ``template_name, réamhshocróidh an teimpléad ar an rogha gnáth:class: ListView, arb é sa chás seo ” books/book_list.html “ toisc gur liosta leabhair é; :class: ListView níl aon rud aige fao:class: ~django.views.generic.detail.singleObjectMixin, mar sin níl aon leid aige Is é an dearcadh a bhaineann le ``Foilsitheoir ``.
Tá an paginate_by beag d'aon ghnó sa sampla mar sin ní gá duit go leor leabhar a chruthú chun an leathanaigh a fheiceáil ag obair! Seo an teimpléad ba mhaith leat a úsáid:
{% extends "base.html" %}\n\n{% block content %}\n <h2>Publisher {{ publisher.name }}</h2>\n\n <ol>\n {% for book in page_obj %}\n <li>{{ book.title }}</li>\n {% endfor %}\n </ol>\n\n <div class="pagination">\n <span class="step-links">\n {% if page_obj.has_previous %}\n <a href="?page={{ page_obj.previous_page_number }}">previous</a>\n {% endif %}\n\n <span class="current">\n Page {{ page_obj.number }} of {{ paginator.num_pages }}.\n </span>\n\n {% if page_obj.has_next %}\n <a href="?page={{ page_obj.next_page_number }}">next</a>\n {% endif %}\n </span>\n </div>\n{% endblock %}\nGo ginearálta is féidir leat: class: ~Django.Views.Generic.Base.TemplateResponseMixin agus:class: ~Django.Views.Generic.Detail.SingleObjectMixin nuair a theastaíonn a bhfeidhmiúlacht uait. Mar a thaispeántar thuas, le beagán cúraim is féidir leat fiú SingleObjectMixin a chomhcheangal la:class: ~django.views.Generic.List.ListView. Mar sin féin éiríonn rudaí níos casta de réir mar a dhéanann tú iarracht é sin a dhéanamh, agus is é riail mhaith ordóige:
Chun a thaispeáint cad a tharlaíonn nuair a dhéanann tú iarracht a bheith níos sofaisticiúla, taispeánann muid sampla a íobraíonn inléiteacht agus inchothabháil nuair a bhíonn réiteach níos simplí ann. Ar dtús, féachaimis ar iarracht naif chun: class: ~django.views.generic.detailView a chomhcheangal le: :class: ~django.views.generic.edit.formMixin chun a chumas dúinn ``POST ``django:Class: ~django.forms.forms.form ar an URL céanna agus muid ag taispeáint réad ag baint úsáide:class: Detail:`Amharc.
\nFormMixin le ``DetailView ``Link to this heading#Smaoinigh ar ais ar ár sampla níos luaithe maidir le húsáid: class: View agus:class: ~django.views.generic.detail.singleObjectMixin le chéile. Bhíomar ag taifeadadh spéis úsáideora in údar áirithe; abair anois gur mhaith linn ligean dóibh teachtaireacht a fhágáil ag rá cén fáth gur maith leo iad. Arís, glacaimis leis nach bhfuilimid chun é seo a stóráil i mbunachar sonraí coibhneasta ach ina ionad sin i rud éigin níos esoteric nach mbeidh imní orainn faoi anseo.
\nAg an bpointe seo tá sé nádúrtha teacht ar a:class: ~django.forms.form chun an fhaisnéis a sheoltar ó bhrabhsálaí an úsáideora chuig Django a chumhdú. Abair freisin go bhfuil infheistíocht mhór againn i REST, mar sin ba mhaith linn an URL céanna a úsáid chun an t-údar a thaispeáint agus chun an teachtaireacht a ghabháil ón úsáideoir. Déanaimis ár “AuthorDetailView” a athscríobh chun é sin a dhéanamh.
\nCoinneoimid an láimhseáil GET ó:class: detailView, cé go mbeidh orainn a:class: ~django.forms.form a chur isteach sna sonraí comhthéacs ionas gur féidir linn é a rinneadh sa teimpléad. Beidh muid ag iarraidh próiseáil foirme a tharraingt isteach ó:class: ~django.views.generic.edit.formMixin, agus beagán cód a scríobh ionas go gcuirfear an fhoirm ar POST` glaoch go cuí ar an bhfoirm.
Breathnaíonn ár “AuthorDetailView” nua mar seo:
\n# CAUTION: you almost certainly do not want to do this.\n# It is provided as part of a discussion of problems you can\n# run into when combining different generic class-based view\n# functionality that is not designed to be used together.\n\nfrom django import forms\nfrom django.http import HttpResponseForbidden\nfrom django.urls import reverse\nfrom django.views.generic import DetailView\nfrom django.views.generic.edit import FormMixin\nfrom books.models import Author\n\n\nclass AuthorInterestForm(forms.Form):\n message = forms.CharField()\n\n\nclass AuthorDetailView(FormMixin, DetailView):\n model = Author\n form_class = AuthorInterestForm\n\n def get_success_url(self):\n return reverse("author-detail", kwargs={"pk": self.object.pk})\n\n def post(self, request, *args, **kwargs):\n if not request.user.is_authenticated:\n return HttpResponseForbidden()\n self.object = self.get_object()\n form = self.get_form()\n if form.is_valid():\n return self.form_valid(form)\n else:\n return self.form_invalid(form)\n\n def form_valid(self, form):\n # Here, we would record the user's interest using the message\n # passed in form.cleaned_data['message']\n return super().form_valid(form)\nSoláthraíonn get_success_url () ``áit éigin le atreorú chuig, a úsáidtear i bhfeidhm réamhshocraithe ``form_valid (). Caithfimid ár “post ()” féin a sholáthar mar a luadh níos luaithe.
Tá líon na n-idirghníomhaíochtaí caolchúiseach idir:class: ~django.views.generic.edit.formMixin agus:class: detailView ag tástáil ár gcumas rudaí a bhainistiú cheana féin. Ní dócha go mbeadh tú ag iarraidh an cineál seo ranga a scríobh tú féin.
\nSa chás seo, d'fhéadfá an modh ``post () a scríobh tú féin, ag coinneáil: class: `DetailView mar an t-aon fheidhmiúlacht chineálach, cé go bhfuil go leor dúbailte i gceist le cód láimhseála ag scríbhneo:class: ~django.forms.form.
\nDe rogha air sin, bheadh sé níos lú oibre fós ná an cur chuige thuas dearcadh ar leithligh a bheith agat chun an fhoirm a phróiseáil, a d'fhéadfaí úsáid: class: ~django.views.generic.edit.formView ar leithligh ó:class: detailView gan imní.
\nIs é an rud atá againn i ndáiríre ag iarraidh a dhéanamh anseo ná dhá dhearcadh éagsúla bunaithe ar rang a úsáid ón URL céanna. Mar sin, cén fáth nach ndéanfaidh sé sin díreach? Tá rannán an-shoiléir againn anseo: ba chóir go bhfaighidh iarratais GET an:class: detailView (leis na:class: ~django.forms.form curtha leis na sonraí comhthéacs), agus ba chóir go bhfaighidh iarratais ``POST ``an:class: FormView. Déanaimis na tuairimí sin a bhunú ar dtús.
Tá an dearcadh AuthorDetailView beagnach mar an gcéanna len:ref: nuair a thugamar AuthorDetailView isteach ar dtús `<generic-views-extra-work>; caithfimid ár ``get_context_data () ``féin a scríobh chun an `AuthorInterestForm` a chur ar fáil don teimpléad. Sceapfaimid an “get_object ()” a shárú ó roimhe seo le haghaidh soiléireachta:
from django import forms\nfrom django.views.generic import DetailView\nfrom books.models import Author\n\n\nclass AuthorInterestForm(forms.Form):\n message = forms.CharField()\n\n\nclass AuthorDetailView(DetailView):\n model = Author\n\n def get_context_data(self, **kwargs):\n context = super().get_context_data(**kwargs)\n context["form"] = AuthorInterestForm()\n return context\nAnsin is é an AuthorInterestFormView` a:class: FormView, ach caithfimid a thabhairt isteach: class: ~django.views.generic.detail.singleObjectMixin ionas gur féidir linn an t-údar atá á caint air a fháil, agus caithfimid cuimhneamh ar template_name a shocrú chun a chinntiú go ndéanfaidh earráidí foirme an teimpléad céanna le AuthorDetailView` ag baint úsáide as GET:
from django.http import HttpResponseForbidden\nfrom django.urls import reverse\nfrom django.views.generic import FormView\nfrom django.views.generic.detail import SingleObjectMixin\n\n\nclass AuthorInterestFormView(SingleObjectMixin, FormView):\n template_name = "books/author_detail.html"\n form_class = AuthorInterestForm\n model = Author\n\n def post(self, request, *args, **kwargs):\n if not request.user.is_authenticated:\n return HttpResponseForbidden()\n self.object = self.get_object()\n return super().post(request, *args, **kwargs)\n\n def get_success_url(self):\n return reverse("author-detail", kwargs={"pk": self.object.pk})\nFinally we bring this together in a new AuthorView view. We\nalready know that calling as_view() on\na class-based view gives us something that behaves exactly like a function\nbased view, so we can do that at the point we choose between the two subviews.
You can pass through keyword arguments to\nas_view() in the same way you\nwould in your URLconf, such as if you wanted the AuthorInterestFormView\nbehavior to also appear at another URL but using a different template:
from django.views import View\n\n\nclass AuthorView(View):\n def get(self, request, *args, **kwargs):\n view = AuthorDetailView.as_view()\n return view(request, *args, **kwargs)\n\n def post(self, request, *args, **kwargs):\n view = AuthorInterestFormView.as_view()\n return view(request, *args, **kwargs)\nIs féidir an cur chuige seo a úsáid freisin le haon tuairimí cineálacha eile bunaithe ar aicme nó le do thuairimí rang-bhunaithe féin a thagann oidhreacht go díreach ó:class: View nó:class: TemplateView, toisc go gcoinníonn sé na tuairimí éagsúla chomh scartha agus is féidir.
\nIs é an áit a bhfuil tuairimí bunaithe ar rang-bhunaithe nuair is mian leat an rud céanna a dhéanamh arís agus arís eile. Cuir i gcás go bhfuil API á scríobh agat, agus ba cheart do gach radharc JSON a thabhairt ar ais in ionad HTML rindreáilte
\nIs féidir linn rang mixin a chruthú le húsáid inár dtuairimí go léir, ag láimhseáil an tiontú go JSON uair amháin.
\nMar shampla, d'fhéadfadh go mbeadh cuma mar seo ar mheascán JSON:
\nfrom django.http import JsonResponse\n\n\nclass JSONResponseMixin:\n """\n A mixin that can be used to render a JSON response.\n """\n\n def render_to_json_response(self, context, **response_kwargs):\n """\n Returns a JSON response, transforming 'context' to make the payload.\n """\n return JsonResponse(self.get_data(context), **response_kwargs)\n\n def get_data(self, context):\n """\n Returns an object that will be serialized as JSON by json.dumps().\n """\n # Note: This is *EXTREMELY* naive; in reality, you'll need\n # to do much more complex handling to ensure that arbitrary\n # objects -- such as Django model instances or querysets\n # -- can be serialized as JSON.\n return context\nThis mixin provides a render_to_json_response() method with the same\nsignature as\nrender_to_response().\nTo use it, we need to mix it into a TemplateView for example, and override\nrender_to_response() to call render_to_json_response() instead:
from django.views.generic import TemplateView\n\n\nclass JSONView(JSONResponseMixin, TemplateView):\n def render_to_response(self, context, **response_kwargs):\n return self.render_to_json_response(context, **response_kwargs)\nMar an gcéanna d'fhéadfaimis ár meascán a úsáid le ceann de na tuairimí cineálacha. Is féidir linn ár leagan féin de:class: ~django.views.generic.detail.detailView a dhéanamh trí JSONResponseMixin a mheascadh leis na:class: ~django.views.generic.detail.detail.baseDetailView -- (an: class: ~Django.Views.Generic.DetailView sula ndéantar iompar rindreála teimpléad measctha):
from django.views.generic.detail import BaseDetailView\n\n\nclass JSONDetailView(JSONResponseMixin, BaseDetailView):\n def render_to_response(self, context, **response_kwargs):\n return self.render_to_json_response(context, **response_kwargs)\nIs féidir an dearcadh seo a imscaradh ar an mbealach céanna le haon ain:class: ~django.views.generic.detail.detailView, leis an iompar céanna go díreach -- ach amháin i gcás formáid na freagartha.
\nIf you want to be really adventurous, you could even mix a\nDetailView subclass that is able\nto return both HTML and JSON content, depending on some property of\nthe HTTP request, such as a query argument or an HTTP header. Mix in both the\nJSONResponseMixin and a\nSingleObjectTemplateResponseMixin,\nand override the implementation of\nrender_to_response()\nto defer to the appropriate rendering method depending on the type of response\nthat the user requested:
from django.views.generic.detail import SingleObjectTemplateResponseMixin\n\n\nclass HybridDetailView(\n JSONResponseMixin, SingleObjectTemplateResponseMixin, BaseDetailView\n):\n def render_to_response(self, context):\n # Look for a 'format=json' GET argument\n if self.request.GET.get("format") == "json":\n return self.render_to_json_response(context)\n else:\n return super().render_to_response(context)\nBecause of the way that Python resolves method overloading, the call to\nsuper().render_to_response(context) ends up calling the\nrender_to_response()\nimplementation of TemplateResponseMixin.