workshop_update_volunteer() - Code Metrics - Inspection of "volunteer request" - pythonindia/wye - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#408)

by Vijay

created 2017-03-04 15:05 UTC

workshop_update_volunteer() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
Bugs	0	Features	4

Metric	Value
c	4
b	0
f	4
dl	0
loc	14
rs	9.2
cc	4

from django.contrib.auth.decorators import login_required
from django.views.decorators.csrf import csrf_exempt
from django.core.urlresolvers import reverse, reverse_lazy
# from django.db.models import Q
from django.contrib.sites.models import Site
from django.http import HttpResponseRedirect, JsonResponse
from django.shortcuts import get_object_or_404
from django.shortcuts import redirect, render
from django.template import loader
from django.views import generic

from braces import views
from wye.base.emailer_html import send_email_to_list
from wye.organisations.models import Organisation
from wye.profiles.models import Profile
# from wye.regions.models import RegionalLead
from wye.base.constants import WorkshopStatus

from wye.social.sites.twitter import send_tweet
from wye.base.views import verify_user_profile
from .forms import (
    WorkshopForm,
    WorkshopEditForm,
    WorkshopFeedbackForm,
    WorkshopListForm,
    WorkshopVolunteer)
from .mixins import (
    WorkshopEmailMixin,
    WorkshopAccessMixin
)
from .models import Workshop, WorkshopFeedBack


@login_required
@verify_user_profile
def workshop_list(request):
    template_name = 'workshops/workshop_list.html'
    user_profile, created = Profile.objects.get_or_create(
        user__id=request.user.id)
    if not user_profile.is_profile_filled:
        return redirect('profiles:profile-edit', slug=request.user.username)
    context_dict = {}
    workshop_list = Workshop.objects.filter(
        is_active=True).order_by('-expected_date')
    workshop_list = workshop_list.filter(
        requester__location__state__id__in=[
            x.id for x in request.user.profile.interested_states.all()]
    )

    location_list = request.GET.getlist("location")
    if location_list:
        workshop_list = workshop_list.filter(
            location__id__in=location_list
        )

    presenter_list = request.GET.getlist("presenter")
    if presenter_list:
        workshop_list = workshop_list.filter(
            presenter__id__in=presenter_list
        )

    workshop_level_list = request.GET.getlist("level")
    if workshop_level_list:
        workshop_list = workshop_list.filter(
            workshop_level__in=workshop_level_list
        )

    workshop_section_list = request.GET.getlist("section")
    if workshop_section_list:
        workshop_list = workshop_list.filter(
            workshop_section__id__in=workshop_section_list
        )

    status_list = request.GET.getlist("status")
    if status_list:
        workshop_list = workshop_list.filter(
            status__in=status_list
        )

    context_dict['workshop_list'] = workshop_list
    context_dict['user'] = request.user
    # need to improve the part
    context_dict['is_not_tutor'] = False
    # as user can be tutor and regional lead hence we need to verify like
    # this
    if (Profile.is_regional_lead(request.user) or
            Profile.is_organiser(request.user) or
            Profile.is_admin(request.user)):
        context_dict['is_not_tutor'] = True
    context_dict['form'] = WorkshopListForm(user=request.user)

    return render(request, template_name, context_dict)


def workshop_details(request, pk):
    template_name = 'workshops/workshop_detail.html'
    workshop_obj = get_object_or_404(Workshop, id=pk)
    show_contact_flag = False
    display_edit_button = False
    user = request.user
    user_is_presenter = [u for u in workshop_obj.presenter.all() if user == u]
    user_is_requester = [
        u for u in workshop_obj.requester.user.all() if user == u]
    if (user_is_presenter or user_is_requester or
            user.is_superuser or (
                (not user.is_anonymous()) and Profile.is_coordinator(user))):
        show_contact_flag = True
    if (user_is_presenter):
        display_edit_button = True

    form = WorkshopVolunteer(initial={'number_of_volunteers': workshop_obj.number_of_volunteers or 0})

    context_dict = {
        'workshop': workshop_obj,
        'show_contact_flag': show_contact_flag,
        'display_edit_button': display_edit_button,
        'form': form
    }
    return render(request, template_name, context_dict)


