110swag / flashy-backend

Commit 2f49f8258704c96bd02d13a3a0af1a947aff981f

Authored by Laura Hawkins 2015-05-20 12:07:17 -0700

Exists in master

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

Conflicts:
	flashcards/views.py

Showing 12 changed files Inline Diff

flashcards/api.py
flashcards/fields.py
flashcards/models.py
flashcards/serializers.py
flashcards/tests/test_api.py
flashcards/tests/test_models.py
flashcards/validators.py
flashcards/views.py
flashy/settings.py
flashy/urls.py
requirements.txt
scripts/run_production.sh

from django.db import models	1	1	from django.db import models
from validators import FlashcardMask, OverlapIntervalException	2	2	from validators import FlashcardMask, OverlapIntervalException
	3	3
	4	4
class MaskField(models.Field):	5	5	class MaskField(models.Field):
def __init__(self, blank_sep=',', range_sep='-', args, *kwargs):	6	6	def __init__(self, blank_sep=',', range_sep='-', args, *kwargs):
self.blank_sep = blank_sep	7	7	self.blank_sep = blank_sep
self.range_sep = range_sep	8	8	self.range_sep = range_sep
super(MaskField, self).__init__(args, *kwargs)	9	9	super(MaskField, self).__init__(args, *kwargs)
	10	10
@staticmethod	11	11	@staticmethod
def _using_array(connection):	12	12	def _using_array(connection):
return connection.settings_dict['ENGINE'] == 'django.db.backends.postgresql_psycopg2'	13	13	return connection.settings_dict['ENGINE'] == 'django.db.backends.postgresql_psycopg2'
	14	14
def deconstruct(self):	15	15	def deconstruct(self):
name, path, args, kwargs = super(MaskField, self).deconstruct()	16	16	name, path, args, kwargs = super(MaskField, self).deconstruct()
kwargs['blank_sep'] = self.blank_sep	17	17	kwargs['blank_sep'] = self.blank_sep
kwargs['range_sep'] = self.range_sep	18	18	kwargs['range_sep'] = self.range_sep
return name, path, args, kwargs	19	19	return name, path, args, kwargs
	20	20
def db_type(self, connection):	21	21	def db_type(self, connection):
return 'integer[2][]' if self._using_array(connection) else 'varchar'	22	22	return 'integer[2][]' if self._using_array(connection) else 'varchar'
	23	23
def from_db_value(self, value, expression, connection, context):	24	24	def from_db_value(self, value, expression, connection, context):
if value is None:	25	25	if value is None:
return value	26	26	return value
if self._using_array(connection):	27	27	if self._using_array(connection):
return MaskField._psql_parse_mask(value)	28	28	return MaskField._psql_parse_mask(value)
return MaskField._varchar_parse_mask(value)	29	29	return MaskField._varchar_parse_mask(value)
	30	30
def get_db_prep_value(self, value, connection, prepared=False):	31	31	def get_db_prep_value(self, value, connection, prepared=False):
if not prepared:	32	32	if not prepared:
value = self.get_prep_value(value)	33	33	value = self.get_prep_value(value)
if value is None:	34	34	if value is None:
return value	35	35	return value
if self._using_array(connection):	36	36	if self._using_array(connection):
return value	37	37	return value
return ','.join(['-'.join(map(str, i)) for i in value])	38	38	return ','.join(['-'.join(map(str, i)) for i in value])
	39	39
def to_python(self, value):	40	40	def to_python(self, value):
if value is None:	41	41	if value is None:
return value	42	42	return value
return sorted(list(FlashcardMask(value)))	43	43	return FlashcardMask(value)
	44	44
def get_prep_value(self, value):	45	45	def get_prep_value(self, value):
if value is None:	46	46	if value is None:
return value	47	47	return value
return sorted(map(list, FlashcardMask(value)))	48	48	return sorted(map(list, FlashcardMask(value)))
	49	49
def get_prep_lookup(self, lookup_type, value):	50	50	def get_prep_lookup(self, lookup_type, value):
raise TypeError("Lookup not supported for MaskField")	51	51	raise TypeError("Lookup not supported for MaskField")
	52	52
@staticmethod	53	53	@staticmethod
def _parse_mask(intervals):	54	54	def _parse_mask(intervals):
p_beg, p_end = -1, -1	55	55	p_beg, p_end = -1, -1
mask_list = []	56	56	mask_list = []
for interval in intervals:	57	57	for interval in intervals:
beg, end = map(int, interval)	58	58	beg, end = map(int, interval)
if not (0 <= beg <= 255) or not (0 <= end <= 255) or not (beg <= end) or not (beg > p_end):	59	59	if not (0 <= beg <= 255) or not (0 <= end <= 255) or not (beg <= end) or not (beg > p_end):
raise ValueError("Invalid range offsets in the mask")	60	60	raise ValueError("Invalid range offsets in the mask")
mask_list.append([beg, end])	61	61	mask_list.append([beg, end])
p_beg, p_end = beg, end	62	62	p_beg, p_end = beg, end
return mask_list	63	63	return mask_list

from json import dumps, loads	1	1	from json import dumps, loads
	2	2
from django.utils.datetime_safe import datetime	3	3	from django.utils.datetime_safe import datetime
from django.utils.timezone import now	4	4	from django.utils.timezone import now
import pytz	5	5	import pytz
from flashcards.models import Section, LecturePeriod, User, Flashcard	6	6	from flashcards.models import Section, LecturePeriod, User, Flashcard, UserFlashcard, UserFlashcardQuiz
from flashcards.validators import FlashcardMask, OverlapIntervalException	7	7	from flashcards.validators import FlashcardMask, OverlapIntervalException
from rest_framework import serializers	8	8	from rest_framework import serializers
from rest_framework.fields import EmailField, BooleanField, CharField, IntegerField, DateTimeField	9	9	from rest_framework.fields import EmailField, BooleanField, CharField, IntegerField, DateTimeField, empty
from rest_framework.serializers import ModelSerializer, Serializer	10	10	from rest_framework.serializers import ModelSerializer, Serializer, PrimaryKeyRelatedField, ListField
from rest_framework.validators import UniqueValidator	11	11	from rest_framework.validators import UniqueValidator
		12	from flashy.settings import QUARTER_END, QUARTER_START
		13	from random import sample
	12	14
	13	15
class EmailSerializer(Serializer):	14	16	class EmailSerializer(Serializer):
email = EmailField(required=True)	15	17	email = EmailField(required=True)
	16	18
	17	19
class EmailPasswordSerializer(EmailSerializer):	18	20	class EmailPasswordSerializer(EmailSerializer):
password = CharField(required=True)	19	21	password = CharField(required=True)
	20	22
	21	23
class RegistrationSerializer(EmailPasswordSerializer):	22	24	class RegistrationSerializer(EmailPasswordSerializer):
email = EmailField(required=True, validators=[UniqueValidator(queryset=User.objects.all())])	23	25	email = EmailField(required=True, validators=[UniqueValidator(queryset=User.objects.all())])
	24	26
	25	27
