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"])
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'])