@login_required
@verify_user_profile
def workshop_create(request):
    template_name = 'workshops/workshop_create.html'
    context_dict = {}
    if not Organisation.list_user_organisations(request.user).exists():
        msg = """
                To request workshop you need to create organisaiton.\n\n
                Please use organisation tab above to create your organisation
            """
        return render(request, 'error.html', {'message': msg})
    if request.method == 'GET':
        form = WorkshopForm(user=request.user)
        context_dict['form'] = form
        return render(request, template_name, context_dict)
    form = WorkshopForm(user=request.user, data=request.POST)
    if not form.is_valid():
        context_dict['form'] = form
        context_dict['errors'] = form.errors
        return render(request, template_name, context_dict)
    workshop = form.save()
    domain = Site.objects.get_current().domain
    context = {
        'workshop': workshop,
        'date': workshop.expected_date,
        'workshop_url': domain + '/workshop/{}/'.format(workshop.id)
    }
    # Collage POC and admin email
    poc_admin_user = Profile.get_user_with_type(
        user_type=['Collage POC', 'admin']
    ).values_list('email', flat=True)

    org_user_emails = workshop.requester.user.filter(
        is_active=True).values_list('email', flat=True)
    # all presenter if any
    all_presenter_email = workshop.presenter.values_list(
        'email', flat=True)
    # List of tutor who have shown interest in that location
    region_interested_member = Profile.objects.filter(
        interested_locations=workshop.requester.location,
        usertype__slug='tutor'
    ).values_list('user__email', flat=True)
    all_email = []
    all_email.extend(org_user_emails)
    all_email.extend(all_presenter_email)
    all_email.extend(poc_admin_user)
    all_email.extend(region_interested_member)
    all_email = set(all_email)
    send_tweet(context)

    subject = '[PythonExpress] Workshop request status.'
    email_body = loader.get_template(
        'email_messages/workshop/create_workshop/message.html').render(context)
    text_body = loader.get_template(
        'email_messages/workshop/create_workshop/message.txt').render(context)
    send_email_to_list(
        subject,
        body=email_body,
        users_list=all_email,
        text_body=text_body)
    success_url = reverse_lazy('workshops:workshop_list')
    return HttpResponseRedirect(success_url)


class WorkshopUpdate(views.LoginRequiredMixin, WorkshopAccessMixin,
                     generic.UpdateView):
    model = Workshop
    form_class = WorkshopEditForm
    template_name = 'workshops/workshop_update.html'

    def get_success_url(self):
        # pk = self.kwargs.get(self.pk_url_kwarg, None)
        self.success_url = reverse("workshops:workshop_list")
        return super(WorkshopUpdate, self).get_success_url()

    def get_initial(self):
        return {
            "requester": self.object.requester.name,
        }

    def get_form_kwargs(self):
        kwargs = super(WorkshopUpdate, self).get_form_kwargs()
        kwargs['request'] = self.request
        return kwargs


class WorkshopToggleActive(views.LoginRequiredMixin, views.CsrfExemptMixin,
                           views.JSONResponseMixin, WorkshopAccessMixin,
                           generic.UpdateView):
    model = Workshop
    fields = ('is_active', 'id')

    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)


class WorkshopAction(views.CsrfExemptMixin, views.LoginRequiredMixin,
                     views.JSONResponseMixin, WorkshopEmailMixin,
                     generic.UpdateView):

    model = Workshop
    email_dir = 'email_messages/workshop/assign_me/'

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

        if response['status'] and response.get('notify') is not None:
            self.send_mail(request.user, response['assigned'])
            del response['notify']
        return self.render_json_response(response)

    def send_mail(self, user, assigned):
        """Send email to presenter and org users."""

        workshop = self.object
        context = {
            'presenter': True,
            'assigned': assigned,
            'date': workshop.expected_date,
            'presenter_name': user.username,
            'workshop_organization': workshop.requester,
            'workshop_url': self.request.build_absolute_uri(reverse(
                'workshops:workshop_detail', args=[workshop.pk]
            ))
        }
        # email to presenter and group
        self.send_mail_to_presenter(user, context)
        context['presenter'] = False
        self.send_mail_to_group(context, exclude_emails=[user.email])


# class WorkshopFeedbackView(views.LoginRequiredMixin,
#                            generic.FormView):
#     form_class = WorkshopFeedbackForm
#     template_name = "workshops/workshop_feedback.html"
#     success_url = reverse_lazy('workshops:workshop_list')