class PasswordResetRequestSerializer(EmailSerializer):	26	28	class PasswordResetRequestSerializer(EmailSerializer):
def validate_email(self, value):	27	29	def validate_email(self, value):
try:	28	30	try:
User.objects.get(email=value)	29	31	User.objects.get(email=value)
return value	30	32	return value
except User.DoesNotExist:	31	33	except User.DoesNotExist:
raise serializers.ValidationError('No user exists with that email')	32	34	raise serializers.ValidationError('No user exists with that email')
	33	35
	34	36
class PasswordResetSerializer(Serializer):	35	37	class PasswordResetSerializer(Serializer):
new_password = CharField(required=True, allow_blank=False)	36	38	new_password = CharField(required=True, allow_blank=False)
uid = IntegerField(required=True)	37	39	uid = IntegerField(required=True)
token = CharField(required=True)	38	40	token = CharField(required=True)
	39	41
def validate_uid(self, value):	40	42	def validate_uid(self, value):
try:	41	43	try:
User.objects.get(id=value)	42	44	User.objects.get(id=value)
return value	43	45	return value
except User.DoesNotExist:	44	46	except User.DoesNotExist:
raise serializers.ValidationError('Could not verify reset token')	45	47	raise serializers.ValidationError('Could not verify reset token')
	46	48
	47	49
class UserUpdateSerializer(Serializer):	48	50	class UserUpdateSerializer(Serializer):
old_password = CharField(required=False)	49	51	old_password = CharField(required=False)
new_password = CharField(required=False, allow_blank=False)	50	52	new_password = CharField(required=False, allow_blank=False)
confirmation_key = CharField(required=False)	51	53	confirmation_key = CharField(required=False)
# reset_token = CharField(required=False)	52	54	# reset_token = CharField(required=False)
	53	55
def validate(self, data):	54	56	def validate(self, data):
if 'new_password' in data and 'old_password' not in data:	55	57	if 'new_password' in data and 'old_password' not in data:
raise serializers.ValidationError('old_password is required to set a new_password')	56	58	raise serializers.ValidationError('old_password is required to set a new_password')
return data	57	59	return data
	58	60
	59	61
class Password(Serializer):	60	62	class Password(Serializer):
email = EmailField(required=True)	61	63	email = EmailField(required=True)
password = CharField(required=True)	62	64	password = CharField(required=True)
	63	65
	64	66
class LecturePeriodSerializer(ModelSerializer):	65	67	class LecturePeriodSerializer(ModelSerializer):
class Meta:	66	68	class Meta:
model = LecturePeriod	67	69	model = LecturePeriod
exclude = 'id', 'section'	68	70	exclude = 'id', 'section'
	69	71
	70	72
class SectionSerializer(ModelSerializer):	71	73	class SectionSerializer(ModelSerializer):
lecture_times = CharField()	72	74	lecture_times = CharField()
short_name = CharField()	73	75	short_name = CharField()
long_name = CharField()	74	76	long_name = CharField()
	75	77
class Meta:	76	78	class Meta:
model = Section	77	79	model = Section
	78	80
class DeepSectionSerializer(SectionSerializer):	79	81	class DeepSectionSerializer(SectionSerializer):
lectures = LecturePeriodSerializer(source='lectureperiod_set', many=True, read_only=True)	80	82	lectures = LecturePeriodSerializer(source='lectureperiod_set', many=True, read_only=True)
	81	83
	82	84
	83	85
class UserSerializer(ModelSerializer):	84	86	class UserSerializer(ModelSerializer):
email = EmailField(required=False)	85	87	email = EmailField(required=False)
sections = SectionSerializer(many=True)	86	88	sections = SectionSerializer(many=True)
is_confirmed = BooleanField()	87	89	is_confirmed = BooleanField()
	88	90
class Meta:	89	91	class Meta:
model = User	90	92	model = User
fields = ("sections", "email", "is_confirmed", "last_login", "date_joined")	91	93	fields = ("sections", "email", "is_confirmed", "last_login", "date_joined")
	92	94
	93	95
class MaskFieldSerializer(serializers.Field):	94	96	class MaskFieldSerializer(serializers.Field):
default_error_messages = {	95	97	default_error_messages = {
'max_length': 'Ensure this field has no more than {max_length} characters.',	96	98	'max_length': 'Ensure this field has no more than {max_length} characters.',
'interval': 'Ensure this field has valid intervals.',	97	99	'interval': 'Ensure this field has valid intervals.',
'overlap': 'Ensure this field does not have overlapping intervals.'	98	100	'overlap': 'Ensure this field does not have overlapping intervals.'
}	99	101	}
	100	102
def to_representation(self, value):	101	103	def to_representation(self, value):
return dumps(list(self._make_mask(value)))	102	104	return dumps(list(self._make_mask(value)))
	103	105
def to_internal_value(self, value):	104	106	def to_internal_value(self, value):
return self._make_mask(loads(value))	105	107	return self._make_mask(loads(value))
	106	108
def _make_mask(self, data):	107	109	def _make_mask(self, data):
try:	108	110	try:
mask = FlashcardMask(data)	109	111	mask = FlashcardMask(data)
except ValueError:	110	112	except ValueError:
raise serializers.ValidationError("Invalid JSON for MaskField")	111	113	raise serializers.ValidationError("Invalid JSON for MaskField")
except TypeError:	112	114	except TypeError:
raise serializers.ValidationError("Invalid data for MaskField.")	113	115	raise serializers.ValidationError("Invalid data for MaskField.")
except OverlapIntervalException:	114	116	except OverlapIntervalException:
raise serializers.ValidationError("Invalid intervals for MaskField data.")	115	117	raise serializers.ValidationError("Invalid intervals for MaskField data.")
if len(mask) > 32:	116	118	if len(mask) > 32:
raise serializers.ValidationError("Too many intervals in the mask.")	117	119	raise serializers.ValidationError("Too many intervals in the mask.")
return mask	118	120	return mask
	119	121
	120	122
class FlashcardSerializer(ModelSerializer):	121	123	class FlashcardSerializer(ModelSerializer):
is_hidden = BooleanField(read_only=True)	122	124	is_hidden = BooleanField(read_only=True)
hide_reason = CharField(read_only=True)	123	125	hide_reason = CharField(read_only=True)
material_date = DateTimeField(default=now)	124	126	material_date = DateTimeField(default=now)
mask = MaskFieldSerializer(allow_null=True)	125	127	mask = MaskFieldSerializer(allow_null=True)
	126	128
def validate_material_date(self, value):	127	129	def validate_material_date(self, value):
utc = pytz.UTC	128
# TODO: make this dynamic	129	130	# TODO: make this dynamic
quarter_start = utc.localize(datetime(2015, 3, 15))	130	131	if QUARTER_START <= value <= QUARTER_END:
quarter_end = utc.localize(datetime(2015, 6, 15))	131
	132
if quarter_start <= value <= quarter_end:	133
return value	134	132	return value
else:	135	133	else:
raise serializers.ValidationError("Material date is outside allowed range for this quarter")	136	134	raise serializers.ValidationError("Material date is outside allowed range for this quarter")
	137	135
