110swag / flashy-backend

Commit fedcc8ded538b1185499a7c5bdab70446fc29eae

Authored by Rohan Rangray 2015-05-16 17:29:51 -0700

Exists in master

Wrote tests for FlashcardMask and Flashcard.edit. Refactored some code.

Showing 6 changed files with 96 additions and 27 deletions Inline Diff

flashcards/models.py
flashcards/serializers.py
flashcards/tests/test_api.py
flashcards/tests/test_models.py
flashcards/validators.py
flashcards/views.py

from datetime import datetime	1	1	from datetime import datetime
	2	2
from django.test import TestCase	3	3	from django.test import TestCase
from flashcards.models import User, Section, Flashcard	4	4	from flashcards.models import User, Section, Flashcard, UserFlashcard
from flashcards.validators import OverlapIntervalException	5	5	from flashcards.validators import FlashcardMask, OverlapIntervalException
	6	6
	7	7
class RegistrationTests(TestCase):	8	8	class RegistrationTests(TestCase):
def setUp(self):	9	9	def setUp(self):
User.objects.create_user(email="none@none.com", password="1234")	10	10	User.objects.create_user(email="none@none.com", password="1234")
	11	11
def test_email_confirmation(self):	12	12	def test_email_confirmation(self):
user = User.objects.get(email="none@none.com")	13	13	user = User.objects.get(email="none@none.com")
self.assertFalse(user.is_confirmed)	14	14	self.assertFalse(user.is_confirmed)
user.confirm_email(user.confirmation_key)	15	15	user.confirm_email(user.confirmation_key)
self.assertTrue(user.is_confirmed)	16	16	self.assertTrue(user.is_confirmed)
	17	17
	18	18
class UserTests(TestCase):	19	19	class UserTests(TestCase):
def setUp(self):	20	20	def setUp(self):
User.objects.create_user(email="none@none.com", password="1234")	21	21	User.objects.create_user(email="none@none.com", password="1234")
Section.objects.create(department='dept',	22	22	Section.objects.create(department='dept',
course_num='101a',	23	23	course_num='101a',
course_title='how 2 test',	24	24	course_title='how 2 test',
instructor='George Lucas',	25	25	instructor='George Lucas',
quarter='SP15')	26	26	quarter='SP15')
	27	27
def test_section_list(self):	28	28	def test_section_list(self):
section = Section.objects.get(course_num='101a')	29	29	section = Section.objects.get(course_num='101a')
user = User.objects.get(email="none@none.com")	30	30	user = User.objects.get(email="none@none.com")
self.assertNotIn(section, user.sections.all())	31	31	self.assertNotIn(section, user.sections.all())
user.sections.add(section)	32	32	user.sections.add(section)
self.assertIn(section, user.sections.all())	33	33	self.assertIn(section, user.sections.all())
user.sections.add(section)	34	34	user.sections.add(section)
self.assertEqual(user.sections.count(), 1)	35	35	self.assertEqual(user.sections.count(), 1)
user.sections.remove(section)	36	36	user.sections.remove(section)
self.assertEqual(user.sections.count(), 0)	37	37	self.assertEqual(user.sections.count(), 0)
	38	38
	39	39
		40	class FlashcardMaskTest(TestCase):
		41	def test_iterable(self):
		42	try:
		43	FlashcardMask(1)
		44	except TypeError as te:
		45	self.assertEqual(te.message, "Interval not a valid iterable")
		46	try:
		47	FlashcardMask([1, 2, 4])
		48	except TypeError as te:
		49	self.assertEqual(te.message, "Interval not a valid iterable")
		50
		51	def test_interval(self):
		52	try:
		53	FlashcardMask([[1, 2, 3], [1]])
		54	except TypeError as te:
		55	self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")
		56	try:
		57	FlashcardMask([[1, 2], [1, 2, 4]])
		58	except TypeError as te:
		59	self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")
		60	try:
		61	FlashcardMask(([1, 2], [1]))
		62	except TypeError as te:
		63	self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")
		64	try:
		65	FlashcardMask("[1,2,3]")
		66	except TypeError as te:
		67	self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")
		68
		69	def test_overlap(self):
		70	try:
		71	FlashcardMask({(1, 2), (2, 5)})
		72	except OverlapIntervalException as oie:
		73	self.assertEqual(oie.message, "Invalid interval offsets in the mask")
		74	try:
		75	FlashcardMask({(1, 20), (12, 15)})
		76	except OverlapIntervalException as oie:
		77	self.assertEqual(oie.message, "Invalid interval offsets in the mask")
		78	try:
		79	FlashcardMask({(2, 1), (5, 2)})
		80	except OverlapIntervalException as oie:
		81	self.assertEqual(oie.message, "Invalid interval offsets in the mask")
		82
		83
		84
