get_firebase_playback() - Code Metrics - Inspection of "Fixed exception while getting firebase messages" - Deathangel908/pychat - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 500a5e...65d0f8 )

by Andrew

created 2018-01-15 17:38 UTC

get_firebase_playback() B

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
c	1
b	0
f	0
dl	0
loc	25
rs	8.8571

# -*- encoding: utf-8 -*-
import datetime
import json

import os
from django.conf import settings
from django.contrib.auth import authenticate
from django.contrib.auth import login as djangologin
from django.contrib.auth import logout as djangologout

from chat.templatetags.md5url import md5url

try:
	from django.template.context_processors import csrf
except ImportError:
	from django.core.context_processors import csrf
from django.core.exceptions import ObjectDoesNotExist, ValidationError
from django.db import transaction
from django.db.models import Count, Q, F
from django.http import Http404
from django.utils.timezone import utc
from django.http import HttpResponse
from django.http import HttpResponseRedirect
from django.shortcuts import render_to_response
from django.template import RequestContext
from django.views.decorators.http import require_http_methods
from django.views.generic import View
from chat import utils
from chat.decorators import login_required_no_redirect
from chat.forms import UserProfileForm, UserProfileReadOnlyForm
from chat.models import Issue, IssueDetails, IpAddress, UserProfile, Verification, Message, Subscription
from chat.settings import VALIDATION_IS_OK, DATE_INPUT_FORMATS_JS, logging, EXTENSION_ID, EXTENSION_INSTALL_URL, \
	ALL_ROOM_ID,  STATIC_ROOT
from chat.utils import hide_fields, check_user, check_password, check_email, extract_photo, send_sign_up_email, \
	create_user_model, check_captcha, send_reset_password_email

logger = logging.getLogger(__name__)
RECAPTCHA_SITE_KEY = getattr(settings, "RECAPTCHA_SITE_KEY", None)
RECAPTHCA_SITE_URL = getattr(settings, "RECAPTHCA_SITE_URL", None)
GOOGLE_OAUTH_2_CLIENT_ID = getattr(settings, "GOOGLE_OAUTH_2_CLIENT_ID", None)
GOOGLE_OAUTH_2_JS_URL = getattr(settings, "GOOGLE_OAUTH_2_JS_URL", None)
FACEBOOK_APP_ID = getattr(settings, "FACEBOOK_APP_ID", None)
FACEBOOK_JS_URL = getattr(settings, "FACEBOOK_JS_URL", None)
FIREBASE_API_KEY = getattr(settings, "FIREBASE_API_KEY", None)

# TODO doesn't work
def handler404(request):
	return HttpResponse("Page not found", content_type='text/plain')


@require_http_methods(['POST'])
def validate_email(request):
	"""
	POST only, validates email during registration
	"""
	email = request.POST.get('email')
	try:
		utils.check_email(email)
		response = VALIDATION_IS_OK
	except ValidationError as e:
		response = e.message
	return HttpResponse(response, content_type='text/plain')


@require_http_methods('GET')
def get_firebase_playback(request):
	registration_id = request.META['HTTP_AUTH']
	user_id = Subscription.objects.values_list('user_id', flat=True).get(registration_id=registration_id)
	off_mess = Message.objects.filter(
		id__gt=F('room__roomusers__last_read_message_id'),
		deleted=False,
		room__roomusers__user_id=user_id
	)
	d = off_mess.select_related("sender__username").order_by("-time")[:1]
	if len(d) > 0:
		message = list(d)[0]
		data = {
			'title': message.sender.username,
			'options': {
				'body': message.content,
				'icon': md5url('images/favicon.ico'),
				'data': {
					'url': '/#/chat/' + str(message.room_id)
				}
			},
		}
		return HttpResponse(json.dumps(data), content_type='application/json')
	else:
		return HttpResponse("No new messages found", content_type='text/plain')


@require_http_methods('POST')
def register_subscription(request):
	registration_id = request.POST['registration_id']
	Subscription.objects.update_or_create(registration_id=registration_id, defaults={ 'user': request.user})
	return HttpResponse(VALIDATION_IS_OK, content_type='text/plain')

@require_http_methods('POST')
def validate_user(request):
	"""
	Validates user during registration
	"""
	try:
		username = request.POST.get('username')
		utils.check_user(username)
		# hardcoded ok check in register.js
		message = VALIDATION_IS_OK
	except ValidationError as e:
		message = e.message
	return HttpResponse(message, content_type='text/plain')


