Пример #1
0
    def get_photo_in_format(self, photo, format):
        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:
                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), e:
                log.warning("Cannot create formatted photo due to %s.", e)
                return format.get_blank_img()
Пример #2
0
def img(parser, token):
    """
    Examples:

        {% img FORMAT for VAR as VAR_NAME %}
        {% img FORMAT with FIELD VALUE as VAR_NAME %}
    """
    bits = token.split_contents()

    if len(bits) < 2 or bits[-2] != 'as':
        raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %} or {% img FORMAT with FIELD VALUE as VAR_NAME %}"

    try:
        format = get_cached_object(Format,
                                   name=bits[1],
                                   sites__id=settings.SITE_ID)
    except Format.DoesNotExist:
        logmsg = "Format with name %r does not exist (for site id %d)" % (
            bits[1], settings.SITE_ID)
        log.error(logmsg)

        if not settings.TEMPLATE_DEBUG:
            return template.Node()

        raise template.TemplateSyntaxError(logmsg)

    if len(bits) == 6:
        # img FORMAT for VAR_NAME
        if bits[2] != 'for':
            raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %}"
        formated_photo = bits[3]
    elif len(bits) == 7:
        # img FORMAT with FIELD VALUE
        if bits[2] != 'with':
            raise template.TemplateSyntaxError, "{% img FORMAT with FIELD VALUE as VAR_NAME %}"
        try:
            photo = get_cached_object(Photo, **{str(bits[3]): bits[4]})
        except photo.DoesNotExist:
            raise template.TemplateSyntaxError, "Photo with %r of %r does not exist" % (
                bits[3], bits[4])

        try:
            formated_photo = get_cached_object(FormatedPhoto,
                                               photo=photo,
                                               format=format)
        except FormatedPhoto.DoesNotExist:
            formated_photo = FormatedPhoto.objects.create(photo=photo,
                                                          format=format)
    else:
        raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %} or {% img FORMAT with FIELD VALUE as VAR_NAME %}"

    return ImgTag(formated_photo, format, bits[-1])
Пример #3
0
 def format_photo_json(self, request, photo, format):
     "Used in admin image 'crop tool'."
     try:
         photo = get_cached_object(Photo, pk=photo)
         format = get_cached_object(Format, pk=format)
         content = {
             "error": False,
             "image": settings.MEDIA_URL + photo.image,
             "width": photo.width,
             "height": photo.height,
             "format_width": format.max_width,
             "format_height": format.max_height,
         }
     except (Photo.DoesNotExist, Format.DoesNotExist):
         content = {"error": True}
     return HttpResponse(simplejson.dumps(content))
Пример #4
0
Файл: core.py Проект: whit/ella
    def render(self, context):
        unique_var_name = None
        for key in self.parameters_to_resolve:
            if key == 'unique':
                unique_var_name = self.parameters[key]
            if key == 'unique' and unique_var_name not in context.dicts[
                    -1]:  # autocreate variable in context
                self.resolved_parameters[key] = context.dicts[-1][
                    unique_var_name] = set()
                continue
            #self.parameters[key] = template.Variable(self.parameters[key]).resolve(context)
            self.resolved_parameters[key] = self.resolve_parameter(
                key, context)
        if self.resolved_parameters.has_key('category') and \
            isinstance(self.resolved_parameters['category'], basestring):
            self.resolved_parameters['category'] = get_cached_object(
                Category,
                tree_path=self.resolved_parameters['category'],
                site__id=settings.SITE_ID)
        out = Listing.objects.get_listing(**self.resolved_parameters)

        if 'unique' in self.parameters:
            unique = self.resolved_parameters[
                'unique']  #context[unique_var_name]
            map(lambda x: unique.add(x.placement_id), out)
        context[self.var_name] = out
        return ''
Пример #5
0
    def __get__(self, instance, instance_type=None):
        # Fix for django 1.0 Admin Validation
        if instance is None:
            # TODO: hotfixed
            #raise AttributeError, u"%s must be accessed via instance" % self.name
            return

        try:
            return getattr(instance, self.cache_attr)
        except AttributeError:
            rel_obj = None

            # Make sure to use ContentType.objects.get_for_id() to ensure that
            # lookups are cached (see ticket #5570). This takes more code than
            # the naive ``getattr(instance, self.ct_field)``, but has better
            # performance when dealing with GFKs in loops and such.
            f = self.model._meta.get_field(self.ct_field)
            ct_id = getattr(instance, f.get_attname(), None)
            if ct_id:
                ct = self.get_content_type(id=ct_id)
                try:
                    rel_obj = get_cached_object(ct,
                                                pk=getattr(
                                                    instance, self.fk_field))
                except ObjectDoesNotExist:
                    pass
            setattr(instance, self.cache_attr, rel_obj)
            return rel_obj