class FlashcardTests(TestCase):	40	85	class FlashcardTests(TestCase):
def setUp(self):	41	86	def setUp(self):
user = User.objects.create_user(email="none@none.com", password="1234")	42
section = Section.objects.create(department='dept',	43	87	section = Section.objects.create(department='dept',
course_num='101a',	44	88	course_num='101a',
course_title='how 2 test',	45	89	course_title='how 2 test',
instructor='George Lucas',	46	90	instructor='George Lucas',
quarter='SP15')	47	91	quarter='SP15')
Flashcard.objects.create(text="This is the text of the Flashcard",	48	92	user = User.objects.create_user(email="none@none.com", password="1234")
section=section,	49	93	user.sections.add(section)
author=user,	50	94	flashcard = Flashcard.objects.create(text="This is the text of the Flashcard",
material_date=datetime.now(),	51	95	section=section,
previous=None,	52	96	author=user,
mask={(24,34), (0, 4)})	53	97	material_date=datetime.now(),
		98	previous=None,
		99	mask={(24,34), (0, 4)})
		100	user.save()
		101	section.save()
		102	flashcard.save()
	54	103
def test_mask_field(self):	55	104	def test_flashcard_edit(self):
user = User.objects.get(email="none@none.com")	56	105	user = User.objects.get(email="none@none.com")
		106	user2 = User.objects.create_user(email="wow@wow.com", password="wow")
section = Section.objects.get(course_title='how 2 test')	57	107	section = Section.objects.get(course_title='how 2 test')
		108	user2.sections.add(section)
		109	user2.save()
		110	flashcard = Flashcard.objects.filter(author=user).get(text="This is the text of the Flashcard")
		111	pk_backup = flashcard.pk
		112	self.assertTrue(user.is_in_section(section))
		113	flashcard.edit(user, {})
		114	self.assertIsNotNone(flashcard.pk)
		115	UserFlashcard.objects.create(user=user2, flashcard=flashcard).save()
		116	flashcard.edit(user2, {'text': 'This is the new text'})
		117	self.assertNotEqual(flashcard.pk, pk_backup)
		118
		119	def test_mask_field(self):
		120	user = User.objects.get(email="none@none.com")
flashcard = Flashcard.objects.filter(author=user).get(text="This is the text of the Flashcard")	58	121	flashcard = Flashcard.objects.filter(author=user).get(text="This is the text of the Flashcard")
self.assertTrue(isinstance(flashcard.mask, set))	59	122	self.assertTrue(isinstance(flashcard.mask, set))
self.assertTrue(all([isinstance(interval, tuple) for interval in flashcard.mask]))	60	123	self.assertTrue(all([isinstance(interval, tuple) for interval in flashcard.mask]))
blank1, blank2 = sorted(list(flashcard.mask))	61	124	blank1, blank2 = sorted(list(flashcard.mask))
self.assertEqual(flashcard.text[slice(*blank1)], 'This')	62	125	self.assertEqual(flashcard.text[slice(*blank1)], 'This')
self.assertEqual(flashcard.text[slice(*blank2)], 'Flashcard')	63	126	self.assertEqual(flashcard.text[slice(*blank2)], 'Flashcard')
try:	64	127	try:
flashcard.mask = {(10, 34), (0, 14)}	65	128	flashcard.mask = {(10, 34), (0, 14)}
flashcard.save()	66	129	flashcard.save()
self.fail()	67	130	self.fail()
except OverlapIntervalException:	68	131	except OverlapIntervalException:

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

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

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)
lecture_times = CharField()	73	73	lecture_times = CharField()
short_name = CharField()	74	74	short_name = CharField()
long_name = CharField()	75	75	long_name = CharField()
	76	76
