TriggerEditedTemplateView.get_context_data() - Code Metrics - Inspection of "cleaning" - foxmask/django-th - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b389e4...004307 )

by Fox

created 2016-10-19 23:19 UTC

TriggerEditedTemplateView.get_context_data() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

# coding: utf-8
from __future__ import unicode_literals

from django.core.cache import caches
from django.core.urlresolvers import reverse_lazy, reverse
from django.conf import settings

from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.views.generic import TemplateView, UpdateView, ListView, DeleteView
from django.db.models import Q
from django.utils.decorators import method_decorator


# trigger_happy
from django_th.models import TriggerService, UserService

from django_th.forms.base import TriggerServiceForm
from django_th.views_fbv import can_modify_trigger

import logging
# Get an instance of a logger
logger = logging.getLogger(__name__)
cache = caches['django_th']


class TriggerListView(ListView):
    """
        list of Triggers
        the list can be filtered by service
    """
    context_object_name = "triggers_list"
    queryset = TriggerService.objects.all()
    template_name = "home.html"
    paginate_by = 3

    def get_paginate_by(self, queryset):
        """
            Get the number of items to paginate by,
            from the settings
        """
        paginate_by = 3
        if hasattr(settings, 'DJANGO_TH'):
            if settings.DJANGO_TH.get('paginate_by'):
                paginate_by = settings.DJANGO_TH['paginate_by']
        return paginate_by

    def get_queryset(self):
        filtered_by = None
        # by default, sort by date_created
        ordered_by = (str('-date_triggered'), )
        # get the Trigger of the connected user
        if self.request.user.is_authenticated():
            # if the user selected a filter, get its ID
            if self.kwargs.get('trigger_filtered_by'):
                filtered_by = UserService.objects.filter(
                    user=self.request.user,
                    name=self.kwargs.get('trigger_filtered_by'))[0].id

            if self.kwargs.get('trigger_ordered_by'):
                """
                    sort by 'name' property in the related model UserService
                """
                order_by = str(self.kwargs.get('trigger_ordered_by') + "__name")
                # append to the tuple, the selected 'trigger_ordered_by'
                # choosen in the dropdown
                ordered_by = (order_by, ) + ordered_by

            # no filter selected
            if filtered_by is None:
                return self.queryset.filter(user=self.request.user).order_by(
                    *ordered_by).select_related('consumer__name',
                                                'provider__name')

            # filter selected : display all related triggers
            else:
                # here the queryset will do :
                # 1) get trigger of the connected user AND
                # 2) get the triggers where the provider OR the consumer match
                # the selected service
                return self.queryset.filter(user=self.request.user).filter(
                    Q(provider=filtered_by) |
                    Q(consumer=filtered_by)).order_by(
                    *ordered_by).select_related('consumer__name',
                                                'provider__name')
        # otherwise return nothing when user is not connected
        return TriggerService.objects.none()

    def get_context_data(self, **kw):
        """
            get the data of the view

            data are :
            1) number of triggers enabled
            2) number of triggers disabled
            3) number of activated services
            4) list of activated services by the connected user
        """
        triggers_enabled = triggers_disabled = services_activated = ()

        context = super(TriggerListView, self).get_context_data(**kw)

        if self.kwargs.get('trigger_filtered_by'):
            page_link = reverse('trigger_filter_by',
                                kwargs={'trigger_filtered_by':
                                        self.kwargs.get('trigger_filtered_by')})
        elif self.kwargs.get('trigger_ordered_by'):
            page_link = reverse('trigger_order_by',
                                kwargs={'trigger_ordered_by':
                                        self.kwargs.get('trigger_ordered_by')})
        else:
            page_link = reverse('home')

        if self.request.user.is_authenticated():
            # get the enabled triggers
            triggers_enabled = TriggerService.objects.filter(
                user=self.request.user, status=1).count()
            # get the disabled triggers
            triggers_disabled = TriggerService.objects.filter(
                user=self.request.user, status=0).count()
            # get the activated services
            user_service = UserService.objects.filter(user=self.request.user)
            """
                List of triggers activated by the user
            """
            context['trigger_filter_by'] = user_service
            """
                number of service activated for the current user
            """
            services_activated = user_service.count()

        """
            which triggers are enabled/disabled
        """
        context['nb_triggers'] = {'enabled': triggers_enabled,
                                  'disabled': triggers_disabled}
        """
            Number of services activated
        """
        context['nb_services'] = services_activated

        context['page_link'] = page_link

        return context