Пример #6
0
def _parse_img(bits):
    if len(bits) < 2 or bits[-2] != 'as':
        raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %} or {% img FORMAT with FIELD VALUE as VAR_NAME %}"

    try:
        format = Format.objects.get_for_name(bits[1])
    except Format.DoesNotExist:
        logmsg = "Format with name %r does not exist (for site id %d)" % (bits[1], settings.SITE_ID)
        log.error(logmsg)

        if not settings.TEMPLATE_DEBUG:
            return template.Node()

        raise template.TemplateSyntaxError(logmsg)

    if len(bits) == 6:
        # img FORMAT for VAR_NAME
        if bits[2] != 'for':
            raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %}"
        formated_photo = bits[3]
    elif len(bits) == 7:
        # img FORMAT with FIELD VALUE
        if bits[2] != 'with':
            raise template.TemplateSyntaxError, "{% img FORMAT with FIELD VALUE as VAR_NAME %}"
        try:
            photo = get_cached_object(Photo, **{str(bits[3]) : bits[4]})
        except photo.DoesNotExist:
            raise template.TemplateSyntaxError, "Photo with %r of %r does not exist" % (bits[3], bits[4])

        formated_photo = FormatedPhoto.objects.get_photo_in_format(photo, format)
    else:
        raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %} or {% img FORMAT with FIELD VALUE as VAR_NAME %}"

    return ImgTag(formated_photo, format, bits[-1])
Пример #7
0
    def test_get_publishable_returns_subclass(self):
        create_basic_categories(self)
        create_and_place_a_publishable(self)

        tools.assert_equals(
            self.publishable,
            utils.get_cached_object(Publishable, pk=self.publishable.pk))
Пример #8
0
def format_photo_json(request, photo, format):
    "Used in admin image 'crop tool'."
    try:
        photo = get_cached_object(Photo, pk=photo)
        format = get_cached_object(Format, pk=format)
        content = {
            'error': False,
            'image': settings.MEDIA_URL + photo.image,
            'width': photo.width,
            'height': photo.height,
            'format_width': format.max_width,
            'format_height': format.max_height
        }
    except (Photo.DoesNotExist, Format.DoesNotExist):
        content = {'error': True}
    return HttpResponse(simplejson.dumps(content))
Пример #9
0
    def __get__(self, instance, instance_type=None):
        # Fix for django 1.0 Admin Validation
        if instance is None:
            # TODO: hotfixed
            #raise AttributeError, u"%s must be accessed via instance" % self.name
            return

        try:
            return getattr(instance, self.cache_attr)
        except AttributeError:
            rel_obj = None

            # Make sure to use ContentType.objects.get_for_id() to ensure that
            # lookups are cached (see ticket #5570). This takes more code than
            # the naive ``getattr(instance, self.ct_field)``, but has better
            # performance when dealing with GFKs in loops and such.
            f = self.model._meta.get_field(self.ct_field)
            ct_id = getattr(instance, f.get_attname(), None)
            if ct_id:
                ct = self.get_content_type(id=ct_id)
                try:
                    rel_obj = get_cached_object(ct, pk=getattr(instance, self.fk_field))
                except ObjectDoesNotExist:
                    pass
            setattr(instance, self.cache_attr, rel_obj)
            return rel_obj
Пример #10
0
    def get_obj(self, context):
        if self.model and self.lookup:
            if isinstance(self.lookup[1], template.Variable):
                try:
                    lookup_val = self.lookup[1].resolve(context)
                except template.VariableDoesNotExist as e:
                    log.warning("BoxNode: Template variable does not exist. var_name=%s", self.lookup[1].var)
                    raise ObjectNotFoundOrInvalid()

            else:
                lookup_val = self.lookup[1]

            try:
                obj = get_cached_object(self.model, **{self.lookup[0]: lookup_val})
            except (models.ObjectDoesNotExist, AssertionError) as e:
                log.warning("BoxNode: %s (%s : %s)", str(e), self.lookup[0], lookup_val)
                raise ObjectNotFoundOrInvalid()
        else:
            try:
                obj = self.var.resolve(context)
            except template.VariableDoesNotExist as e:
                log.warning("BoxNode: Template variable does not exist. var_name=%s", self.var.var)
                raise ObjectNotFoundOrInvalid()

            if not obj:
                raise ObjectNotFoundOrInvalid()
        return obj
Пример #11
0
 def get_for_name(self, name):
     try:
         return FORMAT_CACHE[name]
     except KeyError:
         FORMAT_CACHE[name] = format = get_cached_object(
             Format, name=name, sites__id=settings.SITE_ID)
     return format
Пример #12
0
 def format_photo_json(self, request, photo, format):
     "Used in admin image 'crop tool'."
     try:
         photo = get_cached_object(Photo, pk=photo)
         format = get_cached_object(Format, pk=format)
         content = {
             'error': False,
             'image':settings.MEDIA_URL + photo.image,
             'width':photo.width,
             'height': photo.height,
             'format_width':format.max_width,
             'format_height':format.max_height
         }
     except (Photo.DoesNotExist, Format.DoesNotExist):
         content = {'error':True}
     return HttpResponse(json.dumps(content))
