110swag / flashy-backend

Commit 21835759b7626ba09aba61b217aaca4fe23d1cdf

Authored by Andrew Buss 2015-05-15 17:21:41 -0700

Exists in master

merge

Showing 5 changed files Inline Diff

flashcards/migrations/0011_auto_20150514_0207.py
flashcards/models.py
flashcards/serializers.py
flashcards/validators.py
flashcards/views.py

File was created	1	# -- coding: utf-8 --
	2	from __future__ import unicode_literals
	3
	4	from django.db import models, migrations
	5	import flashcards.fields
	6
	7
	8	class Migration(migrations.Migration):
	9
	10	dependencies = [
	11	('flashcards', '0010_auto_20150513_1546'),
	12	]
	13
	14	operations = [
	15	migrations.AlterModelOptions(
	16	name='lectureperiod',
	17	options={'ordering': ['section', 'week_day']},
	18	),
	19	migrations.AlterField(
	20	model_name='userflashcard',
	21	name='mask',
	22	field=flashcards.fields.MaskField(default=None, blank_sep=b',', range_sep=b'-', max_length=255, blank=True, help_text=b'The user-specific mask on the card', null=True),
	23	),
	24	migrations.AlterField(
	25	model_name='userflashcard',
	26	name='pulled',
	27	field=models.DateTimeField(default=None, help_text=b'When the user pulled the card', null=True, blank=True),
	28	),
	29	migrations.AlterField(

__author__ = 'rray'	1
	2
from collections import Iterable	3	1	from collections import Iterable
	4	2
	5	3
class FlashcardMask(set):	6	4	class FlashcardMask(set):
def __init__(self, iterable, args, *kwargs):	7	5	def __init__(self, iterable, args, *kwargs):
iterable = map(tuple, iterable)	8	6	iterable = map(tuple, iterable)
super(FlashcardMask, self).__init__(iterable, args, *kwargs)	9	7	super(FlashcardMask, self).__init__(iterable, args, *kwargs)
self._iterable_check()	10	8	self._iterable_check()
self._interval_check()	11	9	self._interval_check()
self._overlap_check()	12	10	self._overlap_check()
	13	11
		12	def max_offset(self):
		13	return self._end
		14
def _iterable_check(self):	14	15	def _iterable_check(self):
if not all([isinstance(i, Iterable) for i in self]):	15	16	if not all([isinstance(i, Iterable) for i in self]):
raise TypeError("Interval not a valid iterable")	16	17	raise TypeError("Interval not a valid iterable")
	17	18
def _interval_check(self):	18	19	def _interval_check(self):
if not all([len(i) == 2 for i in self]):	19	20	if not all([len(i) == 2 for i in self]):
raise TypeError("Intervals must have exactly 2 elements, begin and end")	20	21	raise TypeError("Intervals must have exactly 2 elements, begin and end")
	21	22
def _overlap_check(self):	22	23	def _overlap_check(self):
p_beg, p_end = -1, -1	23	24	p_beg, p_end = -1, -1
for interval in sorted(self):	24	25	for interval in sorted(self):
beg, end = map(int, interval)	25	26	beg, end = map(int, interval)
if not (0 <= beg <= 255) or not (0 <= end <= 255) or not (beg <= end) or not (beg > p_end):	26	27	if not (0 <= beg <= 255) or not (0 <= end <= 255) or not (beg <= end) or not (beg > p_end):
raise OverlapIntervalException((beg, end), "Invalid interval offsets in the mask")	27	28	raise OverlapIntervalException((beg, end), "Invalid interval offsets in the mask")
p_beg, p_end = beg, end	28	29	p_beg, p_end = beg, end
		30	self._end = end

from django.contrib.auth.models import AbstractUser, UserManager	1	1	from django.contrib.auth.models import AbstractUser, UserManager
from django.db.models import *	2	2	from django.db.models import *
from django.utils.timezone import now	3	3	from django.utils.timezone import now
from simple_email_confirmation import SimpleEmailConfirmationUserMixin	4	4	from simple_email_confirmation import SimpleEmailConfirmationUserMixin
from fields import MaskField	5	5	from fields import MaskField
	6	6
# Hack to fix AbstractUser before subclassing it	7	7	# Hack to fix AbstractUser before subclassing it
AbstractUser._meta.get_field('email')._unique = True	8	8	AbstractUser._meta.get_field('email')._unique = True
AbstractUser._meta.get_field('username')._unique = False	9	9	AbstractUser._meta.get_field('username')._unique = False
	10	10
	11	11
class EmailOnlyUserManager(UserManager):	12	12	class EmailOnlyUserManager(UserManager):
"""	13	13	"""
A tiny extension of Django's UserManager which correctly creates users	14	14	A tiny extension of Django's UserManager which correctly creates users
without usernames (using emails instead).	15	15	without usernames (using emails instead).
"""	16	16	"""
	17	17
def _create_user(self, email, password, is_staff, is_superuser, **extra_fields):	18	18	def _create_user(self, email, password, is_staff, is_superuser, **extra_fields):
"""	19	19	"""
Creates and saves a User with the given email and password.	20	20	Creates and saves a User with the given email and password.
"""	21	21	"""
email = self.normalize_email(email)	22	22	email = self.normalize_email(email)
user = self.model(email=email,	23	23	user = self.model(email=email,
is_staff=is_staff, is_active=True,	24	24	is_staff=is_staff, is_active=True,
is_superuser=is_superuser,	25	25	is_superuser=is_superuser,
date_joined=now(), **extra_fields)	26	26	date_joined=now(), **extra_fields)
user.set_password(password)	27	27	user.set_password(password)
user.save(using=self._db)	28	28	user.save(using=self._db)
return user	29	29	return user
	30	30
def create_user(self, email, password=None, **extra_fields):	31	31	def create_user(self, email, password=None, **extra_fields):
return self._create_user(email, password, False, False, **extra_fields)	32	32	return self._create_user(email, password, False, False, **extra_fields)
	33	33
def create_superuser(self, email, password, **extra_fields):	34	34	def create_superuser(self, email, password, **extra_fields):
return self._create_user(email, password, True, True, **extra_fields)	35	35	return self._create_user(email, password, True, True, **extra_fields)
	36	36
	37	37
class User(AbstractUser, SimpleEmailConfirmationUserMixin):	38	38	class User(AbstractUser, SimpleEmailConfirmationUserMixin):
"""	39	39	"""
An extension of Django's default user model.	40	40	An extension of Django's default user model.
We use email as the username field, and include enrolled sections here	41	41	We use email as the username field, and include enrolled sections here
"""	42	42	"""
objects = EmailOnlyUserManager()	43	43	objects = EmailOnlyUserManager()
USERNAME_FIELD = 'email'	44	44	USERNAME_FIELD = 'email'
REQUIRED_FIELDS = []	45	45	REQUIRED_FIELDS = []
sections = ManyToManyField('Section', help_text="The sections which the user is enrolled in")	46	46	sections = ManyToManyField('Section', help_text="The sections which the user is enrolled in")
	47	47
	48	48
class UserFlashcard(Model):	49	49	class UserFlashcard(Model):
"""	50	50	"""
Represents the relationship between a user and a flashcard by:	51	51	Represents the relationship between a user and a flashcard by:
1. A user has a flashcard in their deck	52	52	1. A user has a flashcard in their deck
2. A user used to have a flashcard in their deck	53	53	2. A user used to have a flashcard in their deck
3. A user has a flashcard hidden from them	54	54	3. A user has a flashcard hidden from them
"""	55	55	"""
user = ForeignKey('User')	56	56	user = ForeignKey('User')
mask = MaskField(max_length=255, null=True, blank=True, help_text="The user-specific mask on the card")	57	57	mask = MaskField(max_length=255, null=True, blank=True, default=None, help_text="The user-specific mask on the card")
pulled = DateTimeField(blank=True, null=True, help_text="When the user pulled the card")	58	58	pulled = DateTimeField(blank=True, null=True, default=None, help_text="When the user pulled the card")
flashcard = ForeignKey('Flashcard')	59	59	flashcard = ForeignKey('Flashcard')
unpulled = DateTimeField(blank=True, null=True, help_text="When the user unpulled this card")	60	60	unpulled = DateTimeField(blank=True, null=True, default=None, help_text="When the user unpulled this card")
	61	61
class Meta:	62	62	class Meta:
# There can be at most one UserFlashcard for each User and Flashcard	63	63	# There can be at most one UserFlashcard for each User and Flashcard
unique_together = (('user', 'flashcard'),)	64	64	unique_together = (('user', 'flashcard'),)
index_together = ["user", "flashcard"]	65	65	index_together = ["user", "flashcard"]
# By default, order by most recently pulled	66	66	# By default, order by most recently pulled
ordering = ['-pulled']	67	67	ordering = ['-pulled']
	68	68
def is_hidden(self):	69	69	def is_hidden(self):
"""	70	70	"""
A card is hidden only if a user has not ever added it to their deck.	71	71	A card is hidden only if a user has not ever added it to their deck.
:return: Whether the flashcard is hidden from the user	72	72	:return: Whether the flashcard is hidden from the user
"""	73	73	"""
return not self.pulled	74	74	return not self.pulled
	75	75
def is_in_deck(self):	76	76	def is_in_deck(self):
"""	77	77	"""
:return:Whether the flashcard is in the user's deck	78	78	:return:Whether the flashcard is in the user's deck
"""	79	79	"""
return self.pulled and not self.unpulled	80	80	return self.pulled and not self.unpulled
	81	81
	82	82
class Flashcard(Model):	83	83	class Flashcard(Model):
text = CharField(max_length=255, help_text='The text on the card')	84	84	text = CharField(max_length=255, help_text='The text on the card')
section = ForeignKey('Section', help_text='The section with which the card is associated')	85	85	section = ForeignKey('Section', help_text='The section with which the card is associated')
pushed = DateTimeField(auto_now_add=True, help_text="When the card was first pushed")	86	86	pushed = DateTimeField(auto_now_add=True, help_text="When the card was first pushed")
material_date = DateTimeField(default=now, help_text="The date with which the card is associated")	87	87	material_date = DateTimeField(default=now, help_text="The date with which the card is associated")
previous = ForeignKey('Flashcard', null=True, blank=True,	88	88	previous = ForeignKey('Flashcard', null=True, blank=True,
help_text="The previous version of this card, if one exists")	89	89	help_text="The previous version of this card, if one exists")
author = ForeignKey(User)	90	90	author = ForeignKey(User)
is_hidden = BooleanField(default=False)	91	91	is_hidden = BooleanField(default=False)
hide_reason = CharField(blank=True, max_length=255, help_text="Reason for hiding this card")	92	92	hide_reason = CharField(blank=True, max_length=255, help_text="Reason for hiding this card")
mask = MaskField(max_length=255, null=True, blank=True, help_text="The mask on the card")	93	93	mask = MaskField(max_length=255, null=True, blank=True, help_text="The mask on the card")
	94	94
class Meta:	95	95	class Meta:
# By default, order by most recently pushed	96	96	# By default, order by most recently pushed
ordering = ['-pushed']	97	97	ordering = ['-pushed']
	98	98
def is_hidden_from(self, user):	99	99	def is_hidden_from(self, user):
"""	100	100	"""
A card can be hidden globally, but if a user has the card in their deck,	101	101	A card can be hidden globally, but if a user has the card in their deck,
this visibility overrides a global hide.	102	102	this visibility overrides a global hide.
:param user:	103	103	:param user:
:return: Whether the card is hidden from the user.	104	104	:return: Whether the card is hidden from the user.
"""	105	105	"""
result = user.userflashcard_set.filter(flashcard=self)	106	106	result = user.userflashcard_set.filter(flashcard=self)
if not result.exists(): return self.is_hidden	107	107	if not result.exists(): return self.is_hidden
return result[0].is_hidden()	108	108	return result[0].is_hidden()
	109	109
@classmethod	110	110	@classmethod
def cards_visible_to(cls, user):	111	111	def cards_visible_to(cls, user):
"""	112	112	"""
:param user:	113	113	:param user:
:return: A queryset with all cards that should be visible to a user.	114	114	:return: A queryset with all cards that should be visible to a user.
"""	115	115	"""
return cls.objects.filter(is_hidden=False).exclude(userflashcard__user=user, userflashcard__pulled=None)	116	116	return cls.objects.filter(is_hidden=False).exclude(userflashcard__user=user, userflashcard__pulled=None)
	117	117
	118	118
class UserFlashcardQuiz(Model):	119	119	class UserFlashcardQuiz(Model):
"""	120	120	"""
An event of a user being quizzed on a flashcard.	121	121	An event of a user being quizzed on a flashcard.
"""	122	122	"""
user_flashcard = ForeignKey(UserFlashcard)	123	123	user_flashcard = ForeignKey(UserFlashcard)
when = DateTimeField(auto_now=True)	124	124	when = DateTimeField(auto_now=True)
blanked_word = CharField(max_length=8, blank=True, help_text="The character range which was blanked")	125	125	blanked_word = CharField(max_length=8, blank=True, help_text="The character range which was blanked")
response = CharField(max_length=255, blank=True, null=True, help_text="The user's response")	126	126	response = CharField(max_length=255, blank=True, null=True, help_text="The user's response")
correct = NullBooleanField(help_text="The user's self-evaluation of their response")	127	127	correct = NullBooleanField(help_text="The user's self-evaluation of their response")
	128	128
def status(self):	129	129	def status(self):
"""	130	130	"""
There are three stages of a quiz object:	131	131	There are three stages of a quiz object:
1. the user has been shown the card	132	132	1. the user has been shown the card
2. the user has answered the card	133	133	2. the user has answered the card
3. the user has self-evaluated their response's correctness	134	134	3. the user has self-evaluated their response's correctness
	135	135
:return: string (evaluated, answered, viewed)	136	136	:return: string (evaluated, answered, viewed)
"""	137	137	"""
if self.correct is not None: return "evaluated"	138	138	if self.correct is not None: return "evaluated"
if self.response: return "answered"	139	139	if self.response: return "answered"
return "viewed"	140	140	return "viewed"
	141	141
	142	142
class Section(Model):	143	143	class Section(Model):
"""	144	144	"""
A UCSD course taught by an instructor during a quarter.	145	145	A UCSD course taught by an instructor during a quarter.
We use the term "section" to avoid collision with the builtin keyword "class"	146	146	We use the term "section" to avoid collision with the builtin keyword "class"
We index gratuitously to support autofill and because this is primarily read-only	147	147	We index gratuitously to support autofill and because this is primarily read-only
"""	148	148	"""
department = CharField(db_index=True, max_length=50)	149	149	department = CharField(db_index=True, max_length=50)
department_abbreviation = CharField(db_index=True, max_length=10)	150	150	department_abbreviation = CharField(db_index=True, max_length=10)
course_num = CharField(db_index=True, max_length=6)	151	151	course_num = CharField(db_index=True, max_length=6)
course_title = CharField(db_index=True, max_length=50)	152	152	course_title = CharField(db_index=True, max_length=50)
instructor = CharField(db_index=True, max_length=100)	153	153	instructor = CharField(db_index=True, max_length=100)
quarter = CharField(db_index=True, max_length=4)	154	154	quarter = CharField(db_index=True, max_length=4)
	155	155
@classmethod	156	156	@classmethod
def search(cls, terms):	157	157	def search(cls, terms):
"""	158	158	"""
Search all fields of all sections for a particular set of terms	159	159	Search all fields of all sections for a particular set of terms
A matching section must match at least one field on each term	160	160	A matching section must match at least one field on each term
:param terms:iterable	161	161	:param terms:iterable
:return: Matching QuerySet ordered by department and course number	162	162	:return: Matching QuerySet ordered by department and course number
"""	163	163	"""
final_q = Q()	164	164	final_q = Q()
for term in terms:	165	165	for term in terms:
q = Q(department__icontains=term)	166	166	q = Q(department__icontains=term)
q \|= Q(department_abbreviation__icontains=term)	167	167	q \|= Q(department_abbreviation__icontains=term)
q \|= Q(course_title__icontains=term)	168	168	q \|= Q(course_title__icontains=term)
q \|= Q(course_num__icontains=term)	169	169	q \|= Q(course_num__icontains=term)
q \|= Q(instructor__icontains=term)	170	170	q \|= Q(instructor__icontains=term)
final_q &= q	171	171	final_q &= q
qs = cls.objects.filter(final_q)	172	172	qs = cls.objects.filter(final_q)
# Have the database cast the course number to an integer so it will sort properly	173	173	# Have the database cast the course number to an integer so it will sort properly
# ECE 35 should rank before ECE 135 even though '135' < '35' lexicographically	174	174	# ECE 35 should rank before ECE 135 even though '135' < '35' lexicographically
qs = qs.extra(select={'course_num_int': "CAST(rtrim(course_num, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') AS INTEGER)"})	175	175	qs = qs.extra(select={'course_num_int': "CAST(rtrim(course_num, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') AS INTEGER)"})
qs = qs.order_by('department_abbreviation', 'course_num_int')	176	176	qs = qs.order_by('department_abbreviation', 'course_num_int')
return qs	177	177	return qs
	178	178
@property	179	179	@property
def is_whitelisted(self):	180	180	def is_whitelisted(self):
"""	181	181	"""
:return: whether a whitelist exists for this section	182	182	:return: whether a whitelist exists for this section
"""	183	183	"""
return self.whitelist.exists()	184	184	return self.whitelist.exists()
	185	185
def is_user_on_whitelist(self, user):	186	186	def is_user_on_whitelist(self, user):
"""	187	187	"""
:return: whether the user is on the waitlist for this section	188	188	:return: whether the user is on the waitlist for this section
"""	189	189	"""
return self.whitelist.filter(email=user.email).exists()	190	190	return self.whitelist.filter(email=user.email).exists()
	191	191
class Meta:	192	192	class Meta:
ordering = ['-course_title']	193	193	ordering = ['-course_title']
	194	194
@property	195	195	@property
def lecture_times(self):	196	196	def lecture_times(self):
return ', '.join(map(lambda x: '%s %s' % (x.weekday_letter, x.short_start_time), self.lectureperiod_set.all()))	197	197	return ', '.join(map(lambda x: '%s %s' % (x.weekday_letter, x.short_start_time), self.lectureperiod_set.all()))
	198	198
@property	199	199	@property
def long_name(self):	200	200	def long_name(self):
return '%s (%s) (%s)' % (self.course_title, self.instructor, self.lecture_times)	201	201	return '%s (%s) (%s)' % (self.course_title, self.instructor, self.lecture_times)
	202	202
@property	203	203	@property
def short_name(self):	204	204	def short_name(self):
return '%s %s' % (self.department_abbreviation, self.course_num)	205	205	return '%s %s' % (self.department_abbreviation, self.course_num)
	206	206
def __unicode__(self):	207	207	def __unicode__(self):
return '%s %s: %s (%s %s)' % (	208	208	return '%s %s: %s (%s %s)' % (
self.department_abbreviation, self.course_num, self.course_title, self.instructor, self.quarter)	209	209	self.department_abbreviation, self.course_num, self.course_title, self.instructor, self.quarter)
	210
	211
	212

from django.utils.datetime_safe import datetime	1	1	from django.utils.datetime_safe import datetime
from django.utils.timezone import now	2	2	from django.utils.timezone import now
import pytz	3	3	import pytz
from flashcards.models import Section, LecturePeriod, User, Flashcard	4	4	from flashcards.models import Section, LecturePeriod, User, Flashcard
from flashcards.validators import FlashcardMask, OverlapIntervalException	5	5	from flashcards.validators import FlashcardMask, OverlapIntervalException
from rest_framework import serializers	6	6	from rest_framework import serializers
from rest_framework.fields import EmailField, BooleanField, CharField, IntegerField, DateTimeField	7	7	from rest_framework.fields import EmailField, BooleanField, CharField, IntegerField, DateTimeField
from rest_framework.relations import HyperlinkedRelatedField	8	8	from rest_framework.relations import HyperlinkedRelatedField
from rest_framework.serializers import ModelSerializer, Serializer	9	9	from rest_framework.serializers import ModelSerializer, Serializer
from rest_framework.validators import UniqueValidator	10	10	from rest_framework.validators import UniqueValidator
from json import dumps, loads	11	11	from json import dumps, loads
	12	12
	13	13
class EmailSerializer(Serializer):	14	14	class EmailSerializer(Serializer):
email = EmailField(required=True)	15	15	email = EmailField(required=True)
	16	16
	17	17
class EmailPasswordSerializer(EmailSerializer):	18	18	class EmailPasswordSerializer(EmailSerializer):
password = CharField(required=True)	19	19	password = CharField(required=True)
	20	20
	21	21
class RegistrationSerializer(EmailPasswordSerializer):	22	22	class RegistrationSerializer(EmailPasswordSerializer):
email = EmailField(required=True, validators=[UniqueValidator(queryset=User.objects.all())])	23	23	email = EmailField(required=True, validators=[UniqueValidator(queryset=User.objects.all())])
	24	24
	25	25
class PasswordResetRequestSerializer(EmailSerializer):	26	26	class PasswordResetRequestSerializer(EmailSerializer):
def validate_email(self, value):	27	27	def validate_email(self, value):
try:	28	28	try:
User.objects.get(email=value)	29	29	User.objects.get(email=value)
return value	30	30	return value
except User.DoesNotExist:	31	31	except User.DoesNotExist:
raise serializers.ValidationError('No user exists with that email')	32	32	raise serializers.ValidationError('No user exists with that email')
	33	33
	34	34
class PasswordResetSerializer(Serializer):	35	35	class PasswordResetSerializer(Serializer):
new_password = CharField(required=True, allow_blank=False)	36	36	new_password = CharField(required=True, allow_blank=False)
uid = IntegerField(required=True)	37	37	uid = IntegerField(required=True)
token = CharField(required=True)	38	38	token = CharField(required=True)
	39	39
def validate_uid(self, value):	40	40	def validate_uid(self, value):
try:	41	41	try:
User.objects.get(id=value)	42	42	User.objects.get(id=value)
return value	43	43	return value
except User.DoesNotExist:	44	44	except User.DoesNotExist:
raise serializers.ValidationError('Could not verify reset token')	45	45	raise serializers.ValidationError('Could not verify reset token')
	46	46
	47	47
class UserUpdateSerializer(Serializer):	48	48	class UserUpdateSerializer(Serializer):
old_password = CharField(required=False)	49	49	old_password = CharField(required=False)
new_password = CharField(required=False, allow_blank=False)	50	50	new_password = CharField(required=False, allow_blank=False)
confirmation_key = CharField(required=False)	51	51	confirmation_key = CharField(required=False)
# reset_token = CharField(required=False)	52	52	# reset_token = CharField(required=False)
	53	53
def validate(self, data):	54	54	def validate(self, data):
if 'new_password' in data and 'old_password' not in data:	55	55	if 'new_password' in data and 'old_password' not in data:
raise serializers.ValidationError('old_password is required to set a new_password')	56	56	raise serializers.ValidationError('old_password is required to set a new_password')
return data	57	57	return data
	58	58
	59	59
class Password(Serializer):	60	60	class Password(Serializer):
email = EmailField(required=True)	61	61	email = EmailField(required=True)
password = CharField(required=True)	62	62	password = CharField(required=True)
	63	63
	64	64
class LecturePeriodSerializer(ModelSerializer):	65	65	class LecturePeriodSerializer(ModelSerializer):
class Meta:	66	66	class Meta:
model = LecturePeriod	67	67	model = LecturePeriod
exclude = 'id', 'section'	68	68	exclude = 'id', 'section'
	69	69
	70	70
class SectionSerializer(ModelSerializer):	71	71	class SectionSerializer(ModelSerializer):
lectures = LecturePeriodSerializer(source='lectureperiod_set', many=True, read_only=True)	72	72	lectures = LecturePeriodSerializer(source='lectureperiod_set', many=True, read_only=True)
short_name = CharField()	73	73	short_name = CharField()
long_name = CharField()	74	74	long_name = CharField()
	75	75
class Meta:	76	76	class Meta:
model = Section	77	77	model = Section
	78	78
	79	79
class UserSerializer(ModelSerializer):	80	80	class UserSerializer(ModelSerializer):
email = EmailField(required=False)	81	81	email = EmailField(required=False)
sections = HyperlinkedRelatedField(queryset=Section.objects.all(), many=True, view_name='section-detail')	82	82	sections = HyperlinkedRelatedField(queryset=Section.objects.all(), many=True, view_name='section-detail')
is_confirmed = BooleanField()	83	83	is_confirmed = BooleanField()
	84	84
class Meta:	85	85	class Meta:
model = User	86	86	model = User
fields = ("sections", "email", "is_confirmed", "last_login", "date_joined")	87	87	fields = ("sections", "email", "is_confirmed", "last_login", "date_joined")
	88	88
	89	89
class MaskFieldSerializer(serializers.Field):	90	90	class MaskFieldSerializer(serializers.Field):
default_error_messages = {	91	91	default_error_messages = {
'max_length': 'Ensure this field has no more than {max_length} characters.',	92	92	'max_length': 'Ensure this field has no more than {max_length} characters.',
'interval': 'Ensure this field has valid intervals.',	93	93	'interval': 'Ensure this field has valid intervals.',
'overlap': 'Ensure this field does not have overlapping intervals.'	94	94	'overlap': 'Ensure this field does not have overlapping intervals.'
}	95	95	}
	96	96
def to_representation(self, value):	97	97	def to_representation(self, value):
return dumps(list(self._make_mask(value)))	98	98	return dumps(list(self._make_mask(value)))
	99	99
def to_internal_value(self, value):	100	100	def to_internal_value(self, value):
return self._make_mask(loads(value))	101	101	return self._make_mask(loads(value))
	102	102
def _make_mask(self, data):	103	103	def _make_mask(self, data):
try:	104	104	try:
mask = FlashcardMask(data)	105	105	mask = FlashcardMask(data)
except ValueError:	106	106	except ValueError:
raise serializers.ValidationError("Invalid JSON for MaskField")	107	107	raise serializers.ValidationError("Invalid JSON for MaskField")
except TypeError:	108	108	except TypeError:
raise serializers.ValidationError("Invalid data for MaskField.")	109	109	raise serializers.ValidationError("Invalid data for MaskField.")
except OverlapIntervalException:	110	110	except OverlapIntervalException:
raise serializers.ValidationError("Invalid intervals for MaskField data.")	111	111	raise serializers.ValidationError("Invalid intervals for MaskField data.")
if len(mask) > 32:	112	112	if len(mask) > 32:
raise serializers.ValidationError("Too many intervals in the mask.")	113	113	raise serializers.ValidationError("Too many intervals in the mask.")
return mask	114	114	return mask
	115	115
	116	116
class FlashcardSerializer(ModelSerializer):	117	117	class FlashcardSerializer(ModelSerializer):
is_hidden = BooleanField(read_only=True)	118	118	is_hidden = BooleanField(read_only=True)
hide_reason = CharField(read_only=True)	119	119	hide_reason = CharField(read_only=True)
material_date = DateTimeField(default=now)	120	120	material_date = DateTimeField(default=now)
mask = MaskFieldSerializer()	121	121	mask = MaskFieldSerializer()
	122	122
def validate_material_date(self, value):	123	123	def validate_material_date(self, value):
utc = pytz.UTC	124	124	utc = pytz.UTC
# TODO: make this dynamic	125	125	# TODO: make this dynamic
quarter_start = utc.localize(datetime(2015, 3, 15))	126	126	quarter_start = utc.localize(datetime(2015, 3, 15))
quarter_end = utc.localize(datetime(2015, 6, 15))	127	127	quarter_end = utc.localize(datetime(2015, 6, 15))
	128	128
if quarter_start <= value <= quarter_end:	129	129	if quarter_start <= value <= quarter_end:
return value	130	130	return value
else:	131	131	else:
raise serializers.ValidationError("Material date is outside allowed range for this quarter")	132	132	raise serializers.ValidationError("Material date is outside allowed range for this quarter")
	133	133
def validate_previous(self, value):	134	134	def validate_previous(self, value):
if value is None:	135	135	if value is None:
return value	136	136	return value
if Flashcard.objects.filter(pk=value).count() > 0:	137	137	if Flashcard.objects.filter(pk=value).count() > 0:
return value	138	138	return value

from django.contrib import auth	1	1	from django.contrib import auth
from flashcards.api import StandardResultsSetPagination	2	2	from flashcards.api import StandardResultsSetPagination
from flashcards.models import Section, User, Flashcard, FlashcardReport, UserFlashcard	3	3	from flashcards.models import Section, User, Flashcard, FlashcardReport, UserFlashcard
from flashcards.serializers import SectionSerializer, UserUpdateSerializer, RegistrationSerializer, UserSerializer, \	4	4	from flashcards.serializers import SectionSerializer, UserUpdateSerializer, RegistrationSerializer, UserSerializer, \
PasswordResetSerializer, PasswordResetRequestSerializer, EmailPasswordSerializer, FlashcardSerializer	5	5	PasswordResetSerializer, PasswordResetRequestSerializer, EmailPasswordSerializer, FlashcardSerializer, \
		6	FlashcardUpdateSerializer
from rest_framework.decorators import detail_route, permission_classes, api_view, list_route	6	7	from rest_framework.decorators import detail_route, permission_classes, api_view, list_route
from rest_framework.generics import ListAPIView, GenericAPIView	7	8	from rest_framework.generics import ListAPIView, GenericAPIView
from rest_framework.mixins import CreateModelMixin, RetrieveModelMixin	8	9	from rest_framework.mixins import CreateModelMixin, RetrieveModelMixin
from rest_framework.permissions import IsAuthenticated	9	10	from rest_framework.permissions import IsAuthenticated
from rest_framework.viewsets import ReadOnlyModelViewSet, GenericViewSet	10	11	from rest_framework.viewsets import ReadOnlyModelViewSet, GenericViewSet
from django.core.mail import send_mail	11	12	from django.core.mail import send_mail
from django.contrib.auth import authenticate	12	13	from django.contrib.auth import authenticate
from django.contrib.auth.tokens import default_token_generator	13	14	from django.contrib.auth.tokens import default_token_generator
from rest_framework.status import HTTP_204_NO_CONTENT, HTTP_201_CREATED	14	15	from rest_framework.status import HTTP_204_NO_CONTENT, HTTP_201_CREATED
from rest_framework.response import Response	15	16	from rest_framework.response import Response
from rest_framework.exceptions import AuthenticationFailed, NotAuthenticated, ValidationError, PermissionDenied	16	17	from rest_framework.exceptions import AuthenticationFailed, NotAuthenticated, ValidationError, PermissionDenied
from simple_email_confirmation import EmailAddress	17	18	from simple_email_confirmation import EmailAddress
		19	from datetime import datetime
	18	20
	19	21
class SectionViewSet(ReadOnlyModelViewSet):	20	22	class SectionViewSet(ReadOnlyModelViewSet):
queryset = Section.objects.all()	21	23	queryset = Section.objects.all()
serializer_class = SectionSerializer	22	24	serializer_class = SectionSerializer
pagination_class = StandardResultsSetPagination	23	25	pagination_class = StandardResultsSetPagination
permission_classes = [IsAuthenticated]	24	26	permission_classes = [IsAuthenticated]
	25	27
@detail_route(methods=['get'], permission_classes=[IsAuthenticated])	26	28	@detail_route(methods=['get'], permission_classes=[IsAuthenticated])
def flashcards(self, request, pk):	27	29	def flashcards(self, request, pk):
"""	28	30	"""
Gets flashcards for a section, excluding hidden cards.	29	31	Gets flashcards for a section, excluding hidden cards.
Returned in strictly chronological order (material date).	30	32	Returned in strictly chronological order (material date).
"""	31	33	"""
flashcards = Flashcard.cards_visible_to(request.user).filter( \	32	34	flashcards = Flashcard.cards_visible_to(request.user).filter( \
section=self.get_object(), is_hidden=False).all()	33	35	section=self.get_object(), is_hidden=False).all()
	34	36
return Response(FlashcardSerializer(flashcards, many=True).data)	35	37	return Response(FlashcardSerializer(flashcards, many=True).data)
	36	38
@detail_route(methods=['post'], permission_classes=[IsAuthenticated])	37	39	@detail_route(methods=['post'], permission_classes=[IsAuthenticated])
def enroll(self, request, pk):	38	40	def enroll(self, request, pk):
"""	39	41	"""
Add the current user to a specified section	40	42	Add the current user to a specified section
If the class has a whitelist, but the user is not on the whitelist, the request will fail.	41	43	If the class has a whitelist, but the user is not on the whitelist, the request will fail.
---	42	44	---
omit_serializer: true	43	45	omit_serializer: true
parameters:	44	46	parameters:
- fake: None	45	47	- fake: None
parameters_strategy:	46	48	parameters_strategy:
form: replace	47	49	form: replace
"""	48	50	"""
section = self.get_object()	49	51	section = self.get_object()
if request.user.sections.filter(pk=section.pk).exists():	50	52	if request.user.sections.filter(pk=section.pk).exists():
raise ValidationError("You are already in this section.")	51	53	raise ValidationError("You are already in this section.")
if section.is_whitelisted and not section.is_user_on_whitelist(request.user):	52	54	if section.is_whitelisted and not section.is_user_on_whitelist(request.user):
raise PermissionDenied("You must be on the whitelist to add this section.")	53	55	raise PermissionDenied("You must be on the whitelist to add this section.")
request.user.sections.add(section)	54	56	request.user.sections.add(section)
return Response(status=HTTP_204_NO_CONTENT)	55	57	return Response(status=HTTP_204_NO_CONTENT)
	56	58
@detail_route(methods=['post'], permission_classes=[IsAuthenticated])	57	59	@detail_route(methods=['post'], permission_classes=[IsAuthenticated])
def drop(self, request, pk):	58	60	def drop(self, request, pk):
"""	59	61	"""
Remove the current user from a specified section	60	62	Remove the current user from a specified section
If the user is not in the class, the request will fail.	61	63	If the user is not in the class, the request will fail.
---	62	64	---
omit_serializer: true	63	65	omit_serializer: true
parameters:	64	66	parameters:
- fake: None	65	67	- fake: None
parameters_strategy:	66	68	parameters_strategy:
form: replace	67	69	form: replace
"""	68	70	"""
section = self.get_object()	69	71	section = self.get_object()
if not section.user_set.filter(pk=request.user.pk).exists():	70	72	if not section.user_set.filter(pk=request.user.pk).exists():
raise ValidationError("You are not in the section.")	71	73	raise ValidationError("You are not in the section.")
section.user_set.remove(request.user)	72	74	section.user_set.remove(request.user)
return Response(status=HTTP_204_NO_CONTENT)	73	75	return Response(status=HTTP_204_NO_CONTENT)
	74	76
@list_route(methods=['get'], permission_classes=[IsAuthenticated])	75	77	@list_route(methods=['get'], permission_classes=[IsAuthenticated])
def search(self, request):	76	78	def search(self, request):
query = request.GET.get('q', None)	77	79	query = request.GET.get('q', None)
if not query: return Response('[]')	78	80	if not query: return Response('[]')
qs = Section.search(query.split(' '))[:8]	79	81	qs = Section.search(query.split(' '))[:8]
serializer = SectionSerializer(qs, many=True)	80	82	serializer = SectionSerializer(qs, many=True)
return Response(serializer.data)	81	83	return Response(serializer.data)
	82	84
@detail_route(methods=['get'], permission_classes=[IsAuthenticated])	83	85	@detail_route(methods=['get'], permission_classes=[IsAuthenticated])
def deck(self, request, pk):	84	86	def deck(self, request, pk):
"""	85	87	"""
Gets the contents of a user's deck for a given section.	86	88	Gets the contents of a user's deck for a given section.
"""	87	89	"""
qs = Flashcard.objects.all()	88	90	qs = Flashcard.objects.all()
qs = qs.filter(userflashcard__user=request.user)	89	91	qs = qs.filter(userflashcard__user=request.user)
		92	qs = qs.filter(section = self.get_object())
serializer = FlashcardSerializer(qs, many=True)	90	93	serializer = FlashcardSerializer(qs, many=True)
return Response(serializer.data)	91	94	return Response(serializer.data)
	92	95
	93	96
class UserSectionListView(ListAPIView):	94	97	class UserSectionListView(ListAPIView):
serializer_class = SectionSerializer	95	98	serializer_class = SectionSerializer
permission_classes = [IsAuthenticated]	96	99	permission_classes = [IsAuthenticated]
	97	100
def get_queryset(self):	98	101	def get_queryset(self):
return self.request.user.sections.all()	99	102	return self.request.user.sections.all()
	100	103
def paginate_queryset(self, queryset): return None	101	104	def paginate_queryset(self, queryset): return None
	102	105
	103	106
class UserDetail(GenericAPIView):	104	107	class UserDetail(GenericAPIView):
serializer_class = UserSerializer	105	108	serializer_class = UserSerializer
permission_classes = [IsAuthenticated]	106	109	permission_classes = [IsAuthenticated]
	107	110
def get_queryset(self):	108	111	def get_queryset(self):
return User.objects.all()	109	112	return User.objects.all()
	110	113
def patch(self, request, format=None):	111	114	def patch(self, request, format=None):
"""	112	115	"""
Updates the user's password, or verifies their email address	113	116	Updates the user's password, or verifies their email address
---	114	117	---
request_serializer: UserUpdateSerializer	115	118	request_serializer: UserUpdateSerializer
response_serializer: UserSerializer	116	119	response_serializer: UserSerializer
"""	117	120	"""
data = UserUpdateSerializer(data=request.data, context={'user': request.user})	118	121	data = UserUpdateSerializer(data=request.data, context={'user': request.user})
data.is_valid(raise_exception=True)	119	122	data.is_valid(raise_exception=True)
data = data.validated_data	120	123	data = data.validated_data
	121	124
if 'new_password' in data:	122	125	if 'new_password' in data:
if not request.user.check_password(data['old_password']):	123	126	if not request.user.check_password(data['old_password']):
raise ValidationError('old_password is incorrect')	124	127	raise ValidationError('old_password is incorrect')
request.user.set_password(data['new_password'])	125	128	request.user.set_password(data['new_password'])
request.user.save()	126	129	request.user.save()
	127	130
if 'confirmation_key' in data:	128	131	if 'confirmation_key' in data:
try:	129	132	try:
request.user.confirm_email(data['confirmation_key'])	130	133	request.user.confirm_email(data['confirmation_key'])
except EmailAddress.DoesNotExist:	131	134	except EmailAddress.DoesNotExist:
raise ValidationError('confirmation_key is invalid')	132	135	raise ValidationError('confirmation_key is invalid')
	133	136
return Response(UserSerializer(request.user).data)	134	137	return Response(UserSerializer(request.user).data)
	135	138
def get(self, request, format=None):	136	139	def get(self, request, format=None):
"""	137	140	"""
Return data about the user	138	141	Return data about the user
---	139	142	---
response_serializer: UserSerializer	140	143	response_serializer: UserSerializer
"""	141	144	"""
serializer = UserSerializer(request.user, context={'request': request})	142	145	serializer = UserSerializer(request.user, context={'request': request})
return Response(serializer.data)	143	146	return Response(serializer.data)
	144	147
def delete(self, request):	145	148	def delete(self, request):
"""	146	149	"""
Irrevocably delete the user and their data	147	150	Irrevocably delete the user and their data
	148	151
Yes, really	149	152	Yes, really
"""	150	153	"""
request.user.delete()	151	154	request.user.delete()
return Response(status=HTTP_204_NO_CONTENT)	152	155	return Response(status=HTTP_204_NO_CONTENT)
	153	156
	154	157
@api_view(['POST'])	155	158	@api_view(['POST'])
def register(request, format=None):	156	159	def register(request, format=None):
"""	157	160	"""
Register a new user	158	161	Register a new user
---	159	162	---
request_serializer: EmailPasswordSerializer	160	163	request_serializer: EmailPasswordSerializer
response_serializer: UserSerializer	161	164	response_serializer: UserSerializer
"""	162	165	"""
data = RegistrationSerializer(data=request.data)	163	166	data = RegistrationSerializer(data=request.data)
data.is_valid(raise_exception=True)	164	167	data.is_valid(raise_exception=True)
	165	168
User.objects.create_user(**data.validated_data)	166	169	User.objects.create_user(**data.validated_data)
user = authenticate(**data.validated_data)	167	170	user = authenticate(**data.validated_data)
auth.login(request, user)	168	171	auth.login(request, user)
	169	172
body = '''	170	173	body = '''
Visit the following link to confirm your email address:	171	174	Visit the following link to confirm your email address:
https://flashy.cards/app/verify_email/%s	172	175	https://flashy.cards/app/verify_email/%s
	173	176
If you did not register for Flashy, no action is required.	174	177	If you did not register for Flashy, no action is required.
'''	175	178	'''
	176	179
assert send_mail("Flashy email verification",	177	180	assert send_mail("Flashy email verification",
body % user.confirmation_key,	178	181	body % user.confirmation_key,
"noreply@flashy.cards",	179	182	"noreply@flashy.cards",
[user.email])	180	183	[user.email])
	181	184
return Response(UserSerializer(request.user).data, status=HTTP_201_CREATED)	182	185	return Response(UserSerializer(request.user).data, status=HTTP_201_CREATED)
	183	186
	184	187
@api_view(['POST'])	185	188	@api_view(['POST'])
def login(request):	186	189	def login(request):
"""	187	190	"""
Authenticates user and returns user data if valid.	188	191	Authenticates user and returns user data if valid.
---	189	192	---
request_serializer: EmailPasswordSerializer	190	193	request_serializer: EmailPasswordSerializer
response_serializer: UserSerializer	191	194	response_serializer: UserSerializer
"""	192	195	"""
	193	196
data = EmailPasswordSerializer(data=request.data)	194	197	data = EmailPasswordSerializer(data=request.data)
data.is_valid(raise_exception=True)	195	198	data.is_valid(raise_exception=True)
user = authenticate(**data.validated_data)	196	199	user = authenticate(**data.validated_data)
	197	200
if user is None:	198	201	if user is None:
raise AuthenticationFailed('Invalid email or password')	199	202	raise AuthenticationFailed('Invalid email or password')
if not user.is_active:	200	203	if not user.is_active:
raise NotAuthenticated('Account is disabled')	201	204	raise NotAuthenticated('Account is disabled')
auth.login(request, user)	202	205	auth.login(request, user)
return Response(UserSerializer(request.user).data)	203	206	return Response(UserSerializer(request.user).data)
	204	207
	205	208
@api_view(['POST'])	206	209	@api_view(['POST'])
@permission_classes((IsAuthenticated, ))	207	210	@permission_classes((IsAuthenticated, ))
def logout(request, format=None):	208	211	def logout(request, format=None):
"""	209	212	"""
Logs the authenticated user out.	210	213	Logs the authenticated user out.
"""	211	214	"""
auth.logout(request)	212	215	auth.logout(request)
return Response(status=HTTP_204_NO_CONTENT)	213	216	return Response(status=HTTP_204_NO_CONTENT)
	214	217
	215	218
@api_view(['POST'])	216	219	@api_view(['POST'])
def request_password_reset(request, format=None):	217	220	def request_password_reset(request, format=None):
"""	218	221	"""
Send a password reset token/link to the provided email.	219	222	Send a password reset token/link to the provided email.
---	220	223	---
request_serializer: PasswordResetRequestSerializer	221	224	request_serializer: PasswordResetRequestSerializer
"""	222	225	"""
data = PasswordResetRequestSerializer(data=request.data)	223	226	data = PasswordResetRequestSerializer(data=request.data)
data.is_valid(raise_exception=True)	224	227	data.is_valid(raise_exception=True)
user = User.objects.get(email=data['email'].value)	225	228	user = User.objects.get(email=data['email'].value)
token = default_token_generator.make_token(user)	226	229	token = default_token_generator.make_token(user)
	227	230
body = '''	228	231	body = '''
Visit the following link to reset your password:	229	232	Visit the following link to reset your password:
https://flashy.cards/app/reset_password/%d/%s	230	233	https://flashy.cards/app/reset_password/%d/%s
	231	234
If you did not request a password reset, no action is required.	232	235	If you did not request a password reset, no action is required.
'''	233	236	'''
	234	237
send_mail("Flashy password reset",	235	238	send_mail("Flashy password reset",
body % (user.pk, token),	236	239	body % (user.pk, token),
"noreply@flashy.cards",	237	240	"noreply@flashy.cards",
[user.email])	238	241	[user.email])
	239	242
return Response(status=HTTP_204_NO_CONTENT)	240	243	return Response(status=HTTP_204_NO_CONTENT)
	241	244
	242	245
@api_view(['POST'])	243	246	@api_view(['POST'])
def reset_password(request, format=None):	244	247	def reset_password(request, format=None):
"""	245	248	"""
Updates user's password to new password if token is valid.	246	249	Updates user's password to new password if token is valid.
---	247	250	---
request_serializer: PasswordResetSerializer	248	251	request_serializer: PasswordResetSerializer
"""	249	252	"""
data = PasswordResetSerializer(data=request.data)	250	253	data = PasswordResetSerializer(data=request.data)
data.is_valid(raise_exception=True)	251	254	data.is_valid(raise_exception=True)
	252	255
user = User.objects.get(id=data['uid'].value)	253	256	user = User.objects.get(id=data['uid'].value)
# Check token validity.	254	257	# Check token validity.
	255	258
if default_token_generator.check_token(user, data['token'].value):	256	259	if default_token_generator.check_token(user, data['token'].value):
user.set_password(data['new_password'].value)	257	260	user.set_password(data['new_password'].value)
user.save()	258	261	user.save()
else:	259	262	else:
raise ValidationError('Could not verify reset token')	260	263	raise ValidationError('Could not verify reset token')
return Response(status=HTTP_204_NO_CONTENT)	261	264	return Response(status=HTTP_204_NO_CONTENT)
	262	265
	263	266
class FlashcardViewSet(GenericViewSet, CreateModelMixin, RetrieveModelMixin):	264	267	class FlashcardViewSet(GenericViewSet, CreateModelMixin, RetrieveModelMixin):
queryset = Flashcard.objects.all()	265	268	queryset = Flashcard.objects.all()
serializer_class = FlashcardSerializer	266	269	serializer_class = FlashcardSerializer
permission_classes = [IsAuthenticated]	267	270	permission_classes = [IsAuthenticated]
	268	271
# Override create in CreateModelMixin	269	272	# Override create in CreateModelMixin
def create(self, request, args, *kwargs):	270	273	def create(self, request, args, *kwargs):
serializer = self.get_serializer(data=request.data)	271	274	serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)	272	275	serializer.is_valid(raise_exception=True)
serializer.validated_data['author'] = request.user	273	276	serializer.validated_data['author'] = request.user
self.perform_create(serializer)	274	277	self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)	275	278	headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=HTTP_201_CREATED, headers=headers)	276	279	return Response(serializer.data, status=HTTP_201_CREATED, headers=headers)
	277	280
@detail_route(methods=['post'], permission_classes=[IsAuthenticated])	278	281	@detail_route(methods=['post'], permission_classes=[IsAuthenticated])
def report(self, request, pk):	279	282	def report(self, request, pk):
"""	280	283	"""
Report the given card	281	284	Report the given card
---	282	285	---
omit_serializer: true	283	286	omit_serializer: true
parameters:	284	287	parameters:
- fake: None	285	288	- fake: None
parameters_strategy:	286	289	parameters_strategy:
form: replace	287	290	form: replace
"""	288	291	"""
obj, created = FlashcardReport.objects.get_or_create(user=request.user, flashcard=self.get_object())	289	292	obj, created = FlashcardReport.objects.get_or_create(user=request.user, flashcard=self.get_object())
obj.reason = request.data['reason']	290	293	obj.reason = request.data['reason']