#     def form_valid(self, form):
#         workshop_id = self.kwargs.get('pk')
#         form.save(self.request.user, workshop_id)
#         return super(WorkshopFeedbackView, self).form_valid(form)

#     def get_context_data(self, *args, **kwargs):
#         context = super(WorkshopFeedbackView, self).get_context_data(
#             *args, **kwargs)
#         context['workshop'] = Workshop.objects.get(pk=self.kwargs.get('pk'))
#         return context


@login_required
def workshop_feedback_view(request, pk):
    context_dict = {}
    template_name = "workshops/workshop_feedback.html"
    context_dict['workshop'] = Workshop.objects.get(pk=pk)
    if request.method == 'POST':
        form = WorkshopFeedbackForm(
            data=request.POST, user=request.user, id=pk)
        if form.is_valid():
            WorkshopFeedBack.save_feedback(
                request.user, pk, **request.POST)
            success_url = reverse_lazy('workshops:workshop_list')
            return HttpResponseRedirect(success_url)
        context_dict['form'] = form
        context_dict['user'] = request.user
        return render(request, template_name, context_dict)
    else:
        context_dict['form'] = WorkshopFeedbackForm(
            user=request.user, id=pk)
    context_dict['user'] = request.user
    return render(request, template_name, context_dict)


def upcoming_workshops(request):
    template_name = 'upcoming.html'
    workshop_list = Workshop.objects.filter(is_active=True).filter(
        status__in=[WorkshopStatus.REQUESTED,
                    WorkshopStatus.ACCEPTED]).order_by('expected_date')
    context_dict = {}
    context_dict['workshop_list'] = workshop_list

    return render(request, template_name, context_dict)


@csrf_exempt
@login_required
def workshop_update_volunteer(request, pk):
    if request.GET:
        return JsonResponse({"items": range(1, 6)})

    if request.POST:
        volunteers = request.POST.get('number_of_volunteers')

        if volunteers.strip() not in ('', None):
            workshop_volunteer = Workshop.objects.filter(pk=pk)
            workshop_volunteer.update(number_of_volunteers=volunteers)
            return JsonResponse({"status": True, "msg": "Updated successfully"})
    return JsonResponse({"status": False, "msg": "Somthing went wrong"})


@csrf_exempt
@login_required
def workshop_accept_as_volunteer(request, pk):
    if request.method == 'POST':
        workshop = Workshop.objects.get(pk=pk)
        user = request.user

        if workshop.number_of_volunteers == 0:
            return JsonResponse({
                "status": False,
                "msg": "Volunteer not request for this workshop."})
        elif workshop.number_of_volunteers - workshop.volunteer.count() >= 1:
            # Check if already registered
            if user in workshop.volunteer.all():
                return JsonResponse({
                    "status": False,
                    "msg": "You are already registered as volunteer."})
            else:
                workshop.volunteer.add(user)
                return JsonResponse({
                    "status": True,
                    "msg": "Registered successfully."})
        else:
            return JsonResponse({
                "status": False,
                "msg": "Unable to register you, as requirement already fulfilled"})
    return JsonResponse({"status": False, "msg": "Something went wrong"})


@csrf_exempt
@login_required
def workshop_opt_out_as_volunteer(request, pk):
    if request.method == 'POST':
        workshop = Workshop.objects.get(pk=pk)
        user = request.user

        if user in workshop.volunteer.all():
            # remove volunteer
            workshop.volunteer.remove(user)

            workshop.save()
            return JsonResponse({
                "status": True,
                "msg": "Opt-out successfully."})
        else:
            return JsonResponse({
                "status": False,
                "msg": "You are not registered as volunteer."})
    return JsonResponse({"status": False, "msg": "Something went wrong"})