class Meta:	77	77	class Meta:
model = Section	78	78	model = Section
	79	79
	80	80
class UserSerializer(ModelSerializer):	81	81	class UserSerializer(ModelSerializer):
email = EmailField(required=False)	82	82	email = EmailField(required=False)
sections = HyperlinkedRelatedField(queryset=Section.objects.all(), many=True, view_name='section-detail')	83	83	sections = HyperlinkedRelatedField(queryset=Section.objects.all(), many=True, view_name='section-detail')
is_confirmed = BooleanField()	84	84	is_confirmed = BooleanField()
	85	85
class Meta:	86	86	class Meta:
model = User	87	87	model = User
fields = ("sections", "email", "is_confirmed", "last_login", "date_joined")	88	88	fields = ("sections", "email", "is_confirmed", "last_login", "date_joined")
	89	89
	90	90
class MaskFieldSerializer(serializers.Field):	91	91	class MaskFieldSerializer(serializers.Field):
default_error_messages = {	92	92	default_error_messages = {
'max_length': 'Ensure this field has no more than {max_length} characters.',	93	93	'max_length': 'Ensure this field has no more than {max_length} characters.',
'interval': 'Ensure this field has valid intervals.',	94	94	'interval': 'Ensure this field has valid intervals.',
'overlap': 'Ensure this field does not have overlapping intervals.'	95	95	'overlap': 'Ensure this field does not have overlapping intervals.'
}	96	96	}
	97	97
def to_representation(self, value):	98	98	def to_representation(self, value):
return dumps(list(self._make_mask(value)))	99	99	return dumps(list(self._make_mask(value)))
	100	100
def to_internal_value(self, value):	101	101	def to_internal_value(self, value):
return self._make_mask(loads(value))	102	102	return self._make_mask(loads(value))
	103	103
def _make_mask(self, data):	104	104	def _make_mask(self, data):
try:	105	105	try:
mask = FlashcardMask(data)	106	106	mask = FlashcardMask(data)
except ValueError:	107	107	except ValueError:
raise serializers.ValidationError("Invalid JSON for MaskField")	108	108	raise serializers.ValidationError("Invalid JSON for MaskField")
except TypeError:	109	109	except TypeError:
raise serializers.ValidationError("Invalid data for MaskField.")	110	110	raise serializers.ValidationError("Invalid data for MaskField.")
except OverlapIntervalException:	111	111	except OverlapIntervalException:
raise serializers.ValidationError("Invalid intervals for MaskField data.")	112	112	raise serializers.ValidationError("Invalid intervals for MaskField data.")
if len(mask) > 32:	113	113	if len(mask) > 32:
raise serializers.ValidationError("Too many intervals in the mask.")	114	114	raise serializers.ValidationError("Too many intervals in the mask.")
return mask	115	115	return mask
	116	116
	117	117
class FlashcardSerializer(ModelSerializer):	118	118	class FlashcardSerializer(ModelSerializer):
is_hidden = BooleanField(read_only=True)	119	119	is_hidden = BooleanField(read_only=True)
hide_reason = CharField(read_only=True)	120	120	hide_reason = CharField(read_only=True)
material_date = DateTimeField(default=now)	121	121	material_date = DateTimeField(default=now)
mask = MaskFieldSerializer()	122	122	mask = MaskFieldSerializer()
	123	123
