StatisticsView.get_initial() - Code Metrics - Inspection of "Bump version: 0.3.2 → 0.3.3" - Crystalnix/omaha-server - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 67eae9...f0f1ec )

unknown

created 2016-04-07 06:56 UTC

StatisticsView.get_initial() A

↳ Parent: StatisticsDetailView

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Metric	Value
dl	0
loc	5
rs	9.4285
cc	1

# coding: utf8

"""
This software is licensed under the Apache 2 license, quoted below.

Copyright 2014 Crystalnix Limited

Licensed under the Apache License, Version 2.0 (the "License"); you may not
use this file except in compliance with the License. You may obtain a copy of
the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
License for the specific language governing permissions and limitations under
the License.
"""

import logging
import datetime
import pytz
from collections import OrderedDict

from django.contrib.admin.views.decorators import staff_member_required
from django.contrib import messages
from django.utils.decorators import method_decorator
from django.views.generic import DetailView, ListView, TemplateView
from django.views.generic.edit import FormView
from django_tables2 import SingleTableView
from django.core.urlresolvers import reverse_lazy, reverse
from django.shortcuts import get_object_or_404
from django.http import Http404
from django.core.cache import cache

from dynamic_preferences.forms import global_preference_form_builder
from dynamic_preferences_registry import global_preferences_manager as gpm

from omaha.models import Application, AppRequest, Version
from omaha.filters import AppRequestFilter
from omaha.utils import make_piechart
from omaha.filters import EVENT_RESULT, EVENT_TYPE
from omaha.tables import AppRequestTable, VersionsUsageTable
from omaha.forms import CrashManualCleanupForm, ManualCleanupForm
from omaha.dynamic_preferences_registry import global_preferences
from sparkle.models import SparkleVersion

logger = logging.getLogger(__name__)


STATE_CANCELLED = {
    0: 'unknown',
    1: 'init',
    2: 'waiting to check for update',
    3: 'checking for update',
    4: 'update available',
    5: 'waiting to download',
    6: 'retrying download',
    7: 'downloading',
    8: 'download complete',
    9: 'extracting',
    10: 'applying differential patch',
    11: 'ready to install',
    12: 'waiting to install',
    13: 'installing',
    14: 'install complete',
    15: 'paused',
    16: 'no update',
    17: 'error',
}


class StaffMemberRequiredMixin(object):
    @method_decorator(staff_member_required)
    def dispatch(self, *args, **kwargs):
        return super(StaffMemberRequiredMixin, self).dispatch(*args, **kwargs)


class StatisticsView(StaffMemberRequiredMixin, ListView):
    template_name = "admin/omaha/statistics.html"
    model = Application
    context_object_name = "app_list"


class StatisticsDetailView(StaffMemberRequiredMixin, DetailView):
    model = Application
    template_name = 'admin/omaha/statistics_detail.html'
    context_object_name = 'app'
    success_url = reverse_lazy('omaha_statistics_detail')

    def get_object(self, queryset=None):
        return get_object_or_404(Application, name=self.kwargs.get('name'))

    def get_context_data(self, **kwargs):
        context = super(StatisticsDetailView, self).get_context_data(**kwargs)

        app = self.object

        first_win_version = Version.objects.all().filter(app=app).order_by('created').first()
        win_start_date = getattr(first_win_version, 'created', datetime.datetime(1970, 1, 1, tzinfo=pytz.UTC))

        first_mac_version = SparkleVersion.objects.all().filter(app=app).order_by('created').first()
        mac_start_date = getattr(first_mac_version, 'created', datetime.datetime(1970, 1, 1, tzinfo=pytz.UTC))
        context['start_date'] = min(win_start_date, mac_start_date).isoformat()
        return context


class LiveStatisticsView(StaffMemberRequiredMixin, DetailView):
    model = Application
    template_name = 'admin/omaha/live_statistics.html'
    context_object_name = 'app'

    def get_object(self, queryset=None):
        return get_object_or_404(Application, name=self.kwargs.get('name'))

    def get_context_data(self, **kwargs):
        context = super(LiveStatisticsView, self).get_context_data(**kwargs)

        app = self.object

        context['app_name'] = app.name
        return context