Пример #13
0
def _parse_img(bits, legacy=True):
    if len(bits) < 2 or bits[-2] != 'as':
        raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %} or {% img FORMAT with FIELD VALUE as VAR_NAME %}"

    try:
        format = Format.objects.get_for_name(bits[1])
    except Format.DoesNotExist:
        logmsg = "Format with name %r does not exist (for site id %d)" % (bits[1], settings.SITE_ID)
        log.error(logmsg)

        if not settings.TEMPLATE_DEBUG:
            return template.Node()

        raise template.TemplateSyntaxError(logmsg)

    if len(bits) == 6:
        # img FORMAT for VAR_NAME
        if bits[2] != 'for':
            raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %}"
        formated_photo = bits[3]
    elif len(bits) == 7:
        # img FORMAT with FIELD VALUE
        if bits[2] != 'with':
            raise template.TemplateSyntaxError, "{% img FORMAT with FIELD VALUE as VAR_NAME %}"
        try:
            photo = get_cached_object(Photo, **{str(bits[3]) : bits[4]})
        except photo.DoesNotExist:
            raise template.TemplateSyntaxError, "Photo with %r of %r does not exist" % (bits[3], bits[4])

        formated_photo = FormatedPhoto.objects.get_photo_in_format(photo, format)
    else:
        raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %} or {% img FORMAT with FIELD VALUE as VAR_NAME %}"

    return ImgTag(formated_photo, format, bits[-1])
Пример #14
0
    def test_save_invalidates_object(self):
        self.ct = ContentType.objects.get_for_model(ContentType)
        ct = utils.get_cached_object(self.ct, pk=self.ct.pk)

        tools.assert_equals(ct, self.ct)
        tools.assert_equals(self.ct, self.cache.get(utils._get_key(utils.KEY_PREFIX, self.ct, pk=self.ct.pk)))
        self.ct.save()
        tools.assert_equals(None, self.cache.get(utils._get_key(utils.KEY_PREFIX, self.ct, pkr=self.ct.pk)))
Пример #15
0
    def thumb_format(self):
        if not hasattr(self, '_thumb_format'):
            if not hasattr(settings, 'PHOTOS_THUMB_FORMAT'):
                self._thumb_format = None
            else:
                self._thumb_format = get_cached_object(Format, id=settings.PHOTOS_THUMB_FORMAT)

        return self._thumb_format
Пример #16
0
def img(parser, token):
    """
    Examples:

        {% img FORMAT for VAR as VAR_NAME %}
        {% img FORMAT with FIELD VALUE as VAR_NAME %}
    """
    bits = token.split_contents()

    if len(bits) < 2 or bits[-2] != 'as':
        raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %} or {% img FORMAT with FIELD VALUE as VAR_NAME %}"

    try:
        format = get_cached_object(Format, name=bits[1], sites__id=settings.SITE_ID)
    except Format.DoesNotExist:
        logmsg = "Format with name %r does not exist (for site id %d)" % (bits[1], settings.SITE_ID)
        log.error(logmsg)

        if not settings.TEMPLATE_DEBUG:
            return template.Node()

        raise template.TemplateSyntaxError(logmsg)

    if len(bits) == 6:
        # img FORMAT for VAR_NAME
        if bits[2] != 'for':
            raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %}"
        formated_photo = bits[3]
    elif len(bits) == 7:
        # img FORMAT with FIELD VALUE
        if bits[2] != 'with':
            raise template.TemplateSyntaxError, "{% img FORMAT with FIELD VALUE as VAR_NAME %}"
        try:
            photo = get_cached_object(Photo, **{str(bits[3]) : bits[4]})
        except photo.DoesNotExist:
            raise template.TemplateSyntaxError, "Photo with %r of %r does not exist" % (bits[3],  bits[4])

        try:
            formated_photo = get_cached_object(FormatedPhoto, photo=photo, format=format)
        except FormatedPhoto.DoesNotExist:
            formated_photo = FormatedPhoto.objects.create(photo=photo, format=format)
    else:
        raise template.TemplateSyntaxError, "{% img FORMAT for VAR as VAR_NAME %} or {% img FORMAT with FIELD VALUE as VAR_NAME %}"

    return ImgTag(formated_photo, format, bits[-1])
Пример #17
0
    def thumb_format(self):
        if not hasattr(self, '_thumb_format'):
            if not hasattr(settings, 'PHOTOS_THUMB_FORMAT'):
                self._thumb_format = None
            else:
                self._thumb_format = get_cached_object(
                    Format, id=settings.PHOTOS_THUMB_FORMAT)

        return self._thumb_format
