|
1 # -*- coding: utf-8 -*- |
|
2 from __future__ import absolute_import |
|
3 |
|
4 import cStringIO as StringIO |
|
5 import csv |
|
6 |
|
7 # django |
|
8 from django.conf import settings |
|
9 from django.shortcuts import render_to_response |
|
10 from django.template.loader import render_to_string |
|
11 from django.shortcuts import get_object_or_404 |
|
12 from django.template import RequestContext |
|
13 from django.core.urlresolvers import reverse |
|
14 from django.http import HttpResponse |
|
15 |
|
16 from django.contrib.auth.decorators import login_required |
|
17 from django.contrib.auth.forms import AuthenticationForm |
|
18 from django.contrib.auth.models import User |
|
19 from django.core.exceptions import ObjectDoesNotExist |
|
20 |
|
21 #kiwipycon |
|
22 from project.kiwipycon.utils import set_message_cookie |
|
23 from project.kiwipycon.utils import slugify |
|
24 from project.kiwipycon.user.models import UserProfile |
|
25 from project.kiwipycon.user.utils import kiwipycon_createregistrant |
|
26 from project.kiwipycon.user.forms import RegistrantForm |
|
27 from project.kiwipycon.sponsor.models import Sponsor |
|
28 from project.kiwipycon.talk.models import Talk |
|
29 |
|
30 from .models import Registration |
|
31 from .models import Wifi |
|
32 from .forms import RegistrationSubmitForm |
|
33 from .forms import RegistrationEditForm |
|
34 from .forms import RegistrationAdminSelectForm |
|
35 from .forms import WifiForm |
|
36 from .utils import send_confirmation |
|
37 |
|
38 from .forms import IC |
|
39 |
|
40 REG_TOTAL = 1000 |
|
41 |
|
42 @login_required |
|
43 def download_csv(request, |
|
44 template_name = 'registration/download-csv.html'): |
|
45 """ |
|
46 """ |
|
47 if not request.user.is_staff: |
|
48 redirect_to = reverse('kiwipycon_login') |
|
49 if request.method == "POST": |
|
50 form = RegistrationAdminSelectForm(request.POST) |
|
51 if form.is_valid(): |
|
52 conference = form.cleaned_data['by_conference'] |
|
53 tutorial = form.cleaned_data['by_tutorial'] |
|
54 sprint = form.cleaned_data['by_sprint'] |
|
55 amount = form.cleaned_data['by_amount'] |
|
56 tshirt = form.cleaned_data['by_tshirt'] |
|
57 order_by = form.cleaned_data['order_by'] |
|
58 include = form.cleaned_data['include'] |
|
59 q = Registration.objects.all() |
|
60 if conference == 'conference': |
|
61 q = q.filter(conference=True) |
|
62 elif conference == 'no conference': |
|
63 q = q.filter(conference=False) |
|
64 elif tutorial == 'tutorial': |
|
65 q = q.filter(tutorial=True) |
|
66 elif tutorial == 'no tutorial': |
|
67 q = q.filter(tutorial=False) |
|
68 if sprint == 'sprint': |
|
69 q = q.filter(sprint=True) |
|
70 if sprint == 'no sprint': |
|
71 q = q.filter(sprint=False) |
|
72 elif tshirt != 'all': |
|
73 q = q.filter(tshirt=tshirt) |
|
74 q = q.order_by('registrant__email') |
|
75 query = q.query |
|
76 results = list(q) |
|
77 if include == []: |
|
78 # default to include all fields |
|
79 include = [i[0] for i in IC] |
|
80 if results: |
|
81 response = HttpResponse(mimetype='text/csv') |
|
82 response['Content-Disposition'] = 'attachment; filename=registrations.csv' |
|
83 output = csv.writer(response) |
|
84 output.writerow([h for h in include]) |
|
85 for row in results: |
|
86 conference = row.conference == True and 'yes' or 'no' |
|
87 tutorial = row.tutorial == True and 'yes' or 'no' |
|
88 sprint = row.sprint == True and 'yes' or 'no' |
|
89 wrow = [] |
|
90 if 'Name' in include: |
|
91 wrow.append( |
|
92 row.registrant.get_full_name().encode('utf-8')) |
|
93 if 'Email' in include: |
|
94 wrow.append(row.registrant.email.encode('utf-8')) |
|
95 if 'Organisation' in include: |
|
96 wrow.append(row.organisation.encode('utf-8')) |
|
97 if 'Conference' in include: |
|
98 wrow.append(conference) |
|
99 if 'Tutorial' in include: |
|
100 wrow.append(tutorial) |
|
101 if 'Sprint' in include: |
|
102 wrow.append(sprint) |
|
103 if 'T-size' in include: |
|
104 wrow.append(row.tshirt) |
|
105 output.writerow(wrow) |
|
106 return response |
|
107 else: |
|
108 no_results = u'No results found for the query' |
|
109 |
|
110 else: |
|
111 form = RegistrationAdminSelectForm() |
|
112 return render_to_response(template_name, RequestContext(request, |
|
113 locals())) |
|
114 |
|
115 # NOT REQUIRED FOR SciPy.in |
|
116 @login_required |
|
117 def invoice(request, template_name='registration/invoice.html'): |
|
118 user = request.user |
|
119 registration = get_object_or_404(Registration, registrant=user) |
|
120 if registration.sponsor: |
|
121 redirect_to = reverse('kiwipycon_account') |
|
122 return set_message_cookie(redirect_to, |
|
123 msg = u'You are a sponsored guest, no payment required.') |
|
124 return render_to_response(template_name, RequestContext(request, |
|
125 {'registration' : registration, 'user': user})) |
|
126 |
|
127 @login_required |
|
128 def pdf_invoice(request, template_name='registration/invoice.html'): |
|
129 user = request.user |
|
130 registration = get_object_or_404(Registration, registrant=user) |
|
131 if registration.sponsor: |
|
132 redirect_to = reverse('kiwipycon_account') |
|
133 return set_message_cookie(redirect_to, |
|
134 msg = u'You are a sponsored guest, no payment required.') |
|
135 content = render_to_string(template_name, |
|
136 {'registration' : registration, 'user': user}) |
|
137 result = StringIO.StringIO() |
|
138 import ho.pisa |
|
139 pdf = ho.pisa.pisaDocument(StringIO.StringIO(content.encode("UTF-8")),result) |
|
140 if not pdf.err: |
|
141 return HttpResponse(result.getvalue(), mimetype='application/pdf') |
|
142 return HttpResponse("Gremlins ate your invoice, please try html" \ |
|
143 " version") |
|
144 |
|
145 |
|
146 def registrations(request, |
|
147 template_name='registration/registrations.html'): |
|
148 """Simple page to count registrations""" |
|
149 #registrations = Registration.objects.filter(payment=True).count() |
|
150 registrations = Registration.objects.all().count() |
|
151 return render_to_response(template_name, RequestContext(request, |
|
152 { |
|
153 'over_reg' : registrations >= REG_TOTAL and True or False, |
|
154 'registrations' : registrations})) |
|
155 |
|
156 @login_required |
|
157 def edit_registration(request, id, |
|
158 template_name='registration/edit-registration.html'): |
|
159 '''Allows users that submitted a registration to edit it. |
|
160 ''' |
|
161 reg = Registration.objects.get(pk=id) |
|
162 |
|
163 if reg.registrant != request.user: |
|
164 redirect_to = reverse('kiwipycon_account') |
|
165 return set_message_cookie(redirect_to, |
|
166 msg = u'Redirected because the registration you selected' \ |
|
167 + ' is not your own.') |
|
168 |
|
169 if request.method == 'POST': |
|
170 form = RegistrationEditForm(data=request.POST) |
|
171 if form.is_valid(): |
|
172 reg.organisation = form.data.get('organisation') |
|
173 reg.occupation = form.data.get('occupation') |
|
174 reg.city = form.data.get('city') |
|
175 reg.tshirt = form.data.get('tshirt') |
|
176 reg.allow_contact = form.data.get('allow_contact') and True or False |
|
177 reg.conference = form.data.get('conference') and True or False |
|
178 reg.tutorial = form.data.get('tutorial') and True or False |
|
179 reg.sprint = form.data.get('sprint') and True or False |
|
180 reg.save() |
|
181 # Saved.. redirect |
|
182 redirect_to = reverse('kiwipycon_account') |
|
183 return set_message_cookie(redirect_to, |
|
184 msg = u'Your changes have been saved.') |
|
185 else: |
|
186 form = RegistrationEditForm(initial={ |
|
187 'id' : id, |
|
188 'organisation' : reg.organisation, |
|
189 'occupation' : reg.occupation, |
|
190 'city' : reg.city, |
|
191 'tshirt' : reg.tshirt, |
|
192 'conference': reg.conference, |
|
193 'tutorial': reg.tutorial, |
|
194 'postcode' : reg.postcode, |
|
195 'sprint' : reg.sprint, |
|
196 'allow_contact' : reg.allow_contact, |
|
197 }) |
|
198 |
|
199 return render_to_response(template_name, RequestContext(request, locals())) |
|
200 |
|
201 def submit_registration(request, |
|
202 template_name='registration/submit-registration.html'): |
|
203 '''Allows user to edit registration |
|
204 ''' |
|
205 user = request.user |
|
206 reg_count = Registration.objects.all().count() |
|
207 if user.is_authenticated(): |
|
208 try: |
|
209 profile = user.get_profile() |
|
210 except: |
|
211 profile, new = UserProfile.objects.get_or_create(user=user) |
|
212 if new: |
|
213 profile.save() |
|
214 try: |
|
215 registration = Registration.objects.get(registrant=user) |
|
216 if registration: |
|
217 redirect_to = reverse('kiwipycon_account') |
|
218 return set_message_cookie(redirect_to, |
|
219 msg = u'You have already been registered.') |
|
220 |
|
221 except ObjectDoesNotExist: |
|
222 pass |
|
223 |
|
224 message = None |
|
225 |
|
226 if request.method == 'POST': |
|
227 registration_form = RegistrationSubmitForm(data=request.POST) |
|
228 registrant_form = RegistrantForm(data=request.POST) |
|
229 wifi_form = WifiForm(data=request.POST) |
|
230 |
|
231 if request.POST.get('action', None) == 'login': |
|
232 login_form = AuthenticationForm(data=request.POST) |
|
233 if login_form.is_valid(): |
|
234 |
|
235 from django.contrib.auth import login |
|
236 login(request, login_form.get_user()) |
|
237 |
|
238 redirect_to = reverse('kiwipycon_submit_registration') |
|
239 return set_message_cookie(redirect_to, |
|
240 msg = u'You have been logged in please continue' + \ |
|
241 'with registration.') |
|
242 |
|
243 newuser = None |
|
244 passwd = None |
|
245 if not user.is_authenticated(): |
|
246 if registrant_form.is_valid(): |
|
247 newuser = kiwipycon_createregistrant(request, registrant_form.data) |
|
248 # Log in user |
|
249 passwd = User.objects.make_random_password() |
|
250 newuser.set_password(passwd) |
|
251 newuser.save() |
|
252 from django.contrib.auth import authenticate |
|
253 user = authenticate(username=newuser.username, password=passwd) |
|
254 |
|
255 from django.contrib.auth import login |
|
256 login(request, user) |
|
257 |
|
258 newuser = user |
|
259 |
|
260 else: |
|
261 newuser = user |
|
262 |
|
263 if registration_form.is_valid() and newuser: |
|
264 allow_contact = registration_form.data.get('allow_contact') and \ |
|
265 True or False |
|
266 conference = registration_form.data.get('conference') and \ |
|
267 True or False |
|
268 tutorial = registration_form.data.get('tutorial') and \ |
|
269 True or False |
|
270 sprint = registration_form.data.get('sprint') and \ |
|
271 True or False |
|
272 |
|
273 registrant = User.objects.get(pk=newuser.id) |
|
274 |
|
275 presenter = None |
|
276 talks = Talk.objects.filter( |
|
277 speaker=registrant).filter(approved=True) |
|
278 if talks: |
|
279 for talk in talks: |
|
280 if talk.duration == '30': |
|
281 presenter = True |
|
282 elif talk.duration == '60': |
|
283 presenter = True |
|
284 |
|
285 reg = Registration( |
|
286 # slug = newuser.username, |
|
287 registrant = registrant, |
|
288 organisation = registration_form.data.get('organisation'), |
|
289 occupation = registration_form.data.get('occupation'), |
|
290 city = registration_form.data.get('city'), |
|
291 tshirt = registration_form.data.get('tshirt'), |
|
292 postcode = registration_form.cleaned_data.get('postcode'), |
|
293 allow_contact = allow_contact, |
|
294 conference = conference, |
|
295 tutorial = tutorial, |
|
296 sprint = sprint) |
|
297 reg.save() |
|
298 |
|
299 # get id and use as slug and invoice number |
|
300 id = reg.id |
|
301 slug = 'KPC09%03d' % id |
|
302 reg.slug = slug |
|
303 reg.save() |
|
304 |
|
305 # additional tasks: |
|
306 if wifi_form.is_valid(): |
|
307 wifi = wifi_form.save(registrant) |
|
308 |
|
309 # 1. include random password if we are a new user |
|
310 if passwd: |
|
311 send_confirmation(registrant, slug, password=passwd) |
|
312 else: |
|
313 # 2. send user email with registration id |
|
314 send_confirmation(registrant, slug) |
|
315 |
|
316 redirect_to = reverse('kiwipycon_registrations') |
|
317 return set_message_cookie(redirect_to, |
|
318 msg = u'Thank you, your registration has been submitted '\ |
|
319 'and an email has been sent with payment details.') |
|
320 |
|
321 else: |
|
322 registration_form = RegistrationSubmitForm() |
|
323 registrant_form = RegistrantForm() |
|
324 wifi_form = WifiForm() |
|
325 |
|
326 login_form = AuthenticationForm() |
|
327 |
|
328 |
|
329 return render_to_response(template_name, RequestContext(request, { |
|
330 'registration_form': registration_form, |
|
331 'registrant_form' : registrant_form, |
|
332 'over_reg' : reg_count >= REG_TOTAL and True or False, |
|
333 'wifi_form' : wifi_form, |
|
334 'message' : message, |
|
335 'login_form' : login_form |
|
336 })) |