Example #1
0
def archive_index(request):
    p = request.GET.get('p', None)
    if p:
        post = Post.objects.get(pk=p)
        return HttpResponseRedirect(post.get_absolute_url())
    return date_based.archive_index(request,
        queryset=Post.objects.published(), date_field='post_date')
Example #2
0
def index(request):
    """
    A wrapper around ``django.views.generic.date_based.archive_index`` that
    will display an entry form for users to input ``Complaint`` objects.
    """
    
    complaints = Complaint.objects.all()
    
    if request.POST:
        form = ComplaintForm(request.POST)
        if form.is_valid():
            form.save()
    else:
        form = ComplaintForm()
    
    return date_based.archive_index(
        request,
        queryset=complaints,
        date_field='published',
        template_name='complaints/complaint_index.html',
        allow_empty=True,
        extra_context={
            'form': form,
            'total_complaints': len(complaints)
        }
    )
Example #3
0
def index(request):
    posts = Post.objects.all()
    return archive_index(request,
            posts,
            'published',
            template_object_name='post_list',
            template_name='index.html')
Example #4
0
def blog_detail(request, blog_slug):
    blog = get_object_or_404(Blog, slug=blog_slug)
    return date_based.archive_index(request, 
        queryset = blog.entry_set.all(),
        date_field = 'pub_date',
        extra_context = {'blog': blog},
        template_name = blog.template_name_blog or 'blogs/entry_archive_index.html')
Example #5
0
def list_msgs(request, number=None):
    '''
    Get a list of messages organized by date.
    '''
    
    if request.method == "GET":
        qs = DatedMessage.objects.get_messages_for_user(request.user)
        
        if number == None:
			number = qs.count()
            
        return date_based.archive_index(
            request,
            queryset=qs,
            date_field='datetime',
            num_latest=number,
            template_name='expedient/common/messaging/list.html',
            extra_context={'requested': number}
        )
        
    elif request.method == "POST":
        msg_ids = request.POST.getlist("selected")
        qs = DatedMessage.objects.filter(id__in=msg_ids)
        DatedMessage.objects.delete_messages_for_user(qs, request.user)
        
        if number:
            return HttpResponseRedirect(
                reverse("messaging_subset", kwargs={"number": number}))
        else:
            return HttpResponseRedirect(
                reverse("messaging_all"))

    return HttpResponseNotAllowed("GET", "POST")
Example #6
0
def category_archive_index(request, slug, **kwargs):
    """
    View of the latest entries published in a ``Category``.
    
    This is a short wrapper around the generic
    ``date_based.archive_index`` view, so all context variables
    populated by that view will be available here. One extra variable
    is added::
    
        object
            The ``Category``.
    
    Additionally, any keyword arguments which are valid for
    ``date_based.archive_year`` will be accepted and passed to it,
    with these exceptions:
    
    * ``queryset`` will always be the ``QuerySet`` of live entries in
      the ``Category``.
    * ``date_field`` will always be 'pub_date'.
    * ``template_name`` will always be 'coltrane/category_archive.html'.
    
    Template::
        coltrane/category_archive.html
    
    """
    category = get_object_or_404(Category, slug__exact=slug)
    kwarg_dict = _category_kwarg_helper(category, kwargs)
    return date_based.archive_index(request,
                                    queryset=category.live_entry_set,
                                    date_field='pub_date',
                                    template_name='coltrane/category_archive.html',
                                    **kwarg_dict)
Example #7
0
def article_archive_index(request, ):
    kwargs = {
        'queryset': Article.objects.published(),
        'date_field': 'publish_at',
        'template_object_name': 'object_list',
        'template_name': r'blogs/article_list.html',
    }
    return date_based.archive_index(request, **kwargs)
Example #8
0
def archive(request, newsletter_slug):
    my_newsletter = get_object_or_404(Newsletter.on_site, slug=newsletter_slug, visible=True)

    submissions = Submission.objects.filter(newsletter=my_newsletter, publish=True)

    return date_based.archive_index(
        request, queryset=submissions, date_field="publish_date", extra_context={"newsletter": my_newsletter}
    )
Example #9
0
def archive_index(request):
    entry = Entry.show.all()
    
    return date_based.archive_index(request,
                                     queryset=entry,
                                     date_field='published',
                                     template_name='spec/archive_index.html',
                                     extra_context={'date_list': entry.dates('published', 'year')[::-1] ,},)