class VersionsUsageView(StaffMemberRequiredMixin, SingleTableView):
    model = AppRequest
    template_name = 'admin/omaha/version_usage.html'
    context_object_name = 'version_usage'
    table_class = VersionsUsageTable

    def get_queryset(self):
        qs = super(VersionsUsageView, self).get_queryset()

        qs = qs.select_related('request', 'request__os')
        qs = qs.order_by('-request__created')
        self.appid = None

        try:
            app = Application.objects.get(name=self.kwargs.get('name'))
            qs = qs.filter(appid=app.id)
            self.appid = app.id
        except Application.DoesNotExist:
            raise Http404

        qs = qs.filter(events__eventtype__in=[2, 3], events__eventresult=1)
        qs = qs.distinct('request__userid').order_by('request__userid', '-request__created')
        return list(qs)

    def get_context_data(self, **kwargs):
        context = super(VersionsUsageView, self).get_context_data(**kwargs)
        context['app_name'] = self.kwargs.get('name')
        return context


class RequestListView(StaffMemberRequiredMixin, SingleTableView):
    model = AppRequest
    context_object_name = 'request_list'
    template_name = 'admin/omaha/request_list.html'
    table_class = AppRequestTable

    def get_queryset(self):
        qs = super(RequestListView, self).get_queryset()
        qs = qs.select_related('request', 'request__os',)
        qs = qs.prefetch_related('events')
        qs = qs.order_by('-request__created')
        self.appid = None

        try:
            app = Application.objects.get(name=self.kwargs.get('name'))
            qs = qs.filter(appid=app.id)
            self.appid = app.id
        except Application.DoesNotExist:
            raise Http404

        qs = qs.distinct()
        self.filter = AppRequestFilter(self.request.GET, queryset=qs)
        return self.filter.qs

    def get_context_data(self, **kwargs):
        context = super(RequestListView, self).get_context_data(**kwargs)
        context['filter'] = self.filter
        context['app_name'] = self.kwargs.get('name')
        context['app_id'] = self.appid
        return context


class AppRequestDetailView(StaffMemberRequiredMixin, DetailView):
    model = AppRequest
    template_name = 'admin/omaha/request_detail.html'

    def get_queryset(self):
        qs = super(AppRequestDetailView, self).get_queryset()
        qs = qs.select_related('request', 'request__os', 'request__hw')
        qs = qs.prefetch_related('events')
        return qs

    def get_context_data(self, **kwargs):
        name = 'Unknown'
        try:
            app_req = self.get_object()
            app = Application.objects.get(id=app_req.appid)
            name = app.name
        except Application.DoesNotExist:
            logger.error('AppRequestDetailView DoesNotExist', exc_info=True, extra=dict(request=self.request))
        context = super(AppRequestDetailView, self).get_context_data(**kwargs)
        context['app_name'] = name
        context['EVENT_RESULT'] = EVENT_RESULT
        context['EVENT_TYPE'] = EVENT_TYPE
        context['STATE_CANCELLED'] = STATE_CANCELLED
        return context


class PreferenceFormView(StaffMemberRequiredMixin, FormView):
    template_name = 'admin/omaha/set_preferences.html'
    registry = global_preferences

    def get_success_url(self):
        return self.request.path

    def get_form_class(self, *args, **kwargs):
        section = self.kwargs.get('section', None)
        form_class = global_preference_form_builder(section=section)
        return form_class

    def get_context_data(self, *args, **kwargs):
        context = super(PreferenceFormView, self).get_context_data(*args, **kwargs)
        context['sections'] = self.registry.sections()
        context['sections'].sort()
        context['cur_section'] = self.kwargs.get('section')
        form = context['form']
        order_fields = ['Crash__limit_size', 'Crash__limit_storage_days', 'Crash__duplicate_number',
                        'Feedback__limit_size', 'Feedback__limit_storage_days', 'SparkleVersion__limit_size',
                        'Symbols__limit_size', 'Version__limit_size', 'Timezone__timezone']
        form.fields = OrderedDict((k, form.fields[k]) for k in order_fields if k in form.fields.keys())
        return context

    def form_valid(self, form):
        form.update_preferences()
        try:
            self.request.session['django_timezone'] = form.cleaned_data['Timezone__timezone']
        except KeyError:
            pass
        messages.add_message(self.request, messages.INFO, 'Preferences were updated')
        return super(PreferenceFormView, self).form_valid(form)


