fire_trigger() - Code Metrics - Inspection of "Fix #77 launch one trigger from its list of trigge..." - foxmask/django-th - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( e8ec91...4c727f )

by Fox

created 2016-10-09 21:47 UTC

fire_trigger() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	0

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

# coding: utf-8
from __future__ import unicode_literals

import arrow
# django
from django.core import management
from django.core.cache import caches
from django.core.urlresolvers import reverse_lazy, reverse
from django.conf import settings
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.contrib.auth import logout
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
from django.utils.translation import ugettext as _


# trigger_happy
from django_th.models import TriggerService, UserService, ServicesActivated
from django_th.tools import get_service
from django_th.forms.base import TriggerServiceForm

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

"""
   Part I : Trigger Part
"""

# ************************
#  FBV : simple actions  *
# ************************


def can_modify_trigger(request, provider, consumer):
    # do not permit to edit the details of one trigger
    # if the provider or consumer is disabled
    if provider and consumer:
        return False
    else:
        from django.contrib import messages
        messages.warning(request, 'You cant modify a disabled trigger')
        return True


def logout_view(request):
    """
        logout the user then redirect him to the home page
    """
    logout(request)
    return HttpResponseRedirect(reverse('base'))


def trigger_on_off(request, trigger_id):
    """
        enable/disable the status of the trigger then go back home
        :param request: request object
        :param trigger_id: the trigger ID to switch the status to True or False
        :type request: HttpRequest object
        :type trigger_id: int
        :return render
        :rtype HttpResponse
    """
    now = arrow.utcnow().to(settings.TIME_ZONE).format(
        'YYYY-MM-DD HH:mm:ssZZ')
    trigger = get_object_or_404(TriggerService, pk=trigger_id)
    if trigger.status:
        title = 'disabled'
        title_trigger = _('Set this trigger on')
        btn = 'success'
        trigger.status = False
    else:
        title = _('Edit your service')
        title_trigger = _('Set this trigger off')
        btn = 'primary'
        trigger.status = True
        # set the trigger to the current date when the
        # the trigger is back online
        trigger.date_triggered = now
    trigger.save()

    return render(request, 'triggers/trigger_line.html',
                           {'trigger': trigger,
                            'title': title,
                            'title_trigger': title_trigger,
                            'btn': btn})


def fire_trigger(request, trigger_id):
    """
        start the handling of only ONE trigger
        :param request: request object
        :param trigger_id: the trigger ID to switch the status to True or False
        :type request: HttpRequest object
        :type trigger_id: int
        :return render
        :rtype HttpResponse
    """
    date = ''

    if cache.get('django_th' + '_fire_trigger_' + str(trigger_id)):
        template = 'triggers/fire_trigger_ko.html'
        trigger = TriggerService.objects.get(id=trigger_id)
        kwargs = {'trigger': trigger}
    else:
        now = arrow.utcnow().to(settings.TIME_ZONE).format(
            'YYYY-MM-DD HH:mm:ssZZ')

        cache.set('django_th' + '_fire_trigger_' + str(trigger_id), '*')
        management.call_command('read_n_pub', trigger_id=trigger_id)

        trigger = TriggerService.objects.get(id=trigger_id)
        date_result = arrow.get(trigger.date_result).to(settings.TIME_ZONE)\
            .format('YYYY-MM-DD HH:mm:ssZZ')
        date_triggered = arrow.get(trigger.date_triggered).\
            to(settings.TIME_ZONE).format('YYYY-MM-DD HH:mm:ssZZ')

        if date_result < date_triggered and date_triggered > now:
            date = '*'

        template = 'triggers/fire_trigger.html'
        kwargs = {'trigger': trigger, 'date': date}

    return render(request, template, kwargs)


def service_related_triggers_switch_to(request, user_service_id, switch):
    """
        switch the status of all the triggers related to the service,
        then go back home
        :param request: request object
        :param user_service_id: the service ID to switch the status to
        True or False of all the related trigger
        :param switch: the switch value
        :type request: HttpRequest object
        :type user_service_id: int
        :type switch: string off or on
    """
    status = True
    if switch == 'off':
        status = False

    TriggerService.objects.filter(provider__id=user_service_id).update(
        status=status)
    TriggerService.objects.filter(consumer__id=user_service_id).update(
        status=status)

    return HttpResponseRedirect(reverse('user_services'))