Example #10
0
def article_archive_index(request, ):
    kwargs = {
        'queryset': Article.objects.published(),
        'date_field': 'publish_at',
        'template_object_name': 'object_list',
        'template_name': r'blogs/article_list.html',
    }
    return date_based.archive_index(request, **kwargs)
Example #11
0
def blog(request, slug):
    #queryset = Blog.objects.filter(active=True)
    posts_blog = Blog.objects.get(slug=slug)
    queryset = Post.objects.get_visible().filter(blog__slug=slug)

    return date_based.archive_index(request, queryset, date_field='publish_at',
            num_latest = 1,
            extra_context={'blog': posts_blog})
Example #12
0
def blog_index(request):
    return date_based.archive_index(
        request,
        queryset=Post.objects.published(),
        date_field='published',
        allow_empty=False,
        num_latest=40,
        template_object_name='post_list',
        extra_context=extra_context())        
Example #13
0
def archive(request, newsletter_slug):
    my_newsletter = get_object_or_404(Newsletter.on_site, slug=newsletter_slug, visible=True)
    
    submissions = Submission.objects.filter(newsletter=my_newsletter, publish=True)
    
    return date_based.archive_index(request, 
                                    queryset=submissions, 
                                    date_field='publish_date', 
                                    extra_context = {'newsletter': my_newsletter})
Example #14
0
def homepage(request, **kwargs):
    defaults = {
        "date_field": "pub_date",
        "num_latest": request.blog.settings.posts_per_page,
        "template_name": "homepage.html",
        "template_object_name": "posts",
    }
    defaults.update(kwargs)
    return date_based.archive_index(request, **defaults)
Example #15
0
def home(request):
    return date_based.archive_index(
        request,
        BlogPost.objects.public_posts(),
        date_field="pub_date",
        template_name="blog/home.html",
        template_object_name="blogpost_list",
        extra_context={"preview": True},
    )
Example #16
0
def homepage(request, **kwargs):
    defaults = {
        "date_field": "pub_date",
        "num_latest": 3,
        "template_name": "blog/homepage.html",
        "template_object_name": "posts",
    }
    defaults.update(kwargs)
    return date_based.archive_index(request, **defaults)
Example #17
0
def  galleries_index(request):
    """ Displays current user's galleries.
    Extended to support users.
    """
    user_galleries =  {'date_field': 'date_added', 
                    'allow_empty': True, 
                    'queryset': Gallery.objects.filter(is_public=True, author=request.user), 
                    'extra_context':{'sample_size':SAMPLE_SIZE}
                    }
    return archive_index(request,  **user_galleries)
Example #18
0
def notes_archive(request): 
    """Archive of all notes"""

    return archive_index(request, 
        queryset=Note.objects.all().order_by('-created', 'title'), # https://docs.djangoproject.com/en/dev/ref/models/querysets/#django.db.models.query.QuerySet.order_by
        date_field='created', # don't forget to set {{ note.created|date:"d F Y" }} in notes/list.html
        template_name='notes/archive.html',
        # template_object_name='note',
        allow_future = False # this is the default, but am keeping it here to remember that it can be set to true for other use cases, such as calendar of upcoming events
    )
Example #19
0
def archive_index(request):
    """
    entry archives
    """
    return date_based.archive_index(
        request,
        queryset=Entry.objects.all(),
        date_field='created_on',
        template_object_name='entry'
    )
Example #20
0
def category_detail(request, category_slug):
    category = get_object_or_404(Category, slug=category_slug)
    return date_based.archive_index(
        request,
        category.blogpost_set.public_posts(),
        date_field="pub_date",
        template_name="blog/category_detail.html",
        template_object_name="blogpost_list",
        extra_context={"category": category, "preview": True},
    )
Example #21
0
def blog(request, slug):
    #queryset = Blog.objects.filter(active=True)
    posts_blog = Blog.objects.get(slug=slug)
    queryset = Post.objects.get_visible().filter(blog__slug=slug)

    return date_based.archive_index(request,
                                    queryset,
                                    date_field='publish_at',
                                    num_latest=1,
                                    extra_context={'blog': posts_blog})
Example #22
0
def index(request):
    return date_based.archive_index(
        request,
        queryset   = BlogPost.objects.filter(is_live=True),
        date_field = 'pubdate',
        num_latest = 5,
        template_name = 'blog/index.html',
        template_object_name = 'object_list',
        extra_context = {
            'page_obj':{'number':0}
        }
    )