Пример #18
0
Файл: media.py Проект: whit/ella
def media(parser, token):
    """
    Examples:

        {% media FORMAT for VAR as VAR_NAME %}
        {% media FORMAT with FIELD VALUE as VAR_NAME %}
    """
    bits = token.split_contents()

    if len(bits) < 2 or bits[-2] != 'as':
        raise template.TemplateSyntaxError, "{% media FORMAT for VAR as VAR_NAME %} or {% media FORMAT with FIELD VALUE as VAR_NAME %}"

    try:
        format = get_cached_object(Format, name=bits[1])
    except Format.DoesNotExist:
        raise template.TemplateSyntaxError, "Format with name %r does not exist" % bits[
            1]

    if len(bits) == 6:
        # media FORMAT for VAR
        if bits[2] != 'for':
            raise template.TemplateSyntaxError, "{% media FORMAT for VAR as VAR_NAME %}"
        formatted_media = bits[3]
    elif len(bits) == 7:
        # media FORMAT with FIELD VALUE
        if bits[2] != 'with':
            raise template.TemplateSyntaxError, "{% media FORMAT with FIELD VALUE as VAR_NAME %}"
        try:
            media = get_cached_object(Media, **{str(bits[3]): bits[4]})
        except media.DoesNotExist:
            raise template.TemplateSyntaxError, "Media with %r of %r does not exist" % (
                bits[3], bits[4])

        try:
            formatted_media = get_cached_object(Target,
                                                source=media.file,
                                                format=format)
        except Target.DoesNotExist:
            raise template.TemplateSyntaxError, "Format %r for media with %r of %r does not exist" % (
                bits[1], bits[3], bits[4])
    else:
        raise template.TemplateSyntaxError, "{% media FORMAT for VAR as VAR_NAME %} or {% media FORMAT with FIELD VALUE as VAR_NAME %}"

    return MediaTag(formatted_media, format, bits[-1])
Пример #19
0
def thumb_url(request, photo):
    try:
        photo = get_cached_object(Photo, pk=photo)
        url = photo.thumb_url()
        if not url:
            url = ''
        content = {'url': url}
    except (Photo.DoesNotExist):
        content = {'url': '', 'does_not_exist': True}
    return HttpResponse(simplejson.dumps(content))
Пример #20
0
def get_thumb_format():
    global _thumb_format
    from ella.photos.models import Format
    if _thumb_format == '--unset--':
        if not hasattr(newman_settings, 'PHOTOS_THUMB_FORMAT'):
            _thumb_format = None
        else:
            _thumb_format = get_cached_object(Format, name=newman_settings.PHOTOS_THUMB_FORMAT)

    return _thumb_format
Пример #21
0
def thumb_url(request, photo):
    try:
        photo = get_cached_object(Photo, pk=photo)
        url = photo.thumb_url()
        if not url:
            url = ''
        content = {'url': url}
    except (Photo.DoesNotExist):
        content = {'url': '', 'does_not_exist': True}
    return HttpResponse(simplejson.dumps(content))
Пример #22
0
def get_thumb_format():
    global _thumb_format
    from ella.photos.models import Format
    if _thumb_format == '--unset--':
        if not hasattr(newman_settings, 'PHOTOS_THUMB_FORMAT'):
            _thumb_format = None
        else:
            _thumb_format = get_cached_object(
                Format, name=newman_settings.PHOTOS_THUMB_FORMAT)

    return _thumb_format
Пример #23
0
 def items(self, obj):
     kwa = {}
     if isinstance(obj, tuple):
         category, content_type = obj
         kwa['content_types'] = [ content_type ]
         kwa['category'] = category
     elif obj:
         kwa['category'] = obj
     else:
         kwa['category'] = get_cached_object(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
     return Listing.objects.get_listing(count=NUM_IN_FEED, **kwa)
Пример #24
0
    def get_formated_photo(self, format):
        "Return formated photo"
        format_object = Format.objects.get(name=format, sites=settings.SITE_ID)
        try:
            formated_photo = get_cached_object(FormatedPhoto, photo=self, format=format_object)
        except FormatedPhoto.DoesNotExist:
            try:
                formated_photo = FormatedPhoto.objects.create(photo=self, format=format_object)
            except (IOError, SystemError, IntegrityError):
                return None

        return formated_photo
Пример #25
0
    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), e:
                log.warning("Cannot create formatted photo due to %s.", e)
                return format.get_blank_img()
Пример #26
0
def media(parser, token):
    """
    Examples:

        {% media FORMAT for VAR as VAR_NAME %}
        {% media FORMAT with FIELD VALUE as VAR_NAME %}
    """
    bits = token.split_contents()

    if len(bits) < 2 or bits[-2] != 'as':
        raise template.TemplateSyntaxError, "{% media FORMAT for VAR as VAR_NAME %} or {% media FORMAT with FIELD VALUE as VAR_NAME %}"

    try:
        format = get_cached_object(Format, name=bits[1])
    except Format.DoesNotExist:
        raise template.TemplateSyntaxError, "Format with name %r does not exist" % bits[1]

    if len(bits) == 6:
        # media FORMAT for VAR
        if bits[2] != 'for':
            raise template.TemplateSyntaxError, "{% media FORMAT for VAR as VAR_NAME %}"
        formatted_media = bits[3]
    elif len(bits) == 7:
        # media FORMAT with FIELD VALUE
        if bits[2] != 'with':
            raise template.TemplateSyntaxError, "{% media FORMAT with FIELD VALUE as VAR_NAME %}"
        try:
            media = get_cached_object(Media, **{str(bits[3]) : bits[4]})
        except media.DoesNotExist:
            raise template.TemplateSyntaxError, "Media with %r of %r does not exist" % (bits[3],  bits[4])

        try:
            formatted_media = get_cached_object(Target, source=media.file, format=format)
        except Target.DoesNotExist:
            raise template.TemplateSyntaxError, "Format %r for media with %r of %r does not exist" % (bits[1], bits[3],  bits[4])
    else:
        raise template.TemplateSyntaxError, "{% media FORMAT for VAR as VAR_NAME %} or {% media FORMAT with FIELD VALUE as VAR_NAME %}"

    return MediaTag(formatted_media, format, bits[-1])