def validate_pushed(self, value):	138	136	def validate_pushed(self, value):
if value > datetime.now():	139	137	if value > datetime.now():
raise serializers.ValidationError("Invalid creation date for the Flashcard")	140	138	raise serializers.ValidationError("Invalid creation date for the Flashcard")
return value	141	139	return value
	142	140
def validate_mask(self, value):	143	141	def validate_mask(self, value):
if value is None:	144	142	if value is None:
return None	145	143	return None
if len(self.initial_data['text']) < value.max_offset():	146	144	if len(self.initial_data['text']) < value.max_offset():
raise serializers.ValidationError("Mask out of bounds")	147	145	raise serializers.ValidationError("Mask out of bounds")
return value	148	146	return value
	149	147
class Meta:	150	148	class Meta:
model = Flashcard	151	149	model = Flashcard
exclude = 'author', 'previous'	152	150	exclude = 'author', 'previous'
	153	151
	154	152
class FlashcardUpdateSerializer(serializers.Serializer):	155	153	class FlashcardUpdateSerializer(serializers.Serializer):
text = CharField(max_length=255, required=False)	156	154	text = CharField(max_length=255, required=False)
material_date = DateTimeField(required=False)	157	155	material_date = DateTimeField(required=False)
mask = MaskFieldSerializer(required=False)	158	156	mask = MaskFieldSerializer(required=False)
	159	157
def validate_material_date(self, date):	160	158	def validate_material_date(self, date):
quarter_end = pytz.UTC.localize(datetime(2015, 6, 15))	161	159	if date > QUARTER_END:
if date > quarter_end:	162
raise serializers.ValidationError("Invalid material_date for the flashcard")	163	160	raise serializers.ValidationError("Invalid material_date for the flashcard")
return date	164	161	return date
	165	162
def validate(self, attrs):	166	163	def validate(self, attrs):
# Make sure that at least one of the attributes was passed in	167	164	# Make sure that at least one of the attributes was passed in
if not any(i in attrs for i in ['material_date', 'text', 'mask']):	168	165	if not any(i in attrs for i in ['material_date', 'text', 'mask']):
raise serializers.ValidationError("No new value passed in")	169	166	raise serializers.ValidationError("No new value passed in")
return attrs	170	167	return attrs
		168
		169
		170	class QuizRequestSerializer(serializers.Serializer):
		171	# sections = PrimaryKeyRelatedField(queryset=Section.objects.all(),required=False, many=True)
		172	sections = ListField(child=IntegerField(min_value=1), required=False)
		173	material_date_begin = DateTimeField(default=QUARTER_START)
		174	material_date_end = DateTimeField(default=QUARTER_END)
		175
		176	def __init__(self, user, args, *kwargs):
		177	super(QuizRequestSerializer, self).__init__(args, *kwargs)
		178	self.user = user
		179	self.user_flashcard = None
		180
		181	def create(self, validated_data):
		182	return UserFlashcardQuiz.objects.create(user_flashcard=self.user_flashcard)
		183
		184	def update(self, instance, validated_data):
		185	for attr in validated_data:
		186	setattr(instance, attr, validated_data[attr])
		187	instance.save()
		188	return instance
		189
		190	def _get_user_flashcard(self, attrs):
		191	user_flashcard_filter = UserFlashcard.objects.filter(
		192	user=self.user, flashcard__section__in=attrs['sections'],
		193	flashcard__material_date__gte=attrs['material_date_begin'],
		194	flashcard__material_date__lte=attrs['material_date_end']
		195	)
		196	if not user_flashcard_filter.exists():
		197	raise serializers.ValidationError("Your deck for that section is empty")
		198	self.user_flashcard = user_flashcard_filter.order_by('?').first()
		199
		200	def validate_material_date_begin(self, value):
		201	if QUARTER_START <= value <= QUARTER_END:
		202	return value
		203	raise serializers.ValidationError("Invalid begin date for the flashcard range")
		204
		205	def validate_material_date_end(self, value):
		206	if QUARTER_START <= value <= QUARTER_END:
		207	return value
		208	raise serializers.ValidationError("Invalid end date for the flashcard range")
		209
		210	def validate_sections(self, value):
		211	if value is None:
		212	return self.user.sections
		213	section_filter = Section.objects.filter(pk__in=value)
		214	if not section_filter.exists():
		215	raise serializers.ValidationError("You aren't enrolled in those section(s)")
		216	return section_filter
		217
		218	def validate(self, attrs):
		219	if attrs['material_date_begin'] > attrs['material_date_end']:
		220	raise serializers.ValidationError("Invalid range")
		221	if 'sections' not in attrs:
		222	attrs['sections'] = self.validate_sections(None)
		223	self._get_user_flashcard(attrs)
		224	return attrs
		225
		226
		227	class QuizResponseSerializer(ModelSerializer):
		228	pk = PrimaryKeyRelatedField(queryset=UserFlashcardQuiz.objects.all(), many=True)
		229	section = PrimaryKeyRelatedField(queryset=Section.objects.all())
		230	text = CharField(max_length=255)
		231	mask = ListField(child=IntegerField())
		232
		233	def __init__(self, instance=None, mask=[], data=empty, **kwargs):
		234	super(QuizResponseSerializer, self).__init__(instance=instance, data=data, **kwargs)
		235	self.mask = self._validate_mask(mask)
		236
		237	def to_representation(self, instance):
		238	return {
		239	'pk': instance.user_flashcard.pk,
		240	'section': instance.user_flashcard.flashcard.section.pk,
		241	'text': instance.user_flashcard.flashcard.text,
		242	'mask': self.mask
		243	}
		244
		245	def _validate_mask(self, value):
		246	if not isinstance(value, tuple) and value is not None:
		247	raise serializers.ValidationError("The selected mask has to be a list")

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, UserFlashcard	4	4	from flashcards.models import User, Section, Flashcard, UserFlashcard, UserFlashcardQuiz
from flashcards.validators import FlashcardMask, OverlapIntervalException	5	5	from flashcards.validators import FlashcardMask, OverlapIntervalException
		6	from flashcards.serializers import QuizRequestSerializer, QuizResponseSerializer, QuizAnswerRequestSerializer
		7	from flashy.settings import QUARTER_START, QUARTER_END
	6	8
	7	9
class RegistrationTests(TestCase):	8	10	class RegistrationTests(TestCase):
def setUp(self):	9	11	def setUp(self):
User.objects.create_user(email="none@none.com", password="1234")	10	12	User.objects.create_user(email="none@none.com", password="1234")
	11	13
def test_email_confirmation(self):	12	14	def test_email_confirmation(self):
user = User.objects.get(email="none@none.com")	13	15	user = User.objects.get(email="none@none.com")
self.assertFalse(user.is_confirmed)	14	16	self.assertFalse(user.is_confirmed)
user.confirm_email(user.confirmation_key)	15	17	user.confirm_email(user.confirmation_key)
self.assertTrue(user.is_confirmed)	16	18	self.assertTrue(user.is_confirmed)
	17	19
	18	20
