110swag / flashy-backend

Commit e314143d375cde3cee46fe36422cb75a45eab0ed

Authored by Laura Hawkins 2015-05-15 17:12:27 -0700

Exists in master

Merge branch 'master' of https://git.ucsd.edu/110swag/flashy-backend

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	210
class LecturePeriod(Model):	211	211	class LecturePeriod(Model):
"""	212	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)
qs = qs.filter(section = self.get_object())	90	92	qs = qs.filter(section = self.get_object())
serializer = FlashcardSerializer(qs, many=True)	91	93	serializer = FlashcardSerializer(qs, many=True)
return Response(serializer.data)	92	94	return Response(serializer.data)
	93	95
	94	96
class UserSectionListView(ListAPIView):	95	97	class UserSectionListView(ListAPIView):
serializer_class = SectionSerializer	96	98	serializer_class = SectionSerializer
permission_classes = [IsAuthenticated]	97	99	permission_classes = [IsAuthenticated]
	98	100
def get_queryset(self):	99	101	def get_queryset(self):
return self.request.user.sections.all()	100	102	return self.request.user.sections.all()
	101	103
def paginate_queryset(self, queryset): return None	102	104	def paginate_queryset(self, queryset): return None
	103	105
	104	106
class UserDetail(GenericAPIView):	105	107	class UserDetail(GenericAPIView):
serializer_class = UserSerializer	106	108	serializer_class = UserSerializer
permission_classes = [IsAuthenticated]	107	109	permission_classes = [IsAuthenticated]
	108	110
def get_queryset(self):	109	111	def get_queryset(self):
return User.objects.all()	110	112	return User.objects.all()
	111	113
def patch(self, request, format=None):	112	114	def patch(self, request, format=None):
"""	113	115	"""
Updates the user's password, or verifies their email address	114	116	Updates the user's password, or verifies their email address
---	115	117	---
request_serializer: UserUpdateSerializer	116	118	request_serializer: UserUpdateSerializer
response_serializer: UserSerializer	117	119	response_serializer: UserSerializer
"""	118	120	"""
data = UserUpdateSerializer(data=request.data, context={'user': request.user})	119	121	data = UserUpdateSerializer(data=request.data, context={'user': request.user})
data.is_valid(raise_exception=True)	120	122	data.is_valid(raise_exception=True)
data = data.validated_data	121	123	data = data.validated_data
	122	124
if 'new_password' in data:	123	125	if 'new_password' in data:
if not request.user.check_password(data['old_password']):	124	126	if not request.user.check_password(data['old_password']):
raise ValidationError('old_password is incorrect')	125	127	raise ValidationError('old_password is incorrect')
request.user.set_password(data['new_password'])	126	128	request.user.set_password(data['new_password'])
request.user.save()	127	129	request.user.save()
	128	130
if 'confirmation_key' in data:	129	131	if 'confirmation_key' in data:
try:	130	132	try:
request.user.confirm_email(data['confirmation_key'])	131	133	request.user.confirm_email(data['confirmation_key'])
except EmailAddress.DoesNotExist:	132	134	except EmailAddress.DoesNotExist:
raise ValidationError('confirmation_key is invalid')	133	135	raise ValidationError('confirmation_key is invalid')
	134	136
return Response(UserSerializer(request.user).data)	135	137	return Response(UserSerializer(request.user).data)
	136	138
def get(self, request, format=None):	137	139	def get(self, request, format=None):
"""	138	140	"""
Return data about the user	139	141	Return data about the user
---	140	142	---
response_serializer: UserSerializer	141	143	response_serializer: UserSerializer
"""	142	144	"""
serializer = UserSerializer(request.user, context={'request': request})	143	145	serializer = UserSerializer(request.user, context={'request': request})
return Response(serializer.data)	144	146	return Response(serializer.data)
	145	147
def delete(self, request):	146	148	def delete(self, request):
"""	147	149	"""
Irrevocably delete the user and their data	148	150	Irrevocably delete the user and their data
	149	151
Yes, really	150	152	Yes, really
"""	151	153	"""
request.user.delete()	152	154	request.user.delete()
return Response(status=HTTP_204_NO_CONTENT)	153	155	return Response(status=HTTP_204_NO_CONTENT)
	154	156
	155	157
@api_view(['POST'])	156	158	@api_view(['POST'])
def register(request, format=None):	157	159	def register(request, format=None):
"""	158	160	"""
Register a new user	159	161	Register a new user
---	160	162	---
request_serializer: EmailPasswordSerializer	161	163	request_serializer: EmailPasswordSerializer
response_serializer: UserSerializer	162	164	response_serializer: UserSerializer
"""	163	165	"""
data = RegistrationSerializer(data=request.data)	164	166	data = RegistrationSerializer(data=request.data)
data.is_valid(raise_exception=True)	165	167	data.is_valid(raise_exception=True)
	166	168
User.objects.create_user(**data.validated_data)	167	169	User.objects.create_user(**data.validated_data)
user = authenticate(**data.validated_data)	168	170	user = authenticate(**data.validated_data)
auth.login(request, user)	169	171	auth.login(request, user)
	170	172
body = '''	171	173	body = '''
Visit the following link to confirm your email address:	172	174	Visit the following link to confirm your email address:
https://flashy.cards/app/verify_email/%s	173	175	https://flashy.cards/app/verify_email/%s
	174	176
If you did not register for Flashy, no action is required.	175	177	If you did not register for Flashy, no action is required.
'''	176	178	'''
	177	179
assert send_mail("Flashy email verification",	178	180	assert send_mail("Flashy email verification",
body % user.confirmation_key,	179	181	body % user.confirmation_key,
"noreply@flashy.cards",	180	182	"noreply@flashy.cards",
[user.email])	181	183	[user.email])
	182	184
return Response(UserSerializer(request.user).data, status=HTTP_201_CREATED)	183	185	return Response(UserSerializer(request.user).data, status=HTTP_201_CREATED)
	184	186
	185	187
@api_view(['POST'])	186	188	@api_view(['POST'])
def login(request):	187	189	def login(request):
"""	188	190	"""
Authenticates user and returns user data if valid.	189	191	Authenticates user and returns user data if valid.
---	190	192	---
request_serializer: EmailPasswordSerializer	191	193	request_serializer: EmailPasswordSerializer
response_serializer: UserSerializer	192	194	response_serializer: UserSerializer
"""	193	195	"""
	194	196
data = EmailPasswordSerializer(data=request.data)	195	197	data = EmailPasswordSerializer(data=request.data)
data.is_valid(raise_exception=True)	196	198	data.is_valid(raise_exception=True)
user = authenticate(**data.validated_data)	197	199	user = authenticate(**data.validated_data)
	198	200
if user is None:	199	201	if user is None:
raise AuthenticationFailed('Invalid email or password')	200	202	raise AuthenticationFailed('Invalid email or password')
if not user.is_active:	201	203	if not user.is_active:
raise NotAuthenticated('Account is disabled')	202	204	raise NotAuthenticated('Account is disabled')
auth.login(request, user)	203	205	auth.login(request, user)
return Response(UserSerializer(request.user).data)	204	206	return Response(UserSerializer(request.user).data)
	205	207
	206	208
@api_view(['POST'])	207	209	@api_view(['POST'])
@permission_classes((IsAuthenticated, ))	208	210	@permission_classes((IsAuthenticated, ))
def logout(request, format=None):	209	211	def logout(request, format=None):
"""	210	212	"""
Logs the authenticated user out.	211	213	Logs the authenticated user out.
"""	212	214	"""
auth.logout(request)	213	215	auth.logout(request)
return Response(status=HTTP_204_NO_CONTENT)	214	216	return Response(status=HTTP_204_NO_CONTENT)
	215	217
	216	218
@api_view(['POST'])	217	219	@api_view(['POST'])
def request_password_reset(request, format=None):	218	220	def request_password_reset(request, format=None):
"""	219	221	"""
Send a password reset token/link to the provided email.	220	222	Send a password reset token/link to the provided email.
---	221	223	---
request_serializer: PasswordResetRequestSerializer	222	224	request_serializer: PasswordResetRequestSerializer
"""	223	225	"""
data = PasswordResetRequestSerializer(data=request.data)	224	226	data = PasswordResetRequestSerializer(data=request.data)
data.is_valid(raise_exception=True)	225	227	data.is_valid(raise_exception=True)
user = User.objects.get(email=data['email'].value)	226	228	user = User.objects.get(email=data['email'].value)
token = default_token_generator.make_token(user)	227	229	token = default_token_generator.make_token(user)
	228	230
body = '''	229	231	body = '''
Visit the following link to reset your password:	230	232	Visit the following link to reset your password:
https://flashy.cards/app/reset_password/%d/%s	231	233	https://flashy.cards/app/reset_password/%d/%s
	232	234
If you did not request a password reset, no action is required.	233	235	If you did not request a password reset, no action is required.
'''	234	236	'''
	235	237
send_mail("Flashy password reset",	236	238	send_mail("Flashy password reset",
body % (user.pk, token),	237	239	body % (user.pk, token),
"noreply@flashy.cards",	238	240	"noreply@flashy.cards",
[user.email])	239	241	[user.email])
	240	242
return Response(status=HTTP_204_NO_CONTENT)	241	243	return Response(status=HTTP_204_NO_CONTENT)
	242	244
	243	245
@api_view(['POST'])	244	246	@api_view(['POST'])
def reset_password(request, format=None):	245	247	def reset_password(request, format=None):
"""	246	248	"""
Updates user's password to new password if token is valid.	247	249	Updates user's password to new password if token is valid.
---	248	250	---
request_serializer: PasswordResetSerializer	249	251	request_serializer: PasswordResetSerializer
"""	250	252	"""
data = PasswordResetSerializer(data=request.data)	251	253	data = PasswordResetSerializer(data=request.data)
data.is_valid(raise_exception=True)	252	254	data.is_valid(raise_exception=True)
	253	255
user = User.objects.get(id=data['uid'].value)	254	256	user = User.objects.get(id=data['uid'].value)
# Check token validity.	255	257	# Check token validity.
	256	258
if default_token_generator.check_token(user, data['token'].value):	257	259	if default_token_generator.check_token(user, data['token'].value):
user.set_password(data['new_password'].value)	258	260	user.set_password(data['new_password'].value)
user.save()	259	261	user.save()
else:	260	262	else:
raise ValidationError('Could not verify reset token')	261	263	raise ValidationError('Could not verify reset token')
return Response(status=HTTP_204_NO_CONTENT)	262	264	return Response(status=HTTP_204_NO_CONTENT)
	263	265
	264	266
class FlashcardViewSet(GenericViewSet, CreateModelMixin, RetrieveModelMixin):	265	267	class FlashcardViewSet(GenericViewSet, CreateModelMixin, RetrieveModelMixin):
queryset = Flashcard.objects.all()	266	268	queryset = Flashcard.objects.all()
serializer_class = FlashcardSerializer	267	269	serializer_class = FlashcardSerializer
permission_classes = [IsAuthenticated]	268	270	permission_classes = [IsAuthenticated]
	269	271
# Override create in CreateModelMixin	270	272	# Override create in CreateModelMixin
def create(self, request, args, *kwargs):	271	273	def create(self, request, args, *kwargs):
serializer = self.get_serializer(data=request.data)	272	274	serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)	273	275	serializer.is_valid(raise_exception=True)
serializer.validated_data['author'] = request.user	274	276	serializer.validated_data['author'] = request.user
self.perform_create(serializer)	275	277	self.perform_create(serializer)
headers = self.get_success_headers(serializer.data)	276	278	headers = self.get_success_headers(serializer.data)
return Response(serializer.data, status=HTTP_201_CREATED, headers=headers)	277	279	return Response(serializer.data, status=HTTP_201_CREATED, headers=headers)
	278	280
@detail_route(methods=['post'], permission_classes=[IsAuthenticated])	279	281	@detail_route(methods=['post'], permission_classes=[IsAuthenticated])
def report(self, request, pk):	280	282	def report(self, request, pk):
"""	281	283	"""
Report the given card	282	284	Report the given card
---	283	285	---
omit_serializer: true	284	286	omit_serializer: true
parameters:	285	287	parameters:
- fake: None	286	288	- fake: None
parameters_strategy:	287	289	parameters_strategy:
form: replace	288	290	form: replace
"""	289	291	"""
obj, created = FlashcardReport.objects.get_or_create(user=request.user, flashcard=self.get_object())	290	292	obj, created = FlashcardReport.objects.get_or_create(user=request.user, flashcard=self.get_object())
obj.reason = request.data['reason']	291	293	obj.reason = request.data['reason']