Пример #27
0
    def test_save_invalidates_object(self):
        self.ct = ContentType.objects.get_for_model(ContentType)
        ct = utils.get_cached_object(self.ct, pk=self.ct.pk)

        tools.assert_equals(ct, self.ct)
        tools.assert_equals(
            self.ct,
            self.cache.get(
                utils._get_key(utils.KEY_PREFIX, self.ct, pk=self.ct.pk)))
        self.ct.save()
        tools.assert_equals(
            None,
            self.cache.get(
                utils._get_key(utils.KEY_PREFIX, self.ct, pkr=self.ct.pk)))
Пример #28
0
def detail(request, category, url_remainder=''):
    path = category.split('/')

    # construct all possible tree_paths and get their IDs from redis
    part = []
    pipe = redis.pipeline()
    for p in path:
        part.append(p)
        pipe.get(REDIS_KEY % '/'.join(part))
    ids = pipe.execute()

    # no IDs -> 404
    if not any(ids):
        raise Http404()
    # get the last ID == the most specific wiki object
    id = filter(None, ids)[-1]
    wiki = get_cached_object(Wiki, pk=id)

    if not (wiki.is_published() or wiki_settings.IS_MODERATOR_FUNC(request.user)):
        # future publish, render if accessed by moderator
        raise Http404()

    # treat the rest as part of custom_urls part
    leftover = category[len(wiki.tree_path):]

    object_rendering.send(sender=Wiki, request=request, category=wiki.category, publishable=wiki)
    context = {
        'category': wiki.category,
        'object': wiki,
        'content_type': wiki.content_type,
    }

    # custom urls
    if leftover or url_remainder:
        url_remainder = ('%s/%s' % (leftover, url_remainder)). strip('/') + '/'
        return custom_urls.resolver.call_custom_view(request, wiki, url_remainder, context)

    # ella API
    response = render_as_api(request, wiki)
    if response:
        return response

    # custom detail
    if custom_urls.resolver.has_custom_detail(wiki):
        return custom_urls.resolver.call_custom_detail(request, context)

    object_rendered.send(sender=Wiki, request=request, category=wiki.category, publishable=wiki)

    return TemplateResponse(request, get_templates_from_publishable('object.html', wiki), context)
Пример #29
0
    def get_for_path(self, path):
        """Returns a CategorySubdomain instance for a first part of the path
        if present in the database.
        """
        path_items = [path_item for path_item in path.split('/') if len(path_item) > 0]
        result = None
        if (len(path_items) > 0):
            slug = path_items[0]
            try:
                result = get_cached_object(self.model, \
                        category__slug=slug, category__site__id=settings.SITE_ID)
            except self.model.DoesNotExist:
                pass

        return result
Пример #30
0
    def get_object(self, bits):
        try:
            ct = get_content_type(bits[-1])
            bits = bits[:-1]
        except (Http404, IndexError):
            ct = False

        if bits:
            cat = get_cached_object_or_404(Category, tree_path=u'/'.join(bits), site__id=settings.SITE_ID)
        else:
            cat = get_cached_object(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)

        if ct:
            return (cat, ct)
        return cat
Пример #31
0
Файл: feeds.py Проект: whit/ella
    def get_object(self, bits):
        try:
            ct = get_content_type(bits[-1])
            bits = bits[:-1]
        except (Http404, IndexError):
            ct = False

        if bits:
            cat = get_cached_object_or_404(Category, tree_path=u'/'.join(bits), site__id=settings.SITE_ID)
        else:
            cat = get_cached_object(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)

        if ct:
            return (cat, ct)
        return cat
Пример #32
0
    def render(self, context):
        if self.model and self.lookup:
            try:
                lookup_val = template.Variable(self.lookup[1]).resolve(context)
            except template.VariableDoesNotExist:
                lookup_val = self.lookup[1]

            try:
                obj = get_cached_object(self.model, **{self.lookup[0] : lookup_val})
            except models.ObjectDoesNotExist, e:
                log.error('BoxNode: %s (%s : %s)' % (str(e), self.lookup[0], lookup_val))
                return ''
            except AssertionError, e:
                log.error('BoxNode: %s (%s : %s)' % (str(e), self.lookup[0], lookup_val))
                return ''
Пример #33
0
    def get_formated_photo(self, format):
        "Return formated photo"
        format_object = Format.objects.get(name=format, sites=settings.SITE_ID)
        try:
            formated_photo = get_cached_object(FormatedPhoto,
                                               photo=self,
                                               format=format_object)
        except FormatedPhoto.DoesNotExist:
            try:
                formated_photo = FormatedPhoto.objects.create(
                    photo=self, format=format_object)
            except (IOError, SystemError, IntegrityError):
                return None

        return formated_photo