Example #23
0
 def calendar_view(self, request, field, year=None, month=None, day=None):
     easy_model = EasyModel(self.site, self.model)
     queryset = easy_model.get_query_set()
     extra_context = {
         'root_url': self.site.root_url,
         'model': easy_model,
         'field': field
     }
     if day is not None:
         return date_based.archive_day(
             request,
             year,
             month,
             day,
             queryset,
             field.name,
             template_name='databrowse/calendar_day.html',
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context)
     elif month is not None:
         return date_based.archive_month(
             request,
             year,
             month,
             queryset,
             field.name,
             template_name='databrowse/calendar_month.html',
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context)
     elif year is not None:
         return date_based.archive_year(
             request,
             year,
             queryset,
             field.name,
             template_name='databrowse/calendar_year.html',
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context)
     else:
         return date_based.archive_index(
             request,
             queryset,
             field.name,
             template_name='databrowse/calendar_main.html',
             allow_empty=True,
             allow_future=True,
             extra_context=extra_context)
     assert False, ('%s, %s, %s, %s' % (field, year, month, day))
Example #24
0
 def calendar_view(self, request, field, year=None, month=None, day=None):
     easy_model = EasyModel(self.site, self.model)
     extra_context = {
         'root_url': self.site.root_url,
         'model': easy_model,
         'field': field
     }
     if day is not None:
         # TODO: The objects in this template should be EasyInstances
         return date_based.archive_day(
             request,
             year,
             month,
             day,
             self.model.objects.all(),
             field.name,
             template_name='databrowse/calendar_day.html',
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context)
     elif month is not None:
         return date_based.archive_month(
             request,
             year,
             month,
             self.model.objects.all(),
             field.name,
             template_name='databrowse/calendar_month.html',
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context)
     elif year is not None:
         return date_based.archive_year(
             request,
             year,
             self.model.objects.all(),
             field.name,
             template_name='databrowse/calendar_year.html',
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context)
     else:
         return date_based.archive_index(
             request,
             self.model.objects.all(),
             field.name,
             template_name='databrowse/calendar_main.html',
             allow_empty=True,
             allow_future=True,
             extra_context=extra_context)
     assert False, ('%s, %s, %s, %s' % (field, year, month, day))
Example #25
0
 def calendar_view(self, request, field, year=None, month=None, day=None):
     easy_model = EasyModel(self.site, self.model)
     queryset = easy_model.get_query_set()
     extra_context = {"root_url": self.site.root_url, "model": easy_model, "field": field}
     if day is not None:
         return date_based.archive_day(
             request,
             year,
             month,
             day,
             queryset,
             field.name,
             template_name="databrowse/calendar_day.html",
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context,
         )
     elif month is not None:
         return date_based.archive_month(
             request,
             year,
             month,
             queryset,
             field.name,
             template_name="databrowse/calendar_month.html",
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context,
         )
     elif year is not None:
         return date_based.archive_year(
             request,
             year,
             queryset,
             field.name,
             template_name="databrowse/calendar_year.html",
             allow_empty=False,
             allow_future=True,
             extra_context=extra_context,
         )
     else:
         return date_based.archive_index(
             request,
             queryset,
             field.name,
             template_name="databrowse/calendar_main.html",
             allow_empty=True,
             allow_future=True,
             extra_context=extra_context,
         )
     assert False, "%s, %s, %s, %s" % (field, year, month, day)
Example #26
0
def notes_archive(request):
    """Archive of all notes"""

    return archive_index(
        request,
        queryset=Note.objects.all().order_by(
            '-created', 'title'
        ),  # https://docs.djangoproject.com/en/dev/ref/models/querysets/#django.db.models.query.QuerySet.order_by
        date_field=
        'created',  # don't forget to set {{ note.created|date:"d F Y" }} in notes/list.html
        template_name='notes/archive.html',
        # template_object_name='note',
        allow_future=
        False  # this is the default, but am keeping it here to remember that it can be set to true for other use cases, such as calendar of upcoming events
    )
Example #27
0
def events(request):
    today = datetime.datetime.today()
    week_number = int(today.strftime('%W'))

    return date_based.archive_index(request,
        queryset=Event.objects.all(),
        date_field='start_date',
        allow_empty=1,
        extra_context={
            'event_last': Event.objects.get_week_events(today.year, week_number - 1),
            'event_this': Event.objects.get_week_events(today.year, week_number),
            'event_next': Event.objects.get_week_events(today.year, week_number + 1),
            'event_next2': Event.objects.get_week_events(today.year, week_number + 2),
            'years': range(2006, today.year + 1),
        },
    )