def get_service_worker(request):  # this stub is only for development, this is replaced in nginx for prod
	worker = open(os.path.join(STATIC_ROOT, 'js', 'sw.js'), 'rb')
	response = HttpResponse(content=worker)
	response['Content-Type'] = 'application/javascript'
	return response

@require_http_methods('GET')
@login_required_no_redirect(False)
def home(request):
	"""
	Login or logout navbar is creates by means of create_nav_page
	@return:  the x intercept of the line M{y=m*x+b}.
	"""
	context = csrf(request)
	up = UserProfile.objects.defer('suggestions', 'notifications', 'cache_messages', 'highlight_code', 'embedded_youtube').get(id=request.user.id)
	context['suggestions'] = up.suggestions
	context['notifications'] = up.notifications
	context['cache_messages'] = up.cache_messages
	context['highlight_code'] = up.highlight_code
	context['embedded_youtube'] = up.embedded_youtube
	context['extensionId'] = EXTENSION_ID
	context['extensionUrl'] = EXTENSION_INSTALL_URL
	context['defaultRoomId'] = ALL_ROOM_ID
	context['manifest'] = FIREBASE_API_KEY is not None
	return render_to_response('chat.html', context, context_instance=RequestContext(request))


@login_required_no_redirect(True)
def logout(request):
	"""
	POST. Logs out into system.
	"""
	djangologout(request)
	return HttpResponseRedirect('/')

@require_http_methods(['POST'])
def auth(request):
	"""
	Logs in into system.
	"""
	username = request.POST.get('username')
	password = request.POST.get('password')
	user = authenticate(username=username, password=password)
	if user is not None:
		djangologin(request, user)
		message = VALIDATION_IS_OK
	else:
		message = 'Login or password is wrong'
	logger.debug('Auth request %s ; Response: %s', hide_fields(request.POST, ('password',)), message)
	return HttpResponse(message, content_type='text/plain')


def send_restore_password(request):
	"""
	Sends email verification code
	"""
	logger.debug('Recover password request %s', request)
	try:
		username_or_password = request.POST.get('username_or_password')
		check_captcha(request)
		user_profile = UserProfile.objects.get(Q(username=username_or_password) | Q(email=username_or_password))
		if not user_profile.email:
			raise ValidationError("You didn't specify email address for this user")
		verification = Verification(type_enum=Verification.TypeChoices.password, user_id=user_profile.id)
		verification.save()
		send_reset_password_email(request, user_profile, verification)
		message = VALIDATION_IS_OK
		logger.debug('Verification email has been send for token %s to user %s(id=%d)',
				verification.token, user_profile.username, user_profile.id)
	except UserProfile.DoesNotExist:
		message = "User with this email or username doesn't exist"
		logger.debug("Skipping password recovery request for nonexisting user")
	except (UserProfile.DoesNotExist, ValidationError) as e:
		logger.debug('Not sending verification email because %s', e)
		message = 'Unfortunately we were not able to send you restore password email because {}'.format(e)
	return HttpResponse(message, content_type='text/plain')


def get_html_restore_pass():
	""""""

class RestorePassword(View):

	def get_user_by_code(self, token):
		"""
		:param token: token code to verify
		:type token: str
		:raises ValidationError: if token is not usable
		:return: UserProfile, Verification: if token is usable
		"""
		try:
			v = Verification.objects.get(token=token)
			if v.type_enum != Verification.TypeChoices.password:
				raise ValidationError("it's not for this operation ")
			if v.verified:
				raise ValidationError("it's already used")
			# TODO move to sql query or leave here?
			if v.time < datetime.datetime.utcnow().replace(tzinfo=utc) - datetime.timedelta(days=1):
				raise ValidationError("it's expired")
			return UserProfile.objects.get(id=v.user_id), v
		except Verification.DoesNotExist:
			raise ValidationError('Unknown verification token')

	@transaction.atomic
	def post(self, request):
		"""
		Sends email verification token
		"""
		token = request.POST.get('token', False)
		try:
			logger.debug('Proceed Recover password with token %s', token)
			user, verification = self.get_user_by_code(token)
			password = request.POST.get('password')
			check_password(password)
			user.set_password(password)
			user.save(update_fields=('password',))
			verification.verified = True
			verification.save(update_fields=('verified',))
			logger.info('Password has been change for token %s user %s(id=%d)', token, user.username, user.id)
			response = VALIDATION_IS_OK
		except ValidationError as e:
			logger.debug('Rejecting verification token %s because %s', token, e)
			response = "".join(("You can't reset password with this token because ", str(e)))
		return HttpResponse(response, content_type='text/plain')

	def get(self, request):
		token = request.GET.get('token', False)
		logger.debug('Rendering restore password page with token  %s', token)
		try:
			user = self.get_user_by_code(token)[0]
			response = {
				'message': VALIDATION_IS_OK,
				'restore_user': user.username,
				'token': token
			}
		except ValidationError as e:
			logger.debug('Rejecting verification token %s because %s', token, e)
			response = {'message': "Unable to confirm email with token {} because {}".format(token, e)}
		return render_to_response('reset_password.html', response, context_instance=RequestContext(request))


