コード例 #1
0
    def render(self, context):
        from django.db.models.options import Options
        from django.contrib.contenttypes.models import ContentType
        from freppledb.admin import data_site
        from django.core.urlresolvers import reverse
        try:
            # Look up the admin class to use
            model = Variable(self.model).resolve(context)
            if not model:
                return ''
            if isinstance(model, Options):
                ct = ContentType.objects.get(app_label=model.app_label,
                                             model=model.object_name.lower())
            elif isinstance(model, models.Model):
                ct = ContentType.objects.get(
                    app_label=model._meta.app_label,
                    model=model._meta.object_name.lower())
            else:
                model = model.split(".")
                ct = ContentType.objects.get(app_label=model[0],
                                             model=model[1])
            admn = data_site._registry[ct.model_class()]
            if not hasattr(admn, 'tabs'):
                return ''

            # Render the admin class
            result = [
                '<div class="row"><div id="tabs" class="col-md-12 form-inline hor-align-right"><ul class="nav nav-tabs">'
            ]
            obj = context['object_id']
            active_tab = context.get('active_tab', 'edit')
            for tab in admn.tabs:
                if 'permissions' in tab:
                    # A single permission is required
                    if isinstance(tab['permissions'], str):
                        if not context['request'].user.has_perm(
                                tab['permissions']):
                            continue
                    else:
                        # A list or tuple of permissions is given
                        ok = True
                        for p in tab['permissions']:
                            if not context['request'].user.has_perm(p):
                                ok = False
                                break
                        if not ok:
                            continue
                # Append to the results
                result.append(
                    '<li %srole="presentation"><a class="ui-tabs-anchor" href="%s%s" target="_self">%s</a></li>'
                    % ('class="active" ' if active_tab == tab['name'] else '',
                       context['request'].prefix,
                       reverse(tab['view'], args=(obj, )),
                       force_text(tab['label']).capitalize()))
            result.append('</ul></div></div>')
            return '\n'.join(result)
        except:
            if settings.TEMPLATE_DEBUG:
                raise
            return ''
コード例 #2
0
ファイル: templatetags.py プロジェクト: zodioo-team/frepple
    def render(self, context):
        from django.db.models.options import Options
        from django.contrib.contenttypes.models import ContentType

        try:
            # Look up the admin class to use
            model = Variable(self.model).resolve(context)
            pk = Variable(self.pk).resolve(context)
            request = Variable("request").resolve(context)
            if not model or not pk:
                context[self.var] = None
                return mark_safe("")
            if isinstance(model, Options):
                ct = ContentType.objects.get(app_label=model.app_label,
                                             model=model.object_name.lower())
            elif isinstance(model, models.Model):
                ct = ContentType.objects.get_for_model(model)
            else:
                model = model.split(".")
                ct = ContentType.objects.get(app_label=model[0],
                                             model=model[1])
            context[self.var] = NotificationFactory.getFollower(
                object_pk=pk,
                content_type=ct,
                user=request.user,
                database=request.database,
            )
        except Exception:
            context[self.var] = None
        return mark_safe("")
コード例 #3
0
ファイル: countthis.py プロジェクト: maxcutler/Courant-News
class MostPopularNode(Node):

    def __init__(self, appmodel, type, limit, days, varname, force=False):
        self.appmodel = appmodel
        self.limit = limit
        self.days = days
        self.varname = varname
        self.force = force

        if type == 'viewed':
            self.type = 'view_count'
        elif type == 'emailed':
            self.type = 'email_count'
        elif type == 'commented':
            self.type = 'comment_count'
        else:
            raise TemplateSyntaxError('The only supported types for this template tag are viewed, emailed, and commented.')

    def render(self, context):
        from courant.core.countthis.models import Statistic
        from datetime import timedelta, datetime

        try:
            self.appmodel = Variable(self.appmodel).resolve(context)
        except VariableDoesNotExist:
            pass #Just leave it alone

        #These are numbers, so either they'll resolve to a variable or resolve will return the number
        self.limit = Variable(self.limit).resolve(context)
        self.days = Variable(self.days).resolve(context)

        #We have to get the ContentType from the app.model string
        appmodel = self.appmodel.split('.')
        content_object = ContentType.objects.get(app_label=appmodel[0], model=appmodel[1])
        content_object_model = content_object.model_class()

        content_type_list = [content_object.pk]
        for related_object in content_object_model._meta.get_all_related_objects():
            if issubclass(related_object.model, content_object_model):
                content_type_list.append(ContentType.objects.get_for_model(related_object.model).pk)

        #Get the right objects
        while True:
            statistics_objects = Statistic.objects.filter(content_type__in=content_type_list, created_at__gte=datetime.now() - timedelta(days=self.days)).order_by('-' + self.type)

            #Do we have enough?
            if self.force and statistics_objects.count() < self.limit:
                self.days = self.days + 7
                continue

            #We have enough!
            statistics_objects = statistics_objects[:self.limit]
            break

        #Create a dictionary of just the content_objects and view_counts, so they don't get Statistic models back and have to do object.content_object
        context[self.varname] = [{appmodel[1]: obj.content_object, 'count': getattr(obj, self.type)} for obj in statistics_objects]
        return ''
