class LocalConfRequest(BaseModel):
name = models.CharField(max_length=100,
unique=False,
help_text="Name of your event")
start_date = models.DateField(
help_text="Enter in following format: YYYY-MM-DD")
end_date = models.DateField(
help_text="Enter in following format: YYYY-MM-DD")
website = models.URLField(help_text="Your event website.")
location_url = models.URLField(help_text="Your event location URL.")
location_address = models.TextField(
help_text="Venue address with the venue name")
required_amount = models.FloatField("Requested amount in INR")
transferred_amount = models.FloatField("Transferred amount in INR",
default=0)
budget = models.FloatField("Conference budget")
expected_audience = models.IntegerField("Total expected participants")
description = MarkdownField("Say us about the conference",
help_text=LOCAL_CONF_HELP_TEXT)
is_brand_new = models.BooleanField(
help_text="Is the event held for the first time?", default=True)
upload = models.FileField(upload_to=upload_to_path,
help_text=UPLOAD_HELP_TEXT)
status = models.CharField(max_length=1,
choices=LOCAL_CONF_STATUS_CHOICES,
db_index=True)
requester = models.ForeignKey(settings.AUTH_USER_MODEL)
def get_all_participants(self):
"""Get all members who have access to the object.
"""
users = set([member.user for member in BoardMember.objects.all()])
users.add(self.requester)
return users
def get_content_type(self):
if self.upload.name.endswith('.pdf'):
return 'application/pdf'
elif self.upload.name.endswith('.xlsx'):
return 'application/vnd.ms-excel'
elif self.upload.name.endswith('ods'):
return 'application/vnd.oasis.opendocument.spreadsheet'
def __str__(self):
return "{name}: {start_date} - {end_date} [{status}] by {user}".format(
name=self.name,
start_date=self.start_date,
end_date=self.end_date,
status=self.get_status_display(),
user=self.requester)
class AnswerComment(BaseComment):
"""Model class to contain the comments for the answers."""
comment_text = MarkdownField()
answer = models.ForeignKey(Answer)
def save(self, *args, **kwargs):
try:
points = settings.QA_SETTINGS['reputation']['CREATE_ANSWER_COMMENT']
except KeyError:
points = 0
self.user.userqaprofile.modify_reputation(points)
super(AnswerComment, self).save(*args, **kwargs)
class Article(models.Model):
title = models.CharField(max_length=200)
body = MarkdownField()
publish = models.BooleanField(default=True)
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
slug = models.SlugField(unique=True, default=title)
def __str__(self):
return self.title
class Meta:
verbose_name = 'Article'
verbose_name_plural = 'Articles'
class Entry(BaseModel):
title = models.CharField(max_length=200)
body = MarkdownField()
slug = models.SlugField(max_length=200, unique=True)
publish = models.BooleanField(default=True)
objects = EntryQuerySet.as_manager()
def __str__(self):
return "%s" % (self.title)
class Meta:
verbose_name = 'Blog Entry'
verbose_name_plural = 'Blog Entries'
ordering = ['-created']
class EventReview(TimeStampedUUIDModel):
event = models.ForeignKey(Event,
related_name="reviews",
on_delete=models.CASCADE)
comment = MarkdownField(blank=True, null=True, verbose_name=_("Notes"))
moderator = models.ForeignKey(settings.AUTH_USER_MODEL,
related_name="event_reviews",
on_delete=models.CASCADE)
is_approved = models.BooleanField()
class Meta:
ordering = ('-created', )
def __str__(self):
return '{} -> {}'.format(self.moderator, self.event)
class QuestionComment(BaseComment):
"""模型类来包含问题的注释."""
comment_text = MarkdownField()
question = models.ForeignKey(Question, on_delete=models.CASCADE)
def save(self, *args, **kwargs):
try:
points = settings.QA_SETTINGS['reputation'][
'CREATE_QUESTION_COMMENT']
except KeyError:
points = 0
self.user.userqaprofile.modify_reputation(points)
super(QuestionComment, self).save(*args, **kwargs)
class Verse(models.Model):
author = models.ForeignKey('auth.User')
title = models.CharField(max_length=400)
text = MarkdownField()
date = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now_add=True)
tags = models.ManyToManyField(Tag)
votes = models.IntegerField(default=0)
def __unicode__(self):
return self.title
class Meta:
verbose_name = "Verse"
verbose_name_plural = "Verses"
class News(models.Model):
CHOICE = [('C', 'Campus News'),
('N', 'In the News'),
('S', 'Spotlight'),
]
title = models.CharField(max_length=300)
news_pic = models.ImageField(upload_to='article_pics/%Y-%m-%d/',null=True,blank=True)
thumbnail = ThumbnailerImageField(upload_to='news_thumbnail/%Y-%m-%d/', blank=True)
details = MarkdownField()
category = models.CharField(max_length=1, choices=CHOICE)
timestamp = models.DateTimeField(auto_now_add=True)
pinned = models.BooleanField(default=False)
def __str__(self):
return self.title
class NewEntry(models.Model):
title = models.CharField(max_length=200,)
body = MarkdownField()
published = models.BooleanField(default=False)
posted = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
slug = models.SlugField(max_length = 200,)
tag = models.ManyToManyField(Tag, null=False)
def save(self, *args, **kwargs):
self.slug = slugify(self.title).__str__()
super(NewEntry, self).save(*args, **kwargs)
def __unicode__(self):
return self.title
class PracticalBlock(models.Model):
title = models.CharField(max_length=255, blank=True)
text = MarkdownField()
photo = models.ImageField(upload_to=RandomFileName('practical'), blank=True)
link = models.URLField(blank=True)
link_placeholder = models.CharField(max_length=255, blank=True, default='')
practical = models.ForeignKey(Practical, on_delete=models.CASCADE, related_name='practical_block')
class Meta:
verbose_name = 'Practical Info Block'
verbose_name_plural = 'Practical Info Block'
ordering = ('pk',)
def __str__(self):
return self.title
class Job(models.Model):
user = models.ForeignKey(User)
company = models.ForeignKey(Company)
tags = TaggableManager()
title = models.CharField(max_length=255)
description = MarkdownField()
location = models.CharField(max_length=255)
application_url = models.URLField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __str__(self):
return self.title
class Company(models.Model):
class Meta:
verbose_name_plural = "companies"
user = models.ForeignKey(User, related_name="companies")
name = models.CharField(max_length=255)
profile = MarkdownField()
homepage = models.URLField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __unicode__(self):
return force_unicode(self.name)
class QaAnswer(models.Model):
"""Model class to contain every answer in the forum and to link it
to the proper question."""
question = models.ForeignKey(QaQuestion)
answer_text = MarkdownField()
pub_date = models.DateTimeField('date published', auto_now_add=True)
updated = models.DateTimeField('date updated', auto_now=True)
user = models.ForeignKey(settings.AUTH_USER_MODEL)
answer = models.BooleanField(default=False)
def __str__(self): # pragma: no cover
return self.answer_text
class Meta:
ordering = ['-answer', '-pub_date']
class AnswerComment(BaseComment):
"""模型类来包含答案的注释."""
comment_text = MarkdownField()
answer = models.ForeignKey(Answer, on_delete=models.CASCADE)
def save(self, *args, **kwargs):
try:
points = settings.QA_SETTINGS['reputation'][
'CREATE_ANSWER_COMMENT']
except KeyError:
points = 0
self.user.userqaprofile.modify_reputation(points)
super(AnswerComment, self).save(*args, **kwargs)
class Post(models.Model):
author = models.ForeignKey('auth.User')
title = models.CharField(max_length=200)
text = MarkdownField()
created_date = models.DateTimeField(default=timezone.now)
published_date = models.DateTimeField(blank=True, null=True)
def publish(self):
self.published_date = timezone.now()
self.save()
def __str__(self):
return self.title
def approved_comments(self):
return self.comments.filter(approved_comment=True)
class Events(models.Model):
title = models.CharField(max_length=200)
organizer = models.ForeignKey(Club)
details = MarkdownField()
start = models.DateTimeField()
end = models.DateTimeField()
phone_regex = RegexValidator(
regex=r'^\+?1?\d{9,15}$',
message=
"Phone number must be entered in the format: '+999999999'. Up to 15 digits allowed."
)
contact = models.CharField(max_length=15,
validators=[phone_regex],
blank=True)
def __str__(self):
return self.title
class Article(models.Model):
title = models.CharField(max_length=200)
body = MarkdownField()
slug = models.SlugField(max_length=200, unique=True)
publish = models.BooleanField(default=True)
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
objects = ArticleQueryset.as_manager()
tag = models.ManyToManyField(Tag)
def __unicode__(self):
return self.title
class Meta:
verbose_name = "文章"
verbose_name_plural = "文章"
ordering = ['-created']
class Event(TimeStampedUUIDModel):
""" Model to capture all details about the event.
"""
name = models.CharField(blank=False, null=False, max_length=100, verbose_name=_("name"),)
description = MarkdownField(blank=False, null=False, verbose_name=_("description"))
start_date = models.DateTimeField(blank=False, verbose_name=_("start date"))
end_date = models.DateTimeField(blank=True, verbose_name=_("end date"))
homepage = models.URLField(blank=True, verbose_name=_("homepage"))
is_published = models.BooleanField(blank=False, null=False, default=False, verbose_name=_("is published"))
auth_token = models.CharField(blank=True, null=False, max_length=50)
owner_email = models.EmailField(
blank=False, null=False, max_length=256, verbose_name=_("owner's email address"),
help_text=_("An email with the edit link for this event would be sent to this address. \
Please provide a vaild address here."))
class Meta:
verbose_name = _("event")
verbose_name_plural = _("events")
ordering = ('-start_date', )
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse('event-detail', kwargs={'slug': self.slug, 'pk': self.id.hex})
def get_edit_url(self):
return reverse('event-update', kwargs={'slug': self.slug, 'pk': self.id.hex, 'token': self.auth_token})
@property
def slug(self):
return slugify(self.name)
# TODO: return date in localize timezone
def date(self):
return get_date_diff_display(self.start_date, self.end_date)
@cached_property
def description_html(self):
return markdown(self.description)
def save(self, *args, **kwargs):
if not self.auth_token:
self.auth_token = str(uuid.uuid4())
super(Event, self).save(*args, **kwargs)
class Entry(models.Model):
title = models.CharField(max_length=200)
body = MarkdownField()
slug = models.SlugField(max_length=200, unique=True)
publish = models.BooleanField(default=True)
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
objects = EntryQuerySet.as_manager()
def __str__(self):
return self.title
class Meta:
verbose_name = "Blog Entry"
verbose_name_plural = "Blog Entries"
ordering = ["-created"]
class Notice(models.Model):
"""
A notice can be pasted on many different notice boards, with an option of adding images
"""
title = models.CharField(max_length=50, blank=False)
body = models.TextField(help_text='Enter any message here')
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
image = models.ImageField(blank=True, help_text='add a screenshot or image, this is optional')
slug = models.SlugField(null=True, blank=True)
attachment = models.FileField(verbose_name="attachment", blank=True, null=True, help_text='add optional attachment', upload_to='media/%Y/%m/%d')
board = models.ForeignKey(Board, related_name="notices")
user = models.ForeignKey('auth.User', null=True, related_name='notices')
body = MarkdownField()
def __str__(self):
return self.title
class Post(models.Model):
'''Post model'''
author = models.ForeignKey('auth.User', on_delete=models.CASCADE)
title = models.CharField(max_length=200)
text = MarkdownField()
created_date = models.DateTimeField(default=timezone.now)
published_date = models.DateTimeField(blank=True, null=True)
def publish(self):
self.published_date = timezone.now()
self.save()
def save(self, *args, **kwargs):
self.text = markdown.markdown(self.text)
def __str__(self):
return self.title
class Grant(AsylumModel):
owner = models.ForeignKey('members.Member',
blank=False,
verbose_name=_("Member"),
related_name='access_granted')
atype = models.ForeignKey(AccessType,
related_name='+',
verbose_name=_("Access"))
notes = MarkdownField(verbose_name=_("Notes"), blank=True)
def __str__(self):
return _("%s for %s") % (self.atype, self.owner)
class Meta:
verbose_name = _('Grant')
verbose_name_plural = _('Grants')
unique_together = ('owner', 'atype')
class QAQuestion(models.Model, HitCountMixin, DateMixin):
"""Model class to contain every question in the forum"""
slug = models.SlugField(max_length=200)
title = models.CharField(max_length=200, blank=False)
description = MarkdownField()
pub_date = models.DateTimeField('date published', auto_now_add=True)
update_date = models.DateTimeField('date updated', null=True)
update_user = models.ForeignKey(settings.AUTH_USER_MODEL,
null=True,
on_delete=models.SET_NULL,
related_name="updated_question")
tags = TaggableManager()
user = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.SET_NULL,
null=True)
closed = models.BooleanField(default=False)
points = models.IntegerField(default=0)
popularity = models.FloatField(default=0)
def mod_points(self, points):
p = self.points + points
self.points = F('points') + points
order = math.log(max(abs(p), 1), 10)
sign = 1 if p > 0 else -1 if p < 0 else 0
seconds = epoch_seconds(self.pub_date) - 1134028003
self.popularity = round(sign * order + seconds / 45000, 7)
self.save()
self.refresh_from_db()
def has_accepted_answer(self):
return bool(self.qaanswer_set.filter(answer=True))
def save(self, *args, **kwargs):
if not self.pk:
self.slug = slugify(self.title)
self.user.profile.mod_rep(REPUTATION['CREATE_QUESTION'])
super(QAQuestion, self).save(*args, **kwargs)
def delete(self, *args, **kwargs):
self.user.profile.mod_rep(-REPUTATION['CREATE_QUESTION'])
super(QAQuestion, self).delete(*args, **kwargs)
def __str__(self):
return self.title
class MembershipApplication(MemberCommon):
received = models.DateField(auto_now_add=True)
tags = models.ManyToManyField(MembershipApplicationTag, related_name='+', verbose_name=_("Application tags"), blank=True)
notes = MarkdownField(verbose_name=_("Notes"), blank=True)
@call_saves('MEMBERAPPLICATION_CALLBACKS_HANDLER')
def save(self, *args, **kwargs):
return super().save(*args, **kwargs)
def validate_unique(self, exclude=None):
if exclude and 'email' in exclude:
return super().validate_unique(exclude)
if Member.objects.filter(email=self.email).count():
# TODO: Figure out the exact format the default form validators use and use that ?
raise ValidationError({'email': ValidationError(_('Member with this email already exists'), code='unique')})
return super().validate_unique(exclude)
def approve(self, set_mtypes):
h = get_handler_instance('MEMBERAPPLICATION_CALLBACKS_HANDLER')
with transaction.atomic(), revisions.create_revision():
m = Member()
m.fname = self.fname
m.lname = self.lname
m.city = self.city
m.email = self.email
m.phone = self.phone
m.nick = self.nick
if h:
h.on_approving(self, m)
m.save()
if set_mtypes:
m.mtypes = set_mtypes
m.save()
if self.notes:
n = MemberNote()
n.notes = self.notes
n.member = m
n.save()
if h:
h.on_approved(self, m)
self.delete()
class Meta:
verbose_name = _('Membership Application')
verbose_name_plural = _('Membership Applications')
class BlogTraduit(BaseModel):
blog = models.ForeignKey(Blog,
default=None,
null=True,
blank=True,
on_delete=models.CASCADE)
locale = models.CharField(
default=None,
null=True,
blank=True,
max_length=2,
help_text=_("Blog's locale (en, fr, ...)"),
verbose_name=_("Blog's locale"),
)
title = models.CharField(
default=None,
null=True,
blank=True,
max_length=200,
help_text=_("Blog's title"),
verbose_name=_('Title'),
)
content = MarkdownField(
default=None,
null=True,
blank=True,
help_text=_("Blog's content"),
verbose_name=_('Content'),
)
def description(self):
a = '{} / {} - {}'.format(
self.locale if self.locale else _('no locale'),
self.title if self.locale else _('no title'),
self.content if self.content else _('no content yet'),
)
return (a[:95] + '...') if len(a) > 90 else a
def __str__(self):
return self.description().strip()
class Meta(BaseModel.Meta):
ordering = ['date_v_debut']
verbose_name = _('Blog-translated content')
verbose_name_plural = _('Blogs-translated')
class UserProfile(models.Model):
user = models.OneToOneField(User)
profile_picture = models.ForeignKey(Picture, null=True, blank=True)
birthdate = models.DateField(null=True, blank=True)
bio = MarkdownField(null=True, blank=True)
gender = models.CharField(max_length=6,
null=True,
blank=True,
choices=(("Male", "Male"), ("Female", "Female")))
spoken_languages = models.CharField(max_length=150, null=True, blank=True)
hometown = models.CharField(max_length=40, null=True, blank=True)
home_country = models.CharField(max_length=25, null=True, blank=True)
home_state = models.CharField(max_length=30, null=True, blank=True)
current_town = models.CharField(max_length=40, null=True, blank=True)
current_country = models.CharField(max_length=25, null=True, blank=True)
current_state = models.CharField(max_length=30, null=True, blank=True)
friends = models.ManyToManyField(User, blank=True, related_name='friends')
subscriptions = models.ManyToManyField(User,
blank=True,
related_name='subscriptions')
invites = models.ManyToManyField(Invite,
blank=True,
related_name='invites')
event_invites = models.ManyToManyField(EventInvite,
blank=True,
related_name='event_invites')
albums = models.ManyToManyField(Album, blank=True)
events = models.ManyToManyField(Event, blank=True)
relationship_status = models.ForeignKey(Relationship,
null=True,
blank=True)
schools = models.ManyToManyField(School,
through=SchoolMembership,
blank=True)
employers = models.ManyToManyField(Employer,
through=EmployerMembership,
blank=True)
messages = models.ManyToManyField(Message, blank=True)
comments = models.ManyToManyField(Comment, blank=True)
groups = models.ManyToManyField(Group, blank=True)
site_language = models.ForeignKey(Language, null=True, blank=True)
url = models.CharField(max_length=20, unique=True)
def __unicode__(self):
return "%s %s" % (self.user.first_name, self.user.last_name)
class StudentReview(models.Model):
student = models.ForeignKey(Student, on_delete=models.CASCADE)
evaluator = models.ForeignKey(Instructor, on_delete=models.CASCADE)
session = models.ForeignKey(ReviewSession)
date = models.DateTimeField()
notes = MarkdownField()
def get_module(self):
return self.session.module
get_module.short_description = 'Module'
@property
def comments(self):
return 'Test'
def __str__(self):
return '%s by %s' % (str(self.session), self.evaluator)
class Job(models.Model):
user = models.ForeignKey(User)
company = models.ForeignKey(Company)
is_approved = models.BooleanField(default=False)
is_sponsored = models.BooleanField(default=False)
tags = TaggableManager()
title = models.CharField(max_length=255)
description = MarkdownField()
location = models.CharField(max_length=255)
application_url = models.URLField(blank=True, null=True)
application_email = models.EmailField(blank=True, null=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def __str__(self):
return "{} - {}".format(self.company.name, self.title)
class Todo(models.Model):
class Meta:
ordering = ('-created_at', )
title = models.CharField(max_length=200)
text = MarkdownField()
created_at = models.DateTimeField(auto_now_add=True, blank=True)
tags = TaggableManager(blank=True)
user = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.PROTECT)
objects = TodoQuerySet.as_manager()
def __str__(self):
return self.title
def get_absolute_url(self):
return reverse('todos:detail', kwargs={'pk': self.pk})
class UserProfileModel(models.Model):
user = models.OneToOneField(User)
user_description = MarkdownField()
skills = TaggableManager()
user_type_select = models.CharField(max_length=50, default='None')
programme = models.CharField(max_length=15)
branch = models.CharField(max_length=100)
college_year = models.CharField(max_length=10)
graduation_year = models.CharField(max_length=4)
user_profile_pic = models.FileField(
upload_to='profile_pics/',
blank=True,
default='profile_pics/avatars/default.png')
created = models.DateTimeField(auto_now_add=True)
modified = models.DateTimeField(auto_now=True)
def __str__(self):
return self.user.username