def validate_material_date(self, value):	124	124	def validate_material_date(self, value):
utc = pytz.UTC	125	125	utc = pytz.UTC
# TODO: make this dynamic	126	126	# TODO: make this dynamic
quarter_start = utc.localize(datetime(2015, 3, 15))	127	127	quarter_start = utc.localize(datetime(2015, 3, 15))
quarter_end = utc.localize(datetime(2015, 6, 15))	128	128	quarter_end = utc.localize(datetime(2015, 6, 15))
	129	129
if quarter_start <= value <= quarter_end:	130	130	if quarter_start <= value <= quarter_end:
return value	131	131	return value
else:	132	132	else:
raise serializers.ValidationError("Material date is outside allowed range for this quarter")	133	133	raise serializers.ValidationError("Material date is outside allowed range for this quarter")
	134	134
def validate_previous(self, value):	135	135	def validate_previous(self, value):
if value is None:	136	136	if value is None:
return value	137	137	return value
if Flashcard.objects.filter(pk=value).count() > 0:	138	138	if Flashcard.objects.filter(pk=value).count() > 0:
return value	139	139	return value
raise serializers.ValidationError("Invalid previous Flashcard object")	140	140	raise serializers.ValidationError("Invalid previous Flashcard object")

from django.core import mail	1	1	from django.core import mail
from flashcards.models import User, Section, Flashcard, WhitelistedAddress	2	2	from flashcards.models import User, Section, Flashcard, WhitelistedAddress
from rest_framework.status import HTTP_204_NO_CONTENT, HTTP_201_CREATED, HTTP_200_OK, HTTP_403_FORBIDDEN	3	3	from rest_framework.status import HTTP_204_NO_CONTENT, HTTP_201_CREATED, HTTP_200_OK, HTTP_403_FORBIDDEN
from rest_framework.test import APITestCase	4	4	from rest_framework.test import APITestCase
from re import search	5	5	from re import search
from django.utils.timezone import now	6	6	from django.utils.timezone import now
	7	7
	8	8
class LoginTests(APITestCase):	9	9	class LoginTests(APITestCase):
fixtures = ['testusers']	10	10	fixtures = ['testusers']
	11	11
def test_login(self):	12	12	def test_login(self):
url = '/api/login'	13	13	url = '/api/login'
data = {'email': 'none@none.com', 'password': '1234'}	14	14	data = {'email': 'none@none.com', 'password': '1234'}
response = self.client.post(url, data, format='json')	15	15	response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, HTTP_200_OK)	16	16	self.assertEqual(response.status_code, HTTP_200_OK)
	17	17
data = {'email': 'none@none.com', 'password': '4321'}	18	18	data = {'email': 'none@none.com', 'password': '4321'}
response = self.client.post(url, data, format='json')	19	19	response = self.client.post(url, data, format='json')
self.assertContains(response, 'Invalid email or password', status_code=403)	20	20	self.assertContains(response, 'Invalid email or password', status_code=403)
	21	21
data = {'email': 'bad@none.com', 'password': '1234'}	22	22	data = {'email': 'bad@none.com', 'password': '1234'}
response = self.client.post(url, data, format='json')	23	23	response = self.client.post(url, data, format='json')
self.assertContains(response, 'Invalid email or password', status_code=403)	24	24	self.assertContains(response, 'Invalid email or password', status_code=403)
	25	25
data = {'password': '4321'}	26	26	data = {'password': '4321'}
response = self.client.post(url, data, format='json')	27	27	response = self.client.post(url, data, format='json')
self.assertContains(response, 'email', status_code=400)	28	28	self.assertContains(response, 'email', status_code=400)
	29	29
data = {'email': 'none@none.com'}	30	30	data = {'email': 'none@none.com'}
response = self.client.post(url, data, format='json')	31	31	response = self.client.post(url, data, format='json')
self.assertContains(response, 'password', status_code=400)	32	32	self.assertContains(response, 'password', status_code=400)
	33	33
user = User.objects.get(email="none@none.com")	34	34	user = User.objects.get(email="none@none.com")
user.is_active = False	35	35	user.is_active = False
user.save()	36	36	user.save()
	37	37