@require_http_methods('GET')
def confirm_email(request):
	"""
	Accept the verification token sent to email
	"""
	token = request.GET.get('token', False)
	logger.debug('Processing email confirm with token  %s', token)
	try:
		try:
			v = Verification.objects.get(token=token)
		except Verification.DoesNotExist:
			raise ValidationError('Unknown verification token')
		if v.type_enum != Verification.TypeChoices.register:
			raise ValidationError('This is not confirm email token')
		if v.verified:
			raise ValidationError('This verification token already accepted')
		user = UserProfile.objects.get(id=v.user_id)
		if user.email_verification_id != v.id:
			raise ValidationError('Verification token expired because you generated another one')
		v.verified = True
		v.save(update_fields=['verified'])
		message = VALIDATION_IS_OK
		logger.info('Email verification token %s has been accepted for user %s(id=%d)', token, user.username, user.id)
	except Exception as e:
		logger.debug('Rejecting verification token %s because %s', token, e)
		message = ("Unable to confirm email with token {} because {}".format(token, e))
	response = {'message': message}
	return render_to_response('confirm_mail.html', response, context_instance=RequestContext(request))


@require_http_methods('GET')
def show_profile(request, profile_id):
	try:
		user_profile = UserProfile.objects.get(pk=profile_id)
		form = UserProfileReadOnlyForm(instance=user_profile)
		form.username = user_profile.username
		return render_to_response(
			'show_profile.html',
			{'form': form},
			context_instance=RequestContext(request)
		)
	except ObjectDoesNotExist:
		raise Http404


@require_http_methods('GET')
def statistics(request):
	pie_data = IpAddress.objects.values('country').filter(country__isnull=False).annotate(count=Count("country"))
	return HttpResponse(json.dumps(list(pie_data)), content_type='application/json')


@login_required_no_redirect()
@transaction.atomic
def report_issue(request):
	logger.info('Saving issue: %s', hide_fields(request.POST, ('log',), huge=True))
	issue = Issue.objects.get_or_create(content=request.POST['issue'])[0]
	issue_details = IssueDetails(
		sender_id=request.user.id,
		browser=request.POST.get('browser'),
		issue=issue,
		log=request.POST.get('log')
	)
	issue_details.save()
	return HttpResponse(VALIDATION_IS_OK, content_type='text/plain')


class ProfileView(View):

	@login_required_no_redirect()
	def get(self, request):
		user_profile = UserProfile.objects.get(pk=request.user.id)
		form = UserProfileForm(instance=user_profile)
		c = csrf(request)
		c['form'] = form
		c['date_format'] = DATE_INPUT_FORMATS_JS
		return render_to_response('change_profile.html', c, context_instance=RequestContext(request))

	@login_required_no_redirect()
	def post(self, request):
		logger.info('Saving profile: %s', hide_fields(request.POST, ("base64_image", ), huge=True))
		user_profile = UserProfile.objects.get(pk=request.user.id)
		image_base64 = request.POST.get('base64_image')

		if image_base64 is not None:
			image = extract_photo(image_base64)
			request.FILES['photo'] = image

		form = UserProfileForm(request.POST, request.FILES, instance=user_profile)
		if form.is_valid():
			profile = form.save()
			response = profile. photo.url if 'photo' in  request.FILES else VALIDATION_IS_OK
		else:
			response = form.errors
		return HttpResponse(response, content_type='text/plain')


