def get_absolute_url(self, domain=False):
obj = self.publishable
category = get_cached_object(Category, pk=self.category_id)
kwargs = {
'content_type' : slugify(obj.content_type.model_class()._meta.verbose_name_plural),
'slug' : self.slug,
}
if self.static:
if category.tree_parent_id:
kwargs['category'] = category.tree_path
url = reverse('static_detail', kwargs=kwargs)
else:
url = reverse('home_static_detail', kwargs=kwargs)
else:
kwargs.update({
'year' : self.publish_from.year,
'month' : self.publish_from.month,
'day' : self.publish_from.day,
})
if category.tree_parent_id:
kwargs['category'] = category.tree_path
url = reverse('object_detail', kwargs=kwargs)
else:
url = reverse('home_object_detail', kwargs=kwargs)
if category.site_id != settings.SITE_ID or domain:
site = get_cached_object(Site, pk=category.site_id)
return 'http://' + site.domain + url
return url
def clean(self):
if not self.category or not self.name:
return
if self.target_ct:
try:
get_cached_object(self.target_ct, pk=self.target_id)
except self.target_ct.model_class().DoesNotExist:
raise ValidationError(
_('This position doesn\'t point to a valid object.'))
qset = Position.objects.filter(category=self.category, name=self.name)
if self.pk:
qset = qset.exclude(pk=self.pk)
if self.active_from:
qset = qset.exclude(active_till__lte=self.active_from)
if self.active_till:
qset = qset.exclude(active_from__gt=self.active_till)
if qset.count():
raise ValidationError(
_('There already is a postion for %(cat)s named %(name)s fo this time.'
) % {
'cat': self.category,
'name': self.name
})
def set_init_props(self, data=None, init_props=INIT_PROPS):
"""set initial form properties
form is created from data, if it is bound
from init_props, if not bound
from options saved in database, if any
"""
if data:
# don't want MultiValueDict here - sorry for this hack - FIXME
init_props = dict(zip(data.keys(), data.values()))
# copy defalt settings
self.init_props = INIT_PROPS.copy()
# set actual time
now = int(time.mktime(datetime.now().timetuple()))
self.init_props['timestamp'] = now
# update defaults with form init params
self.init_props.update(init_props)
target_ct, target_id = None, None
try:
target_ct, target_id = self.init_props['target'].split(':')
target_ct, target_id = int(target_ct), int(target_id)
target_contenttype = get_cached_object(ContentType, pk=target_ct)
self.target_object = get_cached_object(target_contenttype, pk=target_id)
except ValueError, ve:
log.error('ValueError: %s' % str(ve))
def set_init_props(self, data=None, init_props=INIT_PROPS):
"""set initial form properties
form is created from data, if it is bound
from init_props, if not bound
from options saved in database, if any
"""
if data:
# don't want MultiValueDict here - sorry for this hack - FIXME
init_props = dict(zip(data.keys(), data.values()))
# copy defalt settings
self.init_props = INIT_PROPS.copy()
# set actual time
now = int(time.mktime(datetime.now().timetuple()))
self.init_props['timestamp'] = now
# update defaults with form init params
self.init_props.update(init_props)
target_ct, target_id = None, None
try:
target_ct, target_id = self.init_props['target'].split(':')
target_ct, target_id = int(target_ct), int(target_id)
target_contenttype = get_cached_object(ContentType, pk=target_ct)
self.target_object = get_cached_object(target_contenttype,
pk=target_id)
except ValueError, ve:
log.error('ValueError: %s' % str(ve))
def __unicode__(self):
if self.author_id:
return unicode(get_cached_object(Author, pk=self.author_id))
elif self.user_id:
user = get_cached_object(User, pk=self.user_id)
return user.get_full_name()
return self.name
def clean(self):
"""Checks if all objects exist and searches for duplicate references to the same object in one gallery."""
if not self.is_valid():
return
obj = self.instance
items = set([])
for i, d in ((i, d) for i, d in enumerate(self.cleaned_data) if d):
# TODO: why cleaned data does not have target_ct_id prop?
target = (
d['target_ct'].id,
d['target_id'],
)
# check if object exists
try:
# TODO: wouldn't it be better not to take objects from cache?
obj = get_cached_object(get_cached_object(
ContentType, pk=d['target_ct'].id),
pk=d['target_id'])
except ObjectDoesNotExist:
raise forms.ValidationError, ugettext(
'%s with id %i does not exist') % (d['target_ct'],
d['target_id'])
# check for duplicities
if target in items:
raise forms.ValidationError, ugettext(
'There are two references to %s in this gallery') % obj
items.add(target)
return self.cleaned_data
def folder_post_save(category_tp, author_slug, sender, instance, **kwargs):
slug = slug_from_folder(instance)
try:
gal = get_cached_object(Gallery, slug=slug)
new = False
except Gallery.DoesNotExist:
gal = Gallery(slug=slug)
new = True
if category_tp is not None:
cat = get_cached_object(Category, tree_path=category_tp)
else:
cat = get_cached_object(Category, tree_path='', site_id=settings.SITE_ID)
gal.title = instance.name
gal.category = cat
gal.publish_from = datetime.now()
gal.published = True
gal.save()
if author_slug is not None:
gal.authors = [get_cached_object(Author, slug=author_slug),]
gal.save()
if new is True:
Listing.objects.create(publishable=gal, category=cat, publish_from=gal.publish_from)
else:
for l in Listing.objects.filter(publishable=gal):
l.category = cat
l.save()
def render(self, context):
try:
cat = template.Variable(self.category).resolve(context)
if not isinstance(cat, Category):
cat = get_cached_object(Category, site=settings.SITE_ID, slug=self.category)
except (template.VariableDoesNotExist, Category.DoesNotExist):
cat = get_cached_object(Category, site=settings.SITE_ID, tree_parent__isnull=True)
try:
pos = Position.objects.get_active_position(cat, self.position, self.nofallback)
except Position.DoesNotExist:
return ""
return pos.render(context, self.nodelist, self.box_type)
def render(self, context):
try:
cat = template.Variable(self.category).resolve(context)
if not isinstance(cat, Category):
cat = get_cached_object(Category, site=settings.SITE_ID, slug=self.category)
except (template.VariableDoesNotExist, Category.DoesNotExist):
cat = get_cached_object(Category, site=settings.SITE_ID, tree_parent__isnull=True)
for pos in self.positions:
try:
Position.objects.get_active_position(cat, pos, self.nofallback)
return self.nodelist_true.render(context)
except Position.DoesNotExist:
pass
return self.nodelist_false.render(context)
def __getitem__(self, key):
if isinstance(key, int):
if self._reversed:
key = -1 - key
pk = redis.lindex(self._key, key)
if pk is None:
raise IndexError('list index out of range')
return get_cached_object(FlatComment, pk=pk)
cnt = None
start = 0 if key.start is None else key.start
stop = key.stop
if key.stop is None:
stop = cnt = self.count()
assert isinstance(key, slice) and isinstance(
start, int) and isinstance(stop, int) and key.step is None
if self._reversed:
if cnt is None:
cnt = self.count()
pks = reversed(redis.lrange(self._key, cnt - stop,
cnt - start - 1))
else:
pks = redis.lrange(self._key, start, stop - 1)
return get_cached_objects(pks, model=FlatComment, missing=SKIP)
def load_template_source(self, template_name, template_dirs=None):
" template loader conforming to django's API "
try:
t = get_cached_object(CT_DBTEMPLATE, name=template_name, site__id=settings.SITE_ID)
return (t.get_text(), template_name)
except DbTemplate.DoesNotExist:
raise TemplateDoesNotExist, template_name
def get_absolute_url(self, domain=False):
obj = self.publishable
category = self.category
kwargs = {
'content_type':
slugify(obj.content_type.model_class()._meta.verbose_name_plural),
'slug':
self.slug,
}
if self.static:
if category.tree_parent_id:
kwargs['category'] = category.tree_path
url = reverse('static_detail', kwargs=kwargs)
else:
url = reverse('home_static_detail', kwargs=kwargs)
else:
kwargs.update({
'year': self.publish_from.year,
'month': self.publish_from.month,
'day': self.publish_from.day,
})
if category.tree_parent_id:
kwargs['category'] = category.tree_path
url = reverse('object_detail', kwargs=kwargs)
else:
url = reverse('home_object_detail', kwargs=kwargs)
if category.site_id != settings.SITE_ID or domain:
site = get_cached_object(Site, pk=category.site_id)
return 'http://' + site.domain + url
return url
def get_context(self, request, category, slug, year, month, day, id):
try:
cat = Category.objects.get_by_tree_path(category)
except Category.DoesNotExist:
# non-static url, no way to recover
if year:
raise Http404("Category with tree_path '%s' doesn't exist." % category)
else:
cat = None
if year:
lookup = {
'publish_from__year': year,
'publish_from__month': month,
'publish_from__day': day,
'category': cat,
'slug': slug,
'static': False
}
try:
publishable = get_cached_object(Publishable, published=True, **lookup)
except Publishable.DoesNotExist:
# Fallback for staff members in case there are multiple
# objects with same URL.
if request.user.is_staff:
try:
publishable = Publishable.objects.filter(published=False, **lookup)[0]
except IndexError:
raise Http404
else:
raise Http404
else:
publishable = get_cached_object_or_404(Publishable, pk=id)
if not (publishable.is_published() or request.user.is_staff):
# future publish, render if accessed by logged in staff member
raise Http404
if not year:
if cat is None:
raise self.WrongUrl('Category with tree_path %r does not exist.' % category, publishable)
elif not publishable.static:
raise self.WrongUrl('%s is not static.' % publishable, publishable)
elif slug != publishable.slug:
raise self.WrongUrl('Wrong slug in URL (%r).' % slug, publishable)
elif publishable.category_id != cat.pk:
raise self.WrongUrl('Wrong category for %s.' % publishable, publishable)
# save existing object to preserve memory and SQL
publishable.category = cat
context = {
'object' : publishable,
'category' : cat,
'content_type_name' : slugify(publishable.content_type.model_class()._meta.verbose_name_plural),
'content_type' : publishable.content_type
}
return context
def image_pre_save(sender, instance, **kwargs):
basetitle = instance.original_filename
try:
p = Photo.objects.get(title=basetitle)
except Photo.DoesNotExist:
p = Photo(title=basetitle)
p.image = instance.file.file
p.save()
fld = instance.folder
if fld is not None and fgs.AUTOCREATE and is_gallery_folder(fld.pretty_logical_path)[0]:
try:
gal = get_cached_object(Gallery, slug=slug_from_folder(fld))
if GalleryItem.objects.filter(gallery=gal, photo=p).count() == 0:
GalleryItem.objects.create(
gallery=gal,
photo=p,
order=fld.file_count
)
except Gallery.DoesNotExist:
pass
def url(self):
if not self.slug:
return ''
url = reverse('ella_exports_by_slug', args={'slug': self.slug,})
# prepend the domain if it doesn't match current Site
site = get_cached_object(Site, pk=self.category.site_id)
return 'http://' + site.domain + url
def _get_template_list(self):
"""
slightly patched version of Box._get_template_list
TODO: ugly ;)
"""
t_list = []
if hasattr(self.obj, 'category_id') and self.obj.category_id:
from ella.core.models import Category
cat = get_cached_object(Category, pk=self.obj.category_id)
base_path = 'box/category/%s/content_type/%s.%s/' % (cat.path, self.obj._meta.app_label, self.obj._meta.module_name)
if hasattr(self.obj, 'slug'):
t_list.append(base_path + 'attachment_type/%s/%s/%s.html' % (self.obj.type.name, self.obj.slug, self.box_type,))
t_list.append(base_path + '%s/%s.html' % (self.obj.slug, self.box_type,))
t_list.append(base_path + 'attachment_type/%s/%s.html' % (self.obj.type.name, self.box_type,))
t_list.append(base_path + 'attachment_type/%s/box.html' % self.obj.type.name)
t_list.append(base_path + '%s.html' % (self.box_type,))
t_list.append(base_path + 'box.html')
base_path = 'box/content_type/%s.%s/' % (self.obj._meta.app_label, self.obj._meta.module_name)
if hasattr(self.obj, 'slug'):
t_list.append(base_path + 'attachment_type/%s/%s/%s.html' % (self.obj.type.name, self.obj.slug, self.box_type,))
t_list.append(base_path + '%s/%s.html' % (self.obj.slug, self.box_type,))
t_list.append(base_path + 'attachment_type/%s/%s.html' % (self.obj.type.name, self.box_type,))
t_list.append(base_path + 'attachment_type/%s/box.html' % self.obj.type.name)
t_list.append(base_path + '%s.html' % (self.box_type,))
t_list.append(base_path + 'box.html')
t_list.append('box/attachment_type/%s/%s.html' % (self.obj.type.name, self.box_type))
t_list.append('box/attachment_type/%s/box.html' % self.obj.type.name)
t_list.append('box/%s.html' % self.box_type)
t_list.append('box/box.html')
return t_list
def image_post_delete(sender, instance, **kwargs):
basetitle = instance.original_filename
try:
p = get_cached_object(Photo, title=basetitle)
p.delete()
except Photo.DoesNotExist:
pass
def get_photo(self):
" Get object's Photo. "
if not hasattr(self, '_photo'):
try:
self._photo = get_cached_object(Photo, pk=self.photo_id)
except Photo.DoesNotExist:
self._photo = None
return self._photo
def get_photo_in_format(self, photo, format, include_original=True):
if isinstance(photo, Photo):
photo_id = photo.id
else:
photo_id = photo
photo = None
if not isinstance(format, Format):
format = Format.objects.get_for_name(format)
if redis:
p = redis.pipeline()
p.hgetall(REDIS_PHOTO_KEY % photo_id)
p.hgetall(REDIS_FORMATTED_PHOTO_KEY % (photo_id, format.id))
original, formatted = p.execute()
if formatted:
if include_original:
formatted['original'] = original
return formatted
if not photo:
try:
photo = get_cached_object(Photo, pk=photo_id)
except Photo.DoesNotExist:
return format.get_blank_img()
try:
formated_photo = get_cached_object(FormatedPhoto, photo=photo, format=format)
except FormatedPhoto.DoesNotExist:
try:
# use get or create because there is a possible race condition here
# we don't want to JUST use get_or_create to go through cache 99.9% of the time
formated_photo, _ = self.get_or_create(photo=photo, format=format)
except (IOError, SystemError) as e:
log.warning("Cannot create formatted photo due to %s.", e)
return format.get_blank_img()
info = {
'url': formated_photo.url,
'width': formated_photo.width,
'height': formated_photo.height,
}
if include_original:
info['original'] = photo.get_image_info()
return info
def _get_template_list(self):
"""
slightly patched version of Box._get_template_list
TODO: ugly ;)
"""
t_list = []
if hasattr(self.obj, 'category_id') and self.obj.category_id:
from ella.core.models import Category
cat = get_cached_object(Category, pk=self.obj.category_id)
base_path = 'box/category/%s/content_type/%s.%s/' % (
cat.path, self.obj._meta.app_label, self.obj._meta.module_name)
if hasattr(self.obj, 'slug'):
t_list.append(base_path + 'attachment_type/%s/%s/%s.html' % (
self.obj.type.name,
self.obj.slug,
self.box_type,
))
t_list.append(base_path + '%s/%s.html' % (
self.obj.slug,
self.box_type,
))
t_list.append(base_path + 'attachment_type/%s/%s.html' % (
self.obj.type.name,
self.box_type,
))
t_list.append(base_path +
'attachment_type/%s/box.html' % self.obj.type.name)
t_list.append(base_path + '%s.html' % (self.box_type, ))
t_list.append(base_path + 'box.html')
base_path = 'box/content_type/%s.%s/' % (self.obj._meta.app_label,
self.obj._meta.module_name)
if hasattr(self.obj, 'slug'):
t_list.append(base_path + 'attachment_type/%s/%s/%s.html' % (
self.obj.type.name,
self.obj.slug,
self.box_type,
))
t_list.append(base_path + '%s/%s.html' % (
self.obj.slug,
self.box_type,
))
t_list.append(base_path + 'attachment_type/%s/%s.html' % (
self.obj.type.name,
self.box_type,
))
t_list.append(base_path +
'attachment_type/%s/box.html' % self.obj.type.name)
t_list.append(base_path + '%s.html' % (self.box_type, ))
t_list.append(base_path + 'box.html')
t_list.append('box/attachment_type/%s/%s.html' %
(self.obj.type.name, self.box_type))
t_list.append('box/attachment_type/%s/box.html' % self.obj.type.name)
t_list.append('box/%s.html' % self.box_type)
t_list.append('box/box.html')
return t_list
def get_percentage(self):
"""
Compute and return percentage representation of choice object to its question's total votes
"""
t = get_cached_object(Question, pk=self.question_id).get_total_votes()
p = 0
if self.votes:
p = int((100.0/t)*self.votes)
return p
def load_template_source(self, template_name, template_dirs=None):
" template loader conforming to django's API "
try:
t = get_cached_object(CT_DBTEMPLATE,
name=template_name,
site__id=settings.SITE_ID)
return (t.get_text(), template_name)
except DbTemplate.DoesNotExist:
raise TemplateDoesNotExist, template_name
def clean(self):
"""registered user validation and other cleaning"""
from django.forms.util import ValidationError
try:
# target_ct, target_id validation
target_ct = self.init_props['target_ct']
target_id = self.init_props['target_id']
target_ct = get_cached_object(ContentType, pk=target_ct)
target_object = get_cached_object(target_ct, pk=target_id)
self.cleaned_data['target_ct'] = target_ct
self.cleaned_data['target_id'] = target_id
self.cleaned_data['target_object'] = target_object
except models.ObjectDoesNotExist:
raise ValidationError, _("Target object does not exist.")
return self.cleaned_data
def clean(self):
"""registered user validation and other cleaning"""
from django.forms.util import ValidationError
try:
# target_ct, target_id validation
target_ct = self.init_props['target_ct']
target_id = self.init_props['target_id']
target_ct = get_cached_object(ContentType, pk=target_ct)
target_object = get_cached_object(target_ct, pk=target_id)
self.cleaned_data['target_ct'] = target_ct
self.cleaned_data['target_id'] = target_id
self.cleaned_data['target_object'] = target_object
except models.ObjectDoesNotExist:
raise ValidationError, _("Target object does not exist.")
return self.cleaned_data
def url(self):
if self.link:
return self.link
if not self.slug:
return ''
url = reverse('ella_exports_by_slug', args=(self.slug, ))
# prepend the domain if it doesn't match current Site
site = get_cached_object(Site, pk=self.category.site_id)
return 'http://' + site.domain + url
def set_init_props(self, data=None, init_props=defaults.INIT_PROPS):
"""
set initial form properties
form is created from data, if it is bound
from init_props, if not bound
from options saved in database, if any
"""
if data:
# don't want MultiValueDict here
init_props = dict(zip(data.keys(), data.values()))
# copy defalt settings
self.init_props = defaults.INIT_PROPS.copy()
# set actual time
now = int(time.time())
self.init_props['timestamp'] = now
self.init_props['timestamp_min'] = now - defaults.FORM_TIMEOUT
# update defaults with form init params
self.init_props.update(init_props)
target_ct, target_id = None, None
try:
target_ct, target_id = self.init_props['target'].split(defaults.OPTS_DELIM)
target_ct, target_id = int(target_ct), int(target_id)
target_contenttype = get_cached_object(ContentType, pk=target_ct)
self.target_object = get_cached_object(target_contenttype, pk=target_id)
except ValueError:
pass
except models.ObjectDoesNotExist:
pass
# defaults for this instance
self.init_props['target_ct'] = target_ct
self.init_props['target_id'] = target_id
# find any options updates in database
self.check_db_options(target_ct, target_id)
# defaults continue
self.OPTIONS = self.init_props['options'].split(defaults.OPTS_DELIM)
self.init_props['gonzo'] = self.get_hash(self.init_props['options'], self.init_props['target'], self.init_props['timestamp'])
def applicable_sites(user, permission=None):
q = SiteUserRole.objects.filter(user=user).distinct().values('site')
if permission:
app_label, code = permission.split('.', 1)
perm = get_cached_object(Permission, content_type__app_label=app_label, codename=code)
q = q.filter(group__permissions=perm)
else:
# take any permission
q = q.filter(group__permissions__id__isnull=False)
return [ d['site'] for d in q ]
def render(self, context):
try:
cat = template.Variable(self.category).resolve(context)
if not isinstance(cat, Category):
cat = get_cached_object(Category,
site=settings.SITE_ID,
slug=self.category)
except (template.VariableDoesNotExist, Category.DoesNotExist):
cat = get_cached_object(Category,
site=settings.SITE_ID,
tree_parent__isnull=True)
try:
pos = Position.objects.get_active_position(cat, self.position,
self.nofallback)
except Position.DoesNotExist:
return ''
return pos.render(context, self.nodelist, self.box_type)
def render(self, context):
try:
cat = template.Variable(self.category).resolve(context)
if not isinstance(cat, Category):
cat = get_cached_object(Category,
site=settings.SITE_ID,
slug=self.category)
except (template.VariableDoesNotExist, Category.DoesNotExist):
cat = get_cached_object(Category,
site=settings.SITE_ID,
tree_parent__isnull=True)
for pos in self.positions:
try:
Position.objects.get_active_position(cat, pos, self.nofallback)
return self.nodelist_true.render(context)
except Position.DoesNotExist:
pass
return self.nodelist_false.render(context)
def points(self):
"""
Parse choices represented as a string and returns reached points count
"""
points = 0
for q in self.choices.split('|'):
vs = q.split(':')
for v in vs[1].split(','):
points += get_cached_object(Choice, pk=v).points
return points
def applicable_sites(user, permission=None):
q = SiteUserRole.objects.filter(user=user).distinct().values('site')
if permission:
app_label, code = permission.split('.', 1)
perm = get_cached_object(Permission, content_type__app_label=app_label, codename=code)
q = q.filter(group__permissions=perm)
else:
# take any permission
q = q.filter(group__permissions__id__isnull=False)
return [ d['site'] for d in q ]
def points(self):
"""
Parse choices represented as a string and returns reached points count
"""
points = 0
for q in self.choices.split('|'):
vs = q.split(':')
for v in vs[1].split(','):
points += get_cached_object(Choice, pk=v).points
return points
def set_init_props(self, data=None, init_props=defaults.INIT_PROPS):
"""
set initial form properties
form is created from data, if it is bound
from init_props, if not bound
from options saved in database, if any
"""
if data:
# don't want MultiValueDict here
init_props = dict(zip(data.keys(), data.values()))
# copy defalt settings
self.init_props = defaults.INIT_PROPS.copy()
# set actual time
now = int(time.time())
self.init_props['timestamp'] = now
self.init_props['timestamp_min'] = now - defaults.FORM_TIMEOUT
# update defaults with form init params
self.init_props.update(init_props)
target_ct, target_id = None, None
try:
target_ct, target_id = self.init_props['target'].split(defaults.OPTS_DELIM)
target_ct, target_id = int(target_ct), int(target_id)
target_contenttype = get_cached_object(ContentType, pk=target_ct)
self.target_object = get_cached_object(target_contenttype, pk=target_id)
except ValueError:
pass
except models.ObjectDoesNotExist:
pass
# defaults for this instance
self.init_props['target_ct'] = target_ct
self.init_props['target_id'] = target_id
# find any options updates in database
self.check_db_options(target_ct, target_id)
# defaults continue
self.OPTIONS = self.init_props['options'].split(defaults.OPTS_DELIM)
self.init_props['gonzo'] = self.get_hash(self.init_props['options'], self.init_props['target'], self.init_props['timestamp'])
def has_site_permission(user, model, site, permission):
if user.has_perm(permission):
return True
app_label, code = permission.split('.', 1)
perm = get_cached_object(Permission, content_type__app_label=app_label, codename=code)
if SiteUserRole.objects.filter(site=site, user=user, group__permissions=perm).count():
return True
return False
def get(self, request, *args, **kwargs):
if 'slug' not in kwargs:
raise Http404
# Compatibility with `paginator` tag.
if 'p' in request.GET:
self.kwargs.update({'page': request.GET['p']})
self.author = get_cached_object(Author, slug=kwargs['slug'])
return super(AuthorView, self).get(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
if "slug" not in kwargs:
raise Http404
# Compatibility with `paginator` tag.
if "p" in request.GET:
self.kwargs.update({"page": request.GET["p"]})
self.author = get_cached_object(Author, slug=kwargs["slug"])
return super(AuthorView, self).get(request, *args, **kwargs)
def get(self, request, *args, **kwargs):
if 'slug' not in kwargs:
raise Http404
# Compatibility with `paginator` tag.
if 'p' in request.GET:
self.kwargs.update({'page': request.GET['p']})
self.author = get_cached_object(Author, slug=kwargs['slug'])
return super(AuthorView, self).get(request, *args, **kwargs)
def has_site_permission(user, model, site, permission):
if user.has_perm(permission):
return True
app_label, code = permission.split('.', 1)
perm = get_cached_object(Permission, content_type__app_label=app_label, codename=code)
if SiteUserRole.objects.filter(site=site, user=user, group__permissions=perm).count():
return True
return False
def get_percentage(self):
"""
Compute and return percentage representation of choice object to its question's total votes
"""
if hasattr(self, 'percentage'):
return self.percentage
t = get_cached_object(Question, pk=self.question_id).get_total_votes()
p = 0
if self.votes:
p = int((100.0 / t) * self.votes)
return p
def get_absolute_url(self):
if not self.tree_parent_id:
url = reverse('root_homepage')
else:
url = reverse('category_detail',
kwargs={
'category': self.tree_path,
})
if self.site_id != settings.SITE_ID:
# prepend the domain if it doesn't match current Site
site = get_cached_object(Site, pk=self.site_id)
return 'http://' + site.domain + url
return url
def save(self, commit=True):
contestant = super(ContestantForm, self).save(commit=False)
contestant.contest = self.contest
if self.request.user.is_authenticated():
contestant.user = self.request.user
if commit:
contestant.save()
for q, f in self.qforms:
ch_pk = f.cleaned_data['choice']
if ch_pk:
if isinstance(ch_pk, (tuple, list)):
ch_pk, ans = ch_pk
if not q.is_required and not ans.strip():
continue
data = dict(contestant=contestant,
choice=get_cached_object(Choice, pk=ch_pk),
answer=ans.strip())
else:
data = dict(contestant=contestant,
choice=get_cached_object(Choice, pk=ch_pk))
Answer.objects.create(**data)
return contestant
def clean(self):
"""Checks if all objects exist and searches for duplicate references to the same object in one gallery."""
if not self.is_valid():
return
obj = self.instance
items = set([])
for i,d in ((i,d) for i,d in enumerate(self.cleaned_data) if d):
# TODO: why cleaned data does not have target_ct_id prop?
target = (d['target_ct'].id, d['target_id'],)
# check if object exists
try:
# TODO: wouldn't it be better not to take objects from cache?
obj = get_cached_object(get_cached_object(ContentType, pk=d['target_ct'].id), pk=d['target_id'])
except ObjectDoesNotExist:
raise forms.ValidationError, ugettext('%s with id %i does not exist') % (d['target_ct'], d['target_id'])
# check for duplicities
if target in items:
raise forms.ValidationError, ugettext('There are two references to %s in this gallery') % obj
items.add(target)
return self.cleaned_data
def get_for_object(self, obj):
if hasattr(obj, 'app_data'):
return obj.app_data.get('comments', DEFAULT_COMMENT_OPTIONS)
ct = ContentType.objects.get_for_model(obj)
try:
coo = get_cached_object(CommentOptionsObject, target_ct=ct, target_id=obj.pk)
return {
'blocked': coo.blocked,
'premoderated': coo.premoderated,
'check_profanities': coo.check_profanities,
}
except CommentOptionsObject.DoesNotExist:
return DEFAULT_COMMENT_OPTIONS
def clean(self):
if not self.category or not self.name:
return
if self.target_ct:
try:
get_cached_object(self.target_ct, pk=self.target_id)
except self.target_ct.model_class().DoesNotExist:
raise ValidationError(_('This position doesn\'t point to a valid object.'))
qset = Position.objects.filter(category=self.category, name=self.name)
if self.pk:
qset = qset.exclude(pk=self.pk)
if self.active_from:
qset = qset.exclude(active_till__lte=self.active_from)
if self.active_till:
qset = qset.exclude(active_from__gt=self.active_till)
if qset.count():
raise ValidationError(_('There already is a postion for %(cat)s named %(name)s fo this time.') % {'cat': self.category, 'name': self.name})
def clean(self):
"""registered user validation and other cleaning"""
if 'username' in self.init_props and 'password' in self.init_props:
user = authenticate(username=self.init_props['username'], password=self.init_props['password'])
if not user:
raise ValidationError, _("Invalid user.")
elif BannedUser.objects.filter(
target_ct=self.init_props['target_ct'],
target_id=self.init_props['target_id'],
user=user
).count():
raise ValidationError, _("Banned user.")
else:
self.cleaned_data['user'] = user
try:
# target_ct, target_id validation
target_ct = self.init_props['target_ct']
target_id = self.init_props['target_id']
target_ct = get_cached_object(ContentType, pk=target_ct)
target_object = get_cached_object(target_ct, pk=target_id)
self.cleaned_data['target_ct'] = target_ct
self.cleaned_data['target_id'] = target_id
self.cleaned_data['target_object'] = target_object
except models.ObjectDoesNotExist:
raise ValidationError, _("Target object does not exist.")
parent = self.cleaned_data['parent']
if parent:
try:
self.cleaned_data['parent'] = get_cached_object(Comment, pk=parent, target_ct=target_ct, target_id=target_id)
except models.ObjectDoesNotExist:
raise ValidationError, _("You are responding to a non-existent comment.")
return self.cleaned_data
def clean(self):
"""registered user validation and other cleaning"""
if 'username' in self.init_props and 'password' in self.init_props:
user = authenticate(username=self.init_props['username'], password=self.init_props['password'])
if not user:
raise ValidationError, _("Invalid user.")
elif BannedUser.objects.filter(
target_ct=self.init_props['target_ct'],
target_id=self.init_props['target_id'],
user=user
).count():
raise ValidationError, _("Banned user.")
else:
self.cleaned_data['user'] = user
try:
# target_ct, target_id validation
target_ct = self.init_props['target_ct']
target_id = self.init_props['target_id']
target_ct = get_cached_object(ContentType, pk=target_ct)
target_object = get_cached_object(target_ct, pk=target_id)
self.cleaned_data['target_ct'] = target_ct
self.cleaned_data['target_id'] = target_id
self.cleaned_data['target_object'] = target_object
except models.ObjectDoesNotExist:
raise ValidationError, _("Target object does not exist.")
parent = self.cleaned_data['parent']
if parent:
try:
self.cleaned_data['parent'] = get_cached_object(Comment, pk=parent, target_ct=target_ct, target_id=target_id)
except models.ObjectDoesNotExist:
raise ValidationError, _("You are responding to a non-existent comment.")
return self.cleaned_data
def get_absolute_url(self):
if not self.tree_parent_id:
url = reverse('root_homepage')
else:
url = reverse(
'category_detail',
kwargs={
'category' : self.tree_path,
}
)
if self.site_id != settings.SITE_ID:
# prepend the domain if it doesn't match current Site
site = get_cached_object(Site, pk=self.site_id)
return 'http://' + site.domain + url
return url
def has_category_permission(user, model, category, permission):
if user.has_perm(permission):
return True
app_label, code = permission.split('.', 1)
perm = get_cached_object(Permission, content_type__app_label=app_label, codename=code)
if CategoryUserRole.objects.filter(
category=category,
user=user,
group__permissions=perm
).count():
return True
# fallback to site permissions
return has_site_permission(user, model, category.site_id, permission)
def has_category_permission(user, model, category, permission):
if user.has_perm(permission):
return True
app_label, code = permission.split('.', 1)
perm = get_cached_object(Permission, content_type__app_label=app_label, codename=code)
if CategoryUserRole.objects.filter(
category=category,
user=user,
group__permissions=perm
).count():
return True
# fallback to site permissions
return has_site_permission(user, model, category.site_id, permission)
def render(self, context):
if self.pk:
try:
place = get_cached_object(Placement, pk=self.place)
except Placement.DoesNotExist:
return ''
else:
try:
place = Variable(self.place).resolve(context)
except VariableDoesNotExist:
return ''
if core_settings.DOUBLE_RENDER and 'SECOND_RENDER' not in context:
return '{%% load hits %%}{%% hitcount for pk %(place_pk)s %%}' % {
'place_pk': place.pk,
}
HitCount.objects.hit(place)
return ''
def render(self, context):
if self.pk:
try:
place = get_cached_object(Placement, pk=self.place)
except Placement.DoesNotExist:
return ''
else:
try:
place = Variable(self.place).resolve(context)
except VariableDoesNotExist:
return ''
if DOUBLE_RENDER and 'SECOND_RENDER' not in context:
return '{%% load hits %%}{%% hitcount for pk %(place_pk)s %%}' % {
'place_pk' : place.pk,
}
HitCount.objects.hit(place)
return ''
def main_placement(self):
" Return object's main placement, that is the object's placement in its primary category "
if hasattr(self, '_main_placement'):
return self._main_placement
current_site = Site.objects.get_current()
# TODO: what if have got multiple listings on one site?
placements = get_cached_list(
Placement,
publishable=self.pk,
category__site=current_site,
)
if placements:
if len(placements) == 1:
self._main_placement = placements[0]
else:
# with multiple listings, one with first publish_from
# primary
first_published = None
for placement in placements:
if first_published is None or placement.publish_from < first_published.publish_from:
first_published = placement
assert first_published is not None
self._main_placement = first_published
else:
try:
# TODO - check and if we don't have category, take the only placement that exists in current site
self._main_placement = get_cached_object(
Placement, publishable=self.pk, category=self.category_id)
except Placement.DoesNotExist:
self._main_placement = None
if self._main_placement:
# preserve memory and SQL queries by using the same object
self._main_placement.publishable = self
return self._main_placement
def parse_object_definition(tagname, od_tokens):
"""parse object definition tokens APP_LABEL.MODEL_NAME with FIELD VALUE"""
if len(od_tokens) == 1:
obj = od_tokens[0]
elif len(od_tokens) == 4:
model = models.get_model(*od_tokens[0].split('.'))
if model is None:
raise template.TemplateSyntaxError, "%r tag: Model %r does not exist" % (
tagname, od_tokens[0])
try:
obj = get_cached_object(model,
**{smart_str(od_tokens[2]): od_tokens[3]})
except models.ObjectDoesNotExist:
raise template.TemplateSyntaxError, "%r tag: Model %r with field %r equal to %r does not exist." % (
tagname, od_tokens[0], od_tokens[2], od_tokens[3])
except AssertionError:
raise template.TemplateSyntaxError, "%r tag: Model %r with field %r equal to %r does not refer to a single object." % (
tagname, od_tokens[0], od_tokens[2], od_tokens[3])
else:
raise template.TemplateSyntaxError, "%r tag: Object must be specified by 'APP_LABEL.MODEL_NAME with FIELD VALUE' or given directly" % tagname
return obj
def last_comment(self):
pk = redis.lindex(self._key, 0)
if pk is None:
return None
return get_cached_object(FlatComment, pk=pk)
def get_comment(self, comment_id):
c = get_cached_object(FlatComment, pk=comment_id)
if not self._verify_own(c):
raise FlatComment.DoesNotExist()
return c
def author(self):
if self.user_id:
user = get_cached_object(User, pk=self.user_id)
return user.username
return self.nickname
