Beispiel #1
0
def pwg_images_addSimple(request):
    form = AddSimpleForm(request.form)
    if not form.validate():
        _log.error("addSimple: form failed")
        raise BadRequest()
    dump = []
    for f in form:
        dump.append("%s=%r" % (f.name, f.data))
    _log.info("addSimple: %r %s %r", request.form, " ".join(dump), request.files)

    if not check_file_field(request, "image"):
        raise BadRequest()

    filename = request.files["image"].filename

    # Sniff the submitted media to determine which
    # media plugin should handle processing
    media_type, media_manager = sniff_media(request.files["image"])

    # create entry and save in database
    entry = new_upload_entry(request.user)
    entry.media_type = unicode(media_type)
    entry.title = unicode(form.name.data) or unicode(splitext(filename)[0])

    entry.description = unicode(form.comment.data)

    """
    # Process the user's folksonomy "tags"
    entry.tags = convert_to_tag_list_of_dicts(
        form.tags.data)
    """

    # Generate a slug from the title
    entry.generate_slug()

    queue_file = prepare_queue_task(request.app, entry, filename)

    with queue_file:
        shutil.copyfileobj(request.files["image"].stream, queue_file, length=4 * 1048576)

    # 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)

    collection_id = form.category.data
    if collection_id > 0:
        collection = Collection.query.get(collection_id)
        if collection is not None and collection.creator == request.user.id:
            add_media_to_collection(collection, entry, "")

    return {"image_id": entry.id, "url": entry.url_for_self(request.urlgen, qualified=True)}
Beispiel #2
0
def post_entry(request):
    _log.debug('Posting entry')

    if request.method == 'OPTIONS':
        return json_response({'status': 200})

    if request.method != 'POST':
        _log.debug('Must POST against post_entry')
        raise BadRequest()

    if not check_file_field(request, 'file'):
        _log.debug('File field not found')
        raise BadRequest()

    upload_limit, max_file_size = get_upload_file_limits(request.user)

    callback_url = request.form.get('callback_url')
    if callback_url:
        callback_url = unicode(callback_url)
    try:
        entry = submit_media(mg_app=request.app,
                             user=request.user,
                             submitted_file=request.files['file'],
                             filename=request.files['file'].filename,
                             title=unicode(request.form.get('title')),
                             description=unicode(
                                 request.form.get('description')),
                             license=unicode(request.form.get('license', '')),
                             tags_string=unicode(request.form.get('tags', '')),
                             upload_limit=upload_limit,
                             max_file_size=max_file_size,
                             callback_url=callback_url)

        return json_response(get_entry_serializable(entry, request.urlgen))

    # Handle upload limit issues
    except FileUploadLimit:
        raise BadRequest(_(u'Sorry, the file size is too big.'))
    except UserUploadLimit:
        raise BadRequest(
            _('Sorry, uploading this file will put you over your'
              ' upload limit.'))
    except UserPastUploadLimit:
        raise BadRequest(_('Sorry, you have reached your upload limit.'))

    except Exception as e:
        '''
        This section is intended to catch exceptions raised in
        mediagoblin.media_types
        '''
        if isinstance(e, InvalidFileType) or \
                isinstance(e, FileTypeNotSupported):
            raise BadRequest(unicode(e))
        else:
            raise
Beispiel #3
0
def post_entry(request):
    _log.debug('Posting entry')

    if request.method == 'OPTIONS':
        return json_response({'status': 200})

    if request.method != 'POST':
        _log.debug('Must POST against post_entry')
        raise BadRequest()

    if not check_file_field(request, 'file'):
        _log.debug('File field not found')
        raise BadRequest()

    upload_limit, max_file_size = get_upload_file_limits(request.user)

    callback_url = request.form.get('callback_url')
    if callback_url:
        callback_url = unicode(callback_url)
    try:
        entry = submit_media(
            mg_app=request.app, user=request.user,
            submitted_file=request.files['file'],
            filename=request.files['file'].filename,
            title=unicode(request.form.get('title')),
            description=unicode(request.form.get('description')),
            license=unicode(request.form.get('license', '')),
            upload_limit=upload_limit, max_file_size=max_file_size,
            callback_url=callback_url)

        return json_response(get_entry_serializable(entry, request.urlgen))

    # Handle upload limit issues
    except FileUploadLimit:
        raise BadRequest(
            _(u'Sorry, the file size is too big.'))
    except UserUploadLimit:
        raise BadRequest(
            _('Sorry, uploading this file will put you over your'
              ' upload limit.'))
    except UserPastUploadLimit:
        raise BadRequest(
            _('Sorry, you have reached your upload limit.'))

    except Exception as e:
        '''
        This section is intended to catch exceptions raised in
        mediagoblin.media_types
        '''
        if isinstance(e, InvalidFileType) or \
                isinstance(e, FileTypeNotSupported):
            raise BadRequest(unicode(e))
        else:
            raise