class TriggerServiceMixin(object):
    """
        Mixin for UpdateView and DeleteView
    """
    queryset = TriggerService.objects.all()

    @method_decorator(login_required)
    def dispatch(self, *args, **kwargs):
        return super(TriggerServiceMixin, self).dispatch(*args, **kwargs)

    def get_queryset(self):
        # get the trigger of the connected user
        if self.request.user.is_authenticated():
            return self.queryset.filter(user=self.request.user,
                                        id=self.kwargs.get('pk'))
        # otherwise return nothing
        return TriggerService.objects.none()


class TriggerUpdateView(TriggerServiceMixin, UpdateView):
    """
        Form to update description
    """
    form_class = TriggerServiceForm
    template_name = "triggers/edit_description_trigger.html"
    success_url = reverse_lazy("trigger_edit_thanks")

    def get_context_data(self, **kw):
        return super(TriggerUpdateView, self).get_context_data(**kw)

    def get(self, *args, **kwargs):
        # Go through keyword arguments, and either save their values to our
        # instance, or raise an error.
        self.object = self.get_object()
        status = can_modify_trigger(self.request,
                                    self.object.provider.name.status,
                                    self.object.consumer.name.status)
        if status:
            return HttpResponseRedirect(reverse('base'))
        else:
            return super(TriggerUpdateView, self).get(
                self.request, *args, **kwargs)


class TriggerEditedTemplateView(TemplateView):
    """
        just a simple form to say thanks :P
    """
    template_name = "triggers/edited_thanks_trigger.html"


class TriggerDeleteView(TriggerServiceMixin, DeleteView):
    """
        page to delete a trigger
    """
    template_name = "triggers/delete_trigger.html"
    success_url = reverse_lazy("trigger_delete_thanks")


class TriggerDeletedTemplateView(TemplateView):
    """
        just a simple form to say thanks :P
    """
    template_name = "triggers/deleted_thanks_trigger.html"


