def upload(request):
"""JFU function to handle uplaods
The assumption here is that jQuery File Upload
has been configured to send files one at a time.
If multiple files can be uploaded simulatenously,
'file' may be a list of files.
"""
my_file = upload_receive(request)
#instance = YourUploadModel( file_field = file )
basename = my_file.name
tfile = tempfile.NamedTemporaryFile("w", delete=False)
tfile.write(my_file.read())
arg_list[basename] = tfile.name
#basename = os.path.basename( instance.file_field.file.name )
file_dict = {
'name': basename,
'size': my_file.size,
#instance.file_field.file.size,
# The assumption is that file_field is a FileField that saves to
# the 'media' directory.
'url': settings.MEDIA_URL + basename,
'thumbnail_url': settings.MEDIA_URL + basename,
'delete_type': 'POST',
}
return UploadResponse(request, file_dict)
def upload( request ):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' will be a list of files.
file = upload_receive( request )
print('instance.file_field.file.name is [%s]', file.name)
instance = Photo( file = file )
instance.save()
LOG.debug('instance.file_field.file.name is [%s]', settings.MEDIA_URL +instance.file.name)
file_dict = {
'name' : instance.file.name,
'size' : instance.file.size,
# The assumption is that file_field is a FileField that saves to
# the 'media' directory.
'url': '../' + instance.file.name,
'thumbnail_url': '../' +instance.file.name,
'delete_url': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'delete_type': 'POST',
}
return UploadResponse( request, file_dict )
def upload(request, book_id, type_to_handle):
book = get_object_or_404(core_models.Book, pk=book_id, owner=request.user)
_file = upload_receive(request)
new_file = handle_file(_file, book, type_to_handle, request.user)
if new_file:
file_dict = {
'name':
new_file.uuid_filename,
'size':
_file.size,
'deleteUrl':
reverse('jfu_delete',
kwargs={
'book_id': book_id,
'file_pk': new_file.pk
}),
'url':
reverse('serve_file',
kwargs={
'submission_id': book_id,
'file_id': new_file.pk
}),
'deleteType':
'POST',
'ruaId':
new_file.pk,
'original_name':
new_file.original_filename,
}
return UploadResponse(request, file_dict)
return HttpResponse('No file')
def uploadVerify( request ):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
print("request.user")
file = upload_receive( request )
# return
# feedbackObj = feedback.objects.create(userId = request.user)
# feedbackObj.save()
# print(feedbackObj)
instance = agent_files( fileUpload = file , userId = request.user)
instance.save()
basename = os.path.basename( instance.fileUpload.path )
file_dict = {
'name' : basename,
'size' : file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
# 'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
# 'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def uploadVerify(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
print("request.user")
file = upload_receive(request)
# return
# feedbackObj = feedback.objects.create(userId = request.user)
# feedbackObj.save()
# print(feedbackObj)
instance = agent_files(fileUpload=file, userId=request.user)
instance.save()
basename = os.path.basename(instance.fileUpload.path)
file_dict = {
'name': basename,
'size': file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
# 'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
# 'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
file = upload_receive(request)
tmp_file = open(file.name, 'wb+')
for chunk in file.chunks():
tmp_file.write(chunk)
tmp_file.close()
photo = flickr_api.upload(photo_file=tmp_file.name, title=tmp_file.name, is_public=0)
basename = os.path.basename(tmp_file.name)
sizes = photo.getSizes()
file_dict = {
'name': basename,
'size': file.size,
'url': sizes['Original']['source'],
'thumbnailUrl': sizes['Thumbnail']['source'],
'deleteUrl': reverse('upload:upload_delete', kwargs={'pk': photo.id}),
'deleteType': 'POST',
}
os.unlink(tmp_file.name)
return UploadResponse(request, file_dict)
def upload(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
file = upload_receive(request)
instance = PromotionAudioItem(file_field=file)
instance.save()
basename = os.path.basename(instance.file_field.file.name)
file_dict = {
'name': basename,
'size': instance.file_field.file.size,
# The assumption is that file_field is a FileField that saves to
# the 'media' directory.
'url': settings.MEDIA_URL + basename,
'thumbnail_url': settings.MEDIA_URL + basename,
'delete_url': reverse('audio_delete', kwargs={'pk': instance.pk}),
'delete_type': 'POST',
}
return UploadResponse(request, file_dict)
def upload( request ):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
file = upload_receive( request )
folder = request.POST['folder']
instance = File( folder = folder, file = file )
instance.save()
basename = os.path.basename( instance.file.path )
basename_path = os.path.join(MEDIA_URL, folder, basename)
file_dict = {
'name' : basename,
'size' : file.size,
'url': basename_path,
'thumbnailUrl': basename_path,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def upload_author(request, assignment_type, assignment_id, type_to_handle):
assignment = logic.get_assignment(assignment_type, assignment_id)
book = assignment.book
_file = upload_receive(request)
new_file = handle_file(_file, book, type_to_handle, request.user)
if new_file:
file_dict = {
'name': new_file.uuid_filename,
'size': _file.size,
'deleteUrl': reverse(
'assignment_jfu_delete',
kwargs={
'assignment_type': assignment_type,
'assignment_id': assignment_id,
'file_pk': new_file.pk,
}
),
'url': reverse(
'serve_file',
kwargs={'submission_id': book.id, 'file_id': new_file.pk}
),
'deleteType': 'POST',
'ruaId': new_file.pk,
'original_name': new_file.original_filename,
}
_assignment = logic.add_file(assignment, new_file, True)
return UploadResponse(request, file_dict)
return HttpResponse('No file')
def jfu_upload(request):
event = get_object_or_404(Event, id=request.session['event_id'])
profile = get_object_or_404(Profile, id=request.session['profile_id'])
uploaded_file = upload_receive(request)
instance = Photo(
photo=uploaded_file,
event=event,
profile=profile,
)
instance.save()
basename = os.path.basename(instance.photo.path)
file_dict = {
'name': basename,
'size': uploaded_file.size,
'url': instance.photo.url,
'thumbnailUrl': instance.get_thumbnail().url,
#'deleteUrl': reverse('jfu_delete', kwargs={'pk': instance.pk}),
#'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def jfu_upload(request):
key = request.GET.get('key')
file = upload_receive(request)
instance = AdPhoto(file=file)
instance.save()
basename = os.path.basename(instance.file.path)
file_dict = {
'name': basename,
'size': file.size,
'url': '%s/%s' % (settings.MEDIA_URL, instance.file,),
'thumbnailUrl': '%s/%s' % (settings.MEDIA_URL, instance.file,),
'deleteUrl': reverse('pca_jfu_delete', kwargs={'pk': instance.pk}) + '?key=' + key,
'deleteType': 'POST',
}
# Can't do it in one line !
file_list = request.session['pca_files_%s' % (key,)]
file_list.append(instance.pk)
request.session['pca_files_%s' % (key,)] = file_list
return UploadResponse(request, file_dict)
def upload( request ):
type = request.POST.get('type')
id = request.POST.get('id')
file = upload_receive( request )
this_news = News.objects.get(id=id)
if type == 'pic':
instance = NewsPic(
pic = file,
news = this_news
)
instance.save()
basename = os.path.basename( instance.pic.path )
elif type == 'mp3':
this_news.mp3 = file
this_news.save()
instance = this_news
basename = os.path.basename( instance.mp3.path )
else:
pass
file_dict = {
'name' : basename,
'size' : file.size,
'url': settings.MEDIA_URL + 'news_pic/'+ basename,
'thumbnailUrl': settings.MEDIA_URL + 'news_pic/'+ basename,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def upload(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
imagen = upload_receive(request)
usertests = UserTests.objects.get(user_id=request.user.id)
instance = Image(image=imagen, uploader=usertests)
instance.save()
basename = os.path.basename(instance.image.path)
namepath = "media/" + basename
file_dict = {
'name': basename,
'size': imagen.size,
'id': instance.pk,
'url': settings.MEDIA_URL + namepath,
'thumbnailUrl': "/" + settings.MEDIA_URL + namepath,
'deleteUrl': reverse('testsforall:jfu_delete',
kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload_photo(request, pid=None):
file = upload_receive( request )
# Save photo
photo = Photo(image = file)
photo.save()
# Attach photo id to the temporary pin
tPin = tempPin.objects.get(id=pid)
list_of_photos = json.loads(tPin.photos)
list_of_photos.append(photo.id)
tPin.photos = json.dumps(list_of_photos)
tPin.save()
basename = os.path.basename( photo.image.url )
newURL = os.path.join(settings.MEDIA_URL, "album", basename)
# TODO: fix 'deleteUrl' [currently save images to webapps/trippins/media/profile-image/]
try:
file_dict = {
'name': basename,
'size': file.size,
'url': newURL,
'thumbnailUrl': newURL,
'photoid': photo.id,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': photo.id, 'pid':pid }),
'deleteType': 'POST',
}
except Exception as error:
print error
return UploadResponse( request, file_dict )
def upload( request ):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
file = upload_receive( request )
autoescuela = Autoescuela.objects.get( pk = request.POST.get('fk') )
instance = Foto( nombre = "la foto", foto = file, autoescuela = autoescuela )
instance.save()
basename = os.path.basename( instance.foto.path )
file_dict = {
'name' : basename,
'size' : file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def upload(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
file = upload_receive(request)
image_buffer = magic.from_buffer(file.read(), mime=True)
if 'image' not in image_buffer or file.size > 1024*1024*1.5:
raise ValidationError()
instance = BlogImage(image=file, user=request.user)
instance.status = 2
instance.save()
basename = instance.image.name
file_dict = {
'name': basename,
'size': file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request, study_group_id=None, post_id=None):
f = upload_receive(request)
instance = File(file_field=f)
instance.save()
post = Post.objects.get(id=post_id)
instance.post = post
instance.uploader = get_student_from_user(request.user)
instance.save()
basename = os.path.basename(instance.file_field.path)
file_dict = {
'name' : basename,
'size' : f.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs = { 'study_group_id': study_group_id, 'pk': instance.pk, 'post_id': post_id }),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
task_id = request.POST.get('task_id', None)
task = Task.objects.get(pk=int(task_id))
if ACL.canUpdateTask(request.user, task):
if task.hasPermissions(request.user):
file_dict = {'task_id': task_id}
if task_id!=None:
file = upload_receive( request )
task = Task.objects.get(pk=int(task_id))
instance = TaskAttachment( task_attachment_file = file, task=task )
instance.save()
basename = os.path.basename( instance.task_attachment_file.path )
file_dict = {
'name' : basename,
'size' : instance.task_attachment_file.size,
'url': settings.MEDIA_URL + str(instance.task_attachment_file),
'thumbnailUrl': '/static/file_thumb.png',
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
else:
file_dict = {}
else:
raise Exception('Permission denied')
return UploadResponse( request, file_dict )
def upload(request):
file = upload_receive( request )
container = request.session.get('container')
prefix = request.session.get('prefix')
instance = Photo(file = file)
if prefix:
instance.path = os.path.join(container,prefix)
else:
instance.path = os.path.join(container)
instance.save()
basename = os.path.basename( instance.file.path )
file_dict = {
'name' : basename,
'size' : file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def upload(request):
"""JFU function to handle uplaods
The assumption here is that jQuery File Upload
has been configured to send files one at a time.
If multiple files can be uploaded simulatenously,
'file' may be a list of files.
"""
my_file = upload_receive(request)
#instance = YourUploadModel( file_field = file )
basename = my_file.name
tfile = tempfile.NamedTemporaryFile("w", delete=False)
tfile.write(my_file.read())
arg_list[basename] = tfile.name
#basename = os.path.basename( instance.file_field.file.name )
file_dict = {
'name': basename,
'size': my_file.size,
#instance.file_field.file.size,
# The assumption is that file_field is a FileField that saves to
# the 'media' directory.
'url': settings.MEDIA_URL + basename,
'thumbnail_url': settings.MEDIA_URL + basename,
'delete_type': 'POST',
}
return UploadResponse(request, file_dict)
def jfu_upload(request):
event = get_object_or_404(Event, id=request.session['event_id'])
profile = get_object_or_404(Profile, id=request.session['profile_id'])
uploaded_file = upload_receive(request)
instance = Photo(
photo=uploaded_file,
event=event,
profile=profile,
)
instance.save()
basename = os.path.basename(instance.photo.path)
file_dict = {
'name': basename,
'size': uploaded_file.size,
'url': instance.photo.url,
'thumbnailUrl': instance.get_thumbnail().url,
#'deleteUrl': reverse('jfu_delete', kwargs={'pk': instance.pk}),
#'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload_files(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
if not request.user.is_authenticated():
Uploadresponse(request, {})
message_id = request.POST.get('message', '-1')
message = get_element(Message, int(message_id))
if message == False:
return UploadResponse(request, {})
file = upload_receive(request)
instance = File(file=file, name=file.name, message=message)
instance.save()
basename = os.path.basename(instance.file.path)
file_dict = {
'name': basename,
'size': file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'delete_url': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'delete_type': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
uploadedfile = upload_receive(request)
if not uploadedfile == None:
if 'encryptKey' in request.POST:
encryptionKey = request.POST['encryptKey']
fileName = uploadedfile.name
file_dict = {
'name' : fileName,
'size' : uploadedfile.size
# The assumption is that file_field is a FileField that saves to
# the 'media' directory.
# 'url': inputDir + '/' + basename,
# 'thumbnailUrl': inputDir + '/' + basename,
}
if (uploadedFile.objects.filter(name=fileName).count() > 0):
file_dict['error'] = 'Failed to upload file! (file with same name already exists)'
else:
save_file(uploadedfile)
fileHash = hashlib.md5(open(os.path.join(inputDir,fileName),'rb').read()).hexdigest()
if (uploadedFile.objects.filter(hash=fileHash).count() > 0):
file_dict['error'] = 'Failed to upload file! (file with same name already exists)'
os.remove(os.path.join(inputDir, fileName))
elif(uploadedfile.size == 0):
file_dict['error'] = 'Failed to upload file! (file does not have any content)'
else:
uid = fileHash[:8] + str(request.user.pk)
os.rename(os.path.join(inputDir,fileName), os.path.join(inputDir,uid))
instance = uploadedFile()
instance.uid = uid
instance.hash = fileHash
instance.key = encryptionKey
instance.filesize = uploadedfile.size
instance.name = fileName
instance.ownerInfo = request.user.first_name + " " + request.user.last_name
instance.uploadDT = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
instance.save()
request.user.owns.add(instance)
request.user.uploaded_fileSize = str(int(request.user.uploaded_fileSize) + int(uploadedfile.size))
request.user.save()
file_dict['deleteUrl'] = reverse('jfu_delete', kwargs = { 'pk': instance.uid })
file_dict['deleteType'] = 'POST'
# os.system("mpiexec.openmpi -np 3 -machinefile /home/pi/machine python -c \"execfile('/home/pi/onDemandEncrypt/src/file/encryption.py');encrypt('%s','%s','$s',$d)")%(os.path.join(inputDir,uid), inputDir + "/encrypted/" + uid,encryptionKey,32)
encrypt(os.path.join(inputDir,uid), inputDir + "/encrypted/" + uid,encryptionKey,32)
else:
file_dict = {
'error':'Missing encryption key!'
}
return UploadResponse(request, file_dict)
else:
return HttpResponseRedirect(reverse('login'))
def upload(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
file = upload_receive(request)
instance = Track(flac=file, user=request.user)
instance.save()
basename = os.path.basename(instance.flac.file.name)
filename = "%s%s%s" % (settings.MEDIA_ROOT, 'mp3/', basename)
mp3_filename = "%s%s" % (filename, '.mp3')
# os.chdir("%s%s" % (settings.MEDIA_ROOT, 'mp3/'))
resp = os.system('track2track -V quiet -t mp3 -o "%s" "%s"' % (mp3_filename, instance.flac.path))
# subprocess.call(['track2track -V quiet -t mp3 -o "%s" "%s"' % (mp3_filename, instance.flac.path)])
instance.mp3 = "mp3/%s" % os.path.basename(mp3_filename)
# f = open(filename, 'r')
# djangofile = File(f)
# instance.mp3.save('filename.txt', djangofile)
# f.close()
instance.save()
us = UserSocialAuth.objects.get(user=request.user)
token = us.extra_data.get("access_token")
vk = vkontakte.API(token=token)
server = vk.audio.getUploadServer()
url = server.get("upload_url")
files = {'file' : open(instance.mp3.path, 'rb')}
r = requests.post(url, files=files)
_json = json.loads(r.text)
vk.audio.save(server=_json.get('server'), hash=_json.get('hash'), audio=_json.get('audio'))
file_dict = {
'name': basename,
'size': instance.flac.file.size,
# The assumption is that file_field is a FileField that saves to
# the 'media' directory.
'url': settings.MEDIA_URL + 'flac/' + basename,
'thumbnail_url': settings.MEDIA_URL + 'flac/' + basename,
'delete_url': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'delete_type': 'POST',
'r' : r.text
}
return UploadResponse(request, file_dict)
def image_upload(request, goods_id):
file = upload_receive(request)
instance = Photo(file=file)
instance.file.save(instance.file.name, file)
g = get_object_or_404(Goods, pk=int(goods_id))
g.add_image(instance)
file_dict = {
'name': os.path.basename(instance.file.path),
'size': file.size,
'url': '/media/%s' % instance.file.name,
'thumbnailUrl': '/media/%s' % instance.thumbnail.name,
'deleteUrl': str.format('/image/{0}/delete', instance.pk),
'deleteType': 'POST'
}
return UploadResponse(request, file_dict)
def upload(request):
file = upload_receive(request)
instance = Photo(file=file)
instance.save()
basename = os.path.basename(instance.file.file.name)
file_dict = {
'name': basename,
'size': instance.file.file.size,
'url': settings.MEDIA_URL + basename,
'thumbnail_url': settings.MEDIA_URL + basename,
'delete_url': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'delete_type': 'POST',
}
return UploadResponse(request, file_dict)
def upload( request ):
file = upload_receive( request )
instance = Photo( file = file )
instance.save()
basename = os.path.basename( instance.file.file.name )
file_dict = {
'name' : basename,
'size' : instance.file.file.size,
'url': settings.MEDIA_URL + basename,
'thumbnail_url': settings.MEDIA_URL + basename,
'delete_url': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'delete_type': 'POST',
}
return UploadResponse( request, file_dict )
def upload( request ):
try:
username = request.session['DukUser']
user = DukUser.objects.get(username = username)
ui = user.usermovie_set.all()[0]
except:
user = None
url = request.get_full_path()
code = url.split('?')[1]
m = Movie.objects.get(code = code)
f = upload_receive(request)
f.name = code+"_"+f.name
v = Video(file_field = f)
if user:
v.uploader = user
v.movie = m
v.save()
path, ext = os.path.splitext(v.file_field.name)
path = "media/" + path
#subprocess.call( ["ffmpeg", "-i" , path + ext, path + ".webm"])
basename = os.path.basename( v.file_field.file.name )
file_dict = {
'name' : basename,
'size' : v.file_field.file.size,
# The assumption is that file_field is a FileField that saves to
# the 'media' directory.
'url': settings.MEDIA_URL + basename,
'thumbnail_url': settings.MEDIA_URL + basename,
'delete_url': reverse('jfu_delete', kwargs = { 'pk': v.pk }),
'delete_type': 'POST',
}
return UploadResponse( request, file_dict )
def upload_author(request, assignment_type, assignment_id, type_to_handle):
assignment = logic.get_assignment(assignment_type, assignment_id)
book = assignment.book
file = upload_receive(request)
new_file = handle_file(file, book, type_to_handle, request.user)
if new_file:
file_dict = {
'name' : new_file.uuid_filename,
'size' : file.size,
'deleteUrl': reverse('assignment_jfu_delete', kwargs = { 'assignment_type':assignment_type,'assignment_id':assignment_id, 'file_pk': new_file.pk }),
'url': reverse('serve_file', kwargs = {'submission_id': book.id, 'file_id': new_file.pk }),
'deleteType': 'POST',
'ruaId': new_file.pk,
'original_name': new_file.original_filename,
}
assignment = logic.add_file(assignment, new_file, True)
return UploadResponse( request, file_dict )
return HttpResponse('No file')
def upload( request ):
video = upload_receive( request )
instance = Video( video = video )
instance.save()
basename = os.path.basename( instance.video.path )
file_dict = {
'name' : basename,
'size' : video.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def upload(request, book_id, type_to_handle):
book = get_object_or_404(core_models.Book, pk=book_id, owner=request.user)
file = upload_receive(request)
new_file = handle_file(file, book, type_to_handle, request.user)
if new_file:
file_dict = {
'name' : new_file.uuid_filename,
'size' : file.size,
'deleteUrl': reverse('jfu_delete', kwargs = { 'book_id': book_id, 'file_pk': new_file.pk }),
'url': reverse('serve_file', kwargs = {'submission_id': book_id, 'file_id': new_file.pk }),
'deleteType': 'POST',
'ruaId': new_file.pk,
}
return UploadResponse( request, file_dict )
return HttpResponse('No file')
def upload(request):
file = upload_receive(request)
#para doctores multiples se tiene que cambiar la consulta de atenciones
instance = ArchivosAdjuntos(file=file,
atenciones=Atenciones.objects.last())
instance.save()
basename = os.path.basename(instance.file.path)
file_dict = {
'name': basename,
'size': file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
file = upload_receive(request)
instance = Dump(file=file,
name=file.name,
timestamp=datetime.datetime.now())
instance.save()
basename = os.path.basename(instance.file.path)
file_dict = {
'name': basename,
'size': file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
file = upload_receive(request)
instance = Dump(file=file, name=file.name, timestamp=datetime.datetime.now())
instance.save()
basename = os.path.basename(instance.file.path)
file_dict = {
'name': basename,
'size': file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
image = upload_receive(request)
size = image.size
model = Image(image=image, resized_image=image)
basename = os.path.basename(model.image.path)
model.original_name = os.path.basename(model.image.path)
model.size = Image.human_size(size)
model.save()
file_dict = {
'name': basename,
'size': size,
'url': MEDIA_URL + str(model.image),
'thumbnailUrl': MEDIA_URL + str(model.resized_image),
'deleteUrl': reverse('images:upload_delete', kwargs={'pk': model.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
file = upload_receive(request)
pet = PetProfile.objects.get(id=int(request.GET.get('pet_id')))
instance = Photo(image=file, pet=pet)
instance.save()
basename = os.path.basename( instance.image.path )
file_dict = {
'name' : basename,
'size' : file.size,
'photo_id': instance.id,
'url': settings.MEDIA_URL + 'photo/' + basename,
'thumbnailUrl': instance.thumbnail.url,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def upload( request ):
file = upload_receive( request )
pk = request.POST['id']
instance = Photo( file = file, file_name = file.name, profile_id = pk)
instance.save()
basename = os.path.basename( instance.file.path )
file_dict = {
'name' : basename,
'size' : file.size,
'url': settings.MEDIA_URL + basename,
'thumbnailUrl': settings.MEDIA_URL + basename,
'deleteUrl': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'deleteType': 'POST',
}
return UploadResponse( request, file_dict )
def upload(request):
file = upload_receive(request)
album = Album.objects.get(id=int(request.POST['object_id']))
ext = os.path.splitext(file.name)[1].lower()
if ext in (".png", ".gif", ".jpg", ".jpeg"):
instance = Image(file=file, album=album)
elif ext in (".mp3"):
instance = GenericFile(file=file, album=album)
instance.type = BaseMedia.AUDIO
elif ext in (".mp4"):
instance = GenericFile(file=file, album=album)
instance.type = BaseMedia.VIDEO
else:
instance = GenericFile(file=file, album=album)
instance.type = BaseMedia.OTHER
try:
instance.full_clean()
instance.save()
except ValidationError as exn:
try:
error = ' '.join('%s: %s' % (k, v)
for k, vs in exn.message_dict.items() for v in vs)
except AttributeError:
error = ' '.join(exn.messages)
jfu_msg = {
'name': file.name,
'size': file.size,
'error': error,
}
return UploadResponse(request, jfu_msg)
jfu_msg = {
'name': os.path.basename(instance.file.path),
'size': file.size,
'url': instance.file.url,
}
return UploadResponse(request, jfu_msg)
def upload(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
image = upload_receive(request)
content_type = ContentType.objects.get(model=request.POST["content_type"])
object_id = request.POST["object_id"]
instance = Image(image=image, content_type=content_type, object_id=object_id)
instance.save()
basename = os.path.basename(instance.image.path)
file_dict = {
"name": basename,
"size": image.size,
"url": instance.image.url,
"deleteUrl": reverse("jfu_delete", kwargs={"pk": instance.pk}),
"deleteType": "POST",
}
return UploadResponse(request, file_dict)
def upload(request, listing):
if Photo.objects.filter(listing=listing).count() >= MAX_PHOTOS:
return UploadResponse(request, {'error': 'Max number of photos reached.'})
image = upload_receive(request)
description = request.POST.get("description[]") or image.name
if not image.name.endswith(ACCEPTED_IMAGE_TYPES):
return UploadResponse(request, {'error': 'Filetype not supported.'})
instance = Photo(image=image, listing=listing, description=description)
instance.save()
file_dict = {
'name': image.name,
'description': description,
'url': instance.image.url,
'thumbnailUrl': instance.image_s.url,
'deleteUrl': reverse('listings:jfu_delete', kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
path = request.POST.get('path', '/')
files = upload_receive(request)
if not isinstance(files, list): files = [files]
data = files[0]
filename = os.path.join(path, str(data))
storage = AVAILABLE_STORAGES.get(request.user)
storage.put_file_contents(filename, data)
fileinfo = storage.file_info(filename)
file_dict = {
'name': fileinfo.filename,
'size': sizeof_fmt(fileinfo.size),
'thumbnail_url': fileinfo.small_thumb,
'url': fileinfo.open_link,
'delete':
'', #'delete_url': reverse('jfu_delete', kwargs = {'filename': str(data) }),
'delete_type': 'POST',
}
return UploadResponse(request, file_dict)
def jfu_upload(request):
key = request.GET.get('key')
file = upload_receive(request)
instance = AdPhoto(file=file)
instance.save()
basename = os.path.basename(instance.file.path)
file_dict = {
'name':
basename,
'size':
file.size,
'url':
'%s/%s' % (
settings.MEDIA_URL,
instance.file,
),
'thumbnailUrl':
'%s/%s' % (
settings.MEDIA_URL,
instance.file,
),
'deleteUrl':
reverse('pca_jfu_delete', kwargs={'pk': instance.pk}) + '?key=' + key,
'deleteType':
'POST',
}
# Can't do it in one line !
file_list = request.session['pca_files_%s' % (key, )]
file_list.append(instance.pk)
request.session['pca_files_%s' % (key, )] = file_list
return UploadResponse(request, file_dict)
def upload(request):
f = Doc_upload_form(request.POST)
folder_pk = request.POST['folder_pk']
file = upload_receive(request)
new_Doc = f.save(commit=False)
new_Doc.date = file
new_Doc.tag_doc = Tag_docs.objects.get(id=folder_pk)
new_Doc.save()
file_dict = {
'name': new_Doc.name,
'size': file.size,
'url': new_Doc.date.url,
'thumbnailUrl': new_Doc.date.url,
'deleteUrl': reverse('jfu_delete', kwargs={'pk': new_Doc.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
image = upload_receive(request)
content_type = ContentType.objects.get(model=request.POST['content_type'])
object_id = request.POST['object_id']
instance = Image(image=image, content_type=content_type, object_id=object_id)
instance.save()
basename = os.path.basename(instance.image.path)
file_dict = {
'name' : basename,
'size' : image.size,
'url': instance.image.url,
'deleteUrl': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
return UploadResponse(request, file_dict)
def upload_image(request):
"""
Image uploading through jQuery using JFU module.
If multiple files can be uploaded simultanuasly,
'file' may be list of files.
"""
file_dict = {}
file = upload_receive(request)
user = User.objects.get(username=request.user.username)
try:
file_obj = File(file, name=file)
image = F_Image.objects.create(owner=user,
original_filename=file, file=file_obj)
instance = Image(file=image, user=user)
instance.save()
thumb = instance.get_file_thumbnail()
print('Thumb', thumb)
file_dict = {
'name': '%s' % instance.file.label,
'size': file.size,
'id': instance.id,
'url': instance.file.url,
'thumbnailUrl': thumb.url,
'deleteUrl': reverse('image_delete', kwargs={'pk': instance.pk}),
'deleteType': 'POST',
}
except instance.DoesNotExist or image.DoesNotExist:
print("Couldn't save Image")
return UploadResponse(request, file_dict)
def multiple_document_upload(request):
"""
Handles the mutiple document upload feature
:param request: WSGI Request
:return:
"""
if request.method == 'POST':
file = upload_receive(request)
name = str(file)
try:
m = DOCUMENT_NAMING_PATTERN.match(name)
if not m:
raise FormatError(
f"File name does not match convention. e.g NE_G0123X_1_DMP.docx"
)
grant_ref = m.group('grant_ref').replace('_', '/')
file_type = m.group('doc_type').lower()
if file_type != 'dmp':
file_type = 'support'
document = Document(upload=file)
document.grant = Grant.objects.get(grant_ref=grant_ref)
document.type = file_type
document.save()
except ValidationError:
response = HttpResponse(status=400)
response.reason_phrase = 'File already uploaded'
except FormatError as exc:
response = HttpResponse(status=400)
response.reason_phrase = f'{exc}'
except ObjectDoesNotExist:
response = HttpResponse(status=404)
response.reason_phrase = f'Grant ref: {grant_ref} not found'
else:
file_dict = {
'name': file.name,
'size': file.size,
'url': document.upload.url,
'deleteUrl': reverse('delete_file', kwargs={'pk':
document.pk}),
'deleteType': 'POST',
}
response = UploadResponse(request, file_dict)
return response
else:
form = datamad_forms.MultipleDocumentUploadForm()
return render(request, 'datamad2/multiple_document_upload.html', {
'form': form,
'JQ_OPEN': '{%',
'JQ_CLOSE': '%}'
})
def upload(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
issue = get_object_or_404(Issue, id=int(request.POST['issue_id']))
if 'update_issue' in request.POST:
event_value = {'files': [], 'comment': '', 'compilers': []}
event_value['comment'] = request.POST['comment']
file_counter = 0
for field, value in dict(request.POST).iteritems():
if 'compiler' in field:
pk = int(field[13:])
file = File.objects.get(pk=pk)
compiler_id = value
event_value['files'].append(file.file)
event_value['compilers'].append(compiler_id)
if 'pk' in field:
pk = int(value[0])
file = File.objects.get(pk=pk)
file_counter += 1
event_value['files'].append(file.file)
event_value['compilers'].append(None)
if not (issue.task.one_file_upload and file_counter > 1):
event = issue.set_byname('comment', event_value, request.user)
if not (issue.task.course.easyCI is None or issue.task.course.easyCI == ''):
print(issue.task.course.easyCI)
files = []
for sent_file in event_value['files']:
print(request.build_absolute_uri(sent_file.url))
files.append(request.build_absolute_uri(sent_file.url))
if len(files) != 0:
check_request_dict = {
'files': files,
'course_id': issue.task.course_id,
'title': issue.task.get_title(),
'issue_id': issue.id,
'event': {
'id': event.id,
'timestamp': event.timestamp.isoformat()
}
}
requests.post(issue.task.course.easyCI + "/api/add_task", json=check_request_dict)
return redirect(issue_page, issue_id=int(request.POST['issue_id']))
file = upload_receive(request)
field = get_object_or_404(IssueField, name='file')
event = Event.objects.create(issue_id=issue.id, field=field)
problem_compilers = []
chosen_compiler = None
send_to_contest = False
if issue.task.contest_integrated:
problem_compilers = get_problem_compilers(issue.task.problem_id, issue.task.contest_id)
for ext in settings.CONTEST_EXTENSIONS:
filename, extension = os.path.splitext(file.name)
if ext == extension:
send_to_contest = True
if not problem_compilers:
chosen_compiler = settings.CONTEST_EXTENSIONS[ext]
if settings.CONTEST_EXTENSIONS[ext] in problem_compilers:
chosen_compiler = settings.CONTEST_EXTENSIONS[ext]
problem_compilers.remove(chosen_compiler)
one_file_upload = False
if issue.task.one_file_upload:
filename, extension = os.path.splitext(file.name)
file.name = 'upload' + extension
one_file_upload = True
else:
file.name = unidecode(file.name)
instance = File(file=file, event=event)
instance.save()
basename = instance.filename()
file_dict = {
'name': basename,
'size': file.size,
'url': instance.file.url,
'thumbnailUrl': instance.file.url,
'delete_url': reverse('jfu_delete', kwargs={'pk': instance.pk}),
'delete_type': 'POST',
'problem_compilers': problem_compilers,
'chosen_compiler': chosen_compiler,
'pk': instance.pk,
'send_to_contest': send_to_contest,
'one_file_upload': one_file_upload,
}
return UploadResponse(request, file_dict)
def upload(request):
# The assumption here is that jQuery File Upload
# has been configured to send files one at a time.
# If multiple files can be uploaded simulatenously,
# 'file' may be a list of files.
issue = get_object_or_404(Issue, id=int(request.POST['issue_id']))
if 'update_issue' in request.POST:
event_value = {'files':[], 'comment':'', 'compilers':[]}
event_value['comment'] = request.POST['comment']
for field, value in dict(request.POST).iteritems():
if 'compiler' in field:
pk = int(field[13:])
file = File.objects.get(pk = pk)
compiler_id = value
event_value['files'].append(file.file)
event_value['compilers'].append(compiler_id)
if 'pk' in field:
pk = int(value[0])
file = File.objects.get(pk = pk)
event_value['files'].append(file.file)
event_value['compilers'].append(None)
issue.set_byname('comment', event_value, request.user)
return redirect(issue_page, issue_id=int(request.POST['issue_id']))
file = upload_receive(request)
field = get_object_or_404(IssueField, name='file')
event = Event.objects.create(issue_id=issue.id, field=field)
problem_compilers = []
chosen_compiler = None
send_to_contest = False
if issue.task.course.contest_integrated:
problem_compilers = get_problem_compilers(issue.task.problem_id, issue.task.contest_id)
for ext in settings.CONTEST_EXTENSIONS:
filename, extension = os.path.splitext(file.name)
if ext == extension:
send_to_contest = True
if not problem_compilers:
chosen_compiler = settings.CONTEST_EXTENSIONS[ext]
if settings.CONTEST_EXTENSIONS[ext] in problem_compilers:
chosen_compiler = settings.CONTEST_EXTENSIONS[ext]
problem_compilers.remove(chosen_compiler)
file.name = unidecode(file.name)
instance = File(file=file, event=event)
instance.save()
basename = instance.filename()
file_dict = {
'name' : basename,
'size' : file.size,
'url': instance.file.url,
'thumbnailUrl': instance.file.url,
'delete_url': reverse('jfu_delete', kwargs = { 'pk': instance.pk }),
'delete_type': 'POST',
'problem_compilers': problem_compilers,
'chosen_compiler' : chosen_compiler,
'pk': instance.pk,
'send_to_contest': send_to_contest,
}
return UploadResponse(request, file_dict)