Beispiel #4
0
def post_entry(request):
    _log.debug('Posting entry')

    if request.method == 'OPTIONS':
        return json_response({'status': 200})

    if request.method != 'POST':
        _log.debug('Must POST against post_entry')
        raise BadRequest()

    if not check_file_field(request, 'file'):
        _log.debug('File field not found')
        raise BadRequest()

    media_file = request.files['file']

    media_type, media_manager = sniff_media(media_file)

    entry = new_upload_entry(request.user)
    entry.media_type = unicode(media_type)
    entry.title = unicode(
        request.form.get('title') or splitext(media_file.filename)[0])

    entry.description = unicode(request.form.get('description'))
    entry.license = unicode(request.form.get('license', ''))

    entry.generate_slug()

    # queue appropriately
    queue_file = prepare_queue_task(request.app, entry, media_file.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()

    if request.form.get('callback_url'):
        metadata = request.db.ProcessingMetaData()
        metadata.media_entry = entry
        metadata.callback_url = unicode(request.form['callback_url'])
        metadata.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)

    return json_response(get_entry_serializable(entry, request.urlgen))
Beispiel #5
0
def post_entry(request):
    _log.debug('Posting entry')

    if request.method == 'OPTIONS':
        return json_response({'status': 200})

    if request.method != 'POST':
        _log.debug('Must POST against post_entry')
        raise BadRequest()

    if not check_file_field(request, 'file'):
        _log.debug('File field not found')
        raise BadRequest()

    media_file = request.files['file']

    media_type, media_manager = sniff_media(media_file)

    entry = new_upload_entry(request.user)
    entry.media_type = unicode(media_type)
    entry.title = unicode(request.form.get('title')
            or splitext(media_file.filename)[0])

    entry.description = unicode(request.form.get('description'))
    entry.license = unicode(request.form.get('license', ''))

    entry.generate_slug()

    # queue appropriately
    queue_file = prepare_queue_task(request.app, entry, media_file.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()

    if request.form.get('callback_url'):
        metadata = request.db.ProcessingMetaData()
        metadata.media_entry = entry
        metadata.callback_url = unicode(request.form['callback_url'])
        metadata.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)

    return json_response(get_entry_serializable(entry, request.urlgen))
Beispiel #6
0
def post_entry(request):
    _log.debug("Posting entry")

    if request.method == "OPTIONS":
        return json_response({"status": 200})

    if request.method != "POST":
        _log.debug("Must POST against post_entry")
        raise BadRequest()

    if not check_file_field(request, "file"):
        _log.debug("File field not found")
        raise BadRequest()

    media_file = request.files["file"]

    media_type, media_manager = sniff_media(media_file)

    entry = request.db.MediaEntry()
    entry.media_type = unicode(media_type)
    entry.title = unicode(request.form.get("title") or splitext(media_file.filename)[0])

    entry.description = unicode(request.form.get("description"))
    entry.license = unicode(request.form.get("license", ""))

    entry.uploader = request.user.id

    entry.generate_slug()

    # queue appropriately
    queue_file = prepare_queue_task(request.app, entry, media_file.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()

    if request.form.get("callback_url"):
        metadata = request.db.ProcessingMetaData()
        metadata.media_entry = entry
        metadata.callback_url = unicode(request.form["callback_url"])
        metadata.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)

    return json_response(get_entry_serializable(entry, request.urlgen))
Beispiel #7
0
def pwg_images_addSimple(request):
    form = AddSimpleForm(request.form)
    if not form.validate():
        _log.error("addSimple: form failed")
        raise BadRequest()
    dump = []
    for f in form:
        dump.append("%s=%r" % (f.name, f.data))
    _log.info("addimple: %r %s %r", request.form, " ".join(dump), request.files)

    if not check_file_field(request, 'image'):
        raise BadRequest()

    return {'image_id': 123456, 'url': ''}
Beispiel #8
0
def pwg_images_addSimple(request):
    form = AddSimpleForm(request.form)
    if not form.validate():
        _log.error("addSimple: form failed")
        raise BadRequest()
    dump = []
    for f in form:
        dump.append("%s=%r" % (f.name, f.data))
    _log.info("addSimple: %r %s %r", request.form, " ".join(dump),
              request.files)

    if not check_file_field(request, 'image'):
        raise BadRequest()

    upload_limit, max_file_size = get_upload_file_limits(request.user)

    try:
        entry = submit_media(
            mg_app=request.app, user=request.user,
            submitted_file=request.files['image'],
            filename=request.files['image'].filename,
            title=six.text_type(form.name.data),
            description=six.text_type(form.comment.data),
            upload_limit=upload_limit, max_file_size=max_file_size)

        collection_id = form.category.data
        if collection_id > 0:
            collection = Collection.query.get(collection_id)
            if collection is not None and collection.actor == request.user.id:
                add_media_to_collection(collection, entry, "")

        return {
            'image_id': entry.id,
            'url': entry.url_for_self(
                request.urlgen,
                qualified=True)}

    # Handle upload limit issues
    except FileUploadLimit:
        raise BadRequest(
            _(u'Sorry, the file size is too big.'))
    except UserUploadLimit:
        raise BadRequest(
            _('Sorry, uploading this file will put you over your'
              ' upload limit.'))
    except UserPastUploadLimit:
        raise BadRequest(
            _('Sorry, you have reached your upload limit.'))