Пример #34
0
    def items(self, obj):
        kwa = {}
        if isinstance(obj, tuple):
            category, content_type = obj
            kwa['content_types'] = [ content_type ]
            kwa['category'] = category
        elif obj:
            kwa['category'] = obj
        else:
            kwa['category'] = get_cached_object(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)

        # TODO: In ella based application children attr can be NONE, IMMEDIATE and ALL
        if kwa['category'].tree_parent != None:
            kwa['children'] = Listing.objects.ALL

        return Listing.objects.get_listing(count=core_settings.RSS_NUM_IN_FEED, **kwa)
Пример #35
0
Файл: feeds.py Проект: whit/ella
    def items(self, obj):
        kwa = {}
        if isinstance(obj, tuple):
            category, content_type = obj
            kwa['content_types'] = [ content_type ]
            kwa['category'] = category
        elif obj:
            kwa['category'] = obj
        else:
            kwa['category'] = get_cached_object(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)

        # TODO: In ella based application children attr can be NONE, IMMEDIATE and ALL
        if kwa['category'].tree_parent != None:
            kwa['children'] = Listing.objects.ALL

        return Listing.objects.get_listing(count=core_settings.RSS_NUM_IN_FEED, **kwa)
Пример #36
0
    def render(self, context):

        if isinstance(self.media, basestring):
            try:
                media = template.resolve_variable(self.media, context)
            except template.VariableDoesNotExist:
                return ''
            try:
                formatted_media = get_cached_object(Target, source=media.file, format=self.format)
            except Target.DoesNotExist:
                return ''
        else:
            formatted_media = self.media

        context[self.var_name] = formatted_media
        return ''
Пример #37
0
 def render(self, context):
     if isinstance(self.photo, basestring):
         try:
             photo = template.Variable(self.photo).resolve(context)
             if not photo:
                 return ''
         except template.VariableDoesNotExist:
             return ''
         try:
             formated_photo = get_cached_object(FormatedPhoto, photo=photo, format=self.format)
         except FormatedPhoto.DoesNotExist:
             try:
                 formated_photo = FormatedPhoto.objects.create(photo=photo, format=self.format)
             except (IOError, SystemError, IntegrityError), e:
                 log.error("Cannot create formatted photo: %s" % e)
                 context[self.var_name] = self.format.get_blank_img()
                 return ''
Пример #38
0
    def get_for_path(self, path):
        """Returns a CategorySubdomain instance for a first part of the path
        if present in the database.
        """
        path_items = [
            path_item for path_item in path.split('/') if len(path_item) > 0
        ]
        result = None
        if (len(path_items) > 0):
            slug = path_items[0]
            try:
                result = get_cached_object(self.model, \
                        category__slug=slug, category__site__id=settings.SITE_ID)
            except self.model.DoesNotExist:
                pass

        return result
Пример #39
0
    def get_obj(self, context=None):
        if self.model and self.lookup:
            if context:
                try:
                    lookup_val = template.Variable(self.lookup[1]).resolve(context)
                except template.VariableDoesNotExist:
                    lookup_val = self.lookup[1]
            else:
                lookup_val = self.lookup[1]

            try:
                obj = get_cached_object(self.model, **{self.lookup[0] : lookup_val})
            except models.ObjectDoesNotExist, e:
                log.error('BoxNode: %s (%s : %s)' % (str(e), self.lookup[0], lookup_val))
                raise ObjectNotFoundOrInvalid()
            except AssertionError, e:
                log.error('BoxNode: %s (%s : %s)' % (str(e), self.lookup[0], lookup_val))
                raise ObjectNotFoundOrInvalid()
Пример #40
0
    def render(self, context):
        unique_var_name = None
        for key in self.parameters_to_resolve:
            if key == 'unique':
                unique_var_name = self.parameters[key]
            if key == 'unique' and unique_var_name not in context.dicts[-1]: # autocreate variable in context
                self.parameters[key] = context.dicts[-1][ unique_var_name ] = set()
                continue
            self.parameters[key] = template.Variable(self.parameters[key]).resolve(context)
        if self.parameters.has_key('category') and isinstance(self.parameters['category'], basestring):
            self.parameters['category'] = get_cached_object(Category, tree_path=self.parameters['category'], site__id=settings.SITE_ID)
        out = Listing.objects.get_listing(**self.parameters)

        if 'unique' in self.parameters:
            unique = self.parameters['unique'] #context[unique_var_name]
            map(lambda x: unique.add(x.placement_id),out)
        context[self.var_name] = out
        return ''
Пример #41
0
Файл: media.py Проект: whit/ella
    def render(self, context):

        if isinstance(self.media, basestring):
            try:
                media = template.resolve_variable(self.media, context)
            except template.VariableDoesNotExist:
                return ''
            try:
                formatted_media = get_cached_object(Target,
                                                    source=media.file,
                                                    format=self.format)
            except Target.DoesNotExist:
                return ''
        else:
            formatted_media = self.media

        context[self.var_name] = formatted_media
        return ''