class UserTests(TestCase):	19	21	class UserTests(TestCase):
def setUp(self):	20	22	def setUp(self):
User.objects.create_user(email="none@none.com", password="1234")	21	23	User.objects.create_user(email="none@none.com", password="1234")
Section.objects.create(department='dept',	22	24	Section.objects.create(department='dept',
course_num='101a',	23	25	course_num='101a',
course_title='how 2 test',	24	26	course_title='how 2 test',
instructor='George Lucas',	25	27	instructor='George Lucas',
quarter='SP15')	26	28	quarter='SP15')
	27	29
def test_section_list(self):	28	30	def test_section_list(self):
section = Section.objects.get(course_num='101a')	29	31	section = Section.objects.get(course_num='101a')
user = User.objects.get(email="none@none.com")	30	32	user = User.objects.get(email="none@none.com")
self.assertNotIn(section, user.sections.all())	31	33	self.assertNotIn(section, user.sections.all())
user.sections.add(section)	32	34	user.sections.add(section)
self.assertIn(section, user.sections.all())	33	35	self.assertIn(section, user.sections.all())
user.sections.add(section)	34	36	user.sections.add(section)
self.assertEqual(user.sections.count(), 1)	35	37	self.assertEqual(user.sections.count(), 1)
user.sections.remove(section)	36	38	user.sections.remove(section)
self.assertEqual(user.sections.count(), 0)	37	39	self.assertEqual(user.sections.count(), 0)
	38	40
	39	41
class FlashcardMaskTest(TestCase):	40	42	class FlashcardMaskTest(TestCase):
def test_empty(self):	41	43	def test_empty(self):
try:	42	44	try:
fm = FlashcardMask([])	43	45	fm = FlashcardMask([])
self.assertEqual(fm.max_offset(), -1)	44	46	self.assertEqual(fm.max_offset(), -1)
except TypeError:	45	47	except TypeError:
self.fail()	46	48	self.fail()
try:	47	49	try:
fm = FlashcardMask('')	48	50	fm = FlashcardMask('')
self.assertEqual(fm.max_offset(), -1)	49	51	self.assertEqual(fm.max_offset(), -1)
except TypeError:	50	52	except TypeError:
self.fail()	51	53	self.fail()
try:	52	54	try:
fm = FlashcardMask(None)	53	55	fm = FlashcardMask(None)
self.assertEqual(fm.max_offset(), -1)	54	56	self.assertEqual(fm.max_offset(), -1)
except TypeError:	55	57	except TypeError:
self.fail()	56	58	self.fail()
	57	59
def test_iterable(self):	58	60	def test_iterable(self):
try:	59	61	try:
FlashcardMask(1)	60	62	FlashcardMask(1)
except TypeError as te:	61	63	except TypeError as te:
self.assertEqual(te.message, "Interval not a valid iterable")	62	64	self.assertEqual(te.message, "Interval not a valid iterable")
try:	63	65	try:
FlashcardMask([1, 2, 4])	64	66	FlashcardMask([1, 2, 4])
except TypeError as te:	65	67	except TypeError as te:
self.assertEqual(te.message, "Interval not a valid iterable")	66	68	self.assertEqual(te.message, "Interval not a valid iterable")
	67	69
def test_interval(self):	68	70	def test_interval(self):
try:	69	71	try:
FlashcardMask([[1, 2, 3], [1]])	70	72	FlashcardMask([[1, 2, 3], [1]])
except TypeError as te:	71	73	except TypeError as te:
self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")	72	74	self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")
try:	73	75	try:
FlashcardMask([[1, 2], [1, 2, 4]])	74	76	FlashcardMask([[1, 2], [1, 2, 4]])
except TypeError as te:	75	77	except TypeError as te:
self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")	76	78	self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")
try:	77	79	try:
FlashcardMask(([1, 2], [1]))	78	80	FlashcardMask(([1, 2], [1]))
except TypeError as te:	79	81	except TypeError as te:
self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")	80	82	self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")
try:	81	83	try:
FlashcardMask("[1,2,3]")	82	84	FlashcardMask("[1,2,3]")
except TypeError as te:	83	85	except TypeError as te:
self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")	84	86	self.assertEqual(te.message, "Intervals must have exactly 2 elements, begin and end")
	85	87
def test_overlap(self):	86	88	def test_overlap(self):
try:	87	89	try:
FlashcardMask({(1, 2), (2, 5)})	88	90	FlashcardMask({(1, 2), (2, 5)})
except OverlapIntervalException as oie:	89	91	except OverlapIntervalException as oie:
self.assertEqual(oie.message, "Invalid interval offsets in the mask")	90	92	self.assertEqual(oie.message, "Invalid interval offsets in the mask")
try:	91	93	try:
FlashcardMask({(1, 20), (12, 15)})	92	94	FlashcardMask({(1, 20), (12, 15)})
except OverlapIntervalException as oie:	93	95	except OverlapIntervalException as oie:
self.assertEqual(oie.message, "Invalid interval offsets in the mask")	94	96	self.assertEqual(oie.message, "Invalid interval offsets in the mask")
try:	95	97	try:
FlashcardMask({(2, 1), (5, 2)})	96	98	FlashcardMask({(2, 1), (5, 2)})
except OverlapIntervalException as oie:	97	99	except OverlapIntervalException as oie:
self.assertEqual(oie.message, "Invalid interval offsets in the mask")	98	100	self.assertEqual(oie.message, "Invalid interval offsets in the mask")
	99	101
	100	102
	101
class FlashcardTests(TestCase):	102	103	class FlashcardTests(TestCase):
def setUp(self):	103	104	def setUp(self):
section = Section.objects.create(department='dept',	104	105	section = Section.objects.create(department='dept',
course_num='101a',	105	106	course_num='101a',
course_title='how 2 test',	106	107	course_title='how 2 test',
instructor='George Lucas',	107	108	instructor='George Lucas',
quarter='SP15')	108	109	quarter='SP15')
user = User.objects.create_user(email="none@none.com", password="1234")	109	110	user = User.objects.create_user(email="none@none.com", password="1234")
user.sections.add(section)	110	111	user.sections.add(section)
flashcard = Flashcard.objects.create(text="This is the text of the Flashcard",	111	112	flashcard = Flashcard.objects.create(text="This is the text of the Flashcard",
section=section,	112	113	section=section,
author=user,	113	114	author=user,
material_date=datetime.now(),	114	115	material_date=datetime.now(),
previous=None,	115	116	previous=None,
mask={(24,34), (0, 4)})	116	117	mask={(24, 34), (0, 4)})
user.save()	117	118	user.save()
section.save()	118	119	section.save()
flashcard.save()	119	120	flashcard.save()
	120	121
