save_room_settings() - Code Metrics - Inspection of "moved sound to roomSettings w/o file/call" - Deathangel908/pychat - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 81a5af...164adb )

by Andrew

created 2018-02-11 19:42 UTC

save_room_settings() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
dl	0
loc	11
rs	9.4285
c	0
b	0
f	0

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

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 django.core.mail import send_mail, mail_admins

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, \
	SubscriptionMessages, RoomUsers
from django.conf import settings
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)

# 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 = settings.VALIDATION_IS_OK
	except ValidationError as e:
		response = e.message
	return HttpResponse(response, content_type='text/plain')


@require_http_methods(['POST'])
@login_required_no_redirect(False)
def save_room_settings(request):
	"""
	POST only, validates email during registration
	"""
	room_id = request.POST['roomId']
	volume = request.POST['volume']
	notifications = request.POST['notifications']
	updated = RoomUsers.objects.filter(room_id=room_id, user_id=request.user.id).update(volume=volume, notifications=notifications == 'true')
	return HttpResponse(settings.VALIDATION_IS_OK if updated == 1 else "Nothing updated", content_type='text/plain')


@require_http_methods('GET')
@transaction.atomic
def get_firebase_playback(request):
	registration_id = request.META['HTTP_AUTH']
	query_sub_message = SubscriptionMessages.objects.filter(subscription__registration_id=registration_id, received=False).order_by('-message__time')[:1]
	sub_message = query_sub_message[0]
	SubscriptionMessages.objects.filter(id=sub_message.id).update(received=True)
	message = Message.objects.select_related("sender__username", "room__name").get(id=sub_message.message_id)
	data = {
		'title': message.sender.username,
		'options': {
			'body': message.content,
			'icon': md5url('images/favicon.ico'),
			'data': {
				'id': sub_message.message_id,
				'sender': message.sender.username,
				'room': message.room.name,
				'url': '/#/chat/' + str(message.room_id)
			}
		},
	}
	return HttpResponse(json.dumps(data), content_type='application/json')


def test(request):
	return HttpResponse(settings.VALIDATION_IS_OK, 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, 'inactive': False})
	return HttpResponse(settings.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 = settings.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(settings.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', 'cache_messages', 'highlight_code', 'embedded_youtube').get(id=request.user.id)
	context['suggestions'] = up.suggestions
	context['cache_messages'] = up.cache_messages
	context['highlight_code'] = up.highlight_code
	context['embedded_youtube'] = up.embedded_youtube
	context['extensionId'] = settings.EXTENSION_ID
	context['extensionUrl'] = settings.EXTENSION_INSTALL_URL
	context['defaultRoomId'] = settings.ALL_ROOM_ID
	context['manifest'] = hasattr(settings, 'FIREBASE_API_KEY')
	return render_to_response('chat.html', context, context_instance=RequestContext(request))


@login_required_no_redirect(True)
def logout(request):
	"""
	POST. Logs out into system.
	"""
	registration_id = request.POST.get('registration_id')
	if registration_id is not None:
		Subscription.objects.filter(registration_id=registration_id).delete()
	djangologout(request)
	return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')

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

Deathangel908 / pychat

Push — master ( 81a5af...164adb )

save_room_settings() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like