Example #28
0
def post_list(request, category_slug=None):
    date_field = 'post_date'
    context_vars = dict()
    context_vars['page'] = 'blog'
    if category_slug:
        try:
            category = Category.objects.get(slug=category_slug)
            context_vars['category'] = category
            context_vars['page'] = category.title
            queryset = category.posts.current()
        except Category.DoesNotExist:
            raise Http404
    else:
        queryset = models.Post.objects.current()
    tags = Tag.objects.all()
    context_vars['tags'] = tags

    return archive_index(request, queryset, date_field, extra_context=context_vars)
Example #29
0
def episode_archive(request, show_slug, month=False, year=False, day=False):
    from django.views.generic.date_based import archive_day, archive_month, archive_year, archive_index

    try:
        show = Show.objects.get(slug=show_slug)
        episodes = show.episode_set.all()
    except Show.DoesNotExist:
        raise Http404

    if day:
        return archive_day(
            request,
            queryset=episodes,
            date_field="date_published",
            template_object_name="episode",
            allow_empty=True,
            month=month,
            day=day,
            year=year,
        )
    elif month:
        return archive_month(
            request,
            queryset=episodes,
            date_field="date_published",
            template_object_name="episode",
            allow_empty=True,
            month=month,
            year=year,
        )
    elif year:
        return archive_year(
            request,
            queryset=episodes,
            date_field="date_published",
            template_object_name="episode",
            allow_empty=True,
            year=year,
        )
    else:
        return archive_index(
            request, queryset=episodes, date_field="date_published", template_object_name="episode", allow_empty=True
        )
Example #30
0
def metaphore_archive_index(request, queryset=None,
                date_field='publish_date', num_latest=15,
                template_name=None, template_loader=loader,
                extra_context=None, allow_empty=True,
                context_processors=None,
                mimetype=None, allow_future=False,
                template_object_name='object_list',
                content_type=None, tags=None,
                author=None):

    queryset, extra_context = metaphore_filters(request, queryset,
                                                extra_context,
                                                content_type, tags, author)


    return archive_index(request, queryset, date_field, num_latest,
                 template_name, template_loader,
                 extra_context, allow_empty, context_processors,
                 mimetype, allow_future, template_object_name)
Example #31
0
def lends(request):
    if request.method == 'POST':
        form = LendForm(request.POST)
        if form.is_valid():
            new_lend = form.save()
            if 'due_date' not in form.cleaned_data:
                new_lend.due_date = datetime.datetime.today() + datetime.timedelta(7)

            return HttpResponseRedirect(new_lend.get_absolute_url())
    else:
        form = LendForm()

    return date_based.archive_index(request,
        queryset=Lend.objects.all().order_by('due_date'),
        date_field='from_date',
        allow_empty=1,
        extra_context={
            'form': form,
        },
    )
Example #32
0
 def calendar_view(self, request, field, year=None, month=None, day=None):
     easy_model = EasyModel(self.site, self.model)
     extra_context = {'root_url': self.site.root_url, 'model': easy_model, 'field': field}
     if day is not None:
         # TODO: The objects in this template should be EasyInstances
         return date_based.archive_day(request, year, month, day, self.model.objects.all(), field.name,
             template_name='databrowse/calendar_day.html', allow_empty=False, allow_future=True,
             extra_context=extra_context)
     elif month is not None:
         return date_based.archive_month(request, year, month, self.model.objects.all(), field.name,
             template_name='databrowse/calendar_month.html', allow_empty=False, allow_future=True,
             extra_context=extra_context)
     elif year is not None:
         return date_based.archive_year(request, year, self.model.objects.all(), field.name,
             template_name='databrowse/calendar_year.html', allow_empty=False, allow_future=True,
             extra_context=extra_context)
     else:
         return date_based.archive_index(request, self.model.objects.all(), field.name,
             template_name='databrowse/calendar_main.html', allow_empty=True, allow_future=True,
             extra_context=extra_context)
     assert False, ('%s, %s, %s, %s' % (field, year, month, day))
