def do_enable_voting_on(sender, **kwargs):
from jmbo import models
secretballot.enable_voting_on(
models.ModelBase,
manager_name="secretballot_objects",
total_name="secretballot_added_vote_total"
)
def setUp(self):
secretballot.enable_voting_on(User)
self.user = User.objects.create_user(
'john',
'*****@*****.**',
'password'
)
self.client = Client()
from django.db import models
import secretballot
class Quote(models.Model):
body = models.TextField()
channel = models.CharField(max_length=32)
username = models.CharField(max_length=32)
ip = models.GenericIPAddressField(editable=False)
timestamp = models.DateTimeField(auto_now_add=True, editable=False)
secretballot.enable_voting_on(Quote)
@receiver(post_save, sender=Item)
def update_cls_score(instance, **kwargs):
if not instance._disable_signals:
try:
item = ItemClsCheck.objects.get(item=instance)
async(item.check_cls, False)
except (ObjectDoesNotExist, ItemClsCheck.DoesNotExist):
item = ItemClsCheck(item=instance)
item.save()
async(item.check_cls, True)
@receiver(post_save, sender=Item)
def run_remdow(instance, **kwargs):
if not instance._disable_signals:
description = instance.description
if description is None:
description = ''
instance.description = \
remdow_lazy_img(
remdow_img_responsive(
remdow_img_center(
remdow_img_local(description))))
instance.save_without_signals()
if likes_enable():
import secretballot
secretballot.enable_voting_on(Item)
likes = models.PositiveIntegerField(default=0)
updated = models.DateTimeField(auto_now=True, auto_now_add=False)
timestamp = models.DateTimeField(auto_now=False, auto_now_add=True)
@property
def total_likes(self):
return self.likes.count()
def __str__(self):
return '%s, %s' % (self.user.username, self.testimonies.testimony)
def __unicode__(self):
return '%s, %s' % (self.user.username, self.testimonies.testimony)
secretballot.enable_voting_on(Testimonies)
'''
class UserFollowers(models.Model):
user = models.ForeignKey(User, unique=True)
date = models.DateTimeField(auto_now_add=True)
count = models.IntegerField(default=1)
followers = models.ManyToManyField(User, related_name='followers')
def __str__(self):
return '%s, %s' % (self.user, self.count)
def __unicode__(self):
return '%s, %s' % (self.user, self.count)
'''
name = models.CharField(max_length=100)
description = models.CharField(max_length=400)
item = models.ForeignKey(Item)
def __unicode__(self):
return self.name
def total_votes(self):
return Annotation.objects.get(id=self.id).vote_total
def upvotes(self):
return Annotation.objects.get(id=self.id).total_upvotes
def downvotes(self):
return Annotation.objects.get(id=self.id).total_downvotes
def to_dict(self):
return {"name": self.name, "description": self.description, "type": self.type,
"id": self.id, "vote_total": self.total_votes(), "total_upvotes": self.upvotes(),
"total_downvotes": self.downvotes()}
class Comment(models.Model):
painting = models.ForeignKey(Painting)
name = models.CharField(max_length=100)
content = models.CharField(max_length=400)
def to_dict(self):
return {"name": self.name, "content": self.content, "id": self.id}
secretballot.enable_voting_on(Annotation)
def setUpClass(cls):
secretballot.enable_voting_on(TestModel)
cls.client = Client()
cls.obj1 = TestModel.objects.create()
cls.obj2 = TestModel.objects.create()
# Create your models here.
class Category(models.Model):
name = models.CharField(max_length=128, unique=True)
views = models.IntegerField(default=0)
likes = models.IntegerField(default=0)
def __unicode__(self):
return self.name
class Page(models.Model):
category = models.ForeignKey(Category)
title = models.CharField(max_length=128)
url = models.URLField()
views = models.IntegerField(default=0)
def __unicode__(self):
return self.title
class UserProfile(models.Model):
# This line is required. Links UserProfile to a User model instance.
user = models.OneToOneField(User)
# The additional attributes we wish to include.
website = models.URLField(blank=True)
picture = models.ImageField(upload_to='profile_images', blank=True)
def __unicode__(self):
return self.user.username
secretballot.enable_voting_on(Category)
@property
def posts_set(self):
return self.post_meshblock_fk.all()
@property
def score_cell(self):
"""
Determine the 'score' of the cell for visualisation purposes
-1: 100% downvotes
0: equal score
+1: 100% upvotes
"""
if self.vote_total == 0:
return 0
return (self.total_upvotes - self.total_downvotes) /\
(self.total_upvotes + self.total_downvotes)
def __unicode__(self):
if self.description is not None:
return self.description
return str(self.id)
def __str__(self):
if self.description is not None:
return self.description
return str(self.id)
secretballot.enable_voting_on(Meshblock)
# NB: at this stage voting only works on parent posts, modify voting methods in views.py to modify
help_text="A name used to identify the relation. Must be of the form \
blog_galleries. Once set it is typically never changed.")
class Meta:
unique_together = (('source_content_type', 'source_object_id',
'target_content_type', 'target_object_id',
'name'), )
def set_managers(sender, **kwargs):
"""
Make sure all classes have the appropriate managers.
"""
cls = sender
if issubclass(cls, ModelBase):
cls.add_to_class('permitted', PermittedManager())
signals.class_prepared.connect(set_managers)
# add natural_key to Django's Site model and manager
Site.add_to_class('natural_key', lambda self: (self.domain, self.name))
SiteManager.get_by_natural_key = lambda self, domain, name: self.get(
domain=domain, name=name)
# enable voting for ModelBase, but specify a different total name
# so ModelBase's vote_total method is not overwritten
secretballot.enable_voting_on(ModelBase,
total_name="secretballot_added_vote_total")
def ready(self):
blog_model = apps.get_model('ahmedjazzarcom', 'Blog')
blog_view_model = apps.get_model('ahmedjazzarcom', 'BlogView')
secretballot.enable_voting_on(blog_model)
secretballot.enable_voting_on(blog_view_model)
avatar = models.URLField(blank=True, default=get_avatar)
desc = models.TextField(blank=True, default=settings.DESC)
@property
def slug(self):
return self.username
class Sharable(models.Model):
class Meta:
ordering = ["pub_date"]
author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
pub_date = models.DateTimeField(auto_now=True)
def __str__(self):
return f"{self.__class__.__name__}@{self.author}"
secretballot.enable_voting_on(Sharable)
class Post(Sharable):
text = models.TextField(max_length=settings.MAX_POST_LENGTH)
class Snippet(Sharable):
text = models.TextField()
class Link(Sharable):
url = models.URLField()
@receiver(post_save, sender=Item)
def update_cls_score(instance, **kwargs):
if not instance._disable_signals:
try:
item = ItemClsCheck.objects.get(item=instance)
async (item.check_cls, False)
except (ObjectDoesNotExist, ItemClsCheck.DoesNotExist):
item = ItemClsCheck(item=instance)
item.save()
async (item.check_cls, True)
@receiver(post_save, sender=Item)
def run_remdow(instance, **kwargs):
if not instance._disable_signals:
description = instance.description
if description is None:
description = ''
instance.description = \
remdow_lazy_img(
remdow_img_responsive(
remdow_img_center(
remdow_img_local(description))))
instance.save_without_signals()
if likes_enable():
import secretballot
secretballot.enable_voting_on(Item)
author = models.ForeignKey(settings.AUTH_USER_MODEL)
status = models.IntegerField(choices=STATUS, default=STATUS.draft)
tags = TaggableManager(blank=True)
objects = ArticleQuerySet().as_manager()
class Meta:
app_label = "knowledgebase"
verbose_name = _("Article")
verbose_name_plural = _("Articles")
def save(self, *args, **kwargs):
# Newly created object, so set slug
if not self.pk:
if not self.slug:
self.slug = custom_slugify(self.title)
super(Article, self).save(*args, **kwargs)
def get_absolute_url(self):
return reverse("knowledgebase:article_detail", kwargs={"slug": self.slug})
def __str__(self):
return self.title
enable_voting_on(Article)
reversion.register(Article)
created_date = models.DateTimeField(
default=timezone.now)
published_date = models.DateTimeField(
blank=True, null=True)
def publish(self):
self.published_date = timezone.now()
self.save()
def approved_comments(self):
return self.comments.filter(approved_comment=True)
def __str__(self):
return self.title
secretballot.enable_voting_on(Post)
class Comment(models.Model):
post = models.ForeignKey('melaongo.Post', related_name='comments')
author = models.CharField(max_length=200)
text = models.TextField()
created_date = models.DateTimeField(default=timezone.now)
approved_comment = models.BooleanField(default=False)
def approve(self):
self.approved_comment = True
self.save()
def __str__(self):
return self.text
@models.permalink
def get_absolute_url(self):
return ("shop_product", (), {"slug": self.slug})
def copy_default_variation(self):
"""
Copies the price and image fields from the default variation
when the product is updated via the change view.
"""
default = self.variations.get(default=True)
default.copy_price_fields_to(self)
if default.image:
self.image = default.image.file.name
self.save()
secretballot.enable_voting_on(Product)
class ProductImage(Orderable):
"""
An image for a product - a relationship is also defined with the
product's variations so that each variation can potentially have
it own image, while the relationship between the ``Product`` and
``ProductImage`` models ensures there is a single set of images
for the product.
"""
file = models.ImageField(_("Image"),
upload_to=upload_to("shop.ProductImage.file", "product"))
description = CharField(_("Description"), blank=True, max_length=100)
product = models.ForeignKey("Product", related_name="images")
comment_obj.comment = instance.comment_text
comment_obj.save()
if comment_obj not in instance.reply_comments.all():
instance.reply_comments.add(comment_obj)
@receiver(post_save, sender=Comment)
def realtime_comment_classifier(sender, instance, created, **kwargs):
"""
Classifies a comment after it has been created.
This behaviour is configurable by the REALTIME_CLASSIFICATION MODERATOR,
default behaviour is to classify(True).
"""
# Only classify if newly created.
if created:
moderator_settings = getattr(settings, 'MODERATOR', None)
if moderator_settings:
if 'REALTIME_CLASSIFICATION' in moderator_settings:
if not moderator_settings['REALTIME_CLASSIFICATION']:
return
# Only classify if not a reply comment.
if not getattr(instance, 'is_reply_comment', False):
from moderator.utils import classify_comment
classify_comment(instance)
# Enable voting on Comments (for negative votes/reporting abuse).
secretballot.enable_voting_on(Comment)
def setUpClass(cls):
secretballot.enable_voting_on(TestModel)
cls.client = Client()
cls.obj1 = TestModel.objects.create()
cls.obj2 = TestModel.objects.create()
return self.title
class Comments(models.Model):
challenge = models.ForeignKey(Challenge)
parent = models.ForeignKey('self', blank = True, null = True)
valid_video = models.BooleanField(default = False)
link = models.CharField(_('Video Link'), max_length=300, help_text=_('Video link'))
desc = models.TextField(_('Description'), help_text=_('Description'))
def __unicode__( self ):
return str(self.challenge) + ' ' + self.desc
secretballot.enable_voting_on(Challenge)
secretballot.enable_voting_on(Comments)
'''
class Address(models.Model):
address = models.CharField(_('Address'), max_length=300, help_text=_('Address'))
city = models.CharField(_('City'), max_length=100, help_text=_('City'))
completed = models.BooleanField(default = False)
lat = models.FloatField(_('Latitude'), help_text=_('Latitude'))
lng = models.FloatField(_('Longitude'), help_text=_('Longitude'))
score_title = models.CharField(_('Score Title'), max_length=300, help_text=_('Score Title'))
score_desc = models.CharField(_('Score Description'), max_length=300, help_text=_('Score Description'))
def setUp(self):
secretballot.enable_voting_on(User)
self.user = User.objects.create_user('john', '*****@*****.**',
'password')
self.client = Client()
def __unicode__(self):
return self.name
post_save.connect(add_to_preview,sender=User)
post_save.connect(add_content,sender=Tutorial)
post_save.connect(add_content,sender=Snippet)
post_save.connect(add_content,sender=Wiki)
post_save.connect(add_content,sender=Announcement)
post_save.connect(add_content,sender=News)
post_save.connect(add_content,sender=Blog)
post_save.connect(add_content,sender=Event)
post_save.connect(add_content,sender=EducationalResource)
post_save.connect(add_content,sender=Package)
secretballot.enable_voting_on(Tutorial)
secretballot.enable_voting_on(Snippet)
secretballot.enable_voting_on(Wiki)
secretballot.enable_voting_on(Announcement)
secretballot.enable_voting_on(News)
secretballot.enable_voting_on(Blog)
secretballot.enable_voting_on(Event)
secretballot.enable_voting_on(EducationalResource)
secretballot.enable_voting_on(Package)
watson.register(Tutorial)
watson.register(Snippet)
watson.register(Wiki)
watson.register(Announcement)
watson.register(News)
watson.register(Blog)
from datetime import date
born = self.user.profile.date_of_birth
today = date.today()
return today.year - born.year - ((today.month, today.day) <
(born.month, born.day))
def content_type_id(self):
return ContentType.objects.get_for_model(self).id
@property
def lat_long(self):
latitude = 0
longitude = 0
if self.location is not None:
latitude = self.location.x
longitude = self.location.y
return {'latitude': latitude, 'longitude': longitude}
@staticmethod
def get_location(latitude, longitude):
from django.contrib.gis.geos import fromstr
return fromstr("POINT({0} {1})".format(latitude, longitude), srid=4326)
enable_voting_on(Post)
enable_voting_on(UserProfile)
# on Initialization, check if user exists or create a new instance
User.profile = property(lambda u: UserProfile.objects.get_or_create(user=u)[0])
description = models.TextField(blank=True)
text_color = ColorField(default="#FFFFFF")
created = models.DateTimeField(auto_now_add=True, auto_now=False)
start_date_time = models.DateTimeField(default=timezone.now) #start time
end_date_time = models.DateTimeField(blank=True,
null=True,
help_text="Optional End Date")
def __unicode__(self):
return self.description
def get_image_url(self):
return "%s/%s" % (MEDIA_URL, self.image)
secretballot.enable_voting_on(Tutorial)
secretballot.enable_voting_on(Snippet)
secretballot.enable_voting_on(Wiki)
secretballot.enable_voting_on(Announcement)
secretballot.enable_voting_on(News)
secretballot.enable_voting_on(Blog)
secretballot.enable_voting_on(Event)
secretballot.enable_voting_on(EducationalResource)
secretballot.enable_voting_on(Package)
watson.register(Tutorial)
watson.register(Snippet)
watson.register(Wiki)
watson.register(Announcement)
watson.register(News)
watson.register(Blog)
"""
Classifies a comment after it has been created.
This behaviour is configurable by the REALTIME_CLASSIFICATION MODERATOR,
default behaviour is to classify(True).
"""
# Only classify if newly created.
if created:
moderator_settings = getattr(settings, 'MODERATOR', None)
if moderator_settings:
if 'REALTIME_CLASSIFICATION' in moderator_settings:
if not moderator_settings['REALTIME_CLASSIFICATION']:
return
# Only classify if not a reply comment.
if not getattr(instance, 'is_reply_comment', False):
from moderator.utils import classify_comment
classify_comment(instance)
@receiver(object_liked)
def flag_reported_comments(instance, request, **kwargs):
if not getattr(instance, 'is_reply_comment', False) and\
isinstance(instance, Comment):
from moderator.tasks import flag_reported_comments_task
flag_reported_comments_task.delay(instance)
# Enable voting on Comments (for negative votes/reporting abuse).
secretballot.enable_voting_on(Comment, 'objects_with_votes')
class Question(models.Model):
question = models.CharField(max_length=200)
slug = models.SlugField(max_length=200, default="")
details = models.CharField(max_length=500)
pub_date = models.DateTimeField('date published', auto_now_add=True)
views = models.IntegerField(default=0)
answered = models.BooleanField(default=False)
rating = models.IntegerField(default=0)
section = models.CharField(max_length=200)
author = models.ForeignKey(settings.AUTH_USER_MODEL)
tags = TaggableManager()
def save(self, *args, **kwargs):
self.slug = slugify(self.question)
super(Question, self).save(*args, **kwargs)
action.send(self.author, verb='asked a question')
for tag in self.tags.all():
action.send(tag, verb='new question')
secretballot.enable_voting_on(Question)
library.register(Question)
library.register(MyUser)
#TODO: this will change in 1.7: https://django-activity-stream.readthedocs.org/en/latest/configuration.html
registry.register(MyUser)
registry.register(Question)
registry.register(Tag)
class Meta:
verbose_name = _("Image override")
verbose_name_plural = _("Image overrides")
def __unicode__(self):
return _("Override for %s") % self.photosize.name
def set_managers(sender, **kwargs):
"""
Make sure all classes have the appropriate managers.
"""
cls = sender
if issubclass(cls, ModelBase):
cls.add_to_class('permitted', PermittedManager())
signals.class_prepared.connect(set_managers)
# add natural_key to Django's Site model and manager
Site.add_to_class('natural_key', lambda self: (self.domain, self.name))
SiteManager.get_by_natural_key = lambda self, domain, name: self.get(domain=domain, name=name)
# enable voting for ModelBase, but specify a different total name
# so ModelBase's vote_total method is not overwritten
secretballot.enable_voting_on(
ModelBase,
manager_name='secretballot_objects',
total_name='secretballot_added_vote_total'
)
class Meta:
db_table = u'pa_legis_votes'
class OfficialOffices(models.Model):
office_legid = models.TextField(blank=True)
pk = models.IntegerField(primary_key=True)
address = models.TextField(blank=True)
phone = models.TextField(blank=True)
name = models.TextField(blank=True)
class Meta:
db_table = u'official_offices'
secretballot.enable_voting_on(Officials)
secretballot.enable_voting_on(OfficialTweets)
secretballot.enable_voting_on(PaLegisVotes)
secretballot.enable_voting_on(FbData)
secretballot.enable_voting_on(OfficialPressReleases)
####################################
## Utility Functions for Views.py ##
####################################
## Filters Press Releases that have incorrect dates ##
## and incorrect titles
def filter_press_releases(press_releases):
relevant_prs = []
MODERATION_CHOICES = ((NOT_REVIEWED, "Not Reviewed (Hidden)"),
(AZURE_APPROVE, "Azure Approved"),
(AZURE_BLOCK, "Azure Blocked (Hidden)"),
(MANUAL_APPROVE, "Manually Approved"),
(MANUAL_BLOCK, "Manually Blocked (Hidden)"),
(DOWNVOTED, "Downvoted (Hidden)"))
id = models.AutoField(primary_key=True)
body = models.CharField(max_length=POST_BODY_LENGTH)
pub_date = models.DateTimeField('Time Posted', default=timezone.now)
post_location = models.PointField(null=True, blank=True)
moderation = models.CharField(
max_length=2,
choices=MODERATION_CHOICES,
default=NOT_REVIEWED,
)
post_meshblock = models.ForeignKey(Meshblock,
on_delete=CASCADE,
null=True,
blank=True,
related_name='post_meshblock_fk')
def __str__(self):
return self.body
# Enable upvotes and downvotes
secretballot.enable_voting_on(PostAbstract)
return Annotation.objects.get(id=self.id).vote_total
def upvotes(self):
return Annotation.objects.get(id=self.id).total_upvotes
def downvotes(self):
return Annotation.objects.get(id=self.id).total_downvotes
def to_dict(self):
return {
"name": self.name,
"description": self.description,
"type": self.type,
"id": self.id,
"vote_total": self.total_votes(),
"total_upvotes": self.upvotes(),
"total_downvotes": self.downvotes()
}
class Comment(models.Model):
painting = models.ForeignKey(Painting)
name = models.CharField(max_length=100)
content = models.CharField(max_length=400)
def to_dict(self):
return {"name": self.name, "content": self.content, "id": self.id}
secretballot.enable_voting_on(Annotation)
@property #Create Comments!
def get_content_type(self):
instance = self
content_type = ContentType.objects.get_for_model(instance.__class__)
return content_type
'''
#model直接生成markdown.body，本博中采用另一种markdown.extensions在views中生成。
def get_markdown(self):
content = self.body
markdown_text = markdown(content)
return mark_safe(markdown_text)
'''
secretballot.enable_voting_on(Article)
#attach the voting helpers to a particular model it is enough to call
#secretballot.enable_voting_on passing the model class.
def create_slug(instance, new_slug=None):
slug = slugify(instance.title)
if new_slug is not None:
slug = new_slug
qs = Article.objects.filter(slug=slug).order_by("-id")
exists = qs.exists()
if exists:
new_slug = "%s-%s" %(slug, qs.first().id)
return create_slug(instance, new_slug=new_slug)
def vote_total(self):
"""
Calculates vote total as total_upvotes - total_downvotes. We are adding a method here instead of relying on django-secretballot's addition since that doesn't work for subclasses.
"""
modelbase_obj = self.modelbase_obj
return modelbase_obj.votes.filter(vote=+1).count() - modelbase_obj.votes.filter(vote=-1).count()
@property
def comment_count(self):
"""
Counts total number of comments on ModelBase object.
"""
modelbase_obj = self.modelbase_obj
t = Template("{% load comments %}{% get_comment_count for object as count %}{{ count }}")
return int(t.render(template.Context({'object': modelbase_obj})))
def set_managers(sender, **kwargs):
"""
Make sure all classes have the appropriate managers
"""
cls = sender
if issubclass(cls, ModelBase):
cls.add_to_class('permitted', PermittedManager())
signals.class_prepared.connect(set_managers)
# enable voting for ModelBase, but specify a different total name
# so ModelBase's vote_total method is not overwritten
secretballot.enable_voting_on(ModelBase, total_name="secretballot_added_vote_total")
class UserAgent(models.Model):
"""
Records hits on a user agent.
"""
user_agent = models.CharField(max_length=256, null=True, blank=True)
hits = models.IntegerField(default=0)
@receiver(m2m_changed)
def check_slug(sender, **kwargs):
"""Slug must be unique per site"""
instance = kwargs['instance']
if (kwargs['action'] == 'post_add') \
and sender.__name__.endswith('_sites') \
and isinstance(instance, (Navbar, Menu, Listing, Page)):
for site in instance.sites.all():
q = instance.__class__.objects.filter(slug=instance.slug, sites=site).exclude(id=instance.id)
if q.exists():
raise RuntimeError("The slug %s is already in use for site %s by %s" % (instance.slug, site.domain, q[0].title))
# Custom fields to be handled by south
add_introspection_rules([], ["^ckeditor\.fields\.RichTextField"])
# enable voting for FoundryComment, but specify a different total name
# so FoundryComment's vote_total method is not overwritten
secretballot.enable_voting_on(
FoundryComment,
total_name="secretballot_added_vote_total"
)
company_name = models.CharField(max_length=200, null=True, blank=True)
webpage = models.CharField(max_length=400, null=True, blank=True)
country_code = models.CharField(max_length=50, null=True, blank=True)
phone = models.CharField(max_length=25, null=True, blank=True)
extension = models.CharField(max_length=25, null=True, blank=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
photo = models.ForeignKey(VendorPhoto, blank=True, null=True, on_delete=models.SET_NULL)
address = models.ForeignKey(Address, null=True, blank=True)
description = models.CharField(max_length=900)
is_active = models.BooleanField(default=False)
facebook_url = models.CharField(max_length=400, null=True, blank=True)
twitter_url = models.CharField(max_length=400, null=True, blank=True)
preferred_email = models.CharField(max_length=400, null=True, blank=True)
secretballot.enable_voting_on(Vendor)
class Category(models.Model):
name = models.CharField(max_length=100, db_index=True)
slug = models.SlugField(max_length=100, db_index=True)
def __unicode__(self):
return '%s' % self.name
class ProductPhoto(models.Model):
image = models.ImageField(storage = fs, upload_to='products', blank=True)
"""
Here we scale the image and save it to the database
content = models.TextField()
created = models.DateTimeField(editable=False)
person = models.ForeignKey(Person, related_name='answers')
def save(self, *args, **kwargs):
if not self.id:
self.created = datetime.datetime.today()
candidate = CandidatePerson.objects.get(id=self.person.id)
totalQuestionsAnswred = candidate.person.answers.count()
if totalQuestionsAnswred < 5:
candidate.ranking = 0
elif totalQuestionsAnswred >= 5 and totalQuestionsAnswred < 10:
candidate.ranking = 1
elif totalQuestionsAnswred >= 10 and totalQuestionsAnswred < 15:
candidate.ranking = 2
elif totalQuestionsAnswred >= 15 and totalQuestionsAnswred < 20:
candidate.ranking = 3
elif totalQuestionsAnswred >= 20 and totalQuestionsAnswred < 25:
candidate.ranking = 4
elif totalQuestionsAnswred >= 25:
candidate.ranking = 5
candidate.save()
return super(VotaInteligenteAnswer, self).save(*args, **kwargs)
# enable secretballot to models using votes
secretballot.enable_voting_on(VotaInteligenteMessage)
secretballot.enable_voting_on(VotaInteligenteAnswer)
uid = models.PositiveIntegerField(blank=True, unique=True)
term_pinyin = models.CharField(max_length=250)
created_time = models.DateTimeField(auto_now_add=True)
modified_time = models.DateTimeField(default='1984-06-04')
visit_times = models.PositiveIntegerField(default=0)
def __unicode__(self):
return self.term
class Definitions(models.Model):
Terms = models.ForeignKey(Terms, related_name='terms_definitions')
definition = models.TextField(max_length=200, blank=False)
author = models.CharField(max_length=65, blank=True)
homepage = models.URLField(max_length=200, blank=True)
author_email = models.EmailField(blank=True)
vote_rank = models.SmallIntegerField(default=0)
vote_rank2 = models.FloatField(default=0.0)
show = models.BooleanField(default=False)
uid = models.PositiveIntegerField(blank=True, unique=True)
created_time = models.DateTimeField(auto_now_add=True)
modified_time = models.DateTimeField(auto_now=True)
docfile = models.ImageField(upload_to=content_file_name, blank=True, null=True)
def __unicode__(self):
return self.definition
secretballot.enable_voting_on(Definitions)
from django.db import models
from django.utils import timezone
import secretballot
class Song(models.Model):
title = models.CharField(max_length=200)
artist = models.CharField(max_length=100)
added_date = models.DateTimeField(blank=True, null=True)
link = models.URLField(null=True)
def publish(self):
self.added_date = timezone.now()
self.save()
def __str__(self):
return self.title
secretballot.enable_voting_on(Song)
def get_absolute_url(self):
"""
return ('video_detail', (), {
'year': self.timestamp.strftime("%Y"),
'month': self.timestamp.strftime("%b"),
'day': self.timestamp.strftime("%d"),
'slug': self.slug
})
"""
pass
def save(self,*args,**kwargs):
self.slug = slugify(self.title)
super(Movie,self).save(*args,**kwargs)
secretballot.enable_voting_on(Movie)
class Like(models.Model):
user = models.ManyToManyField(
settings.AUTH_USER_MODEL,
related_name='likes'
)
movie = models.ForeignKey(
Movie,related_name='+',
verbose_name='Movie'
)
total_likes = models.IntegerField(
default=0,verbose_name='Total Likes'
)
created_at = models.DateTimeField(
auto_now_add=True
from django.db import models
import secretballot
class Link(models.Model):
url = models.URLField()
secretballot.enable_voting_on(Link)
# used for testing field renames
class WeirdLink(models.Model):
url = models.URLField()
title = models.CharField(max_length=255)
def __str__(self):
return self.title
secretballot.enable_voting_on(
WeirdLink,
votes_name='vs',
upvotes_name='total_upvs',
downvotes_name='total_downvs',
total_name='v_total',
add_vote_name='add_v',
remove_vote_name='remove_v',
)
# TODO?: base_manager?
from django.db import models
import secretballot
class Link(models.Model):
url = models.URLField()
secretballot.enable_voting_on(Link)
# used for testing field renames
class WeirdLink(models.Model):
url = models.URLField()
title = models.CharField(max_length=255)
def __str__(self):
return self.title
secretballot.enable_voting_on(WeirdLink,
votes_name='vs',
upvotes_name='total_upvs',
downvotes_name='total_downvs',
total_name='v_total',
add_vote_name='add_v',
remove_vote_name='remove_v',
)
# TODO?: base_manager?
# Used for testing custom manager_name
from django.db import models
import secretballot
class Link(models.Model):
url = models.URLField()
secretballot.enable_voting_on(Link)
# used for testing field renames
class WeirdLink(models.Model):
url = models.URLField()
secretballot.enable_voting_on(
WeirdLink,
votes_name='vs',
upvotes_name='total_upvs',
downvotes_name='total_downvs',
total_name='v_total',
add_vote_name='add_v',
remove_vote_name='remove_v',
)
# TODO?: manager name & base_manager?
def get_absolute_url(self):
return ("twit-company", (), {'slug':self.company_slug})
class Hate(models.Model):
""" The tweets that will be assigned to companies - aka the rants """
hate_company = models.ForeignKey(Company)
hate_title = models.CharField(max_length=100)
hate_entry = models.CharField(max_length=200)
hate_vote = models.IntegerField(blank=True)
created_date = models.DateTimeField(default=datetime.datetime.now)
class Meta:
verbose_name_plural = "Hates"
ordering = ['-created_date']
def __unicode__(self):
return self.hate_title
def save(self):
if not self.id:
if self.hate_vote is None:
self.hate_vote = 0
super(Hate, self).save()
@permalink
def get_absolute_url(self):
return ("twit-hate", (), {'id':self.id})
secretballot.enable_voting_on(Hate)
self.video_url = self.video_url.replace('watch?v=', 'embed/')
if 'vimeo' in self.video_url:
self.video_url = 'https://player.vimeo.com/video/' + self.video_url.split('/')[-1]
super(VideoAd, self).save(*args, **kwargs)
class ContentListImage(models.Model):
adbase = models.ForeignKey(AdBase, related_name='images')
image = models.ImageField(
verbose_name=_(u'List Image'), upload_to="content/bannerads/images"
)
main = models.NullBooleanField()
class DownloadLink(models.Model):
key = models.CharField(verbose_name=_(u'Key'), max_length=255)
filepath = models.FilePathField(verbose_name=_(u'Link Path'))
since = models.DateTimeField(verbose_name=_(u'Since'), auto_now_add=True)
url = models.URLField(verbose_name=_(u'Url Path'))
ad = models.ForeignKey(AdBase, related_name='links')
def delete(self, using=None):
import os
try:
os.remove(self.filepath)
except OSError:
pass
super(DownloadLink, self).delete(using)
secretballot.enable_voting_on(AdBase)
from django.db import models
import secretballot
class Link(models.Model):
url = models.URLField()
secretballot.enable_voting_on(Link)
# used for testing field renames
class WeirdLink(models.Model):
url = models.URLField()
secretballot.enable_voting_on(WeirdLink,
votes_name='vs',
upvotes_name='total_upvs',
downvotes_name='total_downvs',
total_name='v_total',
add_vote_name='add_v',
remove_vote_name='remove_v',
)
# TODO?: manager name & base_manager?
return self.title
@property
def comments(self):
instance = self
qs = Comment.objects.filter_by_instance(instance)
return qs
@property
def get_content_type(self):
instance = self
content_type = ContentType.objects.get_for_models(instance.__class__)
return content_type
secretballot.enable_voting_on(Article)
def create_slug(instance, new_slug=None):
slug = slugify(instance.title)
if new_slug is not None:
slug = new_slug
qs = Article.objects.filter(slug=slug).order_by("-id")
exists = qs.exists()
if exists:
new_slug = "%s-%s" % (slug, qs.first().id)
return create_slug(instance, new_slug=new_slug)
return slug
def get_upload_img_name(self, filename):
