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)