def ready(self): if EasyTagConfig.configured: return from django.contrib.contenttypes.models import ContentType from tagging.registry import register app_settings = {} for model_setting in getattr(settings, 'EASY_TAGS', {}): if 'MODEL' in model_setting: app_settings[import_string(model_setting['MODEL'])] = { 'label': model_setting.get('LABEL'), 'permissions': model_setting.get('PERMISSIONS'), 'filters': model_setting.get('FILTERS') } content_types = {} try: for model, content_type in ContentType.objects.get_for_models( *app_settings.keys()).items(): label = app_settings[model]['label'] if not label: label = content_type.model content_types[label] = { 'content_type': content_type, 'permissions': get_setting(app_settings[model]['permissions']), 'filters': get_setting(app_settings[model]['filters']) } register(model) easy_tags_settings.EASY_TAGS_CONFIG = content_types EasyTagConfig.configured = len(content_types) > 0 except (ProgrammingError, OperationalError): pass
self.is_active = False # print('image', image.exists()) if image.exists() and self.in_stock and self.price > 0: self.is_active = True else: self.is_active = False cache.delete('product-%s' % self.slug) super().save(*args, **kwargs) # REGISTER PRODUCT MODEL AS A TAG register(Product) class DisplayImageManager(models.Manager): def get_query_set(self): return super(DisplayImageManager, self).get_query_set().filter(in_display=True) class ProductImage(CreationModificationDateMixin): item = models.ForeignKey(Product, on_delete=models.CASCADE) image = StdImageField(upload_to='images/products', variations={ 'thumbnail': (180, 150), 'medium': (365, 365), 'deals_size': (365, 365, True),
self.region.save() class Meta: verbose_name = _('Django person') verbose_name_plural = _('Django people') def irc_tracking_allowed(self): return not self.machinetags.filter( namespace='privacy', predicate='irctrack', value='private', ).count() register(DjangoPerson, tag_descriptor_attr='skilltags', tagged_item_manager_attr='skilltagged') class PortfolioSite(models.Model): title = models.CharField(_('Title'), max_length=100) url = models.URLField(_('URL'), max_length=255) contributor = models.ForeignKey(DjangoPerson, models.CASCADE, verbose_name=_('Contributor')) def __str__(self): return '%s <%s>' % (self.title, self.url) class Meta: verbose_name = _('Portfolio site')
def __str__(self): return self.title class Meta: ordering = ['-publish_time'] class UReport(models.Model): ruser = models.ForeignKey(User) post = models.CharField(max_length=100) report_time = models.DateTimeField(auto_now_add=True) reason = models.CharField(max_length=100) pname = models.CharField(max_length=50) def __str__(self): return self.ruser class Collection(models.Model): collect_user = models.ForeignKey(settings.AUTH_USER_MODEL) collect_post = models.ForeignKey(Post) class RecommendList(models.Model): referee = models.ForeignKey(settings.AUTH_USER_MODEL) recommend_post = models.ForeignKey(Post) register(Post)
from django.db import models from django.core.validators import RegexValidator from tagging.registry import register from libs.helpers import UserModelHelper class Vendor(UserModelHelper): picture = models.ImageField(upload_to='', blank=True, null=True) number_of_employee = models.IntegerField(blank=True, default=0) def tag_names(self): return ' '.join([tag.name for tag in self.tags]) register(Vendor)
def cross_sells_hybrid(self): from checkout.models import Order, OrderItem from django.contrib.auth.models import User from django.db.models import Q orders = Order.objects.filter(orderitem__product=self) users = User.objects.filter(order__orderitem__product=self) items = OrderItem.objects.filter( Q(order__in=orders) | Q(order__user__in=users)).exclude(product=self) products = Product.active.filter(orderitem__in=items).distinct() return products try: tagging.register(Product) except tagging.AlreadyRegistered: pass class ActiveProductReviewManager(models.Manager): def all(self): return super(ActiveProductReviewManager, self).all().filter(is_approved=True) class ProductReview(models.Model): RATINGS = ( (5, 5), (4, 4), (3, 3),
def save(self, force_insert=False, force_update=False): self.body_html = markdown(self.body) super(Art, self).save(force_insert, force_update) def low_res_image_tag(self): return markdown('<img src="/%s/%s/%s" width="30%" height="30%" />' % (self.art_type, "low", self.image_lowres)) def high_res_image_tag(self): return markdown('<img src="/%s/%s/%s" width="70%" height="70%" />' % (self.art_type, "high", self.image_highres)) @models.permalink def get_absolute_url(self): return ('art_detail_page', (), { 'slug': self.slug }) register(Art, tag_descriptor_attr='atags') class Art_Category(models.Model): """ Class defining art types """ category = models.CharField(max_length=100, help_text=u'Max 100 characters') slug = models.SlugField(unique=True, help_text=u'Suggested value automatically generated from title. Must be unique.') class Meta: verbose_name = "Art Category" verbose_name_plural = "Art Categories" ordering = ['category'] def __unicode__(self):
self.country.save() if self.region: self.region.num_people = self.region.djangoperson_set.count() self.region.save() class Meta: verbose_name = _('Django person') verbose_name_plural = _('Django people') def irc_tracking_allowed(self): return not self.machinetags.filter( namespace='privacy', predicate='irctrack', value='private', ).count() register(DjangoPerson, tag_descriptor_attr='skilltags', tagged_item_manager_attr='skilltagged') class PortfolioSite(models.Model): title = models.CharField(_('Title'), max_length=100) url = models.URLField(_('URL'), max_length=255) contributor = models.ForeignKey(DjangoPerson, models.CASCADE, verbose_name=_('Contributor')) def __str__(self): return '%s <%s>' % (self.title, self.url) class Meta: verbose_name = _('Portfolio site') verbose_name_plural = _('Portfolio sites')
on_delete=models.CASCADE) objects = EntryManager.from_queryset(EntryQuerySet)() published = PublishedEntryManager.from_queryset(EntryQuerySet)() class Meta: verbose_name = _(u'Wpis') verbose_name_plural = _(u'Wpisy') ordering = ['-publish_time', '-posted', '-pk'] def __unicode__(self): return self.title def get_text_length(self): return len(self.text) def get_absolute_url(self): return reverse('blog_entry', kwargs={ 'year': str(self.posted.year), 'month': str(self.posted.month), 'slug': str(self.slug) }) @cached_property def is_long(self): return len(self.text) > settings.LONG_ENTRY_LENGTH registry.register(Entry)
class Meta: db_table = u'artist' def __unicode__(self): return self.name def get_absolute_url(self): return "/artist/%d/" % self.id def lastfm(self): return ("http://last.fm/music/" + urllib.quote_plus(self.name.encode('utf-8'))) register(Artist) class Composer(models.Model): name = models.TextField() class Meta: db_table = u'composer' def __unicode__(self): return self.name def full_search(q): title_tracks = Track.objects.filter(title__icontains=q) artists = Artist.objects.filter(name__icontains=q)
null=True, blank=True) def get_absolute_url(self): return reverse('posts:detail', kwargs={'slug': self.slug}) def get_others(self): return Post.published_objects.exclude(pk=self.pk) def get_next_published(self): try: published_gte = self.get_others().filter( published_at__gte=self.published_at) return published_gte.order_by('published_at')[0] except IndexError: raise Post.DoesNotExist def get_previous_published(self): try: published_lte = self.get_others().filter( published_at__lte=self.published_at) return published_lte.order_by('-published_at')[0] except IndexError: raise Post.DoesNotExist def __str__(self): return self.title register(Post, 'post_tags')
products = Product.active.filter(orderitem__in=items).distinct() return products def cross_sell_hybrid(self): from checkout.models import Order,OrderItem from django.contrib.auth.models import User from django.db.models import Q orders=Order.objects.filter(orderitem__product=self) users=User.objects.filter(order__orderitem__product=self) items=OrderItem.objects.filter(Q(order__in=orders)|Q(order__user__in=users)).exclude(product=self) products = Product.active.filter(orderitem__in=items).distinct() #print(products) return products try: register(Product) except tagging.registry.AlreadyRegistered: pass class ActiveProductReviewManager(models.Manager): def all(self): return super(ActiveProductReviewManager, self).all().filter(is_approved=True) class ProductReview(models.Model): RATINGS = ((5,5),(4,4),(3,3),(2,2),(1,1),) product=models.ForeignKey(Product) user=models.ForeignKey(User) title=models.CharField(max_length=50) date=models.DateTimeField(auto_now_add=True) rating=models.PositiveSmallIntegerField(default=5,choices=RATINGS)
check.notify_resurrection(event) if event.is_failed_finish(): check.notify_failed_finish(event) if event.event == 'log': if event.violates_expected_regex(): check.notify_expected_regex(event) if event.violates_alert_regex(): check.notify_alert_regex(event) @receiver(post_save) def add_notification_for_new_user(sender, **kwargs): if sender != User or NotificationReceiver.objects.filter( owner=kwargs['instance']).count() > 0: return user = kwargs['instance'] n = NotificationReceiver(owner=user, address=user.email, confirmation_token=None) n.save() @receiver(post_save) def check_cron_run(sender, **kwargs): if sender != CheckEvent: return TotmannRuntimeData.check_cron_run() register(Check)
excerpt_html = models.TextField(editable=False, blank=True) body_html = models.TextField(editable=False, blank=True) enable_comments = models.BooleanField(default=True) slug = models.SlugField(unique_for_date='pub_date', help_text=u'Suggested value automatically generated from title. Must be unique.') status = models.IntegerField(choices=STATUS_CHOICES, default=LIVE_STATUS, help_text=u'Only entries with live status will be publicly displayed.') tags = TagField(help_text=u'Seperate tags with spaces.') class Meta: ordering = ['-pub_date'] verbose_name_plural = u'Entries' def __unicode__(self): return self.title def save(self, force_insert=False, force_update=False): self.body_html = markdown(self.body) self.excerpt_html = markdown(self.excerpt) super(Entry, self).save(force_insert, force_update) @models.permalink def get_absolute_url(self): return ('blog_entry_detail', (), { 'year': self.pub_date.strftime("%Y"), 'month': self.pub_date.strftime("%b").lower(), 'day': self.pub_date.strftime("%d"), 'slug': self.slug }) register(Entry, tag_descriptor_attr='etags')
ordering = ['created'] indexes = [models.Index(fields=['created'])] def __str__(self): return self.value def get_absolute_url(self): return reverse('definition-detail', kwargs={'uuid': self.uuid}) @property def has_examples(self): return self.example_set.exists() @property def examples(self): return self.example_set.all() class Example(base_models.BaseModel): definition = models.ForeignKey(Definition, on_delete=models.CASCADE) value = models.TextField() objects = managers.ActiveManager() all_objects = models.Manager() def __str__(self): return self.value registry.register(Definition, tag_descriptor_attr='assigned_tags')
# if instance.forth_relation_partner: # just in case user is not specified # instance.forth_relation_partner.delete() def get_or_create_by_title(cls, title_in=""): title_in = title_in.strip(" ") try: ob = cls.objects.get(_title=title_in) except cls.DoesNotExist: ob = cls.objects.create() ob.title = title_in ob.save() return ob register(Concept) register(Relation) register(ToLink) register(ForthLink) register(Link)
return 'charity/profile_images/' + str(uuid.uuid4()) + str( instance.id) + filename # Specifies the profile of the charity class CharityProfile(models.Model): likes = models.ManyToManyField(UserProfile, related_name='likes') user = models.OneToOneField(User, related_name='charity_profile') charity_name = models.CharField(max_length=100, null=True) goal = models.CharField(max_length=255, null=True) address = models.CharField(max_length=255, null=True) city = models.CharField(max_length=255, null=True) country = models.CharField(max_length=255, null=True) postcode = models.CharField(max_length=255, null=True) phone_number = models.CharField(max_length=255, null=True) email = models.CharField(max_length=255, null=True) description = models.TextField(max_length=1000, null=True) verified = models.BooleanField(default=False) paypal_email = models.CharField(max_length=255, null=True) paypal_identity_token = models.CharField(max_length=255, null=True) profile_image = models.FileField(upload_to=content_file_name, null=True) website = models.CharField(max_length=255, null=True) # Register the charity profile for tagging purpose register(CharityProfile)
RSAkey = models.CharField(max_length=15000) pubkey = models.CharField(max_length=15000) class project(models.Model): upvotes = models.IntegerField(default=0, help_text='upvotes') project_name = models.CharField(max_length=100, help_text='project name') project_description = models.CharField(max_length=1000, help_text='project description') project_company = models.CharField(max_length=100, help_text='project name', default='') register(project) class comment(models.Model): sender_name = models.CharField(max_length=100, help_text='sender name') comment = models.CharField(max_length=2000, help_text="comment") report_id = models.IntegerField(default=0, help_text='report id') class reportRate(models.Model): report_rate = models.FloatField(default=0.0, help_text="report rating") report_id = models.IntegerField(default=0, help_text='report id') rate_by = models.CharField(max_length=100, help_text='rater username')
last_num = dindic.warning_words.weigth last_word = dindic.warning_words.name return last_word def __str__(self): return self.comercial_name class Meta: verbose_name = _('Sustance') verbose_name_plural = _('Sustances') permissions = ( ("view_sustance", _("Can see available Sustance")), ) register(Sustance) # build information class BuilderInformation(models.Model): name = models.CharField(max_length=150, verbose_name=_("Name")) phone = models.TextField(max_length=15, verbose_name=_("Phone")) address = models.TextField(max_length=100, verbose_name=_("Address")) def __str__(self): return self.name class Meta: verbose_name = _('Builder Information') verbose_name_plural = _('Information of Builders') permissions = (
def __unicode__(self): return self.reason #store the identification fields for that organism (i.e. a leaf type) class IdentificationDetail(models.Model): organism = models.ForeignKey(Organism, related_name="id_details") field = models.ForeignKey(IdentificationField, related_name="id_field_details") description = models.CharField(max_length=250) #Don't need this anymore def __unicode__(self): return u"%s is %s" % (self.field.name, self.description) #consider doing a def save here to store the description slugified... class Meta: verbose_name_plural = "identification details" register(Organism) class Location(models.Model): name = models.CharField(max_length=100) description = models.TextField(blank=True) latitude = models.DecimalField(max_digits=11, decimal_places=9) longitude = models.DecimalField(max_digits=11, decimal_places=9) miles_wide = models.DecimalField(max_digits=7, decimal_places=2) miles_tall = models.DecimalField(max_digits=7, decimal_places=2) created_by = models.ForeignKey(User, related_name="+") private = models.BooleanField() def __unicode__(self): return self.description def __unicode__(self): return self.name
return (user.id == self.maintainer_id or self in user.softwarecollection_set.all()) elif perm == 'rate': return (user.id != self.maintainer_id or self not in user.softwarecollection_set.all()) else: return False def save(self, *args, **kwargs): if self.auto_sync: self.need_sync = True if not self.instructions.strip(): self.instructions = self.get_default_instructions() super(SoftwareCollection, self).save(*args, **kwargs) register(SoftwareCollection) class Repo(models.Model): # automatic value (scl.slug/name) used as unique key slug = models.SlugField(max_length=150, editable=False) scl = models.ForeignKey(SoftwareCollection, related_name='repos') copr = models.ForeignKey(Copr, related_name='repos') name = models.CharField(_('Name'), max_length=50) copr_url = models.CharField(_('Copr URL'), max_length=200) download_count = models.IntegerField(default=0, editable=False) last_synced = models.DateTimeField(_('Last synced'), null=True, editable=False) has_content = models.BooleanField(_('Has content'), default=False) class Meta:
def get_absolute_url(self): return reverse("blog:post_detail", kwargs={'pk': self.pk}) def __str__(self): return self.title class Comment(models.Model): post = models.ForeignKey('blog.Post', related_name='comments', on_delete='CASCADE') author = models.CharField(max_length=100) text = models.TextField() create_date = models.DateTimeField(default=timezone.now) approve_comment = models.BooleanField(default=False) def approve(self): self.approved_comment = True self.save() def get_absolute_url(self): return reverse('blog:post_detail', kwargs={'pk': self.post.pk}) def __str__(self): return self.text # Register models for tagging register(Post) register(Comment)
from tagging.registry import register from .configuration import Configuration from .issue import Issue from .object_source import ObjectSource from .product import Product from .reset_result import ResetResult from .result_analysis import ResultAnalysis from .result_error import ResultError from .result_file import ResultFile from .team import Team from .test_case import TestCase from .test_client import TestClient from .test_result import TestResult from .test_run import TestRun register(TestCase)
reformatted_li = [("_" + str(value), text) for value, text in sorted_li] choice_lists[fieldname] = OrderedDict(reformatted_li) # Choice lists for other models # choice_lists['morphology_role'] = [human_value for machine_value, human_value in # build_choice_list('MorphologyType')] choice_lists["morphology_role"] = get_choices("MorphologyType") reformatted_morph_role = [("_" + str(value), text) for value, text in choice_lists["morphology_role"]] choice_lists["morphology_role"] = OrderedDict(reformatted_morph_role) # morphology_role return json.dumps(choice_lists) # Register Gloss for tags try: register(Gloss) except tagging.registry.AlreadyRegistered: pass RELATION_ROLE_CHOICES = ( # Translators: RELATION_ROLE_CHOICES ("homonym", _("Homonym")), # Translators: RELATION_ROLE_CHOICES ("synonym", _("Synonym")), # Translators: RELATION_ROLE_CHOICES ("variant", _("Variant")), # Translators: RELATION_ROLE_CHOICES ("antonym", _("Antonym")), # Translators: RELATION_ROLE_CHOICES ("hyponym", _("Hyponym")), # Translators: RELATION_ROLE_CHOICES
from django.contrib import admin from tagging.registry import register # Register your models here. from phdadmissions.models.academic_year import AcademicYear from phdadmissions.models.application import Application from phdadmissions.models.configuration import Configuration from phdadmissions.models.documentation import Documentation from phdadmissions.models.supervision import Supervision admin.site.register(Application) admin.site.register(Supervision) admin.site.register(Documentation) admin.site.register(AcademicYear) admin.site.register(Configuration) # Register model for tagging purpose register(Application)
on_delete=models.CASCADE) book = models.ForeignKey(Book, on_delete=models.CASCADE) # ************************************************************** # # *********************** series data ************************** # # ************************************************************** # class Series(models.Model): id = models.BigAutoField(primary_key=True) name = models.CharField(max_length=200) count = models.IntegerField() def __str__(self): return self.name class SeriesDetail(models.Model): id = models.BigAutoField(primary_key=True) series = models.ForeignKey(Series, on_delete=models.CASCADE) book = models.ForeignKey(Book, on_delete=models.CASCADE) sequence = models.IntegerField() def __str__(self): return "%s - %s, %s of %s" % (self.series, self.book, self.sequence, self.series.count) register(Book)
blank=True, default='') mediaType = models.CharField(max_length=len('soundcloud'), choices=MEDIA_TYPE_CHOICES) mediaHash = models.CharField(max_length=30, null=True, blank=True, default='') published = models.BooleanField(default=False) def __str__(self): return 'Submission: ' + self.name + ' (' + str(self.submissionId) + ')' # Django Tagging register(Submission) class Category(models.Model): class Meta: verbose_name_plural = 'categories' categoryId = models.AutoField(primary_key=True) name = models.CharField(max_length=100) slug = models.SlugField(max_length=100, unique=True) hidden = models.BooleanField(default=False) description = models.TextField(null=True, blank=True, default='') def __str__(self): return 'Category: ' + self.name
ret = blog_prefix or reverse('pages-root') activate(old_lang) return ret def _template(self): from simple_translation.utils import get_translated_model model = get_translated_model(self.__class__) return model.DETAIL_TEMPLATE template = property(_template) class Meta: verbose_name = _('entry') verbose_name_plural = _('entries') ordering = ('-pub_date', ) registry.register(Entry, tag_descriptor_attr='entry_tags') class AbstractEntryTitle(models.Model): DETAIL_TEMPLATE = 'cmsplugin_blog/entry_detail.html' entry = models.ForeignKey(Entry, verbose_name=_('entry')) language = models.CharField(_('language'), max_length=15, choices=settings.LANGUAGES) title = models.CharField(_('title'), max_length=255) slug = models.SlugField(_('slug'), max_length=255) author = models.ForeignKey('auth.User', null=True, blank=True, verbose_name=_("author")) def __unicode__(self): return self.title def __str__(self):
status = models.IntegerField( choices=STATUS_CHOICES, default=LIVE_STATUS, help_text=u'Only entries with live status will be publicly displayed.') tags = TagField(help_text=u'Seperate tags with spaces.') class Meta: ordering = ['-pub_date'] verbose_name_plural = u'Entries' def __unicode__(self): return self.title def save(self, force_insert=False, force_update=False): self.body_html = markdown(self.body) self.excerpt_html = markdown(self.excerpt) super(Entry, self).save(force_insert, force_update) @models.permalink def get_absolute_url(self): return ('blog_entry_detail', (), { 'year': self.pub_date.strftime("%Y"), 'month': self.pub_date.strftime("%b").lower(), 'day': self.pub_date.strftime("%d"), 'slug': self.slug }) register(Entry, tag_descriptor_attr='etags')
def update_emotion_number(self): # 감정 개수 업데이트 emotion_list = ContentsEmotion.objects.filter( contents_id=self.id).values_list('name', flat=True) # emotion_number_list = Counter(emotion_list) self.like_number = emotion_number_list['1'] self.dislike_number = emotion_number_list['2'] self.surprise_number = emotion_number_list['3'] self.angry_number = emotion_number_list['4'] self.laugh_number = emotion_number_list['5'] self.sad_number = emotion_number_list['6'] self.save() register(Contents) class Congressman(models.Model): # 국회의원 모델 name = models.CharField(max_length=32) #국회의원 이름 profile_image_path = models.CharField(max_length=512, null=True, blank=True) # 프로필 사진 저장 경로 description = models.TextField(max_length=512, null=True, blank=True) # 추가 정보 party = models.CharField(max_length=32, null=True, blank=True) # 정당 constituency = models.CharField(max_length=32, null=True, blank=True) # 선거구 email = models.CharField(max_length=64, null=True, blank=True) # 이메일 주소 updated_at = models.DateTimeField(auto_now=True, null=True,
return "/edit/list/%i/" % self.id def get_delete_url(self): return "/delete/list/%i/" % self.id def get_add_url(self): return "/add/list/" class ListDetail(models.Model): list = models.ForeignKey(List, related_name="list_details") book = models.ForeignKey(Book) # ************************************************************** # # *********************** series data ************************** # # ************************************************************** # class Series(models.Model): name = models.CharField(max_length=200) count = models.IntegerField() def __unicode__(self): return self.name class SeriesDetail(models.Model): series = models.ForeignKey(Series) book = models.ForeignKey(Book) sequence = models.IntegerField() def __unicode__(self): return u"%s - %s, %s of %s" % (self.series, self.book, self.sequence, self.series.count) register(Book)
from django.db import models from django.contrib.auth.models import User from django.utils import timezone from tagging.registry import register from star_ratings.models import Rating from django.contrib.contenttypes.fields import GenericRelation class Post(models.Model): user = models.ForeignKey(User, on_delete=models.CASCADE) title = models.CharField(max_length=100) date_published = models.DateTimeField(default=timezone.now()) description = models.TextField(blank=True) text = models.TextField(blank=True) text_rendered = models.TextField(blank=True) media_url = models.CharField(max_length=200, blank=True) template_name = models.CharField(max_length=50, blank=True) ratings = GenericRelation(Rating, related_query_name='foos') def avg_rating(self): return self.ratings.all()[0].average if self.ratings.all().exists() else 0 register(Post)
def group_enabled(self): return self.group_config != "~" @property def point_list(self): return list(map(int, list(filter(lambda x: x, self.points.split( ','))))) # point list should be as long as case list @property def sample_display(self): return [ get_input_and_output_for_case(case) for case in self.sample_list ] register(Problem) class ProblemRewardStatus(models.Model): user = models.ForeignKey(User) problem = models.ForeignKey(Problem) class Meta: unique_together = ('user', 'problem') class SpecialProgram(models.Model): CATEGORIES = ((x, x) for x in ('checker', 'generator', 'interactor', 'validator'))
from tagging.registry import register # Create your models here. class FlashCard(models.Model): title = models.CharField(max_length=100) frontface = models.TextField() backface = models.TextField() created_date = models.DateTimeField(default=timezone.now) activated = models.BooleanField(blank=True, null=True) owner = models.ForeignKey('auth.User', on_delete='CASCADE', default=None) know_level = models.IntegerField( default=1, validators=[MaxValueValidator(100), MinValueValidator(1)]) def activate_card(self): self.activated = True def deactivate_card(self): self.activated = False def get_absolute_url(self): return reverse("card_detail", kwargs={'pk': self.pk}) def __str__(self): return self.title register(FlashCard)
charities = models.ManyToManyField(Charity) media = GenericRelation(Medium) def __str__(self): return '{} <{}>'.format(self.type.title(), self.title) @property def similar_donors(self): return self.get_similar_donors(2) def get_similar_donors(self, count): return TaggedItem.objects.get_related( self, Donor.objects.prefetch_related('media'), count) register(Donor) class Product(ModelTagnamesMixin, models.Model): title = models.CharField(unique=True, max_length=200) description = models.TextField() charge_tax = models.BooleanField(default=False) requires_shipping = models.BooleanField(default=False) weight_unit = models.CharField(max_length=10, choices=PRODUCT_WEIGHT_UNIT_CHOICES, default=PRODUCT_WEIGHT_UNIT_KG) weight = models.FloatField(default=0) hs_tariff_code = models.CharField(max_length=50, null=True, default=None) donor = models.ForeignKey(Donor, null=True, on_delete=models.SET_NULL) media = GenericRelation(Medium)
pass return None def get_previous_episode_in_program(self): if self.program: num = self.number - 1 try: return Episode.published.get( program=self.program, number=num, ) except Episode.DoesNotExist: pass return None def get_number(self): return u"{} #{:01d}".format( self.program, self.number) if self.program and self.number else u"" @staticmethod def autocomplete_search_fields(): return ( "id__iexact", "title__icontains", ) register(Program) register(Episode) register(Playlist)
last_num = dindic.warning_words.weigth last_word = dindic.warning_words.name return last_word def __str__(self): return self.comercial_name class Meta: verbose_name = _('Sustance') verbose_name_plural = _('Sustances') permissions = ( ("view_sustance", _("Can see available Sustance")), ) register(Substance) # build information class BuilderInformation(models.Model): name = models.CharField(max_length=150, verbose_name=_("Name")) phone = models.TextField(max_length=15, verbose_name=_("Phone")) address = models.TextField(max_length=100, verbose_name=_("Address")) def __str__(self): return self.name class Meta: verbose_name = _('Builder Information') verbose_name_plural = _('Information of Builders') permissions = (
""" note = models.ForeignKey(Note, on_delete=models.CASCADE, related_name='references') reference_url = models.URLField() reference_desc = models.TextField(max_length=255, blank=True) def __str__(self): return self.reference_url class NoteMetaData(models.Model): """ Model to store meta data for a Note. `note` is the created Note and `cloned_note` is the Note in which the new Note is cloned from. """ note = models.OneToOneField(Note, on_delete=models.CASCADE, related_name='meta_data') cloned_note = models.ForeignKey(Note, on_delete=models.SET_NULL, related_name='clones', null=True, blank=True) num_views = models.PositiveIntegerField(default=0) num_clones = models.PositiveIntegerField(default=0) # Register Note model for tagging register(Note)
def save(self, force_insert=False, force_update=False): self.body_html = markdown(self.body) super(Art, self).save(force_insert, force_update) def low_res_image_tag(self): return markdown('<img src="/%s/%s/%s" width="30%" height="30%" />' % (self.art_type, "low", self.image_lowres)) def high_res_image_tag(self): return markdown('<img src="/%s/%s/%s" width="70%" height="70%" />' % (self.art_type, "high", self.image_highres)) @models.permalink def get_absolute_url(self): return ('art_detail_page', (), { 'slug': self.slug }) register(Art, tag_descriptor_attr='atags') class Art_Category(models.Model): """ Class defining art types """ category = models.CharField(max_length=100, help_text=u'Max 100 characters') class Meta: verbose_name = "Art Category" verbose_name_plural = "Art Categories" def __unicode__(self): return self.category
Set the default season start to what's in the settings. ''' return settings.DEFAULT_SEASON_START # Models for users and relations to tags class UserProfile(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE) season_start = models.DateField(default=_default_season_start) @receiver(post_save, sender=User) def create_user_profile(sender, instance, created, **kwargs): if created: UserProfile.objects.create(user=instance) @receiver(post_save, sender=User) def save_user_profile(sender, instance, **kwargs): instance.userprofile.save() class UserTeam(models.Model): team = models.OneToOneField(Tag) owner = models.OneToOneField(UserProfile) is_closed = models.BooleanField(default=False) # register the class for tagging register(UserProfile)