def test_flashcard_edit(self):	121	122	def test_flashcard_edit(self):
user = User.objects.get(email="none@none.com")	122	123	user = User.objects.get(email="none@none.com")
user2 = User.objects.create_user(email="wow@wow.com", password="wow")	123	124	user2 = User.objects.create_user(email="wow@wow.com", password="wow")
section = Section.objects.get(course_title='how 2 test')	124	125	section = Section.objects.get(course_title='how 2 test')
user2.sections.add(section)	125	126	user2.sections.add(section)
user2.save()	126	127	user2.save()
flashcard = Flashcard.objects.filter(author=user).get(text="This is the text of the Flashcard")	127	128	flashcard = Flashcard.objects.filter(author=user).get(text="This is the text of the Flashcard")
pk_backup = flashcard.pk	128	129	pk_backup = flashcard.pk
self.assertTrue(user.is_in_section(section))	129	130	self.assertTrue(user.is_in_section(section))
flashcard.edit(user, {})	130	131	flashcard.edit(user, {})
self.assertIsNotNone(flashcard.pk)	131	132	self.assertIsNotNone(flashcard.pk)
UserFlashcard.objects.create(user=user2, flashcard=flashcard).save()	132	133	UserFlashcard.objects.create(user=user2, flashcard=flashcard).save()
flashcard.edit(user2, {'text': 'This is the new text'})	133	134	flashcard.edit(user2, {'text': 'This is the new text'})
self.assertNotEqual(flashcard.pk, pk_backup)	134	135	self.assertNotEqual(flashcard.pk, pk_backup)
self.assertEqual(flashcard.text, 'This is the new text')	135	136	self.assertEqual(flashcard.text, 'This is the new text')
	136	137
def test_mask_field(self):	137	138	def test_mask_field(self):
user = User.objects.get(email="none@none.com")	138	139	user = User.objects.get(email="none@none.com")
flashcard = Flashcard.objects.filter(author=user).get(text="This is the text of the Flashcard")	139	140	flashcard = Flashcard.objects.filter(author=user).get(text="This is the text of the Flashcard")
self.assertTrue(isinstance(flashcard.mask, set))	140	141	self.assertTrue(isinstance(flashcard.mask, set))
self.assertTrue(all([isinstance(interval, tuple) for interval in flashcard.mask]))	141	142	self.assertTrue(all([isinstance(interval, tuple) for interval in flashcard.mask]))
blank1, blank2 = sorted(list(flashcard.mask))	142	143	blank1, blank2 = sorted(list(flashcard.mask))
self.assertEqual(flashcard.text[slice(*blank1)], 'This')	143	144	self.assertEqual(flashcard.text[slice(*blank1)], 'This')
self.assertEqual(flashcard.text[slice(*blank2)], 'Flashcard')	144	145	self.assertEqual(flashcard.text[slice(*blank2)], 'Flashcard')
try:	145	146	try:
flashcard.mask = {(10, 34), (0, 14)}	146	147	flashcard.mask = {(10, 34), (0, 14)}
flashcard.save()	147	148	flashcard.save()
self.fail()	148	149	self.fail()
except OverlapIntervalException:	149	150	except OverlapIntervalException:
self.assertTrue(True)	150	151	self.assertTrue(True)
		152
		153
		154	class UserFlashcardQuizTests(TestCase):
		155	def setUp(self):
		156	self.section = Section.objects.create(department='dept',
		157	course_num='101a',
		158	course_title='how 2 test',
		159	instructor='George Lucas',
		160	quarter='SP15')
		161	self.user = User.objects.create_user(email="none@none.com", password="1234")
		162	self.user.sections.add(self.section)
		163	self.flashcard = Flashcard.objects.create(text="This is the text of the Flashcard",
		164	section=self.section,
		165	author=self.user,
		166	material_date=datetime.now(),
		167	previous=None,
		168	mask=[(24, 33), (0, 4)])
		169	self.user.save()
		170	self.section.save()
		171	self.flashcard.save()
		172	self.user_flashcard = UserFlashcard.objects.create(flashcard=self.flashcard,
		173	user=self.user,
		174	mask=self.flashcard.mask,
		175	pulled=datetime.now())
		176	self.user_flashcard.save()
		177	self.user_flashcard.refresh_from_db()
		178	self.flashcard.refresh_from_db()
		179
		180	def test_quiz_request(self):
		181	data = {'sections': [1], 'material_date_begin': QUARTER_START, 'material_date_end': QUARTER_END}
		182	serializer = QuizRequestSerializer(user=self.user, data=data)
		183	serializer.is_valid(raise_exception=True)
		184	user_flashcard_quiz = serializer.create(serializer.validated_data)
		185	self.assertTrue(isinstance(user_flashcard_quiz, UserFlashcardQuiz))
		186	mask = user_flashcard_quiz.user_flashcard.mask.get_random_blank()
		187	self.assertIn(mask, [(24, 33), (0, 4)])
		188	user_flashcard_quiz.blanked_word = user_flashcard_quiz.user_flashcard.flashcard.text[slice(*mask)]
		189	self.assertIn(user_flashcard_quiz.blanked_word, ["This", "Flashcard"])
		190	user_flashcard_quiz.save()
		191	response = QuizResponseSerializer(instance=user_flashcard_quiz, mask=mask).data
		192	self.assertEqual(response['pk'], 1)
		193	self.assertEqual(response['section'], 1)
		194	self.assertEqual(response['text'], user_flashcard_quiz.user_flashcard.flashcard.text)
		195	self.assertEqual(response['mask'], mask)
		196

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

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)	1	1	# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os	2	2	import os
		3	from datetime import datetime
		4	from pytz import UTC
	3	5
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))	4	6	BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
	5	7
IN_PRODUCTION = 'FLASHY_PRODUCTION' in os.environ	6	8	IN_PRODUCTION = 'FLASHY_PRODUCTION' in os.environ
	7	9
DEBUG = not IN_PRODUCTION	8	10	DEBUG = not IN_PRODUCTION
	9	11
ALLOWED_HOSTS = ['127.0.0.1', 'flashy.cards']	10	12	ALLOWED_HOSTS = ['127.0.0.1', 'flashy.cards']
	11	13
AUTH_USER_MODEL = 'flashcards.User'	12	14	AUTH_USER_MODEL = 'flashcards.User'
REST_FRAMEWORK = {	13	15	REST_FRAMEWORK = {
'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',	14	16	'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',
'PAGE_SIZE': 20	15	17	'PAGE_SIZE': 20
}	16	18	}
INSTALLED_APPS = [	17	19	INSTALLED_APPS = [
'simple_email_confirmation',	18	20	'simple_email_confirmation',
'flashcards',	19	21	'flashcards',
'django.contrib.admin',	20	22	'django.contrib.admin',
'django.contrib.admindocs',	21	23	'django.contrib.admindocs',
'django.contrib.auth',	22	24	'django.contrib.auth',
'django.contrib.contenttypes',	23	25	'django.contrib.contenttypes',
'django.contrib.sessions',	24	26	'django.contrib.sessions',
'django.contrib.messages',	25	27	'django.contrib.messages',
'django.contrib.staticfiles',	26	28	'django.contrib.staticfiles',
	27	29	'ws4redis',
'rest_framework_swagger',	28	30	'rest_framework_swagger',
'rest_framework',	29	31	'rest_framework',
]	30	32	]
	31	33
		34	WEBSOCKET_URL = '/ws/'
		35
		36
MIDDLEWARE_CLASSES = (	32	37	MIDDLEWARE_CLASSES = (
'django.contrib.sessions.middleware.SessionMiddleware',	33	38	'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',	34	39	'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',	35	40	'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',	36	41	'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.auth.middleware.SessionAuthenticationMiddleware',	37	42	'django.contrib.auth.middleware.SessionAuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',	38	43	'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',	39	44	'django.middleware.clickjacking.XFrameOptionsMiddleware',
'django.middleware.security.SecurityMiddleware',	40	45	'django.middleware.security.SecurityMiddleware',
)	41	46	)
	42	47
