OrganisationMemberAdd.post() - Code Metrics - Inspection of "fix #168" - pythonindia/wye - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#271)

unknown

created 2016-06-03 20:34 UTC

OrganisationMemberAdd.post() B

↳ Parent: OrganisationMemberAdd

Complexity

Conditions

Size

Total Lines

119

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	1	Features	1

Metric	Value
cc	4
dl	0
loc	119
rs	8.1935
c	2
b	1
f	1

How to fix Long Method

import uuid

from django.conf import settings
from django.conf.urls import patterns, url
from django.core.urlresolvers import reverse_lazy
from django.contrib.auth.tokens import PasswordResetTokenGenerator
from django.http import Http404
from django.http.response import HttpResponseRedirect
from django.shortcuts import redirect, render
from django.template import Context, loader
from django.views import generic


from braces import views
from wye.base.emailer_html import send_email_to_id, send_email_to_list
from wye.profiles.models import Profile
from wye.regions.models import RegionalLead
from .forms import (
    OrganisationForm, OrganisationMemberAddForm,
    UserRegistrationForm
)
from .models import Organisation, User


class OrganisationList(views.LoginRequiredMixin, generic.ListView):
    model = Organisation
    template_name = 'organisation/list.html'

    def dispatch(self, request, *args, **kwargs):
        user_profile, created = Profile.objects.get_or_create(
            user__id=self.request.user.id)
        if not user_profile.get_user_type:
            return redirect('profiles:profile-edit', slug=request.user.username)
        return super(OrganisationList, self).dispatch(request, *args, **kwargs)

    def get_queryset(self):
        return Organisation.objects.filter(active=True)

    def get_context_data(self, *args, **kwargs):
        context = super(OrganisationList, self).get_context_data(
            *args, **kwargs)
        if Profile.is_organiser(self.request.user):
            context['org_created_list'] = self.get_queryset().filter(
                created_by=self.request.user)
            context['org_belongs_list'] = self.get_queryset().exclude(
                created_by=self.request.user).filter(
                user=self.request.user)
        elif Profile.is_regional_lead(self.request.user):
            regions = RegionalLead.objects.filter(leads=self.request.user)
            context['regional_org_list'] = self.get_queryset().filter(
                location__id__in=[x.location.id for x in regions])
        context['user'] = self.request.user
        # need to improve the part
        context['is_not_tutor'] = False
        # as user can be tutor and regional lead hence we need to verify like
        # this
        if (Profile.is_regional_lead(self.request.user) or
                Profile.is_organiser(self.request.user) or
                Profile.is_admin(self.request.user)):
            context['is_not_tutor'] = True
        return context


class OrganisationCreate(views.LoginRequiredMixin, generic.CreateView):
    model = Organisation
    form_class = OrganisationForm
    template_name = 'organisation/create.html'
    success_url = reverse_lazy('organisations:organisation_list')

    def post(self, request, *args, **kwargs):
        form = OrganisationForm(data=request.POST)
        if form.is_valid():
            form.instance.modified_by = request.user
            form.instance.created_by = request.user
            form.instance.save()
            form.instance.user.add(request.user)
            form.instance.save()
            host = '{}://{}'.format(settings.SITE_PROTOCOL,
                                    request.META['HTTP_HOST'])
            email_context = Context({
                'full_name': '%s %s' % (request.user.first_name,
                                        request.user.last_name),
                'org_id': form.instance.id,
                'host': host

            })
            subject = "%s organisation for region %s is created" % (
                form.instance.name, form.instance.location.name)
            email_body = loader.get_template(
                'email_messages/organisation/new.html').render(email_context)
            text_body = loader.get_template(
                'email_messages/organisation/new.txt').render(email_context)

            regional_lead = Profile.objects.filter(
                interested_locations=form.instance.location,
                usertype__slug='lead').values_list('user__email', flat=True)
            send_email_to_id(subject,
                             body=email_body,
                             email_id=request.user.email,
                             text_body=text_body)

            send_email_to_list(subject,
                               body=email_body,
                               users_list=regional_lead,
                               text_body=text_body)

            return HttpResponseRedirect(self.success_url)
        else:
            return render(request, self.template_name, {'form': form})