Пример #42
0
 def title(self, obj):
     if isinstance(obj, tuple):
         category, content_type = obj
         return _('Top %(count)d %(ctype)s objects in category %(cat)s.') % {
                 'count' : core_settings.RSS_NUM_IN_FEED,
                 'ctype' : content_type.model_class()._meta.verbose_name_plural,
                 'cat' : category.title
         }
     elif obj:
         return _('Top %(count)d objects in category %(cat)s.') % {
                 'count' : core_settings.RSS_NUM_IN_FEED,
                 'cat' : obj.title
         }
     else:
         obj = get_cached_object(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
         return _('Top %(count)d objects in category %(cat)s.') % {
                 'count' : core_settings.RSS_NUM_IN_FEED,
                 'cat' : obj.title
         }
Пример #43
0
Файл: feeds.py Проект: whit/ella
 def title(self, obj):
     if isinstance(obj, tuple):
         category, content_type = obj
         return _('Top %(count)d %(ctype)s objects in category %(cat)s.') % {
                 'count' : core_settings.RSS_NUM_IN_FEED,
                 'ctype' : content_type.model_class()._meta.verbose_name_plural,
                 'cat' : category.title
         }
     elif obj:
         return _('Top %(count)d objects in category %(cat)s.') % {
                 'count' : core_settings.RSS_NUM_IN_FEED,
                 'cat' : obj.title
         }
     else:
         obj = get_cached_object(Category, tree_parent__isnull=True, site__id=settings.SITE_ID)
         return _('Top %(count)d objects in category %(cat)s.') % {
                 'count' : core_settings.RSS_NUM_IN_FEED,
                 'cat' : obj.title
         }
Пример #44
0
 def render(self, ctx):
     if self.tree_path == self.tree_path.strip('"'):
         try:
             root_cat = template.Variable(self.tree_path).resolve(ctx)
         except template.TemplateSyntaxError:
             return ''
     else:
         try:
             root_cat = get_cached_object(Category, tree_path=self.tree_path.strip('"'), site = settings.SITE_ID)
         except Category.DoesNotExist:
             return ''
     try:
         cats = Category.objects.filter(tree_parent=root_cat).order_by('title')
         if self.limit:
             cats = cats[:self.limit]
         ctx.update({self.varname: cats})
     except Category.DoesNotExist:
         pass
     return ''
Пример #45
0
 def render(self, context):
     if isinstance(self.photo, basestring):
         try:
             photo = template.Variable(self.photo).resolve(context)
             if not photo:
                 return ''
         except template.VariableDoesNotExist:
             return ''
         try:
             formated_photo = get_cached_object(FormatedPhoto,
                                                photo=photo,
                                                format=self.format)
         except FormatedPhoto.DoesNotExist:
             try:
                 formated_photo = FormatedPhoto.objects.create(
                     photo=photo, format=self.format)
             except (IOError, SystemError, IntegrityError), e:
                 log.error("Cannot create formatted photo: %s" % e)
                 context[self.var_name] = self.format.get_blank_img()
                 return ''
Пример #46
0
    def render(self, context):
        try:
            obj = template.Variable(self.obj_var).resolve(context)
        except template.VariableDoesNotExist:
            return ''

        related = []
        count = self.count

        # manually entered dependencies
        for rel in Related.objects.filter(source_ct=ContentType.objects.get_for_model(obj), source_id=obj._get_pk_val()):
            related.append(rel)
            count -= 1
            if count <= 0:
                break

        # related objects vie tags
        if self.models and count > 0:
            from ella.tagging.models import TaggedItem
            for m in self.models:
                to_add = TaggedItem.objects.get_related(obj, m, count)
                for rel in to_add:
                    if rel != obj and rel not in related:
                        count -= 1
                        related.append(rel)
                    if count <= 0:
                        break

        # top objects in given category
        if count > 0:
            cat = get_cached_object(Category, pk=obj.category_id)
            listings = Listing.objects.get_listing(category=cat, count=count, mods=self.models)
            ext = [ listing.target for listing in listings if listing.target != obj ]
            related.extend(ext)
            count -= len(ext)
        if self.all_categories and count > 0:
            listings = Listing.objects.get_listing(count=count, mods=self.models)
            related.extend(listing.target for listing in listings if listing.target != obj)

        context[self.var_name] = related
        return ''
Пример #47
0
Файл: core.py Проект: Pheox/ella
    def get_obj(self, context):
        if self.model and self.lookup:
            if isinstance(self.lookup[1], template.Variable):
                try:
                    lookup_val = self.lookup[1].resolve(context)
                except template.VariableDoesNotExist, e:
                    log.warning(
                        'BoxNode: Template variable does not exist. var_name=%s',
                        self.lookup[1].var)
                    raise ObjectNotFoundOrInvalid()

            else:
                lookup_val = self.lookup[1]

            try:
                obj = get_cached_object(self.model,
                                        **{self.lookup[0]: lookup_val})
            except (models.ObjectDoesNotExist, AssertionError), e:
                log.warning('BoxNode: %s (%s : %s)', str(e), self.lookup[0],
                            lookup_val)
                raise ObjectNotFoundOrInvalid()
Пример #48
0
Файл: core.py Проект: whit/ella
    def get_obj(self, context=None):
        if self.model and self.lookup:
            if context:
                try:
                    lookup_val = template.Variable(
                        self.lookup[1]).resolve(context)
                except template.VariableDoesNotExist:
                    lookup_val = self.lookup[1]
            else:
                lookup_val = self.lookup[1]

            try:
                obj = get_cached_object(self.model,
                                        **{self.lookup[0]: lookup_val})
            except models.ObjectDoesNotExist, e:
                log.error('BoxNode: %s (%s : %s)' %
                          (str(e), self.lookup[0], lookup_val))
                raise ObjectNotFoundOrInvalid()
            except AssertionError, e:
                log.error('BoxNode: %s (%s : %s)' %
                          (str(e), self.lookup[0], lookup_val))
                raise ObjectNotFoundOrInvalid()
Пример #49
0
    def _get_template_list(self):
        " Get the hierarchy of templates belonging to the object/box_type given. "
        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.app_label, self.module_name)
            if hasattr(self.obj, 'slug'):
                t_list.append(base_path + '%s/%s.html' % (self.obj.slug, self.box_type,))
            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.app_label, self.module_name)
        if hasattr(self.obj, 'slug'):
            t_list.append(base_path + '%s/%s.html' % (self.obj.slug, self.box_type,))
        t_list.append(base_path + '%s.html' % (self.box_type,))
        t_list.append(base_path + 'box.html')

        t_list.append('box/%s.html' % self.box_type)
        t_list.append('box/box.html')

        return t_list
