search_messages() - Code Metrics - Inspection of "* Add search in messages" - Deathangel908/pychat - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 61004a...31a88b )

by Andrew

created 2018-04-21 16:25 UTC

search_messages() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
dl	0
loc	18
rs	9.4285
c	0
b	0
f	0

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

from django.contrib.auth import authenticate
from django.contrib.auth import login as djangologin
from django.contrib.auth import logout as djangologout
from django.contrib.auth.hashers import make_password
from django.core.mail import mail_admins

from chat.templatetags.md5url import md5url
from chat.tornado.message_creator import MessagesCreator

try:
	from django.template.context_processors import csrf
except ImportError:
	from django.core.context_processors import csrf
from django.core.exceptions import ObjectDoesNotExist, ValidationError, PermissionDenied
from django.db import transaction
from django.db.models import Count, Q
from django.http import Http404
from django.http import HttpResponse
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, validation
from chat.forms import UserProfileForm, UserProfileReadOnlyForm
from chat.models import Issue, IssueDetails, IpAddress, UserProfile, Verification, Message, Subscription, \
	SubscriptionMessages, RoomUsers, Room, UserJoinedInfo
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, get_client_ip, get_or_create_ip, \
	send_password_changed, send_email_change, send_new_email_ver, get_message_images, prepare_img

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'])
@validation
def validate_email(request):
	"""
	POST only, validates email during registration
	"""
	utils.check_email(request.POST.get('email'))
	return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')


@require_http_methods(['POST'])
@login_required_no_redirect(False)
@transaction.atomic
def save_room_settings(request):
	"""
	POST only, validates email during registration
	"""
	logger.debug('save_room_settings request,  %s', request.POST)
	room_id = request.POST['roomId']
	room_name = request.POST.get('roomName')
	updated = RoomUsers.objects.filter(room_id=room_id, user_id=request.user.id).update(
		volume=request.POST['volume'],
		notifications=request.POST['notifications'] == 'true',
	)
	if updated != 1:
		raise PermissionDenied
	if room_name is not None:
		room_name = room_name.strip()
		if room_name and int(room_id) != settings.ALL_ROOM_ID:
			Room.objects.filter(id=room_id).update(name = room_name)
	return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')


@require_http_methods('GET')
@transaction.atomic
def get_firebase_playback(request):
	registration_id = request.META['HTTP_AUTH']
	logger.debug('Firebase playback, id %s', registration_id)
	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,
				'roomId': message.room_id
			},
			'requireInteraction': True
		},
	}
	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')
@login_required_no_redirect(False)
@validation
def search_messages(request):
	import time
	time.sleep(2)
	data = request.POST['data']
	room_id = request.POST['room']
	if not RoomUsers.objects.filter(room_id=room_id, user_id=request.user.id).exists():
		raise ValidationError("You can't access this room")
	messages = Message.objects.filter(content__icontains=data, room_id=room_id)[:10]
	images = get_message_images(messages)
	result = []
	for message in messages:
		prep_m = MessagesCreator.create_message(message, prepare_img(images, message.id))
		result.append(prep_m)
	response = json.dumps(result)
	return HttpResponse(response, content_type='application/json')


@require_http_methods('POST')
def register_subscription(request):
	logger.debug('Subscription request,  %s', request)
	registration_id = request.POST['registration_id']
	agent = request.POST['agent']
	is_mobile = request.POST['is_mobile']
	ip = get_or_create_ip(get_client_ip(request), logger)
	Subscription.objects.update_or_create(
		registration_id=registration_id,
		defaults={
			'user': request.user,
			'inactive': False,
			'updated': datetime.datetime.now(),
			'agent': agent,
			'is_mobile': is_mobile == 'true',
			'ip': ip
		}
	)
	return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')

@require_http_methods('POST')
@validation
def validate_user(request):
	"""
	Validates user during registration
	"""
	utils.check_user(request.POST.get('username'))
	# hardcoded ok check in register.js
	return HttpResponse(settings.VALIDATION_IS_OK, 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)
	ip = get_client_ip(request)
	if not UserJoinedInfo.objects.filter(Q(ip__ip=ip) & Q(user=request.user)).exists():
		ip_obj = get_or_create_ip(ip, logger)
		UserJoinedInfo.objects.create(ip=ip_obj, user=request.user)
	up = UserProfile.objects.defer('suggestions', 'highlight_code', 'embedded_youtube', 'online_change_sound', 'incoming_file_call_sound', 'message_sound', 'theme').get(id=request.user.id)
	context['suggestions'] = up.suggestions
	context['highlight_code'] = up.highlight_code
	context['message_sound'] = up.message_sound
	context['incoming_file_call_sound'] = up.incoming_file_call_sound
	context['online_change_sound'] = up.online_change_sound
	context['theme'] = up.theme
	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')


