WorkshopVolunteer - Code Metrics - pythonindia/wye - Measure and Improve Code Quality continuously with Scrutinizer

WorkshopVolunteer A
last analyzed 2017-09-08 05:39 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	5
Duplicated Lines	0 %

Importance

Changes	3
Bugs	1	Features	2

Metric	Value
wmc	1
c	3
b	1
f	2
dl	0
loc	5
rs	10

import datetime

from django import forms
from django.conf import settings
# from django.utils.text import slugify
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError

from wye.base.constants import (
    WorkshopRatings,
    WorkshopLevel,
    WorkshopStatus,
    FeedbackType,
    YesNO)
from wye.base.widgets import CalendarWidget
from wye.organisations.models import Organisation
from wye.profiles.models import Profile
from wye.regions.models import RegionalLead, Location, State

from .models import (
    Workshop,
    WorkshopRatingValues,
    WorkshopFeedBack,
    WorkshopSections)


class WorkshopForm(forms.ModelForm):

    def __init__(self, *args, **kwargs):
        user = kwargs.pop('user')
        super(WorkshopForm, self).__init__(*args, **kwargs)
        self.fields['expected_date'] = forms.DateField(
            widget=CalendarWidget,
            input_formats=settings.ALLOWED_DATE_FORMAT)
        self.fields['requester'].queryset = self.get_organisations(user)
        self.fields[
            'workshop_section'].queryset = WorkshopSections.objects.filter(
            is_active=True)
        if not self.instance.id:
            self.fields['tutor_reimbursement_flag'].required = False
            self.fields[
                'tutor_reimbursement_flag'].widget = forms.HiddenInput()
            self.fields['comments'].required = False
            self.fields['comments'].widget = forms.HiddenInput()

    def clean_location(self):
        if "requester" not in self.cleaned_data:
            return ""

        organisation = self.cleaned_data['requester']
        return organisation.location

    def get_organisations(self, user):
        if Profile.is_admin(user):
            return Organisation.objects.all()
        elif Profile.is_regional_lead(user):
            return Organisation.objects.filter(location=user.profile.location)
        else:
            return Organisation.list_user_organisations(user)

    def clean_expected_date(self):
        date = self.cleaned_data['expected_date']
        if not (date > datetime.date.today() + datetime.timedelta(days=14)):
            raise ValidationError(
                '''Workshop request has to future date and
                 atleast 2 weeks ahead of today''')
        else:
            return date

    class Meta:
        model = Workshop
        exclude = (
            'presenter', 'created_at', 'modified_at',
            'number_of_volunteers', 'volunteer',
            'is_active', 'status',)


class WorkshopEditForm(forms.ModelForm):
    requester = forms.CharField()

    def __init__(self, request, *args, **kwargs):
        super(WorkshopEditForm, self).__init__(*args, **kwargs)
        self.fields['expected_date'] = forms.DateField(
            widget=CalendarWidget,
            input_formats=settings.ALLOWED_DATE_FORMAT)
        self.fields['requester'].widget = forms.TextInput()
        self.fields['requester'].widget.attrs['readonly'] = True
        if RegionalLead.is_regional_lead(
                request.user, self.instance.requester.location):
            self.fields['presenter'].queryset = User.objects.filter(
                profile__usertype__slug="tutor"
            )
        else:
            del self.fields['presenter']

    def clean_requester(self):
        return self.instance.requester

    class Meta:
        model = Workshop
        exclude = (
            'created_at', 'modified_at',
            'number_of_volunteers', 'volunteer',
            'is_active', 'status')


class WorkshopFeedbackForm(forms.Form):
    """
    Dynamically generates feedback form depending on questions available
    in model assigend to question_model.
    """

    question_model = WorkshopRatingValues

    def __init__(self, user, id, *args, **kwargs):
        super(WorkshopFeedbackForm, self).__init__(*args, **kwargs)
        w = Workshop.objects.get(id=id)
        if user in w.presenter.all():
            feedback_type = FeedbackType.PRESENTER
        elif user in w.requester.user.all():
            feedback_type = FeedbackType.ORGANISATION
        else:
            feedback_type = None
        questions = self.question_model.get_questions(feedback_type)

        for question in questions:
            key = "{}".format(question)
            self.fields[key] = forms.ChoiceField(
                choices=WorkshopRatings.CHOICES, required=True,
                widget=forms.RadioSelect())
            self.fields[key].label = question.name

        self.fields["comment"] = forms.CharField(widget=forms.Textarea)

    def save(self, user, workshop_id):
        print(dir(self))
        data = {k: v for k, v in self.cleaned_data.items()}
        WorkshopFeedBack.save_feedback(user, workshop_id, **data)