ROOT_URLCONF = 'flashy.urls'	43	48	ROOT_URLCONF = 'flashy.urls'
	44	49
AUTHENTICATION_BACKENDS = (	45	50	AUTHENTICATION_BACKENDS = (
'django.contrib.auth.backends.ModelBackend',	46	51	'django.contrib.auth.backends.ModelBackend',
)	47	52	)
	48	53
TEMPLATES = [	49	54	TEMPLATES = [
{	50	55	{
'BACKEND': 'django.template.backends.django.DjangoTemplates',	51	56	'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': ['templates/'],	52	57	'DIRS': ['templates/'],
'APP_DIRS': True,	53	58	'APP_DIRS': True,
'OPTIONS': {	54	59	'OPTIONS': {
'context_processors': [	55	60	'context_processors': [
'django.template.context_processors.debug',	56	61	'django.template.context_processors.debug',
'django.template.context_processors.request',	57	62	'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',	58	63	'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',	59	64	'django.contrib.messages.context_processors.messages',
		65	'django.core.context_processors.static',
		66	'ws4redis.context_processors.default',
],	60	67	],
},	61	68	},
},	62	69	},
]	63	70	]
	64	71
WSGI_APPLICATION = 'flashy.wsgi.application'	65	72	WSGI_APPLICATION = 'ws4redis.django_runserver.application'
	66	73
DATABASES = {	67	74	DATABASES = {
'default': {	68	75	'default': {
'ENGINE': 'django.db.backends.sqlite3',	69	76	'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),	70	77	'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}	71	78	}
}	72	79	}
	73	80
if IN_PRODUCTION:	74	81	if IN_PRODUCTION:
DATABASES['default'] = {	75	82	DATABASES['default'] = {
'ENGINE': 'django.db.backends.postgresql_psycopg2',	76	83	'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'flashy',	77	84	'NAME': 'flashy',
'USER': 'flashy',	78	85	'USER': 'flashy',
'PASSWORD': os.environ['FLASHY_DB_PW'],	79	86	'PASSWORD': os.environ['FLASHY_DB_PW'],
'HOST': 'localhost',	80	87	'HOST': 'localhost',
'PORT': '',	81	88	'PORT': '',
}	82	89	}
	83	90
LANGUAGE_CODE = 'en-us'	84	91	LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'America/Los_Angeles'	85	92	TIME_ZONE = 'America/Los_Angeles'
USE_I18N = True	86	93	USE_I18N = True
USE_L10N = True	87	94	USE_L10N = True
USE_TZ = True	88	95	USE_TZ = True
		96
		97	QUARTER_START = UTC.localize(datetime(2015, 3, 30))
		98	QUARTER_END = UTC.localize(datetime(2015, 6, 12))
	89	99
STATIC_URL = '/static/'	90	100	STATIC_URL = '/static/'
STATIC_ROOT = 'static'	91	101	STATIC_ROOT = 'static'
	92	102
# Four settings just to be sure	93	103	# Four settings just to be sure
EMAIL_FROM = 'noreply@flashy.cards'	94	104	EMAIL_FROM = 'noreply@flashy.cards'
EMAIL_HOST_USER = 'noreply@flashy.cards'	95	105	EMAIL_HOST_USER = 'noreply@flashy.cards'
DEFAULT_FROM_EMAIL = 'noreply@flashy.cards'	96	106	DEFAULT_FROM_EMAIL = 'noreply@flashy.cards'
SERVER_EMAIL = 'noreply@flashy.cards'	97	107	SERVER_EMAIL = 'noreply@flashy.cards'
	98	108
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'	99	109	EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'
	100	110
if IN_PRODUCTION:	101	111	if IN_PRODUCTION:
INSTALLED_APPS.append('django_ses')	102	112	INSTALLED_APPS.append('django_ses')
AWS_SES_REGION_NAME = 'us-west-2'	103	113	AWS_SES_REGION_NAME = 'us-west-2'
AWS_SES_REGION_ENDPOINT = 'email.us-west-2.amazonaws.com'	104	114	AWS_SES_REGION_ENDPOINT = 'email.us-west-2.amazonaws.com'
EMAIL_BACKEND = 'django_ses.SESBackend'	105	115	EMAIL_BACKEND = 'django_ses.SESBackend'
	106	116
if IN_PRODUCTION:	107	117	if IN_PRODUCTION:
SESSION_COOKIE_SECURE = True	108	118	SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True	109	119	CSRF_COOKIE_SECURE = True
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')	110	120	SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
# are we secure yet?	111	121	# are we secure yet?
	112	122
