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)
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):