aboutsummaryrefslogtreecommitdiffstats
path: root/mediagoblin/submit
diff options
context:
space:
mode:
Diffstat (limited to 'mediagoblin/submit')
-rw-r--r--mediagoblin/submit/lib.py155
-rw-r--r--mediagoblin/submit/views.py141
2 files changed, 194 insertions, 102 deletions
diff --git a/mediagoblin/submit/lib.py b/mediagoblin/submit/lib.py
index 1bbf2cb8..c70e2731 100644
--- a/mediagoblin/submit/lib.py
+++ b/mediagoblin/submit/lib.py
@@ -16,12 +16,18 @@
import logging
import uuid
+from os.path import splitext
+
from werkzeug.utils import secure_filename
from werkzeug.datastructures import FileStorage
-from mediagoblin.db.models import MediaEntry
+from mediagoblin import mg_globals
+from mediagoblin.tools.text import convert_to_tag_list_of_dicts
+from mediagoblin.db.models import MediaEntry, ProcessingMetaData
from mediagoblin.processing import mark_entry_failed
from mediagoblin.processing.task import ProcessMedia
+from mediagoblin.notifications import add_comment_subscription
+from mediagoblin.media_types import sniff_media
_log = logging.getLogger(__name__)
@@ -47,6 +53,153 @@ def new_upload_entry(user):
return entry
+def get_upload_file_limits(user):
+ """
+ Get the upload_limit and max_file_size for this user
+ """
+ if user.upload_limit >= 0:
+ upload_limit = user.upload_limit
+ else:
+ upload_limit = mg_globals.app_config.get('upload_limit', None)
+
+ max_file_size = mg_globals.app_config.get('max_file_size', None)
+
+ return upload_limit, max_file_size
+
+
+class UploadLimitError(Exception):
+ """
+ General exception for when an upload will be over some upload limit
+ """
+ pass
+
+
+class FileUploadLimit(UploadLimitError):
+ """
+ This file is over the site upload limit
+ """
+ pass
+
+
+class UserUploadLimit(UploadLimitError):
+ """
+ This file is over the user's particular upload limit
+ """
+ pass
+
+
+class UserPastUploadLimit(UploadLimitError):
+ """
+ The user is *already* past their upload limit!
+ """
+ pass
+
+
+
+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 prepare_queue_task(app, entry, filename):
"""
Prepare a MediaEntry for the processing queue and get a queue file
diff --git a/mediagoblin/submit/views.py b/mediagoblin/submit/views.py
index 7f7dee33..42c378a8 100644
--- a/mediagoblin/submit/views.py
+++ b/mediagoblin/submit/views.py
@@ -16,55 +16,38 @@
from mediagoblin import messages
import mediagoblin.mg_globals as mg_globals
-from os.path import splitext
import logging
-import uuid
_log = logging.getLogger(__name__)
-from mediagoblin.tools.text import convert_to_tag_list_of_dicts
from mediagoblin.tools.translate import pass_to_ugettext as _
from mediagoblin.tools.response import render_to_response, redirect
-from mediagoblin.decorators import require_active_login
+from mediagoblin.decorators import require_active_login, user_has_privilege
from mediagoblin.submit import forms as submit_forms
from mediagoblin.messages import add_message, SUCCESS
-from mediagoblin.media_types import sniff_media, \
+from mediagoblin.media_types import \
InvalidFileType, FileTypeNotSupported
-from mediagoblin.submit.lib import check_file_field, prepare_queue_task, \
- run_process_media, new_upload_entry
-
-from mediagoblin.notifications import add_comment_subscription
+from mediagoblin.submit.lib import \
+ check_file_field, submit_media, get_upload_file_limits, \
+ FileUploadLimit, UserUploadLimit, UserPastUploadLimit
@require_active_login
+@user_has_privilege(u'uploader')
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)
+ upload_limit, max_file_size = get_upload_file_limits(request.user)
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)
+ uploaded=request.user.uploaded)
if request.method == 'POST' and submit_form.validate():
if not check_file_field(request, 'file'):
@@ -72,83 +55,39 @@ def submit_start(request):
_(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)
+ submit_media(
+ mg_app=request.app, user=request.user,
+ submitted_file=request.files['file'],
+ filename=request.files['file'].filename,
+ title=unicode(submit_form.title.data),
+ description=unicode(submit_form.description.data),
+ license=unicode(submit_form.license.data) or None,
+ tags_string=submit_form.tags.data,
+ upload_limit=upload_limit, max_file_size=max_file_size,
+ urlgen=request.urlgen)
+
+ add_message(request, SUCCESS, _('Woohoo! Submitted!'))
+
+ return redirect(request, "mediagoblin.user_pages.user_home",
+ user=request.user.username)
+
+
+ # Handle upload limit issues
+ except FileUploadLimit:
+ submit_form.file.errors.append(
+ _(u'Sorry, the file size is too big.'))
+ except UserUploadLimit:
+ submit_form.file.errors.append(
+ _('Sorry, uploading this file will put you over your'
+ ' upload limit.'))
+ except UserPastUploadLimit:
+ 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)
- return redirect(request, "mediagoblin.user_pages.user_home",
- user=user.username)
except Exception as e:
'''
This section is intended to catch exceptions raised in