class WorkshopListForm(forms.Form):
    """
    Form to filter workshop list
    """
    state = forms.ModelMultipleChoiceField(
        label="Workshop Location",
        required=False,
        queryset='')

    presenter = forms.ModelMultipleChoiceField(
        label="Presenter",
        required=False,
        queryset='')

    level = forms.MultipleChoiceField(
        label="Level",
        required=False,
        choices=WorkshopLevel.CHOICES)

    section = forms.ModelMultipleChoiceField(
        label="Section",
        required=False,
        queryset='')

    status = forms.MultipleChoiceField(
        label="Status",
        required=False,
        choices=WorkshopStatus.CHOICES)

    def __init__(self, *args, **kwargs):
        user = kwargs.pop('user')
        super(WorkshopListForm, self).__init__(*args, **kwargs)
        self.fields['state'].queryset = self.get_all_locations(user)
        if Profile.is_admin(user) or Profile.is_regional_lead(user):
            self.fields['presenter'].queryset = User.objects.filter(
                profile__usertype__slug="tutor"
            )
        elif 'poc' in user.profile.get_user_type:
            self.fields['presenter'].queryset = User.objects.filter(
                profile__usertype__slug="tutor",
                profile__location__state__in=self.get_all_states(user)
            )
        else:
            del self.fields['presenter']
        self.fields['section'].queryset = WorkshopSections.objects.all()

    def get_all_locations(self, user):
        if Profile.is_admin(user):
            return Location.objects.all()
        else:
            return user.profile.interested_locations.all()

    def get_all_states(self, user):
        if Profile.is_admin(user):
            return State.objects.all()
        else:
            return user.profile.interested_states.all()


class WorkshopVolunteer(forms.Form):
    CHOICE_LIST = ((idx, idx) for idx in range(0, 6))
    number_of_volunteers = forms.ChoiceField(choices=CHOICE_LIST)
    tutor_reimbursement_flag = forms.ChoiceField(choices=YesNO.CHOICES)
    comments = forms.CharField(widget=forms.Textarea)


