Class based ajax views for django

The  code defines several Django views that handle AJAX requests for different actions in a web application. The views are designed to respond with JSON containing HTML content that can be used to update specific parts of a web page without requiring a full page reload. These views follow a common pattern for handling AJAX requests and can be used with Django's built-in views or custom views that inherit from them.

Let's go through each of the views to understand their purposes and functionalities:

1. AjaxListView:

   • Purpose: This view is intended to handle AJAX requests for listing objects and rendering the corresponding HTML partial template for the object list.
   • Key methods:
     • get: Renders the object list template and returns it as JSON if the request is an AJAX request.

2. AjaxCreateView:

   • Purpose: This view is used to handle AJAX requests for creating objects and rendering the corresponding HTML partial template for the create form.
   • Key methods:
     • get: Renders the create form template and returns it as JSON if the request is an AJAX request.
     • form_valid: Saves the form if it is valid and returns the updated object list template as JSON.
     • form_invalid: Returns the create form template as JSON if the form is invalid.

3. AjaxUpdateView:

   • Purpose: This view is designed to handle AJAX requests for updating objects and rendering the corresponding HTML partial template for the update form.
   • Key methods:
     • get: Renders the update form template and returns it as JSON if the request is an AJAX request.
     • form_valid: Saves the form if it is valid and returns the updated object list template as JSON.
     • form_invalid: Returns the update form template as JSON if the form is invalid.

4. AjaxDeleteView:

   • Purpose: This view is used to handle AJAX requests for deleting objects and rendering the corresponding HTML partial template for the delete confirmation.
   • Key methods:
     • get: Renders the delete confirmation template and returns it as JSON if the request is an AJAX request.
     • post: Deletes the object and returns the updated object list template as JSON.

Overall, these views are intended to be used in scenarios where you need to update specific parts of a webpage asynchronously using AJAX, without reloading the entire page. The views provide a way to handle AJAX requests and render templates in response to those requests. They seem to work well in conjunction with Django's built-in views for listing, creating, updating, and deleting objects. Remember that these views should be used with Django templates that contain the necessary HTML and form elements for listing, creating, updating, and deleting objects.

To use these views, you need to include them in your Django application, define URLs to map to these views, and create corresponding templates for listing, creating, updating, and deleting objects. Additionally, you'll need to set up appropriate JavaScript on the frontend to trigger the AJAX requests and update the webpage with the received JSON data.

              
                from django.http import JsonResponse
from django import template
from django.template.loader import render_to_string
from django.template.loader import TemplateDoesNotExist


class AjaxListView:
    def get(self, request, *args, **kwargs):
        ajax_list_partial = self.ajax_list_partial
        self.object_list = super().get_queryset()
        context = super().get_context_data(**kwargs)
        if not ajax_list_partial:
            raise TemplateDoesNotExist("No ajax__list_partial provided {}".format(self))
        if request.is_ajax():
            html_form = render_to_string(self.ajax_list_partial, context, request)
            return JsonResponse({'html_form': html_form})
        return super().get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['object_list'] = super().get_queryset()
        return context


class AjaxCreateView:
    def get(self, request, *args, **kwargs):
        self.object = None
        ajax_create_partial = self.ajax_create_partial
        ajax_list_partial = self.ajax_list_partial
        context = super().get_context_data(**kwargs)
        if not ajax_create_partial or not ajax_list_partial:
            raise TemplateDoesNotExist("No ajax_create_partial or ajax_list_partial provided {}".format(self))
        if request.is_ajax():
            html_form = render_to_string(self.ajax_create_partial, context, request)
            return JsonResponse({'html_form': html_form})
        return super().get(request, *args, **kwargs)

    def form_valid(self, form):
        data = dict()
        context = self.get_context_data()
        if form.is_valid():
            form.save()
            data['form_is_valid'] = True
            data['list'] = render_to_string(
                    self.ajax_list_partial, context, self.request)
        if self.request.is_ajax():
            return JsonResponse(data)
        return super().form_valid(form)

    def form_invalid(self, form):
        data = dict()
        context = self.get_context_data()
        data['form_is_valid'] = False
        data['html_form'] = render_to_string(
                self.ajax_create_partial, context, request=self.request)
        if self.request.is_ajax():
            return JsonResponse(data)
        return super().form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['object_list'] = super().get_queryset()
        return context



class AjaxUpdateView:
    def get(self, request, *args, **kwargs):
        ajax_update_partial = self.ajax_update_partial
        ajax_list_partial = self.ajax_list_partial
        self.object = super().get_object()
        context = super().get_context_data(**kwargs)
        if not ajax_update_partial or not ajax_list_partial:
            raise TemplateDoesNotExist("No ajax_update_partial or ajax_list_partial provided {}".format(self))
        if request.is_ajax():
            html_form = render_to_string(self.ajax_update_partial, context, request)
            return JsonResponse({'html_form': html_form})
        return super().get(request, *args, **kwargs)

    def form_valid(self, form):
        data = dict()
        context = self.get_context_data()
        if form.is_valid():
            form.save()
            data['form_is_valid'] = True
            data['list'] = render_to_string(
                    self.ajax_list_partial, context, self.request)
        if self.request.is_ajax():
            return JsonResponse(data)
        return super().form_valid(form)

    def form_invalid(self, form):
        data = dict()
        context = super().get_context_data()
        data['form_is_valid'] = False
        data['html_form'] = render_to_string(
                self.ajax_update_partial, context, request=self.request)
        if self.request.is_ajax():
            return JsonResponse(data)
        return super().form_invalid(form)

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['object_list'] = super().get_queryset()
        return context


class AjaxDeleteView:
    def get(self, request, *args, **kwargs):
        self.object = self.get_object()
        context = super().get_context_data(**kwargs)
        ajax_delete_partial = self.ajax_delete_partial
        ajax_list_partial = self.ajax_list_partial
        if not ajax_delete_partial or not ajax_list_partial:
            raise TemplateDoesNotExist("No ajax_delete_partial or ajax_list_partial provided {}".format(self))
        if request.is_ajax():
            html_form = render_to_string(
                    self.ajax_delete_partial, context, request)
            return JsonResponse({'html_form': html_form})
        return super().get(request, *args, **kwargs)

    def post(self, *args, **kwargs):
        ajax_delete_partial = self.ajax_delete_partial
        ajax_list_partial = self.ajax_list_partial
        if self.request.is_ajax():
            self.object = super().get_object()
            self.object.delete()
            data = dict()
            data['form_is_valid'] = True
            context = super().get_context_data(**kwargs)
            context['object_list'] = self.get_queryset()
            data['list'] = render_to_string(
                    self.ajax_list_partial, context, self.request)
            return JsonResponse(data)
        return self.delete(*args, **kwargs)