data = {'email': 'none@none.com', 'password': '1234'}	38	38	data = {'email': 'none@none.com', 'password': '1234'}
response = self.client.post(url, data, format='json')	39	39	response = self.client.post(url, data, format='json')
self.assertContains(response, 'Account is disabled', status_code=403)	40	40	self.assertContains(response, 'Account is disabled', status_code=403)
	41	41
def test_logout(self):	42	42	def test_logout(self):
self.client.login(email='none@none.com', password='1234')	43	43	self.client.login(email='none@none.com', password='1234')
response = self.client.post('/api/logout')	44	44	response = self.client.post('/api/logout')
self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)	45	45	self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)
	46	46
# since we're not logged in, we should get a 403 response	47	47	# since we're not logged in, we should get a 403 response
response = self.client.get('/api/me', format='json')	48	48	response = self.client.get('/api/me', format='json')
self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)	49	49	self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)
	50	50
	51	51
class PasswordResetTest(APITestCase):	52	52	class PasswordResetTest(APITestCase):
fixtures = ['testusers']	53	53	fixtures = ['testusers']
	54	54
def test_reset_password(self):	55	55	def test_reset_password(self):
# submit the request to reset the password	56	56	# submit the request to reset the password
url = '/api/request_password_reset'	57	57	url = '/api/request_password_reset'
post_data = {'email': 'none@none.com'}	58	58	post_data = {'email': 'none@none.com'}
self.client.post(url, post_data, format='json')	59	59	self.client.post(url, post_data, format='json')
self.assertEqual(len(mail.outbox), 1)	60	60	self.assertEqual(len(mail.outbox), 1)
self.assertIn('reset your password', mail.outbox[0].body)	61	61	self.assertIn('reset your password', mail.outbox[0].body)
	62	62
# capture the reset token from the email	63	63	# capture the reset token from the email
capture = search('https://flashy.cards/app/reset_password/(\d+)/(.*)',	64	64	capture = search('https://flashy.cards/app/reset_password/(\d+)/(.*)',
mail.outbox[0].body)	65	65	mail.outbox[0].body)
patch_data = {'new_password': '4321'}	66	66	patch_data = {'new_password': '4321'}
patch_data['uid'] = capture.group(1)	67	67	patch_data['uid'] = capture.group(1)
reset_token = capture.group(2)	68	68	reset_token = capture.group(2)
	69	69
# try to reset the password with the wrong reset token	70	70	# try to reset the password with the wrong reset token
patch_data['token'] = 'wrong_token'	71	71	patch_data['token'] = 'wrong_token'
url = '/api/reset_password'	72	72	url = '/api/reset_password'
response = self.client.post(url, patch_data, format='json')	73	73	response = self.client.post(url, patch_data, format='json')
self.assertContains(response, 'Could not verify reset token', status_code=400)	74	74	self.assertContains(response, 'Could not verify reset token', status_code=400)
	75	75
# try to reset the password with the correct token	76	76	# try to reset the password with the correct token
patch_data['token'] = reset_token	77	77	patch_data['token'] = reset_token
response = self.client.post(url, patch_data, format='json')	78	78	response = self.client.post(url, patch_data, format='json')
self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)	79	79	self.assertEqual(response.status_code, HTTP_204_NO_CONTENT)
user = User.objects.get(id=patch_data['uid'])	80	80	user = User.objects.get(id=patch_data['uid'])
assert user.check_password(patch_data['new_password'])	81	81	assert user.check_password(patch_data['new_password'])
	82	82
	83	83
class RegistrationTest(APITestCase):	84	84	class RegistrationTest(APITestCase):
def test_create_account(self):	85	85	def test_create_account(self):
url = '/api/register'	86	86	url = '/api/register'
	87	87
# missing password	88	88	# missing password
data = {'email': 'none@none.com'}	89	89	data = {'email': 'none@none.com'}
response = self.client.post(url, data, format='json')	90	90	response = self.client.post(url, data, format='json')
self.assertContains(response, 'password', status_code=400)	91	91	self.assertContains(response, 'password', status_code=400)
	92	92