class RegisterView(View):

	def get(self, request):
		logger.debug(
			'Rendering register page with captcha site key %s and oauth key %s',
			RECAPTCHA_SITE_KEY, GOOGLE_OAUTH_2_CLIENT_ID
		)
		c = csrf(request)
		c['captcha_key'] = RECAPTCHA_SITE_KEY
		c['captcha_url'] = RECAPTHCA_SITE_URL
		c['oauth_url'] = GOOGLE_OAUTH_2_JS_URL
		c['oauth_token'] = GOOGLE_OAUTH_2_CLIENT_ID
		c['fb_app_id'] = FACEBOOK_APP_ID
		c['fb_js_url'] = FACEBOOK_JS_URL
		return render_to_response("register.html", c, context_instance=RequestContext(request))

	@transaction.atomic
	def post(self, request):
		try:
			rp = request.POST
			logger.info('Got register request %s', hide_fields(rp, ('password', 'repeatpassword')))
			(username, password, email) = (rp.get('username'), rp.get('password'), rp.get('email'))
			check_user(username)
			check_password(password)
			check_email(email)
			user_profile = UserProfile(username=username, email=email, sex_str=rp.get('sex'))
			user_profile.set_password(password)
			create_user_model(user_profile)
			# You must call authenticate before you can call login
			auth_user = authenticate(username=username, password=password)
			message = VALIDATION_IS_OK  # redirect
			if email:
				send_sign_up_email(user_profile, request.get_host(), request)
			djangologin(request, auth_user)
		except ValidationError as e:
			message = e.message
			logger.debug('Rejecting request because "%s"', message)
		return HttpResponse(message, content_type='text/plain')