class MonitoringFormView(StaffMemberRequiredMixin, TemplateView):
    template_name = 'admin/omaha/monitoring.html'
    form_class = ManualCleanupForm
    success_url = reverse_lazy('monitoring')

    def get_context_data(self, **kwargs):
        context = super(MonitoringFormView, self).get_context_data(**kwargs)
        omaha_version_size = float(cache.get('omaha_version_size') or 0)/1073741824
        sparkle_version_size = float(cache.get('sparkle_version_size') or 0)/1073741824
        feedbacks_size = float(cache.get('feedbacks_size') or 0)/1073741824
        crashes_size = float(cache.get('crashes_size') or 0)/1073741824
        symbols_size = float(cache.get('symbols_size') or 0)/1073741824

        data = dict(
            omaha_version=dict(label='Omaha Versions', size=omaha_version_size, limit=gpm['Version__limit_size'], percent=omaha_version_size/gpm['Version__limit_size']*100),
            sparkle_version=dict(label='Sparkle Versions', size=sparkle_version_size, limit=gpm['SparkleVersion__limit_size'], percent=sparkle_version_size/gpm['SparkleVersion__limit_size']*100),
            feedbacks=dict(label='Feedbacks', size=feedbacks_size, limit=gpm['Feedback__limit_size'], percent=feedbacks_size/gpm['Feedback__limit_size']*100),
            crashes=dict(label='Crashes',  size=crashes_size, limit=gpm['Crash__limit_size'], percent=crashes_size/gpm['Crash__limit_size']*100),
            symbols=dict(label='Symbols',  size=symbols_size, limit=gpm['Symbols__limit_size'], percent=symbols_size/gpm['Symbols__limit_size']*100),
        )
        full_size = reduce(lambda res, x: res + x['size'], data.values(), 0)
        context.update(data)
        piechart = None
        if full_size:
            pie_data = [(x['label'], x['size']/full_size * 100) for x in data.values()]
            piechart = make_piechart('used_space', pie_data, unit="%")
        context.update({'used_space': piechart})
        return context


class ManualCleanupFormView(StaffMemberRequiredMixin, FormView):
    template_name = 'admin/omaha/manually_deletion.html'
    form_class = CrashManualCleanupForm

    def get_context_data(self, **kwargs):
        context = super(ManualCleanupFormView, self).get_context_data(**kwargs)
        context['tabs'] = (
            ('crash__Crash', 'Crash'),
            ('feedback__Feedback', 'Feedback'),
            ('omaha__Version', 'Omaha Version'),
            ('sparkle__SparkleVersion', 'Sparkle Version'),
            ('crash__Symbols', 'Symbols')
        )
        context['cur_tab'] = self.kwargs.get('model')
        return context

    def get_success_url(self):
        return reverse('monitoring')

    def get_initial(self):
        return {'type': self.kwargs.get('model')}

    def get_form_class(self):
        cur_tab = self.kwargs.get('model')
        if cur_tab == 'crash__Crash':
            return CrashManualCleanupForm
        if cur_tab in ('feedback__Feedback', 'omaha__Version', 'sparkle__SparkleVersion', 'crash__Symbols'):
            return ManualCleanupForm
        raise Http404

    def form_valid(self, form):
        form.cleanup()
        messages.add_message(self.request, messages.INFO, 'Task was added in queue. Execution can take a long time. Check results on Sentry after a while.')
        return super(ManualCleanupFormView, self).form_valid(form)


