TriggerServiceMixin.dispatch() - Code Metrics - foxmask/django-th - Measure and Improve Code Quality continuously with Scrutinizer

TriggerServiceMixin.dispatch() A
last analyzed 2017-10-09 22:02 UTC

↳ Parent: TriggerServiceMixin

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

# coding: utf-8
from __future__ import unicode_literals

from django.core.cache import caches
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

try:
    from django.urls import reverse, reverse_lazy
except ImportError:  # Django 1.9 and earlier
    from django.core.urlresolvers import reverse, reverse_lazy

# 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']

"""
   Part I : Triggers
"""


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
        """
        return settings.DJANGO_TH.get('paginate_by', self.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, **kwargs):
        """
            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(**kwargs)

        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
        context['fire'] = settings.DJANGO_TH.get('fire', False)

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

foxmask / django-th

TriggerServiceMixin.dispatch() A last analyzed 2017-10-09 22:02 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

TriggerServiceMixin.dispatch() A
last analyzed 2017-10-09 22:02 UTC