def sample(self, count=None, public=True): """Return a sample of photos, ordered at random. If the 'count' is not specified, it will return a number of photos limited by the GALLERY_SAMPLE_SIZE setting. """ if not count: count = SAMPLE_SIZE if count > self.photo_count(): count = self.photo_count() if public: photo_set = self.public() else: photo_set = self.photos.all() return random.sample(set(photo_set), count) def photo_count(self, public=True): """Return a count of all the photos in this gallery.""" if public: return self.public().count() else: return self.photos.all().count() photo_count.short_description = _('count') def public(self): """Return a queryset of all the public photos in this gallery.""" return self.photos.filter(is_public=True) utils.register(Photo) #utils.register(User)
majority = models.IntegerField(max_length=3) prop_hours = models.IntegerField(max_length=3) createtime = models.DateTimeField(auto_now_add=True) updated_at = models.DateTimeField(auto_now=True) last_prop = models.DateTimeField(auto_now_add=True) def __unicode__(self): return "%s" % (self.thesis) class Meta: verbose_name_plural = "Micro-constitutions" # registers the model with follow app utils.register(MicroCons) class MicroConsModelForm(forms.ModelForm): class Meta: model = MicroCons exclude = "director" thesis = forms.CharField( label="Thesis", required="True", help_text="What's your opinion in 130 characters or less. Make it the kernel of your idea. Short and sweet.", widget=forms.Textarea(attrs={"rows": "2"}), ) majority = forms.CharField(
class Rating(models.Model): """ A rating that can be given to a piece of content. """ value = models.IntegerField(_("Value")) rating_date = models.DateTimeField(_("Rating date"), auto_now_add=True, null=True) content_type = models.ForeignKey("contenttypes.ContentType") object_pk = models.IntegerField() content_object = GenericForeignKey("content_type", "object_pk") user = models.ForeignKey(get_user_model_name(), verbose_name=_("Rater"), null=True, related_name="%(class)ss") class Meta: verbose_name = _("Rating") verbose_name_plural = _("Ratings") def save(self, *args, **kwargs): """ Validate that the rating falls between the min and max values. """ valid = map(str, settings.RATINGS_RANGE) if str(self.value) not in valid: raise ValueError("Invalid rating. %s is not in %s" % (self.value, ", ".join(valid))) super(Rating, self).save(*args, **kwargs) utils.register(Review)
from django import template from django.contrib.auth.models import User, AnonymousUser, Group from django.core.urlresolvers import reverse from django.test import TestCase, override_settings from follow import signals, utils from follow.models import Follow from follow.utils import register import follow.urls register(User) register(Group) class FollowTest(TestCase): @override_settings(ROOT_URLCONF=follow.urls) def setUp(self): self.lennon = User.objects.create(username="******") self.lennon.set_password("test") self.lennon.save() self.hendrix = User.objects.create(username="******") self.musicians = Group.objects.create() self.lennon.groups.add(self.musicians) def test_follow(self): follow = Follow.objects.create(self.lennon, self.hendrix) _, result = Follow.objects.get_or_create(self.lennon, self.hendrix) self.assertEqual(False, result)
content_type = models.ForeignKey( ContentType, verbose_name=_('content type'), related_name="content_type_set_for_%(class)s", on_delete=models.CASCADE) object_id = models.TextField(_('object ID')) content_object = GenericForeignKey() class Meta: verbose_name = _('objecttask') verbose_name_plural = _('objecttasks') def __str__(self): return "%s for %s" % (str(self.task), str(self.content_object)) from follow import utils from reversion import revisions as reversion reversion.register(Task) utils.register(User) utils.register(Project) utils.register(Milestone) utils.register(Task) # IMPORTANT LINE, really leave it there! from django_project import handlers
self.email = email def __unicode__(self): return "%s <%s>" % (self.name, self.email) def __str__(self): return self.__unicode__() class NottyResponse(HttpResponse): notty = "jQuery.notty({ content : \"%s\", timeout: 5000 }); " def __init__(self, data, extra=None): data = self.notty % (data) if extra: data = "%s %s" % (data, extra) HttpResponse.__init__( self, data, mimetype='application/json' ) class JsonpResponse(HttpResponse): def __init__(self, data): json = simplejson.dumps(data) jsonp = "jQuery(%s)" % (json) HttpResponse.__init__( self, jsonp, mimetype='application/json' ) utils.register(User) import signals import feeds
#create image thumbnail print 'model - starting thumbnail' super(Pin, self).save() temp_thumb = NamedTemporaryFile() size = image.size prop = 200.0 / float(image.size[0]) size = (int(prop*float(image.size[0])), int(prop*float(image.size[1]))) image.thumbnail(size, Image.ANTIALIAS) image.save(temp_thumb.name, 'JPEG') self.thumbnail.save(''.join([hash_name, '.jpg']), File(temp_thumb)) print 'model - delete_uplaod called' if self.uImage: delete_upload(None, self.uImage) print 'model - thumbnail complete' if not self.srcUrl: print 'if not srcUrl' print self.image.name print self.image.url print self.srcUrl self.srcUrl = settings.MEDIA_URL+self.image.name #TODO: srcUrl gets http://domain but imgUrl does not? self.imgUrl = settings.MEDIA_URL+self.image.name super(Pin, self).save(*args, **kwargs) class Meta: ordering = ['-id'] utils.register(Pin, 'favorite', 'f_pin') utils.register(User, 'folowing', 'f_user')
from django.db.models.signals import pre_save, post_save, pre_delete from django.template.defaultfilters import slugify from django.utils.translation import ugettext_lazy as _ from django.contrib.auth.models import User, Permission from django.contrib.contenttypes.models import ContentType from idios.models import ProfileBase from follow.utils import register from taggit.managers import TaggableManager from items.models import Content from profiles.settings import POINTS_TABLE_RATED, POINTS_TABLE_RATING from utils.vote import Vote register(User) class ProfileManager(models.Manager): def get_all_names(self): qs = self.order_by("name").distinct("name") return json.dumps(filter(None, qs.values_list("name", flat=True))) class Profile(ProfileBase): name = models.CharField(_("name"), max_length=30, null=True, blank=True) slug = models.SlugField(verbose_name=_('slug'), editable=False) about = models.TextField(_("about"), null=True, blank=True) location = models.CharField(_("location"), max_length=40, null=True,
target=instance.list) @receiver(post_save, sender=Notification) def send_notification_email(sender, instance, created, **kwargs): content = render_to_string('notifications/notice.txt', {'notice': instance}) site = Site.objects.get_current() site_name = site.name send_mail(_('[%(site_name)s] You have new notification messages') % {'site_name': site_name}, content, settings.DEFAULT_FROM_EMAIL, [instance.recipient.email], fail_silently=False) @receiver(post_save, sender=Feedback) def send_feedback_notfication(sender, instance, created, **kwargs): if created: log(user=instance.user, action="FEEDBACK", extra={}) admin_user = User.objects.get(id=settings.ADMIN_USER_ID) notify.send(instance.user, recipient=admin_user, verb=_('feedback'), action_object=instance, description=instance.text) utils.register(User) utils.register(List)
from django import template from django.contrib.auth.models import User, AnonymousUser, Group from django.core.urlresolvers import reverse from django.test import TestCase, override_settings from follow import signals, utils from follow.models import Follow from follow.utils import register import follow.urls register(User) register(Group) class FollowTest(TestCase): @override_settings(ROOT_URLCONF=follow.urls) def setUp(self): self.lennon = User.objects.create(username='******') self.lennon.set_password('test') self.lennon.save() self.hendrix = User.objects.create(username='******') self.musicians = Group.objects.create() self.lennon.groups.add(self.musicians) def test_follow(self): follow = Follow.objects.create(self.lennon, self.hendrix) _, result = Follow.objects.get_or_create(self.lennon, self.hendrix) self.assertEqual(False, result)
image = image.convert("RGB") image.save(temp_img.name, 'JPEG') self.image.save(''.join([hash_name, '.jpg']), File(temp_img)) #create image thumbnail print 'model - starting thumbnail' temp_thumb = NamedTemporaryFile() size = image.size prop = 200.0 / float(image.size[0]) size = (int(prop * float(image.size[0])), int(prop * float(image.size[1]))) image.thumbnail(size, Image.ANTIALIAS) image.save(temp_thumb.name, 'JPEG') self.thumbnail.save(''.join([hash_name, '.jpg']), File(temp_thumb)) #super(Pin, self).save() if self.uImage: print 'model - delete_uplaod called' delete_upload(None, self.uImage) media_url = settings.MEDIA_URL if not self.srcUrl: print 'model - if not srcUrl' self.srcUrl = media_url + self.image.name #always link to our saved image to prevent linking back to dead images. self.imgUrl = media_url + self.image.name super(Pin, self).save(*args, **kwargs) class Meta: ordering = ['-id'] utils.register(Pin, 'favorite', 'f_pin') utils.register(User, 'folowing', 'f_user')
warn("blog_post.category_list in templates is deprecated" "use blog_post.categories.all which are prefetched") return getattr(self, "_categories", self.categories.all()) def keyword_list(self): from warnings import warn warn("blog_post.keyword_list in templates is deprecated" "use the keywords_for template tag, as keywords are prefetched") try: return self._keywords except AttributeError: keywords = [k.keyword for k in self.keywords.all()] setattr(self, "_keywords", keywords) return self._keywords utils.register(BlogPost) class BlogCategory(Slugged): """ A category for grouping blog posts into a series. """ parent_category = models.ManyToManyField("BlogParentCategory", null=True, related_name="blog_parent_category") class Meta: verbose_name = _("Blog Category") verbose_name_plural = _("Blog Categories") ordering = ("title",) @models.permalink def get_absolute_url(self): url_name = "get_vendors"
def get_node(self): if self._node is None: self._node = sync_products(Item, self) return self._node def set_node(self, value): self._node = value def del_node(self): del self._node node = property(get_node, set_node, del_node, "Node property") register(Item) class Content(VoteModel): author = models.ForeignKey(User, verbose_name=_("author"), null=True) status = models.SmallIntegerField(_("status"), choices=STATUSES, default=STATUSES.public) items = models.ManyToManyField(Item, verbose_name=_("products"), blank=True) tags = TaggableManager(TAG_VERBOSE_NAME, help_text=TAG_HELP_TEXT, blank=True) objects = ContentManager()
objects = BroadcastDealManager() def get_absolute_url(self): return ('view_deal', [self.id]) get_absolute_url = models.permalink(get_absolute_url) class Meta: db_table = "broadcastdeal" User.profile = property(lambda u: UserProfile.objects.get_or_create(user=u)[0]) pre_update.connect(new_users_handler, sender=FacebookBackend) pre_update.connect(new_users_handler, sender=TwitterBackend) pre_update.connect(new_users_handler, sender=GoogleOAuth2Backend) utils.register(GenericWish) utils.register(BroadcastWish) utils.register(BroadcastDeal) def comment_action(sender, comment=None, target=None, **kwargs): if comment.user: if isinstance(comment.content_object, BlogPost): action.send(comment.user, verb=settings.REVIEW_POST_VERB, action_object=comment.content_object, target=comment) Follow.objects.get_or_create(comment.user, comment) actions.follow(comment.user, comment, send_action=False, actor_only=False) elif isinstance(comment.content_object, ThreadedComment): action.send(comment.user, verb=settings.REVIEW_COMMENT_VERB, action_object=comment, target=comment.content_object, batch_time_minutes=30, is_batchable=True) elif isinstance(comment.content_object, Album):
""" task = models.ForeignKey(Task, verbose_name=_('task'), related_name="%(class)s_tasks") content_type = models.ForeignKey(ContentType, verbose_name=_('content type'), related_name="content_type_set_for_%(class)s") object_id = models.TextField(_('object ID')) content_object = GenericForeignKey() class Meta: verbose_name = _('objecttask') verbose_name_plural = _('objecttasks') def __str__(self): return "%s for %s" % (str(self.task), str(self.content_object)) from follow import utils from reversion import revisions as reversion reversion.register(Task) utils.register(User) utils.register(Project) utils.register(Milestone) utils.register(Task) # IMPORTANT LINE, really leave it there! from django_project import handlers
for nail in query: try: cursor.execute( 'INSERT INTO core_friendfeed (user_id, nail_id, timestamp, ref_count) ' 'VALUES (%s, %s, %s, 1) ' 'ON DUPLICATE KEY ' 'UPDATE ref_count=ref_count+1', [user.id, nail.id, nail.timestamp] ) transaction.commit_unless_managed() except IntegrityError: # just ignore dupes pass utils.register(User) utils.register(Workbench) @receiver(post_save, sender=Nail) def nail_saved(sender, instance=None, created=None, **kwargs): if not created: # remove nail from old friendfeeds instance.friendfeed.all().delete() query = [instance] # for each follower of the workbench, add this nail to a friendfeed for follow in instance.workbench.get_follows(): FriendFeed.populate_user_feed(follow.user, query)
class Meta: verbose_name = _('objecttask') verbose_name_plural = _('objecttasks') def __str__(self): return "%s for %s" % (str(self.task), str(self.content_object)) # def upload_manager(instance, filename): # user = instance.project.author # user_profile = Profile.objects.get(user=user) # user_organisation = user_profile.organisation # user_project = instance.project.name # # b = str(MEDIA_ROOT) # a = user_organisation+'/'+user_project+'/'+filename+'/' # return a # # return MEDIA_ROOT from follow import utils from reversion import revisions as reversion reversion.register(Task) utils.register(User) utils.register(Project) # utils.register(Milestone) utils.register(Task) # # IMPORTANT LINE, really leave it there! from django_project import handlers