def exercise_image_upload(request):
if request.method != 'POST':
return HttpResponseBadRequest(
"Only POST requests are allowed on this endpoint.")
fobj = request.FILES.values()[0]
assessment_item_id = request.POST.get('assessment_item_id', None)
name, ext = os.path.splitext(fobj._name)
get_hash(DjFile(fobj))
file_object = File(
preset_id=format_presets.EXERCISE_IMAGE,
file_on_disk=DjFile(request.FILES.values()[0]),
file_format_id=ext[1:].lower(),
assessment_item_id=assessment_item_id,
)
file_object.save()
return HttpResponse(
json.dumps({
"success":
True,
"formatted_filename":
exercises.CONTENT_STORAGE_FORMAT.format(str(file_object)),
"file_id":
file_object.pk,
"path":
generate_storage_url(str(file_object)),
}))
def file_upload(request):
if request.method == 'POST':
# Implement logic for switching out files without saving it yet
filename, ext = os.path.splitext(request.FILES.values()[0]._name)
size = request.FILES.values()[0]._size
contentfile = DjFile(request.FILES.values()[0])
checksum = get_hash(contentfile)
request.user.check_space(size, checksum)
file_object = File(
file_size=size,
file_on_disk=contentfile,
checksum=checksum,
file_format_id=ext[1:].lower(),
original_filename=request.FILES.values()[0]._name,
preset_id=request.META.get('HTTP_PRESET'),
language_id=request.META.get('HTTP_LANGUAGE'),
uploaded_by=request.user,
)
file_object.save()
return HttpResponse(
json.dumps({
"success":
True,
"filename":
str(file_object),
"file":
JSONRenderer().render(FileSerializer(file_object).data)
}))
def image_upload(request):
if request.method != 'POST':
return HttpResponseBadRequest(
"Only POST requests are allowed on this endpoint.")
fobj = request.FILES.values()[0]
name, ext = os.path.splitext(
fobj._name) # gets file extension without leading period
checksum = get_hash(DjFile(fobj))
request.user.check_space(fobj._size, checksum)
file_object = File(contentnode_id=request.META.get('HTTP_NODE'),
original_filename=name,
preset_id=request.META.get('HTTP_PRESET'),
file_on_disk=DjFile(request.FILES.values()[0]),
file_format_id=ext[1:].lower(),
uploaded_by=request.user)
file_object.save()
return HttpResponse(
json.dumps({
"success":
True,
"file":
JSONRenderer().render(FileSerializer(file_object).data),
"path":
generate_storage_url(str(file_object)),
}))
def file_upload(request):
if request.method != 'POST':
return HttpResponseBadRequest("Only POST requests are allowed on this endpoint.")
# Implement logic for switching out files without saving it yet
filename, ext = os.path.splitext(request.FILES.values()[0]._name)
size = request.FILES.values()[0]._size
contentfile = DjFile(request.FILES.values()[0])
checksum = get_hash(contentfile)
request.user.check_space(size, checksum)
file_object = File(
file_size=size,
file_on_disk=contentfile,
checksum=checksum,
file_format_id=ext[1:].lower(),
original_filename=request.FILES.values()[0]._name,
preset_id=request.META.get('HTTP_PRESET'),
language_id=request.META.get('HTTP_LANGUAGE'),
uploaded_by=request.user,
)
file_object.save()
return HttpResponse(json.dumps({
"success": True,
"filename": str(file_object),
"file": JSONRenderer().render(FileSerializer(file_object).data)
}))
def image_upload(request):
# Used for content nodes
if request.method != 'POST':
return HttpResponseBadRequest("Only POST requests are allowed on this endpoint.")
fobj = request.FILES.values()[0]
name, ext = os.path.splitext(fobj._name) # gets file extension without leading period
checksum = get_hash(DjFile(fobj))
request.user.check_space(fobj._size, checksum)
file_object = File(
contentnode_id=request.META.get('HTTP_NODE'),
original_filename=name,
preset_id=request.META.get('HTTP_PRESET'),
file_on_disk=DjFile(request.FILES.values()[0]),
file_format_id=ext[1:].lower(),
uploaded_by=request.user
)
file_object.save()
return HttpResponse(json.dumps({
"success": True,
"file": JSONRenderer().render(FileSerializer(file_object).data),
"path": generate_storage_url(str(file_object)),
"encoding": get_thumbnail_encoding(str(file_object)),
}))
def exercise_image_upload(request):
if request.method != 'POST':
return HttpResponseBadRequest("Only POST requests are allowed on this endpoint.")
fobj = request.FILES.values()[0]
assessment_item_id = request.POST.get('assessment_item_id', None)
name, ext = os.path.splitext(fobj._name)
get_hash(DjFile(fobj))
file_object = File(
preset_id=format_presets.EXERCISE_IMAGE,
file_on_disk=DjFile(request.FILES.values()[0]),
file_format_id=ext[1:].lower(),
assessment_item_id=assessment_item_id,
)
file_object.save()
return HttpResponse(json.dumps({
"success": True,
"formatted_filename": exercises.CONTENT_STORAGE_FORMAT.format(str(file_object)),
"file_id": file_object.pk,
"path": generate_storage_url(str(file_object)),
}))
def thumbnail_upload(request):
if request.method == 'POST':
fobj = request.FILES.values()[0]
checksum = get_hash(DjFile(fobj))
request.user.check_space(fobj._size, checksum)
formatted_filename = write_file_to_storage(fobj)
return HttpResponse(
json.dumps({
"success": True,
"formatted_filename": formatted_filename,
"file": None,
"path": generate_storage_url(formatted_filename),
}))
def thumbnail_upload(request):
# Used for channels
if request.method != 'POST':
return HttpResponseBadRequest("Only POST requests are allowed on this endpoint.")
fobj = request.FILES.values()[0]
checksum = get_hash(DjFile(fobj))
request.user.check_space(fobj._size, checksum)
formatted_filename = write_file_to_storage(fobj)
return HttpResponse(json.dumps({
"success": True,
"formatted_filename": formatted_filename,
"file": None,
"path": generate_storage_url(formatted_filename),
"encoding": get_thumbnail_encoding(formatted_filename),
}))
def thumbnail_upload(request):
# Used for channels
if request.method != 'POST':
return HttpResponseBadRequest("Only POST requests are allowed on this endpoint.")
fobj = request.FILES.values()[0]
checksum = get_hash(DjFile(fobj))
request.user.check_space(fobj._size, checksum)
formatted_filename = write_file_to_storage(fobj)
return HttpResponse(json.dumps({
"success": True,
"formatted_filename": formatted_filename,
"file": None,
"path": generate_storage_url(formatted_filename),
"encoding": get_thumbnail_encoding(formatted_filename),
}))
def exercise_image_upload(request):
if request.method == 'POST':
fobj = request.FILES.values()[0]
name, ext = os.path.splitext(fobj._name)
checksum = get_hash(DjFile(fobj))
file_object = File(
preset_id=format_presets.EXERCISE_IMAGE,
file_on_disk=DjFile(request.FILES.values()[0]),
file_format_id=ext[1:].lower(),
)
file_object.save()
return HttpResponse(
json.dumps({
"success":
True,
"formatted_filename":
exercises.CONTENT_STORAGE_FORMAT.format(str(file_object)),
"file_id":
file_object.pk,
"path":
generate_storage_url(str(file_object)),
}))
def file_create(request):
if request.method == 'POST':
original_filename, ext = os.path.splitext(
request.FILES.values()[0]._name)
size = request.FILES.values()[0]._size
contentfile = DjFile(request.FILES.values()[0])
checksum = get_hash(contentfile)
request.user.check_space(size, checksum)
presets = FormatPreset.objects.filter(
allowed_formats__extension__contains=ext[1:].lower())
kind = presets.first().kind
preferences = json.loads(request.META.get('HTTP_PREFERENCES'))
author = preferences.get('author') or ""
license = License.objects.filter(
license_name=preferences.get('license')).first(
) # Use filter/first in case preference hasn't been set
license_id = license.pk if license else None
new_node = ContentNode(
title=original_filename,
kind=kind,
license_id=license_id,
author=author,
copyright_holder=preferences.get('copyright_holder'),
)
if license and license.is_custom:
new_node.license_description = preferences.get(
'license_description')
new_node.save()
file_object = File(
file_on_disk=contentfile,
checksum=checksum,
file_format_id=ext[1:].lower(),
original_filename=request.FILES.values()[0]._name,
contentnode=new_node,
file_size=size,
uploaded_by=request.user,
)
file_object.save()
if kind.pk == content_kinds.VIDEO:
file_object.preset_id = guess_video_preset_by_resolution(
str(file_object.file_on_disk))
elif presets.filter(supplementary=False).count() == 1:
file_object.preset = presets.filter(supplementary=False).first()
file_object.save()
thumbnail = None
try:
if preferences.get('auto_derive_video_thumbnail') and new_node.kind_id == content_kinds.VIDEO \
or preferences.get('auto_derive_audio_thumbnail') and new_node.kind_id == content_kinds.AUDIO \
or preferences.get('auto_derive_html5_thumbnail') and new_node.kind_id == content_kinds.HTML5 \
or preferences.get('auto_derive_document_thumbnail') and new_node.kind_id == content_kinds.DOCUMENT:
thumbnail = generate_thumbnail_from_node(new_node,
set_node=True)
request.user.check_space(thumbnail.file_size,
thumbnail.checksum)
except Exception:
if thumbnail:
thumbnail.delete()
return HttpResponse(
json.dumps({
"success":
True,
"node":
JSONRenderer().render(
ContentNodeEditSerializer(new_node).data)
}))
def file_create(request):
if request.method != 'POST':
return HttpResponseBadRequest("Only POST requests are allowed on this endpoint.")
original_filename, ext = os.path.splitext(request.FILES.values()[0]._name)
size = request.FILES.values()[0]._size
contentfile = DjFile(request.FILES.values()[0])
checksum = get_hash(contentfile)
request.user.check_space(size, checksum)
presets = FormatPreset.objects.filter(allowed_formats__extension__contains=ext[1:].lower())
kind = presets.first().kind
preferences = json.loads(request.POST.get('content_defaults', None) or "{}")
license = License.objects.filter(license_name=preferences.get('license')).first() # Use filter/first in case preference hasn't been set
license_id = license.pk if license else None
new_node = ContentNode(
title=original_filename,
kind=kind,
license_id=license_id,
author=preferences.get('author') or "",
aggregator=preferences.get('aggregator') or "",
provider=preferences.get('provider') or "",
copyright_holder=preferences.get('copyright_holder'),
parent_id=settings.ORPHANAGE_ROOT_ID,
)
if license and license.is_custom:
new_node.license_description = preferences.get('license_description')
new_node.save()
file_object = File(
file_on_disk=contentfile,
checksum=checksum,
file_format_id=ext[1:].lower(),
original_filename=request.FILES.values()[0]._name,
contentnode=new_node,
file_size=size,
uploaded_by=request.user,
)
file_object.save()
if kind.pk == content_kinds.VIDEO:
file_object.preset_id = guess_video_preset_by_resolution(str(file_object.file_on_disk))
elif presets.filter(supplementary=False).count() == 1:
file_object.preset = presets.filter(supplementary=False).first()
file_object.save()
thumbnail = None
try:
if preferences.get('auto_derive_video_thumbnail') and new_node.kind_id == content_kinds.VIDEO \
or preferences.get('auto_derive_audio_thumbnail') and new_node.kind_id == content_kinds.AUDIO \
or preferences.get('auto_derive_html5_thumbnail') and new_node.kind_id == content_kinds.HTML5 \
or preferences.get('auto_derive_document_thumbnail') and new_node.kind_id == content_kinds.DOCUMENT:
thumbnail = generate_thumbnail_from_node(new_node, set_node=True)
request.user.check_space(thumbnail.file_size, thumbnail.checksum)
except Exception:
if thumbnail:
thumbnail.delete()
return HttpResponse(json.dumps({
"success": True,
"node": JSONRenderer().render(ContentNodeEditSerializer(new_node).data)
}))
def file_create(request):
if request.method != 'POST':
return HttpResponseBadRequest(
"Only POST requests are allowed on this endpoint.")
original_filename, ext = os.path.splitext(request.FILES.values()[0]._name)
size = request.FILES.values()[0]._size
contentfile = DjFile(request.FILES.values()[0])
checksum = get_hash(contentfile)
request.user.check_space(size, checksum)
presets = FormatPreset.objects.filter(
allowed_formats__extension__contains=ext[1:].lower())
kind = presets.first().kind
preferences = json.loads(
request.POST.get('content_defaults', None) or "{}")
license = License.objects.filter(
license_name=preferences.get('license')).first(
) # Use filter/first in case preference hasn't been set
license_id = license.pk if license else None
new_node = ContentNode(
title=original_filename,
kind=kind,
license_id=license_id,
author=preferences.get('author') or "",
aggregator=preferences.get('aggregator') or "",
provider=preferences.get('provider') or "",
copyright_holder=preferences.get('copyright_holder'),
parent_id=settings.ORPHANAGE_ROOT_ID,
)
if license and license.is_custom:
new_node.license_description = preferences.get('license_description')
# The orphanage is not an actual tree but just a long list of items.
with ContentNode.objects.disable_mptt_updates():
new_node.save()
file_object = File(
file_on_disk=contentfile,
checksum=checksum,
file_format_id=ext[1:].lower(),
original_filename=request.FILES.values()[0]._name,
contentnode=new_node,
file_size=size,
uploaded_by=request.user,
)
file_object.save()
if kind.pk == content_kinds.VIDEO:
file_object.preset_id = guess_video_preset_by_resolution(
str(file_object.file_on_disk))
elif presets.filter(supplementary=False).count() == 1:
file_object.preset = presets.filter(supplementary=False).first()
file_object.save()
thumbnail = None
try:
if preferences.get('auto_derive_video_thumbnail') and new_node.kind_id == content_kinds.VIDEO \
or preferences.get('auto_derive_audio_thumbnail') and new_node.kind_id == content_kinds.AUDIO \
or preferences.get('auto_derive_html5_thumbnail') and new_node.kind_id == content_kinds.HTML5 \
or preferences.get('auto_derive_document_thumbnail') and new_node.kind_id == content_kinds.DOCUMENT:
thumbnail = generate_thumbnail_from_node(new_node, set_node=True)
request.user.check_space(thumbnail.file_size, thumbnail.checksum)
except Exception:
if thumbnail:
thumbnail.delete()
return HttpResponse(
json.dumps({
"success":
True,
"node":
JSONRenderer().render(ContentNodeEditSerializer(new_node).data)
}))
def subtitle_upload(request):
# File will be converted to VTT format
ext = file_formats.VTT
language_id = request.META.get('HTTP_LANGUAGE')
content_file = request.FILES.values()[0]
with NamedTemporaryFile() as temp_file:
try:
converter = build_subtitle_converter(
unicode(content_file.read(), 'utf-8'))
convert_language_code = language_id
# We're making the assumption here that language the user selected is truly the caption
# file's language if it's unknown
if len(converter.get_language_codes()) == 1 \
and converter.has_language(LANGUAGE_CODE_UNKNOWN):
converter.replace_unknown_language(language_id)
# determine if the request language exists by another code, otherwise we can't continue
if not converter.has_language(convert_language_code):
for language_code in converter.get_language_codes():
language = getlang_by_alpha2(language_code)
if language and language.code == language_id:
convert_language_code = language_code
break
else:
return HttpResponseBadRequest(
"Language '{}' not present in subtitle file".format(
language_id))
converter.write(temp_file.name, convert_language_code)
except InvalidSubtitleFormatError as ex:
return HttpResponseBadRequest(
"Subtitle conversion failed: {}".format(ex))
temp_file.seek(0)
converted_file = DjFile(temp_file)
checksum = get_hash(converted_file)
size = converted_file.size
request.user.check_space(size, checksum)
file_object = File(
file_size=size,
file_on_disk=converted_file,
checksum=checksum,
file_format_id=ext,
original_filename=request.FILES.values()[0]._name,
preset_id=request.META.get('HTTP_PRESET'),
language_id=language_id,
uploaded_by=request.user,
)
file_object.save()
return HttpResponse(
json.dumps({
"success":
True,
"filename":
str(file_object),
"file":
JSONRenderer().render(FileSerializer(file_object).data)
}))
