def edit(self, id, engine_type=None, **kwargs):
"""Display the :class:`~mediacore.lib.storage.StorageEngine` for editing or adding.
:param id: Storage ID
:type id: ``int`` or ``"new"``
:rtype: dict
:returns:
"""
if id != "new":
engine = fetch_row(StorageEngine, id)
else:
types = dict((cls.engine_type, cls) for cls in StorageEngine)
engine_cls = types.get(engine_type, None)
if not engine_cls:
redirect(controller="/admin/storage", action="index")
engine = engine_cls()
if not engine.settings_form:
# XXX: If this newly created storage engine has no settings,
# just save it. This isn't RESTful (as edit is a GET
# action), but it simplifies the creation process.
DBSession.add(engine)
redirect(controller="/admin/storage", action="index")
return {
"engine": engine,
"form": engine.settings_form,
"form_action": url_for(action="save", engine_type=engine_type),
"form_values": kwargs,
}
def feed(self, slug, **kwargs):
"""Serve the feed as RSS 2.0.
If :attr:`~mediacore.model.podcasts.Podcast.feedburner_url` is
specified for this podcast, we redirect there if the useragent
does not contain 'feedburner', as described here:
http://www.google.com/support/feedburner/bin/answer.py?hl=en&answer=78464
:param feedburner_bypass: If true, the redirect to feedburner is disabled.
:rtype: Dict
:returns:
podcast
A :class:`~mediacore.model.podcasts.Podcast` instance.
episodes
A list of :class:`~mediacore.model.media.Media` instances
that belong to the ``podcast``.
Renders: :data:`podcasts/feed.xml` XML
"""
podcast = fetch_row(Podcast, slug=slug)
if (
podcast.feedburner_url
and not "feedburner" in request.environ.get("HTTP_USER_AGENT", "").lower()
and not kwargs.get("feedburner_bypass", False)
):
redirect(podcast.feedburner_url.encode("utf-8"))
response.content_type = content_type_for_response(["application/rss+xml", "application/xml", "text/xml"])
episodes = podcast.media.published().order_by(Media.publish_on.desc())[:25]
return dict(podcast=podcast, episodes=episodes)
def save(self,
id,
display_name,
group_name,
permissions,
delete=None,
**kwargs):
"""Save changes or create a new :class:`~mediacore.model.auth.Group` instance.
:param id: Group ID. If ``"new"`` a new group is created.
:type id: ``int`` or ``"new"``
:returns: Redirect back to :meth:`index` after successful save.
"""
group = fetch_row(Group, id)
if delete:
DBSession.delete(group)
redirect(action='index', id=None)
group.display_name = display_name
group.group_name = group_name
if permissions:
query = DBSession.query(Permission).filter(
Permission.permission_id.in_(permissions))
group.permissions = list(query.all())
else:
group.permissions = []
DBSession.add(group)
redirect(action='index', id=None)
def save(self, id, email_address, display_name, login_details,
delete=None, **kwargs):
"""Save changes or create a new :class:`~mediacore.model.auth.User` instance.
:param id: User ID. If ``"new"`` a new user is created.
:type id: ``int`` or ``"new"``
:returns: Redirect back to :meth:`index` after successful save.
"""
user = fetch_row(User, id)
if delete:
DBSession.delete(user)
redirect(action='index', id=None)
user.display_name = display_name
user.email_address = email_address
user.user_name = login_details['user_name']
password = login_details['password']
if password is not None and password != '':
user.password = password
if login_details['group']:
group = fetch_row(Group, login_details['group'])
user.groups = [group]
else:
user.groups = []
DBSession.add(user)
DBSession.flush()
redirect(action='index', id=None)
def _save(self, form, redirect_action=None, values=None):
"""Save the values from the passed in form instance."""
values = self._flatten_settings_from_form(tmpl_context.settings,
form, values)
self._update_settings(values)
if redirect_action:
helpers.redirect(action=redirect_action)
def login(self, came_from=None, **kwargs):
if request.environ.get('repoze.who.identity'):
redirect(came_from or '/')
# the friendlyform plugin requires that these values are set in the
# query string
form_url = url_for('/login/submit',
came_from=(came_from or '').encode('utf-8'),
__logins=str(self._is_failed_login()))
login_errors = None
if self._is_failed_login():
login_errors = Invalid('dummy',
None, {},
error_dict={
'_form':
Invalid(
_('Invalid username or password.'),
None, {}),
'login':
Invalid('dummy', None, {}),
'password':
Invalid('dummy', None, {}),
})
return dict(
login_form=login_form,
form_action=form_url,
form_values=kwargs,
login_errors=login_errors,
)
def update_status(self,
id,
status=None,
publish_on=None,
publish_until=None,
**values):
"""Update the publish status for the given media.
:param id: Media ID
:type id: ``int``
:param update_status: The text of the submit button which indicates
that the :attr:`~mediacore.model.media.Media.status` should change.
:type update_status: ``unicode`` or ``None``
:param publish_on: A date to set to
:attr:`~mediacore.model.media.Media.publish_on`
:type publish_on: :class:`datetime.datetime` or ``None``
:param publish_until: A date to set to
:attr:`~mediacore.model.media.Media.publish_until`
:type publish_until: :class:`datetime.datetime` or ``None``
:rtype: JSON dict
:returns:
success
bool
message
Error message, if unsuccessful
status_form
Rendered XHTML for the status form, updated to reflect the
changes made.
"""
media = fetch_row(Media, id)
new_slug = None
# Make the requested change assuming it will be allowed
if status == 'unreviewed':
media.reviewed = True
elif status == 'draft':
self._publish_media(media, publish_on)
elif publish_on:
media.publish_on = publish_on
media.update_popularity()
elif publish_until:
media.publish_until = publish_until
# Verify the change is valid by re-determining the status
media.update_status()
DBSession.flush()
if request.is_xhr:
# Return the rendered widget for injection
status_form_xhtml = unicode(
update_status_form.display(
action=url_for(action='update_status'), media=media))
return dict(
success=True,
status_form=status_form_xhtml,
slug=new_slug,
)
else:
redirect(action='edit')
def serve(self, id, slug, container, **kwargs):
"""Serve a :class:`~mediacore.model.media.MediaFile` binary.
:param id: File ID
:type id: ``int``
:param slug: The media :attr:`~mediacore.model.media.Media.slug`
:type slug: The file :attr:`~mediacore.model.media.MediaFile.container`
:raises webob.exc.HTTPNotFound: If no file exists for the given params.
:raises webob.exc.HTTPNotAcceptable: If an Accept header field
is present, and if the mimetype of the requested file doesn't
match, then a 406 (not acceptable) response is returned.
"""
media = fetch_row(Media, slug=slug)
for file in media.files:
if file.id == id and file.container == container:
# Catch external redirects in case they aren't linked to directly
if file.url:
redirect(file.url.encode('utf-8'))
# Ensure that the clients request allows for files of this container
mimetype = mimeparse.best_match([file.mimetype],
request.environ.get('HTTP_ACCEPT', '*/*'))
if mimetype == '':
raise webob.exc.HTTPNotAcceptable() # 406
response.headers['Content-Type'] = mimetype
response.headers['Content-Disposition'] = \
'attachment;filename="%s"' % file.display_name.encode('utf-8')
return open(file.file_path, 'rb').read()
else:
raise webob.exc.HTTPNotFound()
def index(self, page=1, **kwargs):
"""List podcasts and podcast media.
Our custom paginate decorator allows us to have fewer podcast episodes
display on the first page than on the rest with the ``items_first_page``
param. See :class:`mediacore.lib.custompaginate.CustomPage`.
:param page: Page number, defaults to 1.
:type page: int
:rtype: dict
:returns:
podcasts
The :class:`~mediacore.model.podcasts.Podcast` instance
"""
podcasts = Podcast.query\
.options(orm.undefer('media_count_published'))\
.all()
if len(podcasts) == 1:
redirect(action='view', slug=podcasts[0].slug)
podcast_episodes = {}
for podcast in podcasts:
podcast_episodes[podcast] = podcast.media.published()\
.order_by(Media.publish_on.desc())[:4]
return dict(
podcasts = podcasts,
podcast_episodes = podcast_episodes,
)
def index(self, page=1, **kwargs):
"""List podcasts and podcast media.
Our custom paginate decorator allows us to have fewer podcast episodes
display on the first page than on the rest with the ``items_first_page``
param. See :class:`mediacore.lib.custompaginate.CustomPage`.
:param page: Page number, defaults to 1.
:type page: int
:rtype: dict
:returns:
podcasts
The :class:`~mediacore.model.podcasts.Podcast` instance
"""
podcasts = Podcast.query\
.options(orm.undefer('media_count_published'))\
.all()
if len(podcasts) == 1:
redirect(action='view', slug=podcasts[0].slug)
podcast_episodes = {}
for podcast in podcasts:
podcast_episodes[podcast] = podcast.media.published()\
.order_by(Media.publish_on.desc())[:4]
return dict(
podcasts=podcasts,
podcast_episodes=podcast_episodes,
)
def index(self, **kwargs):
"""List podcasts and podcast media.
:rtype: dict
:returns:
podcasts
The :class:`~mediacore.model.podcasts.Podcast` instance
"""
podcasts = Podcast.query\
.options(orm.undefer('media_count_published'))\
.all()
if len(podcasts) == 1:
redirect(action='view', slug=podcasts[0].slug)
podcast_episodes = {}
for podcast in podcasts:
episode_query = podcast.media.published().order_by(Media.publish_on.desc())
podcast_episodes[podcast] = viewable_media(episode_query)[:4]
return dict(
podcasts = podcasts,
podcast_episodes = podcast_episodes,
)
def edit(self, id, engine_type=None, **kwargs):
"""Display the :class:`~mediacore.lib.storage.StorageEngine` for editing or adding.
:param id: Storage ID
:type id: ``int`` or ``"new"``
:rtype: dict
:returns:
"""
if id != 'new':
engine = fetch_row(StorageEngine, id)
else:
types = dict((cls.engine_type, cls) for cls in StorageEngine)
engine_cls = types.get(engine_type, None)
if not engine_cls:
redirect(controller='/admin/storage', action='index')
engine = engine_cls()
if not engine.settings_form:
# XXX: If this newly created storage engine has no settings,
# just save it. This isn't RESTful (as edit is a GET
# action), but it simplifies the creation process.
DBSession.add(engine)
redirect(controller='/admin/storage', action='index')
return {
'engine': engine,
'form': engine.settings_form,
'form_action': url_for(action='save', engine_type=engine_type),
'form_values': kwargs,
}
def rate(self, slug, up=None, down=None, **kwargs):
"""Say 'I like this' for the given media.
:param slug: The media :attr:`~mediacore.model.media.Media.slug`
:rtype: unicode
:returns:
The new number of likes
"""
media = fetch_row(Media, slug=slug)
request.perm.assert_permission(u'view', media.resource)
if up:
if not request.settings['appearance_show_like']:
abort(status_code=403)
media.increment_likes()
elif down:
if not request.settings['appearance_show_dislike']:
abort(status_code=403)
media.increment_dislikes()
if request.is_xhr:
return u''
else:
redirect(action='view')
def rate(self, slug, up=None, down=None, **kwargs):
"""Say 'I like this' for the given media.
:param slug: The media :attr:`~mediacore.model.media.Media.slug`
:rtype: unicode
:returns:
The new number of likes
"""
media = fetch_row(Media, slug=slug)
request.perm.assert_permission(u'view', media.resource)
if up:
if not request.settings['appearance_show_like']:
abort(status_code=403)
media.increment_likes()
elif down:
if not request.settings['appearance_show_dislike']:
abort(status_code=403)
media.increment_dislikes()
if request.is_xhr:
return u''
else:
redirect(action='view')
def index(self, **kwargs):
"""List podcasts and podcast media.
:rtype: dict
:returns:
podcasts
The :class:`~mediacore.model.podcasts.Podcast` instance
"""
podcasts = Podcast.query\
.options(orm.undefer('media_count_published'))\
.all()
if len(podcasts) == 1:
redirect(action='view', slug=podcasts[0].slug)
podcast_episodes = {}
for podcast in podcasts:
episode_query = podcast.media.published().order_by(
Media.publish_on.desc())
podcast_episodes[podcast] = viewable_media(episode_query)[:4]
return dict(
podcasts=podcasts,
podcast_episodes=podcast_episodes,
)
def _save(self, form, redirect_action=None, values=None):
"""Save the values from the passed in form instance."""
values = self._flatten_settings_from_form(tmpl_context.settings, form,
values)
self._update_settings(values)
if redirect_action:
helpers.redirect(action=redirect_action)
def save(self, id, delete=None, **kwargs):
"""Save changes or create a category.
See :class:`~mediacore.forms.admin.settings.categories.CategoryForm` for POST vars.
:param id: Category ID
:param delete: If true the category is to be deleted rather than saved.
:type delete: bool
:rtype: JSON dict
:returns:
success
bool
"""
if tmpl_context.form_errors:
if request.is_xhr:
return dict(success=False, errors=tmpl_context.form_errors)
else:
# TODO: Add error reporting for users with JS disabled?
return redirect(action="edit")
cat = fetch_row(Category, id)
if delete:
DBSession.delete(cat)
data = dict(success=True, id=cat.id, parent_options=unicode(category_form.c["parent_id"].display()))
else:
cat.name = kwargs["name"]
cat.slug = get_available_slug(Category, kwargs["slug"], cat)
if kwargs["parent_id"]:
parent = fetch_row(Category, kwargs["parent_id"])
if parent is not cat and cat not in parent.ancestors():
cat.parent = parent
else:
cat.parent = None
DBSession.add(cat)
DBSession.flush()
data = dict(
success=True,
id=cat.id,
name=cat.name,
slug=cat.slug,
parent_id=cat.parent_id,
parent_options=unicode(category_form.c["parent_id"].display()),
depth=cat.depth(),
row=unicode(
category_row_form.display(
action=url_for(id=cat.id), category=cat, depth=cat.depth(), first_child=True
)
),
)
if request.is_xhr:
return data
else:
redirect(action="index", id=None)
def view(self, slug, podcast_slug=None, **kwargs):
"""Display the media player, info and comments.
:param slug: The :attr:`~mediacore.models.media.Media.slug` to lookup
:param podcast_slug: The :attr:`~mediacore.models.podcasts.Podcast.slug`
for podcast this media belongs to. Although not necessary for
looking up the media, it tells us that the podcast slug was
specified in the URL and therefore we reached this action by the
preferred route.
:rtype dict:
:returns:
media
The :class:`~mediacore.model.media.Media` instance for display.
comment_form
The :class:`~mediacore.forms.comments.PostCommentForm` instance.
comment_form_action
``str`` comment form action
comment_form_values
``dict`` form values
next_episode
The next episode in the podcast series, if this media belongs to
a podcast, another :class:`~mediacore.model.media.Media`
instance.
"""
media = fetch_row(Media, slug=slug)
if media.podcast_id is not None:
# Always view podcast media from a URL that shows the context of the podcast
if url_for() != url_for(podcast_slug=media.podcast.slug):
redirect(podcast_slug=media.podcast.slug)
if media.fulltext:
search_terms = '%s %s' % (media.title, media.fulltext.tags)
related = Media.query.published()\
.options(orm.undefer('comment_count_published'))\
.filter(Media.id != media.id)\
.search(search_terms, bool=False)
else:
related = []
media.increment_views()
# Which style of 'likes' links has the admin selected?
# TODO: Add settings to control these options.
mediacore_likes = True
facebook_likes = False
return dict(
media = media,
related_media = related[:6],
comments = media.comments.published().all(),
comment_form = post_comment_form,
comment_form_action = url_for(action='comment', anchor=post_comment_form.id),
comment_form_values = kwargs,
mediacore_likes = mediacore_likes,
facebook_likes = facebook_likes,
)
def view(self, slug, podcast_slug=None, **kwargs):
"""Display the media player, info and comments.
:param slug: The :attr:`~mediacore.models.media.Media.slug` to lookup
:param podcast_slug: The :attr:`~mediacore.models.podcasts.Podcast.slug`
for podcast this media belongs to. Although not necessary for
looking up the media, it tells us that the podcast slug was
specified in the URL and therefore we reached this action by the
preferred route.
:rtype dict:
:returns:
media
The :class:`~mediacore.model.media.Media` instance for display.
related_media
A list of :class:`~mediacore.model.media.Media` instances that
rank as topically related to the given media item.
comments
A list of :class:`~mediacore.model.comments.Comment` instances
associated with the selected media item.
comment_form_action
``str`` comment form action
comment_form_values
``dict`` form values
next_episode
The next episode in the podcast series, if this media belongs to
a podcast, another :class:`~mediacore.model.media.Media`
instance.
"""
media = fetch_row(Media, slug=slug)
request.perm.assert_permission(u'view', media.resource)
if media.podcast_id is not None:
# Always view podcast media from a URL that shows the context of the podcast
if url_for() != url_for(podcast_slug=media.podcast.slug):
redirect(podcast_slug=media.podcast.slug)
try:
media.increment_views()
DBSession.commit()
except OperationalError:
DBSession.rollback()
if request.settings['comments_engine'] == 'facebook':
response.facebook = Facebook(request.settings['facebook_appid'])
related_media = viewable_media(Media.query.related(media))[:6]
# TODO: finish implementation of different 'likes' buttons
# e.g. the default one, plus a setting to use facebook.
return dict(
media = media,
related_media = related_media,
comments = media.comments.published().all(),
comment_form_action = url_for(action='comment'),
comment_form_values = kwargs,
)
def view(self, slug, podcast_slug=None, **kwargs):
"""Display the media player, info and comments.
:param slug: The :attr:`~mediacore.models.media.Media.slug` to lookup
:param podcast_slug: The :attr:`~mediacore.models.podcasts.Podcast.slug`
for podcast this media belongs to. Although not necessary for
looking up the media, it tells us that the podcast slug was
specified in the URL and therefore we reached this action by the
preferred route.
:rtype dict:
:returns:
media
The :class:`~mediacore.model.media.Media` instance for display.
related_media
A list of :class:`~mediacore.model.media.Media` instances that
rank as topically related to the given media item.
comments
A list of :class:`~mediacore.model.comments.Comment` instances
associated with the selected media item.
comment_form_action
``str`` comment form action
comment_form_values
``dict`` form values
next_episode
The next episode in the podcast series, if this media belongs to
a podcast, another :class:`~mediacore.model.media.Media`
instance.
"""
media = fetch_row(Media, slug=slug)
request.perm.assert_permission(u'view', media.resource)
if media.podcast_id is not None:
# Always view podcast media from a URL that shows the context of the podcast
if url_for() != url_for(podcast_slug=media.podcast.slug):
redirect(podcast_slug=media.podcast.slug)
try:
media.increment_views()
DBSession.commit()
except OperationalError:
DBSession.rollback()
if request.settings['comments_engine'] == 'facebook':
response.facebook = Facebook(request.settings['facebook_appid'])
related_media = viewable_media(Media.query.related(media))[:6]
# TODO: finish implementation of different 'likes' buttons
# e.g. the default one, plus a setting to use facebook.
return dict(
media=media,
related_media=related_media,
comments=media.comments.published().all(),
comment_form_action=url_for(action='comment'),
comment_form_values=kwargs,
)
def fetch_engine(self, id, engine_type=None):
if id != 'new':
engine = fetch_row(StorageEngine, id)
else:
types = dict((cls.engine_type, cls) for cls in StorageEngine)
engine_cls = types.get(engine_type, None)
if not engine_cls:
redirect(controller='/admin/storage', action='index')
engine = engine_cls()
return engine
def enable(self, id, **kwargs):
"""Enable a StorageEngine.
:param id: Storage ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after success.
"""
engine = fetch_row(StorageEngine, id)
engine.enabled = True
redirect(action="index", id=None)
def disable(self, id, **kwargs):
"""Disable a StorageEngine.
:param id: engine ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after success.
"""
engine = fetch_row(StorageEngine, id)
engine.enabled = False
redirect(action='index', id=None)
def fetch_engine(self, id, engine_type=None):
if id != 'new':
engine = fetch_row(StorageEngine, id)
else:
types = dict((cls.engine_type, cls) for cls in StorageEngine)
engine_cls = types.get(engine_type, None)
if not engine_cls:
redirect(controller='/admin/storage', action='index')
engine = engine_cls()
return engine
def disable(self, id, **kwargs):
"""Disable a StorageEngine.
:param id: engine ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after success.
"""
engine = fetch_row(StorageEngine, id)
engine.enabled = False
redirect(action='index', id=None)
def update_status(self, id, update_button=None, publish_on=None, **values):
"""Update the publish status for the given media.
:param id: Media ID
:type id: ``int``
:param update_status: The text of the submit button which indicates
that the :attr:`~mediacore.model.media.Media.status` should change.
:type update_status: ``unicode`` or ``None``
:param publish_on: A date to set to
:attr:`~mediacore.model.media.Media.publish_on`
:type publish_on: :class:`datetime.datetime` or ``None``
:rtype: JSON dict
:returns:
success
bool
message
Error message, if unsuccessful
status_form
Rendered XHTML for the status form, updated to reflect the
changes made.
"""
media = fetch_row(Media, id)
new_slug = None
# Make the requested change assuming it will be allowed
if update_button == _('Review Complete'):
media.reviewed = True
elif update_button == _('Publish Now'):
media.publishable = True
media.publish_on = publish_on or datetime.now()
media.update_popularity()
# Remove the stub prefix if the user wants the default media title
if media.slug.startswith('_stub_'):
new_slug = get_available_slug(Media, media.slug[len('_stub_'):])
media.slug = new_slug
elif publish_on:
media.publish_on = publish_on
media.update_popularity()
# Verify the change is valid by re-determining the status
media.update_status()
DBSession.flush()
if request.is_xhr:
# Return the rendered widget for injection
status_form_xhtml = unicode(update_status_form.display(
action=url_for(action='update_status'), media=media))
return dict(
success = True,
status_form = status_form_xhtml,
slug = new_slug,
)
else:
redirect(action='edit')
def disable(self, id, **kwargs):
"""Disable a PlayerPref.
:param id: Player ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after success.
"""
player = fetch_row(PlayerPrefs, id)
player.enabled = False
update_enabled_players()
redirect(action='index', id=None)
def update_status(self, id, status=None, publish_on=None, publish_until=None, **values):
"""Update the publish status for the given media.
:param id: Media ID
:type id: ``int``
:param update_status: The text of the submit button which indicates
that the :attr:`~mediacore.model.media.Media.status` should change.
:type update_status: ``unicode`` or ``None``
:param publish_on: A date to set to
:attr:`~mediacore.model.media.Media.publish_on`
:type publish_on: :class:`datetime.datetime` or ``None``
:param publish_until: A date to set to
:attr:`~mediacore.model.media.Media.publish_until`
:type publish_until: :class:`datetime.datetime` or ``None``
:rtype: JSON dict
:returns:
success
bool
message
Error message, if unsuccessful
status_form
Rendered XHTML for the status form, updated to reflect the
changes made.
"""
media = fetch_row(Media, id)
new_slug = None
# Make the requested change assuming it will be allowed
if status == 'unreviewed':
media.reviewed = True
elif status == 'draft':
self._publish_media(media, publish_on)
elif publish_on:
media.publish_on = publish_on
media.update_popularity()
elif publish_until:
media.publish_until = publish_until
# Verify the change is valid by re-determining the status
media.update_status()
DBSession.flush()
if request.is_xhr:
# Return the rendered widget for injection
status_form_xhtml = unicode(update_status_form.display(
action=url_for(action='update_status'), media=media))
return dict(
success = True,
status_form = status_form_xhtml,
slug = new_slug,
)
else:
redirect(action='edit')
def popularity_save(self, **kwargs):
"""Save :class:`~mediacore.forms.admin.settings.PopularityForm`.
Updates the popularity for every media item based on the submitted
values.
"""
self._save(popularity_form, values=kwargs)
for m in Media.query:
m.update_popularity()
DBSession.add(m)
redirect(action='popularity')
def popularity_save(self, **kwargs):
"""Save :class:`~mediacore.forms.admin.settings.PopularityForm`.
Updates the popularity for every media item based on the submitted
values.
"""
self._save(popularity_form, values=kwargs)
for m in Media.query:
m.update_popularity()
DBSession.add(m)
redirect(action='popularity')
def disable(self, id, **kwargs):
"""Disable a PlayerPref.
:param id: Player ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after success.
"""
player = fetch_row(PlayerPrefs, id)
player.enabled = False
update_enabled_players()
redirect(action='index', id=None)
def save(self,
id,
slug,
title,
subtitle,
author_name,
author_email,
description,
details,
feed,
delete=None,
**kwargs):
"""Save changes or create a new :class:`~mediacore.model.podcasts.Podcast` instance.
Form handler the :meth:`edit` action and the
:class:`~mediacore.forms.admin.podcasts.PodcastForm`.
Redirects back to :meth:`edit` after successful editing
and :meth:`index` after successful deletion.
"""
podcast = fetch_row(Podcast, id)
if delete:
file_paths = thumb_paths(podcast).values()
DBSession.delete(podcast)
DBSession.commit()
helpers.delete_files(file_paths, Podcast._thumb_dir)
redirect(action='index', id=None)
if not slug:
slug = title
if slug != podcast.slug:
podcast.slug = get_available_slug(Podcast, slug, podcast)
podcast.title = title
podcast.subtitle = subtitle
podcast.author = Author(author_name, author_email)
podcast.description = description
podcast.copyright = details['copyright']
podcast.category = details['category']
podcast.itunes_url = feed['itunes_url']
podcast.feedburner_url = feed['feedburner_url']
podcast.explicit = {
'yes': True,
'clean': False
}.get(details['explicit'], None)
if id == 'new':
DBSession.add(podcast)
DBSession.flush()
create_default_thumbs_for(podcast)
redirect(action='edit', id=podcast.id)
def comments_save(self, **kwargs):
"""Save :class:`~mediacore.forms.admin.settings.CommentsForm`."""
old_vulgarity_filter = c.settings['vulgarity_filtered_words'].value
self._save(comments_form, values=kwargs)
# Run the filter now if it has changed
if old_vulgarity_filter != c.settings['vulgarity_filtered_words'].value:
for comment in DBSession.query(Comment):
comment.body = filter_vulgarity(comment.body)
redirect(action='comments')
def post_login(self, came_from=None, **kwargs):
if not request.identity:
# The FriendlyForm plugin will always issue a redirect to
# /login/continue (post login url) even for failed logins.
# If 'came_from' is a protected page (i.e. /admin) we could just
# redirect there and the login form will be displayed again with
# our login error message.
# However if the user tried to login from the front page, this
# mechanism doesn't work so go to the login method directly here.
self._increase_number_of_failed_logins()
return self.login(came_from=came_from)
redirect(came_from or url_for('/admin'))
def save_display(self, **kwargs):
"""Save :class:`~mediacore.forms.admin.settings.DisplayForm`."""
player_type = c.settings['player_type'].value
self._save(display_form, **kwargs)
# If the player_type changes, we must update the Media.encoded flag,
# since some things may play now and/or not play anymore with the
# new setting.
if player_type != c.settings['player_type'].value:
for m in Media.query.options(orm.eagerload('files')):
m.update_status()
DBSession.add(m)
redirect(action='display')
def save(self, id, slug, title, author_name, author_email,
description, notes, podcast, tags, categories,
delete=None, **kwargs):
"""Save changes or create a new :class:`~mediacore.model.media.Media` instance.
Form handler the :meth:`edit` action and the
:class:`~mediacore.forms.admin.media.MediaForm`.
Redirects back to :meth:`edit` after successful editing
and :meth:`index` after successful deletion.
"""
media = fetch_row(Media, id)
if delete:
self._delete_media(media)
DBSession.commit()
redirect(action='index', id=None)
if not slug:
slug = title
elif slug.startswith('_stub_'):
slug = slug[len('_stub_'):]
if slug != media.slug:
media.slug = get_available_slug(Media, slug, media)
media.title = title
media.author = Author(author_name, author_email)
media.description = description
media.notes = notes
media.podcast_id = podcast
media.set_tags(tags)
media.set_categories(categories)
media.update_status()
DBSession.add(media)
DBSession.flush()
if id == 'new' and not has_thumbs(media):
create_default_thumbs_for(media)
if request.is_xhr:
status_form_xhtml = unicode(update_status_form.display(
action=url_for(action='update_status', id=media.id),
media=media))
return dict(
media_id = media.id,
values = {'slug': slug},
link = url_for(action='edit', id=media.id),
status_form = status_form_xhtml,
)
else:
redirect(action='edit', id=media.id)
def save(self, id, slug, title, author_name, author_email,
description, notes, podcast, tags, categories,
delete=None, **kwargs):
"""Save changes or create a new :class:`~mediacore.model.media.Media` instance.
Form handler the :meth:`edit` action and the
:class:`~mediacore.forms.admin.media.MediaForm`.
Redirects back to :meth:`edit` after successful editing
and :meth:`index` after successful deletion.
"""
media = fetch_row(Media, id)
if delete:
self._delete_media(media)
DBSession.commit()
redirect(action='index', id=None)
if not slug:
slug = title
elif slug.startswith('_stub_'):
slug = slug[len('_stub_'):]
if slug != media.slug:
media.slug = get_available_slug(Media, slug, media)
media.title = title
media.author = Author(author_name, author_email)
media.description = description
media.notes = notes
media.podcast_id = podcast
media.set_tags(tags)
media.set_categories(categories)
media.update_status()
DBSession.add(media)
DBSession.flush()
if id == 'new' and not has_thumbs(media):
create_default_thumbs_for(media)
if request.is_xhr:
status_form_xhtml = unicode(update_status_form.display(
action=url_for(action='update_status', id=media.id),
media=media))
return dict(
media_id = media.id,
values = {'slug': slug},
link = url_for(action='edit', id=media.id),
status_form = status_form_xhtml,
)
else:
redirect(action='edit', id=media.id)
def comments_save(self, **kwargs):
"""Save :class:`~mediacore.forms.admin.settings.CommentsForm`."""
old_vulgarity_filter = c.settings['vulgarity_filtered_words'].value
self._save(comments_form, values=kwargs)
# Run the filter now if it has changed
if old_vulgarity_filter != c.settings['vulgarity_filtered_words'].value:
for comment in DBSession.query(Comment):
comment.body = filter_vulgarity(comment.body)
redirect(action='comments')
def delete(self, id, **kwargs):
"""Delete a user.
:param id: User ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after successful delete.
"""
user = fetch_row(User, id)
DBSession.delete(user)
if request.is_xhr:
return dict(success=True)
redirect(action='index', id=None)
def delete(self, id, **kwargs):
"""Delete a StorageEngine.
:param id: Storage ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after successful delete.
"""
engine = fetch_row(StorageEngine, id)
files = engine.files
for f in files:
engine.delete(f.unique_id)
DBSession.delete(engine)
redirect(action='index', id=None)
def submit(self, **kwargs):
"""
"""
kwargs.setdefault("name")
# Save the media_obj!
media_obj = self.save_media_obj(
kwargs["name"], kwargs["email"], kwargs["title"], kwargs["description"], None, kwargs["file"], kwargs["url"]
)
email.send_media_notification(media_obj)
# Redirect to success page!
redirect(action="success")
def delete(self, id, **kwargs):
"""Delete a StorageEngine.
:param id: Storage ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after successful delete.
"""
engine = fetch_row(StorageEngine, id)
files = engine.files
for f in files:
engine.delete(f.unique_id)
DBSession.delete(engine)
redirect(action='index', id=None)
def delete(self, id, **kwargs):
"""Delete a group.
:param id: Group ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after successful delete.
"""
group = fetch_row(Group, id)
DBSession.delete(group)
if request.is_xhr:
return dict(success=True)
redirect(action='index', id=None)
def delete(self, id, **kwargs):
"""Delete a group.
:param id: Group ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after successful delete.
"""
group = fetch_row(Group, id)
DBSession.delete(group)
if request.is_xhr:
return dict(success=True)
redirect(action='index', id=None)
def random(self, **kwargs):
"""Redirect to a randomly selected media item."""
# TODO: Implement something more efficient than ORDER BY RAND().
# This method does a full table scan every time.
random_query = Media.query.published().order_by(sql.func.random())
media = viewable_media(random_query).first()
if media is None:
redirect(action='explore')
if media.podcast_id:
podcast_slug = DBSession.query(Podcast.slug).get(media.podcast_id)
else:
podcast_slug = None
redirect(action='view', slug=media.slug, podcast_slug=podcast_slug)
def random(self, **kwargs):
"""Redirect to a randomly selected media item."""
# TODO: Implement something more efficient than ORDER BY RAND().
# This method does a full table scan every time.
media = Media.query.published()\
.order_by(sql.func.random())\
.first()
if media is None:
redirect(action='explore')
if media.podcast_id:
podcast_slug = DBSession.query(Podcast.slug).get(media.podcast_id)
else:
podcast_slug = None
redirect(action='view', slug=media.slug, podcast_slug=podcast_slug)
def panda_update(self, media_id=None, file_id=None, video_id=None, **kwargs):
if file_id:
media_file = fetch_row(MediaFile, file_id)
media_files = [media_file]
elif media_id:
media = fetch_row(Media, media_id)
media_files = media.files
storage = DBSession.query(PandaStorage).first()
for media_file in media_files:
storage.panda_helper().video_status_update(media_file, video_id)
redirect(controller='/admin/media', action='edit', id=media_id)
def submit(self, **kwargs):
"""
"""
kwargs.setdefault('name')
# Save the media_obj!
media_obj = self.save_media_obj(
kwargs['name'], kwargs['email'],
kwargs['title'], kwargs['description'],
None, kwargs['file'], kwargs['url'],
)
email.send_media_notification(media_obj)
# Redirect to success page!
redirect(action='success')
def submit(self, **kwargs):
"""
"""
kwargs.setdefault('name')
# Save the media_obj!
media_obj = self.save_media_obj(
kwargs['name'], kwargs['email'],
kwargs['title'], kwargs['description'],
None, kwargs['file'], kwargs['url'],
)
email.send_media_notification(media_obj)
# Redirect to success page!
redirect(action='success')
def report(self, email='', description='', **kwargs):
"""Email a support request that's been submitted on :meth:`document`.
Redirects back to the root URL ``/``.
"""
url = ''
get_vars = post_vars = {}
for x in kwargs:
if x.startswith('GET_'):
get_vars[x] = kwargs[x]
elif x.startswith('POST_'):
post_vars[x] = kwargs[x]
libemail.send_support_request(email, url, description, get_vars, post_vars)
redirect('/')
def report(self, email='', description='', **kwargs):
"""Email a support request that's been submitted on :meth:`document`.
Redirects back to the root URL ``/``.
"""
url = ''
get_vars = post_vars = {}
for x in kwargs:
if x.startswith('GET_'):
get_vars[x] = kwargs[x]
elif x.startswith('POST_'):
post_vars[x] = kwargs[x]
libemail.send_support_request(email, url, description, get_vars, post_vars)
redirect('/')
def view(self, slug, podcast_slug=None, **kwargs):
"""Display the media player, info and comments.
:param slug: The :attr:`~mediacore.models.media.Media.slug` to lookup
:param podcast_slug: The :attr:`~mediacore.models.podcasts.Podcast.slug`
for podcast this media belongs to. Although not necessary for
looking up the media, it tells us that the podcast slug was
specified in the URL and therefore we reached this action by the
preferred route.
:rtype dict:
:returns:
media
The :class:`~mediacore.model.media.Media` instance for display.
comment_form
The :class:`~mediacore.forms.comments.PostCommentForm` instance.
comment_form_action
``str`` comment form action
comment_form_values
``dict`` form values
next_episode
The next episode in the podcast series, if this media belongs to
a podcast, another :class:`~mediacore.model.media.Media`
instance.
"""
media = fetch_row(Media, slug=slug)
if media.podcast_id is not None:
# Always view podcast media from a URL that shows the context of the podcast
if url_for() != url_for(podcast_slug=media.podcast.slug):
redirect(podcast_slug=media.podcast.slug)
media.increment_views()
# Which style of 'likes' links has the admin selected?
# TODO: Add settings to control these options.
mediacore_likes = True
facebook_likes = False
return dict(
media=media,
related_media=Media.query.related(media)[:6],
comments=media.comments.published().all(),
comment_form_action=url_for(action='comment'),
comment_form_values=kwargs,
mediacore_likes=mediacore_likes,
facebook_likes=facebook_likes,
)
class YouTubeImportController(BaseSettingsController):
@expose('youtube_import/admin/import.html')
def index(self, **kwargs):
category_tree = Category.query.order_by(Category.name).populated_tree()
return dict(
form=import_form,
form_values=kwargs,
form_action=url_for(controller='youtube_import',
action='perform_import'),
category_tree=category_tree,
)
@expose()
@validate(import_form, error_handler=index)
@autocommit
def perform_import(self, youtube, **kwargs):
auto_publish = youtube.get('auto_publish', False)
user = request.perm.user
tags = kwargs.get('youtube.tags')
categories = kwargs.get('youtube.categories')
channel_names = parse_channel_names(youtube.get('channel_names', ''))
importer = YouTubeImporter(user, auto_publish, tags, categories)
try:
for channel_name in channel_names:
importer.import_videos_from_channel(channel_name)
except YouTubeQuotaExceeded, e:
error_message = e.args[0]
c.form_errors['_the_form'] = error_message
return self.index(youtube=youtube, **kwargs)
# Redirect to the Media view page, when the import is complete
redirect(url_for(controller='admin/media', action='index'))
def save(self,
id,
email_address,
display_name,
login_details,
delete=None,
**kwargs):
"""Save changes or create a new :class:`~mediacore.model.auth.User` instance.
:param id: User ID. If ``"new"`` a new user is created.
:type id: ``int`` or ``"new"``
:returns: Redirect back to :meth:`index` after successful save.
"""
user = fetch_row(User, id)
if delete:
DBSession.delete(user)
redirect(action='index', id=None)
user.display_name = display_name
user.email_address = email_address
user.user_name = login_details['user_name']
password = login_details['password']
if password is not None and password != '':
user.password = password
if login_details['group']:
group = fetch_row(Group, login_details['group'])
user.groups = [group]
else:
user.groups = []
DBSession.add(user)
# Check if we're changing the logged in user's own password
logged_in_user = request.environ['repoze.who.identity']['user']
if user.user_id == logged_in_user.user_id \
and password is not None and password != '':
DBSession.commit()
# repoze.who sees the Unauthorized response and clears the cookie,
# forcing a fresh login with the new password
raise webob.exc.HTTPUnauthorized().exception
redirect(action='index', id=None)
def delete(self, id, **kwargs):
"""Delete a PlayerPref.
After deleting the PlayerPref, cleans up the players table,
ensuring that each Player class is represented--if the deleted
PlayerPref is the last example of that Player class, creates a new
disabled PlayerPref for that Player class with the default settings.
:param id: Player ID.
:type id: ``int``
:returns: Redirect back to :meth:`index` after successful delete.
"""
player = fetch_row(PlayerPrefs, id)
DBSession.delete(player)
DBSession.flush()
cleanup_players_table()
redirect(action='index', id=None)
def save_status(self, id, status, ids=None, **kwargs):
"""Approve or delete a comment or comments.
:param id: A :attr:`~mediacore.model.comments.Comment.id` if we are
acting on a single comment, or ``"bulk"`` if we should refer to
``ids``.
:type id: ``int`` or ``"bulk"``
:param status: ``"approve"`` or ``"trash"`` depending on what action
the user requests.
:param ids: An optional string of IDs separated by commas.
:type ids: ``unicode`` or ``None``
:rtype: JSON dict
:returns:
success
bool
ids
A list of :attr:`~mediacore.model.comments.Comment.id`
that have changed.
"""
if id != 'bulk':
ids = [id]
if not isinstance(ids, list):
ids = [ids]
if status == 'approve':
publishable = True
elif status == 'trash':
publishable = False
else:
# XXX: This form should never be submitted without a valid status.
raise AssertionError('Unexpected status: %r' % status)
comments = Comment.query.filter(Comment.id.in_(ids)).all()
for comment in comments:
comment.reviewed = True
comment.publishable = publishable
DBSession.add(comment)
DBSession.flush()
if request.is_xhr:
return dict(success=True, ids=ids)
else:
redirect(action='index')
def view(self, slug, podcast_slug=None, **kwargs):
"""Display the media player, info and comments.
:param slug: The :attr:`~mediacore.models.media.Media.slug` to lookup
:param podcast_slug: The :attr:`~mediacore.models.podcasts.Podcast.slug`
for podcast this media belongs to. Although not necessary for
looking up the media, it tells us that the podcast slug was
specified in the URL and therefore we reached this action by the
preferred route.
:rtype dict:
:returns:
media
The :class:`~mediacore.model.media.Media` instance for display.
related_media
A list of :class:`~mediacore.model.media.Media` instances that
rank as topically related to the given media item.
comments
A list of :class:`~mediacore.model.comments.Comment` instances
associated with the selected media item.
comment_form_action
``str`` comment form action
comment_form_values
``dict`` form values
next_episode
The next episode in the podcast series, if this media belongs to
a podcast, another :class:`~mediacore.model.media.Media`
instance.
"""
media = fetch_row(Media, slug=slug)
if media.podcast_id is not None:
# Always view podcast media from a URL that shows the context of the podcast
if url_for() != url_for(podcast_slug=media.podcast.slug):
redirect(podcast_slug=media.podcast.slug)
media.increment_views()
# TODO: finish implementation of different 'likes' buttons
# e.g. the default one, plus a setting to use facebook.
return dict(media=media,
related_media=Media.query.related(media)[:6],
comments=media.comments.published().all(),
comment_form_action=url_for(action='comment'),
comment_form_values=kwargs,
can_comment=self.can_comment())
def popularity_save(self, **kwargs):
"""Save :class:`~mediacore.forms.admin.settings.PopularityForm`.
Updates the popularity for every media item based on the submitted
values.
"""
self._save(popularity_form, values=kwargs)
# ".util.calculate_popularity()" uses the popularity settings from
# the request.settings which are only updated when a new request
# comes in.
# update the settings manually so the popularity is actually updated
# correctly.
for key in ('popularity_decay_exponent', 'popularity_decay_lifetime'):
request.settings[key] = kwargs['popularity.'+key]
for m in Media.query:
m.update_popularity()
DBSession.add(m)
redirect(action='popularity')
def rate(self, slug, up=None, down=None, **kwargs):
"""Say 'I like this' for the given media.
:param slug: The media :attr:`~mediacore.model.media.Media.slug`
:rtype: unicode
:returns:
The new number of likes
"""
# we have to check if current user is anonymous or authenticated
userid = check_user_authentication(request)
if not userid:
log.warn('Anonymous user cannot rate media')
raise HTTPUnauthorized().exception
media = fetch_row(Media, slug=slug)
# check if current user has already voted this media object
votes = Vote.query.get_votes(media_id=media.id, user_name=userid)
if votes.count():
# if true redirect to 'view'
log.warn('User %s already voted this media')
redirect(action='view')
# create new vote object mapping current media and user
vote = Vote()
vote.media_id = media.id
vote.user_name = userid
# Give the Vote object an ID.
DBSession.add(vote)
DBSession.flush()
if up:
vote.increment_likes()
media.increment_likes()
elif down:
vote.increment_dislikes()
media.increment_dislikes()
if request.is_xhr:
return u''
else:
redirect(action='view')