1			# coding: utf-8
2			from __future__ import unicode_literals
3
4			from django.core.cache import caches
5			from django.core.urlresolvers import reverse_lazy, reverse
6			from django.conf import settings
7
8			from django.contrib.auth.decorators import login_required
9			from django.http import HttpResponseRedirect
10			from django.views.generic import TemplateView, UpdateView, ListView, DeleteView
11			from django.db.models import Q
12			from django.utils.decorators import method_decorator
13
14
15			# trigger_happy
16			from django_th.models import TriggerService, UserService
17
18			from django_th.forms.base import TriggerServiceForm
19			from django_th.views_fbv import can_modify_trigger
20
21			import logging
22			# Get an instance of a logger
23			logger = logging.getLogger(__name__)
24			cache = caches['django_th']
25
26
27			class TriggerListView(ListView):
28			"""
29			list of Triggers
30			the list can be filtered by service
31			"""
32			context_object_name = "triggers_list"
33			queryset = TriggerService.objects.all()
34			template_name = "home.html"
35			paginate_by = 3
36
37			def get_paginate_by(self, queryset):
38			"""
39			Get the number of items to paginate by,
40			from the settings
41			"""
42			paginate_by = 3
43			if hasattr(settings, 'DJANGO_TH'):
44			if settings.DJANGO_TH.get('paginate_by'):
45			paginate_by = settings.DJANGO_TH['paginate_by']
46			return paginate_by
47
48			def get_queryset(self):
49			filtered_by = None
50			# by default, sort by date_created
51			ordered_by = (str('-date_triggered'), )
52			# get the Trigger of the connected user
53			if self.request.user.is_authenticated():
54			# if the user selected a filter, get its ID
55			if self.kwargs.get('trigger_filtered_by'):
56			filtered_by = UserService.objects.filter(
57			user=self.request.user,
58			name=self.kwargs.get('trigger_filtered_by'))[0].id
59
60			if self.kwargs.get('trigger_ordered_by'):
61			"""
62			sort by 'name' property in the related model UserService
63			"""
64			order_by = str(self.kwargs.get('trigger_ordered_by') + "__name")
65			# append to the tuple, the selected 'trigger_ordered_by'
66			# choosen in the dropdown
67			ordered_by = (order_by, ) + ordered_by
68
69			# no filter selected
70			if filtered_by is None:
71			return self.queryset.filter(user=self.request.user).order_by(
72			*ordered_by).select_related('consumer__name',
73			'provider__name')
74
75			# filter selected : display all related triggers
76			else:
77			# here the queryset will do :
78			# 1) get trigger of the connected user AND
79			# 2) get the triggers where the provider OR the consumer match
80			# the selected service
81			return self.queryset.filter(user=self.request.user).filter(
82			Q(provider=filtered_by) \|
83			Q(consumer=filtered_by)).order_by(
84			*ordered_by).select_related('consumer__name',
85			'provider__name')
86			# otherwise return nothing when user is not connected
87			return TriggerService.objects.none()
88
89			def get_context_data(self, **kw):
90			"""
91			get the data of the view
92
93			data are :
94			1) number of triggers enabled
95			2) number of triggers disabled
96			3) number of activated services
97			4) list of activated services by the connected user
98			"""
99			triggers_enabled = triggers_disabled = services_activated = ()
100
101			context = super(TriggerListView, self).get_context_data(**kw)
102
103			if self.kwargs.get('trigger_filtered_by'):
104			page_link = reverse('trigger_filter_by',
105			kwargs={'trigger_filtered_by':
106			self.kwargs.get('trigger_filtered_by')})
107			elif self.kwargs.get('trigger_ordered_by'):
108			page_link = reverse('trigger_order_by',
109			kwargs={'trigger_ordered_by':
110			self.kwargs.get('trigger_ordered_by')})
111			else:
112			page_link = reverse('home')
113
114			if self.request.user.is_authenticated():
115			# get the enabled triggers
116			triggers_enabled = TriggerService.objects.filter(
117			user=self.request.user, status=1).count()
118			# get the disabled triggers
119			triggers_disabled = TriggerService.objects.filter(
120			user=self.request.user, status=0).count()
121			# get the activated services
122			user_service = UserService.objects.filter(user=self.request.user)
123			"""
124			List of triggers activated by the user
125			"""
126			context['trigger_filter_by'] = user_service
127			"""
128			number of service activated for the current user
129			"""
130			services_activated = user_service.count()
131
132			"""
133			which triggers are enabled/disabled
134			"""
135			context['nb_triggers'] = {'enabled': triggers_enabled,
136			'disabled': triggers_disabled}
137			"""
138			Number of services activated
139			"""
140			context['nb_services'] = services_activated
141
142			context['page_link'] = page_link
143
144			return context
145
146
147			class TriggerServiceMixin(object):
148			"""
149			Mixin for UpdateView and DeleteView
150			"""
151			queryset = TriggerService.objects.all()
152
153			@method_decorator(login_required)
154			def dispatch(self, args, *kwargs):
155			return super(TriggerServiceMixin, self).dispatch(args, *kwargs)
156
157			def get_queryset(self):
158			# get the trigger of the connected user
159			if self.request.user.is_authenticated():
160			return self.queryset.filter(user=self.request.user,
161			id=self.kwargs.get('pk'))
162			# otherwise return nothing
163			return TriggerService.objects.none()
164
165
166			class TriggerUpdateView(TriggerServiceMixin, UpdateView):
167			"""
168			Form to update description
169			"""
170			form_class = TriggerServiceForm
171			template_name = "triggers/edit_description_trigger.html"
172			success_url = reverse_lazy("trigger_edit_thanks")
173
174			def get_context_data(self, **kw):
175			return super(TriggerUpdateView, self).get_context_data(**kw)
176
177			def get(self, args, *kwargs):
178			# Go through keyword arguments, and either save their values to our
179			# instance, or raise an error.
180			self.object = self.get_object()
181			status = can_modify_trigger(self.request,
182			self.object.provider.name.status,
183			self.object.consumer.name.status)
184			if status:
185			return HttpResponseRedirect(reverse('base'))
186			else:
187			return super(TriggerUpdateView, self).get(
188			self.request, args, *kwargs)
189
190
191			class TriggerEditedTemplateView(TemplateView):
192			"""
193			just a simple form to say thanks :P
194			"""
195			template_name = "triggers/edited_thanks_trigger.html"
196
197
198			class TriggerDeleteView(TriggerServiceMixin, DeleteView):
199			"""
200			page to delete a trigger
201			"""
202			template_name = "triggers/delete_trigger.html"
203			success_url = reverse_lazy("trigger_delete_thanks")
204
205
206			class TriggerDeletedTemplateView(TemplateView):
207			"""
208			just a simple form to say thanks :P
209			"""
210			template_name = "triggers/deleted_thanks_trigger.html"
211

foxmask / django-th

Push — master ( b389e4...004307 )

TriggerEditedTemplateView.get_context_data() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like