1			from django.contrib.auth.decorators import login_required
2			from django.views.decorators.csrf import csrf_exempt
3			from django.core.urlresolvers import reverse, reverse_lazy
4			# from django.db.models import Q
5			from django.contrib.sites.models import Site
6			from django.http import HttpResponseRedirect, JsonResponse
7			from django.shortcuts import get_object_or_404
8			from django.shortcuts import redirect, render
9			from django.template import loader
10			from django.views import generic
11
12			from braces import views
13			from wye.base.emailer_html import send_email_to_list
14			from wye.organisations.models import Organisation
15			from wye.profiles.models import Profile
16			# from wye.regions.models import RegionalLead
17			from wye.base.constants import WorkshopStatus
18
19			from wye.social.sites.twitter import send_tweet
20			from wye.base.views import verify_user_profile
21			from .forms import (
22			WorkshopForm,
23			WorkshopEditForm,
24			WorkshopFeedbackForm,
25			WorkshopListForm,
26			WorkshopVolunteer)
27			from .mixins import (
28			WorkshopEmailMixin,
29			WorkshopAccessMixin
30			)
31			from .models import Workshop, WorkshopFeedBack
32
33
34			@login_required
35			@verify_user_profile
36			def workshop_list(request):
37			template_name = 'workshops/workshop_list.html'
38			user_profile, created = Profile.objects.get_or_create(
39			user__id=request.user.id)
40			if not user_profile.is_profile_filled:
41			return redirect('profiles:profile-edit', slug=request.user.username)
42			context_dict = {}
43			workshop_list = Workshop.objects.filter(
44			is_active=True).order_by('-expected_date')
45			workshop_list = workshop_list.filter(
46			requester__location__state__id__in=[
47			x.id for x in request.user.profile.interested_states.all()]
48			)
49
50			location_list = request.GET.getlist("location")
51			if location_list:
52			workshop_list = workshop_list.filter(
53			location__id__in=location_list
54			)
55
56			presenter_list = request.GET.getlist("presenter")
57			if presenter_list:
58			workshop_list = workshop_list.filter(
59			presenter__id__in=presenter_list
60			)
61
62			workshop_level_list = request.GET.getlist("level")
63			if workshop_level_list:
64			workshop_list = workshop_list.filter(
65			workshop_level__in=workshop_level_list
66			)
67
68			workshop_section_list = request.GET.getlist("section")
69			if workshop_section_list:
70			workshop_list = workshop_list.filter(
71			workshop_section__id__in=workshop_section_list
72			)
73
74			status_list = request.GET.getlist("status")
75			if status_list:
76			workshop_list = workshop_list.filter(
77			status__in=status_list
78			)
79
80			context_dict['workshop_list'] = workshop_list
81			context_dict['user'] = request.user
82			# need to improve the part
83			context_dict['is_not_tutor'] = False
84			# as user can be tutor and regional lead hence we need to verify like
85			# this
86			if (Profile.is_regional_lead(request.user) or
87			Profile.is_organiser(request.user) or
88			Profile.is_admin(request.user)):
89			context_dict['is_not_tutor'] = True
90			context_dict['form'] = WorkshopListForm(user=request.user)
91
92			return render(request, template_name, context_dict)
93
94
95			def workshop_details(request, pk):
96			template_name = 'workshops/workshop_detail.html'
97			workshop_obj = get_object_or_404(Workshop, id=pk)
98			show_contact_flag = False
99			display_edit_button = False
100			user = request.user
101			user_is_presenter = [u for u in workshop_obj.presenter.all() if user == u]
102			user_is_requester = [
103			u for u in workshop_obj.requester.user.all() if user == u]
104			if (user_is_presenter or user_is_requester or
105			user.is_superuser or (
106			(not user.is_anonymous()) and Profile.is_coordinator(user))):
107			show_contact_flag = True
108			if (user_is_presenter):
109			display_edit_button = True
110
111			form = WorkshopVolunteer(initial={'number_of_volunteers': workshop_obj.number_of_volunteers or 0})
112
113			context_dict = {
114			'workshop': workshop_obj,
115			'show_contact_flag': show_contact_flag,
116			'display_edit_button': display_edit_button,
117			'form': form
118			}
119			return render(request, template_name, context_dict)
120
121
122			@login_required
123			@verify_user_profile
124			def workshop_create(request):
125			template_name = 'workshops/workshop_create.html'
126			context_dict = {}
127			if not Organisation.list_user_organisations(request.user).exists():
128			msg = """
129			To request workshop you need to create organisaiton.\n\n
130			Please use organisation tab above to create your organisation
131			"""
132			return render(request, 'error.html', {'message': msg})
133			if request.method == 'GET':
134			form = WorkshopForm(user=request.user)
135			context_dict['form'] = form
136			return render(request, template_name, context_dict)
137			form = WorkshopForm(user=request.user, data=request.POST)
138			if not form.is_valid():
139			context_dict['form'] = form
140			context_dict['errors'] = form.errors
141			return render(request, template_name, context_dict)
142			workshop = form.save()
143			domain = Site.objects.get_current().domain
144			context = {
145			'workshop': workshop,
146			'date': workshop.expected_date,
147			'workshop_url': domain + '/workshop/{}/'.format(workshop.id)
148			}
149			# Collage POC and admin email
150			poc_admin_user = Profile.get_user_with_type(
151			user_type=['Collage POC', 'admin']
152			).values_list('email', flat=True)
153
154			org_user_emails = workshop.requester.user.filter(
155			is_active=True).values_list('email', flat=True)
156			# all presenter if any
157			all_presenter_email = workshop.presenter.values_list(
158			'email', flat=True)
159			# List of tutor who have shown interest in that location
160			region_interested_member = Profile.objects.filter(
161			interested_locations=workshop.requester.location,
162			usertype__slug='tutor'
163			).values_list('user__email', flat=True)
164			all_email = []
165			all_email.extend(org_user_emails)
166			all_email.extend(all_presenter_email)
167			all_email.extend(poc_admin_user)
168			all_email.extend(region_interested_member)
169			all_email = set(all_email)
170			send_tweet(context)
171
172			subject = '[PythonExpress] Workshop request status.'
173			email_body = loader.get_template(
174			'email_messages/workshop/create_workshop/message.html').render(context)
175			text_body = loader.get_template(
176			'email_messages/workshop/create_workshop/message.txt').render(context)
177			send_email_to_list(
178			subject,
179			body=email_body,
180			users_list=all_email,
181			text_body=text_body)
182			success_url = reverse_lazy('workshops:workshop_list')
183			return HttpResponseRedirect(success_url)
184
185
186			class WorkshopUpdate(views.LoginRequiredMixin, WorkshopAccessMixin,
187			generic.UpdateView):
188			model = Workshop
189			form_class = WorkshopEditForm
190			template_name = 'workshops/workshop_update.html'
191
192			def get_success_url(self):
193			# pk = self.kwargs.get(self.pk_url_kwarg, None)
194			self.success_url = reverse("workshops:workshop_list")
195			return super(WorkshopUpdate, self).get_success_url()
196
197			def get_initial(self):
198			return {
199			"requester": self.object.requester.name,
200			}
201
202			def get_form_kwargs(self):
203			kwargs = super(WorkshopUpdate, self).get_form_kwargs()
204			kwargs['request'] = self.request
205			return kwargs
206
207
208			class WorkshopToggleActive(views.LoginRequiredMixin, views.CsrfExemptMixin,
209			views.JSONResponseMixin, WorkshopAccessMixin,
210			generic.UpdateView):
211			model = Workshop
212			fields = ('is_active', 'id')
213
214			def post(self, request, args, *kwargs):
215			self.object = self.get_object()
216			response = self.object.toggle_active(request.user, **kwargs)
217			return self.render_json_response(response)
218
219
220			class WorkshopAction(views.CsrfExemptMixin, views.LoginRequiredMixin,
221			views.JSONResponseMixin, WorkshopEmailMixin,
222			generic.UpdateView):
223
224			model = Workshop
225			email_dir = 'email_messages/workshop/assign_me/'
226
227			def post(self, request, args, *kwargs):
228			self.object = self.get_object()
229			response = self.object.manage_action(request.user, **kwargs)
230
231			if response['status'] and response.get('notify') is not None:
232			self.send_mail(request.user, response['assigned'])
233			del response['notify']
234			return self.render_json_response(response)
235
236			def send_mail(self, user, assigned):
237			"""Send email to presenter and org users."""
238
239			workshop = self.object
240			context = {
241			'presenter': True,
242			'assigned': assigned,
243			'date': workshop.expected_date,
244			'presenter_name': user.username,
245			'workshop_organization': workshop.requester,
246			'workshop_url': self.request.build_absolute_uri(reverse(
247			'workshops:workshop_detail', args=[workshop.pk]
248			))
249			}
250			# email to presenter and group
251			self.send_mail_to_presenter(user, context)
252			context['presenter'] = False
253			self.send_mail_to_group(context, exclude_emails=[user.email])
254
255
256			# class WorkshopFeedbackView(views.LoginRequiredMixin,
257			# generic.FormView):
258			# form_class = WorkshopFeedbackForm
259			# template_name = "workshops/workshop_feedback.html"
260			# success_url = reverse_lazy('workshops:workshop_list')
261
262			# def form_valid(self, form):
263			# workshop_id = self.kwargs.get('pk')
264			# form.save(self.request.user, workshop_id)
265			# return super(WorkshopFeedbackView, self).form_valid(form)
266
267			# def get_context_data(self, args, *kwargs):
268			# context = super(WorkshopFeedbackView, self).get_context_data(
269			# args, *kwargs)
270			# context['workshop'] = Workshop.objects.get(pk=self.kwargs.get('pk'))
271			# return context
272
273
274			@login_required
275			def workshop_feedback_view(request, pk):
276			context_dict = {}
277			template_name = "workshops/workshop_feedback.html"
278			context_dict['workshop'] = Workshop.objects.get(pk=pk)
279			if request.method == 'POST':
280			form = WorkshopFeedbackForm(
281			data=request.POST, user=request.user, id=pk)
282			if form.is_valid():
283			WorkshopFeedBack.save_feedback(
284			request.user, pk, **request.POST)
285			success_url = reverse_lazy('workshops:workshop_list')
286			return HttpResponseRedirect(success_url)
287			context_dict['form'] = form
288			context_dict['user'] = request.user
289			return render(request, template_name, context_dict)
290			else:
291			context_dict['form'] = WorkshopFeedbackForm(
292			user=request.user, id=pk)
293			context_dict['user'] = request.user
294			return render(request, template_name, context_dict)
295
296
297			def upcoming_workshops(request):
298			template_name = 'upcoming.html'
299			workshop_list = Workshop.objects.filter(is_active=True).filter(
300			status__in=[WorkshopStatus.REQUESTED,
301			WorkshopStatus.ACCEPTED]).order_by('expected_date')
302			context_dict = {}
303			context_dict['workshop_list'] = workshop_list
304
305			return render(request, template_name, context_dict)
306
307
308			@csrf_exempt
309			@login_required
310			def workshop_update_volunteer(request, pk):
311			if request.GET:
312			return JsonResponse({"items": range(1, 6)})
313
314			if request.POST:
315			volunteers = request.POST.get('number_of_volunteers')
316
317			if volunteers.strip() not in ('', None):
318			workshop_volunteer = Workshop.objects.filter(pk=pk)
319			workshop_volunteer.update(number_of_volunteers=volunteers)
320			return JsonResponse({"status": True, "msg": "Updated successfully"})
321			return JsonResponse({"status": False, "msg": "Somthing went wrong"})
322
323
324			@csrf_exempt
325			@login_required
326			def workshop_accept_as_volunteer(request, pk):
327			if request.method == 'POST':
328			workshop = Workshop.objects.get(pk=pk)
329			user = request.user
330
331			if workshop.number_of_volunteers == 0:
332			return JsonResponse({
333			"status": False,
334			"msg": "Volunteer not request for this workshop."})
335			elif workshop.number_of_volunteers - workshop.volunteer.count() >= 1:
336			# Check if already registered
337			if user in workshop.volunteer.all():
338			return JsonResponse({
339			"status": False,
340			"msg": "You are already registered as volunteer."})
341			else:
342			workshop.volunteer.add(user)
343			return JsonResponse({
344			"status": True,
345			"msg": "Registered successfully."})
346			else:
347			return JsonResponse({
348			"status": False,
349			"msg": "Unable to register you, as requirement already fulfilled"})
350			return JsonResponse({"status": False, "msg": "Something went wrong"})
351
352
353			@csrf_exempt
354			@login_required
355			def workshop_opt_out_as_volunteer(request, pk):
356			if request.method == 'POST':
357			workshop = Workshop.objects.get(pk=pk)
358			user = request.user
359
360			if user in workshop.volunteer.all():
361			# remove volunteer
362			workshop.volunteer.remove(user)
363
364			workshop.save()
365			return JsonResponse({
366			"status": True,
367			"msg": "Opt-out successfully."})
368			else:
369			return JsonResponse({
370			"status": False,
371			"msg": "You are not registered as volunteer."})
372			return JsonResponse({"status": False, "msg": "Something went wrong"})
373

pythonindia / wye

Pull Request — master (#408)

workshop_update_volunteer() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like