1			import datetime
2
3			from django import forms
4			from django.conf import settings
5			# from django.utils.text import slugify
6			from django.contrib.auth.models import User
7			from django.core.exceptions import ValidationError
8
9			from wye.base.constants import (
10			WorkshopRatings,
11			WorkshopLevel,
12			WorkshopStatus,
13			FeedbackType,
14			YesNO)
15			from wye.base.widgets import CalendarWidget
16			from wye.organisations.models import Organisation
17			from wye.profiles.models import Profile
18			from wye.regions.models import RegionalLead, Location, State
19
20			from .models import (
21			Workshop,
22			WorkshopRatingValues,
23			WorkshopFeedBack,
24			WorkshopSections)
25
26
27			class WorkshopForm(forms.ModelForm):
28
29			def __init__(self, args, *kwargs):
30			user = kwargs.pop('user')
31			super(WorkshopForm, self).__init__(args, *kwargs)
32			self.fields['expected_date'] = forms.DateField(
33			widget=CalendarWidget,
34			input_formats=settings.ALLOWED_DATE_FORMAT)
35			self.fields['requester'].queryset = self.get_organisations(user)
36			self.fields[
37			'workshop_section'].queryset = WorkshopSections.objects.filter(
38			is_active=True)
39			if not self.instance.id:
40			self.fields['tutor_reimbursement_flag'].required = False
41			self.fields[
42			'tutor_reimbursement_flag'].widget = forms.HiddenInput()
43			self.fields['comments'].required = False
44			self.fields['comments'].widget = forms.HiddenInput()
45
46			def clean_location(self):
47			if "requester" not in self.cleaned_data:
48			return ""
49
50			organisation = self.cleaned_data['requester']
51			return organisation.location
52
53			def get_organisations(self, user):
54			if Profile.is_admin(user):
55			return Organisation.objects.all()
56			elif Profile.is_regional_lead(user):
57			return Organisation.objects.filter(location=user.profile.location)
58			else:
59			return Organisation.list_user_organisations(user)
60
61			def clean_expected_date(self):
62			date = self.cleaned_data['expected_date']
63			if not (date > datetime.date.today() + datetime.timedelta(days=14)):
64			raise ValidationError(
65			'''Workshop request has to future date and
66			atleast 2 weeks ahead of today''')
67			else:
68			return date
69
70			class Meta:
71			model = Workshop
72			exclude = (
73			'presenter', 'created_at', 'modified_at',
74			'number_of_volunteers', 'volunteer',
75			'is_active', 'status',)
76
77
78			class WorkshopEditForm(forms.ModelForm):
79			requester = forms.CharField()
80
81			def __init__(self, request, args, *kwargs):
82			super(WorkshopEditForm, self).__init__(args, *kwargs)
83			self.fields['expected_date'] = forms.DateField(
84			widget=CalendarWidget,
85			input_formats=settings.ALLOWED_DATE_FORMAT)
86			self.fields['requester'].widget = forms.TextInput()
87			self.fields['requester'].widget.attrs['readonly'] = True
88			if RegionalLead.is_regional_lead(
89			request.user, self.instance.requester.location):
90			self.fields['presenter'].queryset = User.objects.filter(
91			profile__usertype__slug="tutor"
92			)
93			else:
94			del self.fields['presenter']
95
96			def clean_requester(self):
97			return self.instance.requester
98
99			class Meta:
100			model = Workshop
101			exclude = (
102			'created_at', 'modified_at',
103			'number_of_volunteers', 'volunteer',
104			'is_active', 'status')
105
106
107			class WorkshopFeedbackForm(forms.Form):
108			"""
109			Dynamically generates feedback form depending on questions available
110			in model assigend to question_model.
111			"""
112
113			question_model = WorkshopRatingValues
114
115			def __init__(self, user, id, args, *kwargs):
116			super(WorkshopFeedbackForm, self).__init__(args, *kwargs)
117			w = Workshop.objects.get(id=id)
118			if user in w.presenter.all():
119			feedback_type = FeedbackType.PRESENTER
120			elif user in w.requester.user.all():
121			feedback_type = FeedbackType.ORGANISATION
122			else:
123			feedback_type = None
124			questions = self.question_model.get_questions(feedback_type)
125
126			for question in questions:
127			key = "{}".format(question)
128			self.fields[key] = forms.ChoiceField(
129			choices=WorkshopRatings.CHOICES, required=True,
130			widget=forms.RadioSelect())
131			self.fields[key].label = question.name
132
133			self.fields["comment"] = forms.CharField(widget=forms.Textarea)
134
135			def save(self, user, workshop_id):
136			print(dir(self))
137			data = {k: v for k, v in self.cleaned_data.items()}
138			WorkshopFeedBack.save_feedback(user, workshop_id, **data)
139
140
141			class WorkshopListForm(forms.Form):
142			"""
143			Form to filter workshop list
144			"""
145			state = forms.ModelMultipleChoiceField(
146			label="Workshop Location",
147			required=False,
148			queryset='')
149
150			presenter = forms.ModelMultipleChoiceField(
151			label="Presenter",
152			required=False,
153			queryset='')
154
155			level = forms.MultipleChoiceField(
156			label="Level",
157			required=False,
158			choices=WorkshopLevel.CHOICES)
159
160			section = forms.ModelMultipleChoiceField(
161			label="Section",
162			required=False,
163			queryset='')
164
165			status = forms.MultipleChoiceField(
166			label="Status",
167			required=False,
168			choices=WorkshopStatus.CHOICES)
169
170			def __init__(self, args, *kwargs):
171			user = kwargs.pop('user')
172			super(WorkshopListForm, self).__init__(args, *kwargs)
173			self.fields['state'].queryset = self.get_all_locations(user)
174			if Profile.is_admin(user) or Profile.is_regional_lead(user):
175			self.fields['presenter'].queryset = User.objects.filter(
176			profile__usertype__slug="tutor"
177			)
178			elif 'poc' in user.profile.get_user_type:
179			self.fields['presenter'].queryset = User.objects.filter(
180			profile__usertype__slug="tutor",
181			profile__location__state__in=self.get_all_states(user)
182			)
183			else:
184			del self.fields['presenter']
185			self.fields['section'].queryset = WorkshopSections.objects.all()
186
187			def get_all_locations(self, user):
188			if Profile.is_admin(user):
189			return Location.objects.all()
190			else:
191			return user.profile.interested_locations.all()
192
193			def get_all_states(self, user):
194			if Profile.is_admin(user):
195			return State.objects.all()
196			else:
197			return user.profile.interested_states.all()
198
199
200			class WorkshopVolunteer(forms.Form):
201			CHOICE_LIST = ((idx, idx) for idx in range(0, 6))
202			number_of_volunteers = forms.ChoiceField(choices=CHOICE_LIST)
203			tutor_reimbursement_flag = forms.ChoiceField(choices=YesNO.CHOICES)
204			comments = forms.CharField(widget=forms.Textarea)
205

pythonindia / wye

WorkshopVolunteer A last analyzed 2017-09-08 05:39 UTC

Complexity

Size/Duplication

Importance

Duplication Side-by-Side

Filter issues like

WorkshopVolunteer A
last analyzed 2017-09-08 05:39 UTC