Example #33
0
def track_archive(request):
   tracks = Entry.live.all()
   archive = {}

   date_field = 'pub_date'

   years = tracks.dates(date_field, 'year')[::-1]
   for date_year in years:
       months = tracks.filter(pub_date__year=date_year.year).dates(date_field, 'month')
       archive[date_year] = months

   archive = sorted(archive.items(), reverse=True)

   return archive_index(
        request,
        date_field=date_field,
        queryset=tracks,
        template_name='coltrane/entry_index.html',
        template_object_name='entry_list',
        extra_context={'archive': archive},
   )
Example #34
0
def diarys(request):
    diarys = Diary.objects.all()
    if request.POST:
        filter = DiaryFilter(request.POST)
        if filter.is_valid():
            for key, value in filter.cleaned_data.items():
                if value:
                    ##'**' rabis zato da ti python resolva spremenljivke (as opposed da passa dobesedni string)
                    diarys = diarys.filter(**{key: value})
    else:
        filter = DiaryFilter()

    return date_based.archive_index(request,
        queryset=diarys.order_by('date'),
        date_field='date',
        allow_empty=1,
        extra_context={
            'filter': filter,
            'diary_form': DiaryForm(),
        }
    )
Example #35
0
def article_list_index_(request, *args, **kwargs):
    from django.views.generic.date_based import archive_index

    queryset = Article.objects.published()
    category = None
    if kwargs.get("category", None):
        category = kwargs.pop("category")
        queryset = queryset.filter(category__slug=category)

    extra_context = {"category": category}
    kwargs.update(
        {
            "queryset": queryset,
            "date_field": "publish_date",
            "template_name": "articles/article_list.html",
            "template_object_name": "article_list",
            "allow_future": True,
            "extra_context": extra_context,
        }
    )
    return archive_index(request, *args, **kwargs)
Example #36
0
def article_list_index_(request, *args, **kwargs):
  from django.views.generic.date_based import archive_index

  queryset = Article.objects.published()
  category = None
  if kwargs.get('category', None):
	category = kwargs.pop('category')
	queryset = queryset.filter(category__slug=category)

  extra_context = {
	'category' : category,
  }
  kwargs.update({
	'queryset' : queryset,
	'date_field' : 'publish_date',
	'template_name' : 'articles/article_list.html',
	'template_object_name' : 'article_list',
	'allow_future' : True,
	'extra_context' : extra_context,
  })
  return archive_index(request, *args, **kwargs)
Example #37
0
def article_list_index_(request, *args, **kwargs):
  from django.views.generic.date_based import archive_index

  queryset = Article.objects.published()
  category = None
  if kwargs.get('category', None):
	category = kwargs.pop('category')
	queryset = queryset.filter(category__slug=category)

  extra_context = {
	'category' : category,
  }
  kwargs.update({
	'queryset' : queryset,
	'date_field' : 'publish_date',
	'template_name' : 'articles/article_list.html',
	'template_object_name' : 'article_list',
	'allow_future' : True,
	'extra_context' : extra_context,
  })
  return archive_index(request, *args, **kwargs)
Example #38
0
def tumble_archive_index(request, page=0, content_type=None, template_name=None, **kwargs):
    queryset = TumbleItem.objects.all()

    if content_type:
        queryset = queryset.filter(content_type__name=content_type)

    select_template_name = select_template([
        template_name or '',
        'djumblr/%s_archive.html' % (content_type),
        'djumblr/tumbleitem_archive.html',
    ])
    template_name = select_template_name.name

    if 'extra_context' not in kwargs:
        kwargs['extra_context'] = {}
    kwargs['extra_context']['content_type'] = content_type

    return date_based.archive_index(
        request,
        date_field = 'pub_date',
        queryset = queryset,
        template_name = template_name,
        **kwargs
    )
Example #39
0
def archive_index(request, *args, **kwargs):
    return date_based.archive_index(request, *args, **kwargs)
Example #40
0
def story_archive(request):
    queryset = Story.objects.for_user(request.user).filter(parent=None)
    date_field = "pub_date"
    return date_based.archive_index(request, queryset, date_field)
def blog(request, slug):
    posts_blog = Blog.objects.get(slug=slug)
    queryset = Post.objects.get_visible().filter(blog__slug=slug)

    return date_based.archive_index(request, queryset, date_field="publish_at",
                                    extra_context={ 'blog': posts_blog })
Example #42
0
def blog_archive_index(request, **kwargs):
    kwargs['queryset'] = kwargs['queryset'].published()
    return archive_index(request, **kwargs)