1			# -- encoding: utf-8 --
2			import datetime
3			import json
4
5			import os
6			from django.conf import settings
7			from django.contrib.auth import authenticate
8			from django.contrib.auth import login as djangologin
9			from django.contrib.auth import logout as djangologout
10
11			from chat.templatetags.md5url import md5url
12
13			try:
14			from django.template.context_processors import csrf
15			except ImportError:
16			from django.core.context_processors import csrf
17			from django.core.exceptions import ObjectDoesNotExist, ValidationError
18			from django.db import transaction
19			from django.db.models import Count, Q, F
20			from django.http import Http404
21			from django.utils.timezone import utc
22			from django.http import HttpResponse
23			from django.http import HttpResponseRedirect
24			from django.shortcuts import render_to_response
25			from django.template import RequestContext
26			from django.views.decorators.http import require_http_methods
27			from django.views.generic import View
28			from chat import utils
29			from chat.decorators import login_required_no_redirect
30			from chat.forms import UserProfileForm, UserProfileReadOnlyForm
31			from chat.models import Issue, IssueDetails, IpAddress, UserProfile, Verification, Message, Subscription
32			from chat.settings import VALIDATION_IS_OK, DATE_INPUT_FORMATS_JS, logging, EXTENSION_ID, EXTENSION_INSTALL_URL, \
33			ALL_ROOM_ID, STATIC_ROOT
34			from chat.utils import hide_fields, check_user, check_password, check_email, extract_photo, send_sign_up_email, \
35			create_user_model, check_captcha, send_reset_password_email
36
37			logger = logging.getLogger(__name__)
38			RECAPTCHA_SITE_KEY = getattr(settings, "RECAPTCHA_SITE_KEY", None)
39			RECAPTHCA_SITE_URL = getattr(settings, "RECAPTHCA_SITE_URL", None)
40			GOOGLE_OAUTH_2_CLIENT_ID = getattr(settings, "GOOGLE_OAUTH_2_CLIENT_ID", None)
41			GOOGLE_OAUTH_2_JS_URL = getattr(settings, "GOOGLE_OAUTH_2_JS_URL", None)
42			FACEBOOK_APP_ID = getattr(settings, "FACEBOOK_APP_ID", None)
43			FACEBOOK_JS_URL = getattr(settings, "FACEBOOK_JS_URL", None)
44			FIREBASE_API_KEY = getattr(settings, "FIREBASE_API_KEY", None)
45
46			# TODO doesn't work
47			def handler404(request):
48			return HttpResponse("Page not found", content_type='text/plain')
49
50
51			@require_http_methods(['POST'])
52			def validate_email(request):
53			"""
54			POST only, validates email during registration
55			"""
56			email = request.POST.get('email')
57			try:
58			utils.check_email(email)
59			response = VALIDATION_IS_OK
60			except ValidationError as e:
61			response = e.message
62			return HttpResponse(response, content_type='text/plain')
63
64
65			@require_http_methods('GET')
66			def get_firebase_playback(request):
67			registration_id = request.META['HTTP_AUTH']
68			user_id = Subscription.objects.values_list('user_id', flat=True).get(registration_id=registration_id)
69			off_mess = Message.objects.filter(
70			id__gt=F('room__roomusers__last_read_message_id'),
71			deleted=False,
72			room__roomusers__user_id=user_id
73			)
74			d = off_mess.select_related("sender__username").order_by("-time")[:1]
75			if len(d) > 0:
76			message = list(d)[0]
77			data = {
78			'title': message.sender.username,
79			'options': {
80			'body': message.content,
81			'icon': md5url('images/favicon.ico'),
82			'data': {
83			'url': '/#/chat/' + str(message.room_id)
84			}
85			},
86			}
87			return HttpResponse(json.dumps(data), content_type='application/json')
88			else:
89			return HttpResponse("No new messages found", content_type='text/plain')
90
91
92			@require_http_methods('POST')
93			def register_subscription(request):
94			registration_id = request.POST['registration_id']
95			Subscription.objects.update_or_create(registration_id=registration_id, defaults={ 'user': request.user})
96			return HttpResponse(VALIDATION_IS_OK, content_type='text/plain')
97
98			@require_http_methods('POST')
99			def validate_user(request):
100			"""
101			Validates user during registration
102			"""
103			try:
104			username = request.POST.get('username')
105			utils.check_user(username)
106			# hardcoded ok check in register.js
107			message = VALIDATION_IS_OK
108			except ValidationError as e:
109			message = e.message
110			return HttpResponse(message, content_type='text/plain')
111
112
113			def get_service_worker(request): # this stub is only for development, this is replaced in nginx for prod
114			worker = open(os.path.join(STATIC_ROOT, 'js', 'sw.js'), 'rb')
115			response = HttpResponse(content=worker)
116			response['Content-Type'] = 'application/javascript'
117			return response
118
119			@require_http_methods('GET')
120			@login_required_no_redirect(False)
121			def home(request):
122			"""
123			Login or logout navbar is creates by means of create_nav_page
124			@return: the x intercept of the line M{y=m*x+b}.
125			"""
126			context = csrf(request)
127			up = UserProfile.objects.defer('suggestions', 'notifications', 'cache_messages', 'highlight_code', 'embedded_youtube').get(id=request.user.id)
128			context['suggestions'] = up.suggestions
129			context['notifications'] = up.notifications
130			context['cache_messages'] = up.cache_messages
131			context['highlight_code'] = up.highlight_code
132			context['embedded_youtube'] = up.embedded_youtube
133			context['extensionId'] = EXTENSION_ID
134			context['extensionUrl'] = EXTENSION_INSTALL_URL
135			context['defaultRoomId'] = ALL_ROOM_ID
136			context['manifest'] = FIREBASE_API_KEY is not None
137			return render_to_response('chat.html', context, context_instance=RequestContext(request))
138
139
140			@login_required_no_redirect(True)
141			def logout(request):
142			"""
143			POST. Logs out into system.
144			"""
145			djangologout(request)
146			return HttpResponseRedirect('/')
147
148			@require_http_methods(['POST'])
149			def auth(request):
150			"""
151			Logs in into system.
152			"""
153			username = request.POST.get('username')
154			password = request.POST.get('password')
155			user = authenticate(username=username, password=password)
156			if user is not None:
157			djangologin(request, user)
158			message = VALIDATION_IS_OK
159			else:
160			message = 'Login or password is wrong'
161			logger.debug('Auth request %s ; Response: %s', hide_fields(request.POST, ('password',)), message)
162			return HttpResponse(message, content_type='text/plain')
163
164
165			def send_restore_password(request):
166			"""
167			Sends email verification code
168			"""
169			logger.debug('Recover password request %s', request)
170			try:
171			username_or_password = request.POST.get('username_or_password')
172			check_captcha(request)
173			user_profile = UserProfile.objects.get(Q(username=username_or_password) \| Q(email=username_or_password))
174			if not user_profile.email:
175			raise ValidationError("You didn't specify email address for this user")
176			verification = Verification(type_enum=Verification.TypeChoices.password, user_id=user_profile.id)
177			verification.save()
178			send_reset_password_email(request, user_profile, verification)
179			message = VALIDATION_IS_OK
180			logger.debug('Verification email has been send for token %s to user %s(id=%d)',
181			verification.token, user_profile.username, user_profile.id)
182			except UserProfile.DoesNotExist:
183			message = "User with this email or username doesn't exist"
184			logger.debug("Skipping password recovery request for nonexisting user")
185			except (UserProfile.DoesNotExist, ValidationError) as e:
186			logger.debug('Not sending verification email because %s', e)
187			message = 'Unfortunately we were not able to send you restore password email because {}'.format(e)
188			return HttpResponse(message, content_type='text/plain')
189
190
191			def get_html_restore_pass():
192			""""""
193
194			class RestorePassword(View):
195
196			def get_user_by_code(self, token):
197			"""
198			:param token: token code to verify
199			:type token: str
200			:raises ValidationError: if token is not usable
201			:return: UserProfile, Verification: if token is usable
202			"""
203			try:
204			v = Verification.objects.get(token=token)
205			if v.type_enum != Verification.TypeChoices.password:
206			raise ValidationError("it's not for this operation ")
207			if v.verified:
208			raise ValidationError("it's already used")
209			# TODO move to sql query or leave here?
210			if v.time < datetime.datetime.utcnow().replace(tzinfo=utc) - datetime.timedelta(days=1):
211			raise ValidationError("it's expired")
212			return UserProfile.objects.get(id=v.user_id), v
213			except Verification.DoesNotExist:
214			raise ValidationError('Unknown verification token')
215
216			@transaction.atomic
217			def post(self, request):
218			"""
219			Sends email verification token
220			"""
221			token = request.POST.get('token', False)
222			try:
223			logger.debug('Proceed Recover password with token %s', token)
224			user, verification = self.get_user_by_code(token)
225			password = request.POST.get('password')
226			check_password(password)
227			user.set_password(password)
228			user.save(update_fields=('password',))
229			verification.verified = True
230			verification.save(update_fields=('verified',))
231			logger.info('Password has been change for token %s user %s(id=%d)', token, user.username, user.id)
232			response = VALIDATION_IS_OK
233			except ValidationError as e:
234			logger.debug('Rejecting verification token %s because %s', token, e)
235			response = "".join(("You can't reset password with this token because ", str(e)))
236			return HttpResponse(response, content_type='text/plain')
237
238			def get(self, request):
239			token = request.GET.get('token', False)
240			logger.debug('Rendering restore password page with token %s', token)
241			try:
242			user = self.get_user_by_code(token)[0]
243			response = {
244			'message': VALIDATION_IS_OK,
245			'restore_user': user.username,
246			'token': token
247			}
248			except ValidationError as e:
249			logger.debug('Rejecting verification token %s because %s', token, e)
250			response = {'message': "Unable to confirm email with token {} because {}".format(token, e)}
251			return render_to_response('reset_password.html', response, context_instance=RequestContext(request))
252
253
254			@require_http_methods('GET')
255			def confirm_email(request):
256			"""
257			Accept the verification token sent to email
258			"""
259			token = request.GET.get('token', False)
260			logger.debug('Processing email confirm with token %s', token)
261			try:
262			try:
263			v = Verification.objects.get(token=token)
264			except Verification.DoesNotExist:
265			raise ValidationError('Unknown verification token')
266			if v.type_enum != Verification.TypeChoices.register:
267			raise ValidationError('This is not confirm email token')
268			if v.verified:
269			raise ValidationError('This verification token already accepted')
270			user = UserProfile.objects.get(id=v.user_id)
271			if user.email_verification_id != v.id:
272			raise ValidationError('Verification token expired because you generated another one')
273			v.verified = True
274			v.save(update_fields=['verified'])
275			message = VALIDATION_IS_OK
276			logger.info('Email verification token %s has been accepted for user %s(id=%d)', token, user.username, user.id)
277			except Exception as e:
278			logger.debug('Rejecting verification token %s because %s', token, e)
279			message = ("Unable to confirm email with token {} because {}".format(token, e))
280			response = {'message': message}
281			return render_to_response('confirm_mail.html', response, context_instance=RequestContext(request))
282
283
284			@require_http_methods('GET')
285			def show_profile(request, profile_id):
286			try:
287			user_profile = UserProfile.objects.get(pk=profile_id)
288			form = UserProfileReadOnlyForm(instance=user_profile)
289			form.username = user_profile.username
290			return render_to_response(
291			'show_profile.html',
292			{'form': form},
293			context_instance=RequestContext(request)
294			)
295			except ObjectDoesNotExist:
296			raise Http404
297
298
299			@require_http_methods('GET')
300			def statistics(request):
301			pie_data = IpAddress.objects.values('country').filter(country__isnull=False).annotate(count=Count("country"))
302			return HttpResponse(json.dumps(list(pie_data)), content_type='application/json')
303
304
305			@login_required_no_redirect()
306			@transaction.atomic
307			def report_issue(request):
308			logger.info('Saving issue: %s', hide_fields(request.POST, ('log',), huge=True))
309			issue = Issue.objects.get_or_create(content=request.POST['issue'])[0]
310			issue_details = IssueDetails(
311			sender_id=request.user.id,
312			browser=request.POST.get('browser'),
313			issue=issue,
314			log=request.POST.get('log')
315			)
316			issue_details.save()
317			return HttpResponse(VALIDATION_IS_OK, content_type='text/plain')
318
319
320			class ProfileView(View):
321
322			@login_required_no_redirect()
323			def get(self, request):
324			user_profile = UserProfile.objects.get(pk=request.user.id)
325			form = UserProfileForm(instance=user_profile)
326			c = csrf(request)
327			c['form'] = form
328			c['date_format'] = DATE_INPUT_FORMATS_JS
329			return render_to_response('change_profile.html', c, context_instance=RequestContext(request))
330
331			@login_required_no_redirect()
332			def post(self, request):
333			logger.info('Saving profile: %s', hide_fields(request.POST, ("base64_image", ), huge=True))
334			user_profile = UserProfile.objects.get(pk=request.user.id)
335			image_base64 = request.POST.get('base64_image')
336
337			if image_base64 is not None:
338			image = extract_photo(image_base64)
339			request.FILES['photo'] = image
340
341			form = UserProfileForm(request.POST, request.FILES, instance=user_profile)
342			if form.is_valid():
343			profile = form.save()
344			response = profile. photo.url if 'photo' in request.FILES else VALIDATION_IS_OK
345			else:
346			response = form.errors
347			return HttpResponse(response, content_type='text/plain')
348
349
350			class RegisterView(View):
351
352			def get(self, request):
353			logger.debug(
354			'Rendering register page with captcha site key %s and oauth key %s',
355			RECAPTCHA_SITE_KEY, GOOGLE_OAUTH_2_CLIENT_ID
356			)
357			c = csrf(request)
358			c['captcha_key'] = RECAPTCHA_SITE_KEY
359			c['captcha_url'] = RECAPTHCA_SITE_URL
360			c['oauth_url'] = GOOGLE_OAUTH_2_JS_URL
361			c['oauth_token'] = GOOGLE_OAUTH_2_CLIENT_ID
362			c['fb_app_id'] = FACEBOOK_APP_ID
363			c['fb_js_url'] = FACEBOOK_JS_URL
364			return render_to_response("register.html", c, context_instance=RequestContext(request))
365
366			@transaction.atomic
367			def post(self, request):
368			try:
369			rp = request.POST
370			logger.info('Got register request %s', hide_fields(rp, ('password', 'repeatpassword')))
371			(username, password, email) = (rp.get('username'), rp.get('password'), rp.get('email'))
372			check_user(username)
373			check_password(password)
374			check_email(email)
375			user_profile = UserProfile(username=username, email=email, sex_str=rp.get('sex'))
376			user_profile.set_password(password)
377			create_user_model(user_profile)
378			# You must call authenticate before you can call login
379			auth_user = authenticate(username=username, password=password)
380			message = VALIDATION_IS_OK # redirect
381			if email:
382			send_sign_up_email(user_profile, request.get_host(), request)
383			djangologin(request, auth_user)
384			except ValidationError as e:
385			message = e.message
386			logger.debug('Rejecting request because "%s"', message)
387			return HttpResponse(message, content_type='text/plain')
388

Deathangel908 / pychat

Push — master ( 500a5e...65d0f8 )

get_firebase_playback() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like