class Notebook(models.Model):
"""A notebook is a bag of notes."""
by_user = models.ForeignKey(User,
null=True,
related_name='notebooks',
on_delete=models.CASCADE)
uuid = models.UUIDField(default=uuid4,
db_index=True,
editable=False,
unique=True)
title = BleachField()
subtitle = BleachField(blank=True, default="")
description = BleachField(blank=True, default="")
when_published = models.DateTimeField(null=True)
when_created = models.DateTimeField(auto_now_add=True)
when_modified = models.DateTimeField(auto_now=True)
is_public = models.BooleanField(default=False)
is_fiction = models.BooleanField(default=False)
is_deleted = models.BooleanField(default=False)
class Meta:
db_table = 'notebook'
unique_together = (("title", "by_user"), )
ordering = ['-when_modified']
def full_notes(self):
return Note.objects.filter(in_notebook__id=self.id)
def __unicode__(self):
return '{}'.format(self.title, )
class Shop(models.Model):
user = models.ForeignKey('user.TinvilleUser')
name = models.CharField(verbose_name="Shop name", unique=True, blank=False, null=False, db_index=True,
default=None, max_length=100)
slug = models.SlugField()
banner = models.ImageField(default='images/banner.jpg',
upload_to=upload_to_banner, max_length=255)
bannerCropping = ImageRatioField('banner', '1779x364', box_max_width=200)
mobileBanner = models.ImageField(default='images/mobilebanner.jpg',
upload_to=upload_to_mobile_banner, max_length=255)
mobileBannerCropping = ImageRatioField('mobileBanner', '968x642', box_max_width=200)
logo = models.ImageField(upload_to=upload_to_logo, max_length=255)
aboutImg = models.ImageField(upload_to=upload_to_about, max_length=255)
# size is "width x height"
aboutImgCropping = ImageRatioField('aboutImg', '155x155', box_max_width=200)
aboutContent = BleachField()
returnPolicy = BleachField(verbose_name="Return policy", blank=True, null=True)
color = models.CharField(default='#5B595A', max_length=7,
validators=[RegexValidator(
regex='^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$',
message='Invalid hex code',
),]
)
def __unicode__(self):
return self.name
def get_absolute_url(self):
return "/%s/" % self.slug
def save(self, *args, **kwargs):
self.slug = slugify(self.name.lower())
super(Shop, self).save(*args, **kwargs)
class Messages(models.Model):
chat_room = BleachField(
max_length=50,
)
user = BleachField(
max_length=50,
)
data = BleachField(
max_length=1000,
)
class Casino_supplier(models.Model):
name = models.CharField(max_length=100)
image = models.ImageField(default=None, blank=True, null=True)
bonus = BleachField(blank=True, null=True)
link = BleachField(blank=True, null=True)
warning_label = BleachField(blank=True, null=True)
position = models.IntegerField(blank=True, default=500)
def __str__(self):
return '{}'.format(self.name, )
class MeasurementScore(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
measurement = models.ForeignKey(Measurement,
related_name='scores',
on_delete=models.CASCADE)
name = BleachField(max_length=DEFAULT_CHAR_LENGTH)
grade = BleachField(max_length=DEFAULT_CHAR_LENGTH)
grade_value = models.FloatField()
def __str__(self):
return "Score[%s = %s (%.1f)]" % self.name, self.grade, self.grade_value
class BleachContent(models.Model):
""" Bleach test model"""
CHOICES = (('f', 'first choice'), ('s', 'second choice'))
content = BleachField(allowed_attributes=ALLOWED_ATTRIBUTES,
allowed_protocols=ALLOWED_PROTOCOLS,
allowed_styles=ALLOWED_STYLES,
allowed_tags=ALLOWED_TAGS,
strip_comments=True,
strip_tags=True)
choice = BleachField(choices=CHOICES)
blank_field = BleachField(blank=True)
class Deck(models.Model):
# profile = models.ForeignKey(Profile, on_delete=models.CASCADE, related_name = 'decks')
# name = models.CharField(max_length=50, null=False, blank=False)
# description = models.CharField(max_length=250, null=False, blank=True)
name = BleachField(max_length=50, null=False, blank=False)
description = BleachField(max_length=50, null=False, blank=True)
def __str__(self):
return self.name
class JSONAPIMeta:
resource_name = "decks"
class Article(models.Model):
slug = models.SlugField(blank=True)
name = models.CharField(max_length=200, blank=True)
image = models.ImageField(default=None, blank=True, null=True)
intro_text = BleachField(blank=True)
content = BleachField(blank=True)
link = BleachField(blank=True)
date = models.CharField(max_length=200, blank=True)
automated_date = models.DateTimeField(auto_now_add=True)
def __str__(self):
return '{}'.format(self.name)
class Event(models.Model):
"""
An event is something that happened at a moment in time.
"""
in_scroll = models.ForeignKey(Scroll,
related_name='events',
on_delete=models.CASCADE)
with_thumbnail = models.ForeignKey(Thumbnail,
related_name='events',
on_delete=models.CASCADE,
null=True)
by_user = models.ForeignKey(User,
null=True,
related_name='events',
on_delete=models.CASCADE)
uuid = models.UUIDField(default=uuid4,
db_index=True,
editable=False,
unique=True)
# Typically filtered text/html, could also be text/text, or something else.
media_type = models.CharField(max_length=128, default="text/html")
# The root content type. A tag. PR, etc.
content_type = models.CharField(db_index=True,
max_length=128,
default="event")
title = BleachField(blank=False)
text = BleachField(blank=True, default="")
ranking = models.FloatField(db_index=True, default=0)
resolution = models.IntegerField(default=0)
content_url = models.URLField(max_length=512, blank=True, null=True)
citation = BleachField(default="", blank=True, null=False)
source_name = models.CharField(max_length=512, default="", blank=True)
source_url = models.URLField(max_length=512,
default="",
db_index=True,
blank=True)
when_created = models.DateTimeField(auto_now_add=True)
when_happened = models.DateTimeField(db_index=True)
when_original = models.CharField(default="", max_length=128, blank=True)
is_deleted = models.BooleanField(default=False)
objects = EventQueryset.as_manager()
class Meta:
unique_together = (("by_user", "in_scroll", "title", "content_url"), )
db_table = 'event'
ordering = ['-ranking', '?']
def __unicode__(self):
return '{}'.format(self.title, )
class ComponentMeasurement(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
measurement = models.ForeignKey(Measurement,
related_name='component_measurements',
on_delete=models.CASCADE)
node = BleachField(max_length=DEFAULT_CHAR_LENGTH)
parent = BleachField(max_length=DEFAULT_CHAR_LENGTH, blank=True)
useful_lines = models.IntegerField()
threshold_violations = models.IntegerField()
full_name = BleachField(max_length=DEFAULT_CHAR_LENGTH)
def __str__(self):
return "ComponentMeasurement[%s]" % self.node
class Post(models.Model):
# This is the default because it is not very common to
# not need to calculate upvotes and that will result in
# a lot of db hits if we don't prefetch the votes
objects = PostVotesManager()
objects_no_votes = models.Manager()
# set default so that management command can overwrite
created = models.DateTimeField(default=timezone.now)
updated = models.DateTimeField(auto_now=True)
title = BleachField(
validators=[MaxLengthValidator(
150,
message=_("The title can only be 150 characters in length.")
)]
)
body = BleachField(blank=True)
subreddit = models.ForeignKey(
Sub,
on_delete=models.CASCADE,
related_name="posts"
)
poster = models.ForeignKey(
User,
on_delete=models.SET_NULL,
null=True,
related_name="posts"
)
voters = models.ManyToManyField(
User,
through='votes.PostVote',
related_name='voted_posts',
)
# Reverse FK to Comment related_name="comments"
@property
def upvotes(self):
"""
Just add up the prefetched votes vote_types.
"""
return sum([vote.vote_type for vote in self.votes.all()])
def __str__(self):
return str(self.title)
class Flashcard(models.Model):
parentdeck = models.ForeignKey(Deck,
on_delete=models.CASCADE,
blank=True,
null=True,
related_name='flashcards')
# term = models.TextField(max_length=50, null=True)
# definition = models.TextField(max_length=250, null=True)
term = BleachField(max_length=50, null=True)
definition = BleachField(max_length=250, null=True)
def __str__(self):
return str(self.term)
class JSONAPIMeta:
resource_name = "flashcards"
class Agreement(models.Model):
name = models.CharField(
max_length=200,
verbose_name=_("Name"),
)
text = BleachField(
verbose_name=_("Text"),
)
start = models.DateField(
verbose_name=_("Start date"),
)
end = models.DateField(
verbose_name=_("End date"),
blank=True,
null=True,
)
def clean(self):
if self.end and self.start > self.end:
raise ValidationError(_("End date must be after start date."))
@property
def in_timeframe(self):
today = datetime.datetime.today().date()
return self.start <= today and (self.end is None or today <= self.end)
def __str__(self):
return "{} ({})".format(self.name, self.start)
class Trip(TimeStampedModel):
location = models.ForeignKey(to=Location, verbose_name=_("Location"))
name = models.CharField(verbose_name=_("Name"), max_length=100)
slug = AutoSlugField(populate_from='name',
verbose_name=_("Slug"),
unique=True)
created_by = models.ForeignKey(to=settings.AUTH_USER_MODEL)
description = BleachField(verbose_name=_("Description of trip"))
base_price = models.IntegerField(verbose_name=_("Price"),
help_text=_("Price per each guest"))
space = models.PositiveIntegerField(
verbose_name=_("Space"),
default=10,
help_text=_("The maximum number of guests"))
main_image = VersatileImageField(_('Image'), upload_to='images/')
objects = TripQuerySet.as_manager()
class Meta:
verbose_name = _("Trip")
verbose_name_plural = _("Trips")
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse('trips:details', kwargs={'slug': self.slug})
def get_price_display(self):
return "%.2f PLN" % (self.base_price / 100)
class Question(models.Model):
title = models.CharField(max_length=50)
description = BleachField(max_length=2000)
asked_by = models.ForeignKey(User, on_delete=models.CASCADE)
asked_on = models.DateField(auto_now_add=True)
upvotes = models.ManyToManyField(User,
related_name='ans_upvote',
blank=True)
downvotes = models.ManyToManyField(User,
related_name='ans_downvote',
blank=True)
accepted_answer = models.OneToOneField(
'Answer',
null=True,
on_delete=models.CASCADE,
related_name="accepted_for_question",
blank=True)
tags = models.ManyToManyField('QuestionTag',
blank=True,
related_name='questions')
def get_score(self):
return self.upvotes.count() - (2 * self.downvotes.count())
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("question-detail", kwargs={"pk": self.pk})
class Article(models.Model):
title = models.CharField(max_length=255)
slug = models.SlugField(
default='',
editable=False,
max_length=255,
)
body = BleachField()
date = models.DateTimeField(auto_now_add=True)
author = models.ForeignKey(
# get_user_model(),
User,
on_delete=models.CASCADE,
)
def __str__(self):
return self.title
def get_absolute_url(self):
kwargs = {'pk': self.id, 'slug': self.slug}
return reverse("article_detail", kwargs=kwargs)
def save(self, *args, **kwargs):
value = self.title
self.slug = slugify(value, allow_unicode=True)
super().save(*args, **kwargs)
class Resource(models.Model):
"""Resources which are protected by Agreements"""
name = models.CharField(max_length=300, unique=True)
slug = models.SlugField(max_length=300,
unique=True,
validators=[
RegexValidator(
regex="^create$",
message="The slug cannot be 'create'.",
inverse_match=True)
],
help_text='URL-safe identifier for the resource.')
description = BleachField(
blank=True,
allowed_tags=DEFAULT_ALLOWED_TAGS,
allowed_attributes={
'a': ['href', 'title'],
'abbr': ['title'],
'acronym': ['title']
},
allowed_protocols=['https', 'mailto'],
strip_tags=False,
strip_comments=True,
help_text=f'An HTML description of the resource. '
f'The following tags are allowed: { ", ".join(DEFAULT_ALLOWED_TAGS)}.')
low_codes_threshold = models.PositiveSmallIntegerField(
default=51,
help_text='If the number of unassigned license codes '
'associated with this resource falls below this '
'threshold, start emailing warnings.')
low_codes_email = models.CharField(
blank=True,
max_length=200,
validators=[validate_email],
help_text='The recipient of email warnings about low numbers of '
'remaning unassigned license codes. If empty, no emails are sent.')
hidden = models.BooleanField(
default=False,
help_text=
'Hidden resources do not appear in the list of active resources.')
history = HistoricalRecords()
class Meta:
permissions = [
('resource_view_file_access_stats',
'Can view the file access statistics associated with this resource'
),
('resource_view_licensecodes',
'Can view the license codes associated with this resource'),
('resource_change_licensecodes',
'Can change the license codes associated with this resource')
]
def get_absolute_url(self):
"""Returns the canonical URL for a Faculty"""
return reverse('resources_read', args=[self.slug])
def __str__(self):
"""Returns the string representation of a Faculty"""
return self.name
class Person(models.Model):
name = models.CharField(max_length=20)
biography = BleachField(max_length=100,
verbose_name='Person biography',
allowed_tags=['p', 'a', 'li', 'ul', 'strong'],
allowed_attributes=['class', 'href', 'style'],
allowed_protocols=['http', 'https'],
allowed_styles=['color', 'background-color'])
class BleachContent(models.Model):
""" Bleach test model"""
content = BleachField(allowed_attributes=ALLOWED_ATTRIBUTES,
allowed_protocols=ALLOWED_PROTOCOLS,
allowed_styles=ALLOWED_STYLES,
allowed_tags=ALLOWED_TAGS,
strip_comments=True,
strip_tags=True)
class EventPage(models.Model):
event = models.ForeignKey('Event', related_name='pages')
slug = models.SlugField(max_length=50, blank=True, null=True)
heading = models.CharField(max_length=40)
body = BleachField()
class Meta:
unique_together = (('event', 'slug'))
class Message(models.Model):
#Limit content space to 500 to prevent nefariously sized messages
content = models.CharField('content', max_length=500)
content = BleachField()
sender = models.ForeignKey(User, null=True)
chatroom = models.ForeignKey(Chatroom, default=None)
def __str__(self):
return "#" + str(self.pk) + " to '" + str(self.chatroom) + "' chatroom"
class ticket_message(BaseModel):
k_ticket = models.ForeignKey("backend.ticket", on_delete=models.CASCADE)
k_created_by = models.ForeignKey("backend.user_model",
null=True,
on_delete=models.SET_NULL)
message = BleachField()
created = models.DateTimeField(auto_now_add=True, editable=False)
last_updated = models.DateTimeField(auto_now=True, editable=False)
class ticket(BaseModel):
k_created_by = models.ForeignKey("backend.user_model",
null=True,
on_delete=models.SET_NULL)
subject = models.CharField(max_length=360)
content = BleachField()
type = models.CharField(max_length=120)
status = models.CharField(default="Open", max_length=120)
created = models.DateTimeField(auto_now_add=True, editable=False)
last_updated = models.DateTimeField(auto_now=True, editable=False)
class Team(models.Model):
name = models.CharField(max_length=128)
subtitle = models.CharField(
max_length=256,
default=
_('Join your neighbors to learn something together. Learning circles meet weekly for 6-8 weeks, and are free to join.'
))
page_slug = models.SlugField(max_length=256, blank=True)
page_image = models.ImageField(blank=True)
logo = models.ImageField(blank=True)
latitude = models.DecimalField(max_digits=8,
decimal_places=6,
null=True,
blank=True)
longitude = models.DecimalField(max_digits=9,
decimal_places=6,
null=True,
blank=True)
zoom = models.IntegerField(default=7)
created_at = models.DateTimeField(default=now)
email_domain = models.CharField(max_length=128, blank=True)
invitation_token = models.UUIDField(null=True, blank=True, unique=True)
email_address = models.CharField(max_length=128, blank=True)
website = models.URLField(max_length=128, blank=True)
location = models.CharField(max_length=128, blank=True)
intro_text = BleachField(
max_length=1000,
blank=True,
allowed_tags=settings.TINYMCE_DEFAULT_CONFIG.get('valid_elements',
'').split(','),
allowed_attributes={'a': ['href', 'title', 'rel', 'target']})
membership = models.BooleanField(
default=False) # why not call this membership_active?
def __str__(self):
return self.name
def generate_invitation_token(self):
try:
self.invitation_token = uuid.uuid4()
self.save()
except IntegrityError:
generate_invitation_token(self)
def team_invitation_link(self):
if self.invitation_token is None:
return None
base_url = f'{settings.PROTOCOL}://{settings.DOMAIN}'
path = reverse('studygroups_facilitator_invitation_confirm_token',
kwargs={'token': self.invitation_token})
return base_url + path
class Benchmark(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
repository = models.ForeignKey(Repository,
related_name='benchmarks',
on_delete=models.CASCADE)
measurement_name = BleachField(max_length=DEFAULT_CHAR_LENGTH)
percentile_25 = models.FloatField()
percentile_50 = models.FloatField()
upper_threshold = models.FloatField()
num_cases = models.IntegerField()
def __str__(self):
return "Benchmark[%s]" % self.measurement_name
class Loser(models.Model):
slug = models.SlugField(unique=True)
meta_title = models.CharField(max_length=100, blank=True)
meta_description = models.TextField(blank=True)
profil_bild = models.ImageField(default=None, blank=True)
welcome_title = models.CharField(max_length=100, blank=True)
welcome_text = models.TextField(blank=True)
content = BleachField(blank=True)
date = models.DateTimeField(auto_now_add=True)
def __str__(self):
return '{}'.format(self.welcome_title, )
class Comment(models.Model):
post = models.ForeignKey('blog.Post', on_delete=models.CASCADE, related_name='comments')
author = models.CharField(max_length=200)
text = BleachField()
created_date = models.DateTimeField(default=timezone.now)
approved_comment = models.BooleanField(default=False)
def approve(self):
self.approved_comment = True
self.save()
def __str__(self):
return self.text
class Card(models.Model):
created = models.DateField(default=datetime.datetime.now())
updated = models.DateField(default=datetime.datetime.now())
name = models.CharField(max_length=80)
content = BleachField(null=True)
image = models.CharField(max_length=200, null=True)
board = models.ForeignKey(Board,
related_name='cards',
on_delete=models.CASCADE)
x_position = models.SmallIntegerField()
y_position = models.SmallIntegerField()
class BenchmarkDescription(models.Model):
""" A description of the how the benchmarks were generated """
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
repository = models.ForeignKey(Repository,
related_name='benchmark_descriptions',
on_delete=models.CASCADE)
num_projects = models.IntegerField(default=0)
selection_type = BleachField(max_length=DEFAULT_CHAR_LENGTH,
default="None")
date = models.DateTimeField()
project_data = BleachField(default="") # table of data in csv format
def __str__(self):
return "BenchmarkDescription[%s]" % self.selection_type
def get_project_data_column(self, column_name):
""" returns a column of data that corresponds to the given measurement name"""
df = pd.read_csv(StringIO(self.project_data))
if column_name in df:
return df[column_name].tolist()
else:
return None
class Scroll(models.Model):
"""A scroll is a bag of Events controlled by a single user."""
by_user = models.ForeignKey(User,
null=True,
related_name='scrolls',
on_delete=models.CASCADE)
uuid = models.UUIDField(default=uuid4,
db_index=True,
editable=False,
unique=True)
slug = models.SlugField(unique=True)
title = BleachField()
description = BleachField(blank=True, default="")
citation = BleachField(blank=True, default="")
link = models.URLField(blank=True, null=True)
with_thumbnail = models.ForeignKey(Thumbnail,
related_name='scrolls',
on_delete=models.CASCADE,
blank=True,
null=True)
when_published = models.DateTimeField(null=True)
when_created = models.DateTimeField(auto_now_add=True)
when_modified = models.DateTimeField(auto_now=True)
is_public = models.BooleanField(default=False)
is_fiction = models.BooleanField(default=False)
is_deleted = models.BooleanField(default=False)
meta_event_count = models.IntegerField(default=0)
meta_first_event = models.DateTimeField(null=True)
meta_last_event = models.DateTimeField(null=True)
class Meta:
db_table = 'scroll'
unique_together = (("title", "by_user"), )
ordering = ['-when_modified']
def __unicode__(self):
return '{}'.format(self.title, )
