def media_home(request, media, page, **kwargs):
"""
'Homepage' of a MediaEntry()
"""
comment_id = request.matchdict.get('comment', None)
if comment_id:
if request.user:
mark_comment_notification_seen(comment_id, request.user)
pagination = Pagination(
page, media.get_comments(
mg_globals.app_config['comments_ascending']),
MEDIA_COMMENTS_PER_PAGE,
comment_id)
else:
pagination = Pagination(
page, media.get_comments(
mg_globals.app_config['comments_ascending']),
MEDIA_COMMENTS_PER_PAGE)
comments = pagination()
comment_form = user_forms.MediaCommentForm(request.form)
media_template_name = media.media_manager.display_template
return render_to_response(
request,
media_template_name,
{'media': media,
'comments': comments,
'pagination': pagination,
'comment_form': comment_form,
'app_config': mg_globals.app_config})
def user_home(request, page):
"""'Homepage' of a User()"""
# TODO: decide if we only want homepages for active users, we can
# then use the @get_active_user decorator and also simplify the
# template html.
user = User.query.filter_by(username=request.matchdict['user']).first()
if not user:
return render_404(request)
elif user.status != u'active':
return render_to_response(request, 'mediagoblin/user_pages/user.html',
{'user': user})
cursor = MediaEntry.query.\
filter_by(uploader = user.id,
state = u'processed').order_by(MediaEntry.created.desc())
pagination = Pagination(page, cursor)
media_entries = pagination()
#if no data is available, return NotFound
if media_entries == None:
return render_404(request)
user_gallery_url = request.urlgen('mediagoblin.user_pages.user_gallery',
user=user.username)
return render_to_response(
request, 'mediagoblin/user_pages/user.html', {
'user': user,
'user_gallery_url': user_gallery_url,
'media_entries': media_entries,
'pagination': pagination
})
def user_home(request, page):
"""'Homepage' of a LocalUser()"""
user = LocalUser.query.filter_by(
username=request.matchdict['user']).first()
if not user:
return render_404(request)
elif not user.has_privilege('active'):
return render_to_response(
request, 'mediagoblin/user_pages/user_nonactive.html',
{'user': user})
cursor = MediaEntry.query.\
filter_by(actor = user.id).order_by(MediaEntry.created.desc())
pagination = Pagination(page, cursor)
media_entries = pagination()
# if no data is available, return NotFound
if media_entries == None:
return render_404(request)
user_gallery_url = request.urlgen('mediagoblin.user_pages.user_gallery',
user=user.username)
return render_to_response(
request, 'mediagoblin/user_pages/user.html', {
'user': user,
'user_gallery_url': user_gallery_url,
'media_entries': media_entries,
'pagination': pagination
})
def user_gallery(request, page, url_user=None):
"""'Gallery' of a LocalUser()"""
tag = request.matchdict.get('tag', None)
cursor = MediaEntry.query.filter_by(actor=url_user.id,
state='processed').order_by(
MediaEntry.created.desc())
# Filter potentially by tag too:
if tag:
cursor = cursor.filter(
MediaEntry.tags_helper.any(
MediaTag.slug == request.matchdict['tag']))
# Paginate gallery
pagination = Pagination(page, cursor)
media_entries = pagination()
#if no data is available, return NotFound
# TODO: Should we really also return 404 for empty galleries?
if media_entries == None:
return render_404(request)
return render_to_response(
request, 'mediagoblin/user_pages/gallery.html', {
'user': url_user,
'tag': tag,
'media_entries': media_entries,
'pagination': pagination
})
def search_results_view(request, page):
media_entries = None
pagination = None
form = indexedsearch.forms.SearchForm(request.form)
config = pluginapi.get_config('indexedsearch')
if config.get('SEARCH_LINK_STYLE') == 'form':
form.show = False
else:
form.show = True
query = None
if request.method == 'GET' and 'q' in request.GET:
query = request.GET['q']
if query:
engine = get_engine()
result_ids = engine.search(query)
if result_ids:
matches = MediaEntry.query.filter(
MediaEntry.id.in_(result_ids))
pagination = Pagination(page, matches)
media_entries = pagination()
return render_to_response(
request,
'indexedsearch/results.html',
{'media_entries': media_entries,
'pagination': pagination,
'form': form})
def user_collection(request, page, url_user=None):
"""A User-defined Collection"""
collection = Collection.query.filter_by(
get_actor=url_user, slug=request.matchdict['collection']).first()
if not collection:
return render_404(request)
cursor = collection.get_collection_items()
pagination = Pagination(page, cursor)
collection_items = pagination()
# if no data is available, return NotFound
# TODO: Should an empty collection really also return 404?
if collection_items == None:
return render_404(request)
return render_to_response(
request, 'mediagoblin/user_pages/collection.html', {
'user': url_user,
'collection': collection,
'collection_items': collection_items,
'pagination': pagination
})
def media_home(request, media, page, **kwargs):
"""
'Homepage' of a MediaEntry()
"""
comment_id = request.matchdict.get('comment', None)
if comment_id:
if request.user:
mark_comment_notification_seen(comment_id, request.user)
pagination = Pagination(
page, media.get_comments(
mg_globals.app_config['comments_ascending']),
MEDIA_COMMENTS_PER_PAGE,
comment_id)
else:
pagination = Pagination(
page, media.get_comments(
mg_globals.app_config['comments_ascending']),
MEDIA_COMMENTS_PER_PAGE)
comments = pagination()
comment_form = user_forms.MediaCommentForm(request.form)
media_template_name = media.media_manager.display_template
context = {
'media': media,
'comments': comments,
'pagination': pagination,
'comment_form': comment_form,
'app_config': mg_globals.app_config}
# Since the media template name gets swapped out for each media
# type, normal context hooks don't work if you want to affect all
# media displays. This gives a general purpose hook.
context = hook_transform(
"media_home_context", context)
return render_to_response(
request,
media_template_name,
context)
def default_root_view(request, page):
cursor = request.db.query(MediaEntry).filter_by(state='processed').\
order_by(MediaEntry.created.desc())
pagination = Pagination(page, cursor)
media_entries = pagination()
return render_to_response(
request, 'mediagoblin/root.html',
{'media_entries': media_entries,
'allow_registration': mg_globals.app_config["allow_registration"],
'pagination': pagination})
def processing_panel(request, page, url_user):
"""
Show to the user what media is still in conversion/processing...
and what failed, and why!
"""
user = LocalUser.query.filter_by(
username=request.matchdict['user']).first()
# TODO: XXX: Should this be a decorator?
#
# Make sure we have permission to access this user's panel. Only
# admins and this user herself should be able to do so.
if not (user.id == request.user.id
or request.user.has_privilege(u'admin')):
# No? Simply redirect to this user's homepage.
return redirect(request,
'mediagoblin.user_pages.user_home',
user=user.username)
# Get media entries which are in-processing
entries = (MediaEntry.query.filter_by(actor=user.id).order_by(
MediaEntry.created.desc()))
try:
state = request.matchdict['state']
# no exception was thrown, filter entries by state
entries = entries.filter_by(state=state)
except KeyError:
# show all entries
pass
pagination = Pagination(page, entries)
pagination.per_page = 30
entries_on_a_page = pagination()
# Render to response
return render_to_response(request,
'mediagoblin/user_pages/processing_panel.html', {
'user': user,
'entries': entries_on_a_page,
'pagination': pagination
})
def recent_media_gallery_view(request, page):
"""
The replaced homepage is available through this view.
"""
cursor = MediaEntry.query.filter_by(state=u'processed').\
order_by(MediaEntry.created.desc())
pagination = Pagination(page, cursor)
media_entries = pagination()
return render_to_response(request, 'archivalook/recent_media.html', {
'media_entries': media_entries,
'pagination': pagination
})
def blog_post_listing(request, page, url_user=None):
"""
Page, listing all the blog posts of a particular blog.
"""
blog_slug = request.matchdict['blog_slug']
blog = get_blog_by_slug(request, blog_slug, author=url_user.id)
if not blog:
return render_404(request)
all_blog_posts = blog.get_all_blog_posts(u'processed').order_by(MediaEntry.created.desc())
pagination = Pagination(page, all_blog_posts)
pagination.per_page = 8
blog_posts_on_a_page = pagination()
return render_to_response(
request,
'mediagoblin/blog/blog_post_listing.html',
{'blog_posts': blog_posts_on_a_page,
'pagination': pagination,
'blog_owner': url_user,
'blog':blog
})
def blog_dashboard(request, page, url_user=None):
"""
Dashboard for a blog, only accessible to
the owner of the blog.
"""
blog_slug = request.matchdict.get('blog_slug', None)
blogs = request.db.Blog.query.filter_by(author=url_user.id)
config = pluginapi.get_config('mediagoblin.media_types.blog')
max_blog_count = config['max_blog_count']
if request.user and (request.user.id == url_user.id or request.user.has_privilege(u'admin')):
if blog_slug:
blog = get_blog_by_slug(request, blog_slug)
if not blog:
return render_404(request)
else:
blog_posts_list = blog.get_all_blog_posts().order_by(MediaEntry.created.desc())
pagination = Pagination(page, blog_posts_list)
pagination.per_page = 15
blog_posts_on_a_page = pagination()
if may_edit_blogpost(request, blog):
return render_to_response(
request,
'mediagoblin/blog/blog_admin_dashboard.html',
{'blog_posts_list': blog_posts_on_a_page,
'blog_slug':blog_slug,
'blog':blog,
'user':url_user,
'pagination':pagination
})
if not request.user or request.user.id != url_user.id or not blog_slug:
blogs = blogs.all()
return render_to_response(
request,
'mediagoblin/blog/list_of_blogs.html',
{
'blogs':blogs,
'user':url_user,
'max_blog_count':max_blog_count
})
def blog_post_listing(request, page, url_user=None):
"""
Page, listing all the blog posts of a particular blog.
"""
blog_slug = request.matchdict['blog_slug']
blog = get_blog_by_slug(request, blog_slug, author=url_user.id)
if not blog:
return render_404(request)
all_blog_posts = blog.get_all_blog_posts(u'processed').order_by(
MediaEntry.created.desc())
pagination = Pagination(page, all_blog_posts)
pagination.per_page = 8
blog_posts_on_a_page = pagination()
return render_to_response(
request, 'mediagoblin/blog/blog_post_listing.html', {
'blog_posts': blog_posts_on_a_page,
'pagination': pagination,
'blog_owner': url_user,
'blog': blog
})
def blog_dashboard(request, page, url_user=None):
"""
Dashboard for a blog, only accessible to
the owner of the blog.
"""
blog_slug = request.matchdict.get('blog_slug', None)
blogs = request.db.Blog.query.filter_by(author=url_user.id)
config = pluginapi.get_config('mediagoblin.media_types.blog')
max_blog_count = config['max_blog_count']
if request.user and (request.user.id == url_user.id
or request.user.has_privilege(u'admin')):
if blog_slug:
blog = get_blog_by_slug(request, blog_slug)
if not blog:
return render_404(request)
else:
blog_posts_list = blog.get_all_blog_posts().order_by(
MediaEntry.created.desc())
pagination = Pagination(page, blog_posts_list)
pagination.per_page = 15
blog_posts_on_a_page = pagination()
if may_edit_blogpost(request, blog):
return render_to_response(
request, 'mediagoblin/blog/blog_admin_dashboard.html',
{
'blog_posts_list': blog_posts_on_a_page,
'blog_slug': blog_slug,
'blog': blog,
'user': url_user,
'pagination': pagination
})
if not request.user or request.user.id != url_user.id or not blog_slug:
blogs = blogs.all()
return render_to_response(request,
'mediagoblin/blog/list_of_blogs.html', {
'blogs': blogs,
'user': url_user,
'max_blog_count': max_blog_count
})
def processing_panel(request, page, url_user):
"""
Show to the user what media is still in conversion/processing...
and what failed, and why!
"""
user = LocalUser.query.filter_by(username=request.matchdict['user']).first()
# TODO: XXX: Should this be a decorator?
#
# Make sure we have permission to access this user's panel. Only
# admins and this user herself should be able to do so.
if not (user.id == request.user.id or request.user.has_privilege(u'admin')):
# No? Simply redirect to this user's homepage.
return redirect(
request, 'mediagoblin.user_pages.user_home',
user=user.username)
# Get media entries which are in-processing
entries = (MediaEntry.query.filter_by(actor=user.id)
.order_by(MediaEntry.created.desc()))
try:
state = request.matchdict['state']
# no exception was thrown, filter entries by state
entries = entries.filter_by(state=state)
except KeyError:
# show all entries
pass
pagination = Pagination(page, entries)
pagination.per_page = 30
entries_on_a_page = pagination()
# Render to response
return render_to_response(
request,
'mediagoblin/user_pages/processing_panel.html',
{'user': user,
'entries': entries_on_a_page,
'pagination': pagination})
def search_results_view(request, page):
media_entries = None
pagination = None
query = None
form = search_forms.SearchForm(request.form)
if (request.GET.get('query') != None and request.GET.get('query') != ''):
terms = []
skipterms = ['a', 'an', 'the', 'of']
for query in request.GET.get('query').split():
lquery = query.lower()
if lquery not in skipterms:
terms.append('%' + lquery + '%')
media_entry_statements = []
media_tag_statements = []
if len(terms) == 0:
media_entry_statements.append(True)
media_tag_statements.append(True)
else:
for term in terms:
media_entry_statements.append(MediaEntry.title.ilike(term))
media_entry_statements.append(
MediaEntry.description.ilike(term))
media_tag_statements.append(MediaTag.name.ilike(term))
matches = MediaEntry.query.filter(
and_(
MediaEntry.state == u'processed',
or_(
and_(MediaEntry.id == MediaTag.media_entry,
*media_tag_statements),
*media_entry_statements))).order_by(MediaEntry.title)
pagination = Pagination(page, matches)
media_entries = pagination()
return render_to_response(request,
'mediagoblin/plugins/basicsearch/results.html', {
'media_entries': media_entries,
'pagination': pagination,
'form': form
})
def tag_listing(request, page):
"""'Gallery'/listing for this tag slug"""
tag_slug = request.matchdict[u'tag']
cursor = media_entries_for_tag_slug(request.db, tag_slug)
cursor = cursor.order_by(MediaEntry.created.desc())
pagination = Pagination(page, cursor)
media_entries = pagination()
tag_name = _get_tag_name_from_entries(media_entries, tag_slug)
return render_to_response(
request,
'mediagoblin/listings/tag.html',
{'tag_slug': tag_slug,
'tag_name': tag_name,
'media_entries': media_entries,
'pagination': pagination})
def _create_paginator(self, num_items, page, per_page):
"""Create a Paginator with a mock database cursor."""
mock_cursor = mock.MagicMock()
mock_cursor.count.return_value = num_items
return Pagination(page, mock_cursor, per_page)