if IN_PRODUCTION:	113	123	if IN_PRODUCTION:
LOGGING = {	114	124	LOGGING = {
'version': 1,	115	125	'version': 1,
'disable_existing_loggers': False,	116	126	'disable_existing_loggers': False,
'handlers': {	117	127	'handlers': {
'file': {	118	128	'file': {
'level': 'DEBUG',	119	129	'level': 'DEBUG',
'class': 'logging.FileHandler',	120	130	'class': 'logging.FileHandler',
'filename': 'debug.log',	121	131	'filename': 'debug.log',
},	122	132	},

#beautifulsoup4	1	1	#beautifulsoup4
Django>=1.8	2	2	Django>=1.8
#django-websocket-redis==0.4.3	3	3	django-websocket-redis
#gevent==1.0.1	4	4	#gevent==1.0.1
#greenlet==0.4.5	5	5	#greenlet==0.4.5
#redis==2.10.3	6	6	#redis==2.10.3
six==1.9.0	7	7	six==1.9.0
djangorestframework	8	8	djangorestframework
docutils	9	9	docutils
django-simple-email-confirmation	10	10	django-simple-email-confirmation
coverage	11	11	coverage
django-rest-swagger	12	12	django-rest-swagger
pytz	13	13	pytz
	14	14

#!/bin/bash -xe	1	1	#!/bin/bash -xe
source secrets.sh	2	2	source secrets.sh
source venv/bin/activate	3	3	source venv/bin/activate
newrelic-admin run-program /srv/flashy-backend/venv/bin/gunicorn --pid /run/flashy/gunicorn.pid -w 6 -n flashy -b 127.0.0.1:7002 flashy.wsgi	4	4	# newrelic-admin run-program /srv/flashy-backend/venv/bin/gunicorn --pid /run/flashy/gunicorn.pid -w 6 -n flashy -b 127.0.0.1:7002 flashy.wsgi
		5	newrelic-admin run-program uwsgi /etc/uwsgi/flashy.ini --touch-reload=/etc/uwsgi/flashy.ini
	5	6

from flashcards.models import Flashcard	1	1	from flashcards.models import Flashcard, UserFlashcardQuiz
from rest_framework.pagination import PageNumberPagination	2	2	from rest_framework.pagination import PageNumberPagination
from rest_framework.permissions import BasePermission	3	3	from rest_framework.permissions import BasePermission
	4	4
	5	5
mock_no_params = lambda x:None	6	6	mock_no_params = lambda x:None
	7	7
class StandardResultsSetPagination(PageNumberPagination):	8	8	class StandardResultsSetPagination(PageNumberPagination):
page_size = 40	9	9	page_size = 40
page_size_query_param = 'page_size'	10	10	page_size_query_param = 'page_size'
max_page_size = 1000	11	11	max_page_size = 1000
	12	12
	13	13
class UserDetailPermissions(BasePermission):	14	14	class UserDetailPermissions(BasePermission):
"""	15	15	"""
Permissions for the user detail view. Anonymous users may only POST.	16	16	Permissions for the user detail view. Anonymous users may only POST.
"""	17	17	"""
	18	18
def has_object_permission(self, request, view, obj):	19	19	def has_object_permission(self, request, view, obj):
if request.method == 'POST':	20	20	if request.method == 'POST':
return True	21	21	return True
return request.user.is_authenticated()	22	22	return request.user.is_authenticated()
	23	23
	24	24
class IsEnrolledInAssociatedSection(BasePermission):	25	25	class IsEnrolledInAssociatedSection(BasePermission):
def has_object_permission(self, request, view, obj):	26	26	def has_object_permission(self, request, view, obj):
		27	if obj is None:
		28	return True
assert type(obj) is Flashcard	27	29	assert type(obj) is Flashcard
return request.user.is_in_section(obj.section)	28	30	return request.user.is_in_section(obj.section)
		31

from django.conf.urls import include, url	1	1	from django.conf.urls import include, url
from django.contrib import admin	2	2	from django.contrib import admin
from flashcards.views import SectionViewSet, UserDetail, FlashcardViewSet, UserSectionListView, request_password_reset, \	3	3	from flashcards.views import SectionViewSet, UserDetail, FlashcardViewSet, UserSectionListView, request_password_reset, \
reset_password, logout, login, register	4	4	reset_password, logout, login, register, UserFlashcardQuizViewSet
from flashy.frontend_serve import serve_with_default	5	5	from flashy.frontend_serve import serve_with_default
from flashy.settings import DEBUG, IN_PRODUCTION	6	6	from flashy.settings import DEBUG, IN_PRODUCTION
from rest_framework.routers import DefaultRouter	7	7	from rest_framework.routers import DefaultRouter
from flashcards.api import *	8	8	from flashcards.api import *
	9	9
router = DefaultRouter()	10	10	router = DefaultRouter()
router.register(r'sections', SectionViewSet)	11	11	router.register(r'sections', SectionViewSet)
router.register(r'flashcards', FlashcardViewSet)	12	12	router.register(r'flashcards', FlashcardViewSet)
		13	router.register(r'study', UserFlashcardQuizViewSet)
	13	14
urlpatterns = [	14	15	urlpatterns = [
url(r'^api/docs/', include('rest_framework_swagger.urls')),	15	16	url(r'^api/docs/', include('rest_framework_swagger.urls')),
url(r'^api/me/$', UserDetail.as_view()),	16	17	url(r'^api/me/$', UserDetail.as_view()),
url(r'^api/register/', register),	17	18	url(r'^api/register/', register),
url(r'^api/login/$', login),	18	19	url(r'^api/login/$', login),
url(r'^api/logout/$', logout),	19	20	url(r'^api/logout/$', logout),
url(r'^api/me/sections/', UserSectionListView.as_view()),	20	21	url(r'^api/me/sections/', UserSectionListView.as_view()),
url(r'^api/request_password_reset/', request_password_reset),	21	22	url(r'^api/request_password_reset/', request_password_reset),
url(r'^api/reset_password/', reset_password),	22	23	url(r'^api/reset_password/', reset_password),
url(r'^api/', include(router.urls)),	23	24	url(r'^api/', include(router.urls)),
url(r'^admin/doc/', include('django.contrib.admindocs.urls')),	24	25	url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
url(r'^admin/', include(admin.site.urls)),	25	26	url(r'^admin/', include(admin.site.urls)),
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),	26	27	url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
]	27	28	]
	28	29
if IN_PRODUCTION:	29	30	if IN_PRODUCTION:
urlpatterns += (url(r'^admin/django-ses/', include('django_ses.urls')),)	30	31	urlpatterns += (url(r'^admin/django-ses/', include('django_ses.urls')),)
	31	32

from django.contrib.auth.models import AbstractUser, UserManager	1	1	from django.contrib.auth.models import AbstractUser, UserManager
from django.contrib.auth.tokens import default_token_generator	2	2	from django.contrib.auth.tokens import default_token_generator
from django.core.cache import cache	3	3	from django.core.cache import cache
from django.core.exceptions import ValidationError	4	4	from django.core.exceptions import ValidationError
from django.core.exceptions import PermissionDenied, SuspiciousOperation	5	5	from django.core.exceptions import PermissionDenied, SuspiciousOperation
from django.core.mail import send_mail	6	6	from django.core.mail import send_mail
from django.db import IntegrityError	7	7	from django.db import IntegrityError
from django.db.models import *	8	8	from django.db.models import *
from django.utils.timezone import now	9	9	from django.utils.timezone import now
from simple_email_confirmation import SimpleEmailConfirmationUserMixin	10	10	from simple_email_confirmation import SimpleEmailConfirmationUserMixin
from fields import MaskField	11	11	from fields import MaskField
	12	12
	13	13
# Hack to fix AbstractUser before subclassing it	14	14	# Hack to fix AbstractUser before subclassing it
AbstractUser._meta.get_field('email')._unique = True	15	15	AbstractUser._meta.get_field('email')._unique = True
AbstractUser._meta.get_field('username')._unique = False	16	16	AbstractUser._meta.get_field('username')._unique = False
	17	17
	18	18
class EmailOnlyUserManager(UserManager):	19	19	class EmailOnlyUserManager(UserManager):
"""	20	20	"""
A tiny extension of Django's UserManager which correctly creates users	21	21	A tiny extension of Django's UserManager which correctly creates users
without usernames (using emails instead).	22	22	without usernames (using emails instead).
"""	23	23	"""
	24	24
def _create_user(self, email, password, is_staff, is_superuser, **extra_fields):	25	25	def _create_user(self, email, password, is_staff, is_superuser, **extra_fields):
"""	26	26	"""
Creates and saves a User with the given email and password.	27	27	Creates and saves a User with the given email and password.
"""	28	28	"""
email = self.normalize_email(email)	29	29	email = self.normalize_email(email)
user = self.model(email=email,	30	30	user = self.model(email=email,
is_staff=is_staff, is_active=True,	31	31	is_staff=is_staff, is_active=True,
is_superuser=is_superuser,	32	32	is_superuser=is_superuser,
date_joined=now(), **extra_fields)	33	33	date_joined=now(), **extra_fields)
user.set_password(password)	34	34	user.set_password(password)
user.save(using=self._db)	35	35	user.save(using=self._db)
return user	36	36	return user
	37	37
def create_user(self, email, password=None, **extra_fields):	38	38	def create_user(self, email, password=None, **extra_fields):
user = self._create_user(email, password, False, False, **extra_fields)	39	39	user = self._create_user(email, password, False, False, **extra_fields)
body = '''	40	40	body = '''

from django.core import mail	1	1	from django.core import mail
from flashcards.models import *	2	2	from flashcards.models import *
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
import datetime	6	6	import datetime
from django.utils.timezone import now	7	7	from django.utils.timezone import now
from flashcards.validators import FlashcardMask	8	8	from flashcards.validators import FlashcardMask
from flashcards.serializers import FlashcardSerializer	9	9	from flashcards.serializers import FlashcardSerializer
	10	10
	11	11
class LoginTests(APITestCase):	12	12	class LoginTests(APITestCase):
fixtures = ['testusers']	13	13	fixtures = ['testusers']
	14	14
def test_login(self):	15	15	def test_login(self):
url = '/api/login/'	16	16	url = '/api/login/'
data = {'email': 'none@none.com', 'password': '1234'}	17	17	data = {'email': 'none@none.com', 'password': '1234'}
response = self.client.post(url, data, format='json')	18	18	response = self.client.post(url, data, format='json')
self.assertEqual(response.status_code, HTTP_200_OK)	19	19	self.assertEqual(response.status_code, HTTP_200_OK)
	20	20
data = {'email': 'none@none.com', 'password': '4321'}	21	21	data = {'email': 'none@none.com', 'password': '4321'}
response = self.client.post(url, data, format='json')	22	22	response = self.client.post(url, data, format='json')
self.assertContains(response, 'Invalid email or password', status_code=403)	23	23	self.assertContains(response, 'Invalid email or password', status_code=403)
	24	24
data = {'email': 'bad@none.com', 'password': '1234'}	25	25	data = {'email': 'bad@none.com', 'password': '1234'}
response = self.client.post(url, data, format='json')	26	26	response = self.client.post(url, data, format='json')
self.assertContains(response, 'Invalid email or password', status_code=403)	27	27	self.assertContains(response, 'Invalid email or password', status_code=403)
	28	28
data = {'password': '4321'}	29	29	data = {'password': '4321'}
response = self.client.post(url, data, format='json')	30	30	response = self.client.post(url, data, format='json')
self.assertContains(response, 'email', status_code=400)	31	31	self.assertContains(response, 'email', status_code=400)
	32	32
data = {'email': 'none@none.com'}	33	33	data = {'email': 'none@none.com'}
response = self.client.post(url, data, format='json')	34	34	response = self.client.post(url, data, format='json')
self.assertContains(response, 'password', status_code=400)	35	35	self.assertContains(response, 'password', status_code=400)
	36	36
user = User.objects.get(email="none@none.com")	37	37	user = User.objects.get(email="none@none.com")
user.is_active = False	38	38	user.is_active = False
user.save()	39	39	user.save()
	40	40

import django	1	1	import django
	2	2
from django.contrib import auth	3	3	from django.contrib import auth
from django.core.cache import cache	4	4	from django.core.cache import cache
from django.shortcuts import get_object_or_404	5	5	from django.shortcuts import get_object_or_404
from flashcards.api import StandardResultsSetPagination, IsEnrolledInAssociatedSection	6	6	from flashcards.api import StandardResultsSetPagination, IsEnrolledInAssociatedSection, IsFlashcardReviewer
from flashcards.models import Section, User, Flashcard, FlashcardHide, UserFlashcard	7	7	from flashcards.models import Section, User, Flashcard, FlashcardHide, UserFlashcard, UserFlashcardQuiz
from flashcards.serializers import SectionSerializer, UserUpdateSerializer, RegistrationSerializer, UserSerializer, \	8	8	from flashcards.serializers import SectionSerializer, UserUpdateSerializer, RegistrationSerializer, UserSerializer, \
PasswordResetSerializer, PasswordResetRequestSerializer, EmailPasswordSerializer, FlashcardSerializer, \	9	9	PasswordResetSerializer, PasswordResetRequestSerializer, EmailPasswordSerializer, FlashcardSerializer, \
FlashcardUpdateSerializer, DeepSectionSerializer	10	10	FlashcardUpdateSerializer, QuizRequestSerializer, QuizResponseSerializer, \
		11	QuizAnswerRequestSerializer, DeepSectionSerializer
from rest_framework.decorators import detail_route, permission_classes, api_view, list_route	11	12	from rest_framework.decorators import detail_route, permission_classes, api_view, list_route
from rest_framework.generics import ListAPIView, GenericAPIView	12	13	from rest_framework.generics import ListAPIView, GenericAPIView
from rest_framework.mixins import CreateModelMixin, RetrieveModelMixin	13	14	from rest_framework.mixins import CreateModelMixin, RetrieveModelMixin, UpdateModelMixin
from rest_framework.permissions import IsAuthenticated	14	15	from rest_framework.permissions import IsAuthenticated
from rest_framework.viewsets import ReadOnlyModelViewSet, GenericViewSet	15	16	from rest_framework.viewsets import ReadOnlyModelViewSet, GenericViewSet
from django.core.mail import send_mail	16	17	from django.core.mail import send_mail
from django.contrib.auth import authenticate	17	18	from django.contrib.auth import authenticate
from django.contrib.auth.tokens import default_token_generator	18	19	from django.contrib.auth.tokens import default_token_generator
from rest_framework.status import HTTP_204_NO_CONTENT, HTTP_201_CREATED, HTTP_200_OK	19	20	from rest_framework.status import HTTP_204_NO_CONTENT, HTTP_201_CREATED, HTTP_200_OK
from rest_framework.response import Response	20	21	from rest_framework.response import Response
from rest_framework.exceptions import AuthenticationFailed, NotAuthenticated, ValidationError, PermissionDenied	21	22	from rest_framework.exceptions import AuthenticationFailed, NotAuthenticated, ValidationError, PermissionDenied
from simple_email_confirmation import EmailAddress	22	23	from simple_email_confirmation import EmailAddress
		24	from random import sample
	23	25
	24	26
class SectionViewSet(ReadOnlyModelViewSet):	25	27	class SectionViewSet(ReadOnlyModelViewSet):
queryset = Section.objects.all()	26	28	queryset = Section.objects.all()
serializer_class = DeepSectionSerializer	27	29	serializer_class = DeepSectionSerializer
pagination_class = StandardResultsSetPagination	28	30	pagination_class = StandardResultsSetPagination
permission_classes = [IsAuthenticated]	29	31	permission_classes = [IsAuthenticated]
	30	32
@detail_route(methods=['GET'])	31	33	@detail_route(methods=['GET'])
def flashcards(self, request, pk):	32	34	def flashcards(self, request, pk):
"""	33	35	"""
Gets flashcards for a section, excluding hidden cards.	34	36	Gets flashcards for a section, excluding hidden cards.
Returned in strictly chronological order (material date).	35	37	Returned in strictly chronological order (material date).
"""	36	38	"""
flashcards = Flashcard.cards_visible_to(request.user).filter(section=self.get_object()).all()	37	39	flashcards = Flashcard.cards_visible_to(request.user).filter(section=self.get_object()).all()
return Response(FlashcardSerializer(flashcards, many=True).data)	38	40	return Response(FlashcardSerializer(flashcards, many=True).data)