def ready(self):
# Import the model requiring translation
ReminderChoice = self.get_model("ReminderChoice")
# Register fields to translate
vinaigrette.register(ReminderChoice, [
'field',
])
def ready(self):
from .models import Kind, Variation, Topping
Kind = self.get_model("Kind")
Variation = self.get_model("Variation")
Topping = self.get_model("Topping")
vinaigrette.register(Kind, ['title', 'description'])
vinaigrette.register(Variation, ['title', 'description'])
vinaigrette.register(Topping, ['title'])
from django.dispatch import receiver
from django.utils.translation import ugettext_lazy as _
# Default causes
causes = ['Professional Training', 'Fight Poverty', 'Conscious consumption', 'Culture, Sport and Art', 'Human Rights', 'Education', 'Youth', 'Elders', 'Environment', 'Citizen Participation', 'Animal Protection', 'Health', 'People with disabilities']
class Cause(ChannelRelationship):
name = models.CharField(_('name'), max_length=100)
image = models.ForeignKey('uploads.UploadedImage', blank=True, null=True, verbose_name=_('image'))
slug = models.SlugField(_('slug'), max_length=100, blank=True, null=True)
class Meta:
app_label = 'core'
verbose_name = _('cause')
unique_together = (('slug', 'channel'), )
def __str__(self):
return self.name
def save(self, *args, **kwargs):
if not self.pk:
self.slug = generate_slug(Cause, self.name, kwargs.get("object_channel", None))
super(Cause, self).save(*args, **kwargs)
@receiver(post_save, sender=Channel)
def create_default_skills(sender, instance, **kwargs):
for cause in causes:
Cause.objects.create(name=cause, object_channel=instance.slug)
vinaigrette.register(Cause, ['name'])
badges = self.badges.filter(value__lte=val)
# Save badges
added_badges = []
if save:
for b in badges:
try:
BadgeUser.objects.create(user=user, badge=b)
added_badges.append(b)
except IntegrityError:
pass # If badge already exist
return badges, added_badges
# Translation
vinaigrette.register(BadgeCategory, ['name', ])
def badge_image_path(instance, filename):
return instance.build_image_path()
class Badge(models.Model):
'''
Badge earned by users after some events
'''
name = models.CharField(max_length=250, unique=True)
value = models.CharField(max_length=250, blank=True, null=True)
category = models.ForeignKey(BadgeCategory, related_name='badges')
position = models.IntegerField()
image = models.ImageField(upload_to=badge_image_path, default='badges/default.png')
users = models.ManyToManyField('users.Athlete', through='badges.BadgeUser', related_name='badges')
def __str__(self):
"""
Takes into account that the DDC number as three digits
"""
return "{:03d} {}".format(self.number, self.name)
@property
def number_as_string(self):
"""
:returns: classification number as formatted string with leading 0 if necessary
"""
return "{:03d}".format(self.number)
# Register DDC as to be translated.
vinaigrette.register(DDC, ['name'])
class License(models.Model):
"""
A model to store licenses. Each repository chooses licenses from this model.
"""
#: Full name of the license as displayed to the user
name = models.CharField(max_length=255, default=None)
#: URI of the license. If no URI is provided, you can use https://dissem.in/deposit/license/ as namespace. Usually used for transmission in depositing process
uri = models.URLField(max_length=255, unique=True, default=None)
def __str__(self):
"""
String representation of license object
"""
if self.depth <= 1 or not self.parent:
return self
return self.parent
def get_category(self):
# Always give a valid parent category
return self.get_parent().slug
@property
def icon(self):
return 'icon-sport-%s' % self.slug
# i18n
vinaigrette.register(Sport, [
'name',
])
class SportSession(models.Model):
day = models.ForeignKey('SportDay', related_name="sessions")
sport = models.ForeignKey(Sport)
time = IntervalField(format='DHMSX', null=True, blank=True)
distance = models.FloatField(null=True, blank=True)
name = models.CharField(max_length=255, null=True, blank=True)
comment = models.TextField(_('session comment'), null=True, blank=True)
type = models.CharField(max_length=12,
default='training',
choices=SESSION_TYPES)
race_category = models.ForeignKey('RaceCategory',
verbose_name=_('Race category'),
class TestExecutionStatus(TCMSActionModel):
class Meta:
# used in the admin view
verbose_name_plural = _("Test execution statuses")
name = models.CharField(max_length=60, blank=True, unique=True)
weight = models.IntegerField(default=0)
icon = models.CharField(max_length=64)
color = ColorField()
def __str__(self):
return self.name
# register model for DB translations
vinaigrette.register(TestExecutionStatus, ["name"])
class TestExecution(TCMSActionModel):
history = KiwiHistoricalRecords()
assignee = models.ForeignKey(
settings.AUTH_USER_MODEL,
blank=True,
null=True,
related_name="case_run_assignee",
on_delete=models.CASCADE,
)
tested_by = models.ForeignKey(
settings.AUTH_USER_MODEL,
blank=True,
def save(self, *args, **kwargs):
if self.slug == "":
self.slug = slugify(self.term)
super(TaxonomyTerm, self).save(*args, **kwargs)
class TaxonomyMap(models.Model):
"""Mappings between content and any taxonomy types/terms used to classify it"""
term = models.ForeignKey(TaxonomyTerm, db_index=True, related_name='taxa')
content_type = models.ForeignKey(ContentType, verbose_name='content type', db_index=True)
object_id = models.CharField(
max_length=getattr(settings, "TAXONOMY",
{'pk_max_length':128})['pk_max_length'], db_index=True)
object = generic.GenericForeignKey('content_type', 'object_id')
objects = TaxonomyManager()
class Meta:
unique_together = (('term', 'content_type', 'object_id'),)
def __unicode__(self):
return u'%s' % self.term
def clean(self):
if self.term.type != self.type:
raise ValidationError("Term must belong to the same taxonomy! Current: {},{}".format(self.type,self.term.type))
vinaigrette.register(TaxonomyTerm, ['term', 'question', 'help_text',])
vinaigrette.register(Taxonomy, ['type',])
def ready(self):
Ingredient = self.get_model("Product")
vinaigrette.register(Ingredient, ["description"])
def ready(self):
from budget.signals import permission_signals
MovementCategory = self.get_model('MovementCategory')
# Register fields to translate
vinaigrette.register(MovementCategory, ['description'])
from django.db import models
import vinaigrette
from . import mixins
class Content(mixins.MultilingualSearchable):
title = models.CharField(max_length=255)
slug = models.SlugField()
text = models.TextField(blank=True)
notes = models.TextField(blank=True)
image = models.ImageField(upload_to='liitokala/uploads', blank=True)
_translatable_fields = ['title', 'text']
_tracked_fields = _translatable_fields
def __str__(self):
return self.title
vinaigrette.register(Content, Content._translatable_fields)
from django.db import models
import vinaigrette
class Dressing(models.Model):
name = models.TextField(blank=True, null=True)
vinaigrette.register(Dressing, ('name', ))
def ready(self):
from .models import Unit
vinaigrette.register(Unit, ['name'])
from django.db import models
from django.utils.translation import ugettext_lazy as _
import vinaigrette
class Post(models.Model):
message = models.CharField(max_length=200,
verbose_name='Message', help_text=_('A message'))
def __unicode__(self):
return self.message
vinaigrette.register(Post, ['message'])
def ready(self):
from .models import Status
Status = self.get_model("Status")
vinaigrette.register(Status, ['title'])
def ready(self):
Ingredient = self.get_model("Material")
vinaigrette.register(Ingredient, ["name"])
from django.db import models
from django.utils.translation import ugettext_lazy as _
import vinaigrette
class Post(models.Model):
message = models.CharField(max_length=200,
verbose_name='Message',
help_text=_('A message'))
def __unicode__(self):
return self.message
vinaigrette.register(Post, ['message'])
def get_parent(self):
# Always give a valid parent
if self.depth <= 1 or not self.parent:
return self
return self.parent
def get_category(self):
# Always give a valid parent category
return self.get_parent().slug
@property
def icon(self):
return 'icon-sport-%s' % self.slug
# i18n
vinaigrette.register(Sport, ['name', ])
class SportSession(models.Model):
day = models.ForeignKey('SportDay', related_name="sessions")
sport = models.ForeignKey(Sport)
time = IntervalField(format='DHMSX', null=True, blank=True)
distance = models.FloatField(null=True, blank=True)
name = models.CharField(max_length=255, null=True, blank=True)
comment = models.TextField(_('session comment'), null=True, blank=True)
type = models.CharField(max_length=12, default='training', choices=SESSION_TYPES)
race_category = models.ForeignKey('RaceCategory', verbose_name=_('Race category'), null=True, blank=True)
created = models.DateTimeField(auto_now_add=True)
updated = models.DateTimeField(auto_now=True)
# Comments
comments_public = models.OneToOneField('messages.Conversation', null=True, blank=True, related_name='session_public')
def ready(self):
super().ready()
# from .models import WowSpec, WowClass, Race, Faction, FightStyle, SimulationType
from general_website.models.world_of_warcraft import Faction
from general_website.models.world_of_warcraft import FightStyle
from general_website.models.world_of_warcraft import Race
from general_website.models.world_of_warcraft import SimulationType
from general_website.models.world_of_warcraft import WowClass
from general_website.models.world_of_warcraft import WowSpec
vinaigrette.register(WowSpec, [
'tokenized_name',
])
vinaigrette.register(WowClass, [
'tokenized_name',
])
vinaigrette.register(Race, [
'tokenized_name',
])
vinaigrette.register(Faction, [
'name',
])
vinaigrette.register(FightStyle, [
'tokenized_name',
])
vinaigrette.register(SimulationType, [
'name',
])
def ready(self):
from .models import CartItem
CartItem = self.get_model("CartItem")
vinaigrette.register(CartItem, ['size'])
class TestCaseStatus(models.Model, UrlMixin):
name = models.CharField(max_length=255)
description = models.TextField(null=True, blank=True)
is_confirmed = models.BooleanField(db_index=True, default=False)
class Meta:
verbose_name = _("Test case status")
verbose_name_plural = _("Test case statuses")
def __str__(self):
return self.name
# register model for DB translations
vinaigrette.register(TestCaseStatus, ["name"])
class Category(models.Model, UrlMixin):
name = models.CharField(max_length=255)
product = models.ForeignKey("management.Product",
related_name="category",
on_delete=models.CASCADE)
description = models.TextField(blank=True)
class Meta:
verbose_name_plural = _("Categories")
unique_together = ("product", "name")
def __str__(self):
return self.name
import vinaigrette
from django.db import models
from django.utils.translation import ugettext_lazy as _
class Skill(models.Model):
name = models.CharField(_('name'), max_length=100)
def __str__(self):
return self.name
class Meta:
app_label = 'ovp_core'
verbose_name = _('skill')
vinaigrette.register(Skill, ['name'])
def get_names(cls):
""" Get all status names in mapping between id and name """
return dict(cls.objects.values_list('pk', 'name'))
@classmethod
def get_names_ids(cls):
""" Get all status names in reverse mapping between name and id """
return dict((name, _id) for _id, name in cls.get_names().items())
def icon(self):
with override('en'):
return self._icons[self.name]
# register model for DB translations
vinaigrette.register(TestExecutionStatus, ['name'])
class TestExecution(TCMSActionModel):
history = KiwiHistoricalRecords()
case_run_id = models.AutoField(primary_key=True)
assignee = models.ForeignKey(settings.AUTH_USER_MODEL,
blank=True,
null=True,
related_name='case_run_assignee',
on_delete=models.CASCADE)
tested_by = models.ForeignKey(settings.AUTH_USER_MODEL,
blank=True,
null=True,
related_name='case_run_tester',
def __str__(self):
"""
Takes into account that the DDC number as three digits
"""
return "{:03d} {}".format(self.number, self.name)
@property
def number_as_string(self):
"""
:returns: classification number as formatted string with leading 0 if necessary
"""
return "{:03d}".format(self.number)
# Register DDC as to be translated.
vinaigrette.register(DDC, ['name'])
class GreenOpenAccessService(models.Model):
"""
A model to store text for a green open access service, i.e. the repository administration offers a service to publish on behalf of their researchers.
Currently, after uploading in a repository with support, text is shown
"""
#: Heading to display after deposit
heading = models.TextField()
#: Text to display after deposit
text = models.TextField()
#: URL to a page which describes the service
learn_more_url = models.URLField(max_length=1024)
@classmethod
def id_passed(cls):
return cls._status_to_id('passed')
@classmethod
def id_failed(cls):
return cls._status_to_id('failed')
@classmethod
def id_blocked(cls):
return cls._status_to_id('blocked')
# register model for DB translations
vinaigrette.register(TestCaseRunStatus, ['name'])
class TestCaseRunManager(models.Manager):
# todo: delete this
def get_automated_case_count(self):
return self.filter(case__is_automated=1).count()
def get_manual_case_count(self):
return self.filter(case__is_automated=0).count()
def get_both(self):
count1 = self.get_automated_case_count()
count2 = self.get_manual_case_count()
return self.count() - count1 - count2
class Event(models.Model):
name = models.CharField(max_length=200, blank=True, null=True, verbose_name=_('Name of Event'))
description = models.CharField(max_length=400, blank=True, null=True, verbose_name=_('Swedish description'))
description_english = models.CharField(max_length=400, blank=True, null=True, verbose_name=_('English description'))
startdate = models.DateTimeField(_('Startdate and time'))
enddate = models.DateTimeField(_('Enddate and time'))
#reccurrences = RecurrenceField(null=True,verbose_name='Upprepade event')
categories = models.ManyToManyField(Category, verbose_name=_('Tags'))
weekdays = models.ManyToManyField(Weekdays, verbose_name=_('Weekdays'), null=True, blank=True)
#multipledates = models.DateTimeField('multiple dates')
host = models.ForeignKey(Host, on_delete=models.CASCADE, null=True, verbose_name=_('Host'))
location = models.ForeignKey(Location, on_delete=models.CASCADE, null=True, verbose_name=_('Location'))
def e_names(self):
return u', '.join([c.name for c in self.categories.all()])
def w_names(self):
return u', '.join([w.name for w in self.weekdays.all()])
e_names.short_description = "Categories"
w_names.short_description = "Weekdays"
def __unicode__(self):
return u'%s / %s / %s' % (self.name, self.description, self.description_english)
vinaigrette.register(Weekdays, ['name'])
vinaigrette.register(Category, ['name'])
