class Kitten(models.Model):
image = AjaxImageField()
thumbnail = AjaxImageField(upload_to='thumbnails', max_height=200,
max_width=200, crop=False)
def __str__(self):
return str(self.thumbnail)
@property
def url(self):
return self.thumbnail.url
@property
def path(self):
return self.thumbnail.path
class Image(models.Model):
name = models.CharField(max_length=100)
gallery = models.ForeignKey(Gallery, on_delete=models.CASCADE)
file = AjaxImageField(upload_to='test/folder')
class Meta:
ordering = ('name', )
def __str__(self):
return self.name
class RecipeImage(models.Model):
""" Model of recipe image """
recipe = models.ForeignKey(Recipe, on_delete=models.CASCADE,
verbose_name=_('recipe'))
image = AjaxImageField(null=True, blank=True, upload_to='images',
max_width=1024, max_height=768, crop=True,
verbose_name=_('image'))
thumbnail = ImageSpecField(source='image',
processors=[ResizeToFill(400, 300)],
format='JPEG', options={'quality': 90})
title = models.CharField(max_length=250, blank=True,
verbose_name=_('title'))
def __str__(self):
return _('image') + '-' + str(self.id)
class Meta:
verbose_name = _('image')
verbose_name_plural = _('images')
def test_widget_render(self):
self.maxDiff = None
file_path = os.path.join(BASE_PATH, 'test.jpg')
file_url = MockStorage().url(file_path)
field = AjaxImageField(upload_to='test',
max_width=100,
max_height=200,
storage_path='tests.tests.MockStorage')
html = field.widget.render(name='test',
value=file_path,
attrs={'id': 1})
correct_html = AjaxImageWidget.html.format(
file_path=file_path,
file_url=file_url,
element_id=1,
name='test',
upload_url=
'/ajaximage/upload/test/100/200/0/tests.tests.MockStorage/',
)
self.assertHTMLEqual(html, correct_html)
class Sponsor(models.Model):
name = models.CharField(max_length=200)
slug = models.SlugField(
blank=True,
null=True,
help_text=
"Suggested value automatically generated from name. Must be unique.",
)
url = models.URLField(help_text="URL to website")
address = models.TextField(blank=True, null=True)
phone = models.CharField(max_length=15, blank=True, null=True)
email = models.EmailField(blank=True, null=True)
logo = AjaxImageField(upload_to="sponsors", blank=True, null=True)
discount_detail = models.TextField(blank=True, null=True)
active = models.BooleanField(default=False)
homepage = models.BooleanField("Show on homepage?", default=False)
content_type = models.ForeignKey("contenttypes.ContentType",
on_delete=models.CASCADE,
blank=True,
null=True)
object_id = models.PositiveIntegerField(blank=True, null=True)
content_object = GenericForeignKey("content_type", "object_id")
objects = SponsorManager()
class Meta:
verbose_name = _("Sponsor")
verbose_name_plural = _("Sponsors")
def __str__(self):
return self.name
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(self.name)
super().save(*args, **kwargs)
def get_absolute_url(self):
return reverse("sponsor_detail", kwargs={"pk": self.pk})
class Post(models.Model):
class Meta:
verbose_name = "Статья"
verbose_name_plural = "Статья"
ordering = ['id']
def __str__(self):
return self.title
title = models.CharField(max_length=256)
content = RichTextField()
image = AjaxImageField(upload_to='uploads',
default="robot.png",
null=True,
blank=True)
created = models.DateTimeField(auto_now_add=True)
def get_image(self):
if self.image and self.image.url and len(self.image.url) > 0:
return self.image.url
else:
return static('uploads/robot.png')
class Recipe(models.Model):
""" Model of recipe """
STATUS_CHOICES = (
(u'P', _('published')),
(u'd', _('draft')),
(u'i', _('idea')),
)
COMPLEXITY_CHOICES = (
(1, _('еasy')),
(2, _('medium')),
(3, _('hard')),
)
title = models.CharField(max_length=250, unique=True,
verbose_name=_('title'))
url = models.CharField(max_length=250, default='', unique=True, blank=True,
verbose_name=_('recipe url'))
status = models.CharField(max_length=2, default=u'i',
choices=STATUS_CHOICES,
verbose_name=_('status'))
category = models.ForeignKey(Category, on_delete=models.CASCADE,
verbose_name=_('category'))
complexity = models.IntegerField(default=1, choices=COMPLEXITY_CHOICES,
verbose_name=_('complexity'))
description = models.TextField(blank=True, verbose_name=_('description'))
time = models.IntegerField(default=0, null=True, blank=True,
verbose_name=_('time'),
help_text=_("Total time for cooking, "
"in minutes"))
manually_weight = models.IntegerField(default=None, null=True, blank=True,
verbose_name=_('weight'),
help_text=_("Weight after cooking, "
"in grams"))
manually_energy = models.DecimalField(default=None, null=True, blank=True,
max_digits=7, decimal_places=3,
verbose_name=_('energy'))
manually_protein = models.DecimalField(default=None, null=True, blank=True,
max_digits=7, decimal_places=3,
verbose_name=_('protein'))
manually_fat = models.DecimalField(default=None, null=True, blank=True,
max_digits=7, decimal_places=3,
verbose_name=_('fat'))
manually_carbohydrate = models.DecimalField(default=None, null=True,
blank=True, max_digits=7,
decimal_places=3,
verbose_name=_('carbohydrate'))
weight = models.IntegerField(default=0, verbose_name=_('weight'),
help_text=_("Weight after cooking, in grams"))
energy = models.DecimalField(default=0, max_digits=7, decimal_places=3,
verbose_name=_('energy'))
protein = models.DecimalField(default=0, max_digits=7, decimal_places=3,
verbose_name=_('protein'))
fat = models.DecimalField(default=0, max_digits=7, decimal_places=3,
verbose_name=_('fat'))
carbohydrate = models.DecimalField(default=0, max_digits=7,
decimal_places=3,
verbose_name=_('carbohydrate'))
image = AjaxImageField(null=True, blank=True, upload_to='images',
max_width=1024, max_height=768, crop=True,
verbose_name=_('image'))
thumbnail = ImageSpecField(source='image',
processors=[ResizeToFill(400, 300)],
format='JPEG', options={'quality': 90})
tags = models.ManyToManyField(Tag, blank=True, verbose_name=_('tags'),
help_text=_('tags'))
def __str__(self):
return self.title
def calculate(self):
""" calculate recipe energy, protein, fat and carbohydrate """
energy = 0
protein = 0
fat = 0
carbohydrate = 0
weight = 0
for ingredient in self.recipeingredient_set.all():
iwt = ingredient.weight
weight = weight + iwt
if ingredient.ingredient.energy:
energy += float(ingredient.ingredient.energy) * iwt / 100
if ingredient.ingredient.protein:
protein += ingredient.ingredient.protein * iwt / 100
if ingredient.ingredient.fat:
fat += ingredient.ingredient.fat * iwt / 100
if ingredient.ingredient.carbohydrate:
carbohydrate += ingredient.ingredient.carbohydrate * iwt / 100
if self.manually_weight:
weight = self.manually_weight
if weight:
self.energy = float(energy / weight * 100) \
if self.manually_energy is None else self.manually_energy
self.protein = float(protein / weight * 100) \
if self.manually_protein is None else self.manually_protein
self.fat = float(fat / weight * 100) \
if self.manually_fat is None else self.manually_fat
self.carbohydrate = float(carbohydrate / weight * 100) \
if self.manually_carbohydrate is None \
else self.manually_carbohydrate
self.weight = weight if self.manually_weight is None \
else self.manually_weight
def count_tags(self):
""" count recipes in tags """
for tag in self.tags.all():
counter = Recipe.objects.filter(models.Q(tags__name=tag.name),
status=u'P').count()
tag = Tag.objects.get(pk=tag.id)
tag.counter = counter
tag.save()
def fullness(self):
""" return recipe fullnes """
fullness = 0
if self.image:
fullness = fullness + 20
if self.description:
fullness = fullness + 10
ok_gram = True
ok_energy = True
ok_nutrients = True
ingredients = self.recipeingredient_set.all()
if ingredients:
fullness = fullness + 20
for ingredient in ingredients:
if ingredient.roughly:
ok_gram = False
if ingredient.ingredient.energy is None:
ok_energy = False
if ingredient.ingredient.protein is None or \
ingredient.ingredient.fat is None or \
ingredient.ingredient.carbohydrate is None:
ok_nutrients = False
if ok_gram:
fullness = fullness + 20
if ok_energy:
fullness = fullness + 20
if ok_nutrients:
fullness = fullness + 5
if self.recipeimage_set.all():
fullness = fullness + 5
return '%i%%' % fullness
fullness.short_description = _('fullness')
def recipe_tags(self):
""" return recipe tags, comma separated """
return ", ".join([t.name for t in self.tags.all()])
recipe_tags.short_description = _('tags')
def recipe_ingredients(self, maximum=3, weight=False, more=False):
""" return list of recipe ingredients """
ingredients = []
for i in self.recipeingredient_set.all():
if weight:
ingr = "{}: {} {}".format(i.ingredient.name, i.weight, _('gr'))
else:
ingr = i.ingredient.name
ingredients.append(ingr)
return ', '.join(ingredients[0:maximum]) + \
(' ...' if (maximum < len(ingredients) and more) else '')
recipe_ingredients.short_description = _('ingredients')
def fix_url(self):
""" convert recipe title to translit [a-zA-Z] """
self.url = transliterate(self.title)
def has_roughly(self):
""" return True if recipe has roughly ingridient """
has_roughly = False
for i in self.recipeingredient_set.all():
if i.roughly:
has_roughly = True
return has_roughly
has_roughly.short_description = _('Has roughly')
class Meta:
verbose_name = _('recipe')
verbose_name_plural = _('recipes')
class Member(MachineTagMixin):
GENDER_CHOICES = (
(1, "Man"),
(2, "Woman"),
)
username = models.ForeignKey("auth.User",
on_delete=models.CASCADE,
null=True,
blank=True)
first_name = models.CharField(max_length=20)
last_name = models.CharField(max_length=20)
hawk_name = models.CharField(max_length=50, blank=True, null=True)
phone = models.CharField(max_length=15, blank=True, null=True)
email = models.EmailField(blank=True, null=True)
address = models.TextField(blank=True, null=True)
address2 = models.CharField(max_length=100, blank=True, null=True)
city = models.CharField(max_length=100, blank=True, null=True)
state = models.CharField(max_length=2, blank=True, null=True)
zip = models.CharField(max_length=25, blank=True, null=True)
avatar = AjaxImageField(upload_to="members/avatars", blank=True, null=True)
date_paid = models.DateField(null=True, blank=True)
member_since = models.DateField(null=True, blank=True)
# gender = models.IntegerField(choices=GENDER_CHOICES, null=True, blank=True)
gender = models.CharField(max_length=100, null=True, blank=True)
notes = models.TextField(null=True, blank=True)
receive_comment_emails = models.BooleanField(
default=False,
help_text=
"Should this member be notified when a comment is left on the website?",
)
objects = MemberManager()
class Meta:
verbose_name = _("Member")
verbose_name_plural = _("Members")
ordering = ["last_name"]
def __str__(self):
return self.full_hawk_name
def get_absolute_url(self):
return reverse("member_detail", kwargs={"pk": self.pk})
def get_machine_tags(self):
machine_tags = super().get_machine_tags()
machine_tags += [
"trailhawk:member={}".format("-".join(
[self.first_name, self.last_name]).lower())
]
return machine_tags
def active(self):
try:
return self.date_expires >= datetime.date.today()
except:
return False
active.boolean = True
@property
def date_expires(self):
if self.date_paid:
date_expires = self.date_paid + datetime.timedelta(weeks=52)
else:
# this is only seen the admin so we can have fun with it
date_expires = "FREELOADER"
return date_expires
@property
def full_hawk_name(self):
if self.hawk_name:
return f'{self.first_name} "{self.hawk_name}" {self.last_name}'
else:
return f"{self.first_name} {self.last_name}"
@property
def full_name(self):
return f"{self.first_name} {self.last_name}"
@property
def get_position(self):
for pos, title in self.POSITION_CHOICES:
if self.position == pos:
return title
@property
def get_blog_posts(self):
from blog.models import Post
return Post.objects.filter(author=self)
@property
def get_race_results(self):
from races.models import Result
return Result.objects.filter(
racer__trailhawk=self).order_by("-race__start_datetime")
@property
def get_race_reports(self):
from races.models import Report
return Report.objects.filter(racer__trailhawk=self)
class Race(MachineTagMixin):
"""Race model."""
KM = 1
MI = 2
UNIT_CHOICES = (
(KM, _("Kilometers")),
(MI, _("Miles")),
)
RUN = 1
BIKE = 2
SWIM = 3
DISCIPLINE_CHOICES = (
(RUN, _("Run")),
(BIKE, _("Bike")),
(SWIM, _("Swim")),
)
title = models.CharField(
max_length=200,
help_text=
'Title of event. If there are multiple races assoiated to an "event", make two events.',
)
active = models.BooleanField(default=True)
number = models.IntegerField(blank=True, null=True)
annual = models.CharField(max_length=32, blank=True, null=True)
slug = models.SlugField(
unique=True,
blank=True,
help_text=
"Suggested value automatically generated from title and annual. Must be unique.",
)
slogan = models.CharField(max_length=300, blank=True, null=True)
logo = AjaxImageField(upload_to="races/logos", blank=True, null=True)
# background = AjaxImageField(upload_to='races/backgrounds', blank=True, null=True,
# help_text='Optional background photo')
background = models.ForeignKey("flickr.Photo",
on_delete=models.CASCADE,
blank=True,
null=True)
race_type = models.IntegerField(choices=DISCIPLINE_CHOICES, default=RUN)
sponsors = models.ManyToManyField("sponsors.Sponsor",
related_name="sponsors")
race_directors = models.ManyToManyField("members.Member")
awards = models.TextField(blank=True, null=True)
distance = models.CharField(max_length=100,
blank=True,
null=True,
help_text="eg 26.2")
unit = models.IntegerField(choices=UNIT_CHOICES,
default=KM,
blank=True,
null=True)
start_datetime = models.DateTimeField(verbose_name="Start Date and Time")
description = models.TextField(blank=True)
location = models.ForeignKey("locations.Location",
on_delete=models.CASCADE,
blank=True,
null=True)
course_map = models.URLField(blank=True,
null=True,
help_text="Link to course map if avail.")
cut_off = models.CharField(max_length=75,
null=True,
blank=True,
help_text="eg: 13 hours")
reg_url = models.URLField(
blank=True,
null=True,
help_text=
"Link to registartion flyer or to registration URL for online signup.",
)
reg_description = models.TextField(blank=True, null=True)
ultrasignup_id = models.CharField(
max_length=50,
null=True,
blank=True,
help_text="This should be the ID of your UltraSignup.com ?did=",
)
entry_form = models.FileField(upload_to="races/entry_forms",
null=True,
blank=True)
discounts = models.TextField(
blank=True,
null=True,
help_text="Describe discounts for the race if they exist.",
)
lodging = models.URLField(blank=True,
null=True,
help_text="Link to lodging information")
packet_pickup = models.TextField(blank=True, null=True)
facebook_url = models.URLField(blank=True,
null=True,
help_text="Link to Facebook page")
facebook_event_url = models.URLField(
blank=True, null=True, help_text="Link to Facebook Event page")
objects = RaceManager()
class Meta:
ordering = ["-start_datetime"]
verbose_name = _("Race")
verbose_name_plural = _("Races")
def save(self, *args, **kwargs):
if not self.slug:
self.slug = slugify(
f"{self.title} {self.start_datetime.strftime('%Y')}")
return super().save(*args, **kwargs)
def __str__(self):
return self.get_full_name()
def get_absolute_url(self):
return reverse(
"race_detail",
kwargs={
"year": self.start_datetime.strftime("%Y"),
"month": self.start_datetime.strftime("%b").lower(),
"day": self.start_datetime.strftime("%d"),
"slug": self.slug,
},
)
def get_full_name(self):
name = f"{self.title}"
if self.number:
number = num2words(self.number, ordinal=True)
if self.number == 1:
name = f"Inaugural {self.title}"
else:
name = f"{number} Annual {self.title}"
elif self.annual:
name = f"{self.annual} {self.title}"
return title(name)
@cached_property
def ical_uid(self):
return f"race-{self.pk}@trailhawks.com"
@cached_property
def get_overall_results(self):
return self.result_set.all().order_by("race_type", "time")
@cached_property
def get_race_reports(self):
return self.report_set.all()
@cached_property
def is_finished(self):
return not self.result_set.count() == 0