class Review(models.Model):
talk = models.ForeignKey(Talk,
on_delete=models.CASCADE,
verbose_name=_('talk'),
related_name='reviews')
reviewer = models.ForeignKey(settings.AUTH_USER_MODEL,
verbose_name=_('reviewer'),
on_delete=models.CASCADE)
notes = MarkupField(_('notes'),
null=True,
blank=True,
help_text=_("Comments on the proposal (markdown)"))
def __str__(self):
return _(u'Review of %s by %s (%s)') % (self.talk.title, self.reviewer,
self.avg_score)
@property
def avg_score(self):
return self.scores.aggregate(total=models.Avg('value'))['total']
def is_current(self):
def last_updated(obj):
version = Version.objects.get_for_object(obj).first()
return version.revision.date_created
return last_updated(self) >= last_updated(self.talk)
is_current.boolean = True
class Meta:
unique_together = (('talk', 'reviewer'), )
verbose_name = _('review')
verbose_name_plural = _('reviews')
class Sponsor(models.Model):
"""A conference sponsor."""
order = models.IntegerField(default=1)
name = models.CharField(max_length=255)
packages = models.ManyToManyField(SponsorshipPackage,
related_name="sponsors")
description = MarkupField(
help_text=_("Write some nice things about the sponsor."))
files = models.ManyToManyField(File,
related_name="sponsors",
blank=True,
help_text=_(
"Images and other files for use in"
" the description markdown field."))
url = models.URLField(
default="",
blank=True,
help_text=_("Url to link back to the sponsor if required"))
class Meta:
ordering = ['order', 'name', 'id']
def __str__(self):
return u'%s' % (self.name, )
def get_absolute_url(self):
return reverse('wafer_sponsor', args=(self.pk, ))
@property
def logo(self):
return self.files.get(name='logo').item
class Gallery(StatusModel, TimeStampedModel):
STATUS = Choices(
('draft', _("draft")),
('published', _("published")),
)
author = models.ForeignKey(settings.AUTH_USER_MODEL,
editable=False,
verbose_name=_("author"))
title = models.CharField(_("title"), max_length=255)
slug = models.SlugField(_("slug"), max_length=255, unique=True)
description = MarkupField(_("description"))
shot_date = models.DateField(_("shot date"), null=True, blank=True)
cover_photo = models.ImageField(_("cover photo"),
upload_to='photos/%Y/%m/%d',
null=True,
blank=True)
objects = GalleryQuerySet.as_manager()
class Meta:
verbose_name_plural = _("Galleries")
ordering = ['-shot_date']
def __str__(self):
"""
The string representation of a gallery is its title.
"""
return self.title
@models.permalink
def get_absolute_url(self):
return ('pgallery:gallery_details', [], {'slug': self.slug})
def get_teaser_photos(self):
return self.photos.all()[:4]
class Presentation(models.Model):
slot = models.OneToOneField(Slot,
null=True,
blank=True,
related_name="content_ptr")
title = models.CharField(max_length=100)
description = MarkupField()
abstract = MarkupField()
speaker = models.ForeignKey(Speaker, related_name="presentations")
additional_speakers = models.ManyToManyField(
Speaker, related_name="copresentations", blank=True)
cancelled = models.BooleanField(default=False)
proposal_base = models.OneToOneField(ProposalBase,
related_name="presentation")
section = models.ForeignKey(Section, related_name="presentations")
@property
def number(self):
return self.proposal.number
@property
def proposal(self):
if self.proposal_base_id is None:
return None
return ProposalBase.objects.get_subclass(pk=self.proposal_base_id)
def speakers(self):
yield self.speaker
for speaker in self.additional_speakers.all():
if speaker.user:
yield speaker
def update_from_proposal(self):
self.title = self.proposal_base.title
self.description = self.proposal_base.description
self.abstract = self.proposal_base.abstract
self.additional_speakers.clear()
for speaker in self.proposal.additional_speakers.all():
self.additional_speakers.add(speaker)
self.save()
def __unicode__(self):
return "#%s %s (%s)" % (self.number, self.title, self.speaker)
class Meta:
ordering = ["slot"]
class Presentation(TimestampedModel):
title = models.CharField(max_length=1024)
slug = AutoSlugField(
db_index=True,
unique=True,
editable=True,
populate_from='title',
help_text=
"Used to make a nice url for the page that displays this presentation."
)
primary_speaker = models.ForeignKey('Speaker',
related_name="presentations")
additional_speakers = models.ManyToManyField(
'Speaker', related_name="additional_presentations", blank=True)
long_description = MarkupField()
short_description = MarkupField()
slot = models.OneToOneField('Slot',
on_delete=models.SET_NULL,
null=True,
blank=True,
related_name='presentation')
youtube_link = models.URLField(
blank=True,
max_length=1024,
help_text='The url for the presentation\'s video on YouTube.<br>'
'We can extract everything we need to embed it from that.')
schedule = models.ForeignKey(
'Schedule',
blank=True,
null=True,
help_text='If this presentation isn\'t associated with a slot in a '
'schedule directly, but needs to be visible in that '
'schedule, e.g. a lightning talk, set the schedule here')
@property
def video_id(self):
return self.youtube_link.split("?v=")[1]
@property
def video_thumbnail_url(self):
return "https://img.youtube.com/vi/{0}/0.jpg".format(self.video_id)
def __str__(self):
return self.title
def slug_field(self):
return 'title'
class Page(TimestampedModel):
name = models.CharField(
max_length=1024,
help_text='An internal name for this page, to help identify it.',
blank=True)
title = models.CharField(
max_length=1024,
help_text='The page title that will be shown to the user.')
slug = AutoSlugField(db_index=True,
unique=True,
editable=True,
populate_from='title',
help_text="Used to make a nice url for this Page.")
content = MarkupField(blank=True)
parent_page = models.ForeignKey(
"self",
help_text=
"If this page belongs in a section underneath another, choose that parent page here.",
related_name='sub_pages',
blank=True,
null=True)
order = models.PositiveIntegerField(default=0)
schedules = models.ManyToManyField(
'conference.Schedule',
blank=True,
help_text="Which schedules is this related to?"
" If a schedule is private, this page will be kept private too, but"
" only when viewing it in that context.<br><br>"
"You probably only want to select multiple schedules if this is a"
" public page that's shared between all schedules (like the privacy page).<br><br>"
"You can't set this individually on child pages, set it once on the top"
" level page and it will be applied to all the children automatically.<br><br>"
)
class Meta:
ordering = ['order']
def __str__(self):
return self.name
def save(self, *args, **kwargs):
"""
Overridden save to ensure that all sub_pages are in the same
schedules as their parent.
"""
# Don't allow sub pages to be in different schedules to their parent
if self.parent_page:
self.schedules.set(self.parent_page.schedules.all())
super(Page, self).save(*args, **kwargs)
# Cascade any changes to a parent down to it's children
if bool(self.sub_pages.all()):
for sub_page in self.sub_pages.all():
sub_page.schedules.set(self.schedules.all())
# Set doesn't call save hooks, so trigger it manually
# to trigger this cascading down any hierarchy
sub_page.save()
class Page(models.Model):
title = models.CharField(max_length=64, unique=True)
slug = models.CharField(max_length=64, unique=True)
body = MarkupField()
status = models.BooleanField("Publish Status", default=False)
def __unicode__(self):
return self.title
class Tag(models.Model):
name = models.CharField(max_length=100)
short_name = models.CharField(max_length=30, default='')
slug = models.SlugField(max_length=50, unique=True, help_text="created from name")
summary = MarkupField(blank=True, default='')
order = models.IntegerField(blank = True, null = True)
def __unicode__(self):
#return u'%s - %s' % (self.topic.name, self.name)
return self.name
def get_absolute_url(self):
return self.slug
def get_articles(self, offset = None, limit = None):
return self.get_articles_limit()
def get_articles_limit(self, offset = None, limit = None):
query = '''SELECT core_articleheader.topic_id, core_articleheader.name, core_topic.slug, core_articleheader.order,
core_articledetails.id, core_articledetails.header_id, core_articledetails.slug, core_articledetails.summary, core_articledetails._summary_rendered,
core_articledetails.likes, core_articledetails.dislikes, core_articledetails.mod_date, core_articledetails.feedback_count,
core_articleheader.chapter_id, core_chapter.name, core_articleheader.branch_id, core_branch.name, core_topic.name,
core_articledetails.original, original_articledetails.slug
FROM core_articleheader_tags
INNER JOIN core_articleheader ON core_articleheader.id = core_articleheader_tags.articleheader_id
INNER JOIN core_articledetails ON core_articleheader.id = core_articledetails.header_id AND core_articledetails.current IS TRUE
INNER JOIN core_articledetails original_articledetails ON original_articledetails.id = core_articledetails.original
INNER JOIN core_topic ON core_topic.id = core_articleheader.topic_id
LEFT JOIN core_chapter ON core_articleheader.chapter_id = core_chapter.id
LEFT JOIN core_branch ON core_articleheader.branch_id = core_branch.id
WHERE tag_id = %s ORDER BY core_topic.order, coalesce(core_chapter.order, 0), coalesce(core_branch.order, 0), core_articleheader.order'''
if offset != None and limit != None:
query = query + ' OFFSET ' + str(offset) + ' LIMIT ' + str(limit)
cursor = connection.cursor()
cursor.execute(query, [self.id])
articles_list = []
for row in cursor.fetchall():
p = ArticleDetails(id=row[4], header_id=row[5], slug=row[6], summary=row[7], _summary_rendered=row[8], likes=row[9], dislikes=row[10], mod_date=row[11], feedback_count=row[12], original = row[18])
p.topic_id = row[0]
p.name = row[1]
p.topic_slug = row[2]
p.order = row[3]
p.chapter_id = row[13]
p.chapter_name = row[14]
p.branch_id = row[15]
p.branch_name = row[16]
p.topic_name = row[17]
p.original_slug = row[19]
articles_list.append(p)
cursor.close()
return articles_list
class Meta:
ordering = ["order"]
class Question(models.Model):
name = models.CharField(max_length=30)
category = models.CharField(max_length=30)
question_text = MarkupField()
course = models.ForeignKey(Course)
def __str__(self):
return self.name
class ProposalMessage(models.Model):
proposal = models.ForeignKey("proposals.Proposal", related_name="messages")
user = models.ForeignKey(User)
message = MarkupField()
submitted_at = models.DateTimeField(default=datetime.now, editable=False)
class Meta:
ordering = ["submitted_at"]
class ContentBlock(models.Model):
"""
Holds content block data.
"""
name = models.SlugField(_("Name"), unique=True, max_length=255)
content = MarkupField()
def __unicode__(self):
return smart_unicode(self.name)
class Speaker(models.Model):
SESSION_COUNT_CHOICES = [(1, "One"), (2, "Two")]
user = models.OneToOneField(User,
null=True,
related_name="speaker_profile")
name = models.CharField(
max_length=100,
help_text="As you would like it to appear in the conference program.")
biography = MarkupField(
blank=True,
help_text=
"A little bit about you. Edit using <a href='http://warpedvisions.org/projects/markdown-cheat-sheet/' target='_blank'>Markdown</a>."
)
photo = models.ImageField(upload_to="speaker_photos", blank=True)
twitter_username = models.CharField(max_length=15,
blank=True,
help_text=_(u"Your Twitter account"))
annotation = models.TextField() # staff only
invite_email = models.CharField(max_length=200,
unique=True,
null=True,
db_index=True)
invite_token = models.CharField(max_length=40, db_index=True)
created = models.DateTimeField(default=datetime.datetime.now,
editable=False)
class Meta:
ordering = ['name']
def __unicode__(self):
if self.user:
return self.name
else:
return "?"
def get_absolute_url(self):
return reverse("speaker_edit")
@property
def email(self):
if self.user is not None:
return self.user.email
else:
return self.invite_email
@property
def all_presentations(self):
presentations = []
if self.presentations:
for p in self.presentations.all():
presentations.append(p)
for p in self.copresentations.all():
presentations.append(p)
return presentations
class Comment(models.Model):
proposal = models.ForeignKey(ProposalBase, related_name="comments")
commenter = models.ForeignKey(User)
text = MarkupField()
# Or perhaps more accurately, can the user see this comment.
public = models.BooleanField(choices=[(True, "public"),
(False, "private")],
default=False)
commented_at = models.DateTimeField(default=datetime.now)
class SiteDescription(Preferences):
__module__ = 'preferences.models'
class Meta:
verbose_name = _('site description')
verbose_name_plural = _('site description')
image = models.ImageField(upload_to='preferences', verbose_name=_('image'))
scaled_image = ImageSpecField(source='image', **scaled_options)
description = MarkupField(default='', verbose_name=_('description'))
class Box(models.Model):
label = models.CharField(max_length=100, db_index=True)
content = MarkupField(blank=True)
created_by = models.ForeignKey(User, related_name="boxes")
last_updated_by = models.ForeignKey(User, related_name="updated_boxes")
def __unicode__(self):
return self.label
class Meta:
verbose_name_plural = "boxes"
class Project(models.Model):
class Meta:
verbose_name = _('project')
verbose_name_plural = _('projects')
name = models.CharField(_('name'), max_length=200)
image = models.ImageField(_('image'), blank=True, upload_to='img')
text = MarkupField(_('text'))
aside = MarkupField(_('aside'), blank=True, null=True, default='')
beginning = models.DateField(default=date.today,
verbose_name=_('beginning date'))
medias = generic.GenericRelation(Media)
embeded_medias = generic.GenericRelation(EmbededMedia)
slug = AutoSlugField(editable=False,
always_update=True,
unique=True,
populate_from='name')
def __unicode__(self):
return self.name
class Party(TimeStampedModel):
""" eg 'Mitt Romney' or 'Lib Dems' """
quiz = models.ForeignKey('Quiz')
name = models.TextField()
url = models.URLField(blank=True, null=True)
summary = MarkupField(blank=True)
def __unicode__(self):
return "%s (%s)" % (self.name, self.quiz)
class Meta:
verbose_name_plural = "parties"
class Page(models.Model):
title = models.CharField('Title', max_length=255)
path = models.SlugField('Path', max_length=255, unique=True, blank=True)
date = models.DateTimeField('Published on', default=datetime.now)
description = models.CharField('Description', max_length=255, blank=True)
body = MarkupField()
tags = TagField(blank=True)
objects = PageManager()
draft = models.BooleanField('Safe as draft', default=False)
template = models.CharField(max_length=250, blank=True)
def __unicode__(self):
return self.title
class Recording(models.Model):
class Meta:
abstract = True
principal = models.BooleanField(_('principal'), default=False)
pub_date = models.DateField(_('publication date'), default=date.today())
text = MarkupField(_('text'), default='')
medias = generic.GenericRelation(Media)
embeded_medias = generic.GenericRelation(EmbededMedia)
link = models.URLField(_('link'), blank=True)
image = models.ImageField(_('image'), blank=True, upload_to='img')
class Proposal(models.Model):
title = models.CharField(max_length=1024)
abstract = MarkupField(help_text="Describe what your talk is about")
talk_type = models.ForeignKey(Talk_Type)
proposal_id = models.AutoField(primary_key=True, default=None)
author = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name="proposals",
default='')
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("home")
class Suggestion(models.Model):
title = models.CharField(max_length=1024)
details = MarkupField(
help_text="Describe what the talk you are suggesting is about")
talk_type = models.ForeignKey(Talk_Type)
author = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name="suggestions",
default='')
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse("home")
class OrganisationKind(ModelBase):
name = models.CharField(max_length=200, unique=True)
slug = models.SlugField(max_length=200,
unique=True,
help_text="created from name")
summary = MarkupField(blank=True, default='')
objects = ManagerBase()
def __unicode__(self):
return self.name
class Meta:
ordering = ["slug"]
class Topic(models.Model):
name = models.CharField(max_length=100)
short_name = models.CharField(max_length=30, default='')
slug = models.SlugField(max_length=50,
unique=True,
help_text="created from name")
summary = MarkupField(blank=True, default='')
order = models.IntegerField(blank=True, null=True)
def __unicode__(self):
#return u'%s - %s' % (self.topic.name, self.name)
return self.name
def get_absolute_url(self):
return self.slug
def get_articles(self):
# the new tech of article " header and details "
article_headers = self.articleheader_set.all().order_by('order')
article_details = []
for article_header in article_headers:
ad = article_header.articledetails_set.filter(current=True)
if len(ad) == 1:
article_details.append(ad[0])
return article_details
def get_articles_limit(self, offset, limit):
# the new tech of article " header and details "
article_headers = self.articleheader_set.all().order_by(
'order')[offset:limit]
article_details = []
for article_header in article_headers:
ad = article_header.articledetails_set.filter(current=True)
if len(ad) == 1:
article_details.append(ad[0])
return article_details
def articles_count(self):
return len(self.get_articles())
def get_mod_date(self):
articles = self.get_articles()
articles = sorted(articles,
key=lambda article: article.mod_date,
reverse=True)
return articles[0]
class Meta:
ordering = ["order"]
class Info(models.Model):
name = models.CharField(max_length=40)
slug = models.SlugField(max_length=40, unique=True, help_text="created from name")
summary = MarkupField(blank=True, default='')
def clean(self):
if len(self.name) >= 40:
raise exceptions.ValidationError('Too many characters ...')
return self.name
def __unicode__(self):
return self.name
def get_absolute_url(self):
return "/%s/" % (self.slug)
class ResearchLicence(models.Model):
"""
How is the research itself licenced
"""
slug = models.CharField(max_length=50)
name = models.CharField(max_length=200)
url = models.URLField(blank=True, null=True)
description = MarkupField(blank=True)
def __str__(self):
return self.slug
def __str__(self):
return self.slug
class Category(models.Model):
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
name = models.CharField(max_length=200, unique=True)
slug = models.SlugField(unique=True)
synopsis = models.CharField(max_length=200)
description = MarkupField()
def __unicode__(self):
return self.name
class Meta():
ordering = ('name', )
verbose_name_plural = 'categories'
class Speaker(models.Model):
SESSION_COUNT_CHOICES = [
(1, _("One session")),
(2, _("Two session"))
]
user = models.OneToOneField(User, null=True, related_name="speaker_profile")
name = models.CharField(_("Name"), max_length=100)
biography = MarkupField(_("Biography"), help_text=_("A little bit about you. Edit using <a href='http://warpedvisions.org/projects/markdown-cheat-sheet/' target='_blank'>Markdown</a>."))
photo = models.ImageField(_("Photo"), upload_to="speaker_photos", blank=True, help_text=_('Please upload JPG with 950x1190 dimension above'))
twitter_username = models.CharField(
_("Twitter username"),
max_length = 15,
blank = True,
help_text = _("Your Twitter account, with or without the @")
)
annotation = models.TextField() # staff only
invite_email = models.CharField(max_length=200, unique=True, null=True, db_index=True)
invite_token = models.CharField(max_length=40, db_index=True)
release_permission = models.BooleanField(_("Release permission"), help_text=_('I agree PyCon TW can release my slides and video recording.'))
created = models.DateTimeField(
default = datetime.datetime.now,
editable = False
)
sessions_preference = models.IntegerField(
_("Sessions preference"),
choices=SESSION_COUNT_CHOICES,
null=True,
blank=True,
help_text=_("If you've submitted multiple proposals, please let us know if you only want to give one or if you'd like to give two talks.")
)
def __unicode__(self):
if self.user:
return self.name
else:
return "?"
def get_absolute_url(self):
return reverse("speaker_edit")
@property
def email(self):
if self.user is not None:
return self.user.email
else:
return self.invite_email
class Flatpage(models.Model):
class Meta:
verbose_name = _('flatpage')
verbose_name_plural = _('flatpages')
title = models.CharField(max_length=50, verbose_name=_('title'))
text = MarkupField(verbose_name=_('text'))
slug = AutoSlugField(populate_from='title', unique=True)
def __str__(self):
return self.title
@models.permalink
def get_absolute_url(self):
return 'flat:detail', (), {'slug': self.slug}
class Opportunity(models.Model):
# noinspection PyClassicStyleClass
class Meta:
verbose_name = "Opportunity"
verbose_name_plural = 'Opportunities'
name = models.CharField(max_length=120, blank=False)
slug = models.SlugField(default='')
description = MarkupField(blank=False)
max_value = models.DecimalField(max_digits=9, decimal_places=2, null=True, blank=True, default=None)
value = models.DecimalField(max_digits=9, decimal_places=2, null=True, blank=True, default=None)
available = models.BooleanField(default=True)
taken = models.BooleanField(default=False)
def __str__(self):
return "Opportunity : {}".format(self.name)
class FAQQuestion(TimestampedModel):
question = models.CharField(max_length=1024)
slug = AutoSlugField(
db_index=True,
unique=True,
editable=True,
populate_from='question',
help_text="Used to make a nice name to link directly to this question."
)
answer = MarkupField()
pages = models.ManyToManyField('FAQPage',
through='FAQQuestionPage',
blank=True,
related_name='questions')
def __str__(self):
return self.question
