class Bid(TimeStampedModel):
bidder = models.ForeignKey(Student, on_delete=models.CASCADE)
listing = models.ForeignKey(Listing, on_delete=models.CASCADE)
price = models.PositiveIntegerField(
default=0,
validators=[MaxValueValidator(1000)],
)
text = models.CharField(
blank=True,
max_length=2000,
)
slug = RandomSlugField(length=6)
def too_many_flags(self):
if BidFlag.objects.filter(bid=self).count() > 0:
return True
else:
return False
def __unicode__(self):
return '%s\'s bid for $%s' % (self.bidder, str(self.price))
class Meta:
ordering = ['-created']
class Shortener(models.Model):
slug = RandomSlugField(length=5)
link_to = models.URLField()
created = models.DateTimeField(auto_now_add=True)
def __str__(self):
return f"{self.slug} -> {self.link_to}"
class Flag(TimeStampedModel):
WRONG_PRODUCT_TYPE = 'Not a Textbook'
# may eventually change as additional product categories are added
OBSCENE = 'Obscene'
SPAM = 'Spam'
COPYRIGHT = 'Copyright Violation'
ILLEGAL = 'Otherwise Problematic'
FLAGGING_REASON_CHOICES = (
(WRONG_PRODUCT_TYPE, 'Not a Textbook'),
(OBSCENE, 'Obscene'),
(SPAM, 'Spam'),
(COPYRIGHT, 'Copyright Violation'),
(ILLEGAL, 'Otherwise Problematic'),
)
flagger = models.ForeignKey(Student, on_delete=models.CASCADE)
listing = models.ForeignKey(Listing, on_delete=models.CASCADE)
reason = models.CharField(
choices=FLAGGING_REASON_CHOICES,
max_length=30,
)
slug = RandomSlugField(length=6)
def __unicode__(self):
return "%s's %s for %s" % (self.flagger.user.username,
self.listing.title, self.reason)
class Meta:
ordering = ['listing', 'created']
class BidFlag(TimeStampedModel):
OBSCENE = 'Obscene'
SPAM = 'Spam'
ILLEGAL = 'Otherwise Problematic'
FLAGGING_REASON_CHOICES = (
(OBSCENE, 'Obscene'),
(SPAM, 'Spam'),
(ILLEGAL, 'Otherwise Problematic'),
)
flagger = models.ForeignKey(Student, on_delete=models.CASCADE)
bid = models.ForeignKey(Bid, on_delete=models.CASCADE)
reason = models.CharField(
choices=FLAGGING_REASON_CHOICES,
max_length=30,
)
slug = RandomSlugField(length=6)
def __unicode__(self):
return "%s's %s for %s" % (self.flagger.user.username,
self.bid.listing.title, self.reason)
class Meta:
ordering = ['bid', 'created']
class Task(caching.base.CachingMixin, models.Model):
"""
Tasks used in the Dashboard.
"""
slug = RandomSlugField(length=settings.RANDOMSLUG_LENGTH,
null=True,
blank=True)
title = models.CharField(max_length=500)
description = models.TextField(null=True, blank=True)
complete = models.BooleanField(default=False)
created_on = models.DateTimeField(auto_now=True)
created_by = models.ForeignKey(User, related_name='task_created_by')
due_on = models.DateTimeField(blank=True, null=True)
assigned_to = models.ForeignKey(User,
blank=True,
null=True,
related_name='task_assigned_to')
video = models.ForeignKey(Video, blank=True, null=True)
status = models.IntegerField(verbose_name='Status',
default=1,
choices=STATUS_CODES)
priority = models.IntegerField(verbose_name='Priority',
default=2,
choices=PRIORITY_CODES)
class Meta:
ordering = ['priority', 'title']
def get_absolute_url(self):
return reverse('tasks-detail', kwargs={'slug': self.slug})
def __unicode__(self):
return self.title
class Lookout(TimeStampedModel):
owner = models.ForeignKey(Student)
isbn = models.CharField(max_length=20,
validators=[
RegexValidator(
'[0-9xX-]{10,20}',
message='Please enter a valid ISBN.')
])
# would have to load in every conceivable course first
# course = models.ForeignKey(Course)
slug = RandomSlugField(length=6)
def get_listings(self):
isbn_listings = models.Q(isbn=self.isbn,
exchanged=False,
cancelled=False)
return Listing.objects.filter(isbn_listings)
def get_absolute_url(self):
return reverse('detail_lookout', kwargs={'slug': self.slug})
def __unicode__(self):
return '%s %s' % (self.owner.user.username, self.isbn)
class Meta:
ordering = ['isbn']
# a student can't create the same lookout twice
unique_together = ['owner', 'isbn']
class LandingPage(models.Model):
"""
Landing Page Model.
"""
ulid = RandomSlugField(length=7, unique=True, primary_key=True)
account = models.ForeignKey(Account,
on_delete=models.CASCADE,
to_field='uaid')
created_by = models.ForeignKey(settings.AUTH_USER_MODEL,
to_field='uuid',
related_name='lp_created_by',
on_delete=models.CASCADE)
title = models.CharField(_('Title'), max_length=255)
slug = models.SlugField()
description = models.TextField(_('Description'), blank=True, null=True)
created_on = models.DateTimeField(_("Created On"), auto_now_add=True)
brand_name = models.CharField(_('Brand Name'),
max_length=255,
default='XYZ Company')
form = models.ForeignKey(Form,
on_delete=models.CASCADE,
to_field='ufid',
related_name='lp_form')
thank_you_message = models.TextField(
default=
"Your Response Has Been Recorded, Thank You For Submitting the Form!")
class Meta:
verbose_name = _('Landing Page')
verbose_name_plural = _('Landing Pages')
def __str__(self):
return self.title
class Entry(models.Model):
created_at = models.DateTimeField(auto_now_add=True, db_index=True)
updated_at = models.DateTimeField(auto_now=True, db_index=True)
user = models.ForeignKey('auth.User', related_name='entries')
# 62 possible chars ^ 5 length = 916,132,832 possible slugs
slug = RandomSlugField(length=5)
tags = TaggableManager(blank=True, through=TaggedEntry)
text = models.TextField(blank=True)
class Job(models.Model):
post_date = models.DateTimeField(verbose_name="Posted on",
auto_now_add=True)
deadline = models.DateTimeField(verbose_name="Deadline")
title = models.TextField(verbose_name="Job Title")
description = models.TextField(verbose_name="Job Description")
employer = models.ForeignKey(User,
verbose_name="Employer",
on_delete=models.CASCADE)
slug = RandomSlugField(length=7)
manually_closed = models.BooleanField(verbose_name="Manually Closed",
default=False)
objects = models.Manager()
manager = JobManager()
def __str__(self):
return self.title
@property
def has_user_applied(self, user):
"""
:param user: a User object
:return: whether the given user has applied to the form
"""
user_ids = []
for application in self.applications.filter(draft=False):
user_ids.append(application.author.id)
if user.id in user_ids:
return True
else:
return False
def get_submitted_application(self):
return self.applications.filter()
def get_timesince_post(self):
return timesince.timesince(self.post_date)
def format_deadline(self):
return self.deadline.strftime("%d %B %Y, %H:%M %p")
def get_time_until_deadline(self):
return timesince.timeuntil(self.deadline).split(",")[0]
def is_closed(self):
if self.deadline < timezone.now() or self.manually_closed:
return True
else:
return False
@property
def is_timed_out(self):
if self.deadline < timezone.now():
return True
else:
return False
class Form(models.Model):
ufid = RandomSlugField(length=7, unique=True, primary_key=True)
account = models.ForeignKey(Account,
on_delete=models.CASCADE,
to_field='uaid')
created_by = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
to_field='uuid')
title = models.CharField(max_length=100)
description = models.TextField(blank=True, null=True)
created_on = models.DateTimeField(default=timezone.now)
title_enabled = models.BooleanField(default=False)
title_required = models.BooleanField(default=False)
fname_enabled = models.BooleanField(default=True)
fname_required = models.BooleanField(default=False)
lname_enabled = models.BooleanField(default=True)
lname_required = models.BooleanField(default=False)
email_enabled = models.BooleanField(default=True)
email_required = models.BooleanField(default=True)
company_enabled = models.BooleanField(default=False)
company_required = models.BooleanField(default=False)
website_enabled = models.BooleanField(default=False)
website_required = models.BooleanField(default=False)
phone_enabled = models.BooleanField(default=False)
phone_required = models.BooleanField(default=False)
address_line_enabled = models.BooleanField(default=False)
address_line_required = models.BooleanField(default=False)
street_enabled = models.BooleanField(default=False)
street_required = models.BooleanField(default=False)
city_enabled = models.BooleanField(default=False)
city_required = models.BooleanField(default=False)
state_enabled = models.BooleanField(default=False)
state_required = models.BooleanField(default=False)
postcode_enabled = models.BooleanField(default=False)
postcode_required = models.BooleanField(default=False)
country_enabled = models.BooleanField(default=False)
country_required = models.BooleanField(default=False)
class Meta:
verbose_name = _('Form')
verbose_name_plural = _('Forms')
def __str__(self):
return self.title
class Project(models.Model):
name = models.CharField(max_length=200, db_index=True)
key = RandomSlugField(length=6, exclude_upper=True)
slug = AutoSlugField(populate_from=["name", "key"], unique=True)
event = models.CharField(max_length=200, default="")
email_sent = models.BooleanField(default=False)
created = models.DateTimeField(auto_now_add=True)
started = models.DateTimeField(blank=True, null=True, editable=False)
ended = models.DateTimeField(blank=True, null=True, editable=False)
idea = models.TextField(blank=True)
tools = models.TextField(blank=True)
validate_customer = models.TextField(blank=True)
validate_offering = models.TextField(blank=True)
validate_value_prop = models.TextField(blank=True)
@property
def has_mvp(self):
try:
return self.mvp is not None
except Mvp.DoesNotExist:
return False
def __unicode__(self):
return self.name
def is_frozen(self):
return datetime.datetime.now() > self.ended
def is_workstream_frozen(self):
return self.has_mvp and self.mvp.workstream_set
def send_created_email(self, project_url):
if self.email_sent:
logger.debug(
"Project %s has already sent an email, so another one will not be sent.",
self.slug)
return
else:
message_template = Template("""
You are a member of the project '${name}', newly created at pinch.tn! You can get back to this project using
the link ${project_url}
""")
message = message_template.substitute(name=self.name,
project_url=project_url)
recipients = [
member.email for member in self.members.all()
if member.email and email_regex.match(member.email)
]
send_mail("You are now pinching '%s'!" % self.name,
message,
"*****@*****.**",
recipients,
fail_silently=False)
self.email_sent = True
self.save()
class Video(models.Model):
slug = RandomSlugField(length=8)
file = models.FileField("Video file", upload_to=get_file_path("inputs"))
email = models.EmailField(null=True)
def get_absolute_url(self):
return reverse('analysis', args=[str(self.slug)])
def __str__(self):
return self.slug.__str__()
class Urls(models.Model):
def __str__(self):
return self.redirect
slug = RandomSlugField(length=6)
redirect = models.URLField(max_length=255, unique=False)
owner = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
null=True,
default=None)
hits = models.IntegerField(default=0)
class PrivateSession(caching.base.CachingMixin, models.Model):
'''
A Private FBZ conversation.
'''
slug = RandomSlugField(length=settings.RANDOMSLUG_LENGTH)
owner = models.ForeignKey(User)
video = models.ForeignKey(Video)
is_synchronized = models.BooleanField(default=False)
class Meta:
verbose_name = 'Private Session'
verbose_name_plural = 'Private Sessions'
class Contact(models.Model):
"""
Contact Model.
"""
ucid = RandomSlugField(length=10, unique=True, primary_key=True)
account = models.ForeignKey(Account, on_delete=models.CASCADE, to_field='uaid')
form = models.ForeignKey(Form, on_delete=models.CASCADE, to_field='ufid', blank=True, null=True)
landing_page = models.ForeignKey(LandingPage, on_delete=models.CASCADE, to_field='ulid', blank=True, null=True)
created_by = models.ForeignKey(settings.AUTH_USER_MODEL, to_field='uuid', related_name='created_by',
on_delete=models.CASCADE, blank=True, null=True)
source = models.CharField(max_length=255, blank=True, null=True)
title = models.CharField(_('Title'), max_length=3, choices=TITLE, blank=True, null=True)
first_name = models.CharField(_("First name"), max_length=255, default=" ", blank=True)
last_name = models.CharField(_("Last name"), max_length=255, default=" ", blank=True)
email = models.EmailField(blank=True, null=True)
company = models.CharField(max_length=255, blank=True, null=True)
website_url = models.URLField(blank=True, null=True)
phone = models.CharField(max_length=20, blank=True, null=True)
address = models.ForeignKey(Address, related_name='address', on_delete=models.CASCADE, blank=True,
null=True)
status = models.CharField(_('Status'), max_length=50, choices=LIFECYCLE_STATUS, default='lead', blank=True,
null=True)
stage = models.CharField(_('Stage'), max_length=50, choices=STAGES, default='lead', blank=True,
null=True)
description = models.TextField(blank=True, null=True)
created_on = models.DateTimeField(_("Created on"), auto_now_add=True)
is_active = models.BooleanField(default=True)
class Meta:
verbose_name = _('Contact')
verbose_name_plural = _('Contacts')
@property
def get_full_name(self):
"""
Full Name
:return: Returns the first_name plus the last_name, with space in between.
"""
full_name = "%s %s" % (self.first_name, self.last_name)
return full_name.strip()
@property
def get_short_name(self):
"""
Short Name
:return: Returns the first_name.
"""
short_name = "%s" % self.first_name
return short_name.strip()
def __str__(self):
return str(self.get_full_name)
class Email(models.Model):
umid = RandomSlugField(length=9, unique=True, primary_key=True)
campaign = models.ForeignKey(EmailCampaign, on_delete=models.CASCADE, to_field='cmid', blank=True, null=True)
account = models.ForeignKey(Account, on_delete=models.CASCADE, to_field='uaid')
to_email = models.EmailField(max_length=200)
from_email = models.EmailField(max_length=200, default='*****@*****.**')
subject = models.CharField(max_length=255, blank=True, null=True)
message = models.TextField(blank=True, null=True)
timestamp = models.DateTimeField(auto_now_add=True)
status = models.CharField(max_length=200, default='SENT')
class Meta:
verbose_name = _('Email')
verbose_name_plural = _('Emails')
def save(self, *args, **kwargs):
email = EmailMessage(
self.subject,
self.message,
self.from_email,
[self.to_email],
)
email.content_subtype = "html"
email.send(fail_silently=True)
super().save(*args, **kwargs)
def send_email_campaign(sender, instance, created, **kwargs):
if created:
for contact in instance.list.assigned_contacts.all():
try:
Email.objects.create(
campaign=instance,
account=instance.account,
to_email=contact.email,
subject=instance.subject,
message=instance.message_template
)
except:
logger.error('Mail Send Error: ', exc_info=True)
finally:
pass
post_save.connect(send_email_campaign, sender=EmailCampaign)
def create(self):
self.save()
def __str__(self):
return self.to_email
class PizzaOrder(models.Model):
slug = RandomSlugField(length=8)
orderer_name = models.TextField()
orderer_phone_number = models.IntegerField()
orderer_address = models.TextField()
pizza = models.TextField()
drink = models.TextField()
pizzeria = models.TextField()
method_of_payment = models.CharField(max_length=10)
date_of_delivery = models.DateTimeField()
date_time_of_order = models.DateTimeField(auto_now=True)
status = models.CharField(max_length=50)
def __str__(self):
return self.slug
class EmailCampaign(models.Model):
cmid = RandomSlugField(length=9, unique=True, primary_key=True)
created_by = models.ForeignKey(settings.AUTH_USER_MODEL, to_field='uuid', on_delete=models.CASCADE, blank=True,
null=True)
account = models.ForeignKey(Account, on_delete=models.CASCADE, to_field='uaid')
list = models.ForeignKey(List, on_delete=models.CASCADE, to_field='ugid', blank=True, null=True)
campaign_title = models.CharField(max_length=255, blank=True, null=True)
subject = models.CharField(max_length=255, blank=True, null=True)
message_template = models.TextField(blank=True, null=True)
timestamp = models.DateTimeField(auto_now_add=True)
class Meta:
verbose_name = _('Campaign')
verbose_name_plural = _('Campaigns')
def __str__(self):
return self.campaign_title
class Account(models.Model):
uaid = RandomSlugField(length=7, unique=True, primary_key=True)
owner = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, to_field='uuid')
name = models.CharField(max_length=100)
domain = models.URLField(unique=True, blank=True, null=True)
created_on = models.DateTimeField(default=timezone.now)
objects = managers.AccountManager()
class Meta:
verbose_name = _('account')
verbose_name_plural = _('accounts')
def get_absolute_url(self):
return "/api/account/%s/" % urlquote(self.uaid)
def __str__(self):
return self.name
class Lookout(TimeStampedModel):
owner = models.ForeignKey(Student, on_delete=models.CASCADE)
isbn = models.CharField(max_length=20,
validators=[
RegexValidator(
'[0-9xX-]{10,20}',
message='Please enter a valid ISBN.')
])
title = models.CharField(max_length=200, null=True, blank=True)
author = models.CharField(max_length=200, null=True, blank=True)
# would have to load in every conceivable course first
# course = models.ForeignKey(Course)
slug = RandomSlugField(length=6)
def get_listings(self):
isbn_listings = models.Q(isbn=self.isbn,
exchanged=False,
cancelled=False)
return Listing.objects.filter(isbn_listings)
def get_title_or_isbn(self):
if self.title:
return self.title
else:
return self.isbn
def get_absolute_url(self):
return reverse('detail_lookout', kwargs={'slug': self.slug})
def save(self, *args, **kwargs):
if not (self.title and self.author): # only run when initially created
isbn_metadata = ISBNMetadata(self.isbn)
self.title = isbn_metadata.get('title')
self.author = isbn_metadata.get('authors')
super().save(*args, **kwargs)
def __unicode__(self):
return '%s %s' % (self.owner.user.username, self.isbn)
class Meta:
ordering = ['isbn']
# a student can't create the same lookout twice
unique_together = ['owner', 'isbn']
class MedicineManufacturer(models.Model):
medicine_manufacturer_slug = RandomSlugField(length=4)
medicine_manufacturer_name = models.CharField(max_length=100)
medicine_manufacturer_contact_no = models.BigIntegerField(
verbose_name='Contact')
medicine_manufacturer_contact_no_optional = models.BigIntegerField(
'Optional Contact', null=True, blank=True)
medicine_manufacturer_address = models.CharField(max_length=200)
class Meta:
verbose_name = 'Medical Manufacturer'
def __str__(self):
return 'ManufacturerName: ' + self.medicine_manufacturer_name + ' | ' + 'ManufacturerAddress: ' + str(
self.medicine_manufacturer_address) + ' | ' + 'ManufacturerContact: ' + \
str(self.medicine_manufacturer_contact_no) + ' | ' + 'MedicineManufacturerSlug: ' + \
str(self.medicine_manufacturer_slug)
class Order(models.Model):
order_id = RandomSlugField(length=10)
medical_shop = models.ForeignKey(MedicalShop, on_delete=models.CASCADE)
order_amount = models.FloatField()
order_list = models.ManyToManyField(Medicine,
verbose_name="list of medicines",
blank=True)
bill_no = models.IntegerField(null=True, blank=True)
order_date = models.DateTimeField(auto_now_add=True)
def save(self, *args, **kwargs):
self.order_amount = round(self.order_amount, 2)
super(Order, self).save(*args, **kwargs)
class Meta:
verbose_name = 'Order'
def __str__(self):
return 'OrderShop: ' + self.medical_shop.shop_name + ' | ' + 'OrderAmount: ' +str(self.order_amount) + ' | ' + \
'OrderDateTime: ' + str(self.order_date)
class List(models.Model):
ugid = RandomSlugField(length=7, unique=True, primary_key=True)
account = models.ForeignKey(Account,
on_delete=models.CASCADE,
to_field='uaid')
created_by = models.ForeignKey(settings.AUTH_USER_MODEL,
on_delete=models.CASCADE,
to_field='uuid')
title = models.CharField(max_length=100)
description = models.TextField(blank=True, null=True)
created_on = models.DateTimeField(default=timezone.now)
assigned_contacts = models.ManyToManyField(
Contact, related_name='assigned_contacts_list', blank=True)
class Meta:
verbose_name = _('List')
verbose_name_plural = _('Lists')
def __str__(self):
return self.title
class CustomData(models.Model):
IDFLD_TYPE = (('coid', 'Contact ID'), ('doid', 'Domain ID'))
namespace = RandomSlugField(length=6,
exclude_vowels=True,
primary_key=True)
system_id_field = models.CharField(max_length=4, choices=IDFLD_TYPE)
identity_column_name = models.CharField(max_length=255)
headers = JSONField()
data = JSONField()
data_table = JSONField()
last_modified = models.DateTimeField(auto_now=True)
created = models.DateTimeField(auto_now_add=True)
created_by = models.ForeignKey('core.KITUser', on_delete=models.PROTECT)
def __str__(self):
return "{}".format(self.namespace)
def get_absolute_url(self):
return reverse('core:custom-data-ajax', args=[self.pk])
class Application(models.Model):
EMPLOYER_STATUS_CHOICES = [
("applied", "applied"),
("interview", "interview"),
("rejected", "rejected"),
]
cv = S3UploadField(dest="cv", null=True)
cover_letter = models.TextField(verbose_name="Cover Letter", null=True)
author = models.ForeignKey(User,
verbose_name="Author",
on_delete=models.CASCADE)
date = models.DateTimeField()
job = models.ForeignKey(Job,
verbose_name="Job",
on_delete=models.CASCADE,
related_name="applications")
employer_status = models.CharField(
max_length=20,
verbose_name="Application Status (for employer)",
default="applied",
choices=EMPLOYER_STATUS_CHOICES,
)
draft = models.BooleanField(default=False, verbose_name="Draft")
slug = RandomSlugField(length=7)
def get_timesince_applied(self):
return timesince.timesince(self.date)
def get_employer_id(self):
return self.job.employer.id
def format_date(self):
return self.date.strftime("%d %B %Y, %H:%M %p")
def __str__(self):
return (self.author.first_name + " " + self.author.last_name + ": " +
self.job.title)
class Medicine(models.Model):
medicine_slug = RandomSlugField(length=8)
medicine_name = models.CharField(max_length=100)
medicine_manufacturer = models.ForeignKey(MedicineManufacturer,
on_delete=models.CASCADE,
null=True,
blank=True)
medicine_expiry_date = models.DateField()
medicine_price = models.FloatField()
def save(self, *args, **kwargs):
self.medicine_price = round(self.medicine_price, 2)
super(Medicine, self).save(*args, **kwargs)
class Meta:
verbose_name = 'Medicine'
def __str__(self):
return 'MedicineName: ' + str(
self.medicine_name) + ' | ' + 'MedicineManufacturer: ' + str(
self.medicine_manufacturer.medicine_manufacturer_name
) + ' | ' + 'MedicinePrice: ' + str(
self.medicine_price) + ' | ' + 'MedicineSlug: ' + str(
self.medicine_slug)
class MedicalShop(models.Model):
shop_slug = RandomSlugField(length=6)
user_id = models.ForeignKey(User, default=0, on_delete=models.CASCADE)
shop_name = models.CharField(max_length=100, default='')
shop_owner_first_name = models.CharField(max_length=50)
shop_owner_last_name = models.CharField(max_length=50,
null=True,
blank=True)
shop_address = models.CharField(max_length=200)
shop_lat_lng = models.CharField(max_length=100)
shop_pin_code = models.IntegerField()
shop_contact_no = models.BigIntegerField()
shop_contact_no_optional = models.BigIntegerField(null=True, blank=True)
shop_email = models.EmailField(null=True, blank=True)
# shop_password = models.CharField(max_length=50)
shop_added_date = models.DateTimeField(editable=True, auto_now_add=True)
shop_last_modified_date = models.DateTimeField(auto_now_add=False)
class Meta:
verbose_name = 'Medical Shop'
def __str__(self):
return 'ShopName: ' + self.shop_name + ' | ' + 'ShopAddress: ' +str(self.shop_address) + ' | ' + \
'ShopContact: ' + str(self.shop_contact_no) + ' | ' + 'MedicalShopSlug: ' + str(self.shop_slug)
class Rating(TimeStampedModel):
ONE_STAR = '1'
TWO_STAR = '2'
THREE_STAR = '3'
FOUR_STAR = '4'
FIVE_STAR = '5'
STAR_CHOICES = (
(ONE_STAR, '1'),
(TWO_STAR, '2'),
(THREE_STAR, '3'),
(FOUR_STAR, '4'),
(FIVE_STAR, '5'),
)
rater = models.ForeignKey(Student, on_delete=models.CASCADE)
listing = models.ForeignKey(Listing, on_delete=models.CASCADE)
stars = models.CharField(
choices=STAR_CHOICES,
max_length=10,
)
review = models.TextField(
blank=True,
max_length=3000,
)
slug = RandomSlugField(length=6)
def __unicode__(self):
return "%s's review of %s" % (self.rater.user.username,
self.listing.poster.user.username)
class Meta:
ordering = ['rater', 'listing', 'created']
class KITActivationCode(models.Model):
user = models.OneToOneField(User)
email_activation_code = RandomSlugField(length=28, db_index=True)
phone_activation_code = models.CharField(max_length=5,
default=get_random_integers,
editable=False,
db_index=True)
expired = models.BooleanField(default=False)
last_modified = models.DateTimeField(auto_now=True)
created = models.DateTimeField(auto_now_add=True)
def __str__(self):
return "{}".format(self.user)
def can_resend_for_code(self):
# user can resend for code only if 10 minutes have passed since the code was created
# or the code has expired.
if arrow.get(self.created).replace(minutes=+10) < arrow.utcnow():
return True
else:
return False
class Issue(models.Model):
circle = models.ForeignKey(Circle)
request_date = models.DateTimeField()
request_html = models.CharField(max_length=100000, null=True, blank=True)
request_text = models.CharField(max_length=100000, null=True, blank=True)
digest_date = models.DateTimeField()
digest_html = models.CharField(max_length=100000, null=True, blank=True)
digest_text = models.CharField(max_length=100000, null=True, blank=True)
slug = RandomSlugField(length=10, max_length=10)
created = models.DateTimeField(auto_now_add=True)
published = models.DateTimeField(null=True)
def status(self):
now = datetime.now()
if now < self.request_date:
return 'PENDING'
elif self.request_date < now < self.digest_date:
return 'REQUESTING'
elif not self.published:
return 'READY'
else:
return 'PUBLISHED'
def request_inbox(self):
return self._inbox_email('call')
def update_inbox(self):
return self._inbox_email('update')
def digest_inbox(self):
return self._inbox_email('digest')
def _inbox_email(self, kind):
return '%s <*****@*****.**>' % (self.circle.name, kind,
self.slug)
def noreply_email(self):
return '%s <*****@*****.**>' % self.circle.name
def get_request_html(self):
m = re.match('.*<body>(.*)</body>.*', self.request_html or '')
return m and m.group(1) or self.request_html
def get_digest_html(self):
m = re.match('.*<body>(.*)</body>.*', self.digest_html or '')
return m and m.group(1) or self.digest_html
@staticmethod
def find(sender, recipient):
match = re.match('(call|digest)\+(.*)@go\.trustcircle\.xyz', recipient)
slug = match and match.group(2) or None
return Issue.objects.filter(circle__owner__email=sender,
slug=slug).last()
@staticmethod
def create(cirlce):
last_issue = cirlce.issue_set.last()
if last_issue:
now = last_issue.digest_date + timedelta(day=1)
else:
now = datetime.now()
last_day = calendar.monthrange(now.year, now.month)[1]
digest = datetime(now.year, now.month, last_day)
request = digest - timedelta(days=5)
return Issue.objects.create(circle=cirlce,
request_date=request,
digest_date=digest)
def __str__(self):
return u'%s | %s %s' % (self.circle.name,
calendar.month_name[self.digest_date.month],
self.digest_date.year)