# missing email	93	93	# missing email
data = {'password': '1234'}	94	94	data = {'password': '1234'}
response = self.client.post(url, data, format='json')	95	95	response = self.client.post(url, data, format='json')
self.assertContains(response, 'email', status_code=400)	96	96	self.assertContains(response, 'email', status_code=400)
	97	97
# create a user	98	98	# create a user
data = {'email': 'none@none.com', 'password': '1234'}	99	99	data = {'email': 'none@none.com', 'password': '1234'}
response = self.client.post(url, data, format='json')	100	100	response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, HTTP_201_CREATED)	101	101	self.assertEqual(response.status_code, HTTP_201_CREATED)
	102	102
# user should not be confirmed	103	103	# user should not be confirmed
user = User.objects.get(email="none@none.com")	104	104	user = User.objects.get(email="none@none.com")
self.assertFalse(user.is_confirmed)	105	105	self.assertFalse(user.is_confirmed)
	106	106
# check that the confirmation key was sent	107	107	# check that the confirmation key was sent
self.assertEqual(len(mail.outbox), 1)	108	108	self.assertEqual(len(mail.outbox), 1)
self.assertIn(user.confirmation_key, mail.outbox[0].body)	109	109	self.assertIn(user.confirmation_key, mail.outbox[0].body)
	110	110
# log the user out	111	111	# log the user out
self.client.logout()	112	112	self.client.logout()
	113	113
# log the user in with their registered credentials	114	114	# log the user in with their registered credentials
self.client.login(email='none@none.com', password='1234')	115	115	self.client.login(email='none@none.com', password='1234')
	116	116
# try activating with an invalid key	117	117	# try activating with an invalid key
	118	118
url = '/api/me'	119	119	url = '/api/me'
response = self.client.patch(url, {'confirmation_key': 'NOT A KEY'})	120	120	response = self.client.patch(url, {'confirmation_key': 'NOT A KEY'})
self.assertContains(response, 'confirmation_key is invalid', status_code=400)	121	121	self.assertContains(response, 'confirmation_key is invalid', status_code=400)
	122	122
# try activating with the valid key	123	123	# try activating with the valid key
response = self.client.patch(url, {'confirmation_key': user.confirmation_key})	124	124	response = self.client.patch(url, {'confirmation_key': user.confirmation_key})
self.assertTrue(response.data['is_confirmed'])	125	125	self.assertTrue(response.data['is_confirmed'])
	126	126
	127	127
class ProfileViewTest(APITestCase):	128	128	class ProfileViewTest(APITestCase):
fixtures = ['testusers']	129	129	fixtures = ['testusers']
	130	130
def test_get_me(self):	131	131	def test_get_me(self):
url = '/api/me'	132	132	url = '/api/me'
response = self.client.get(url, format='json')	133	133	response = self.client.get(url, format='json')
# since we're not logged in, we shouldn't be able to see this	134	134	# since we're not logged in, we shouldn't be able to see this
self.assertEqual(response.status_code, 403)	135	135	self.assertEqual(response.status_code, 403)
	136	136
self.client.login(email='none@none.com', password='1234')	137	137	self.client.login(email='none@none.com', password='1234')
response = self.client.get(url, format='json')	138	138	response = self.client.get(url, format='json')
self.assertEqual(response.status_code, HTTP_200_OK)	139	139	self.assertEqual(response.status_code, HTTP_200_OK)
	140	140
	141	141
class PasswordChangeTest(APITestCase):	142	142	class PasswordChangeTest(APITestCase):
fixtures = ['testusers']	143	143	fixtures = ['testusers']
	144	144
def test_change_password(self):	145	145	def test_change_password(self):
url = '/api/me'	146	146	url = '/api/me'
user = User.objects.get(email='none@none.com')	147	147	user = User.objects.get(email='none@none.com')
self.assertTrue(user.check_password('1234'))	148	148	self.assertTrue(user.check_password('1234'))
	149	149