Beispiel #9
0
def post_entry(request):
    _log.debug('Posting entry')

    if request.method == 'OPTIONS':
        return json_response({'status': 200})

    if request.method != 'POST':
        _log.debug('Must POST against post_entry')
        raise BadRequest()

    if not check_file_field(request, 'file'):
        _log.debug('File field not found')
        raise BadRequest()

    callback_url = request.form.get('callback_url')
    if callback_url:
        callback_url = six.text_type(callback_url)
    try:
        entry = submit_media(
            mg_app=request.app, user=request.user,
            submitted_file=request.files['file'],
            filename=request.files['file'].filename,
            title=six.text_type(request.form.get('title')),
            description=six.text_type(request.form.get('description')),
            license=six.text_type(request.form.get('license', '')),
            tags_string=six.text_type(request.form.get('tags', '')),
            callback_url=callback_url)

        return json_response(get_entry_serializable(entry, request.urlgen))

    # Handle upload limit issues
    except FileUploadLimit:
        raise BadRequest(
            _(u'Sorry, the file size is too big.'))
    except UserUploadLimit:
        raise BadRequest(
            _('Sorry, uploading this file will put you over your'
              ' upload limit.'))
    except UserPastUploadLimit:
        raise BadRequest(
            _('Sorry, you have reached your upload limit.'))
    except FileTypeNotSupported as e:
        raise BadRequest(e)
Beispiel #10
0
def submit_start(request):
    """
    First view for submitting a file.
    """
    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=request.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:
                submit_media(
                    mg_app=request.app, user=request.user,
                    submitted_file=request.files['file'],
                    filename=request.files['file'].filename,
                    title=six.text_type(submit_form.title.data),
                    description=six.text_type(submit_form.description.data),
                    license=six.text_type(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)
            except FileTypeNotSupported as e:
                submit_form.file.errors.append(e)
            except Exception as e:
                raise

    return render_to_response(
        request,
        'mediagoblin/submit/start.html',
        {'submit_form': submit_form,
         'app_config': mg_globals.app_config})
Beispiel #11
0
def submit_start(request):
    """
    First view for submitting a file.
    """
    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=request.user.uploaded)
    users_collections = Collection.query.filter_by(
        actor=request.user.id,
        type=Collection.USER_DEFINED_TYPE
    ).order_by(Collection.title)

    # Only show the Collections dropdown if the user has some
    # collections set up
    if users_collections.count() > 0:
        submit_form.collection.query = users_collections
    else:
        del submit_form.collection

    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:
                media = submit_media(
                    mg_app=request.app, user=request.user,
                    submitted_file=request.files['file'],
                    filename=request.files['file'].filename,
                    title=six.text_type(submit_form.title.data),
                    description=six.text_type(submit_form.description.data),
                    license=six.text_type(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)

                if submit_form.collection and submit_form.collection.data:
                    add_media_to_collection(
                        submit_form.collection.data, media)
                    create_activity(
                        "add", media, request.user,
                        target=submit_form.collection.data)

                messages.add_message(
                    request,
                    messages.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)
            except FileTypeNotSupported as e:
                submit_form.file.errors.append(e)
            except Exception as e:
                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 = 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})
Beispiel #13
0
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})
Beispiel #14
0
def submit_start(request):
    """
    First view for submitting a file.
    """
    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=request.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:
                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)

            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})
Beispiel #16
0
def submit_start(request):
    """
    First view for submitting a file.
    """
    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=request.user.uploaded)
    users_collections = Collection.query.filter_by(
        actor=request.user.id,
        type=Collection.USER_DEFINED_TYPE
    ).order_by(Collection.title)

    # Only show the Collections dropdown if the user has some
    # collections set up
    if users_collections.count() > 0:
        submit_form.collection.query = users_collections
    else:
        del submit_form.collection

    if request.method == 'POST' and submit_form.validate():
        if not check_file_field(request, 'file'):
            submit_form.file.errors.append(
                _('You must provide a file.'))
        else:
            try:
                media = submit_media(
                    mg_app=request.app, user=request.user,
                    submitted_file=request.files['file'],
                    filename=request.files['file'].filename,
                    title=str(submit_form.title.data),
                    description=str(submit_form.description.data),
                    license=str(submit_form.license.data) or None,
                    tags_string=submit_form.tags.data,
                    urlgen=request.urlgen)

                if submit_form.collection and submit_form.collection.data:
                    add_media_to_collection(
                        submit_form.collection.data, media)
                    create_activity(
                        "add", media, request.user,
                        target=submit_form.collection.data)

                messages.add_message(
                    request,
                    messages.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(
                    _('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)
            except FileTypeNotSupported as e:
                submit_form.file.errors.append(e)
            except Exception as e:
                raise

    return render_to_response(
        request,
        'mediagoblin/submit/start.html',
        {'submit_form': submit_form,
         'app_config': mg_globals.app_config})
Beispiel #17
0
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})