def trigger_switch_all_to(request, switch):
    """
        switch the status of all the "my" triggers then go back home
        :param request: request object
        :param switch: the switch value
        :type request: HttpRequest object
        :type switch: string off or on
    """
    now = arrow.utcnow().to(settings.TIME_ZONE).format('YYYY-MM-DD HH:mm:ss')
    status = True
    if switch == 'off':
        status = False
    if status:
        TriggerService.objects.filter(user=request.user).update(
            status=status, date_triggered=now)
    else:
        TriggerService.objects.filter(user=request.user).update(status=status)

    return HttpResponseRedirect(reverse('base'))


def list_services(request, step):
    """
        get the activated services added from the administrator
        :param request: request object
        :param step: the step which is proceeded
        :type request: HttpRequest object
        :type step: string
        :return the activated services added from the administrator
    """
    all_datas = []

    if step == '0':
        services = ServicesActivated.objects.filter(status=1)
    elif step == '3':
        services = ServicesActivated.objects.filter(status=1,
                                                    id__iexact=request.id)
    for class_name in services:
        all_datas.append({class_name: class_name.name.rsplit('Service', 1)[1]})

    return all_datas


def trigger_edit(request, trigger_id, edit_what):
    """
        edit the provider
        :param request: request object
        :param trigger_id: ID of the trigger to edit
        :param edit_what: edit a 'Provider' or 'Consumer' ?
        :type request: HttpRequest object
        :type trigger_id: int
        :type edit_what: string
        :return render
        :rtype HttpResponse
    """
    if edit_what not in ('Provider', 'Consumer'):
        # bad request
        return redirect('base')

    form_name = edit_what + 'Form'

    # get the trigger object
    service = TriggerService.objects.get(id=trigger_id)

    if can_modify_trigger(request,
                          service.provider.name.status,
                          service.consumer.name.status):
        return HttpResponseRedirect(reverse('base'))

    if edit_what == 'Consumer':
        my_service = service.consumer.name.name
    else:
        my_service = service.provider.name.name

    # get the service name
    service_name = str(my_service).split('Service')[1]
    # get the model of this service
    model = get_service(my_service)

    # get the data of this service linked to that trigger
    data = model.objects.get(trigger_id=trigger_id)

    template = service_name.lower() + '/edit_' + edit_what.lower() + ".html"

    if request.method == 'POST':
        form = get_service(my_service, 'forms', form_name)(
            request.POST, instance=data)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse('trigger_edit_thanks'))
    else:
        form = get_service(my_service, 'forms', form_name)(instance=data)

    context = {'description': service.description, 'edit_what': edit_what}
    return render(request, template, {'form': form, 'context': context})


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/thanks_trigger.html"

    def get_context_data(self, **kw):
        context = super(TriggerEditedTemplateView, self).get_context_data(**kw)
        context['sentence'] = 'Your trigger has been successfully modified'
        return context


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/thanks_trigger.html"

    def get_context_data(self, **kw):
        context = super(TriggerDeletedTemplateView, self).\
            get_context_data(**kw)
        context['sentence'] = 'Your trigger has been successfully deleted'
        return context