Пример #50
0
    def get_for_host(self, host):
        """Searches for a CategorySubdomain instance matching the first part
        of the domain.
        """
        # split the domain into parts
        domain_parts = host.split('.')
        # prepare the default response
        result = None
        # process the domain if it is of the 3rd level or more
        if (len(domain_parts) > 2):
            # get the first part of the domain
            subdomain = domain_parts[0].lower()

            try:
                # get the category subdomain
                result = get_cached_object(self.model, \
                        subdomain_slug=subdomain, category__site__id=settings.SITE_ID)

            except self.model.DoesNotExist:
                # category subdomain does not exists
                pass

        return result
Пример #51
0
    def get_for_host(self, host):
        """Searches for a CategorySubdomain instance matching the first part
        of the domain.
        """
        # split the domain into parts
        domain_parts = host.split('.')
        # prepare the default response
        result = None
        # process the domain if it is of the 3rd level or more
        if (len(domain_parts) > 2):
            # get the first part of the domain
            subdomain = domain_parts[0].lower()

            try:
                # get the category subdomain
                result = get_cached_object(self.model, \
                        subdomain_slug=subdomain, category__site__id=settings.SITE_ID)

            except self.model.DoesNotExist:
                # category subdomain does not exists
                pass

        return result
Пример #52
0
    def test_get_publishable_returns_subclass(self):
        create_basic_categories(self)
        create_and_place_a_publishable(self)

        tools.assert_equals(self.publishable, utils.get_cached_object(Publishable, pk=self.publishable.pk))
Пример #53
0
 def author(self):
     if self.is_authorized:
         user = get_cached_object(User, pk=self.user_id)
         return user.username
     return self.nickname
Пример #54
0
                val = getattr(instance, self.field.attname)
                if val is None:
                    # If NULL is an allowed value, return it.
                    if self.field.null:
                        return None
                    raise self.field.rel.to.DoesNotExist
                rel_obj = retrieve_func(self.field.rel.to, val)
                setattr(instance, cache_name, rel_obj)
                return rel_obj

    CustomForeignKey.__name__ = name
    return CustomForeignKey


CachedForeignKey = generate_fk_class('CachedForeignKey',
                                     lambda m, pk: get_cached_object(m, pk=pk))


def get_site(model, pk):
    try:
        return SITE_CACHE[pk]
    except KeyError:
        SITE_CACHE[pk] = get_cached_object(model, pk=pk)
        return SITE_CACHE[pk]


SiteForeignKey = generate_fk_class('SiteForeignKey', get_site, Site)
ContentTypeForeignKey = generate_fk_class(
    'ContentTypeForeignKey', lambda m, pk: m._default_manager.get_for_id(pk),
    ContentType)
CategoryForeignKey = generate_fk_class(
Пример #55
0
def get_site(model, pk):
    try:
        return SITE_CACHE[pk]
    except KeyError:
        SITE_CACHE[pk] = get_cached_object(model, pk=pk)
        return SITE_CACHE[pk]
Пример #56
0
 def get_part_for_placement(self, placement):
     """ Return serie part for placement """
     return get_cached_object(SeriePart, placement=placement)
Пример #57
0
def get_site(model, pk):
    try:
        return SITE_CACHE[pk]
    except KeyError:
        SITE_CACHE[pk] = get_cached_object(model, pk=pk)
        return SITE_CACHE[pk]