@require_http_methods(['GET'])
def proceed_email_changed(request):
	try:
		with transaction.atomic():
			token = request.GET['token']
			logger.debug('Proceed change email with token %s', token)
			user, verification = utils.get_user_by_code(token, Verification.TypeChoices.email)
			new_ver = send_new_email_ver(request, user, verification.email)
			user.email = verification.email
			user.email_verification = new_ver
			user.save(update_fields=('email', 'email_verification'))
			verification.verified = True
			verification.save(update_fields=('verified',))
			logger.info('Email has been change for token %s user %s(id=%d)', token, user.username, user.id)
			return render_to_response(
				'email_changed.html',
				{'text': 'Your email has been changed to {}.'.format(verification.email)},
				context_instance=RequestContext(request)
			)
	except Exception as e:
		return render_to_response(
			'email_changed.html',
			{'text': 'Unable to change your email because {}'.format(e.message)}
			, context_instance=RequestContext(request)
		)


class RestorePassword(View):

	@transaction.atomic
	@validation
	def post(self, request):
		"""
		Sends email verification token
		"""
		token = request.POST.get('token', False)
		logger.debug('Proceed Recover password with token %s', token)
		user, verification = utils.get_user_by_code(token, Verification.TypeChoices.password)
		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)
		return HttpResponse(settings.VALIDATION_IS_OK, 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 = utils.get_user_by_code(token, Verification.TypeChoices.password)[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 not in (Verification.TypeChoices.register, Verification.TypeChoices.confirm_email):
			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))


	@transaction.atomic
	@login_required_no_redirect()
	@validation # should follow after transaciton.atomic, thus ValidationError doesn't rollback
	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')
		new_email = request.POST['email']
		if not new_email:
			new_email = None
		if new_email:
			utils.validate_email(new_email)
		utils.validate_user(request.POST['username'])
		if image_base64 is not None:
			image = extract_photo(image_base64)
			request.FILES['photo'] = image
		passwd = request.POST['password']
		if passwd:
			if request.user.password:
				is_valid = authenticate(username=request.user.username, password=request.POST['old_password'])
				if not is_valid:
					return HttpResponse("Invalid old password", content_type='text/plain')
			utils.check_password(passwd)
			request.POST['password'] = make_password(passwd)
		form = UserProfileForm(request.POST, request.FILES, instance=user_profile)
		if form.is_valid():
			if not passwd:
				form.instance.password = form.initial['password']
			if new_email != form.initial['email']:
				if form.initial['email'] and form.instance.email_verification and  form.instance.email_verification.verified:
					verification = Verification(
						type_enum=Verification.TypeChoices.email,
						user_id=user_profile.id,
						email=new_email
					)
					verification.save()
					send_email_change(request, request.user.username, form.initial['email'], verification, new_email)
					raise ValidationError("In order to change an email please confirm it from you current address. We send you an verification email to {}.".format(form.initial['email']))
				if new_email:
					new_ver = send_new_email_ver(request, request.user, new_email)
					form.instance.email_verification = new_ver
			profile = form.save()
			if passwd and form.initial['email']:
				send_password_changed(request, form.initial['email'])
			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
	@validation
	def post(self, request):
		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)
		if email:
			send_sign_up_email(user_profile, request.get_host(), request)
		djangologin(request, auth_user)
		return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')


