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_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): 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)