response = self.client.patch(url, {'new_password': '4321', 'old_password': '1234'}, format='json')	150	150	response = self.client.patch(url, {'new_password': '4321', 'old_password': '1234'}, format='json')
self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)	151	151	self.assertEqual(response.status_code, HTTP_403_FORBIDDEN)
	152	152
self.client.login(email='none@none.com', password='1234')	153	153	self.client.login(email='none@none.com', password='1234')
response = self.client.patch(url, {'new_password': '4321'}, format='json')	154	154	response = self.client.patch(url, {'new_password': '4321'}, format='json')
self.assertContains(response, 'old_password is required', status_code=400)	155	155	self.assertContains(response, 'old_password is required', status_code=400)
	156	156
response = self.client.patch(url, {'new_password': '4321', 'old_password': '4321'}, format='json')	157	157	response = self.client.patch(url, {'new_password': '4321', 'old_password': '4321'}, format='json')
self.assertContains(response, 'old_password is incorrect', status_code=400)	158	158	self.assertContains(response, 'old_password is incorrect', status_code=400)
	159	159
response = self.client.patch(url, {'new_password': '4321', 'old_password': '1234'}, format='json')	160	160	response = self.client.patch(url, {'new_password': '4321', 'old_password': '1234'}, format='json')
self.assertEqual(response.status_code, 200)	161	161	self.assertEqual(response.status_code, 200)
user = User.objects.get(email='none@none.com')	162	162	user = User.objects.get(email='none@none.com')
	163	163
self.assertFalse(user.check_password('1234'))	164	164	self.assertFalse(user.check_password('1234'))
self.assertTrue(user.check_password('4321'))	165	165	self.assertTrue(user.check_password('4321'))
	166	166
	167	167
class DeleteUserTest(APITestCase):	168	168	class DeleteUserTest(APITestCase):
fixtures = ['testusers']	169	169	fixtures = ['testusers']
	170	170
def test_delete_user(self):	171	171	def test_delete_user(self):
url = '/api/me'	172	172	url = '/api/me'
user = User.objects.get(email='none@none.com')	173	173	user = User.objects.get(email='none@none.com')
	174	174
self.client.login(email='none@none.com', password='1234')	175	175	self.client.login(email='none@none.com', password='1234')
self.client.delete(url)	176	176	self.client.delete(url)
self.assertFalse(User.objects.filter(email='none@none.com').exists())	177	177	self.assertFalse(User.objects.filter(email='none@none.com').exists())
	178	178
	179	179
class FlashcardDetailTest(APITestCase):	180	180	class FlashcardDetailTest(APITestCase):
fixtures = ['testusers', 'testsections']	181	181	fixtures = ['testusers', 'testsections']
	182	182
def setUp(self):	183	183	def setUp(self):
section = Section.objects.get(pk=1)	184	184	section = Section.objects.get(pk=1)
user = User.objects.get(email='none@none.com')	185	185	user = User.objects.get(email='none@none.com')
	186	186
self.flashcard = Flashcard(text="jason", section=section, material_date=now(), author=user)	187	187	self.flashcard = Flashcard(text="jason", section=section, material_date=now(), author=user)
self.flashcard.save()	188	188	self.flashcard.save()
	189	189
def test_get_flashcard(self):	190	190	def test_get_flashcard(self):
self.client.login(email='none@none.com', password='1234')	191	191	self.client.login(email='none@none.com', password='1234')
response = self.client.get("/api/flashcards/%d/" % self.flashcard.id, format="json")	192	192	response = self.client.get("/api/flashcards/%d/" % self.flashcard.id, format="json")
self.assertEqual(response.status_code, HTTP_200_OK)	193	193	self.assertEqual(response.status_code, HTTP_200_OK)
self.assertEqual(response.data["text"], "jason")	194	194	self.assertEqual(response.data["text"], "jason")
	195	195
	196	196
class SectionViewSetTest(APITestCase):	197	197	class SectionViewSetTest(APITestCase):
fixtures = ['testusers', 'testsections']	198	198	fixtures = ['testusers', 'testsections']

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