class OrganisationDetail(views.LoginRequiredMixin, generic.DetailView):
    model = Organisation
    template_name = 'organisation/detail.html'
    success_url = reverse_lazy('organisations:organisation_list')

    def get_queryset(self):
        return Organisation.objects.filter(
            user=self.request.user,
            id=self.kwargs['pk'])


class OrganisationUpdate(views.LoginRequiredMixin, generic.UpdateView):
    model = Organisation
    form_class = OrganisationForm
    template_name = 'organisation/edit.html'
    success_url = reverse_lazy('organisations:organisation_list')

    def get_object(self, queryset=None):
        return Organisation.objects.get(user=self.request.user, id=self.kwargs['pk'])


class OrganisationMemberAdd(views.LoginRequiredMixin, generic.UpdateView):
    model = Organisation
    form_class = OrganisationMemberAddForm
    template_name = 'organisation/member-add.html'
    success_url = reverse_lazy('organisations:organisation_list')

    def get_username(self, email):
        """
        Returns a UUID-based 'random' and unique username.

        This is required data for user models with a username field.
        """
        uuid_str = str(uuid.uuid4())
        username = email.split("@")[0]
        uuid_str = uuid_str[:30 - len(username)]
        return username + uuid_str

    def get_token(self, user, **kwargs):
        """Returns a unique token for the given user"""
        return PasswordResetTokenGenerator().make_token(user)

    def get_urls(self):
        return patterns('',
                        url(r'^(?P<user_id>[\d]+)-(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/',
                            view=self.activate_view, name="invitation_register")
                        )

    def post(self, request, *args, **kwargs):
        form = OrganisationMemberAddForm(data=request.POST)
        if form.is_valid():
            existing_user = form.cleaned_data['existing_user']
            new_user = form.cleaned_data['new_user']

            org = Organisation.objects.get(id=self.kwargs['pk'])
            host = '{}://{}'.format(settings.SITE_PROTOCOL,
                                    request.META['HTTP_HOST'])

            context = {
                'full_name': '%s %s' % (request.user.first_name,
                                        request.user.last_name),
                'org_name': org.name,
                'host': host
            }

            if existing_user:
                # add user to organisation
                user = existing_user
                org.user.add(user)
                org.save()

                # set email user's name in context
                context['new_member_name'] = '%s %s' % (user.first_name,
                                                        user.last_name)
                email_context = Context(context)

                # send mail to user being added
                subject = "You are added in %s organisation" % (
                    org.location.name)
                email_body = loader.get_template(
                    'email_messages/organisation/to_new_member_existing.html').render(
                        email_context)
                text_body = loader.get_template(
                    'email_messages/organisation/to_new_member_existing.txt').render(email_context)

                send_email_to_id(subject,
                                 body=email_body,
                                 email_id=user.email,
                                 text_body=text_body)

            elif new_user:
                # generate a random password
                random_password = User.objects.make_random_password()

                # create a user with the email from form
                user = User(username=self.get_username(new_user),
                            email=new_user,
                            password=random_password)

                # user is inactive initialy
                user.is_active = False
                user.save()

                # add the user to organisation
                org.user.add(user.id)
                org.save()

                # set the email context, the token will be used to generate a unique varification
                # link
                token = self.get_token(user)

                context['new_member_name'] = '%s' % (user.email)
                context['token'] = token
                context['user'] = user
                email_context = Context(context)

                # set the meta
                subject = "[Python Express]:You are added in %s organisation" % (
                    org.location.name)
                email_body = loader.get_template(
                    'email_messages/organisation/to_new_member.html').render(email_context)
                text_body = loader.get_template(
                    'email_messages/organisation/to_new_member.txt').render(email_context)

                # send the mail to new user
                send_email_to_id(subject,
                                 body=email_body,
                                 email_id=new_user,
                                 text_body=text_body)

            # These mails will be sent in both cases.
            subject = "user %s %s added in %s organisation" % (
                user.first_name, user.last_name, org.location.name)
            email_body = loader.get_template(
                'email_messages/organisation/member_addition_to_user.html').render(
                    email_context)
            text_body = loader.get_template(
                'email_messages/organisation/member_addition_to_user.txt').render(
                    email_context)

            # send mail to the user who added the new member
            send_email_to_id(subject,
                             body=email_body,
                             email_id=request.user.email,
                             text_body=text_body)

            regional_lead = Profile.objects.filter(
                interested_locations=org.location,
                usertype__slug='lead').values_list('user__email', flat=True)

            email_body = loader.get_template(
                'email_messages/organisation/member_addition_to_lead.html').render(
                    email_context)
            text_body = loader.get_template(
                'email_messages/organisation/member_addition_to_lead.txt').render(
                    email_context)

            # send mail to the regional leads
            send_email_to_list(subject,
                               body=email_body,
                               users_list=regional_lead,
                               text_body=text_body)

            return HttpResponseRedirect(self.success_url)

        else:
            return render(request, self.template_name, {'form': form})


