Django

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)

def initial_form(request, form):
    '''
    form is an instance of a form 

    '''
    form_init = {}
    if request.GET.items():
        try:
            parameters = request.GET.items()
        except KeyError:
            parameters = {}
        for key, value in parameters:
            for field in form.fields:
                if key == field:
                    form_init[key] = value
        form.initial = form_init
    return form

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger


def get_pagination(request, queryset, items):
    '''
    items: The number for pagination

    return tuple (total_pages, paginated queryset) 
    '''
    paginator = Paginator(queryset, items)
    page = request.GET.get('page')
    try:
        items_page = paginator.page(page)
    except PageNotAnInteger:
        items_page = paginator.page(1)
    except EmptyPage:
        items_page = paginator.page(paginator.num_pages)
    return (paginator.num_pages, items_page)

def get_initial(self):
    if self.request.GET:
        initial = self.request.GET.dict()
        return initial
    else:
        return super().get_initial()

from django import template
from django.urls import reverse_lazy
register = template.Library()


@register.simple_tag(takes_context=True)
def get_url(context, *args):
    '''
    example 1  "{% get_url 'list' %}"
    example 2  "{% get_url 'create' %}"
    example 3  "{% get_url 'create' 'cms' %}"
    example 4  "{% get_url 'detail' obj  %}"
    example 5  "{% get_url 'detail' obj 'cms'  %}"

    the first argument is action create or list or detail or update or delete
    the second argument is a model object
    the third argument is custom app

    the name of url pattern so as to work

    app:model-create
    app:model-update
    app:model-delete
    app:model-detail
    '''

    model = context['model']
    obj = None
    print(len(args))
    lower_name = model.__name__.lower()
    app = model._meta.app_label
    if len(args) == 0:
        return ''
    if len(args) == 2:
        action = args[0]
        app = args[1]
    if len(args) ==3:
        action = args[0]
        obj = args[1]
        app = args[2]
        lower_name = obj.__class__.__name__.lower()

    url_string = '{}:{}-{}'.format(app, lower_name, action)
    if hasattr(obj, 'uuid'):
        url = reverse_lazy(url_string, kwargs={'uuid': obj.uuid})
    if(hasattr(obj, 'slug')):
        url = reverse_lazy(url_string, kwargs={'slug': obj.slug})
    if hasattr(obj, 'pk'):
        url = reverse_lazy(url_string, kwargs={'pk': obj.pk})

    if not obj:
        url_string = '{}:{}-{}'.format(app, lower_name, action)
        url = reverse_lazy(url_string)
    return url