def test_file_delete(self):
self.newfile.contentnode = self.video
self.put("/api/file",
FileSerializer([self.video_file, self.newfile],
many=True).data) # Add the file
self.put("/api/file",
FileSerializer([self.newfile],
many=True).data) # Now delete the file
self.video.refresh_from_db()
self.assertTrue(self.video.files.filter(pk=self.newfile.pk).exists())
self.assertFalse(
self.video.files.filter(pk=self.video_file.pk).exists())
self.assertFalse(File.objects.filter(pk=self.video_file.pk).exists())
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 generate_thumbnail(request):
logging.debug("Entering the generate_thumbnail endpoint")
if request.method != 'POST':
return HttpResponseBadRequest(
"Only POST requests are allowed on this endpoint.")
else:
data = json.loads(request.body)
node = ContentNode.objects.get(pk=data["node_id"])
thumbnail_object = generate_thumbnail_from_node(node)
try:
request.user.check_space(thumbnail_object.file_size,
thumbnail_object.checksum)
except Exception as e:
if thumbnail_object:
thumbnail_object.delete()
raise e
return HttpResponse(
json.dumps({
"success":
True,
"file":
JSONRenderer().render(FileSerializer(thumbnail_object).data),
"path":
generate_storage_url(str(thumbnail_object)),
}))
def test_file_update(self):
self.video_file.contentnode = self.testnode
response = self.put("/api/file",
FileSerializer([self.video_file], many=True).data)
self.assertEqual(response.status_code, 200)
self.video_file.refresh_from_db()
self.assertEqual(self.video_file.contentnode.pk, self.testnode.pk)
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 image_upload(request):
if request.method == 'POST':
name, ext = os.path.splitext(request.FILES.values()[0]._name) # gets file extension without leading period
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:])
file_object.save()
return HttpResponse(json.dumps({
"success": True,
"file": JSONRenderer().render(FileSerializer(file_object).data),
"path": generate_storage_url(str(file_object)),
}))
def test_file_add(self):
self.newfile.preset_id = 'low_res_video'
self.newfile.save()
self.newfile.contentnode = self.video
self.put(
"/api/file",
FileSerializer([self.video_file, self.newfile], many=True).data)
self.video.refresh_from_db()
self.assertTrue(self.video.files.filter(pk=self.newfile.pk).exists())
self.assertTrue(
self.video.files.filter(pk=self.video_file.pk).exists())
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)
}))