def activate_view(request, user_id, token):
    """
    View function that activates the given User by setting `is_active` to
    true if the provided information is verified.
    """
    try:
        user = User.objects.get(id=user_id, is_active=False)
    except(User.DoesNotExist):
        raise Http404("Your URL may have expired.")

    if not PasswordResetTokenGenerator().check_token(user, token):
        raise Http404("Your URL may have expired.")

    form = UserRegistrationForm(data=request.POST or None, instance=user)
    if form.is_valid():
        user.is_active = True
        user.username = form.cleaned_data['username']
        user.first_name = form.cleaned_data['first_name']
        user.last_name = form.cleaned_data['last_name']
        user.set_password(form.cleaned_data['password'])
        user.save()
        return redirect(reverse_lazy('organisations:organisation_list'))
    else:
        return render(request, 'organisation/register_form.html',
                      {'form': form})


class OrganisationDeactive(views.CsrfExemptMixin,
                           views.LoginRequiredMixin,
                           views.JSONResponseMixin,
                           generic.UpdateView):
    model = Organisation
    fields = ('active', 'id')

    def get_object(self, queryset=None):
        return Organisation.objects.get(user=self.request.user,
                                        id=self.kwargs['pk'])

    def post(self, request, *args, **kwargs):
        self.object = self.get_object()
        response = self.object.toggle_active(request.user, **kwargs)
        return self.render_json_response(response)


