def test_list_of_dicts_conversion(test_app):
"""
When the user adds tags to a media entry, the string from the form is
converted into a list of tags, where each tag is stored in the database
as a dict. Each tag dict should contain the tag's name and slug. Another
function performs the reverse operation when populating a form to edit tags.
"""
# Leading, trailing, and internal whitespace should be removed and slugified
assert text.convert_to_tag_list_of_dicts('sleep , 6 AM, chainsaw! ') == [
{'name': u'sleep', 'slug': u'sleep'},
{'name': u'6 AM', 'slug': u'6-am'},
{'name': u'chainsaw!', 'slug': u'chainsaw'}]
# If the user enters two identical tags, record only one of them
assert text.convert_to_tag_list_of_dicts('echo,echo') == [{'name': u'echo',
'slug': u'echo'}]
# When checking for duplicates, use the slug, not the tag
assert text.convert_to_tag_list_of_dicts('echo,#echo') == [{'name': u'#echo',
'slug': u'echo'}]
# Make sure converting the list of dicts to a string works
assert text.media_tags_as_string([{'name': u'yin', 'slug': u'yin'},
{'name': u'yang', 'slug': u'yang'}]) == \
u'yin, yang'
def edit_blog_post(request):
"""
First view for submitting a file.
"""
form = forms.BlogPostEditForm(request.form,
license=request.user.license_preference)
if request.method == 'POST' and form.validate():
media_type = 'blogpost'
entry = request.db.MediaEntry()
entry.media_type = unicode(media_type)
entry.title = unicode(form.title.data)
entry.description = unicode(form.description.data)
entry.license = unicode(form.license.data) or None
entry.uploader = request.user.id
entry.tags = convert_to_tag_list_of_dicts(form.tags.data)
entry.generate_slug()
entry.save()
add_message(request, SUCCESS, _('Woohoo! Submitted!'))
return redirect(request, "mediagoblin.plugins.blog.blog.view",
user=request.user.username)
return render_to_response(
request,
'blog/blogpost_edit.html',
{'form': form,
'app_config': mg_globals.app_config,
'user': request.user})
def import_file(self, media):
try:
media_type, media_manager = (
#get_media_type_and_manager(media.filename))
type_match_handler(media,media.filename))
except FileTypeNotSupported:
print u"File type not supported: {0}".format(media.filename)
return
entry = self.db.MediaEntry()
entry.media_type = unicode(media_type)
entry.title = unicode(
os.path.basename(os.path.splitext(media.filename)[0]))
entry.uploader = 1
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts("")
# Generate a slug from the title
entry.generate_slug()
task_id = unicode(uuid.uuid4())
entry.queued_media_file = media.filename.split("/")
entry.queued_task_id = task_id
try:
entry.save()
entry_id = entry.id
run_process_media(entry)
Session.commit()
return entry_id
except Exception:
Session.rollback()
raise
def import_file(self, media):
try:
media_type, media_manager = sniff_media(media)
except (InvalidFileType, FileTypeNotSupported) as e:
print u"File error {0}: {1}".format(media.filename, repr(e)).encode("utf-8")
return
entry = self.db.MediaEntry()
entry.media_type = unicode(media_type)
entry.title = unicode(os.path.splitext(media.filename)[0])
entry.uploader = 1
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts("")
# Generate a slug from the title
entry.generate_slug()
task_id = unicode(uuid.uuid4())
entry.queued_media_file = media.filename.split("/")
entry.queued_task_id = task_id
entry.save()
process_media = registry.tasks[ProcessMedia.name]
try:
process_media.apply_async( [unicode(entry.id)], {}, task_id=task_id)
except BaseException as exc:
mark_entry_failed(entry.id, exc)
raise
def test_list_of_dicts_conversion(test_app):
"""
When the user adds tags to a media entry, the string from the form is
converted into a list of tags, where each tag is stored in the database
as a dict. Each tag dict should contain the tag's name and slug. Another
function performs the reverse operation when populating a form to edit tags.
"""
# Leading, trailing, and internal whitespace should be removed and slugified
assert text.convert_to_tag_list_of_dicts('sleep , 6 AM, chainsaw! ') == [
{'name': u'sleep', 'slug': u'sleep'},
{'name': u'6 AM', 'slug': u'6-am'},
{'name': u'chainsaw!', 'slug': u'chainsaw'}]
# If the user enters two identical tags, record only one of them
assert text.convert_to_tag_list_of_dicts('echo,echo') == [{'name': u'echo',
'slug': u'echo'}]
# Make sure converting the list of dicts to a string works
assert text.media_tags_as_string([{'name': u'yin', 'slug': u'yin'},
{'name': u'yang', 'slug': u'yang'}]) == \
u'yin, yang'
def edit_media(request, media):
if not may_edit_media(request, media):
return exc.HTTPForbidden()
defaults = dict(
title=media.title,
slug=media.slug,
description=media.description,
tags=media_tags_as_string(media.tags),
license=media.license)
form = forms.EditForm(
request.form,
**defaults)
if request.method == 'POST' and form.validate():
# Make sure there isn't already a MediaEntry with such a slug
# and userid.
slug_used = check_media_slug_used(request.db, media.uploader,
request.form['slug'], media.id)
if slug_used:
form.slug.errors.append(
_(u'An entry with that slug already exists for this user.'))
else:
media.title = unicode(request.form['title'])
media.description = unicode(request.form.get('description'))
media.tags = convert_to_tag_list_of_dicts(
request.form.get('tags'))
media.license = unicode(request.form.get('license', '')) or None
media.slug = unicode(request.form['slug'])
media.save()
return exc.HTTPFound(
location=media.url_for_self(request.urlgen))
if request.user.is_admin \
and media.uploader != request.user._id \
and request.method != 'POST':
messages.add_message(
request, messages.WARNING,
_("You are editing another user's media. Proceed with caution."))
return render_to_response(
request,
'mediagoblin/edit/edit.html',
{'media': media,
'form': form})
def edit_media(request, media):
if not may_edit_media(request, media):
raise Forbidden("User may not edit this media")
defaults = dict(
title=media.title,
slug=media.slug,
description=media.description,
tags=media_tags_as_string(media.tags),
license=media.license)
form = forms.EditForm(
request.form,
**defaults)
if request.method == 'POST' and form.validate():
# Make sure there isn't already a MediaEntry with such a slug
# and userid.
slug = slugify(form.slug.data)
slug_used = check_media_slug_used(media.uploader, slug, media.id)
if slug_used:
form.slug.errors.append(
_(u'An entry with that slug already exists for this user.'))
else:
media.title = form.title.data
media.description = form.description.data
media.tags = convert_to_tag_list_of_dicts(
form.tags.data)
media.license = unicode(form.license.data) or None
media.slug = slug
media.save()
return redirect_obj(request, media)
if request.user.has_privilege(u'admin') \
and media.uploader != request.user.id \
and request.method != 'POST':
messages.add_message(
request, messages.WARNING,
_("You are editing another user's media. Proceed with caution."))
return render_to_response(
request,
'mediagoblin/edit/edit.html',
{'media': media,
'form': form})
def edit_media(request, media):
# If media is not processed, return NotFound.
if not media.state == 'processed':
return render_404(request)
if not may_edit_media(request, media):
raise Forbidden("User may not edit this media")
defaults = dict(title=media.title,
slug=media.slug,
description=media.description,
tags=media_tags_as_string(media.tags),
license=media.license)
form = forms.EditForm(request.method == 'POST' and request.form or None,
**defaults)
if request.method == 'POST' and form.validate():
# Make sure there isn't already a MediaEntry with such a slug
# and userid.
slug = slugify(form.slug.data)
slug_used = check_media_slug_used(media.actor, slug, media.id)
if slug_used:
form.slug.errors.append(
_('An entry with that slug already exists for this user.'))
else:
media.title = form.title.data
media.description = form.description.data
media.tags = convert_to_tag_list_of_dicts(form.tags.data)
media.license = str(form.license.data) or None
media.slug = slug
media.save()
return redirect_obj(request, media)
if request.user.has_privilege('admin') \
and media.actor != request.user.id \
and request.method != 'POST':
messages.add_message(
request, messages.WARNING,
_("You are editing another user's media. Proceed with caution."))
return render_to_response(request, 'mediagoblin/edit/edit.html', {
'media': media,
'form': form
})
def blogpost_create(request):
form = blog_forms.BlogPostEditForm(request.form,
license=request.user.license_preference)
if request.method == 'POST' and form.validate():
blog_slug = request.matchdict.get('blog_slug')
blog = request.db.Blog.query.filter_by(slug=blog_slug,
author=request.user.id).first()
if not blog:
return render_404(request)
blogpost = request.db.MediaEntry()
blogpost.media_type = 'mediagoblin.media_types.blogpost'
blogpost.title = unicode(form.title.data)
blogpost.description = unicode(
cleaned_markdown_conversion((form.description.data)))
blogpost.tags = convert_to_tag_list_of_dicts(form.tags.data)
blogpost.license = unicode(form.license.data) or None
blogpost.uploader = request.user.id
blogpost.generate_slug()
set_blogpost_state(request, blogpost)
blogpost.save()
# connect this blogpost to its blog
blog_post_data = request.db.BlogPostData()
blog_post_data.blog = blog.id
blog_post_data.media_entry = blogpost.id
blog_post_data.save()
add_message(request, SUCCESS, _('Woohoo! Submitted!'))
add_comment_subscription(request.user, blogpost)
return redirect(request,
"mediagoblin.media_types.blog.blog-dashboard",
user=request.user.username,
blog_slug=blog.slug)
return render_to_response(
request, 'mediagoblin/blog/blog_post_edit_create.html', {
'form': form,
'app_config': mg_globals.app_config,
'user': request.user.username
})
def blogpost_edit(request):
blog_slug = request.matchdict.get('blog_slug', None)
blog_post_slug = request.matchdict.get('blog_post_slug', None)
blogpost = request.db.MediaEntry.query.filter_by(slug=blog_post_slug, actor=request.user.id).first()
blog = get_blog_by_slug(request, blog_slug, author=request.user.id)
if not blogpost or not blog:
return render_404(request)
defaults = dict(
title = blogpost.title,
description = cleaned_markdown_conversion(blogpost.description),
tags=media_tags_as_string(blogpost.tags),
license=blogpost.license)
form = blog_forms.BlogPostEditForm(request.form, **defaults)
if request.method == 'POST' and form.validate():
blogpost.title = six.text_type(form.title.data)
blogpost.description = six.text_type(cleaned_markdown_conversion((form.description.data)))
blogpost.tags = convert_to_tag_list_of_dicts(form.tags.data)
blogpost.license = six.text_type(form.license.data)
set_blogpost_state(request, blogpost)
blogpost.generate_slug()
blogpost.save()
messages.add_message(
request,
messages.SUCCESS,
_('Woohoo! edited blogpost is submitted'))
return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
user=request.user.username,
blog_slug=blog.slug)
return render_to_response(
request,
'mediagoblin/blog/blog_post_edit_create.html',
{'form': form,
'app_config': mg_globals.app_config,
'user': request.user.username,
'blog_post_slug': blog_post_slug
})
def blogpost_create(request):
form = blog_forms.BlogPostEditForm(request.form, license=request.user.license_preference)
if request.method == 'POST' and form.validate():
blog_slug = request.matchdict.get('blog_slug')
blog = get_blog_by_slug(request, blog_slug, author=request.user.id)
if not blog:
return render_404(request)
blogpost = request.db.MediaEntry()
blogpost.media_type = 'mediagoblin.media_types.blogpost'
blogpost.title = six.text_type(form.title.data)
blogpost.description = six.text_type(cleaned_markdown_conversion((form.description.data)))
blogpost.tags = convert_to_tag_list_of_dicts(form.tags.data)
blogpost.license = six.text_type(form.license.data) or None
blogpost.actor = request.user.id
blogpost.generate_slug()
set_blogpost_state(request, blogpost)
blogpost.save()
# connect this blogpost to its blog
blog_post_data = request.db.BlogPostData()
blog_post_data.blog = blog.id
blog_post_data.media_entry = blogpost.id
blog_post_data.save()
messages.add_message(
request,
messages.SUCCESS,
_('Woohoo! Submitted!'))
add_comment_subscription(request.user, blogpost)
return redirect(request, "mediagoblin.media_types.blog.blog-dashboard",
user=request.user.username,
blog_slug=blog.slug)
return render_to_response(
request,
'mediagoblin/blog/blog_post_edit_create.html',
{'form': form,
'app_config': mg_globals.app_config,
'user': request.user.username})
def blogpost_edit(request):
blog_slug = request.matchdict.get('blog_slug', None)
blog_post_slug = request.matchdict.get('blog_post_slug', None)
blogpost = request.db.MediaEntry.query.filter_by(
slug=blog_post_slug, uploader=request.user.id).first()
blog = get_blog_by_slug(request, blog_slug, author=request.user.id)
if not blogpost or not blog:
return render_404(request)
defaults = dict(title=blogpost.title,
description=cleaned_markdown_conversion(
blogpost.description),
tags=media_tags_as_string(blogpost.tags),
license=blogpost.license)
form = blog_forms.BlogPostEditForm(request.form, **defaults)
if request.method == 'POST' and form.validate():
blogpost.title = six.text_type(form.title.data)
blogpost.description = six.text_type(
cleaned_markdown_conversion((form.description.data)))
blogpost.tags = convert_to_tag_list_of_dicts(form.tags.data)
blogpost.license = six.text_type(form.license.data)
set_blogpost_state(request, blogpost)
blogpost.generate_slug()
blogpost.save()
add_message(request, SUCCESS,
_('Woohoo! edited blogpost is submitted'))
return redirect(request,
"mediagoblin.media_types.blog.blog-dashboard",
user=request.user.username,
blog_slug=blog.slug)
return render_to_response(
request, 'mediagoblin/blog/blog_post_edit_create.html', {
'form': form,
'app_config': mg_globals.app_config,
'user': request.user.username,
'blog_post_slug': blog_post_slug
})
def edit_media(request, media):
if not may_edit_media(request, media):
raise Forbidden("User may not edit this media")
defaults = dict(
title=media.title,
slug=media.slug,
description=media.description,
tags=media_tags_as_string(media.tags),
license=media.license,
)
form = forms.EditForm(request.form, **defaults)
if request.method == "POST" and form.validate():
# Make sure there isn't already a MediaEntry with such a slug
# and userid.
slug_used = check_media_slug_used(request.db, media.uploader, request.form["slug"], media.id)
if slug_used:
form.slug.errors.append(_(u"An entry with that slug already exists for this user."))
else:
media.title = unicode(request.form["title"])
media.description = unicode(request.form.get("description"))
media.tags = convert_to_tag_list_of_dicts(request.form.get("tags"))
media.license = unicode(request.form.get("license", "")) or None
media.slug = unicode(request.form["slug"])
media.save()
return redirect(request, location=media.url_for_self(request.urlgen))
if request.user.is_admin and media.uploader != request.user.id and request.method != "POST":
messages.add_message(
request, messages.WARNING, _("You are editing another user's media. Proceed with caution.")
)
return render_to_response(request, "mediagoblin/edit/edit.html", {"media": media, "form": form})
def submit_media(mg_app, user, submitted_file, filename,
title=None, description=None,
license=None, tags_string=u"",
upload_limit=None, max_file_size=None,
callback_url=None,
# If provided we'll do the feed_url update, otherwise ignore
urlgen=None,):
"""
Args:
- mg_app: The MediaGoblinApp instantiated for this process
- user: the user object this media entry should be associated with
- submitted_file: the file-like object that has the
being-submitted file data in it (this object should really have
a .name attribute which is the filename on disk!)
- filename: the *original* filename of this. Not necessarily the
one on disk being referenced by submitted_file.
- title: title for this media entry
- description: description for this media entry
- license: license for this media entry
- tags_string: comma separated string of tags to be associated
with this entry
- upload_limit: size in megabytes that's the per-user upload limit
- max_file_size: maximum size each file can be that's uploaded
- callback_url: possible post-hook to call after submission
- urlgen: if provided, used to do the feed_url update
"""
if upload_limit and user.uploaded >= upload_limit:
raise UserPastUploadLimit()
# If the filename contains non ascii generate a unique name
if not all(ord(c) < 128 for c in filename):
filename = unicode(uuid.uuid4()) + splitext(filename)[-1]
# Sniff the submitted media to determine which
# media plugin should handle processing
media_type, media_manager = sniff_media(submitted_file, filename)
# create entry and save in database
entry = new_upload_entry(user)
entry.media_type = media_type
entry.title = (title or unicode(splitext(filename)[0]))
entry.description = description or u""
entry.license = license or None
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(tags_string)
# Generate a slug from the title
entry.generate_slug()
queue_file = prepare_queue_task(mg_app, entry, filename)
with queue_file:
queue_file.write(submitted_file.read())
# Get file size and round to 2 decimal places
file_size = mg_app.queue_store.get_file_size(
entry.queued_media_file) / (1024.0 * 1024)
file_size = float('{0:.2f}'.format(file_size))
# Check if file size is over the limit
if max_file_size and file_size >= max_file_size:
raise FileUploadLimit()
# Check if user is over upload limit
if upload_limit and (user.uploaded + file_size) >= upload_limit:
raise UserUploadLimit()
user.uploaded = user.uploaded + file_size
user.save()
entry.file_size = file_size
# Save now so we have this data before kicking off processing
entry.save()
# Various "submit to stuff" things, callbackurl and this silly urlgen
# thing
if callback_url:
metadata = ProcessingMetaData()
metadata.media_entry = entry
metadata.callback_url = callback_url
metadata.save()
if urlgen:
feed_url = urlgen(
'mediagoblin.user_pages.atom_feed',
qualified=True, user=user.username)
else:
feed_url = None
# Pass off to processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
run_process_media(entry, feed_url)
add_comment_subscription(user, entry)
return entry
def submit_media(
mg_app,
user,
submitted_file,
filename,
title=None,
description=None,
collection_slug=None,
license=None,
metadata=None,
tags_string=u"",
callback_url=None,
urlgen=None,
):
"""
Args:
- mg_app: The MediaGoblinApp instantiated for this process
- user: the user object this media entry should be associated with
- submitted_file: the file-like object that has the
being-submitted file data in it (this object should really have
a .name attribute which is the filename on disk!)
- filename: the *original* filename of this. Not necessarily the
one on disk being referenced by submitted_file.
- title: title for this media entry
- description: description for this media entry
- collection_slug: collection for this media entry
- license: license for this media entry
- tags_string: comma separated string of tags to be associated
with this entry
- callback_url: possible post-hook to call after submission
- urlgen: if provided, used to do the feed_url update and assign a public
ID used in the API (very important).
"""
upload_limit, max_file_size = get_upload_file_limits(user)
if upload_limit and user.uploaded >= upload_limit:
raise UserPastUploadLimit()
# If the filename contains non ascii generate a unique name
if not all(ord(c) < 128 for c in filename):
filename = six.text_type(uuid.uuid4()) + splitext(filename)[-1]
# Sniff the submitted media to determine which
# media plugin should handle processing
media_type, media_manager = sniff_media(submitted_file, filename)
# create entry and save in database
entry = new_upload_entry(user)
entry.media_type = media_type
entry.title = (title or six.text_type(splitext(filename)[0]))
entry.description = description or u""
entry.license = license or None
entry.media_metadata = metadata or {}
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(tags_string)
# Generate a slug from the title
entry.generate_slug()
queue_file = prepare_queue_task(mg_app, entry, filename)
with queue_file:
queue_file.write(submitted_file)
# Get file size and round to 2 decimal places
file_size = mg_app.queue_store.get_file_size(
entry.queued_media_file) / (1024.0 * 1024)
file_size = float('{0:.2f}'.format(file_size))
# Check if file size is over the limit
if max_file_size and file_size >= max_file_size:
raise FileUploadLimit()
# Check if user is over upload limit
if upload_limit and (user.uploaded + file_size) >= upload_limit:
raise UserUploadLimit()
user.uploaded = user.uploaded + file_size
user.save()
entry.file_size = file_size
# Save now so we have this data before kicking off processing
entry.save()
# Various "submit to stuff" things, callbackurl and this silly urlgen
# thing
if callback_url:
metadata = ProcessingMetaData()
metadata.media_entry = entry
metadata.callback_url = callback_url
metadata.save()
if urlgen:
# Generate the public_id, this is very importent, especially relating
# to deletion, it allows the shell to be accessable post-delete!
entry.get_public_id(urlgen)
# Generate the feed URL
feed_url = urlgen('mediagoblin.user_pages.atom_feed',
qualified=True,
user=user.username)
else:
feed_url = None
add_comment_subscription(user, entry)
# Create activity
create_activity("post", entry, entry.actor)
entry.save()
# add to collection
if collection_slug:
collection = Collection.query.filter_by(slug=collection_slug,
actor=user.id).first()
if collection:
add_media_to_collection(collection, entry)
# Pass off to processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
run_process_media(entry, feed_url)
return entry
def multi_submit_start(request):
"""
First view for submitting a file.
"""
submit_form = submit_forms.get_submit_start_form(
request.form, license=request.user.license_preference)
users_collections = Collection.query.filter_by(
actor=request.user.id,
type=Collection.USER_DEFINED_TYPE).order_by(Collection.title)
if users_collections.count() > 0:
submit_form.collection.query = users_collections
else:
del submit_form.collection
# Below is what was used for mediagoblin 0.5.0-dev. Above is the new way.
# submit_form = submit_forms.SubmitStartForm(request.form, license=request.user.license_preference)
filecount = 0
if request.method == 'POST' and submit_form.validate():
if not check_file_field(request, 'file'):
submit_form.file.errors.append(
_(u'You must provide at least one file.'))
else:
for submitted_file in request.files.getlist('file'):
try:
if not submitted_file.filename:
# MOST likely an invalid file
continue # Skip the rest of the loop for this file
else:
filename = submitted_file.filename
_log.info("html5-multi-upload: Got filename: %s" %
filename)
# If the filename contains non ascii generate a unique name
if not all(ord(c) < 128 for c in filename):
filename = str(
uuid.uuid4()) + splitext(filename)[-1]
# Sniff the submitted media to determine which
# media plugin should handle processing
media_type, media_manager = sniff_media(
submitted_file, filename)
# create entry and save in database
entry = new_upload_entry(request.user)
entry.media_type = str(media_type)
entry.title = (str(submit_form.title.data) or str(
splitext(submitted_file.filename)[0]))
entry.description = str(submit_form.description.data)
entry.license = str(submit_form.license.data) or None
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(
submit_form.tags.data)
# Generate a slug from the title
entry.generate_slug()
queue_file = prepare_queue_task(
request.app, entry, filename)
with queue_file:
queue_file.write(submitted_file.stream.read())
# Save now so we have this data before kicking off processing
entry.save()
# Pass off to async processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
feed_url = request.urlgen(
'mediagoblin.user_pages.atom_feed',
qualified=True,
user=request.user.username)
run_process_media(entry, feed_url)
if submit_form.collection and submit_form.collection.data:
add_media_to_collection(
submit_form.collection.data, entry)
create_activity("add",
entry,
request.user,
target=submit_form.collection.data)
add_comment_subscription(request.user, entry)
filecount = filecount + 1
except Exception as e:
'''
This section is intended to catch exceptions raised in
mediagoblin.media_types
'''
if isinstance(e, TypeNotFound) or isinstance(
e, FileTypeNotSupported):
submit_form.file.errors.append(e)
else:
raise
add_message(request, SUCCESS,
_('Woohoo! Submitted %d Files!' % filecount))
return redirect(request,
"mediagoblin.user_pages.user_home",
user=request.user.username)
return render_to_response(request, 'start.html',
{'multi_submit_form': submit_form})
def submit_start(request):
"""
First view for submitting a file.
"""
submit_form = submit_forms.SubmitStartForm(request.form,
license=request.user.license_preference)
if request.method == 'POST' and submit_form.validate():
if not check_file_field(request, 'file'):
submit_form.file.errors.append(
_(u'You must provide a file.'))
else:
try:
filename = request.files['file'].filename
# If the filename contains non ascii generate a unique name
if not all(ord(c) < 128 for c in filename):
filename = unicode(uuid.uuid4()) + splitext(filename)[-1]
# Sniff the submitted media to determine which
# media plugin should handle processing
# I've modified ../media_types/__init__.py so that a zip file can pass the checking system
# It will be seen as an image file
media_type, media_manager = sniff_media(
request.files['file'])
# Read the zip file and processing each photo with its metadata
zf = zipfile.ZipFile(request.files['file'], 'r')
for name in zf.namelist():
try:
data = zf.read(name)
if imghdr.what(name, data):
metadata = ElementTree.ElementTree(ElementTree.fromstring(zf.read(name.split(".")[0]+'.xml')))
# Fetch the data in metadata that matches the format in mediagoblin
# Not yet finish the whole checking problem, some data may not exist
img_title = metadata.find('title').text
img_description = metadata.find('description').text
img_tags = ''
for tag in metadata.find('tags'):
img_tags = img_tags + ', ' + tag.text
upload_data = data
upload_filename = name.lstrip('dst/')
# create entry and save in database
entry = new_upload_entry(request.user)
entry.media_type = unicode(media_type)
entry.title = unicode(img_title)#(
#unicode(submit_form.title.data)
#or unicode(splitext(request.files['file'].filename)[0]))
entry.description = unicode(img_description)#unicode(submit_form.description.data)
entry.license = unicode('http://creativecommons.org/publicdomain/mark/1.0/')#unicode(submit_form.license.data) or None
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(img_tags)
# submit_form.tags.data)
# Generate a slug from the title
entry.generate_slug()
queue_file = prepare_queue_task(request.app, entry, upload_filename)#filename)
with queue_file:
queue_file.write(upload_data)#request.files['file'].stream.read())
# Save now so we have this data before kicking off processing
entry.save()
feed_url = request.urlgen(
'mediagoblin.user_pages.atom_feed',
qualified=True, user=request.user.username)
run_process_media(entry, feed_url)
except KeyError:
print 'ERROR: Did not find %s in zip file' % name
# Pass off to processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
add_message(request, SUCCESS, _('Woohoo! Submitted!'))
add_comment_subscription(request.user, entry)
return redirect(request, "mediagoblin.user_pages.user_home",
user=request.user.username)
except Exception as e:
'''
This section is intended to catch exceptions raised in
mediagoblin.media_types
'''
if isinstance(e, InvalidFileType) or \
isinstance(e, FileTypeNotSupported):
submit_form.file.errors.append(
e)
else:
raise
return render_to_response(
request,
'mediagoblin/import_flickr/start.html',
{'submit_form': submit_form,
'app_config': mg_globals.app_config})
def submit_start(request):
"""
First view for submitting a file.
"""
user = request.user
if user.upload_limit >= 0:
upload_limit = user.upload_limit
else:
upload_limit = mg_globals.app_config.get('upload_limit', None)
if upload_limit and user.uploaded >= upload_limit:
messages.add_message(
request,
messages.WARNING,
_('Sorry, you have reached your upload limit.'))
return redirect(request, "mediagoblin.user_pages.user_home",
user=request.user.username)
max_file_size = mg_globals.app_config.get('max_file_size', None)
submit_form = submit_forms.get_submit_start_form(
request.form,
license=request.user.license_preference,
max_file_size=max_file_size,
upload_limit=upload_limit,
uploaded=user.uploaded)
if request.method == 'POST' and submit_form.validate():
if not check_file_field(request, 'file'):
submit_form.file.errors.append(
_(u'You must provide a file.'))
else:
try:
filename = request.files['file'].filename
# If the filename contains non ascii generate a unique name
if not all(ord(c) < 128 for c in filename):
filename = unicode(uuid.uuid4()) + splitext(filename)[-1]
# Sniff the submitted media to determine which
# media plugin should handle processing
media_type, media_manager = sniff_media(
request.files['file'])
# create entry and save in database
entry = new_upload_entry(request.user)
entry.media_type = unicode(media_type)
entry.title = (
unicode(submit_form.title.data)
or unicode(splitext(request.files['file'].filename)[0]))
entry.description = unicode(submit_form.description.data)
entry.license = unicode(submit_form.license.data) or None
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(
submit_form.tags.data)
# Generate a slug from the title
entry.generate_slug()
queue_file = prepare_queue_task(request.app, entry, filename)
with queue_file:
queue_file.write(request.files['file'].stream.read())
# Get file size and round to 2 decimal places
file_size = request.app.queue_store.get_file_size(
entry.queued_media_file) / (1024.0 * 1024)
file_size = float('{0:.2f}'.format(file_size))
error = False
# Check if file size is over the limit
if max_file_size and file_size >= max_file_size:
submit_form.file.errors.append(
_(u'Sorry, the file size is too big.'))
error = True
# Check if user is over upload limit
if upload_limit and (user.uploaded + file_size) >= upload_limit:
submit_form.file.errors.append(
_('Sorry, uploading this file will put you over your'
' upload limit.'))
error = True
if not error:
user.uploaded = user.uploaded + file_size
user.save()
entry.file_size = file_size
# Save now so we have this data before kicking off processing
entry.save()
# Pass off to processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
feed_url = request.urlgen(
'mediagoblin.user_pages.atom_feed',
qualified=True, user=request.user.username)
run_process_media(entry, feed_url)
add_message(request, SUCCESS, _('Woohoo! Submitted!'))
add_comment_subscription(request.user, entry)
return redirect(request, "mediagoblin.user_pages.user_home",
user=user.username)
except Exception as e:
'''
This section is intended to catch exceptions raised in
mediagoblin.media_types
'''
if isinstance(e, InvalidFileType) or \
isinstance(e, FileTypeNotSupported):
submit_form.file.errors.append(
e)
else:
raise
return render_to_response(
request,
'mediagoblin/submit/start.html',
{'submit_form': submit_form,
'app_config': mg_globals.app_config})
def submit_start(request):
"""
First view for submitting a file.
"""
submit_form = submit_forms.SubmitStartForm(request.form)
if request.method == 'POST' and submit_form.validate():
if not ('file' in request.files
and isinstance(request.files['file'], FileStorage)
and request.files['file'].stream):
submit_form.file.errors.append(
_(u'You must provide a file.'))
else:
try:
filename = request.files['file'].filename
# Sniff the submitted media to determine which
# media plugin should handle processing
media_type, media_manager = sniff_media(
request.files['file'])
# create entry and save in database
entry = request.db.MediaEntry()
entry.id = ObjectId()
entry.media_type = unicode(media_type)
entry.title = (
unicode(request.form['title'])
or unicode(splitext(filename)[0]))
entry.description = unicode(request.form.get('description'))
entry.license = unicode(request.form.get('license', "")) or None
entry.uploader = request.user._id
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(
request.form.get('tags'))
# Generate a slug from the title
entry.generate_slug()
# We generate this ourselves so we know what the taks id is for
# retrieval later.
# (If we got it off the task's auto-generation, there'd be
# a risk of a race condition when we'd save after sending
# off the task)
task_id = unicode(uuid.uuid4())
# Now store generate the queueing related filename
queue_filepath = request.app.queue_store.get_unique_filepath(
['media_entries',
task_id,
secure_filename(filename)])
# queue appropriately
queue_file = request.app.queue_store.get_file(
queue_filepath, 'wb')
with queue_file:
queue_file.write(request.files['file'].stream.read())
# Add queued filename to the entry
entry.queued_media_file = queue_filepath
entry.queued_task_id = task_id
# Save now so we have this data before kicking off processing
entry.save(validate=True)
# Pass off to processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
process_media = registry.tasks[ProcessMedia.name]
try:
process_media.apply_async(
[unicode(entry._id)], {},
task_id=task_id)
except BaseException as exc:
# The purpose of this section is because when running in "lazy"
# or always-eager-with-exceptions-propagated celery mode that
# the failure handling won't happen on Celery end. Since we
# expect a lot of users to run things in this way we have to
# capture stuff here.
#
# ... not completely the diaper pattern because the
# exception is re-raised :)
mark_entry_failed(entry._id, exc)
# re-raise the exception
raise
if mg_globals.app_config["push_urls"]:
feed_url = request.urlgen(
'mediagoblin.user_pages.atom_feed',
qualified=True,
user=request.user.username)
hubparameters = {
'hub.mode': 'publish',
'hub.url': feed_url}
hubdata = urllib.urlencode(hubparameters)
hubheaders = {
"Content-type": "application/x-www-form-urlencoded",
"Connection": "close"}
for huburl in mg_globals.app_config["push_urls"]:
hubrequest = urllib2.Request(huburl, hubdata, hubheaders)
try:
hubresponse = urllib2.urlopen(hubrequest)
except urllib2.HTTPError as exc:
# This is not a big issue, the item will be fetched
# by the PuSH server next time we hit it
_log.warning(
"push url %r gave error %r", huburl, exc.code)
except urllib2.URLError as exc:
_log.warning(
"push url %r is unreachable %r", huburl, exc.reason)
add_message(request, SUCCESS, _('Woohoo! Submitted!'))
return redirect(request, "mediagoblin.user_pages.user_home",
user=request.user.username)
except Exception as e:
'''
This section is intended to catch exceptions raised in
mediagoblin.media_types
'''
if isinstance(e, InvalidFileType) or \
isinstance(e, FileTypeNotSupported):
submit_form.file.errors.append(
e)
else:
raise
return render_to_response(
request,
'mediagoblin/submit/start.html',
{'submit_form': submit_form,
'app_config': mg_globals.app_config})
def multi_submit_start(request):
"""
First view for submitting a file.
"""
submit_form = submit_forms.get_submit_start_form(request.form, license=request.user.license_preference)
users_collections = Collection.query.filter_by(
actor=request.user.id,
type=Collection.USER_DEFINED_TYPE
).order_by(Collection.title)
if users_collections.count() > 0:
submit_form.collection.query = users_collections
else:
del submit_form.collection
# Below is what was used for mediagoblin 0.5.0-dev. Above is the new way.
# submit_form = submit_forms.SubmitStartForm(request.form, license=request.user.license_preference)
filecount = 0
if request.method == 'POST' and submit_form.validate():
if not check_file_field(request, 'file'):
submit_form.file.errors.append(_(u'You must provide at least one file.'))
else:
for submitted_file in request.files.getlist('file'):
try:
if not submitted_file.filename:
# MOST likely an invalid file
continue # Skip the rest of the loop for this file
else:
filename = submitted_file.filename
_log.info("html5-multi-upload: Got filename: %s" % filename)
# If the filename contains non ascii generate a unique name
if not all(ord(c) < 128 for c in filename):
filename = unicode(uuid.uuid4()) + splitext(filename)[-1]
# Sniff the submitted media to determine which
# media plugin should handle processing
media_type, media_manager = sniff_media(
submitted_file, filename)
# create entry and save in database
entry = new_upload_entry(request.user)
entry.media_type = unicode(media_type)
entry.title = (
unicode(submit_form.title.data)
or unicode(splitext(submitted_file.filename)[0]))
entry.description = unicode(submit_form.description.data)
entry.license = unicode(submit_form.license.data) or None
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(
submit_form.tags.data)
# Generate a slug from the title
entry.generate_slug()
queue_file = prepare_queue_task(request.app, entry, filename)
with queue_file:
queue_file.write(submitted_file.stream.read())
# Save now so we have this data before kicking off processing
entry.save()
# Pass off to async processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
feed_url = request.urlgen(
'mediagoblin.user_pages.atom_feed',
qualified=True, user=request.user.username)
run_process_media(entry, feed_url)
if submit_form.collection and submit_form.collection.data:
add_media_to_collection(
submit_form.collection.data, entry)
create_activity(
"add", entry, request.user,
target=submit_form.collection.data)
add_comment_subscription(request.user, entry)
filecount = filecount + 1
except Exception as e:
'''
This section is intended to catch exceptions raised in
mediagoblin.media_types
'''
if isinstance(e, TypeNotFound) or isinstance(e, FileTypeNotSupported):
submit_form.file.errors.append(e)
else:
raise
add_message(request, SUCCESS, _('Woohoo! Submitted %d Files!' % filecount))
return redirect(request, "mediagoblin.user_pages.user_home",
user=request.user.username)
return render_to_response(
request,
'start.html',
{'multi_submit_form': submit_form})
def submit_start(request):
"""
First view for submitting a file.
"""
submit_form = submit_forms.SubmitStartForm(request.form)
if request.method == 'POST' and submit_form.validate():
if not ('file' in request.files
and isinstance(request.files['file'], FileStorage)
and request.files['file'].stream):
submit_form.file.errors.append(
_(u'You must provide a file.'))
else:
try:
filename = request.files['file'].filename
# Sniff the submitted media to determine which
# media plugin should handle processing
media_type, media_manager = sniff_media(
request.files['file'])
# create entry and save in database
entry = request.db.MediaEntry()
entry.media_type = unicode(media_type)
entry.title = (
unicode(request.form['title'])
or unicode(splitext(filename)[0]))
entry.description = unicode(request.form.get('description'))
entry.license = unicode(request.form.get('license', "")) or None
entry.uploader = request.user.id
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(
request.form.get('tags'))
# Generate a slug from the title
entry.generate_slug()
queue_file = prepare_queue_task(request.app, entry, filename)
with queue_file:
queue_file.write(request.files['file'].stream.read())
# Save now so we have this data before kicking off processing
entry.save()
# Pass off to processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
run_process_media(entry)
handle_push_urls(request)
add_message(request, SUCCESS, _('Woohoo! Submitted!'))
return redirect(request, "mediagoblin.user_pages.user_home",
user=request.user.username)
except Exception as e:
'''
This section is intended to catch exceptions raised in
mediagoblin.media_types
'''
if isinstance(e, InvalidFileType) or \
isinstance(e, FileTypeNotSupported):
submit_form.file.errors.append(
e)
else:
raise
return render_to_response(
request,
'mediagoblin/submit/start.html',
{'submit_form': submit_form,
'app_config': mg_globals.app_config})
def submit_start(request):
"""
First view for submitting a file.
"""
submit_form = submit_forms.SubmitStartForm(request.form,
license=request.user.license_preference)
if request.method == 'POST' and submit_form.validate():
if not check_file_field(request, 'file'):
submit_form.file.errors.append(
_(u'You must provide a file.'))
else:
try:
filename = request.files['file'].filename
# If the filename contains non ascii generate a unique name
if not all(ord(c) < 128 for c in filename):
filename = unicode(uuid.uuid4()) + splitext(filename)[-1]
# Sniff the submitted media to determine which
# media plugin should handle processing
media_type, media_manager = sniff_media(
request.files['file'])
# create entry and save in database
entry = new_upload_entry(request.user)
entry.media_type = unicode(media_type)
entry.title = (
unicode(submit_form.title.data)
or unicode(splitext(request.files['file'].filename)[0]))
entry.description = unicode(submit_form.description.data)
entry.license = unicode(submit_form.license.data) or None
# Process the user's folksonomy "tags"
entry.tags = convert_to_tag_list_of_dicts(
submit_form.tags.data)
# Generate a slug from the title
entry.generate_slug()
queue_file = prepare_queue_task(request.app, entry, filename)
with queue_file:
queue_file.write(request.files['file'].stream.read())
# Save now so we have this data before kicking off processing
entry.save()
# Pass off to async processing
#
# (... don't change entry after this point to avoid race
# conditions with changes to the document via processing code)
feed_url = request.urlgen(
'mediagoblin.user_pages.atom_feed',
qualified=True, user=request.user.username)
run_process_media(entry, feed_url)
add_message(request, SUCCESS, _('Woohoo! Submitted!'))
add_comment_subscription(request.user, entry)
return redirect(request, "mediagoblin.user_pages.user_home",
user=request.user.username)
except Exception as e:
'''
This section is intended to catch exceptions raised in
mediagoblin.media_types
'''
if isinstance(e, InvalidFileType) or \
isinstance(e, FileTypeNotSupported):
submit_form.file.errors.append(
e)
else:
raise
return render_to_response(
request,
'mediagoblin/submit/start.html',
{'submit_form': submit_form,
'app_config': mg_globals.app_config})
