110swag / flashy-backend

Download as
Browse Code ยป

Commit e7a281e8667a66961e5ec69f043943987a938237

Authored by Andrew Buss
1 parent 666a9e28a2
Exists in master

sort order got reversed!

Showing 1 changed file with 1 additions and 1 deletions Inline Diff

flashcards/models.py View file @ e7a281e
from math import log1p 1 1 from math import log1p
from math import exp 2 2 from math import exp
3 3
from django.contrib.auth.models import AbstractUser, UserManager 4 4 from django.contrib.auth.models import AbstractUser, UserManager
from django.contrib.auth.tokens import default_token_generator 5 5 from django.contrib.auth.tokens import default_token_generator
from django.core.cache import cache 6 6 from django.core.cache import cache
from django.core.exceptions import ValidationError 7 7 from django.core.exceptions import ValidationError
from django.core.exceptions import PermissionDenied, SuspiciousOperation 8 8 from django.core.exceptions import PermissionDenied, SuspiciousOperation
from django.core.mail import send_mail 9 9 from django.core.mail import send_mail
from django.db import IntegrityError 10 10 from django.db import IntegrityError
from django.db.models import * 11 11 from django.db.models import *
from django.utils.timezone import now, make_aware 12 12 from django.utils.timezone import now, make_aware
from simple_email_confirmation import SimpleEmailConfirmationUserMixin 13 13 from simple_email_confirmation import SimpleEmailConfirmationUserMixin
from fields import MaskField 14 14 from fields import MaskField
from cached_property import cached_property 15 15 from cached_property import cached_property
import datetime 16 16 import datetime
17 17
18 18
19 19
# Hack to fix AbstractUser before subclassing it 20 20 # Hack to fix AbstractUser before subclassing it
21 21
AbstractUser._meta.get_field('email')._unique = True 22 22 AbstractUser._meta.get_field('email')._unique = True
AbstractUser._meta.get_field('username')._unique = False 23 23 AbstractUser._meta.get_field('username')._unique = False
24 24
25 25
class EmailOnlyUserManager(UserManager): 26 26 class EmailOnlyUserManager(UserManager):
""" 27 27 """
A tiny extension of Django's UserManager which correctly creates users 28 28 A tiny extension of Django's UserManager which correctly creates users
without usernames (using emails instead). 29 29 without usernames (using emails instead).
""" 30 30 """
31 31
def _create_user(self, email, password, is_staff, is_superuser, **extra_fields): 32 32 def _create_user(self, email, password, is_staff, is_superuser, **extra_fields):
""" 33 33 """
Creates and saves a User with the given email and password. 34 34 Creates and saves a User with the given email and password.
""" 35 35 """
email = self.normalize_email(email) 36 36 email = self.normalize_email(email)
user = self.model(email=email, 37 37 user = self.model(email=email,
is_staff=is_staff, is_active=True, 38 38 is_staff=is_staff, is_active=True,
is_superuser=is_superuser, 39 39 is_superuser=is_superuser,
date_joined=now(), **extra_fields) 40 40 date_joined=now(), **extra_fields)
user.set_password(password) 41 41 user.set_password(password)
user.save(using=self._db) 42 42 user.save(using=self._db)
return user 43 43 return user
44 44
def create_user(self, email, password=None, **extra_fields): 45 45 def create_user(self, email, password=None, **extra_fields):
user = self._create_user(email, password, False, False, **extra_fields) 46 46 user = self._create_user(email, password, False, False, **extra_fields)
body = ''' 47 47 body = '''
Visit the following link to confirm your email address: 48 48 Visit the following link to confirm your email address:
https://flashy.cards/app/verifyemail/%s 49 49 https://flashy.cards/app/verifyemail/%s
50 50
If you did not register for Flashy, no action is required. 51 51 If you did not register for Flashy, no action is required.
''' 52 52 '''
53 53
assert send_mail("Flashy email verification", 54 54 assert send_mail("Flashy email verification",
body % user.confirmation_key, 55 55 body % user.confirmation_key,
"noreply@flashy.cards", 56 56 "noreply@flashy.cards",
[user.email]) 57 57 [user.email])
return user 58 58 return user
59 59
def create_superuser(self, email, password, **extra_fields): 60 60 def create_superuser(self, email, password, **extra_fields):
return self._create_user(email, password, True, True, **extra_fields) 61 61 return self._create_user(email, password, True, True, **extra_fields)
62 62
63 63
class User(AbstractUser, SimpleEmailConfirmationUserMixin): 64 64 class User(AbstractUser, SimpleEmailConfirmationUserMixin):
""" 65 65 """
An extension of Django's default user model. 66 66 An extension of Django's default user model.
We use email as the username field, and include enrolled sections here 67 67 We use email as the username field, and include enrolled sections here
""" 68 68 """
objects = EmailOnlyUserManager() 69 69 objects = EmailOnlyUserManager()
USERNAME_FIELD = 'email' 70 70 USERNAME_FIELD = 'email'
REQUIRED_FIELDS = [] 71 71 REQUIRED_FIELDS = []
sections = ManyToManyField('Section', help_text="The sections which the user is enrolled in") 72 72 sections = ManyToManyField('Section', help_text="The sections which the user is enrolled in")
73 73
def is_in_section(self, section): 74 74 def is_in_section(self, section):
return self.sections.filter(pk=section.pk).exists() 75 75 return self.sections.filter(pk=section.pk).exists()
76 76
def pull(self, flashcard): 77 77 def pull(self, flashcard):
if not self.is_in_section(flashcard.section): 78 78 if not self.is_in_section(flashcard.section):
raise ValueError("User not in the section this flashcard belongs to") 79 79 raise ValueError("User not in the section this flashcard belongs to")
user_card = UserFlashcard.objects.create(user=self, flashcard=flashcard) 80 80 user_card = UserFlashcard.objects.create(user=self, flashcard=flashcard)
user_card.pulled = now() 81 81 user_card.pulled = now()
user_card.save() 82 82 user_card.save()
import flashcards.notifications 83 83 import flashcards.notifications
84 84
flashcards.notifications.notify_score_change(flashcard) 85 85 flashcards.notifications.notify_score_change(flashcard)
flashcards.notifications.deck_card_score_change(flashcard) 86 86 flashcards.notifications.deck_card_score_change(flashcard)
87 87
def unpull(self, flashcard): 88 88 def unpull(self, flashcard):
if not self.is_in_section(flashcard.section): 89 89 if not self.is_in_section(flashcard.section):
raise ValueError("User not in the section this flashcard belongs to") 90 90 raise ValueError("User not in the section this flashcard belongs to")
91 91
try: 92 92 try:
import flashcards.notifications 93 93 import flashcards.notifications
94 94
user_card = UserFlashcard.objects.get(user=self, flashcard=flashcard) 95 95 user_card = UserFlashcard.objects.get(user=self, flashcard=flashcard)
user_card.delete() 96 96 user_card.delete()
flashcards.notifications.notify_score_change(flashcard) 97 97 flashcards.notifications.notify_score_change(flashcard)
except UserFlashcard.DoesNotExist: 98 98 except UserFlashcard.DoesNotExist:
raise ValueError('Cannot unpull card that is not pulled.') 99 99 raise ValueError('Cannot unpull card that is not pulled.')
100 100
def get_deck(self, section): 101 101 def get_deck(self, section):
if not self.is_in_section(section): 102 102 if not self.is_in_section(section):
raise ObjectDoesNotExist("User not enrolled in section") 103 103 raise ObjectDoesNotExist("User not enrolled in section")
return Flashcard.objects.all().filter(userflashcard__user=self).filter(section=section) 104 104 return Flashcard.objects.all().filter(userflashcard__user=self).filter(section=section)
105 105
def request_password_reset(self): 106 106 def request_password_reset(self):
token = default_token_generator.make_token(self) 107 107 token = default_token_generator.make_token(self)
108 108
body = ''' 109 109 body = '''
Visit the following link to reset your password: 110 110 Visit the following link to reset your password:
https://flashy.cards/app/resetpassword/%d/%s 111 111 https://flashy.cards/app/resetpassword/%d/%s
112 112
If you did not request a password reset, no action is required. 113 113 If you did not request a password reset, no action is required.
''' 114 114 '''
115 115
send_mail("Flashy password reset", 116 116 send_mail("Flashy password reset",
body % (self.pk, token), 117 117 body % (self.pk, token),
"noreply@flashy.cards", 118 118 "noreply@flashy.cards",
[self.email]) 119 119 [self.email])
120 120
121 121
class UserFlashcard(Model): 122 122 class UserFlashcard(Model):
""" 123 123 """
Represents the relationship between a user and a flashcard by: 124 124 Represents the relationship between a user and a flashcard by:
1. A user has a flashcard in their deck 125 125 1. A user has a flashcard in their deck
2. A user used to have a flashcard in their deck 126 126 2. A user used to have a flashcard in their deck
3. A user has a flashcard hidden from them 127 127 3. A user has a flashcard hidden from them
""" 128 128 """
user = ForeignKey('User') 129 129 user = ForeignKey('User')
mask = MaskField(max_length=255, null=True, blank=True, default=None, 130 130 mask = MaskField(max_length=255, null=True, blank=True, default=None,
help_text="The user-specific mask on the card") 131 131 help_text="The user-specific mask on the card")
pulled = DateTimeField(auto_now_add=True, help_text="When the user pulled the card") 132 132 pulled = DateTimeField(auto_now_add=True, help_text="When the user pulled the card")
flashcard = ForeignKey('Flashcard') 133 133 flashcard = ForeignKey('Flashcard')
134 134
class Meta: 135 135 class Meta:
# There can be at most one UserFlashcard for each User and Flashcard 136 136 # There can be at most one UserFlashcard for each User and Flashcard
unique_together = (('user', 'flashcard'),) 137 137 unique_together = (('user', 'flashcard'),)
index_together = ["user", "flashcard"] 138 138 index_together = ["user", "flashcard"]
# By default, order by most recently pulled 139 139 # By default, order by most recently pulled
ordering = ['-pulled'] 140 140 ordering = ['-pulled']
141 141
142 142
class FlashcardHide(Model): 143 143 class FlashcardHide(Model):
""" 144 144 """
Represents the property of a flashcard being hidden by a user. 145 145 Represents the property of a flashcard being hidden by a user.
Each instance of this class represents a single user hiding a single flashcard. 146 146 Each instance of this class represents a single user hiding a single flashcard.
If reason is null, the flashcard was just hidden. 147 147 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. 148 148 If reason is not null, the flashcard was reported, and reason is the reason why it was reported.
""" 149 149 """
user = ForeignKey('User') 150 150 user = ForeignKey('User')
flashcard = ForeignKey('Flashcard') 151 151 flashcard = ForeignKey('Flashcard')
reason = CharField(max_length=255, blank=True, null=True) 152 152 reason = CharField(max_length=255, blank=True, null=True)
hidden = DateTimeField(auto_now_add=True) 153 153 hidden = DateTimeField(auto_now_add=True)
154 154
class Meta: 155 155 class Meta:
# There can only be one FlashcardHide object for each User and Flashcard 156 156 # There can only be one FlashcardHide object for each User and Flashcard
unique_together = (('user', 'flashcard'),) 157 157 unique_together = (('user', 'flashcard'),)
index_together = ["user", "flashcard"] 158 158 index_together = ["user", "flashcard"]
159 159
160 160
class Flashcard(Model): 161 161 class Flashcard(Model):
text = CharField(max_length=255, help_text='The text on the card') 162 162 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') 163 163 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") 164 164 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") 165 165 material_date = DateTimeField(default=now, help_text="The date with which the card is associated")
previous = ForeignKey('Flashcard', null=True, blank=True, default=None, 166 166 previous = ForeignKey('Flashcard', null=True, blank=True, default=None,
help_text="The previous version of this card, if one exists") 167 167 help_text="The previous version of this card, if one exists")
author = ForeignKey(User) 168 168 author = ForeignKey(User)
is_hidden = BooleanField(default=False) 169 169 is_hidden = BooleanField(default=False)
hide_reason = CharField(blank=True, null=True, max_length=255, default='', 170 170 hide_reason = CharField(blank=True, null=True, max_length=255, default='',
help_text="Reason for hiding this card") 171 171 help_text="Reason for hiding this card")
mask = MaskField(max_length=255, null=True, blank=True, help_text="The mask on the card") 172 172 mask = MaskField(max_length=255, null=True, blank=True, help_text="The mask on the card")
173 173
class Meta: 174 174 class Meta:
# By default, order by most recently pushed 175 175 # By default, order by most recently pushed
ordering = ['-pushed'] 176 176 ordering = ['-pushed']
177 177
def is_hidden_from(self, user): 178 178 def is_hidden_from(self, user):
""" 179 179 """
A card can be hidden globally, but if a user has the card in their deck, 180 180 A card can be hidden globally, but if a user has the card in their deck,
this visibility overrides a global hide. 181 181 this visibility overrides a global hide.
:param user: 182 182 :param user:
:return: Whether the card is hidden from the user. 183 183 :return: Whether the card is hidden from the user.
""" 184 184 """
if self.userflashcard_set.filter(user=user).exists(): return False 185 185 if self.userflashcard_set.filter(user=user).exists(): return False
if self.is_hidden or self.flashcardhide_set.filter(user=user).exists(): return True 186 186 if self.is_hidden or self.flashcardhide_set.filter(user=user).exists(): return True
return False 187 187 return False
188 188
def hide_from(self, user, reason=None): 189 189 def hide_from(self, user, reason=None):
if self.is_in_deck(user): user.unpull(self) 190 190 if self.is_in_deck(user): user.unpull(self)
obj, created = FlashcardHide.objects.get_or_create(user=user, flashcard=self, reason=None) 191 191 obj, created = FlashcardHide.objects.get_or_create(user=user, flashcard=self, reason=None)
if not created: 192 192 if not created:
raise ValidationError("The card has already been hidden.") 193 193 raise ValidationError("The card has already been hidden.")
obj.save() 194 194 obj.save()
195 195
def is_in_deck(self, user): 196 196 def is_in_deck(self, user):
return self.userflashcard_set.filter(user=user).exists() 197 197 return self.userflashcard_set.filter(user=user).exists()
198 198
def add_to_deck(self, user): 199 199 def add_to_deck(self, user):
if not user.is_in_section(self.section): 200 200 if not user.is_in_section(self.section):
raise PermissionDenied("You don't have the permission to add this card") 201 201 raise PermissionDenied("You don't have the permission to add this card")
try: 202 202 try:
user_flashcard = UserFlashcard.objects.create(user=user, flashcard=self, mask=self.mask) 203 203 user_flashcard = UserFlashcard.objects.create(user=user, flashcard=self, mask=self.mask)
except IntegrityError: 204 204 except IntegrityError:
raise SuspiciousOperation("The flashcard is already in the user's deck") 205 205 raise SuspiciousOperation("The flashcard is already in the user's deck")
user_flashcard.save() 206 206 user_flashcard.save()
return user_flashcard 207 207 return user_flashcard
208 208
def edit(self, user, new_data): 209 209 def edit(self, user, new_data):
""" 210 210 """
Creates a new flashcard if a new flashcard should be created when the given user edits this flashcard. 211 211 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. 212 212 Sets up everything correctly so this object, when saved, will result in the appropriate changes.
:param user: The user editing this card. 213 213 :param user: The user editing this card.
:param new_data: The new information, namely a dict containg 'material_date', 'text', and 'mask' keys. 214 214 :param new_data: The new information, namely a dict containg 'material_date', 'text', and 'mask' keys.
""" 215 215 """
216 216
# content_changed is True iff either material_date or text were changed 217 217 # content_changed is True iff either material_date or text were changed
content_changed = False 218 218 content_changed = False
# create_new is True iff the user editing this card is the author of this card 219 219 # 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 220 220 # and there are no other users with this card in their decks
create_new = user != self.author or \ 221 221 create_new = user != self.author or \
UserFlashcard.objects.filter(flashcard=self).exclude(user=user).exists() 222 222 UserFlashcard.objects.filter(flashcard=self).exclude(user=user).exists()
if 'material_date' in new_data and self.material_date != new_data['material_date']: 223 223 if 'material_date' in new_data and self.material_date != new_data['material_date']:
content_changed = True 224 224 content_changed = True
self.material_date = new_data['material_date'] 225 225 self.material_date = new_data['material_date']
if 'text' in new_data and self.text != new_data['text']: 226 226 if 'text' in new_data and self.text != new_data['text']:
content_changed = True 227 227 content_changed = True
self.text = new_data['text'] 228 228 self.text = new_data['text']
if create_new and content_changed: 229 229 if create_new and content_changed:
if self.is_in_deck(user): user.unpull(self) 230 230 if self.is_in_deck(user): user.unpull(self)
self.previous_id = self.pk 231 231 self.previous_id = self.pk
self.pk = None 232 232 self.pk = None
self.mask = new_data.get('mask', self.mask) 233 233 self.mask = new_data.get('mask', self.mask)
self.save() 234 234 self.save()
self.add_to_deck(user) 235 235 self.add_to_deck(user)
else: 236 236 else:
user_card, created = UserFlashcard.objects.get_or_create(user=user, flashcard=self) 237 237 user_card, created = UserFlashcard.objects.get_or_create(user=user, flashcard=self)
user_card.mask = new_data.get('mask', user_card.mask) 238 238 user_card.mask = new_data.get('mask', user_card.mask)
user_card.save() 239 239 user_card.save()
return self 240 240 return self
241 241
def report(self, user, reason=None): 242 242 def report(self, user, reason=None):
obj, created = FlashcardHide.objects.get_or_create(user=user, flashcard=self) 243 243 obj, created = FlashcardHide.objects.get_or_create(user=user, flashcard=self)
obj.reason = reason 244 244 obj.reason = reason
obj.save() 245 245 obj.save()
246 246
@cached_property 247 247 @cached_property
def score(self): 248 248 def score(self):
def seconds_since_epoch(dt): 249 249 def seconds_since_epoch(dt):
epoch = make_aware(datetime.datetime.utcfromtimestamp(0)) 250 250 epoch = make_aware(datetime.datetime.utcfromtimestamp(0))
delta = dt - epoch 251 251 delta = dt - epoch
return delta.total_seconds() 252 252 return delta.total_seconds()
z = 0 253 253 z = 0
rate = 1.0 / 3600 254 254 rate = 1.0 / 3600
for vote in self.userflashcard_set.iterator(): 255 255 for vote in self.userflashcard_set.iterator():
t = seconds_since_epoch(vote.pulled) 256 256 t = seconds_since_epoch(vote.pulled)
u = max(z, rate * t) 257 257 u = max(z, rate * t)
v = min(z, rate * t) 258 258 v = min(z, rate * t)
z = u + log1p(exp(v - u)) 259 259 z = u + log1p(exp(v - u))
return z 260 260 return z
261 261
@classmethod 262 262 @classmethod
def cards_visible_to(cls, user): 263 263 def cards_visible_to(cls, user):
""" 264 264 """
:param user: 265 265 :param user:
:return: A queryset with all cards that should be visible to a user. 266 266 :return: A queryset with all cards that should be visible to a user.
""" 267 267 """
return cls.objects.filter(author__is_active=True).filter(is_hidden=False).exclude(flashcardhide__user=user) 268 268 return cls.objects.filter(author__is_active=True).filter(is_hidden=False).exclude(flashcardhide__user=user)
269 269
270 270
class UserFlashcardQuiz(Model): 271 271 class UserFlashcardQuiz(Model):
""" 272 272 """
An event of a user being quizzed on a flashcard. 273 273 An event of a user being quizzed on a flashcard.
""" 274 274 """
user_flashcard = ForeignKey(UserFlashcard) 275 275 user_flashcard = ForeignKey(UserFlashcard)
when = DateTimeField(auto_now=True) 276 276 when = DateTimeField(auto_now=True)
blanked_word = CharField(max_length=8, blank=True, help_text="The character range which was blanked") 277 277 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, default=None, help_text="The user's response") 278 278 response = CharField(max_length=255, blank=True, null=True, default=None, help_text="The user's response")
correct = NullBooleanField(help_text="The user's self-evaluation of their response") 279 279 correct = NullBooleanField(help_text="The user's self-evaluation of their response")
280 280
def status(self): 281 281 def status(self):
""" 282 282 """
There are three stages of a quiz object: 283 283 There are three stages of a quiz object:
1. the user has been shown the card 284 284 1. the user has been shown the card
2. the user has answered the card 285 285 2. the user has answered the card
3. the user has self-evaluated their response's correctness 286 286 3. the user has self-evaluated their response's correctness
287 287
:return: string (evaluated, answered, viewed) 288 288 :return: string (evaluated, answered, viewed)
""" 289 289 """
if self.correct is not None: return "evaluated" 290 290 if self.correct is not None: return "evaluated"
if self.response: return "answered" 291 291 if self.response: return "answered"
return "viewed" 292 292 return "viewed"
293 293
294 294
class Section(Model): 295 295 class Section(Model):
""" 296 296 """
A UCSD course taught by an instructor during a quarter. 297 297 A UCSD course taught by an instructor during a quarter.
We use the term "section" to avoid collision with the builtin keyword "class" 298 298 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 299 299 We index gratuitously to support autofill and because this is primarily read-only
""" 300 300 """
department = CharField(db_index=True, max_length=50) 301 301 department = CharField(db_index=True, max_length=50)
department_abbreviation = CharField(db_index=True, max_length=10) 302 302 department_abbreviation = CharField(db_index=True, max_length=10)
course_num = CharField(db_index=True, max_length=6) 303 303 course_num = CharField(db_index=True, max_length=6)
course_title = CharField(db_index=True, max_length=50) 304 304 course_title = CharField(db_index=True, max_length=50)
instructor = CharField(db_index=True, max_length=100) 305 305 instructor = CharField(db_index=True, max_length=100)
quarter = CharField(db_index=True, max_length=4) 306 306 quarter = CharField(db_index=True, max_length=4)
307 307
@classmethod 308 308 @classmethod
def search(cls, terms): 309 309 def search(cls, terms):
""" 310 310 """
Search all fields of all sections for a particular set of terms 311 311 Search all fields of all sections for a particular set of terms
A matching section must match at least one field on each term 312 312 A matching section must match at least one field on each term
:param terms:iterable 313 313 :param terms:iterable
:return: Matching QuerySet ordered by department and course number 314 314 :return: Matching QuerySet ordered by department and course number
""" 315 315 """
final_q = Q() 316 316 final_q = Q()
for term in terms: 317 317 for term in terms:
q = Q(department__icontains=term) 318 318 q = Q(department__icontains=term)
q |= Q(department_abbreviation__icontains=term) 319 319 q |= Q(department_abbreviation__icontains=term)
q |= Q(course_title__icontains=term) 320 320 q |= Q(course_title__icontains=term)
q |= Q(course_num__icontains=term) 321 321 q |= Q(course_num__icontains=term)
q |= Q(instructor__icontains=term) 322 322 q |= Q(instructor__icontains=term)
final_q &= q 323 323 final_q &= q
qs = cls.objects.filter(final_q) 324 324 qs = cls.objects.filter(final_q)
# Have the database cast the course number to an integer so it will sort properly 325 325 # 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 326 326 # 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)"}) 327 327 qs = qs.extra(select={'course_num_int': "CAST(rtrim(course_num, 'ABCDEFGHIJKLMNOPQRSTUVWXYZ') AS INTEGER)"})
qs = qs.order_by('department_abbreviation', 'course_num_int') 328 328 qs = qs.order_by('department_abbreviation', 'course_num_int')
return qs 329 329 return qs
330 330
@property 331 331 @property
def is_whitelisted(self): 332 332 def is_whitelisted(self):
""" 333 333 """
:return: whether a whitelist exists for this section 334 334 :return: whether a whitelist exists for this section
""" 335 335 """
return self.whitelist.exists() 336 336 return self.whitelist.exists()
337 337
def is_user_on_whitelist(self, user): 338 338 def is_user_on_whitelist(self, user):
""" 339 339 """
:return: whether the user is on the waitlist for this section 340 340 :return: whether the user is on the waitlist for this section
""" 341 341 """
return self.whitelist.filter(email=user.email).exists() 342 342 return self.whitelist.filter(email=user.email).exists()
343 343
def enroll(self, user): 344 344 def enroll(self, user):
if user.sections.filter(pk=self.pk).exists(): 345 345 if user.sections.filter(pk=self.pk).exists():
raise ValidationError('User is already enrolled in this section') 346 346 raise ValidationError('User is already enrolled in this section')
if self.is_whitelisted and not self.is_user_on_whitelist(user): 347 347 if self.is_whitelisted and not self.is_user_on_whitelist(user):
raise PermissionDenied("User must be on the whitelist to add this section.") 348 348 raise PermissionDenied("User must be on the whitelist to add this section.")
self.user_set.add(user) 349 349 self.user_set.add(user)
350 350
def drop(self, user): 351 351 def drop(self, user):
if not user.sections.filter(pk=self.pk).exists(): 352 352 if not user.sections.filter(pk=self.pk).exists():
raise ValidationError("User is not enrolled in the section.") 353 353 raise ValidationError("User is not enrolled in the section.")
self.user_set.remove(user) 354 354 self.user_set.remove(user)