class Choice(models.Model):
name = fields.CharField(max_length=200)
key = fields.CharField(max_length=200, unique=True)
description = fields.TextField(default='', blank=True)
collection = models.ForeignKey(Collection, on_delete=models.CASCADE)
image_url = fields.URLField(blank=True, null=True)
def __str__(self):
return self.name
class Event(models.Model):
title = fields.CharField(max_length=100, verbose_name=_('Title and venue'))
description = fields.TextField(blank=True,
verbose_name=_('Long description'))
date = fields.DateTimeField(verbose_name=_('Date of the event'))
tickets_info = fields.URLField(blank=True,
verbose_name=_('Link to buy tickets'))
class Meta:
verbose_name = 'event'
verbose_name_plural = 'events'
class UserProfile(models.Model):
"""Model for github user data """
username = fields.CharField(max_length=512, unique=True)
image_url = fields.URLField(null=True, blank=True)
name = fields.CharField(null=True, max_length=127)
company = fields.CharField(null=True, max_length=127)
email = fields.CharField(null=True, max_length=127)
adding_date = fields.DateTimeField(auto_now_add=True)
class Meta:
verbose_name = "GitHub User"
def __unicode__(self):
return "{}".format(self.username)
class ArticlePage(Page):
standfirst = RichTextField(blank=True, max_length=350, help_text='To be displayed in the list view')
body = RichTextField(blank=True, help_text='Full body of the article')
external_ref = fields.URLField(verbose_name='Source URL', blank=True, null=True)
category = models.ForeignKey('ArticleCategory',
null=True,
blank=False,
on_delete=models.SET_NULL)
bg_image = models.ForeignKey('wagtailimages.Image',
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='+')
tags = TaggableManager()
content_panels = Page.content_panels + [
FieldPanel('body', classname="full"),
ImageChooserPanel('bg_image'),
FieldPanel('standfirst', classname="full"),
FieldPanel('external_ref'),
FieldPanel('category')
]
class LongUrl(Model):
url = fields.URLField()
shortcut = fields.CharField(max_length=50,
unique=True,
default=get_random_string)
class Store(Site):
url = fields.URLField(
verbose_name=_('Store Url'),
max_length=255,
null=False,
blank=False,
)
default_language = models.ForeignKey(
Language,
related_name='stores',
null=True,
blank=True,
)
default_currency = models.ForeignKey(
Currency,
related_name='stores',
null=True,
blank=True,
)
default_country = models.ForeignKey(
Country,
related_name='stores',
null=True,
blank=True,
)
is_default = fields.BooleanField(
verbose_name=_('Is Default'),
null=False,
blank=False,
default=False,
db_index=True,
)
is_active = fields.BooleanField(
verbose_name=_('Is Active'),
null=False,
blank=False,
default=True,
db_index=True,
)
language = models.ManyToManyField(
'Language',
related_name='languages',
db_table='billing_store_languages',
)
currency = models.ManyToManyField(
'Currency',
related_name='currencies',
db_table='billing_store_currencies',
)
records = models.Manager()
class Meta:
db_table = 'billing_store'
default_related_name = 'stores'
verbose_name = _('Store')
verbose_name_plural = _('Stores')
def __unicode__(self):
return '%(id)d: %(name)s (%(domain)s)' % {
'id': self.id,
'domain': self.domain,
'name': self.name,
}
class Cyclist(models.Model):
user = models.OneToOneField(User, on_delete=models.CASCADE, db_index=True)
legs = models.ManyToManyField(Leg, related_name='cyclist', blank=True)
targetAmount = fields.DecimalField(max_digits=7,
decimal_places=2,
default=Decimal(0),
blank=False)
currentPledgedAmount = fields.DecimalField(max_digits=7,
decimal_places=2,
default=Decimal(0),
blank=False)
fundraising_site = fields.URLField(default='', blank=True)
statement = fields.TextField(max_length=1200, default="", blank=True)
picture = models.ImageField(
upload_to=get_portrait_path, blank=True,
storage=HashedURLStorage()) # Use custom FileStorageSystem as above
def get_absolute_url(self):
"""Return the absolute URL - always the FundMe page"""
return reverse('FundMe', kwargs={'username': self.user.username})
def __repr__(self):
"""A nice representation of this cyclist"""
return "Cyclist(username={})".format(self.user.username)
def __str__(self):
return "Cyclist : {}".format(self.user.username)
def get_full_name(self):
"""The full name of the cyclist - derived from the User attribute"""
return self.user.get_full_name()
def total_distance(self):
""" Total Distance in km which this cyclist has signed up for"""
return "{:.1f}".format(sum(l.distanceKM for l in self.legs.all()))
def total_days(self):
""" Return the number of days that this cyclist is involved in"""
return self.legs.all().aggregate(
day_count=Count('date', distinct=True))['day_count']
def percentage_funding(self):
"""Return as a formatted string the % funding - current vs target"""
if not (self.currentPledgedAmount and self.targetAmount):
return 0
if self.targetAmount == 0:
return 0
return "{:.0f}".format(100.0 * int(self.currentPledgedAmount) /
int(self.targetAmount))
def fundraising_domain(self):
"""Return as a domain name of the users fundraising site"""
parsed_uri = urlparse(self.fundraising_site)
return parsed_uri.netloc
@classmethod
def total_funds(cls):
"""Calculate the funds across all cyclists"""
return cls.objects.aggregate(pledges=Sum('currentPledgedAmount'),
target=Sum('targetAmount'))