コード例 #4
0
ファイル: base_utils.py プロジェクト: tiexinliu/frePPLe
    def render(self, context):
        from django.db.models.options import Options
        from django.contrib.contenttypes.models import ContentType
        from freppledb.admin import data_site
        from django.core.urlresolvers import reverse

        try:
            # Look up the admin class to use
            model = Variable(self.model).resolve(context)
            if isinstance(model, Options):
                ct = ContentType.objects.get(app_label=model.app_label, model=model.object_name.lower())
            else:
                model = model.split(".")
                ct = ContentType.objects.get(app_label=model[0], model=model[1])
            admn = data_site._registry[ct.model_class()]
            if not hasattr(admn, "tabs"):
                return ""

            # Render the admin class
            result = [
                '<div class="row"><div id="tabs" class="col-md-12 form-inline hor-align-right"><ul class="nav nav-tabs">'
            ]
            obj = context["object_id"]
            active_tab = context.get("active_tab", "edit")
            for tab in admn.tabs:
                if "permissions" in tab:
                    # A single permission is required
                    if isinstance(tab["permissions"], str):
                        if not context["request"].user.has_perm(tab["permissions"]):
                            continue
                    else:
                        # A list or tuple of permissions is given
                        ok = True
                        for p in tab["permissions"]:
                            if not context["request"].user.has_perm(p):
                                ok = False
                                break
                        if not ok:
                            continue
                # Append to the results
                result.append(
                    '<li %srole="presentation"><a class="ui-tabs-anchor" href="%s%s">%s</a></li>'
                    % (
                        'class="active" ' if active_tab == tab["name"] else "",
                        context["request"].prefix,
                        reverse(tab["view"], args=(obj,)),
                        force_text(tab["label"]).capitalize(),
                    )
                )
            result.append("</ul></div></div>")
            return "\n".join(result)
        except:
            if settings.TEMPLATE_DEBUG:
                raise
            return ""
コード例 #5
0
ファイル: templatetags.py プロジェクト: frePPLe/frePPLe
  def render(self, context):
    from django.db.models.options import Options
    from django.contrib.contenttypes.models import ContentType
    from freppledb.admin import data_site
    from django.urls import reverse
    try:
      # Look up the admin class to use
      model = Variable(self.model).resolve(context)
      if not model:
        return mark_safe('')
      if isinstance(model, Options):
        ct = ContentType.objects.get(app_label=model.app_label, model=model.object_name.lower())
      elif isinstance(model, models.Model):
        ct = ContentType.objects.get(app_label=model._meta.app_label, model=model._meta.object_name.lower())
      else:
        model = model.split(".")
        ct = ContentType.objects.get(app_label=model[0], model=model[1])
      admn = data_site._registry[ct.model_class()]
      if not hasattr(admn, 'tabs'):
        return mark_safe('')

      # Render the admin class
      result = ['<div class="row"><div id="tabs" class="col-md-12 form-inline hor-align-right"><ul class="nav nav-tabs">']
      obj = context['object_id']
      active_tab = context.get('active_tab', 'edit')
      for tab in admn.tabs:
        if 'permissions' in tab:
          # A single permission is required
          if isinstance(tab['permissions'], str):
            if not context['request'].user.has_perm(tab['permissions']):
              continue
          else:
            # A list or tuple of permissions is given
            ok =  True
            for p in tab['permissions']:
              if not context['request'].user.has_perm(p):
                ok = False
                break
            if not ok:
              continue
        # Append to the results
        result.append(
          '<li %srole="presentation"><a class="ui-tabs-anchor" href="%s%s" target="_self">%s</a></li>' % (
          'class="active" ' if active_tab == tab['name'] else '',
          context['request'].prefix,
          reverse(tab['view'], args=(obj,)),
          force_text(tab['label']).capitalize()
          ))
      result.append('</ul></div></div>')
      return mark_safe('\n'.join(result))
    except:
      raise
コード例 #6
0
    def render(self, context):
        tag_list_csv = Variable(self.tag_var).resolve(context)
        
        if (tag_list_csv is None):
            return None
            
        tag_list = tag_list_csv.split(',')
            
        #markup = ""
        #for tag in tag_list:
        #    markup += '<a href="/blog-term/%s" name="blogtag">%s</a>' % (tag, tag)
            # what is the "has next" syntax in an iterator in python
        markup = ', '.join(['<a href="/alfresco/tag_search?q=%s" name="blogtag">%s</a>' % (tag, tag) for tag in tag_list])

        return markup
コード例 #7
0
    def render(self, context):
        tag_list_csv = Variable(self.tag_var).resolve(context)

        if (tag_list_csv is None):
            return None

        tag_list = tag_list_csv.split(',')

        #markup = ""
        #for tag in tag_list:
        #    markup += '<a href="/blog-term/%s" name="blogtag">%s</a>' % (tag, tag)
        # what is the "has next" syntax in an iterator in python
        markup = ', '.join([
            '<a href="/alfresco/tag_search?q=%s" name="blogtag">%s</a>' %
            (tag, tag) for tag in tag_list
        ])

        return markup
