class Invite(models.Model): # old: invite
key = CharField(max_length=255) # old: id
user = ForeignKey(User) # old: id_user
ensemble = ForeignKey(Ensemble) # old: id_ensemble
admin = BooleanField(default=False) # old: admin integer
ctime = DateTimeField(null=True, default=datetime.now())
class AssignmentGradeHistory(models.Model):
user = ForeignKey(User, related_name="u_grade_h")
grader = ForeignKey(User, related_name="g_grade_h")
ctime = DateTimeField(default=datetime.now())
grade = IntegerField()
source = ForeignKey(Source)
class Folder(models.Model): # old: folder
parent = ForeignKey("self", null=True) # old: id_parent integer
ensemble = ForeignKey(Ensemble) # old: id_ensemble integer
name = CharField(max_length=255) # old: name text
class UserPlan(Model):
user = ForeignKey(User, on_delete=CASCADE)
plan = OneToOneField(Plan, on_delete=CASCADE)
def __str__(self):
return f"{self.user}, {self.plan}"
class GuestLoginHistory(models.Model):
guest = ForeignKey(User, related_name="u1")
user = ForeignKey(User, related_name="u2")
ctime = DateTimeField(null=True, default=datetime.now())
class Watchlist(models.Model):
user = ForeignKey(User, on_delete=models.CASCADE, related_name="watching")
item = ForeignKey(Listing, on_delete=models.CASCADE, related_name="watched")
def test_fk_db_constraint(self):
"Tests that the db_constraint parameter is respected"
# Create the table
with connection.schema_editor() as editor:
editor.create_model(Tag)
editor.create_model(Author)
editor.create_model(BookWeak)
# Check that initial tables are there
list(Author.objects.all())
list(Tag.objects.all())
list(BookWeak.objects.all())
# Check that BookWeak doesn't have an FK constraint
constraints = self.get_constraints(BookWeak._meta.db_table)
for name, details in constraints.items():
if details['columns'] == ["author_id"] and details['foreign_key']:
self.fail("FK constraint for author_id found")
# Make a db_constraint=False FK
new_field = ForeignKey(Tag, db_constraint=False)
new_field.set_attributes_from_name("tag")
with connection.schema_editor() as editor:
editor.add_field(
Author,
new_field,
)
# Make sure no FK constraint is present
constraints = self.get_constraints(Author._meta.db_table)
for name, details in constraints.items():
if details['columns'] == ["tag_id"] and details['foreign_key']:
self.fail("FK constraint for tag_id found")
# Alter to one with a constraint
new_field_2 = ForeignKey(Tag)
new_field_2.set_attributes_from_name("tag")
with connection.schema_editor() as editor:
editor.alter_field(
Author,
new_field,
new_field_2,
strict=True,
)
# Make sure the new FK constraint is present
constraints = self.get_constraints(Author._meta.db_table)
for name, details in constraints.items():
if details['columns'] == ["tag_id"] and details['foreign_key']:
self.assertEqual(details['foreign_key'], ('schema_tag', 'id'))
break
else:
self.fail("No FK constraint for tag_id found")
# Alter to one without a constraint again
new_field_2 = ForeignKey(Tag)
new_field_2.set_attributes_from_name("tag")
with connection.schema_editor() as editor:
editor.alter_field(
Author,
new_field_2,
new_field,
strict=True,
)
# Make sure no FK constraint is present
constraints = self.get_constraints(Author._meta.db_table)
for name, details in constraints.items():
if details['columns'] == ["tag_id"] and details['foreign_key']:
self.fail("FK constraint for tag_id found")
class Idle(models.Model):
session = ForeignKey(Session)
t1 = DateTimeField()
t2 = DateTimeField()
class SettingLabel(models.Model):
setting = ForeignKey(DefaultSetting)
value = IntegerField()
label = TextField()
class Session(models.Model):
user = ForeignKey(User)
ctime = DateTimeField(default=datetime.now)
lastactivity = DateTimeField(default=datetime.now, null=True)
ip = CharField(max_length=63, blank=True, null=True)
class CommentSeen(models.Model):
comment = ForeignKey(Comment)
session = ForeignKey(Session, null=True)
user = ForeignKey(
User) #duplicate (cf session) but inlined for performance
ctime = DateTimeField(default=datetime.now)
class Reminder(models.Model):
project_id = CharField(null=False, blank=False, max_length=264)
day = IntegerField(null=True, blank=True)
message = CharField(max_length=160)
reminder_mode = CharField(null=False,
blank=False,
max_length=20,
default=ReminderMode.BEFORE_DEADLINE)
organization = ForeignKey(Organization)
def to_dict(self):
return {
'day': self.day,
'message': self.message,
'reminder_mode': self.reminder_mode,
'id': self.id
}
def void(self, void=True):
self.voided = void
self.save()
def should_be_send_on(self, deadline, on_date):
assert isinstance(on_date, date)
deadline_date = self._get_applicapable_deadline_date(deadline, on_date)
return on_date == deadline_date + timedelta(days=self._delta())
def get_sender_list(self, project, on_date, dbm):
if not project.reminder_and_deadline['should_send_reminder_to_all_ds']:
deadline_date = self._get_applicapable_deadline_date(
project.deadline(), on_date)
return project.get_data_senders_without_submissions_for(
deadline_date, dbm)
return project.get_data_senders(dbm)
def _delta(self):
if self.reminder_mode == ReminderMode.ON_DEADLINE:
return 0
if self.reminder_mode == ReminderMode.BEFORE_DEADLINE:
return -self.day
if self.reminder_mode == ReminderMode.AFTER_DEADLINE:
return self.day
def _get_applicapable_deadline_date(self, deadline, on_date):
if self.reminder_mode == ReminderMode.BEFORE_DEADLINE:
return deadline.next_deadline(on_date)
else:
return deadline.current_deadline(on_date)
def log(self,
dbm,
project_id,
date,
to_number,
sent_status='sent',
number_of_sms=0):
log = ReminderLog(dbm=dbm,
reminder=self,
project_id=project_id,
date=date,
sent_status=sent_status,
number_of_sms=number_of_sms,
to_number=to_number)
log.save()
return log
class NavbarLink(Model):
display_name = CharField(max_length=50, verbose_name='Display Name')
permission_classes = ManyToManyField(PermissionClass,
verbose_name='Permission Classes',
blank=True)
show_to_all = BooleanField(verbose_name='Show To All Users', default=False)
icon = CharField(max_length=100,
verbose_name='Icon Static File Location',
blank=True,
null=True)
sequence_index = SmallIntegerField(verbose_name='Sequence Index')
parent_group = ForeignKey('NavbarLink',
related_name='links',
blank=True,
null=True,
verbose_name='Parent Link Group',
on_delete=CASCADE)
external_url = URLField(verbose_name='URL', blank=True, null=True)
url_name = CharField(max_length=100, blank=True, null=True)
onclick = CharField(max_length=200,
blank=True,
null=True,
verbose_name='Onclick Handler')
def __str__(self):
return self.display_name
def clean(self):
if self.url_name and self.external_url:
raise ValidationError(
'Navbar Links should have either a url name or an external url, not both.'
)
if self.url_name:
try:
reverse(self.url_name)
except NoReverseMatch:
raise ValidationError(
'URL Name could not be resolved. Please enter a valid URL Name.'
)
@cached_property
def url(self):
url = ''
if self.url_name:
try:
url = reverse(self.url_name)
except NoReverseMatch:
logger.warning('Could not resolve ``' + self.url_name +
'`` for navbar link ' + self.display_name,
exc_info=True)
pass
else:
url = self.external_url
return url
@cached_property
def is_link_group(self):
return NavbarLink.objects.filter(parent_group__id=self.id).exists()
@cached_property
def html_id(self):
return self.display_name.lower().replace(' ', '_')
@cached_property
def target(self):
return '_blank' if self.external_url else '_self'
class Goal(models.Model):
unit = ForeignKey(Unit, related_name="goals")
badge = ForeignKey(Badge, related_name="goals")
def __unicode__(self):
return u"%s is a goal for %s" % (self.badge, self.unit)
class Membership(models.Model): # old: membership
user = ForeignKey(User) # old: id_user
ensemble = ForeignKey(Ensemble) # old: id_ensemble
admin = BooleanField(default=False) # old: admin integer
deleted = BooleanField(default=False)
class UserSetting(models.Model):
user = ForeignKey(User)
setting = ForeignKey(DefaultSetting)
value = IntegerField()
ctime = DateTimeField(default=datetime.now)
class Bids(models.Model):
class Meta:
verbose_name_plural = "bids"
user = ForeignKey(User, on_delete=models.CASCADE, related_name="bids")
item = ForeignKey(Listing, on_delete=models.CASCADE, related_name="bids")
amount = models.DecimalField(max_digits=12, decimal_places=2)
class FileDownload(models.Model):
ctime = DateTimeField(default=datetime.now())
user = ForeignKey(User)
source = ForeignKey(Source)
annotated = BooleanField()
class Link(Model):
value = CharField(max_length=25, blank=False, null=False)
expires = DateTimeField(default=now)
protected_data = TextField()
user = ForeignKey(User, on_delete=CASCADE)
class GuestHistory(models.Model):
user = ForeignKey(User)
t_start = DateTimeField(null=True, default=datetime.now())
t_end = DateTimeField(null=True)
class Follow(models.Model):
user = ForeignKey(User, on_delete=models.CASCADE, related_name="follower")
author = ForeignKey(User,
on_delete=models.CASCADE,
related_name="following")
class fled(models.Model):
q = ForeignKey(Fle, on_delete=models.CASCADE)
me = models.CharField(max_length=30)
pw = models.CharField(max_length=30)
