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)