コード例 #8
0
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = 'next_upcoming'
        event_type = ''
        group = u''
        start_dt = u''

        randomize = False

        if 'start_dt' in self.kwargs:
            try:
                start_dt = datetime.strptime(self.kwargs['start_dt'].replace('"', '').replace('"', ''), '%m/%d/%Y-%H:%M')
            except ValueError:
                pass

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = unicode(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = tags.split(',')

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
                if user == "anon" or user == "anonymous":
                    user = AnonymousUser()
        else:
            # check the context for an already existing user
            # and see if it is really a user object
            if 'user' in context:
                if isinstance(context['user'], User):
                    user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']

        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'type' in self.kwargs:
            try:
                event_type = Variable(self.kwargs['type'])
                event_type = event_type.resolve(context)
            except:
                event_type = self.kwargs['type']

        if 'group' in self.kwargs:
            try:
                group = Variable(self.kwargs['group'])
                group = unicode(group.resolve(context))
            except:
                group = self.kwargs['group']

            try:
                group = int(group)
            except:
                group = None

        filters = get_query_filters(user, 'events.view_event')
        items = Event.objects.filter(filters)
        if user.is_authenticated():
            if not user.profile.is_superuser:
                items = items.distinct()

        if event_type:
            items = items.filter(type__name__iexact=event_type)

        if tags:  # tags is a comma delimited list
            # this is fast; but has one hole
            # it finds words inside of other words
            # e.g. "prev" is within "prevent"
            tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
            tag_queries += [Q(tags__istartswith=t.strip()+",") for t in tags]
            tag_queries += [Q(tags__iendswith=", "+t.strip()) for t in tags]
            tag_queries += [Q(tags__iendswith=","+t.strip()) for t in tags]
            tag_queries += [Q(tags__icontains=", "+t.strip()+",") for t in tags]
            tag_queries += [Q(tags__icontains=","+t.strip()+",") for t in tags]
            tag_query = reduce(or_, tag_queries)
            items = items.filter(tag_query)

        if hasattr(self.model, 'group') and group:
            items = items.filter(groups=group)
        if hasattr(self.model, 'groups') and group:
            items = items.filter(groups__in=[group])

        objects = []

        if start_dt:
            items = items.filter(start_dt__gte=start_dt)
            
        # exclude private events
        items = items.filter(enable_private_slug=False)

        # if order is not specified it sorts by relevance
        if order:
            if order == "next_upcoming":
                if not start_dt:
                    # Removed seconds and microseconds so we can cache the query better
                    now = datetime.now().replace(second=0, microsecond=0)
                    items = items.filter(start_dt__gt=now)
                items = items.order_by("start_dt")
            elif order == "current_and_upcoming":
                if not start_dt:
                    now = datetime.now().replace(second=0, microsecond=0)
                    items = items.filter(Q(start_dt__gt=now) | Q(end_dt__gt=now))
                items = items.order_by("start_dt")
            elif order == "current_and_upcoming_by_hour":
                now = datetime.now().replace(second=0, microsecond=0)
                today = datetime.now().replace(second=0, hour=0, minute=0, microsecond=0)
                tomorrow = today + timedelta(days=1)
                items = items.filter(Q(start_dt__lte=tomorrow) & Q(end_dt__gte=today)).extra(select={'hour': 'extract( hour from start_dt )'}).extra(select={'minute': 'extract( minute from start_dt )'}).extra(where=["extract( hour from start_dt ) >= %s"], params=[now.hour])
                items = items.distinct()
                items = items.order_by('hour', 'minute')
            else:
                items = items.order_by(order)

        if randomize:
            objects = [item for item in random.sample(items, items.count())][:limit]
        else:
            objects = [item for item in items[:limit]]

        context[self.context_var] = objects
        return ""
コード例 #9
0
ファイル: templatetags.py プロジェクト: zodioo-team/frepple
    def render(self, context):
        from django.db.models.options import Options
        from django.contrib.contenttypes.models import ContentType
        from freppledb.admin import data_site
        from django.urls import reverse

        try:
            # Look up the admin class to use
            model = Variable(self.model).resolve(context)
            if not model:
                return mark_safe("")
            if isinstance(model, Options):
                ct = ContentType.objects.get(app_label=model.app_label,
                                             model=model.object_name.lower())
            elif isinstance(model, models.Model):
                ct = ContentType.objects.get(
                    app_label=model._meta.app_label,
                    model=model._meta.object_name.lower(),
                )
            else:
                model = model.split(".")
                ct = ContentType.objects.get(app_label=model[0],
                                             model=model[1])
            admn = data_site._registry[ct.model_class()]
            if not hasattr(admn, "tabs"):
                return mark_safe("")

            # Render the admin class
            result = [
                '<div class="row"><div id="tabs" class="col-md-12 form-inline hor-align-right"><ul class="nav nav-tabs">'
            ]
            obj = context["object_id"]
            active_tab = context.get("active_tab", "edit")
            for tab in admn.tabs:
                if "permissions" in tab:
                    # A single permission is required
                    if isinstance(tab["permissions"], str):
                        if not context["request"].user.has_perm(
                                tab["permissions"]):
                            continue
                    else:
                        # A list or tuple of permissions is given
                        ok = True
                        for p in tab["permissions"]:
                            if not context["request"].user.has_perm(p):
                                ok = False
                                break
                        if not ok:
                            continue
                # Append to the results
                result.append(
                    '<li %srole="presentation"><a class="ui-tabs-anchor" href="%s%s?noautofilter" target="_self">%s</a></li>'
                    % (
                        'class="active" ' if active_tab == tab["name"] else "",
                        context["request"].prefix,
                        reverse(tab["view"], args=(obj, )),
                        force_text(tab["label"]).capitalize(),
                    ))
            result.append("</ul></div></div>")
            return mark_safe("\n".join(result))
        except Exception:
            raise
コード例 #10
0
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = u''
        exclude = u''
        randomize = False
        group = u''
        status_detail = u'active'

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = str(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = tags.split(',')

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
                if user == "anon" or user == "anonymous":
                    user = AnonymousUser()
        # for performance reason, if user is not passed in, use AnonymousUser
#         else:
#             # check the context for an already existing user
#             # and see if it is really a user object
#             if 'user' in context:
#                 if isinstance(context['user'], User):
#                     user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']
        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'exclude' in self.kwargs:
            try:
                exclude = Variable(self.kwargs['exclude'])
                exclude = str(exclude.resolve(context))
            except:
                exclude = self.kwargs['exclude']

            exclude = exclude.replace('"', '')
            exclude = exclude.split(',')

        if 'group' in self.kwargs:
            try:
                group = Variable(self.kwargs['group'])
                group = str(group.resolve(context))
            except:
                group = self.kwargs['group']

            try:
                group = int(group)
            except:
                group = None

        if 'status_detail' in self.kwargs:
            try:
                status_detail = Variable(self.kwargs['status_detail'])
                status_detail = status_detail.resolve(context)
            except:
                status_detail = self.kwargs['status_detail']

        # get the list of items
        self.perms = getattr(self, 'perms', str())

        # Only use the search index if there is a query passed
        if query:
            for tag in tags:
                tag = tag.strip()
                query = '%s "tag:%s"' % (query, tag)

            items = self.model.objects.search(user=user, query=query)

        else:
            filters = get_query_filters(user, self.perms)
            items = self.model.objects.filter(filters)
            if user.is_authenticated:
                items = items.distinct()

            if tags:  # tags is a comma delimited list
                # this is fast; but has one hole
                # it finds words inside of other words
                # e.g. "prev" is within "prevent"
                tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
                tag_queries += [
                    Q(tags__istartswith=t.strip() + ",") for t in tags
                ]
                tag_queries += [
                    Q(tags__iendswith=", " + t.strip()) for t in tags
                ]
                tag_queries += [
                    Q(tags__iendswith="," + t.strip()) for t in tags
                ]
                tag_queries += [
                    Q(tags__icontains=", " + t.strip() + ",") for t in tags
                ]
                tag_queries += [
                    Q(tags__icontains="," + t.strip() + ",") for t in tags
                ]
                tag_query = reduce(or_, tag_queries)
                items = items.filter(tag_query)

            if hasattr(self.model, 'group') and group:
                items = items.filter(group=group)
            if hasattr(self.model, 'groups') and group:
                items = items.filter(groups__in=[group])

            if hasattr(self.model(), 'status_detail'):
                items = items.filter(status_detail__iexact=status_detail)

            items = self.custom_model_filter(items, user)

        objects = []

        # exclude certain primary keys
        if exclude:
            excludes = []
            for ex in exclude:
                if ex.isdigit():
                    excludes.append(int(ex))
            if query:
                items = items.exclude(primary_key__in=excludes)
            else:
                items = items.exclude(pk__in=excludes)

        # if order is not specified it sorts by relevance
        if order:
            items = items.order_by(order)

        if randomize:
            items = list(items)
            objects = random.sample(items, min(len(items), limit))
        else:
            objects = items[:limit]

        if query:
            objects = [item.object for item in objects]

        context[self.context_var] = objects

        if 'template' in self.kwargs:
            try:
                template = Variable(self.kwargs['template'])
                template = str(template.resolve(context))
            except:
                template = self.kwargs['template']

            t = context.template.engine.get_template(template)
            return t.render(context=context, autoescape=context.autoescape)

        return ""
コード例 #11
0
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = u''
        randomize = False
        group = u''

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = str(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = [t.strip() for t in tags.split(',')]

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
        else:
            # check the context for an already existing user
            if 'user' in context:
                user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']

        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'group' in self.kwargs:
            try:
                group = Variable(self.kwargs['group'])
                group = str(group.resolve(context))
            except:
                group = self.kwargs['group']

            try:
                group = int(group)
            except:
                group = None

        filters = get_query_filters(user, self.perms)
        items = self.model.objects.filter(filters)
        if isinstance(user, User) and user.is_authenticated:
            if not user.profile.is_superuser:
                items = items.distinct()

        if tags:  # tags is a comma delimited list
            # this is fast; but has one hole
            # it finds words inside of other words
            # e.g. "prev" is within "prevent"
            tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
            tag_queries += [Q(tags__istartswith=t.strip() + ",") for t in tags]
            tag_queries += [Q(tags__iendswith=", " + t.strip()) for t in tags]
            tag_queries += [Q(tags__iendswith="," + t.strip()) for t in tags]
            tag_queries += [
                Q(tags__icontains=", " + t.strip() + ",") for t in tags
            ]
            tag_queries += [
                Q(tags__icontains="," + t.strip() + ",") for t in tags
            ]
            tag_query = reduce(or_, tag_queries)
            items = items.filter(tag_query)

        if group:
            items = items.filter(group=group)

        objects = []

        # Removed seconds and microseconds so we can cache the query better
        now = datetime.now().replace(second=0, microsecond=0)

        # Custom filter for stories
        date_query = reduce(or_, [Q(end_dt__gte=now), Q(expires=False)])
        date_query = reduce(and_, [Q(start_dt__lte=now), date_query])
        items = items.filter(date_query)

        if order:
            items = items.order_by(order)
        else:
            items = items.order_by('-position', '-start_dt')

        # if order is not specified it sorts by relevance
        if randomize:
            items = list(items)
            objects = random.sample(items, min(len(items), limit))
        else:
            objects = items[:limit]

        context[self.context_var] = objects

        return ""
コード例 #12
0
ファイル: event_tags.py プロジェクト: zenny/tendenci
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = 'next_upcoming'
        event_type = ''
        group = u''
        start_dt = u''

        randomize = False

        if 'start_dt' in self.kwargs:
            try:
                start_dt = datetime.strptime(
                    self.kwargs['start_dt'].replace('"', '').replace('"', ''),
                    '%m/%d/%Y-%H:%M')
            except ValueError:
                pass

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = unicode(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = tags.split(',')

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
                if user == "anon" or user == "anonymous":
                    user = AnonymousUser()
        else:
            # check the context for an already existing user
            # and see if it is really a user object
            if 'user' in context:
                if isinstance(context['user'], User):
                    user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']

        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'type' in self.kwargs:
            try:
                event_type = Variable(self.kwargs['type'])
                event_type = event_type.resolve(context)
            except:
                event_type = self.kwargs['type']

        if 'group' in self.kwargs:
            try:
                group = Variable(self.kwargs['group'])
                group = unicode(group.resolve(context))
            except:
                group = self.kwargs['group']

            try:
                group = int(group)
            except:
                group = None

        filters = get_query_filters(user, 'events.view_event')
        items = Event.objects.filter(filters)
        if user.is_authenticated():
            if not user.profile.is_superuser:
                items = items.distinct()

        if event_type:
            items = items.filter(type__name__iexact=event_type)

        if tags:  # tags is a comma delimited list
            # this is fast; but has one hole
            # it finds words inside of other words
            # e.g. "prev" is within "prevent"
            tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
            tag_queries += [Q(tags__istartswith=t.strip() + ",") for t in tags]
            tag_queries += [Q(tags__iendswith=", " + t.strip()) for t in tags]
            tag_queries += [Q(tags__iendswith="," + t.strip()) for t in tags]
            tag_queries += [
                Q(tags__icontains=", " + t.strip() + ",") for t in tags
            ]
            tag_queries += [
                Q(tags__icontains="," + t.strip() + ",") for t in tags
            ]
            tag_query = reduce(or_, tag_queries)
            items = items.filter(tag_query)

        if hasattr(self.model, 'group') and group:
            items = items.filter(group=group)

        objects = []

        if start_dt:
            items = items.filter(start_dt__gte=start_dt)

        # if order is not specified it sorts by relevance
        if order:
            if order == "next_upcoming":
                if not start_dt:
                    # Removed seconds and microseconds so we can cache the query better
                    now = datetime.now().replace(second=0, microsecond=0)
                    items = items.filter(start_dt__gt=now)
                items = items.order_by("start_dt")
            elif order == "current_and_upcoming":
                if not start_dt:
                    now = datetime.now().replace(second=0, microsecond=0)
                    items = items.filter(
                        Q(start_dt__gt=now) | Q(end_dt__gt=now))
                items = items.order_by("start_dt")
            elif order == "current_and_upcoming_by_hour":
                now = datetime.now().replace(second=0, microsecond=0)
                today = datetime.now().replace(second=0,
                                               hour=0,
                                               minute=0,
                                               microsecond=0)
                tomorrow = today + timedelta(days=1)
                items = items.filter(
                    Q(start_dt__lte=tomorrow) & Q(end_dt__gte=today)).extra(
                        select={
                            'hour': 'extract( hour from start_dt )'
                        }).extra(select={
                            'minute': 'extract( minute from start_dt )'
                        }).extra(where=["extract( hour from start_dt ) >= %s"],
                                 params=[now.hour])
                items = items.distinct()
                items = items.order_by('hour', 'minute')
            else:
                items = items.order_by(order)

        if randomize:
            objects = [item
                       for item in random.sample(items, items.count())][:limit]
        else:
            objects = [item for item in items[:limit]]

        context[self.context_var] = objects
        return ""
コード例 #13
0
ファイル: template_tags.py プロジェクト: goetzk/tendenci
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = u''
        exclude = u''
        randomize = False
        group = u''
        status_detail = u'active'

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = unicode(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = tags.split(',')

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
                if user == "anon" or user == "anonymous":
                    user = AnonymousUser()
        # for performance reason, if user is not passed in, use AnonymousUser
#         else:
#             # check the context for an already existing user
#             # and see if it is really a user object
#             if 'user' in context:
#                 if isinstance(context['user'], User):
#                     user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']
        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'exclude' in self.kwargs:
            try:
                exclude = Variable(self.kwargs['exclude'])
                exclude = unicode(exclude.resolve(context))
            except:
                exclude = self.kwargs['exclude']

            exclude = exclude.replace('"', '')
            exclude = exclude.split(',')

        if 'group' in self.kwargs:
            try:
                group = Variable(self.kwargs['group'])
                group = unicode(group.resolve(context))
            except:
                group = self.kwargs['group']

            try:
                group = int(group)
            except:
                group = None

        if 'status_detail' in self.kwargs:
            try:
                status_detail = Variable(self.kwargs['status_detail'])
                status_detail = status_detail.resolve(context)
            except:
                status_detail = self.kwargs['status_detail']

        # get the list of items
        self.perms = getattr(self, 'perms', unicode())

        # Only use the search index if there is a query passed
        if query:
            for tag in tags:
                tag = tag.strip()
                query = '%s "tag:%s"' % (query, tag)

            items = self.model.objects.search(user=user, query=query)

        else:
            filters = get_query_filters(user, self.perms)
            items = self.model.objects.filter(filters)
            if user.is_authenticated():
                items = items.distinct()

            if tags:  # tags is a comma delimited list
                # this is fast; but has one hole
                # it finds words inside of other words
                # e.g. "prev" is within "prevent"
                tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
                tag_queries += [Q(tags__istartswith=t.strip() + ",") for t in tags]
                tag_queries += [Q(tags__iendswith=", " + t.strip()) for t in tags]
                tag_queries += [Q(tags__iendswith="," + t.strip()) for t in tags]
                tag_queries += [Q(tags__icontains=", " + t.strip() + ",") for t in tags]
                tag_queries += [Q(tags__icontains="," + t.strip() + ",") for t in tags]
                tag_query = reduce(or_, tag_queries)
                items = items.filter(tag_query)

            if hasattr(self.model, 'group') and group:
                items = items.filter(group=group)
            if hasattr(self.model, 'groups') and group:
                items = items.filter(groups__in=[group])

            if hasattr(self.model(), 'status_detail'):
                items = items.filter(status_detail__iexact=status_detail)

            items = self.custom_model_filter(items, user)

        objects = []

        # exclude certain primary keys
        if exclude:
            excludes = []
            for ex in exclude:
                if ex.isdigit():
                    excludes.append(int(ex))
            if query:
                items = items.exclude(primary_key__in=excludes)
            else:
                items = items.exclude(pk__in=excludes)

        # if order is not specified it sorts by relevance
        if order:
            items = items.order_by(order)

        if randomize:
            objects = [item for item in random.sample(items, len(items))][:limit]
        else:
            objects = [item for item in items[:limit]]

        if query:
            objects = [item.object for item in objects]

        context[self.context_var] = objects

        if 'template' in self.kwargs:
            try:
                template = Variable(self.kwargs['template'])
                template = unicode(template.resolve(context))
            except:
                template = self.kwargs['template']

            t = loader.get_template(template)
            return t.render(Context(context, autoescape=context.autoescape))

        return ""
コード例 #14
0
ファイル: event_tags.py プロジェクト: Spacepoints/tendenci
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = 'next_upcoming'
        event_type = ''
        group = u''

        randomize = False

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = unicode(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = tags.split(',')

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
                if user == "anon" or user == "anonymous":
                    user = AnonymousUser()
        else:
            # check the context for an already existing user
            # and see if it is really a user object
            if 'user' in context:
                if isinstance(context['user'], User):
                    user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']

        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'type' in self.kwargs:
            try:
                event_type = Variable(self.kwargs['type'])
                event_type = event_type.resolve(context)
            except:
                event_type = self.kwargs['type']

        if 'group' in self.kwargs:
            try:
                group = Variable(self.kwargs['group'])
                group = unicode(group.resolve(context))
            except:
                group = self.kwargs['group']

            try:
                group = int(group)
            except:
                group = None

        filters = get_query_filters(user, 'events.view_event')
        items = Event.objects.filter(filters)
        if user.is_authenticated():
            if not user.profile.is_superuser:
                items = items.distinct()

        if event_type:
            items = items.filter(type__name__iexact=event_type)

        if tags:  # tags is a comma delimited list
            # this is fast; but has one hole
            # it finds words inside of other words
            # e.g. "prev" is within "prevent"
            tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
            tag_queries += [Q(tags__istartswith=t.strip()+",") for t in tags]
            tag_queries += [Q(tags__iendswith=", "+t.strip()) for t in tags]
            tag_queries += [Q(tags__iendswith=","+t.strip()) for t in tags]
            tag_queries += [Q(tags__icontains=", "+t.strip()+",") for t in tags]
            tag_queries += [Q(tags__icontains=","+t.strip()+",") for t in tags]
            tag_query = reduce(or_, tag_queries)
            items = items.filter(tag_query)

        if hasattr(self.model, 'group') and group:
            items = items.filter(group=group)

        objects = []

        # if order is not specified it sorts by relevance
        if order:
            if order == "next_upcoming":
                # Removed seconds and microseconds so we can cache the query better
                now = datetime.now().replace(second=0, microsecond=0)
                items = items.filter(start_dt__gt = now)
                items = items.order_by("start_dt")
            elif order == "current_and_upcoming":
                now = datetime.now().replace(second=0, microsecond=0)
                items = items.filter(Q(start_dt__gt=now) | Q(end_dt__gt=now))
                items = items.order_by("start_dt")
            else:
                items = items.order_by(order)

        if randomize:
            objects = [item for item in random.sample(items, items.count())][:limit]
        else:
            objects = [item for item in items[:limit]]

        context[self.context_var] = objects
        return ""
コード例 #15
0
ファイル: story_tags.py プロジェクト: DeepInTheCode/tendenci
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = u''
        randomize = False
        group = u''

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = unicode(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = [t.strip() for t in tags.split(',')]

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
        else:
            # check the context for an already existing user
            if 'user' in context:
                user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']

        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'group' in self.kwargs:
            try:
                group = Variable(self.kwargs['group'])
                group = unicode(group.resolve(context))
            except:
                group = self.kwargs['group']

            try:
                group = int(group)
            except:
                group = None

        filters = get_query_filters(user, self.perms)
        items = self.model.objects.filter(filters)
        if user.is_authenticated():
            if not user.profile.is_superuser:
                items = items.distinct()

        if tags:  # tags is a comma delimited list
            # this is fast; but has one hole
            # it finds words inside of other words
            # e.g. "prev" is within "prevent"
            tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
            tag_queries += [Q(tags__istartswith=t.strip()+",") for t in tags]
            tag_queries += [Q(tags__iendswith=", "+t.strip()) for t in tags]
            tag_queries += [Q(tags__iendswith=","+t.strip()) for t in tags]
            tag_queries += [Q(tags__icontains=", "+t.strip()+",") for t in tags]
            tag_queries += [Q(tags__icontains=","+t.strip()+",") for t in tags]
            tag_query = reduce(or_, tag_queries)
            items = items.filter(tag_query)

        if group:
            items = items.filter(group=group)

        objects = []

        # Removed seconds and microseconds so we can cache the query better
        now = datetime.now().replace(second=0, microsecond=0)

        # Custom filter for stories
        date_query = reduce(or_, [Q(end_dt__gte=now), Q(expires=False)])
        date_query = reduce(and_, [Q(start_dt__lte=now), date_query])
        items = items.filter(date_query)

        if order:
            items = items.order_by(order)
        else:
            items = items.order_by('-position', '-start_dt')

        # if order is not specified it sorts by relevance
        if randomize:
            objects = [item for item in random.sample(items, len(items))][:limit]
        else:
            objects = [item for item in items[:limit]]

        context[self.context_var] = objects

        return ""
コード例 #16
0
ファイル: event_tags.py プロジェクト: BakethemPie/tendenci
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = 'next_upcoming'
        event_type = ''

        randomize = False

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = unicode(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = tags.split(',')

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
                if user == "anon" or user == "anonymous":
                    user = AnonymousUser()
        else:
            # check the context for an already existing user
            # and see if it is really a user object
            if 'user' in context:
                if isinstance(context['user'], User):
                    user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']

        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'type' in self.kwargs:
            try:
                event_type = Variable(self.kwargs['type'])
                event_type = event_type.resolve(context)
            except:
                event_type = self.kwargs['type']

        # process tags
        for tag in tags:
            tag = tag.strip()
            query = '%s "tag:%s"' % (query, tag)

        filters = get_query_filters(user, 'events.view_event')
        items = Event.objects.filter(filters).distinct()
        if event_type:
            items = items.filter(type__name__iexact=event_type)
        objects = []

        # if order is not specified it sorts by relevance
        if order:
            if order == "next_upcoming":
                # Removed seconds so we can cache the query better
                now = datetime.now().replace(second=0)
                items = items.filter(start_dt__gt = now)
                items = items.order_by("start_dt")
            else:
                items = items.order_by(order)

        if items:
            if randomize:
                objects = [item for item in random.sample(items, items.count())][:limit]
            else:
                objects = [item for item in items[:limit]]

        context[self.context_var] = objects
        return ""
コード例 #17
0
ファイル: template_tags.py プロジェクト: BakethemPie/tendenci
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = u''
        exclude = u''
        randomize = False

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = unicode(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = tags.split(',')

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
                if user == "anon" or user == "anonymous":
                    user = AnonymousUser()
        else:
            # check the context for an already existing user
            # and see if it is really a user object
            if 'user' in context:
                if isinstance(context['user'], User):
                    user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']
        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']
                
        if 'exclude' in self.kwargs:
            try:
                exclude = Variable(self.kwargs['exclude'])
                exclude = unicode(tags.resolve(context))
            except:
                exclude = self.kwargs['exclude']

            exclude = exclude.replace('"', '')
            exclude = exclude.split(',')

        # get the list of items
        self.perms = getattr(self, 'perms', unicode())

        filters = get_query_filters(user, self.perms)
        items = self.model.objects.filter(filters).distinct()

        if tags:  # tags is a comma delimited list
            # this is fast; but has one hole
            # it finds words inside of other words
            # e.g. "event" is within "prevent"
            tag_queries = [Q(tags__icontains=t) for t in tags]
            tag_query = reduce(or_, tag_queries)
            items = items.filter(tag_query)

        objects = []
        
        if items:
            #exclude certain primary keys
            if exclude:
                excludes = []
                for ex in exclude:
                    if ex.isdigit():
                        excludes.append(int(ex))
                items = items.exclude(pk__in=excludes)

            # if order is not specified it sorts by relevance
            if order:
                items = items.order_by(order)

            if randomize:
                objects = [item for item in random.sample(items, len(items))][:limit]
            else:
                objects = [item for item in items[:limit]]

        context[self.context_var] = objects
        
        if 'template' in self.kwargs:
            try:
                template = Variable(self.kwargs['template'])
                template = unicode(template.resolve(context))
            except:
                template = self.kwargs['template']
                
            t = loader.get_template(template)
            return t.render(Context(context, autoescape=context.autoescape))
            
        return ""
コード例 #18
0
    def render(self, context):
        tags = u''
        query = u''
        user = AnonymousUser()
        limit = 3
        order = 'next_upcoming'
        event_type = ''

        randomize = False

        if 'random' in self.kwargs:
            randomize = bool(self.kwargs['random'])

        if 'tags' in self.kwargs:
            try:
                tags = Variable(self.kwargs['tags'])
                tags = unicode(tags.resolve(context))
            except:
                tags = self.kwargs['tags']

            tags = tags.replace('"', '')
            tags = tags.split(',')

        if 'user' in self.kwargs:
            try:
                user = Variable(self.kwargs['user'])
                user = user.resolve(context)
            except:
                user = self.kwargs['user']
                if user == "anon" or user == "anonymous":
                    user = AnonymousUser()
        else:
            # check the context for an already existing user
            # and see if it is really a user object
            if 'user' in context:
                if isinstance(context['user'], User):
                    user = context['user']

        if 'limit' in self.kwargs:
            try:
                limit = Variable(self.kwargs['limit'])
                limit = limit.resolve(context)
            except:
                limit = self.kwargs['limit']

        limit = int(limit)

        if 'query' in self.kwargs:
            try:
                query = Variable(self.kwargs['query'])
                query = query.resolve(context)
            except:
                query = self.kwargs['query']  # context string

        if 'order' in self.kwargs:
            try:
                order = Variable(self.kwargs['order'])
                order = order.resolve(context)
            except:
                order = self.kwargs['order']

        if 'type' in self.kwargs:
            try:
                event_type = Variable(self.kwargs['type'])
                event_type = event_type.resolve(context)
            except:
                event_type = self.kwargs['type']

        filters = get_query_filters(user, 'events.view_event')
        items = Event.objects.filter(filters)
        if user.is_authenticated():
            if not user.profile.is_superuser:
                items = items.distinct()

        if event_type:
            items = items.filter(type__name__iexact=event_type)

        if tags:  # tags is a comma delimited list
            # this is fast; but has one hole
            # it finds words inside of other words
            # e.g. "prev" is within "prevent"
            tag_queries = [Q(tags__iexact=t.strip()) for t in tags]
            tag_queries += [Q(tags__istartswith=t.strip() + ",") for t in tags]
            tag_queries += [Q(tags__iendswith=", " + t.strip()) for t in tags]
            tag_queries += [Q(tags__iendswith="," + t.strip()) for t in tags]
            tag_queries += [
                Q(tags__icontains=", " + t.strip() + ",") for t in tags
            ]
            tag_queries += [
                Q(tags__icontains="," + t.strip() + ",") for t in tags
            ]
            tag_query = reduce(or_, tag_queries)
            items = items.filter(tag_query)

        objects = []

        # if order is not specified it sorts by relevance
        if order:
            if order == "next_upcoming":
                # Removed seconds and microseconds so we can cache the query better
                now = datetime.now().replace(second=0, microsecond=0)
                items = items.filter(start_dt__gt=now)
                items = items.order_by("start_dt")
            elif order == "current_and_upcoming":
                now = datetime.now().replace(second=0, microsecond=0)
                items = items.filter(Q(start_dt__gt=now) | Q(end_dt__gt=now))
                items = items.order_by("start_dt")
            else:
                items = items.order_by(order)

        if randomize:
            objects = [item
                       for item in random.sample(items, items.count())][:limit]
        else:
            objects = [item for item in items[:limit]]

        context[self.context_var] = objects
        return ""