1			# coding: utf8
2
3			"""
4			This software is licensed under the Apache 2 license, quoted below.
5
6			Copyright 2014 Crystalnix Limited
7
8			Licensed under the Apache License, Version 2.0 (the "License"); you may not
9			use this file except in compliance with the License. You may obtain a copy of
10			the License at
11
12			http://www.apache.org/licenses/LICENSE-2.0
13
14			Unless required by applicable law or agreed to in writing, software
15			distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
16			WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
17			License for the specific language governing permissions and limitations under
18			the License.
19			"""
20
21			import logging
22			import datetime
23			import pytz
24			from collections import OrderedDict
25
26			from django.contrib.admin.views.decorators import staff_member_required
27			from django.contrib import messages
28			from django.utils.decorators import method_decorator
29			from django.views.generic import DetailView, ListView, TemplateView
30			from django.views.generic.edit import FormView
31			from django_tables2 import SingleTableView
32			from django.core.urlresolvers import reverse_lazy, reverse
33			from django.shortcuts import get_object_or_404
34			from django.http import Http404
35			from django.core.cache import cache
36
37			from dynamic_preferences.forms import global_preference_form_builder
38			from dynamic_preferences_registry import global_preferences_manager as gpm
39
40			from omaha.models import Application, AppRequest, Version
41			from omaha.filters import AppRequestFilter
42			from omaha.utils import make_piechart
43			from omaha.filters import EVENT_RESULT, EVENT_TYPE
44			from omaha.tables import AppRequestTable, VersionsUsageTable
45			from omaha.forms import CrashManualCleanupForm, ManualCleanupForm
46			from omaha.dynamic_preferences_registry import global_preferences
47			from sparkle.models import SparkleVersion
48
49			logger = logging.getLogger(__name__)
50
51
52			STATE_CANCELLED = {
53			0: 'unknown',
54			1: 'init',
55			2: 'waiting to check for update',
56			3: 'checking for update',
57			4: 'update available',
58			5: 'waiting to download',
59			6: 'retrying download',
60			7: 'downloading',
61			8: 'download complete',
62			9: 'extracting',
63			10: 'applying differential patch',
64			11: 'ready to install',
65			12: 'waiting to install',
66			13: 'installing',
67			14: 'install complete',
68			15: 'paused',
69			16: 'no update',
70			17: 'error',
71			}
72
73
74			class StaffMemberRequiredMixin(object):
75			@method_decorator(staff_member_required)
76			def dispatch(self, args, *kwargs):
77			return super(StaffMemberRequiredMixin, self).dispatch(args, *kwargs)
78
79
80			class StatisticsView(StaffMemberRequiredMixin, ListView):
81			template_name = "admin/omaha/statistics.html"
82			model = Application
83			context_object_name = "app_list"
84
85
86			class StatisticsDetailView(StaffMemberRequiredMixin, DetailView):
87			model = Application
88			template_name = 'admin/omaha/statistics_detail.html'
89			context_object_name = 'app'
90			success_url = reverse_lazy('omaha_statistics_detail')
91
92			def get_object(self, queryset=None):
93			return get_object_or_404(Application, name=self.kwargs.get('name'))
94
95			def get_context_data(self, **kwargs):
96			context = super(StatisticsDetailView, self).get_context_data(**kwargs)
97
98			app = self.object
99
100			first_win_version = Version.objects.all().filter(app=app).order_by('created').first()
101			win_start_date = getattr(first_win_version, 'created', datetime.datetime(1970, 1, 1, tzinfo=pytz.UTC))
102
103			first_mac_version = SparkleVersion.objects.all().filter(app=app).order_by('created').first()
104			mac_start_date = getattr(first_mac_version, 'created', datetime.datetime(1970, 1, 1, tzinfo=pytz.UTC))
105			context['start_date'] = min(win_start_date, mac_start_date).isoformat()
106			return context
107
108
109			class LiveStatisticsView(StaffMemberRequiredMixin, DetailView):
110			model = Application
111			template_name = 'admin/omaha/live_statistics.html'
112			context_object_name = 'app'
113
114			def get_object(self, queryset=None):
115			return get_object_or_404(Application, name=self.kwargs.get('name'))
116
117			def get_context_data(self, **kwargs):
118			context = super(LiveStatisticsView, self).get_context_data(**kwargs)
119
120			app = self.object
121
122			context['app_name'] = app.name
123			return context
124
125
126			class VersionsUsageView(StaffMemberRequiredMixin, SingleTableView):
127			model = AppRequest
128			template_name = 'admin/omaha/version_usage.html'
129			context_object_name = 'version_usage'
130			table_class = VersionsUsageTable
131
132			def get_queryset(self):
133			qs = super(VersionsUsageView, self).get_queryset()
134
135			qs = qs.select_related('request', 'request__os')
136			qs = qs.order_by('-request__created')
137			self.appid = None
138
139			try:
140			app = Application.objects.get(name=self.kwargs.get('name'))
141			qs = qs.filter(appid=app.id)
142			self.appid = app.id
143			except Application.DoesNotExist:
144			raise Http404
145
146			qs = qs.filter(events__eventtype__in=[2, 3], events__eventresult=1)
147			qs = qs.distinct('request__userid').order_by('request__userid', '-request__created')
148			return list(qs)
149
150			def get_context_data(self, **kwargs):
151			context = super(VersionsUsageView, self).get_context_data(**kwargs)
152			context['app_name'] = self.kwargs.get('name')
153			return context
154
155
156			class RequestListView(StaffMemberRequiredMixin, SingleTableView):
157			model = AppRequest
158			context_object_name = 'request_list'
159			template_name = 'admin/omaha/request_list.html'
160			table_class = AppRequestTable
161
162			def get_queryset(self):
163			qs = super(RequestListView, self).get_queryset()
164			qs = qs.select_related('request', 'request__os',)
165			qs = qs.prefetch_related('events')
166			qs = qs.order_by('-request__created')
167			self.appid = None
168
169			try:
170			app = Application.objects.get(name=self.kwargs.get('name'))
171			qs = qs.filter(appid=app.id)
172			self.appid = app.id
173			except Application.DoesNotExist:
174			raise Http404
175
176			qs = qs.distinct()
177			self.filter = AppRequestFilter(self.request.GET, queryset=qs)
178			return self.filter.qs
179
180			def get_context_data(self, **kwargs):
181			context = super(RequestListView, self).get_context_data(**kwargs)
182			context['filter'] = self.filter
183			context['app_name'] = self.kwargs.get('name')
184			context['app_id'] = self.appid
185			return context
186
187
188			class AppRequestDetailView(StaffMemberRequiredMixin, DetailView):
189			model = AppRequest
190			template_name = 'admin/omaha/request_detail.html'
191
192			def get_queryset(self):
193			qs = super(AppRequestDetailView, self).get_queryset()
194			qs = qs.select_related('request', 'request__os', 'request__hw')
195			qs = qs.prefetch_related('events')
196			return qs
197
198			def get_context_data(self, **kwargs):
199			name = 'Unknown'
200			try:
201			app_req = self.get_object()
202			app = Application.objects.get(id=app_req.appid)
203			name = app.name
204			except Application.DoesNotExist:
205			logger.error('AppRequestDetailView DoesNotExist', exc_info=True, extra=dict(request=self.request))
206			context = super(AppRequestDetailView, self).get_context_data(**kwargs)
207			context['app_name'] = name
208			context['EVENT_RESULT'] = EVENT_RESULT
209			context['EVENT_TYPE'] = EVENT_TYPE
210			context['STATE_CANCELLED'] = STATE_CANCELLED
211			return context
212
213
214			class PreferenceFormView(StaffMemberRequiredMixin, FormView):
215			template_name = 'admin/omaha/set_preferences.html'
216			registry = global_preferences
217
218			def get_success_url(self):
219			return self.request.path
220
221			def get_form_class(self, args, *kwargs):
222			section = self.kwargs.get('section', None)
223			form_class = global_preference_form_builder(section=section)
224			return form_class
225
226			def get_context_data(self, args, *kwargs):
227			context = super(PreferenceFormView, self).get_context_data(args, *kwargs)
228			context['sections'] = self.registry.sections()
229			context['sections'].sort()
230			context['cur_section'] = self.kwargs.get('section')
231			form = context['form']
232			order_fields = ['Crash__limit_size', 'Crash__limit_storage_days', 'Crash__duplicate_number',
233			'Feedback__limit_size', 'Feedback__limit_storage_days', 'SparkleVersion__limit_size',
234			'Symbols__limit_size', 'Version__limit_size', 'Timezone__timezone']
235			form.fields = OrderedDict((k, form.fields[k]) for k in order_fields if k in form.fields.keys())
236			return context
237
238			def form_valid(self, form):
239			form.update_preferences()
240			try:
241			self.request.session['django_timezone'] = form.cleaned_data['Timezone__timezone']
242			except KeyError:
243			pass
244			messages.add_message(self.request, messages.INFO, 'Preferences were updated')
245			return super(PreferenceFormView, self).form_valid(form)
246
247
248			class MonitoringFormView(StaffMemberRequiredMixin, TemplateView):
249			template_name = 'admin/omaha/monitoring.html'
250			form_class = ManualCleanupForm
251			success_url = reverse_lazy('monitoring')
252
253			def get_context_data(self, **kwargs):
254			context = super(MonitoringFormView, self).get_context_data(**kwargs)
255			omaha_version_size = float(cache.get('omaha_version_size') or 0)/1073741824
256			sparkle_version_size = float(cache.get('sparkle_version_size') or 0)/1073741824
257			feedbacks_size = float(cache.get('feedbacks_size') or 0)/1073741824
258			crashes_size = float(cache.get('crashes_size') or 0)/1073741824
259			symbols_size = float(cache.get('symbols_size') or 0)/1073741824
260
261			data = dict(
262			omaha_version=dict(label='Omaha Versions', size=omaha_version_size, limit=gpm['Version__limit_size'], percent=omaha_version_size/gpm['Version__limit_size']*100),
263			sparkle_version=dict(label='Sparkle Versions', size=sparkle_version_size, limit=gpm['SparkleVersion__limit_size'], percent=sparkle_version_size/gpm['SparkleVersion__limit_size']*100),
264			feedbacks=dict(label='Feedbacks', size=feedbacks_size, limit=gpm['Feedback__limit_size'], percent=feedbacks_size/gpm['Feedback__limit_size']*100),
265			crashes=dict(label='Crashes', size=crashes_size, limit=gpm['Crash__limit_size'], percent=crashes_size/gpm['Crash__limit_size']*100),
266			symbols=dict(label='Symbols', size=symbols_size, limit=gpm['Symbols__limit_size'], percent=symbols_size/gpm['Symbols__limit_size']*100),
267			)
268			full_size = reduce(lambda res, x: res + x['size'], data.values(), 0)
269			context.update(data)
270			piechart = None
271			if full_size:
272			pie_data = [(x['label'], x['size']/full_size * 100) for x in data.values()]
273			piechart = make_piechart('used_space', pie_data, unit="%")
274			context.update({'used_space': piechart})
275			return context
276
277
278			class ManualCleanupFormView(StaffMemberRequiredMixin, FormView):
279			template_name = 'admin/omaha/manually_deletion.html'
280			form_class = CrashManualCleanupForm
281
282			def get_context_data(self, **kwargs):
283			context = super(ManualCleanupFormView, self).get_context_data(**kwargs)
284			context['tabs'] = (
285			('crash__Crash', 'Crash'),
286			('feedback__Feedback', 'Feedback'),
287			('omaha__Version', 'Omaha Version'),
288			('sparkle__SparkleVersion', 'Sparkle Version'),
289			('crash__Symbols', 'Symbols')
290			)
291			context['cur_tab'] = self.kwargs.get('model')
292			return context
293
294			def get_success_url(self):
295			return reverse('monitoring')
296
297			def get_initial(self):
298			return {'type': self.kwargs.get('model')}
299
300			def get_form_class(self):
301			cur_tab = self.kwargs.get('model')
302			if cur_tab == 'crash__Crash':
303			return CrashManualCleanupForm
304			if cur_tab in ('feedback__Feedback', 'omaha__Version', 'sparkle__SparkleVersion', 'crash__Symbols'):
305			return ManualCleanupForm
306			raise Http404
307
308			def form_valid(self, form):
309			form.cleanup()
310			messages.add_message(self.request, messages.INFO, 'Task was added in queue. Execution can take a long time. Check results on Sentry after a while.')
311			return super(ManualCleanupFormView, self).form_valid(form)
312

Crystalnix / omaha-server

Push — master ( 67eae9...f0f1ec )

StatisticsView.get_initial() A

Complexity

Size

Duplication

Duplication Side-by-Side

Filter issues like