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