1			# -- encoding: utf-8 --
2			import datetime
3			import json
4			import logging
5			import os
6
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			from django.contrib.auth.hashers import make_password
11			from django.core.mail import mail_admins
12
13			from chat.templatetags.md5url import md5url
14			from chat.tornado.message_creator import MessagesCreator
15
16			try:
17			from django.template.context_processors import csrf
18			except ImportError:
19			from django.core.context_processors import csrf
20			from django.core.exceptions import ObjectDoesNotExist, ValidationError, PermissionDenied
21			from django.db import transaction
22			from django.db.models import Count, Q
23			from django.http import Http404
24			from django.http import HttpResponse
25			from django.shortcuts import render_to_response
26			from django.template import RequestContext
27			from django.views.decorators.http import require_http_methods
28			from django.views.generic import View
29			from chat import utils
30			from chat.decorators import login_required_no_redirect, validation
31			from chat.forms import UserProfileForm, UserProfileReadOnlyForm
32			from chat.models import Issue, IssueDetails, IpAddress, UserProfile, Verification, Message, Subscription, \
33			SubscriptionMessages, RoomUsers, Room, UserJoinedInfo
34			from django.conf import settings
35			from chat.utils import hide_fields, check_user, check_password, check_email, extract_photo, send_sign_up_email, \
36			create_user_model, check_captcha, send_reset_password_email, get_client_ip, get_or_create_ip, \
37			send_password_changed, send_email_change, send_new_email_ver, get_message_images, prepare_img
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			@validation
54			def validate_email(request):
55			"""
56			POST only, validates email during registration
57			"""
58			utils.check_email(request.POST.get('email'))
59			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
60
61
62			@require_http_methods(['POST'])
63			@login_required_no_redirect(False)
64			@transaction.atomic
65			def save_room_settings(request):
66			"""
67			POST only, validates email during registration
68			"""
69			logger.debug('save_room_settings request, %s', request.POST)
70			room_id = request.POST['roomId']
71			room_name = request.POST.get('roomName')
72			updated = RoomUsers.objects.filter(room_id=room_id, user_id=request.user.id).update(
73			volume=request.POST['volume'],
74			notifications=request.POST['notifications'] == 'true',
75			)
76			if updated != 1:
77			raise PermissionDenied
78			if room_name is not None:
79			room_name = room_name.strip()
80			if room_name and int(room_id) != settings.ALL_ROOM_ID:
81			Room.objects.filter(id=room_id).update(name = room_name)
82			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
83
84
85			@require_http_methods('GET')
86			@transaction.atomic
87			def get_firebase_playback(request):
88			registration_id = request.META['HTTP_AUTH']
89			logger.debug('Firebase playback, id %s', registration_id)
90			query_sub_message = SubscriptionMessages.objects.filter(subscription__registration_id=registration_id, received=False).order_by('-message__time')[:1]
91			sub_message = query_sub_message[0]
92			SubscriptionMessages.objects.filter(id=sub_message.id).update(received=True)
93			message = Message.objects.select_related("sender__username", "room__name").get(id=sub_message.message_id)
94			data = {
95			'title': message.sender.username,
96			'options': {
97			'body': message.content,
98			'icon': md5url('images/favicon.ico'),
99			'data': {
100			'id': sub_message.message_id,
101			'sender': message.sender.username,
102			'room': message.room.name,
103			'roomId': message.room_id
104			},
105			'requireInteraction': True
106			},
107			}
108			return HttpResponse(json.dumps(data), content_type='application/json')
109
110
111			def test(request):
112			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
113
114
115			@require_http_methods('POST')
116			@login_required_no_redirect(False)
117			@validation
118			def search_messages(request):
119			import time
120			time.sleep(2)
121			data = request.POST['data']
122			room_id = request.POST['room']
123			if not RoomUsers.objects.filter(room_id=room_id, user_id=request.user.id).exists():
124			raise ValidationError("You can't access this room")
125			messages = Message.objects.filter(content__icontains=data, room_id=room_id)[:10]
126			images = get_message_images(messages)
127			result = []
128			for message in messages:
129			prep_m = MessagesCreator.create_message(message, prepare_img(images, message.id))
130			result.append(prep_m)
131			response = json.dumps(result)
132			return HttpResponse(response, content_type='application/json')
133
134
135			@require_http_methods('POST')
136			def register_subscription(request):
137			logger.debug('Subscription request, %s', request)
138			registration_id = request.POST['registration_id']
139			agent = request.POST['agent']
140			is_mobile = request.POST['is_mobile']
141			ip = get_or_create_ip(get_client_ip(request), logger)
142			Subscription.objects.update_or_create(
143			registration_id=registration_id,
144			defaults={
145			'user': request.user,
146			'inactive': False,
147			'updated': datetime.datetime.now(),
148			'agent': agent,
149			'is_mobile': is_mobile == 'true',
150			'ip': ip
151			}
152			)
153			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
154
155			@require_http_methods('POST')
156			@validation
157			def validate_user(request):
158			"""
159			Validates user during registration
160			"""
161			utils.check_user(request.POST.get('username'))
162			# hardcoded ok check in register.js
163			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
164
165
166			def get_service_worker(request): # this stub is only for development, this is replaced in nginx for prod
167			worker = open(os.path.join(settings.STATIC_ROOT, 'js', 'sw.js'), 'rb')
168			response = HttpResponse(content=worker)
169			response['Content-Type'] = 'application/javascript'
170			return response
171
172			@require_http_methods('GET')
173			@login_required_no_redirect(False)
174			def home(request):
175			"""
176			Login or logout navbar is creates by means of create_nav_page
177			@return: the x intercept of the line M{y=m*x+b}.
178			"""
179			context = csrf(request)
180			ip = get_client_ip(request)
181			if not UserJoinedInfo.objects.filter(Q(ip__ip=ip) & Q(user=request.user)).exists():
182			ip_obj = get_or_create_ip(ip, logger)
183			UserJoinedInfo.objects.create(ip=ip_obj, user=request.user)
184			up = UserProfile.objects.defer('suggestions', 'highlight_code', 'embedded_youtube', 'online_change_sound', 'incoming_file_call_sound', 'message_sound', 'theme').get(id=request.user.id)
185			context['suggestions'] = up.suggestions
186			context['highlight_code'] = up.highlight_code
187			context['message_sound'] = up.message_sound
188			context['incoming_file_call_sound'] = up.incoming_file_call_sound
189			context['online_change_sound'] = up.online_change_sound
190			context['theme'] = up.theme
191			context['embedded_youtube'] = up.embedded_youtube
192			context['extensionId'] = settings.EXTENSION_ID
193			context['extensionUrl'] = settings.EXTENSION_INSTALL_URL
194			context['defaultRoomId'] = settings.ALL_ROOM_ID
195			context['manifest'] = hasattr(settings, 'FIREBASE_API_KEY')
196			return render_to_response('chat.html', context, context_instance=RequestContext(request))
197
198
199			@login_required_no_redirect(True)
200			def logout(request):
201			"""
202			POST. Logs out into system.
203			"""
204			registration_id = request.POST.get('registration_id')
205			if registration_id is not None:
206			Subscription.objects.filter(registration_id=registration_id).delete()
207			djangologout(request)
208			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
209
210
211			@require_http_methods(['POST'])
212			def auth(request):
213			"""
214			Logs in into system.
215			"""
216			username = request.POST.get('username')
217			password = request.POST.get('password')
218			user = authenticate(username=username, password=password)
219			if user is not None:
220			djangologin(request, user)
221			message = settings.VALIDATION_IS_OK
222			else:
223			message = 'Login or password is wrong'
224			logger.debug('Auth request %s ; Response: %s', hide_fields(request.POST, ('password',)), message)
225			return HttpResponse(message, content_type='text/plain')
226
227
228			def send_restore_password(request):
229			"""
230			Sends email verification code
231			"""
232			logger.debug('Recover password request %s', request)
233			try:
234			username_or_password = request.POST.get('username_or_password')
235			check_captcha(request)
236			user_profile = UserProfile.objects.get(Q(username=username_or_password) \| Q(email=username_or_password))
237			if not user_profile.email:
238			raise ValidationError("You didn't specify email address for this user")
239			verification = Verification(type_enum=Verification.TypeChoices.password, user_id=user_profile.id)
240			verification.save()
241			send_reset_password_email(request, user_profile, verification)
242			message = settings.VALIDATION_IS_OK
243			logger.debug('Verification email has been send for token %s to user %s(id=%d)',
244			verification.token, user_profile.username, user_profile.id)
245			except UserProfile.DoesNotExist:
246			message = "User with this email or username doesn't exist"
247			logger.debug("Skipping password recovery request for nonexisting user")
248			except (UserProfile.DoesNotExist, ValidationError) as e:
249			logger.debug('Not sending verification email because %s', e)
250			message = 'Unfortunately we were not able to send you restore password email because {}'.format(e)
251			return HttpResponse(message, content_type='text/plain')
252
253
254			@require_http_methods(['GET'])
255			def proceed_email_changed(request):
256			try:
257			with transaction.atomic():
258			token = request.GET['token']
259			logger.debug('Proceed change email with token %s', token)
260			user, verification = utils.get_user_by_code(token, Verification.TypeChoices.email)
261			new_ver = send_new_email_ver(request, user, verification.email)
262			user.email = verification.email
263			user.email_verification = new_ver
264			user.save(update_fields=('email', 'email_verification'))
265			verification.verified = True
266			verification.save(update_fields=('verified',))
267			logger.info('Email has been change for token %s user %s(id=%d)', token, user.username, user.id)
268			return render_to_response(
269			'email_changed.html',
270			{'text': 'Your email has been changed to {}.'.format(verification.email)},
271			context_instance=RequestContext(request)
272			)
273			except Exception as e:
274			return render_to_response(
275			'email_changed.html',
276			{'text': 'Unable to change your email because {}'.format(e.message)}
277			, context_instance=RequestContext(request)
278			)
279
280
281			class RestorePassword(View):
282
283			@transaction.atomic
284			@validation
285			def post(self, request):
286			"""
287			Sends email verification token
288			"""
289			token = request.POST.get('token', False)
290			logger.debug('Proceed Recover password with token %s', token)
291			user, verification = utils.get_user_by_code(token, Verification.TypeChoices.password)
292			password = request.POST.get('password')
293			check_password(password)
294			user.set_password(password)
295			user.save(update_fields=('password',))
296			verification.verified = True
297			verification.save(update_fields=('verified',))
298			logger.info('Password has been change for token %s user %s(id=%d)', token, user.username, user.id)
299			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
300
301			def get(self, request):
302			token = request.GET.get('token', False)
303			logger.debug('Rendering restore password page with token %s', token)
304			try:
305			user = utils.get_user_by_code(token, Verification.TypeChoices.password)[0]
306			response = {
307			'message': settings.VALIDATION_IS_OK,
308			'restore_user': user.username,
309			'token': token
310			}
311			except ValidationError as e:
312			logger.debug('Rejecting verification token %s because %s', token, e)
313			response = {'message': "Unable to confirm email with token {} because {}".format(token, e)}
314			return render_to_response('reset_password.html', response, context_instance=RequestContext(request))
315
316
317			@require_http_methods('GET')
318			def confirm_email(request):
319			"""
320			Accept the verification token sent to email
321			"""
322			token = request.GET.get('token', False)
323			logger.debug('Processing email confirm with token %s', token)
324			try:
325			try:
326			v = Verification.objects.get(token=token)
327			except Verification.DoesNotExist:
328			raise ValidationError('Unknown verification token')
329			if v.type_enum not in (Verification.TypeChoices.register, Verification.TypeChoices.confirm_email):
330			raise ValidationError('This is not confirm email token')
331			if v.verified:
332			raise ValidationError('This verification token already accepted')
333			user = UserProfile.objects.get(id=v.user_id)
334			if user.email_verification_id != v.id:
335			raise ValidationError('Verification token expired because you generated another one')
336			v.verified = True
337			v.save(update_fields=['verified'])
338			message = settings.VALIDATION_IS_OK
339			logger.info('Email verification token %s has been accepted for user %s(id=%d)', token, user.username, user.id)
340			except Exception as e:
341			logger.debug('Rejecting verification token %s because %s', token, e)
342			message = ("Unable to confirm email with token {} because {}".format(token, e))
343			response = {'message': message}
344			return render_to_response('confirm_mail.html', response, context_instance=RequestContext(request))
345
346
347			@require_http_methods('GET')
348			def show_profile(request, profile_id):
349			try:
350			user_profile = UserProfile.objects.get(pk=profile_id)
351			form = UserProfileReadOnlyForm(instance=user_profile)
352			form.username = user_profile.username
353			return render_to_response(
354			'show_profile.html',
355			{'form': form},
356			context_instance=RequestContext(request)
357			)
358			except ObjectDoesNotExist:
359			raise Http404
360
361
362			@require_http_methods('GET')
363			def statistics(request):
364			pie_data = IpAddress.objects.values('country').filter(country__isnull=False).annotate(count=Count("country"))
365			return HttpResponse(json.dumps(list(pie_data)), content_type='application/json')
366
367
368			@login_required_no_redirect()
369			@transaction.atomic
370			def report_issue(request):
371			logger.info('Saving issue: %s', hide_fields(request.POST, ('log',), huge=True))
372			issue_text = request.POST['issue']
373			issue = Issue.objects.get_or_create(content=issue_text)[0]
374			issue_details = IssueDetails(
375			sender_id=request.user.id,
376			browser=request.POST.get('browser'),
377			issue=issue,
378			log=request.POST.get('log')
379			)
380			try:
381			mail_admins("{} reported issue".format(request.user.username), issue_text, fail_silently=True)
382			except Exception as e:
383			logging.error("Failed to send issue email because {}".format(e))
384			issue_details.save()
385			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
386
387
388			class ProfileView(View):
389
390			@login_required_no_redirect()
391			def get(self, request):
392			user_profile = UserProfile.objects.get(pk=request.user.id)
393			form = UserProfileForm(instance=user_profile)
394			c = csrf(request)
395			c['form'] = form
396			c['date_format'] = settings.DATE_INPUT_FORMATS_JS
397			return render_to_response('change_profile.html', c, context_instance=RequestContext(request))
398
399
400			@transaction.atomic
401			@login_required_no_redirect()
402			@validation # should follow after transaciton.atomic, thus ValidationError doesn't rollback
403			def post(self, request):
404			logger.info('Saving profile: %s', hide_fields(request.POST, ("base64_image", ), huge=True))
405			user_profile = UserProfile.objects.get(pk=request.user.id)
406			image_base64 = request.POST.get('base64_image')
407			new_email = request.POST['email']
408			if not new_email:
409			new_email = None
410			if new_email:
411			utils.validate_email(new_email)
412			utils.validate_user(request.POST['username'])
413			if image_base64 is not None:
414			image = extract_photo(image_base64)
415			request.FILES['photo'] = image
416			passwd = request.POST['password']
417			if passwd:
418			if request.user.password:
419			is_valid = authenticate(username=request.user.username, password=request.POST['old_password'])
420			if not is_valid:
421			return HttpResponse("Invalid old password", content_type='text/plain')
422			utils.check_password(passwd)
423			request.POST['password'] = make_password(passwd)
424			form = UserProfileForm(request.POST, request.FILES, instance=user_profile)
425			if form.is_valid():
426			if not passwd:
427			form.instance.password = form.initial['password']
428			if new_email != form.initial['email']:
429			if form.initial['email'] and form.instance.email_verification and form.instance.email_verification.verified:
430			verification = Verification(
431			type_enum=Verification.TypeChoices.email,
432			user_id=user_profile.id,
433			email=new_email
434			)
435			verification.save()
436			send_email_change(request, request.user.username, form.initial['email'], verification, new_email)
437			raise ValidationError("In order to change an email please confirm it from you current address. We send you an verification email to {}.".format(form.initial['email']))
438			if new_email:
439			new_ver = send_new_email_ver(request, request.user, new_email)
440			form.instance.email_verification = new_ver
441			profile = form.save()
442			if passwd and form.initial['email']:
443			send_password_changed(request, form.initial['email'])
444			response = profile. photo.url if 'photo' in request.FILES else settings.VALIDATION_IS_OK
445			else:
446			response = form.errors
447			return HttpResponse(response, content_type='text/plain')
448
449
450			class RegisterView(View):
451
452			def get(self, request):
453			logger.debug(
454			'Rendering register page with captcha site key %s and oauth key %s',
455			RECAPTCHA_SITE_KEY, GOOGLE_OAUTH_2_CLIENT_ID
456			)
457			c = csrf(request)
458			c['captcha_key'] = RECAPTCHA_SITE_KEY
459			c['captcha_url'] = RECAPTHCA_SITE_URL
460			c['oauth_url'] = GOOGLE_OAUTH_2_JS_URL
461			c['oauth_token'] = GOOGLE_OAUTH_2_CLIENT_ID
462			c['fb_app_id'] = FACEBOOK_APP_ID
463			c['fb_js_url'] = FACEBOOK_JS_URL
464			return render_to_response("register.html", c, context_instance=RequestContext(request))
465
466			@transaction.atomic
467			@validation
468			def post(self, request):
469			rp = request.POST
470			logger.info('Got register request %s', hide_fields(rp, ('password', 'repeatpassword')))
471			(username, password, email) = (rp.get('username'), rp.get('password'), rp.get('email'))
472			check_user(username)
473			check_password(password)
474			check_email(email)
475			user_profile = UserProfile(username=username, email=email, sex_str=rp.get('sex'))
476			user_profile.set_password(password)
477			create_user_model(user_profile)
478			# You must call authenticate before you can call login
479			auth_user = authenticate(username=username, password=password)
480			if email:
481			send_sign_up_email(user_profile, request.get_host(), request)
482			djangologin(request, auth_user)
483			return HttpResponse(settings.VALIDATION_IS_OK, content_type='text/plain')
484

Deathangel908 / pychat

Push — master ( 61004a...31a88b )

search_messages() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like