crudbuilder.ViewBuilder

Complexity

Total Complexity

18

Size/Duplication

Total Lines	144
Duplicated Lines	0 %

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	3	1
A	generate_crud()	0	6	1
A	generate_modelform()	0	7	2
A	get_actual_table()	0	6	2
A	get_template()	0	9	3
A	get_actual_form()	0	7	4
A	generate_create_view()	0	17	1
A	generate_delete_view()	0	16	1
B	generate_list_view()	0	24	1
A	generate_detail_view()	0	15	1
A	generate_update_view()	0	21	1

from django.core.urlresolvers import reverse_lazy
from django.forms.models import modelform_factory
from django.views.generic import(
    DetailView,
    CreateView,
    UpdateView,
    DeleteView
)
from django_tables2 import SingleTableView

from crudbuilder.mixins import(
    CrudBuilderMixin,
    BaseListViewMixin,
    CreateUpdateViewMixin
)
from crudbuilder.abstract import BaseBuilder
from crudbuilder.tables import TableBuilder
from crudbuilder.helpers import model_class_form, plural


class ViewBuilder(BaseBuilder):
    """View builder which returns all the CRUD class based views"""

    def __init__(self, *args, **kwargs):
        super(ViewBuilder, self).__init__(*args, **kwargs)
        self.classes = {}

    def generate_crud(self):
        self.generate_list_view()
        self.generate_create_view()
        self.generate_detail_view()
        self.generate_update_view()
        self.generate_delete_view()

    def get_actual_form(self, view):
        if self.createupdate_forms and self.createupdate_forms.get(view, None):
            return self.createupdate_forms.get(view)
        elif self.custom_modelform:
            return self.custom_modelform
        else:
            return self.generate_modelform()

    def get_actual_table(self):
        if self.custom_table2:
            return self.custom_table2
        else:
            table_builder = TableBuilder(self.app, self.model, self.crud)
            return table_builder.generate_table()

    def generate_modelform(self):
        """Generate modelform from Django modelform_factory"""

        model_class = self.get_model_class
        excludes = self.modelform_excludes if self.modelform_excludes else []
        _ObjectForm = modelform_factory(model_class, exclude=excludes)
        return _ObjectForm

    def get_template(self, tname):
        """
        - Get custom template from CRUD class, if it is defined in it
        - No custom template in CRUD class, then use the default template
        """
        if self.custom_templates and self.custom_templates.get(tname, None):
            return self.custom_templates.get(tname)
        else:
            return 'object_{}.html'.format(tname)

    def generate_list_view(self):
        """Generate class based view for ListView"""

        name = model_class_form(self.model + 'ListView')
        list_args = dict(
            model=self.get_model_class,
            context_object_name=plural(self.model),
            template_name=self.get_template('list'),
            table_class=self.get_actual_table(),
            context_table_name='table_objects',
            crud=self.crud,
            permissions=self.view_permission('list'),
            permission_required=self.check_permission_required,
            login_required=self.check_login_required,
            table_pagination=self.tables2_pagination or 10
            )

        list_class = type(
            name,
            (BaseListViewMixin, SingleTableView),
            list_args
            )
        self.classes[name] = list_class
        return list_class

    def generate_create_view(self):

This code seems to be duplicated in your project.

        """Generate class based view for CreateView"""

        name = model_class_form(self.model + 'CreateView')
        create_args = dict(
            form_class=self.get_actual_form('create'),
            model=self.get_model_class,
            template_name=self.get_template('create'),
            permissions=self.view_permission('create'),
            permission_required=self.check_permission_required,
            login_required=self.check_login_required,
            success_url=reverse_lazy('{}-{}-list'.format(self.app, self.model))
            )

        create_class = type(name, (CreateUpdateViewMixin, CreateView), create_args)
        self.classes[name] = create_class
        return create_class

    def generate_detail_view(self):
        """Generate class based view for DetailView"""

        name = model_class_form(self.model + 'DetailView')
        detail_args = dict(
            model=self.get_model_class,
            template_name=self.get_template('detail'),
            login_required=self.check_login_required,
            permissions=self.view_permission('detail'),
            permission_required=self.check_permission_required,
            )

        detail_class = type(name, (CrudBuilderMixin, DetailView), detail_args)
        self.classes[name] = detail_class
        return detail_class

    def generate_update_view(self):

This code seems to be duplicated in your project.

        """Generate class based view for UpdateView"""

        name = model_class_form(self.model + 'UpdateView')
        update_args = dict(
            form_class=self.get_actual_form('update'),
            model=self.get_model_class,
            template_name=self.get_template('update'),
            permissions=self.view_permission('update'),
            permission_required=self.check_permission_required,
            login_required=self.check_login_required,
            success_url=reverse_lazy('{}-{}-list'.format(self.app, self.model))
            )

        update_class = type(
            name,
            (CreateUpdateViewMixin, UpdateView),
            update_args
            )
        self.classes[name] = update_class
        return update_class

    def generate_delete_view(self):
        """Generate class based view for DeleteView"""

        name = model_class_form(self.model + 'DeleteView')
        delete_args = dict(
            model=self.get_model_class,
            template_name=self.get_template('delete'),
            permissions=self.view_permission('delete'),
            permission_required=self.check_permission_required,
            login_required=self.check_login_required,
            success_url=reverse_lazy('{}-{}-list'.format(self.app, self.model))
            )

        delete_class = type(name, (CrudBuilderMixin, DeleteView), delete_args)
        self.classes[name] = delete_class
        return delete_class