1			import uuid
2
3			from django.conf import settings
4			from django.conf.urls import patterns, url
5			from django.core.urlresolvers import reverse_lazy
6			from django.contrib.auth.tokens import PasswordResetTokenGenerator
7			from django.http import Http404
8			from django.http.response import HttpResponseRedirect
9			from django.shortcuts import redirect, render
10			from django.template import Context, loader
11			from django.views import generic
12
13
14			from braces import views
15			from wye.base.emailer_html import send_email_to_id, send_email_to_list
16			from wye.profiles.models import Profile
17			from wye.regions.models import RegionalLead
18			from .forms import (
19			OrganisationForm, OrganisationMemberAddForm,
20			UserRegistrationForm
21			)
22			from .models import Organisation, User
23
24
25			class OrganisationList(views.LoginRequiredMixin, generic.ListView):
26			model = Organisation
27			template_name = 'organisation/list.html'
28
29			def dispatch(self, request, args, *kwargs):
30			user_profile, created = Profile.objects.get_or_create(
31			user__id=self.request.user.id)
32			if not user_profile.get_user_type:
33			return redirect('profiles:profile-edit', slug=request.user.username)
34			return super(OrganisationList, self).dispatch(request, args, *kwargs)
35
36			def get_queryset(self):
37			return Organisation.objects.filter(active=True)
38
39			def get_context_data(self, args, *kwargs):
40			context = super(OrganisationList, self).get_context_data(
41			args, *kwargs)
42			if Profile.is_organiser(self.request.user):
43			context['org_created_list'] = self.get_queryset().filter(
44			created_by=self.request.user)
45			context['org_belongs_list'] = self.get_queryset().exclude(
46			created_by=self.request.user).filter(
47			user=self.request.user)
48			elif Profile.is_regional_lead(self.request.user):
49			regions = RegionalLead.objects.filter(leads=self.request.user)
50			context['regional_org_list'] = self.get_queryset().filter(
51			location__id__in=[x.location.id for x in regions])
52			context['user'] = self.request.user
53			# need to improve the part
54			context['is_not_tutor'] = False
55			# as user can be tutor and regional lead hence we need to verify like
56			# this
57			if (Profile.is_regional_lead(self.request.user) or
58			Profile.is_organiser(self.request.user) or
59			Profile.is_admin(self.request.user)):
60			context['is_not_tutor'] = True
61			return context
62
63
64			class OrganisationCreate(views.LoginRequiredMixin, generic.CreateView):
65			model = Organisation
66			form_class = OrganisationForm
67			template_name = 'organisation/create.html'
68			success_url = reverse_lazy('organisations:organisation_list')
69
70			def post(self, request, args, *kwargs):
71			form = OrganisationForm(data=request.POST)
72			if form.is_valid():
73			form.instance.modified_by = request.user
74			form.instance.created_by = request.user
75			form.instance.save()
76			form.instance.user.add(request.user)
77			form.instance.save()
78			host = '{}://{}'.format(settings.SITE_PROTOCOL,
79			request.META['HTTP_HOST'])
80			email_context = Context({
81			'full_name': '%s %s' % (request.user.first_name,
82			request.user.last_name),
83			'org_id': form.instance.id,
84			'host': host
85
86			})
87			subject = "%s organisation for region %s is created" % (
88			form.instance.name, form.instance.location.name)
89			email_body = loader.get_template(
90			'email_messages/organisation/new.html').render(email_context)
91			text_body = loader.get_template(
92			'email_messages/organisation/new.txt').render(email_context)
93
94			regional_lead = Profile.objects.filter(
95			interested_locations=form.instance.location,
96			usertype__slug='lead').values_list('user__email', flat=True)
97			send_email_to_id(subject,
98			body=email_body,
99			email_id=request.user.email,
100			text_body=text_body)
101
102			send_email_to_list(subject,
103			body=email_body,
104			users_list=regional_lead,
105			text_body=text_body)
106
107			return HttpResponseRedirect(self.success_url)
108			else:
109			return render(request, self.template_name, {'form': form})
110
111
112			class OrganisationDetail(views.LoginRequiredMixin, generic.DetailView):
113			model = Organisation
114			template_name = 'organisation/detail.html'
115			success_url = reverse_lazy('organisations:organisation_list')
116
117			def get_queryset(self):
118			return Organisation.objects.filter(
119			user=self.request.user,
120			id=self.kwargs['pk'])
121
122
123			class OrganisationUpdate(views.LoginRequiredMixin, generic.UpdateView):
124			model = Organisation
125			form_class = OrganisationForm
126			template_name = 'organisation/edit.html'
127			success_url = reverse_lazy('organisations:organisation_list')
128
129			def get_object(self, queryset=None):
130			return Organisation.objects.get(user=self.request.user, id=self.kwargs['pk'])
131
132
133			class OrganisationMemberAdd(views.LoginRequiredMixin, generic.UpdateView):
134			model = Organisation
135			form_class = OrganisationMemberAddForm
136			template_name = 'organisation/member-add.html'
137			success_url = reverse_lazy('organisations:organisation_list')
138
139			def get_username(self, email):
140			"""
141			Returns a UUID-based 'random' and unique username.
142
143			This is required data for user models with a username field.
144			"""
145			uuid_str = str(uuid.uuid4())
146			username = email.split("@")[0]
147			uuid_str = uuid_str[:30 - len(username)]
148			return username + uuid_str
149
150			def get_token(self, user, **kwargs):
151			"""Returns a unique token for the given user"""
152			return PasswordResetTokenGenerator().make_token(user)
153
154			def get_urls(self):
155			return patterns('',
156			url(r'^(?P<user_id>[\d]+)-(?P<token>[0-9A-Za-z]{1,13}-[0-9A-Za-z]{1,20})/',
157			view=self.activate_view, name="invitation_register")
158			)
159
160			def post(self, request, args, *kwargs):
161			form = OrganisationMemberAddForm(data=request.POST)
162			if form.is_valid():
163			existing_user = form.cleaned_data['existing_user']
164			new_user = form.cleaned_data['new_user']
165
166			org = Organisation.objects.get(id=self.kwargs['pk'])
167			host = '{}://{}'.format(settings.SITE_PROTOCOL,
168			request.META['HTTP_HOST'])
169
170			context = {
171			'full_name': '%s %s' % (request.user.first_name,
172			request.user.last_name),
173			'org_name': org.name,
174			'host': host
175			}
176
177			if existing_user:
178			# add user to organisation
179			user = existing_user
180			org.user.add(user)
181			org.save()
182
183			# set email user's name in context
184			context['new_member_name'] = '%s %s' % (user.first_name,
185			user.last_name)
186			email_context = Context(context)
187
188			# send mail to user being added
189			subject = "You are added in %s organisation" % (
190			org.location.name)
191			email_body = loader.get_template(
192			'email_messages/organisation/to_new_member_existing.html').render(
193			email_context)
194			text_body = loader.get_template(
195			'email_messages/organisation/to_new_member_existing.txt').render(email_context)
196
197			send_email_to_id(subject,
198			body=email_body,
199			email_id=user.email,
200			text_body=text_body)
201
202			elif new_user:
203			# generate a random password
204			random_password = User.objects.make_random_password()
205
206			# create a user with the email from form
207			user = User(username=self.get_username(new_user),
208			email=new_user,
209			password=random_password)
210
211			# user is inactive initialy
212			user.is_active = False
213			user.save()
214
215			# add the user to organisation
216			org.user.add(user.id)
217			org.save()
218
219			# set the email context, the token will be used to generate a unique varification
220			# link
221			token = self.get_token(user)
222
223			context['new_member_name'] = '%s' % (user.email)
224			context['token'] = token
225			context['user'] = user
226			email_context = Context(context)
227
228			# set the meta
229			subject = "[Python Express]:You are added in %s organisation" % (
230			org.location.name)
231			email_body = loader.get_template(
232			'email_messages/organisation/to_new_member.html').render(email_context)
233			text_body = loader.get_template(
234			'email_messages/organisation/to_new_member.txt').render(email_context)
235
236			# send the mail to new user
237			send_email_to_id(subject,
238			body=email_body,
239			email_id=new_user,
240			text_body=text_body)
241
242			# These mails will be sent in both cases.
243			subject = "user %s %s added in %s organisation" % (
244			user.first_name, user.last_name, org.location.name)
245			email_body = loader.get_template(
246			'email_messages/organisation/member_addition_to_user.html').render(
247			email_context)
248			text_body = loader.get_template(
249			'email_messages/organisation/member_addition_to_user.txt').render(
250			email_context)
251
252			# send mail to the user who added the new member
253			send_email_to_id(subject,
254			body=email_body,
255			email_id=request.user.email,
256			text_body=text_body)
257
258			regional_lead = Profile.objects.filter(
259			interested_locations=org.location,
260			usertype__slug='lead').values_list('user__email', flat=True)
261
262			email_body = loader.get_template(
263			'email_messages/organisation/member_addition_to_lead.html').render(
264			email_context)
265			text_body = loader.get_template(
266			'email_messages/organisation/member_addition_to_lead.txt').render(
267			email_context)
268
269			# send mail to the regional leads
270			send_email_to_list(subject,
271			body=email_body,
272			users_list=regional_lead,
273			text_body=text_body)
274
275			return HttpResponseRedirect(self.success_url)
276
277			else:
278			return render(request, self.template_name, {'form': form})
279
280
281			def activate_view(request, user_id, token):
282			"""
283			View function that activates the given User by setting `is_active` to
284			true if the provided information is verified.
285			"""
286			try:
287			user = User.objects.get(id=user_id, is_active=False)
288			except(User.DoesNotExist):
289			raise Http404("Your URL may have expired.")
290
291			if not PasswordResetTokenGenerator().check_token(user, token):
292			raise Http404("Your URL may have expired.")
293
294			form = UserRegistrationForm(data=request.POST or None, instance=user)
295			if form.is_valid():
296			user.is_active = True
297			user.username = form.cleaned_data['username']
298			user.first_name = form.cleaned_data['first_name']
299			user.last_name = form.cleaned_data['last_name']
300			user.set_password(form.cleaned_data['password'])
301			user.save()
302			return redirect(reverse_lazy('organisations:organisation_list'))
303			else:
304			return render(request, 'organisation/register_form.html',
305			{'form': form})
306
307
308			class OrganisationDeactive(views.CsrfExemptMixin,
309			views.LoginRequiredMixin,
310			views.JSONResponseMixin,
311			generic.UpdateView):
312			model = Organisation
313			fields = ('active', 'id')
314
315			def get_object(self, queryset=None):
316			return Organisation.objects.get(user=self.request.user,
317			id=self.kwargs['pk'])
318
319			def post(self, request, args, *kwargs):
320			self.object = self.get_object()
321			response = self.object.toggle_active(request.user, **kwargs)
322			return self.render_json_response(response)
323

pythonindia / wye

Pull Request — master (#271)

OrganisationMemberAdd.post() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like