def _upload_file(request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
if request.method == 'POST':
folder = request.POST.get('folder')
fb_uploadurl_re = re.compile(r'^(%s)' % reverse("fb_upload"))
folder = fb_uploadurl_re.sub('', folder)
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, folder)
if request.FILES:
filedata = request.FILES['Filedata']
filedata.name = convert_filename(filedata.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, filedata)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(os.path.join(MEDIA_ROOT, DIRECTORY, folder, filedata.name)):
old_file = os.path.join(abs_path, filedata.name)
new_file = os.path.join(abs_path, uploadedfile)
file_move_safe(new_file, old_file)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=FileObject(os.path.join(DIRECTORY, folder, filedata.name)))
return HttpResponse('True')
def upload(request):
"""
Multiple File Upload.
"""
from django.forms.formsets import formset_factory
# QUERY / PATH CHECK
query = request.GET
path = get_path(query.get('dir', ''))
if path is None:
msg = _('The requested Folder does not exist.')
messages.add_message(request, messages.ERROR, msg)
return HttpResponseRedirect(reverse("fb_browse"))
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, path)
if STRICT_PIL:
from PIL import ImageFile
else:
try:
from PIL import ImageFile
except ImportError:
import ImageFile
ImageFile.MAXBLOCK = IMAGE_MAXBLOCK # default is 64k
from filebrowser.forms import UploadForm, BaseUploadFormSet
UploadFormSet = formset_factory(UploadForm, formset=BaseUploadFormSet, extra=5)
if request.method == 'POST':
formset = UploadFormSet(data=request.POST, files=request.FILES, path=abs_path)
if formset.is_valid():
for cleaned_data in formset.cleaned_data:
if cleaned_data:
f = cleaned_data['file']
f.name = convert_filename(f.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=abs_path, file=f)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, f)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request, path=abs_path, file=uploadedfile)
# MESSAGE & REDIRECT
msg = _('Upload successful.')
messages.add_message(request, messages.INFO, msg)
# on redirect, sort by date desc to see the uploaded files on top of the list
redirect_url = reverse("fb_browse") + query_helper(query, "ot=desc,o=date", "ot,o")
return HttpResponseRedirect(redirect_url)
else:
formset = UploadFormSet(path=abs_path)
return render_to_response('filebrowser/upload.html', {
'formset': formset,
'dir': path,
'query': query,
'settings_var': get_settings_var(),
'breadcrumbs_title': _(u'Upload'),
'title': _(u'Select files to upload'),
}, context_instance=Context(request))
def _upload_file(request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
from django.http import QueryDict
if request.method == 'POST':
query = QueryDict(request.POST.get('get_query'))
folder = request.POST.get('folder')
fb_uploadurl_re = re.compile(r'^(%s)' % reverse("fb_upload"))
folder = fb_uploadurl_re.sub('', folder)
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, folder)
if request.FILES:
filedata = request.FILES['Filedata']
filedata.name = convert_filename(filedata.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, filedata)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(os.path.join(MEDIA_ROOT, DIRECTORY, folder, filedata.name)):
old_file = os.path.join(abs_path, filedata.name)
new_file = os.path.join(abs_path, uploadedfile)
file_move_safe(new_file, old_file)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=FileObject(os.path.join(DIRECTORY, folder, filedata.name)))
return HttpResponseRedirect(reverse("fb_browse") + query_helper(query, "", "filename,filetype"))
else:
return HttpResponse("Error: No files were posted")
else:
return HttpResponse("Error: No POST data")
def _process_fileupload(request, file, target_folder):
"""Helper that is called upon a successful fileupload with the
file object, and a target folder.
"""
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, target_folder)
file.name = convert_filename(file.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=target_folder, file=file)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, file)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(
os.path.join(MEDIA_ROOT, DIRECTORY, target_folder, file.name)):
old_file = os.path.join(abs_path, file.name)
new_file = os.path.join(abs_path, uploadedfile)
file_move_safe(new_file, old_file)
# POST UPLOAD SIGNAL
# TODO: Do something about the fileobject class.
filebrowser_post_upload.send(sender=request,
path=target_folder,
file=FileObject(
os.path.join(DIRECTORY, target_folder,
file.name)))
def _upload_file(self, request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
if request.method == 'POST':
folder = request.POST.get('folder')
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("filebrowser:fb_upload", current_app=self.name))
folder = fb_uploadurl_re.sub('', folder)
abs_path = os.path.join(self.media_root, folder)
if request.FILES:
filedata = request.FILES['Filedata']
filedata.name = convert_filename(filedata.name)
self.filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata)
uploadedfile = handle_file_upload(abs_path, filedata, media_root=self.media_root)
# if file already exists
if os.path.isfile(smart_unicode(os.path.join(self.media_root, folder, filedata.name))):
old_file = smart_unicode(os.path.join(abs_path, filedata.name))
new_file = smart_unicode(os.path.join(abs_path, uploadedfile))
file_move_safe(new_file, old_file, allow_overwrite=True)
# POST UPLOAD SIGNAL
self.filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=FileObject(smart_unicode(os.path.join(folder, filedata.name)), media_root=self.media_root, media_url=self.media_url))
return HttpResponse('True')
def _upload_file(request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
if request.method == 'POST':
folder = request.POST.get('folder')
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("fb_upload"))
folder = fb_uploadurl_re.sub('', folder)
abs_path = _check_access(request, folder)
if request.FILES:
filedata = request.FILES['Filedata']
filedata.name = convert_filename(filedata.name)
_check_access(request, abs_path, filedata.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, filedata)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(smart_str(os.path.join(fb_settings.MEDIA_ROOT, fb_settings.DIRECTORY, folder, filedata.name))):
old_file = smart_str(os.path.join(abs_path, filedata.name))
new_file = smart_str(os.path.join(abs_path, uploadedfile))
file_move_safe(new_file, old_file)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=FileObject(smart_str(os.path.join(fb_settings.DIRECTORY, folder, filedata.name))))
return HttpResponse('True')
def upload(request):
"""
Multiple File Upload.
"""
from django.forms.formsets import formset_factory
# QUERY / PATH CHECK
query = request.GET
path = get_path(query.get('dir', ''))
if path is None:
msg = _('The requested Folder does not exist.')
request.user.message_set.create(message=msg)
return HttpResponseRedirect(reverse("fb_browse"))
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, path)
if STRICT_PIL:
from PIL import ImageFile
else:
try:
from PIL import ImageFile
except ImportError:
import ImageFile
ImageFile.MAXBLOCK = IMAGE_MAXBLOCK # default is 64k
from filebrowser.forms import UploadForm, BaseUploadFormSet
UploadFormSet = formset_factory(UploadForm, formset=BaseUploadFormSet, extra=5)
if request.method == 'POST':
formset = UploadFormSet(data=request.POST, files=request.FILES, path=abs_path)
if formset.is_valid():
for cleaned_data in formset.cleaned_data:
if cleaned_data:
f = cleaned_data['file']
f.name = convert_filename(f.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=abs_path, file=f)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, f)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request, path=abs_path, file=uploadedfile)
# MESSAGE & REDIRECT
msg = _('Upload successful.')
request.user.message_set.create(message=msg)
# on redirect, sort by date desc to see the uploaded files on top of the list
redirect_url = reverse("fb_browse") + query_helper(query, "ot=desc,o=date", "ot,o")
return HttpResponseRedirect(redirect_url)
else:
formset = UploadFormSet(path=abs_path)
return render_to_response('filebrowser/upload.html', {
'formset': formset,
'dir': path,
'query': query,
'settings_var': get_settings_var(),
'breadcrumbs_title': _(u'Upload'),
'title': _(u'Select files to upload'),
}, context_instance=Context(request))
def _upload_file(self, request):
"""
Upload file to the server.
"""
if request.method == "POST":
folder = request.GET.get('folder', '')
if request.is_ajax(): # Advanced (AJAX) submission
filedata = ContentFile(request.raw_post_data)
else: # Basic (iframe) submission
if len(request.FILES) != 1:
raise Http404('Invalid request! Multiple files included.')
filedata = request.FILES.values()[0]
try:
filedata.name = convert_filename(request.GET['qqfile'])
except KeyError:
return HttpResponseBadRequest(
'Invalid request! No filename given.')
fb_uploadurl_re = re.compile(
r'^.*(%s)' %
reverse("filebrowser:fb_upload", current_app=self.name))
folder = fb_uploadurl_re.sub('', folder)
path = os.path.join(self.directory, folder)
file_name = os.path.join(path, filedata.name)
file_already_exists = self.storage.exists(file_name)
# Check for name collision with a directory
if file_already_exists and self.storage.isdir(file_name):
ret_json = {'success': False, 'filename': filedata.name}
return HttpResponse(json.dumps(ret_json))
signals.filebrowser_pre_upload.send(
sender=request,
path=request.POST.get('folder'),
file=filedata,
site=self)
uploadedfile = handle_file_upload(path, filedata, site=self)
if file_already_exists and OVERWRITE_EXISTING:
old_file = smart_unicode(file_name)
new_file = smart_unicode(uploadedfile)
self.storage.move(new_file, old_file, allow_overwrite=True)
else:
file_name = smart_unicode(uploadedfile)
signals.filebrowser_post_upload.send(
sender=request,
path=request.POST.get('folder'),
file=FileObject(smart_unicode(file_name), site=self),
site=self)
# let Ajax Upload know whether we saved it or not
ret_json = {'success': True, 'filename': filedata.name}
return HttpResponse(json.dumps(ret_json))
def _upload_file(self, request):
"""
Upload file to the server.
"""
if request.method == "POST":
folder = request.GET.get('folder', '')
if request.is_ajax(): # Advanced (AJAX) submission
filedata = ContentFile(request.raw_post_data)
else: # Basic (iframe) submission
if len(request.FILES) != 1:
raise Http404('Invalid request! Multiple files included.')
filedata = request.FILES.values()[0]
try:
filedata.name = convert_filename(request.GET['qqfile'])
except KeyError:
return HttpResponseBadRequest('Invalid request! No filename given.')
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("filebrowser:fb_upload", current_app=self.name))
folder = fb_uploadurl_re.sub('', folder)
path = os.path.join(self.directory, folder)
file_name = os.path.join(path, filedata.name)
file_already_exists = self.storage.exists(file_name)
# Check for name collision with a directory
if file_already_exists and self.storage.isdir(file_name):
ret_json = {'success': False, 'filename': filedata.name}
return HttpResponse(json.dumps(ret_json))
signals.filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata, site=self)
uploadedfile = handle_file_upload(path, filedata, site=self)
if file_already_exists and OVERWRITE_EXISTING:
old_file = smart_unicode(file_name)
new_file = smart_unicode(uploadedfile)
self.storage.move(new_file, old_file, allow_overwrite=True)
else:
file_name = smart_unicode(uploadedfile)
fobj = FileObject(smart_unicode(file_name), site=self)
signals.filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=fobj, site=self)
if fobj.filetype == "Image":
version_path = get_version_path(fobj.path,ADMIN_THUMBNAIL,site=self)
if not self.storage.isfile(version_path):
version_path = version_generator(fobj.path, ADMIN_THUMBNAIL, site=self)
thumbnail_path = self.storage.url(version_path)
else:
thumbnail_path = ''
# let Ajax Upload know whether we saved it or not
ret_json = {'success': True, 'filename': filedata.name, 'path': fobj.path, 'url': fobj.url, 'thumbnail': thumbnail_path, 'filetype': fobj.filetype }
return HttpResponse(json.dumps(ret_json))
def save(self):
klass = self.get_model_class()
instance = klass(name=self.cleaned_data["name"])
abs_path = os.path.join(settings.MEDIA_ROOT,
klass._meta.get_field_by_name(instance.media_file_field)[0].directory)
f = self.cleaned_data['file']
f.name = convert_filename(f.name)
name = handle_file_upload(abs_path, f)
setattr(instance, instance.media_file_field, name)
instance.save()
return instance
def handle_file_save(directory, multimedia):
""" DRY file upload for pictures_create and embed_create """
# normalize file name
multimedia.name = convert_filename(multimedia.name)
multimedia_folder = _get_todays_folder(directory)
abs_path = os.path.join(settings.MEDIA_ROOT, multimedia_folder)
uploaded_path = handle_file_upload(abs_path, multimedia)
# uploaded path can be different from name ex. if path already exists
uploaded_path_name = uploaded_path.split(multimedia_folder)[1]
url = "%s/%s" % (multimedia_folder, uploaded_path_name)
url = url.replace('//', '/')
objeto = FileObject(url)
return objeto
def _upload_file(self, request):
"""
Upload file to the server.
"""
if request.method == "POST":
if request.is_ajax(): # Advanced (AJAX) submission
folder = request.GET.get('folder')
if hasattr(request, 'raw_post_data'):
filedata = ContentFile(request.raw_post_data)
else:
filedata = ContentFile(request.body)
try:
filedata.name = convert_filename(request.GET['qqfile'])
except KeyError:
return HttpResponseBadRequest('Invalid request! No filename given.')
else: # Basic (iframe) submission
# TODO: This needs some attention, do we use this at all?
folder = request.POST.get('folder')
if len(request.FILES) == 1:
filedata = request.FILES.values()[0]
else:
raise Http404('Invalid request! Multiple files included.')
# filedata.name = convert_filename(upload.name)
filedata.name = convert_filename(request.POST.get('file_name'))
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("filebrowser:fb_upload", current_app=self.name))
folder = fb_uploadurl_re.sub('', folder)
path = os.path.join(self.directory, folder)
file_name = os.path.join(path, filedata.name)
file_already_exists = self.storage.exists(file_name)
# Check for name collision with a directory
if file_already_exists and self.storage.isdir(file_name):
ret_json = {'success': False, 'filename': filedata.name}
return HttpResponse(json.dumps(ret_json))
signals.filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata, site=self)
uploadedfile = handle_file_upload(path, filedata, site=self)
if file_already_exists:
old_file = smart_unicode(file_name)
new_file = smart_unicode(uploadedfile)
self.storage.move(new_file, old_file, allow_overwrite=True)
signals.filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=FileObject(smart_unicode(file_name), site=self), site=self)
# let Ajax Upload know whether we saved it or not
ret_json = {'success': True, 'filename': filedata.name}
return HttpResponse(json.dumps(ret_json))
def make_file_obj(self):
field = SoundcloudTrack._meta.get_field('image')
# filebrowser needs a FileObject so we can't return a
# ContentFile like we would for an ImageField
# so we use filebrowser's own handler, which seems to work fine
path = field.directory + self.fn
full_path = os.path.join(settings.MEDIA_ROOT, path)
# assert os.path.exists(full_path), full_path
if os.path.exists(full_path):
stored_at = path
else:
content_file = self.download_img()
stored_at = handle_file_upload(field.directory, content_file, field.site)
return FileObject(stored_at, site=field.site)
def make_file_obj(self):
field = SoundcloudTrack._meta.get_field("image")
# filebrowser needs a FileObject so we can't return a
# ContentFile like we would for an ImageField
# so we use filebrowser's own handler, which seems to work fine
path = field.directory + self.fn
full_path = os.path.join(settings.MEDIA_ROOT, path)
# assert os.path.exists(full_path), full_path
if os.path.exists(full_path):
stored_at = path
else:
content_file = self.download_img()
stored_at = handle_file_upload(field.directory, content_file, field.site)
return FileObject(stored_at, site=field.site)
def _upload_file(request):
"""
Upload file to the server.
"""
logger.info('_upload_file')
from django.core.files.move import file_move_safe
if request.method == 'POST':
try:
folder = request.POST.get('folder')
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("fb_upload"))
folder = fb_uploadurl_re.sub('', folder)
abs_path = _check_access(request, folder)
if request.FILES:
filedata = request.FILES['Filedata']
filedata.name = convert_filename(filedata.name)
logger.info('file data: %s', filedata)
_check_access(request, abs_path, filedata.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request,
path=request.POST.get('folder'),
file=filedata)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, filedata)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(
smart_str(
os.path.join(fb_settings.MEDIA_ROOT,
fb_settings.DIRECTORY, folder,
filedata.name))):
old_file = smart_str(os.path.join(abs_path, filedata.name))
new_file = smart_str(os.path.join(abs_path, uploadedfile))
file_move_safe(new_file, old_file, allow_overwrite=True)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(
sender=request,
path=request.POST.get('folder'),
file=FileObject(
smart_str(
os.path.join(fb_settings.DIRECTORY, folder,
filedata.name))))
except Exception as exc:
logger.error(exc)
return HttpResponse('True')
def _upload_file(self, request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
if request.method == "POST":
if request.is_ajax(): # Advanced (AJAX) submission
folder = request.GET.get("folder")
filedata = ContentFile(request.raw_post_data)
try:
filedata.name = convert_filename(request.GET["qqfile"])
except KeyError:
return HttpResponseBadRequest("Invalid request! No filename given.")
else: # Basic (iframe) submission
folder = request.POST.get("folder")
if len(request.FILES) == 1:
filedata = request.FILES.values()[0]
else:
raise Http404("Invalid request! Multiple files included.")
filedata.name = convert_filename(upload.name)
fb_uploadurl_re = re.compile(r"^.*(%s)" % reverse("filebrowser:fb_upload", current_app=self.name))
folder = fb_uploadurl_re.sub("", folder)
abs_path = os.path.join(self.media_root, folder)
self.filebrowser_pre_upload.send(sender=request, path=request.POST.get("folder"), file=filedata)
uploadedfile = handle_file_upload(abs_path, filedata, media_root=self.media_root)
# if file already exists
if os.path.isfile(smart_unicode(os.path.join(self.media_root, folder, filedata.name))):
old_file = smart_unicode(os.path.join(abs_path, filedata.name))
new_file = smart_unicode(os.path.join(abs_path, uploadedfile))
file_move_safe(new_file, old_file, allow_overwrite=True)
self.filebrowser_post_upload.send(
sender=request,
path=request.POST.get("folder"),
file=FileObject(
smart_unicode(os.path.join(folder, filedata.name)),
media_root=self.media_root,
media_url=self.media_url,
),
)
# let Ajax Upload know whether we saved it or not
ret_json = {"success": True, "filename": filedata.name}
return HttpResponse(json.dumps(ret_json))
def _upload_file(request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
if request.method == "POST":
if request.is_ajax(): # Advanced (AJAX) submission
folder = request.GET.get('folder')
filedata = ContentFile(request.raw_post_data)
try:
filedata.name = convert_filename(request.GET['qqfile'])
except KeyError:
return HttpResponseBadRequest('Invalid request! No filename given.')
else: # Basic (iframe) submission
folder = request.POST.get('folder')
if len(request.FILES) == 1:
filedata = request.FILES.values()[0]
else:
raise Http404('Invalid request! Multiple files included.')
filedata.name = convert_filename(upload.name)
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("fb_upload"))
folder = fb_uploadurl_re.sub('', folder)
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, folder)
filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata)
uploadedfile = handle_file_upload(abs_path, filedata)
# if file already exists
if os.path.isfile(smart_str(os.path.join(MEDIA_ROOT, DIRECTORY, folder, filedata.name))):
old_file = smart_str(os.path.join(abs_path, filedata.name))
new_file = smart_str(os.path.join(abs_path, uploadedfile))
file_move_safe(new_file, old_file, allow_overwrite=True)
filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=FileObject(smart_str(os.path.join(DIRECTORY, folder, filedata.name))))
# let Ajax Upload know whether we saved it or not
ret_json = {'success': True, 'filename': filedata.name}
return HttpResponse(json.dumps(ret_json))
def _upload_file(request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
if request.method == "POST":
folder = request.POST.get("folder")
fb_uploadurl_re = re.compile(r"^.*(%s)" % reverse("fb_upload"))
folder = fb_uploadurl_re.sub("", folder)
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, folder)
if request.FILES:
filedata = request.FILES["Filedata"]
filedata.name = convert_filename(filedata.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=request.POST.get("folder"), file=filedata)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(os.path.join(DIRECTORY, folder), filedata)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(smart_str(os.path.join(MEDIA_ROOT, DIRECTORY, folder, filedata.name))):
old_file = smart_str(os.path.join(abs_path, filedata.name))
new_file = smart_str(
os.path.join(MEDIA_ROOT, uploadedfile)
) # uploadedfile already contains 'directory, folder'
try:
file_move_safe(new_file, old_file, allow_overwrite=True)
except Exception, exc:
# print exc
raise
# Create versions if necessary
if PRERENDER_VERSIONS:
for version in VERSIONS:
version_generator(uploadedfile, version)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(
sender=request,
path=request.POST.get("folder"),
file=FileObject(smart_str(os.path.join(DIRECTORY, folder, filedata.name))),
)
def file_process(request):
query = request.GET
path = get_path(query.get('dir', ''))
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, path)
from filebrowser.forms import UploadForm
form = UploadForm(data=request.POST, files=request.FILES, path=abs_path)
if form.is_valid():
f = form.cleaned_data['file']
f.name = convert_filename(f.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=abs_path, file=f)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, f)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request, path=abs_path, file=uploadedfile)
else:
return form.errors
def file_process(request):
query = request.GET
path = get_path(query.get('dir', ''))
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, path)
from filebrowser.forms import UploadForm
form = UploadForm(data=request.POST, files=request.FILES, path=abs_path)
if form.is_valid():
f = form.cleaned_data['file']
f.name = convert_filename(f.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=abs_path, file=f)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, f)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request, path=abs_path, file=uploadedfile)
else:
return form.errors
def _process_fileupload(request, file, target_folder):
"""Helper that is called upon a successful fileupload with the
file object, and a target folder.
"""
abs_path = os.path.join(MEDIA_ROOT, DIRECTORY, target_folder)
file.name = convert_filename(file.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=target_folder, file=file)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, file)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(os.path.join(MEDIA_ROOT, DIRECTORY, target_folder, file.name)):
old_file = os.path.join(abs_path, file.name)
new_file = os.path.join(abs_path, uploadedfile)
file_move_safe(new_file, old_file)
# POST UPLOAD SIGNAL
# TODO: Do something about the fileobject class.
filebrowser_post_upload.send(sender=request, path=target_folder,
file=FileObject(os.path.join(DIRECTORY, target_folder, file.name)))
def _upload_file(request):
"""
Upload file to the server.
"""
if request.method == 'POST':
folder = request.GET.get('folder')
fb_uploadurl_re = re.compile(r'^.*({0})'.format(reverse("fb_upload")))
folder = fb_uploadurl_re.sub('', folder)
abs_path = _check_access(request, folder)
if request.FILES:
filedata = request.FILES['file']
filedata.name = convert_filename(filedata.name)
_check_access(request, abs_path, filedata.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request,
path=request.GET.get('folder'),
file=filedata)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, filedata)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(
smart_str(
os.path.join(fb_settings.MEDIA_ROOT,
fb_settings.DIRECTORY, folder,
filedata.name))):
old_file = smart_str(os.path.join(abs_path, filedata.name))
new_file = smart_str(os.path.join(abs_path, uploadedfile))
file_move_safe(new_file, old_file)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request,
path=request.GET.get('folder'),
file=FileObject(
smart_str(
os.path.join(
fb_settings.DIRECTORY,
folder, filedata.name))))
return JsonResponse({'success': True})
def _upload_file(request):
"""
Upload file to the server.
"""
from django.core.files.move import file_move_safe
if request.method == 'POST':
folder = request.POST.get('folder')
fb_uploadurl_re = re.compile(r'^.*(%s)' % reverse("fb_upload"))
folder = fb_uploadurl_re.sub('', folder)
abs_path = _check_access(request, folder)
if request.FILES:
try:
filedata = request.FILES['Filedata']
filedata.name = convert_filename(filedata.name)
_check_access(request, abs_path, filedata.name)
# PRE UPLOAD SIGNAL
filebrowser_pre_upload.send(sender=request, path=request.POST.get('folder'), file=filedata)
# HANDLE UPLOAD
uploadedfile = handle_file_upload(abs_path, filedata)
# MOVE UPLOADED FILE
# if file already exists
if os.path.isfile(smart_str(os.path.join(fb_settings.MEDIA_ROOT, fb_settings.DIRECTORY, folder, filedata.name))):
old_file = smart_str(os.path.join(abs_path, filedata.name))
new_file = smart_str(os.path.join(abs_path, uploadedfile))
file_move_safe(new_file, old_file)
# POST UPLOAD SIGNAL
filebrowser_post_upload.send(sender=request, path=request.POST.get('folder'), file=FileObject(smart_str(os.path.join(fb_settings.DIRECTORY, folder, filedata.name))))
except Exception, e:
try: #try to log the error with django-db-log
from djangodblog.middleware import DBLogMiddleware as M
M().process_exception(request, e)
except:
pass
return HttpResponseServerError(str(e))
def save(self, *args, **kwargs):
# We override the standard behavior because we've overriden the FileBrowseField
# with a simple ClearableFileInput
if self.simple:
abs_paths = {}
instance = super(MediaLibraryForm, self).save(commit=False)
image_file_field = instance.image_file_field
file_fields = [instance.media_file_field]
if image_file_field:
file_fields.append(image_file_field)
for f_field in file_fields:
folder = media_model._meta.get_field_by_name(
f_field)[0].directory
abs_paths[f_field] = os.path.join(
settings.MEDIA_ROOT, settings.FILEBROWSER_DIRECTORY,
folder)
if f_field in self.files.keys():
f = self.files[f_field]
f.name = convert_filename(f.name)
name = handle_file_upload(abs_paths[f_field], f)
setattr(instance, f_field, name)
else:
# TODO(nicoechaniz): this is ugly! refactor
if f_field in ["image", "still"]:
if hasattr(self, "image_file_initial"):
setattr(instance, f_field,
self.image_file_initial)
else:
if hasattr(self, "media_file_initial"):
setattr(instance, f_field,
self.media_file_initial)
instance.save()
return instance
else:
return super(MediaLibraryForm, self).save(*args, **kwargs)
def account(request, form_class=ProfileAccountForm):
"""
Update a profiles account as a Contributor or Member in the system.
Allow different account editing possibilities depending on profile_type.
"""
# import ipdb; ipdb.set_trace()
# Get the logged in user
user = request.user
try:
profile = user.get_profile()
except ObjectDoesNotExist:
profile = None
else:
if profile.is_contributor:
form_class = ContributorAccountForm
if request.method == "POST":
args = [request.POST,]
if request.FILES.has_key('avatar'):
args.append(request.FILES)
else:
# save the existing avatar for resave
profile_avatar = profile.avatar
profile_account_form = form_class(*args, instance=profile)
if profile_account_form.is_valid():
profile = profile_account_form.save(commit=False)
profile.user = request.user # @@@ if not 'cannot edit someone elses account
if profile_account_form.files.has_key('avatar'):
avatar_path = os.path.join(
settings.FILEBROWSER_MEDIA_ROOT,
settings.FILEBROWSER_DIRECTORY,
"avatars")
if settings.FILEBROWSER_SAVE_FULL_URL:
profile.avatar = os.path.join(avatar_path, request.FILES['avatar'].name)
else:
profile.avatar = os.path.join(
settings.FILEBROWSER_DIRECTORY,
"avatars",
request.FILES['avatar'].name)
handle_file_upload(
avatar_path,
request.FILES['avatar'])
# else:
# profile.avatar = profile_avatar
profile.save()
messages.add_message(request, messages.SUCCESS, ugettext("Your account has been updated."))
return HttpResponseRedirect(reverse("profile_account"))
else:
profile.avatar = profile_avatar # Why does this go missing?
else:
profile_account_form = form_class(instance=profile)
return render_to_response(
'profiles/account.html',
{
"profile": profile,
"profile_account_form": profile_account_form,
},
context_instance=RequestContext(request))
