ViewBuilder.get_actual_form() - Code Metrics - Inspection of "Fixed #23" - asifpy/django-crudbuilder - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0e6eac...543ed2 )

by Asif

created 2016-08-08 19:51 UTC

ViewBuilder.get_actual_form() A

↳ Parent: ViewBuilder

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	7
rs	9.2
cc	4

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,
    InlineFormsetViewMixin,
    BaseDetailViewMixin
)
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)
        elif self.inlineformset:
            return 'inline/{}.html'.format(tname)
        else:
            return 'instance/{}.html'.format(tname)

    def get_createupdate_mixin(self):
        if self.inlineformset:
            return InlineFormsetViewMixin
        else:
            return CreateUpdateViewMixin

    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={'per_page': self.tables2_pagination or 10},
            custom_queryset=self.custom_queryset,
            custom_context=self.custom_context
        )

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

    def generate_create_view(self):

        """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,
            inlineformset=self.inlineformset,
            success_url=reverse_lazy('{}-{}-list'.format(self.app, self.model)),
            custom_form=self.createupdate_forms or self.custom_modelform
        )

        create_class = type(
            name,
            (self.get_createupdate_mixin(), 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'),
            inlineformset=self.inlineformset,
            permission_required=self.check_permission_required,
        )

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

    def generate_update_view(self):

        """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,
            inlineformset=self.inlineformset,
            custom_form=self.createupdate_forms or self.custom_modelform,
            success_url=reverse_lazy('{}-{}-list'.format(self.app, self.model))
        )

        update_class = type(
            name,
            (self.get_createupdate_mixin(), 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


1		from django.core.urlresolvers import reverse_lazy
2		from django.forms.models import modelform_factory
3		from django.views.generic import(
4		DetailView,
5		CreateView,
6		UpdateView,
7		DeleteView
8		)
9		from django_tables2 import SingleTableView
10
11		from crudbuilder.mixins import(
12		CrudBuilderMixin,
13		BaseListViewMixin,
14		CreateUpdateViewMixin,
15		InlineFormsetViewMixin,
16		BaseDetailViewMixin
17		)
18		from crudbuilder.abstract import BaseBuilder
19		from crudbuilder.tables import TableBuilder
20		from crudbuilder.helpers import model_class_form, plural
21
22
23		class ViewBuilder(BaseBuilder):
24		"""View builder which returns all the CRUD class based views"""
25
26		def __init__(self, args, *kwargs):
27		super(ViewBuilder, self).__init__(args, *kwargs)
28		self.classes = {}
29
30		def generate_crud(self):
31		self.generate_list_view()
32		self.generate_create_view()
33		self.generate_detail_view()
34		self.generate_update_view()
35		self.generate_delete_view()
36
37		def get_actual_form(self, view):
38		if self.createupdate_forms and self.createupdate_forms.get(view, None):
39		return self.createupdate_forms.get(view)
40		elif self.custom_modelform:
41		return self.custom_modelform
42		else:
43		return self.generate_modelform()
44
45		def get_actual_table(self):
46		if self.custom_table2:
47		return self.custom_table2
48		else:
49		table_builder = TableBuilder(self.app, self.model, self.crud)
50		return table_builder.generate_table()
51
52		def generate_modelform(self):
53		"""Generate modelform from Django modelform_factory"""
54
55		model_class = self.get_model_class
56		excludes = self.modelform_excludes if self.modelform_excludes else []
57		_ObjectForm = modelform_factory(model_class, exclude=excludes)
58		return _ObjectForm
59
60		def get_template(self, tname):
61		"""
62		- Get custom template from CRUD class, if it is defined in it
63		- No custom template in CRUD class, then use the default template
64		"""
65
66		if self.custom_templates and self.custom_templates.get(tname, None):
67		return self.custom_templates.get(tname)
68		elif self.inlineformset:
69		return 'inline/{}.html'.format(tname)
70		else:
71		return 'instance/{}.html'.format(tname)
72
73		def get_createupdate_mixin(self):
74		if self.inlineformset:
75		return InlineFormsetViewMixin
76		else:
77		return CreateUpdateViewMixin
78
79		def generate_list_view(self):
80		"""Generate class based view for ListView"""
81
82		name = model_class_form(self.model + 'ListView')
83		list_args = dict(
84		model=self.get_model_class,
85		context_object_name=plural(self.model),
86		template_name=self.get_template('list'),
87		table_class=self.get_actual_table(),
88		context_table_name='table_objects',
89		crud=self.crud,
90		permissions=self.view_permission('list'),
91		permission_required=self.check_permission_required,
92		login_required=self.check_login_required,
93		table_pagination={'per_page': self.tables2_pagination or 10},
94		custom_queryset=self.custom_queryset,
95		custom_context=self.custom_context
96		)
97
98		list_class = type(
99		name,
100		(BaseListViewMixin, SingleTableView),
101		list_args
102		)
103		self.classes[name] = list_class
104		return list_class
105
106	View Code Duplication	def generate_create_view(self):
		0 ignored issues – show Duplication introduced 2016-08-08 19:52 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
107		"""Generate class based view for CreateView"""
108
109		name = model_class_form(self.model + 'CreateView')
110		create_args = dict(
111		form_class=self.get_actual_form('create'),
112		model=self.get_model_class,
113		template_name=self.get_template('create'),
114		permissions=self.view_permission('create'),
115		permission_required=self.check_permission_required,
116		login_required=self.check_login_required,
117		inlineformset=self.inlineformset,
118		success_url=reverse_lazy('{}-{}-list'.format(self.app, self.model)),
119		custom_form=self.createupdate_forms or self.custom_modelform
120		)
121
122		create_class = type(
123		name,
124		(self.get_createupdate_mixin(), CreateView),
125		create_args
126		)
127
128		self.classes[name] = create_class
129		return create_class
130
131		def generate_detail_view(self):
132		"""Generate class based view for DetailView"""
133
134		name = model_class_form(self.model + 'DetailView')
135		detail_args = dict(
136		model=self.get_model_class,
137		template_name=self.get_template('detail'),
138		login_required=self.check_login_required,
139		permissions=self.view_permission('detail'),
140		inlineformset=self.inlineformset,
141		permission_required=self.check_permission_required,
142		)
143
144		detail_class = type(name, (BaseDetailViewMixin, DetailView), detail_args)
145		self.classes[name] = detail_class
146		return detail_class
147
148	View Code Duplication	def generate_update_view(self):
		0 ignored issues – show Duplication introduced 2016-08-01 21:03 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
149		"""Generate class based view for UpdateView"""
150
151		name = model_class_form(self.model + 'UpdateView')
152		update_args = dict(
153		form_class=self.get_actual_form('update'),
154		model=self.get_model_class,
155		template_name=self.get_template('update'),
156		permissions=self.view_permission('update'),
157		permission_required=self.check_permission_required,
158		login_required=self.check_login_required,
159		inlineformset=self.inlineformset,
160		custom_form=self.createupdate_forms or self.custom_modelform,
161		success_url=reverse_lazy('{}-{}-list'.format(self.app, self.model))
162		)
163
164		update_class = type(
165		name,
166		(self.get_createupdate_mixin(), UpdateView),
167		update_args
168		)
169		self.classes[name] = update_class
170		return update_class
171
172		def generate_delete_view(self):
173		"""Generate class based view for DeleteView"""
174
175		name = model_class_form(self.model + 'DeleteView')
176		delete_args = dict(
177		model=self.get_model_class,
178		template_name=self.get_template('delete'),
179		permissions=self.view_permission('delete'),
180		permission_required=self.check_permission_required,
181		login_required=self.check_login_required,
182		success_url=reverse_lazy('{}-{}-list'.format(self.app, self.model))
183		)
184
185		delete_class = type(name, (CrudBuilderMixin, DeleteView), delete_args)
186		self.classes[name] = delete_class
187		return delete_class
188

asifpy / django-crudbuilder

Push — master ( 0e6eac...543ed2 )

ViewBuilder.get_actual_form() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like