1		# coding: utf-8
2		from __future__ import unicode_literals
3
4		import arrow
5		# django
6		from django.core import management
7		from django.core.cache import caches
8		from django.core.urlresolvers import reverse_lazy, reverse
9		from django.conf import settings
10		from django.shortcuts import render, redirect, get_object_or_404
11		from django.contrib.auth.decorators import login_required
12		from django.contrib.auth import logout
13		from django.http import HttpResponseRedirect
14		from django.views.generic import TemplateView, UpdateView, ListView, DeleteView
15		from django.db.models import Q
16		from django.utils.decorators import method_decorator
17		from django.utils.translation import ugettext as _
18
19
20		# trigger_happy
21		from django_th.models import TriggerService, UserService, ServicesActivated
22		from django_th.tools import get_service
23		from django_th.forms.base import TriggerServiceForm
24
25		import logging
26		# Get an instance of a logger
27		logger = logging.getLogger(__name__)
28		cache = caches['django_th']
29
30		"""
31		Part I : Trigger Part
32		"""
33
34		# ************************
35		# FBV : simple actions *
36		# ************************
37
38
39		def can_modify_trigger(request, provider, consumer):
40		# do not permit to edit the details of one trigger
41		# if the provider or consumer is disabled
42		if provider and consumer:
43		return False
44		else:
45		from django.contrib import messages
46		messages.warning(request, 'You cant modify a disabled trigger')
47		return True
48
49
50		def logout_view(request):
51		"""
52		logout the user then redirect him to the home page
53		"""
54		logout(request)
55		return HttpResponseRedirect(reverse('base'))
56
57
58		def trigger_on_off(request, trigger_id):
59		"""
60		enable/disable the status of the trigger then go back home
61		:param request: request object
62		:param trigger_id: the trigger ID to switch the status to True or False
63		:type request: HttpRequest object
64		:type trigger_id: int
65		:return render
66		:rtype HttpResponse
67		"""
68		now = arrow.utcnow().to(settings.TIME_ZONE).format(
69		'YYYY-MM-DD HH:mm:ssZZ')
70		trigger = get_object_or_404(TriggerService, pk=trigger_id)
71		if trigger.status:
72		title = 'disabled'
73		title_trigger = _('Set this trigger on')
74		btn = 'success'
75		trigger.status = False
76		else:
77		title = _('Edit your service')
78		title_trigger = _('Set this trigger off')
79		btn = 'primary'
80		trigger.status = True
81		# set the trigger to the current date when the
82		# the trigger is back online
83		trigger.date_triggered = now
84		trigger.save()
85
86		return render(request, 'triggers/trigger_line.html',
87		{'trigger': trigger,
88		'title': title,
89		'title_trigger': title_trigger,
90		'btn': btn})
91
92
93		def fire_trigger(request, trigger_id):
94		"""
95		start the handling of only ONE trigger
96		:param request: request object
97		:param trigger_id: the trigger ID to switch the status to True or False
98		:type request: HttpRequest object
99		:type trigger_id: int
100		:return render
101		:rtype HttpResponse
102		"""
103		date = ''
104
105		if cache.get('django_th' + '_fire_trigger_' + str(trigger_id)):
106		template = 'triggers/fire_trigger_ko.html'
107		trigger = TriggerService.objects.get(id=trigger_id)
108		kwargs = {'trigger': trigger}
109		else:
110		now = arrow.utcnow().to(settings.TIME_ZONE).format(
111		'YYYY-MM-DD HH:mm:ssZZ')
112
113		cache.set('django_th' + '_fire_trigger_' + str(trigger_id), '*')
114		management.call_command('read_n_pub', trigger_id=trigger_id)
115
116		trigger = TriggerService.objects.get(id=trigger_id)
117		date_result = arrow.get(trigger.date_result).to(settings.TIME_ZONE)\
118		.format('YYYY-MM-DD HH:mm:ssZZ')
119		date_triggered = arrow.get(trigger.date_triggered).\
120		to(settings.TIME_ZONE).format('YYYY-MM-DD HH:mm:ssZZ')
121
122		if date_result < date_triggered and date_triggered > now:
123		date = '*'
124
125		template = 'triggers/fire_trigger.html'
126		kwargs = {'trigger': trigger, 'date': date}
127
128		return render(request, template, kwargs)
129
130
131		def service_related_triggers_switch_to(request, user_service_id, switch):
132		"""
133		switch the status of all the triggers related to the service,
134		then go back home
135		:param request: request object
136		:param user_service_id: the service ID to switch the status to
137		True or False of all the related trigger
138		:param switch: the switch value
139		:type request: HttpRequest object
140		:type user_service_id: int
141		:type switch: string off or on
142		"""
143		status = True
144		if switch == 'off':
145		status = False
146
147		TriggerService.objects.filter(provider__id=user_service_id).update(
148		status=status)
149		TriggerService.objects.filter(consumer__id=user_service_id).update(
150		status=status)
151
152		return HttpResponseRedirect(reverse('user_services'))
153
154
155		def trigger_switch_all_to(request, switch):
156		"""
157		switch the status of all the "my" triggers then go back home
158		:param request: request object
159		:param switch: the switch value
160		:type request: HttpRequest object
161		:type switch: string off or on
162		"""
163		now = arrow.utcnow().to(settings.TIME_ZONE).format('YYYY-MM-DD HH:mm:ss')
164		status = True
165		if switch == 'off':
166		status = False
167		if status:
168		TriggerService.objects.filter(user=request.user).update(
169		status=status, date_triggered=now)
170		else:
171		TriggerService.objects.filter(user=request.user).update(status=status)
172
173		return HttpResponseRedirect(reverse('base'))
174
175
176		def list_services(request, step):
177		"""
178		get the activated services added from the administrator
179		:param request: request object
180		:param step: the step which is proceeded
181		:type request: HttpRequest object
182		:type step: string
183		:return the activated services added from the administrator
184		"""
185		all_datas = []
186
187		if step == '0':
188		services = ServicesActivated.objects.filter(status=1)
189		elif step == '3':
190		services = ServicesActivated.objects.filter(status=1,
191		id__iexact=request.id)
192		for class_name in services:
193		all_datas.append({class_name: class_name.name.rsplit('Service', 1)[1]})
194
195		return all_datas
196
197
198		def trigger_edit(request, trigger_id, edit_what):
199		"""
200		edit the provider
201		:param request: request object
202		:param trigger_id: ID of the trigger to edit
203		:param edit_what: edit a 'Provider' or 'Consumer' ?
204		:type request: HttpRequest object
205		:type trigger_id: int
206		:type edit_what: string
207		:return render
208		:rtype HttpResponse
209		"""
210		if edit_what not in ('Provider', 'Consumer'):
211		# bad request
212		return redirect('base')
213
214		form_name = edit_what + 'Form'
215
216		# get the trigger object
217		service = TriggerService.objects.get(id=trigger_id)
218
219		if can_modify_trigger(request,
220		service.provider.name.status,
221		service.consumer.name.status):
222		return HttpResponseRedirect(reverse('base'))
223
224		if edit_what == 'Consumer':
225		my_service = service.consumer.name.name
226		else:
227		my_service = service.provider.name.name
228
229		# get the service name
230		service_name = str(my_service).split('Service')[1]
231		# get the model of this service
232		model = get_service(my_service)
233
234		# get the data of this service linked to that trigger
235		data = model.objects.get(trigger_id=trigger_id)
236
237		template = service_name.lower() + '/edit_' + edit_what.lower() + ".html"
238
239		if request.method == 'POST':
240		form = get_service(my_service, 'forms', form_name)(
241		request.POST, instance=data)
242		if form.is_valid():
243		form.save()
244		return HttpResponseRedirect(reverse('trigger_edit_thanks'))
245		else:
246		form = get_service(my_service, 'forms', form_name)(instance=data)
247
248		context = {'description': service.description, 'edit_what': edit_what}
249		return render(request, template, {'form': form, 'context': context})
250
251
252		class TriggerListView(ListView):
253		"""
254		list of Triggers
255		the list can be filtered by service
256		"""
257		context_object_name = "triggers_list"
258		queryset = TriggerService.objects.all()
259		template_name = "home.html"
260		paginate_by = 3
261
262		def get_paginate_by(self, queryset):
263		"""
264		Get the number of items to paginate by,
265		from the settings
266		"""
267		paginate_by = 3
268		if hasattr(settings, 'DJANGO_TH'):
269		if settings.DJANGO_TH.get('paginate_by'):
270		paginate_by = settings.DJANGO_TH['paginate_by']
271		return paginate_by
272
273		def get_queryset(self):
274		filtered_by = None
275		# by default, sort by date_created
276		ordered_by = (str('-date_triggered'), )
277		# get the Trigger of the connected user
278		if self.request.user.is_authenticated():
279		# if the user selected a filter, get its ID
280		if self.kwargs.get('trigger_filtered_by'):
281		filtered_by = UserService.objects.filter(
282		user=self.request.user,
283		name=self.kwargs.get('trigger_filtered_by'))[0].id
284
285		if self.kwargs.get('trigger_ordered_by'):
286		"""
287		sort by 'name' property in the related model UserService
288		"""
289		order_by = str(self.kwargs.get('trigger_ordered_by') + "__name")
290		# append to the tuple, the selected 'trigger_ordered_by'
291		# choosen in the dropdown
292		ordered_by = (order_by, ) + ordered_by
293
294		# no filter selected
295		if filtered_by is None:
296		return self.queryset.filter(user=self.request.user).order_by(
297		*ordered_by).select_related('consumer__name',
298		'provider__name')
299
300		# filter selected : display all related triggers
301		else:
302		# here the queryset will do :
303		# 1) get trigger of the connected user AND
304		# 2) get the triggers where the provider OR the consumer match
305		# the selected service
306		return self.queryset.filter(user=self.request.user).filter(
307		Q(provider=filtered_by) \|
308		Q(consumer=filtered_by)).order_by(
309		*ordered_by).select_related('consumer__name',
310		'provider__name')
311		# otherwise return nothing when user is not connected
312		return TriggerService.objects.none()
313
314		def get_context_data(self, **kw):
315		"""
316		get the data of the view
317
318		data are :
319		1) number of triggers enabled
320		2) number of triggers disabled
321		3) number of activated services
322		4) list of activated services by the connected user
323		"""
324		triggers_enabled = triggers_disabled = services_activated = ()
325
326		context = super(TriggerListView, self).get_context_data(**kw)
327
328		if self.kwargs.get('trigger_filtered_by'):
329		page_link = reverse('trigger_filter_by',
330		kwargs={'trigger_filtered_by':
331		self.kwargs.get('trigger_filtered_by')})
332		elif self.kwargs.get('trigger_ordered_by'):
333	View Code Duplication	page_link = reverse('trigger_order_by',
		0 ignored issues – show Duplication introduced 2016-09-04 17:05 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
334		kwargs={'trigger_ordered_by':
335		self.kwargs.get('trigger_ordered_by')})
336		else:
337		page_link = reverse('home')
338
339		if self.request.user.is_authenticated():
340		# get the enabled triggers
341		triggers_enabled = TriggerService.objects.filter(
342		user=self.request.user, status=1).count()
343		# get the disabled triggers
344		triggers_disabled = TriggerService.objects.filter(
345		user=self.request.user, status=0).count()
346		# get the activated services
347		user_service = UserService.objects.filter(user=self.request.user)
348		"""
349		List of triggers activated by the user
350		"""
351		context['trigger_filter_by'] = user_service
352		"""
353		number of service activated for the current user
354		"""
355		services_activated = user_service.count()
356
357		"""
358		which triggers are enabled/disabled
359		"""
360		context['nb_triggers'] = {'enabled': triggers_enabled,
361		'disabled': triggers_disabled}
362		"""
363		Number of services activated
364		"""
365		context['nb_services'] = services_activated
366
367		context['page_link'] = page_link
368
369		return context
370
371
372		class TriggerServiceMixin(object):
373		"""
374		Mixin for UpdateView and DeleteView
375		"""
376		queryset = TriggerService.objects.all()
377
378		@method_decorator(login_required)
379		def dispatch(self, args, *kwargs):
380		return super(TriggerServiceMixin, self).dispatch(args, *kwargs)
381
382		def get_queryset(self):
383		# get the trigger of the connected user
384		if self.request.user.is_authenticated():
385		return self.queryset.filter(user=self.request.user,
386		id=self.kwargs.get('pk'))
387		# otherwise return nothing
388		return TriggerService.objects.none()
389
390
391		class TriggerUpdateView(TriggerServiceMixin, UpdateView):
392		"""
393		Form to update description
394		"""
395		form_class = TriggerServiceForm
396		template_name = "triggers/edit_description_trigger.html"
397		success_url = reverse_lazy("trigger_edit_thanks")
398
399		def get_context_data(self, **kw):
400		return super(TriggerUpdateView, self).get_context_data(**kw)
401
402		def get(self, args, *kwargs):
403		# Go through keyword arguments, and either save their values to our
404		# instance, or raise an error.
405		self.object = self.get_object()
406		status = can_modify_trigger(self.request,
407		self.object.provider.name.status,
408		self.object.consumer.name.status)
409		if status:
410		return HttpResponseRedirect(reverse('base'))
411		else:
412		return super(TriggerUpdateView, self).get(
413		self.request, args, *kwargs)
414
415
416		class TriggerEditedTemplateView(TemplateView):
417		"""
418		just a simple form to say thanks :P
419		"""
420		template_name = "triggers/thanks_trigger.html"
421
422		def get_context_data(self, **kw):
423		context = super(TriggerEditedTemplateView, self).get_context_data(**kw)
424		context['sentence'] = 'Your trigger has been successfully modified'
425		return context
426
427
428		class TriggerDeleteView(TriggerServiceMixin, DeleteView):
429		"""
430		page to delete a trigger
431		"""
432		template_name = "triggers/delete_trigger.html"
433		success_url = reverse_lazy("trigger_delete_thanks")
434
435
436		class TriggerDeletedTemplateView(TemplateView):
437		"""
438		just a simple form to say thanks :P
439		"""
440		template_name = "triggers/thanks_trigger.html"
441
442		def get_context_data(self, **kw):
443		context = super(TriggerDeletedTemplateView, self).\
444		get_context_data(**kw)
445		context['sentence'] = 'Your trigger has been successfully deleted'
446		return context
447

foxmask / django-th

Push — master ( e8ec91...4c727f )

fire_trigger() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like