def upload(request):
samples = mwinfo.objects.order_by('-submit_date')[:5]
if request.method == 'POST' and request.FILES['sample']:
myfile = request.FILES['sample']
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
file_content = request.FILES['sample'].read()
mw = mwinfo()
mw.sha256 = hashlib.sha256(file_content).hexdigest()
mw.sha1 = hashlib.sha1(file_content).hexdigest()
mw.md5 = hashlib.md5(file_content).hexdigest()
mw.file_size = myfile.size
mw.file_type = myfile.content_type
mw.file_name = myfile.name
mw.sample.save(mw.sha256, ContentFile(file_content))
mw.image.save(mw.sha256 + ".png",
ContentFile(convert(mw.sample.path)))
mw.vtreport.save(mw.sha256 + ".json",
ContentFile(vtsearch(mw.sha256)))
mw.description = magic.from_file(mw.sample.path)
mw.avlabel = labeler(mw.vtreport.path)
mw.save()
context = {'sha256': mw.sha256, 'samples': samples}
return render(request, 'upload.html', context)
context = {'samples': samples}
return render(request, 'upload.html', context)
def upload(request):
ctoken = {}
ctoken.update(csrf(request))
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
shp = form.handle(request.FILES['file_obj'])
ds = gdal.DataSource(shp)
ct = CoordTransform(SpatialReference('EPSG:4326'),
SpatialReference('EPSG:900913'))
dados = []
for layer in ds[0]:
aux = layer.geom
aux.transform(ct)
dados.append(aux)
form = UploadForm()
return render_to_response(
'googlev3_upload.html',
RequestContext(request, {
'form': form,
'dados': dados,
'token': ctoken
}))
else:
form = UploadForm()
return render_to_response('googlev3_upload.html',
RequestContext(request, {'form': form}))
def upload(request):
if request.method == "POST":
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
subject = form.cleaned_data["subject"]
message = form.cleaned_data["message"]
attach2 = request.FILES["attach"]
sender = form.cleaned_data["sender"]
cc_myself = form.cleaned_data["cc_myself"]
recipient = ["*****@*****.**"]
if cc_myself:
recipient.append(sender)
try:
mail = EmailMessage(subject, message, sender, recipient, ["EMAIL_ADDRESS"])
mail.attach(attach2.name, attach2.read(), attach2.content_type)
mail.send()
except:
return "Attachment error"
return HttpResponseRedirect(reverse("feel_home"))
else:
# Dynamic initial values.
form = UploadForm(initial={"sender": "Email address"})
return render(request, "upload.html", {"form": form})
def handleImagePopAdd(request,
addForm,
field,
template="form/popmediaadd.html"):
if not request.method == "POST":
f = UploadForm()
ctx = {'form': f, 'field': field}
return render(request, template, ctx)
f = UploadForm(request.POST, request.FILES)
if not f.is_valid() and not request.FILES['file'].name.endswith('.svg'):
ctx = {'form': f, 'field': field}
return render(request, template, ctx)
file = request.FILES['file']
store_in_s3(file.name, file.read())
p = Image(url="http://%s.s3.amazonaws.com/%s" % (bucket, file.name))
if isinstance(request.user, AnonymousUser):
p.user = User.objects.get(username="******")
else:
p.user = User.objects.get(username=request.user)
if request.POST['artist']:
p.artist = User.objects.get(pk=request.POST['artist'])
p.save()
newObject = p
# Self destruction:
if newObject:
return HttpResponse('<script type="text/javascript">opener.dismissAddAnotherPopup(window, "%s", "%s");</script>' %\
(escape(newObject._get_pk_val()), escape(newObject)))
def upload_img(request):
form = UploadForm()
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
if not os.path.isdir(app_settings['DIC_UPLOAD_FULL']):
os.makedirs(app_settings['DIC_UPLOAD_FULL'])
filename = "%s.%s" % (get_file_code(), form.cleaned_data['image'].name.split('.')[-1])
filepath = os.path.join(app_settings['DIC_UPLOAD_FULL'], filename)
fileurl = '%s%s' % (app_settings['DIC_IMG_URL'], filename)
f = open(filepath, 'wb+')
for chunk in form.cleaned_data['image'].chunks():
f.write(chunk)
f.close()
image = Image.open(filepath)
if image.size[0] > app_settings['DIC_IMG_SIZE'][0] and image.size[1] > app_settings['DIC_IMG_SIZE'][1]:
image.thumbnail(app_settings['DIC_IMG_SIZE'], Image.ANTIALIAS)
print filepath
image.save(filepath)
width_b = image.size[0]
height_b = image.size[1]
width = int(request.GET.get('w'))
height = int(request.GET.get('h'))
return HttpResponseRedirect('%s?filename=%s&w=%s&h=%s&wb=%s&hb=%s' % (reverse('dic-crop-img'), filename, width, height, width_b, height_b))
return render_to_response('django_img_crop/upload-img.html', {'form': form, 'is_popup': True}, context_instance=RequestContext(request))
def judge_action(request):
form = UploadForm(request.POST)
if form.is_valid():
data = form.cleaned_data
context = data['context']
if '_auth_user_id' in request.session:
user_id = request.session['_auth_user_id']
user = User.objects.get(id=user_id)
else:
user = None
if request.FILES.has_key('image'):
image = request.FILES['image']
else:
image = None
if image != None and image.size > 3 * 1024 * 1024:
return render_to_response('result.jinja', {'state':'2', 'message':u'图片最大3M', 'url':'/main/upload'}, RequestContext(request))
item = Item.objects.create(
user=user,
context=context,
time=datetime.now(),
image=image,
status=0,
agree=random.randint(100, 200),
disagree=random.randint(0, 50),
score=int(time.time() / (60 * 60) * 1000),
)
item.save()
return render_to_response('result.jinja', {'state':'1', 'message':u'上传成功', 'url':'/main/upload'}, RequestContext(request))
else:
for field in form:
if field.errors:
return render_to_response('result.jinja', {'state':'2', 'message':field.errors, 'url':'/main/upload'}, RequestContext(request))
def upload(request):
"""
Renders the upload form page.
Args:
request: the request object
Returns:
response: a http response object
"""
if request.method == 'POST': # If the form has been submitted...
form = UploadForm(request.POST,
request.FILES) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
for filefield, tmpname in handle_uploaded_file(request):
c = Content()
originalname = str(request.FILES["file"])
c.user = request.user # Only authenticated users can use this view
c.set_file(originalname,
tmpname) # Save uploaded file to filesystem
c.get_type_instance() # Create thumbnail if it is supported
c.save()
Uploadinfo.create(c, request)
# uli.set_request_data(request)
# uli.save()
return HttpResponseRedirect(reverse('content:edit', args=[c.uid]))
else:
form = UploadForm(initial={}) # An unbound form
return _render_to_response(request, 'content_upload.html', {
'uploadform': form,
})
def put(request):
"""
Se ocupa de poner un fichero en tagfs,
verificando que se cumplen todos los requisitos del form.
"""
form = UploadForm()
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
name = form.cleaned_data['name']
description = form.cleaned_data['description']
tags_cleaned = form.cleaned_data['tags']
data = form.cleaned_data['data']
replication = form.cleaned_data['replication']
tags = set()
for tag in tags_cleaned.split():
tags.add(tag)
data = data.read()
description = not description and 'Uploaded using the web client.' or description
replication = not replication and 25 or replication
save = CLIENT.put(name, description, tags, 'tagfs', 'tagfs', 775, data, replication)
form = UploadForm()
return render_to_response(PUT_TEMPLATE,
{'form_put': form.as_p(), 'save': save,
'put': True},
context_instance=RequestContext(request))
return render_to_response(PUT_TEMPLATE,
{'form_put': form.as_p(), 'put': True},
context_instance=RequestContext(request))
def file_upload(request, template_name='oms_config/file_upload_form.html'):
var4 = 'active'
s = .objects.all()
# repository = Repository.objects.all()
username = request.session['username']
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
# print form
new_file = Upload(
doc_file=request.FILES['doc_file'],
s_id=request.POST['s'],
title=request.POST['title']
)
new_file.save()
# handle_uploaded_file(request.FILES['file'])
return redirect('upload_list')
else:
form = UploadForm()
return render(request, template_name, {'form': form,
'var4': var4,
'username': username,
'highlight3': 'active',
's': s,
})
def handleImagePopAdd(request, addForm, field, template="form/popmediaadd.html"):
if not request.method == "POST":
f = UploadForm()
ctx = {'form': f, 'field': field}
return render(request, template, ctx)
f = UploadForm(request.POST, request.FILES)
if not f.is_valid() and not request.FILES['file'].name.endswith('.svg'):
ctx = {'form': f, 'field': field}
return render(request, template, ctx)
file = request.FILES['file']
store_in_s3(file.name, file.read())
p = Image(url="http://%s.s3.amazonaws.com/%s" % (bucket, file.name))
if isinstance(request.user, AnonymousUser):
p.user = User.objects.get(username="******")
else:
p.user = User.objects.get(username=request.user)
if request.POST['artist']:
p.artist = User.objects.get(pk=request.POST['artist'])
p.save()
newObject = p
# Self destruction:
if newObject:
return HttpResponse('<script type="text/javascript">opener.dismissAddAnotherPopup(window, "%s", "%s");</script>' %\
(escape(newObject._get_pk_val()), escape(newObject)))
def upload_file(request):
resp = {}
url = str(request.get_full_path())
pid = url.split("/")[-1]
try:
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
#获取表单信息
xlsfile = form.cleaned_data['Filedata']
filename = xlsfile.name
#写入数据库
uf = Upload(Filedata = xlsfile, uptime = datetime.datetime.now())
uf.save()
filepath = uf.Filedata
uipath = unicode(str(filepath), "utf8")
uipath = os.path.join(settings.MEDIA_ROOT,uipath)
excel_table_byindex(request,file= uipath, pid = pid)
resp['success'] = True
else:
form = UploadForm()
except Exception,e:
info = "%s" % (sys.exc_info()[1])
resp['success'] = False
resp['message'] = info
def upload_file(request):
msg = ''
if request.method == 'POST':
form = UploadForm(request.POST,request.FILES)
if form.is_valid():
user_capacity = User_capacity.objects.get(user=request.user)
form = form.cleaned_data
the_file = form['upload_file']
user_name = request.user.username
size = the_file.size
capacity = user_capacity.capacity
if capacity - size < 0:
msg = 'Su archivo no pudo ser subido, excede su capacidad de almacenamiento (%s)' % (str(user_capacity))
data = {'form':UploadForm(initial={'choices':'privado'}),
'msg':msg}
return render(request,'upload_file.html',data)
scale = 'B'
if size > 1048576: # mayor a 1 MB
size = size / 1048576.0
scale = 'MB'
elif size > 1024: # mayor a 1 KB
size = size / 1024.0
scale = 'KB'
filepath = os.path.join(settings.BASE_DIR,'BajarCaja','uploads',user_name+'_files',the_file.name)
if not os.path.exists(os.path.dirname(filepath)):
os.makedirs(os.path.dirname(filepath))
with open(filepath, 'wb') as destination:
for chunk in the_file.chunks():
destination.write(chunk)
file_db = File(
filename=the_file.name,
upload_date=datetime.now(),
filepath=filepath,
size=size,
real_size=the_file.size,
scale_sz = scale,
public=form['choices']=='publico',
user=request.user)
file_db.save()
user_capacity.capacity = capacity - the_file.size
if user_capacity.capacity >= 1048576: # mayor a 1 MB
user_capacity.capacity_show = user_capacity.capacity / 1048576.0
user_capacity.scale_sz = 'MB'
elif user_capacity.capacity >= 1024: # mayor a 1 KB
user_capacity.capacity_show = user_capacity.capacity / 1024.0
user_capacity.scale_sz = 'KB'
else:
user_capacity.capacity_show = user_capacity.capacity / 1.0
user_capacity.scale_sz = 'B'
user_capacity.save()
msg = 'Archivo %s subido exitosamente.' % (the_file.name)
data = {'form':UploadForm(initial={'choices':'privado'}),
'msg':msg}
return render(request,'upload_file.html',data)
def api_upload(request):
"""
Renders the upload form page.
Args:
request: the request object
Returns:
response: a http response object
"""
if request.method == 'POST': # If the form has been submitted...
# for header in request.META.keys():
# if header.startswith('HTTP'):
# print header, request.META[header]
# print request.raw_post_data[:1000]
if request.user.is_authenticated() is False:
return HttpResponse(status=401)
form = UploadForm(request.POST,
request.FILES) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
for filefield, tmpname in handle_uploaded_file(request):
SUPPORTED_FIELDS = ['title', 'caption', 'author']
kwargs = {}
for field in SUPPORTED_FIELDS:
kwargs[field] = request.POST.get(field)
try:
kwargs['point'] = Point(float(request.POST.get('lon')),
float(request.POST.get('lat')))
except:
# raise
pass
print kwargs
c = Content(**kwargs)
originalname = str(request.FILES["file"])
# Only authenticated users can use this view
c.user = request.user
# Save uploaded file to filesystem
c.set_file(originalname, tmpname)
# Create thumbnail if it is supported
c.get_type_instance()
c.save()
Uploadinfo.create(c, request)
break # We save only the first file
response = HttpResponse(status=201)
# response.status_code = 201
# FIXME: use reverse()
response['Location'] = '/content/api/v1/content/%s/' % c.uid
return response
# return HttpResponseRedirect(reverse('content:edit', args=[c.uid]))
else:
response = HttpResponse(status=204)
return response
else:
raise Http404
def load_single_shp(request):
"""
GET returns a form to upload a zipped shp
POST takes the zip, validates that it is a single-feature poly shp and returns KML
"""
user = request.user
if user.is_anonymous() or not user.is_authenticated():
return HttpResponse('You must be logged in', status=401)
form = UploadForm()
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
# Override the defulat form behavior and
# only allow single-feature polygon shps
form.multi_feature = False
form.supported_geomtypes = ['Polygon']
if form.is_valid():
layer = form.handle(request.FILES['file_obj'], user)
g = layer[0].geom
if g.srs:
g.transform_to(4326)
geoms = [g]
t = get_template('loadshp/loadshp.kml')
kml = t.render(Context({
'username': user.username,
'geoms': geoms
}))
json = simplejson.dumps({'input_kml': kml, 'status': 'success'})
# Jquery Form plugin requires that we wrap this in a textarea
# otherwise it mangles the kml
return HttpResponse('<textarea>' + json + '</textarea>',
mimetype="text/html")
else:
json = simplejson.dumps({
'error_html': form.errors['file_obj'][0],
'status': 'errors'
})
return HttpResponse('<textarea>' + json + '</textarea>',
mimetype="text/html")
elif request.method == 'GET':
return render_to_response(
'loadshp/upload.html',
RequestContext(request, {
'form': form,
'action': request.path
}))
else:
raise Exception("This URL does not support %s requests" %
request.method)
def index(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
#print form.is_valid()
if form.is_valid():
return HttpResponseRedirect('/thanks/')
spreadsheet = request.FILES['spreadsheet']
print spreadsheet.content_type
else:
form = UploadForm()
return render(request, 'frontpage/index.html', {'form': form})
def simple_upload(request):
"""
Handles uploaded files
"""
try:
if request.method == 'POST': # If the form has been submitted...
user = request.user if request.user.is_authenticated() else None
form = UploadForm(request.POST, request.FILES) # A form bound to the POST data
if form.is_valid(): # File was posted with form
c = None
kwargs = {}
kwargs['author'] = user.username.title() if user else 'Anonymous'
# Create a new Egg
e = Egg(**kwargs)
print kwargs
for filefield, tmpname in handle_uploaded_file(request):
print "HANDLING FILE:", filefield, tmpname
c = Content(**kwargs)
originalname = str(request.FILES["file"])
# c.user = request.user # Only authenticated users can use this view
c.set_file(originalname, tmpname) # Save uploaded file to filesystem
c.get_type_instance() # Create thumbnail if it is supported
c.save()
e.content = c
e.uid = c.uid
break # We save only the first file
if c:
c.user = user
c.save()
e.user = user
print "USER", user
if user:
response_status = 200 # Created
else:
response_status = 401 # Unauthorized
e.save()
# We can handle tags after egg has id (it is saved)
response = HttpResponse(status=response_status)
#response.status_code = 201
# FIXME: use reverse()
#return HttpResponseRedirect(reverse('egg api', args=[e.uid]))
response['Location'] = '/fourdnest/api/v1/egg/%s/' % e.uid
return response
else:
response = HttpResponse(status=204)
return response
else:
raise Http404
except Exception, err:
print err
raise
return HttpResponse("Server error", status=500)
def puzzle_upload(request, puzzle_id):
puzzle = Puzzle.objects.get(id=puzzle_id)
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
handle_puzzle_upload(puzzle, form.cleaned_data['name'], request.FILES['file'])
return redirect(reverse('puzzles.views.puzzle_info', args=[puzzle_id]))
else:
form = UploadForm()
return render_to_response('puzzles/puzzle-upload.html', puzzle_context(request, {
'form': form,
'puzzle': puzzle
}))
def upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
image = UploadedImage(name = form.cleaned_data['name'], file = form.cleaned_data['file'])
image.save()
return HttpResponseRedirect('/')
else:
form = UploadForm()
return render(request, 'upload.html', {
'form': form,
})
def subir(request):
try:
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
NewPhoto = Fotos(album=request.POST['album'], url=request.FILES['url'])
NewPhoto.save()
messages.success(request, 'Imagen subida exitosamente!!! Por favor espere que nuestros administradores la aprueben para que pueda verla publicada')
else:
messages.error(request, 'Formato de archivo no aceptado')
else:
messages.error(request, 'Error al subir imagen')
except Exception, e:
logger.debug(e)
messages.error(request, 'Error al subir imagen')
def index(request):
#add to session starting_from=0
#return first 5 photos via return_next_posts
#context = RequestContext(request, )
#print settings.CONSUMER_KEY
if request.method == 'POST':
#if user is trying to submit new photo
form = UploadForm(request.POST, request.FILES)
if form.is_valid() and request.is_ajax():
description = form.cleaned_data['description']
print description
#think about resizing to a certain size!
#it has to be a photo (jpg, npg...) not some other
#file type
photo = form.cleaned_data['photo']
#create and save post, but save with status pending !DONE!///
#Post(description=description, original_photo=photo, ).save()
logger.info("new photo sent")
#also return notification regarding the success or failure
#of post submission
return HttpResponse(json.dumps({'message':
"success"})) #to return clean form
else:
#handle badly submitted forms aka
#someone putted something that isn't a photo
#when called using ajax it's being recognized as invalid
#it is required to use FormData as wrapper around form data in html
#form_object.serialize() works only for form without file fields
errors = form.errors
print errors
#print "request: ", request
return HttpResponse(json.dumps({'message': errors}))
else:
#if user is first time on the page
logger.info("came to index page")
form = UploadForm()
#get latest Posts (doing that by putting minus sign)
#negativ index slicing is not allowed while querying in Django
#take care of case when the number of posts is less then list_end
#it take cares by it self
list_end = 3
posts = Post.objects.filter(
status=Post.ACCEPTED).order_by('-pub_date')[:list_end]
request.session['start_from'] = list_end
#increment start_from at the end
return render(request, 'photos/index.html', {'form': form, 'posts': posts})
def puzzle_upload(request, puzzle_id):
puzzle = Puzzle.objects.get(id=puzzle_id)
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
handle_puzzle_upload(puzzle, form.cleaned_data['name'],
request.FILES['file'])
return redirect(
reverse('puzzles.views.puzzle_info', args=[puzzle_id]))
else:
form = UploadForm()
return render_to_response(
'puzzles/puzzle-upload.html',
puzzle_context(request, {
'form': form,
'puzzle': puzzle
}))
def index(request):
#add to session starting_from=0
#return first 5 photos via return_next_posts
#context = RequestContext(request, )
#print settings.CONSUMER_KEY
if request.method == 'POST':
#if user is trying to submit new photo
form = UploadForm(request.POST, request.FILES)
if form.is_valid() and request.is_ajax() :
description = form.cleaned_data['description']
print description
#think about resizing to a certain size!
#it has to be a photo (jpg, npg...) not some other
#file type
photo = form.cleaned_data['photo']
#create and save post, but save with status pending !DONE!///
#Post(description=description, original_photo=photo, ).save()
logger.info("new photo sent")
#also return notification regarding the success or failure
#of post submission
return HttpResponse(json.dumps({'message':"success"}))#to return clean form
else:
#handle badly submitted forms aka
#someone putted something that isn't a photo
#when called using ajax it's being recognized as invalid
#it is required to use FormData as wrapper around form data in html
#form_object.serialize() works only for form without file fields
errors = form.errors
print errors
#print "request: ", request
return HttpResponse(json.dumps({'message':errors}))
else:
#if user is first time on the page
logger.info("came to index page")
form = UploadForm()
#get latest Posts (doing that by putting minus sign)
#negativ index slicing is not allowed while querying in Django
#take care of case when the number of posts is less then list_end
#it take cares by it self
list_end = 3
posts = Post.objects.filter(status=Post.ACCEPTED).order_by('-pub_date')[:list_end]
request.session['start_from']=list_end
#increment start_from at the end
return render(request, 'photos/index.html', {'form':form, 'posts':posts})
def upload(request, json=False):
if request.method == 'GET':
form = UploadForm()
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
data = request.FILES['file']
size = form.cleaned_data['file'].size
expire_date = form.cleaned_data['expire_date'] or one_week_later()
message = form.cleaned_data['message']
receiver = form.cleaned_data['receiver']
if form.cleaned_data['filename_overwrite']:
name = form.cleaned_data['filename_overwrite']
else:
name = form.cleaned_data['file'].name
file = File(name=name, owner=request.user,
expire_date=expire_date, message=message, size=size)
md5 = handle_uploaded_file(name, file.secret, data)
file.md5 = md5
file.save()
if receiver:
downloader = Downloader(email=receiver, file=file)
downloader.save()
url = 'http://%s/files/download/%s/%s' % \
(Site.objects.get_current().domain, file.id, file.secret)
from_ = request.user.email
mailit([receiver], from_, message, url)
if json:
response = {'status': 'ok', 'fileid': file.id}
return HttpResponse(simplejson.dumps(response))
else:
return HttpResponseRedirect('/files/list/')
if json:
response = {'status': 'error', 'message': 'form not valid'}
return HttpResponse(simplejson.dumps(response))
else:
return render_to_response('files/upload.html', {'form': form, }, context_instance=RequestContext(request))
def judge_action(request):
form = UploadForm(request.POST)
if form.is_valid():
data = form.cleaned_data
context = data['context']
if '_auth_user_id' in request.session:
user_id = request.session['_auth_user_id']
user = User.objects.get(id=user_id)
else:
user = None
if request.FILES.has_key('image'):
image = request.FILES['image']
else:
image = None
if image != None and image.size > 3 * 1024 * 1024:
return render_to_response('result.jinja', {
'state': '2',
'message': u'图片最大3M',
'url': '/main/upload'
}, RequestContext(request))
item = Item.objects.create(
user=user,
context=context,
time=datetime.now(),
image=image,
status=0,
agree=random.randint(100, 200),
disagree=random.randint(0, 50),
score=int(time.time() / (60 * 60) * 1000),
)
item.save()
return render_to_response('result.jinja', {
'state': '1',
'message': u'上传成功',
'url': '/main/upload'
}, RequestContext(request))
else:
for field in form:
if field.errors:
return render_to_response('result.jinja', {
'state': '2',
'message': field.errors,
'url': '/main/upload'
}, RequestContext(request))
def upload_data(request):
switch = {
"logparse": parse_log,
"longchain": long_chain_limit,
"gjfreset": reset_gjf,
"structureview": view_structure,
}
if request.method == "POST":
upload_form = UploadForm(request.POST or None, files=request.FILES)
if upload_form.is_valid():
return switch[request.POST["options"]](request, upload_form)
else:
upload_form = UploadForm()
c = {
"upload_form": upload_form,
"job_form": JobForm.get_form(request, "{{ name }}", initial=True),
}
return render(request, "chem/upload_log.html", c)
def upload_files(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
print "form is valid"
form_data = form.cleaned_data
saved_file = handle_uploads(form_data['uploaded_file'], form_data['filename'])
newdoc = FileUpload()
newdoc.uploaded_file_url = saved_file
newdoc.description = form_data['description']
newdoc.filename = form_data['filename']
newdoc.save()
newdoc.allowed_users = form_data['allowed_users']
newdoc.save()
messages.add_message(request, messages.INFO, "File "+newdoc.filename+" Uploaded Sucessfully")
return HttpResponseRedirect(reverse('uploaded_files'))
form = UploadForm()
base_template = 'dashboard.html'
return render(request,'fileupload/upload_file.html',{'form':form, 'base_template':base_template })
def analyse(request, request_id=None, page=None):
"""
Render view for uploading data and presenting analysis results.
"""
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
request_id = path.splitext(request.FILES['data'].name)[0]
entities = _analyse(request.FILES['data'])
paginator = Paginator(entities, ENTITIES_PER_PAGE)
entities = paginator.page(1)
message = 'Success!'
else:
entities = []
message = form.errors['data']
else:
form = UploadForm()
message = None
if request_id and page:
try:
entities = parse_results(request_id)
except IOError:
raise Http404
paginator = Paginator(entities, ENTITIES_PER_PAGE)
try:
entities = paginator.page(page)
except EmptyPage:
return redirect('results', request_id=request_id, page=1)
else:
entities = []
dictionary = {
'title': 'TrendMiner Web Services',
'commit_tag': COMMIT_TAG,
'max_upload_size': MAX_UPLOAD_SIZE / (1024**2),
'form': form,
'message': message,
'rid': request_id,
'entities': entities,
}
return render_to_response(
"analyse.html", dictionary,
context_instance=RequestContext(request))
def index(request, template='./gallery/index.html'):
entry = get("Gallery")
if 'gallery' in request.POST and request.POST['gallery']:
artist = User.objects.get(pk=request.POST['gallery'])
photos = Image.objects.filter(artist=artist).order_by('-uploaded')
else:
photos = Image.objects.all().order_by('-uploaded')
if not request.method == "POST" or ('gallery' in request.POST):
f = UploadForm()
af = ArtistForm(request.POST)
ctx = {'entry': entry, 'form': f, 'photos': photos, 'artist': af}
return render(request, template, ctx)
f = UploadForm(request.POST, request.FILES)
af = ArtistForm(request.POST)
if not f.is_valid() and not request.FILES['file'].name.endswith('.svg'):
ctx = {'entry': entry, 'form': f, 'photos': photos, 'artist': af}
return render(request, template, ctx)
file = request.FILES['file']
#print type(file)
#print dir(file)
#for k,v in file.items(): print k, v
#filename = file._get_name() #['filename']
#content = file['content']
store_in_s3(file.name, file.read())
p = Image(url="http://%s.s3.amazonaws.com/%s" % (bucket, file.name))
if isinstance(request.user, AnonymousUser):
p.user = User.objects.get(username="******")
else:
p.user = User.objects.get(username=request.user)
if request.POST['artist']:
p.artist = User.objects.get(pk=request.POST['artist'])
p.save()
photos = Image.objects.all().order_by('-uploaded')
ctx = {'entry': entry, 'form': f, 'photos': photos, 'artist': af}
return render(request, template, ctx)
def api_upload(request):
"""
Renders the upload form page.
"""
if request.method == 'POST': # If the form has been submitted...
#for header in request.META.keys():
# if header.startswith('HTTP'):
# print header, request.META[header]
#print request.raw_post_data[:1000]
if request.user.is_authenticated() is False:
return HttpResponse(status=401)
form = UploadForm(request.POST, request.FILES) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
for filefield, tmpname in handle_uploaded_file(request):
SUPPORTED_FIELDS = ['title', 'caption', 'author']
kwargs = {}
for field in SUPPORTED_FIELDS:
kwargs[field] = request.POST.get(field)
try:
kwargs['point'] = Point(float(request.POST.get('lon')), float(request.POST.get('lat')))
except:
#raise
pass
print kwargs
c = Content(**kwargs)
originalname = str(request.FILES["file"])
c.user = request.user # Only authenticated users can use this view
c.set_file(originalname, tmpname) # Save uploaded file to filesystem
c.get_type_instance() # Create thumbnail if it is supported
c.save()
break # We save only the first file
response = HttpResponse(status=201)
#response.status_code = 201
# FIXME: use reverse()
response['Location'] = '/content/api/v1/content/%s/' % c.uid
return response
#return HttpResponseRedirect(reverse('edit', args=[c.uid]))
else:
response = HttpResponse(status=204)
return response
else:
raise Http404
def upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
uploaded_file = form.save()
source = default_storage.open(uploaded_file.file)
try:
if uploaded_file.records_format == 'iso2709':
check_iso2709(source, uploaded_file.records_scheme, uploaded_file.records_encodings)
elif uploaded_file.records_format == 'xml':
check_xml(source)
else:
return HttpResponse(u"Wrong file format")
except Exception as e:
default_storage.delete(uploaded_file.file)
uploaded_file.delete()
return HttpResponse(u"Error: wrong records file structure: " + e.message)
return redirect('ssearch:administration:initial')
def upload(request):
"""
Renders the upload form page.
"""
if request.method == 'POST': # If the form has been submitted...
form = UploadForm(request.POST, request.FILES) # A form bound to the POST data
if form.is_valid(): # All validation rules pass
for filefield, tmpname in handle_uploaded_file(request):
c = Content()
originalname = str(request.FILES["file"])
c.user = request.user # Only authenticated users can use this view
c.set_file(originalname, tmpname) # Save uploaded file to filesystem
c.get_type_instance() # Create thumbnail if it is supported
c.save()
return HttpResponseRedirect(reverse('edit', args=[c.uid]))
else:
form = UploadForm(initial={}) # An unbound form
return _render_to_response(request, 'content_upload.html', {
'uploadform' : form,
})
def upload_data(request):
switch = {
"logparse": parse_log,
"longchain": long_chain_limit,
"gjfreset": reset_gjf,
"structureview": view_structure,
"percent": get_percent,
}
if request.method == "POST":
upload_form = UploadForm(request.POST or None, files=request.FILES)
if upload_form.is_valid():
return switch[request.POST["options"]](request, upload_form)
else:
upload_form = UploadForm()
c = {
"upload_form": upload_form,
"job_form": JobForm.get_form(request, "{{ name }}", initial=True),
}
return render(request, "chem/upload_log.html", c)
def upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
uploaded_file = form.save()
source = default_storage.open(uploaded_file.file)
try:
if uploaded_file.records_format == 'iso2709':
check_iso2709(source, uploaded_file.records_scheme, uploaded_file.records_encodings)
elif uploaded_file.records_format == 'xml':
check_xml(source)
else:
return HttpResponse(u"Wrong file format")
except Exception as e:
default_storage.delete(uploaded_file.file)
uploaded_file.delete()
return HttpResponse(u"Error: wrong records file structure: " + e.message)
return redirect('ssearch:administration:initial')
def index(request, template='./gallery/index.html'):
entry = get("Gallery")
if 'gallery' in request.POST and request.POST['gallery']:
artist = User.objects.get(pk=request.POST['gallery'])
photos = Image.objects.filter(artist=artist).order_by('-uploaded')
else:
photos = Image.objects.all().order_by('-uploaded')
if not request.method == "POST" or ('gallery' in request.POST):
f = UploadForm()
af = ArtistForm(request.POST)
ctx = {'entry': entry, 'form': f, 'photos': photos, 'artist': af}
return render(request, template, ctx)
f = UploadForm(request.POST, request.FILES)
af = ArtistForm(request.POST)
if not f.is_valid() and not request.FILES['file'].name.endswith('.svg'):
ctx = {'entry': entry, 'form': f, 'photos': photos, 'artist': af}
return render(request, template, ctx)
file = request.FILES['file']
#print type(file)
#print dir(file)
#for k,v in file.items(): print k, v
#filename = file._get_name() #['filename']
#content = file['content']
store_in_s3(file.name, file.read())
p = Image(url="http://%s.s3.amazonaws.com/%s" % (bucket, file.name))
if isinstance(request.user, AnonymousUser):
p.user = User.objects.get(username="******")
else:
p.user = User.objects.get(username=request.user)
if request.POST['artist']:
p.artist = User.objects.get(pk=request.POST['artist'])
p.save()
photos = Image.objects.all().order_by('-uploaded')
ctx = {'entry': entry, 'form': f, 'photos': photos, 'artist': af}
return render(request, template, ctx)
def upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
filehandle = request.FILES['file']
# paginator = Paginator(filehandle..get_records(), 30)
# text_2_render = u'Đã xử lý xong'
filehandle.save_to_database(
model=Path,
mapdict=['departure_port',
'destination_port',
'search_flag',
'transfer_flag',
'direct_flag',
'lcc_flag',
'old_stop', ]
)
return HttpResponseRedirect('/show')
else:
form2 = UploadForm()
text_2_render1 = 'sai sai sai sai sai'
return render_to_response(
'show/import.html',
{
'form': form2,
'text_header': text_2_render1
},
context_instance=RequestContext(request)
)
else:
form = UploadForm()
# template = loader.get_template('show/import.html')
return render(request,
'show/import.html',
{
'form': form,
'text_header': 'All hail EE-sama, chọn file excel.xlsx để nạp dữ liệu '
'vào database'
},
context_instance=RequestContext(request)
)
def append(request, fileid):
if request.method != 'POST':
response = {'status': 'error', 'message': 'expected a post'}
return HttpResponse(simplejson.dumps(response))
form = UploadForm(request.POST, request.FILES)
if not form.is_valid():
response = {'status': 'error', 'message': 'no file'}
return HttpResponse(simplejson.dumps(response))
file = get_object_or_404(File, pk=fileid)
if request.user != file.owner:
raise Http404
data = request.FILES['file']
size = form.cleaned_data['file'].size
filelocation = os.path.join(settings.STORAGE_ROOT, file.secret, file.name)
if not os.access(filelocation, os.F_OK):
raise Http404
md5 = hashlib.md5()
# recalculate md5 for existing blob
with open(filelocation, 'rb') as f:
for chunk in iter(lambda: f.read(8192), ''):
md5.update(chunk)
with open(filelocation, 'ab') as f:
for chunk in data.chunks():
md5.update(chunk)
f.write(chunk)
file.md5 = md5.hexdigest()
file.size = file.size + size
file.save()
response = {'status': 'ok', 'md5': file.md5}
return HttpResponse(simplejson.dumps(response))
def upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
filehandle = request.FILES['file']
# paginator = Paginator(filehandle..get_records(), 30)
# text_2_render = u'Đã xử lý xong'
filehandle.save_to_database(model=Path,
mapdict=[
'departure_port',
'destination_port',
'search_flag',
'transfer_flag',
'direct_flag',
'lcc_flag',
'old_stop',
])
return HttpResponseRedirect('/show')
else:
form2 = UploadForm()
text_2_render1 = 'sai sai sai sai sai'
return render_to_response('show/import.html', {
'form': form2,
'text_header': text_2_render1
},
context_instance=RequestContext(request))
else:
form = UploadForm()
# template = loader.get_template('show/import.html')
return render(
request,
'show/import.html', {
'form':
form,
'text_header':
'All hail EE-sama, chọn file excel.xlsx để nạp dữ liệu '
'vào database'
},
context_instance=RequestContext(request))
def upload(request):
if request.method == 'POST':
print request.POST
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
cd = form.cleaned_data
image_field = cd.get('photo')
img = str(image_field)
img_name, img_extension = img.split(".")
image_file = StringIO.StringIO(image_field.read())
image = Image.open(image_file)
h = pytesseract.image_to_string(image)
t = str(unicode(h).encode('utf8'))
f = open("guru99.txt", "w+")
f.write(t)
photodetails = FileUpload()
photodetails.text = t
photodetails.photo = image_field
photodetails.save()
response = HttpResponse(t, content_type='text/plain')
f.close()
response[
'Content-Disposition'] = 'attachment;filename="' + img_name + '-converted.txt' '"'
# return response and HttpResponseRedirect('map_view')
return response
query = FileUpload.objects.order_by('-id')[:1].values_list('latitude',
flat=True)
# lat = query.values_list('latitude', flat=True)
p = []
for item in query:
p.append(item)
context = {
"form": form,
"latitude": p,
}
return render(request, 'image-to-text.html', context)
def upload_view(request):
user = check_validation(request)
if user:
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
image = form.cleaned_data.get('image')
concept = 'apple'
post = UploadModel(user=user,
image=image,
concept=concept,
points=0)
post.save()
path = str(BASE_DIR + '/' + post.image.url)
client = ImgurClient(
'e2dd69870de1f73',
'1b49cedd71bdbd818498a1c3434ed56bfb0ed676')
post.image_url = client.upload_from_path(path,
anon=True)['link']
post.save()
app = ClarifaiApp(api_key='{api-key}')
# get the general model
model = app.models.get("general-v1.3")
# predict with the model
response = model.predict_by_url(url=post.image_url)
x = response[concept]
x = 10 * x
post.points = x
post.save()
return redirect('/upload/')
else:
form = PostForm()
return render(request, 'get_file.html', {'form': form})
def load_single_shp(request):
"""
GET returns a form to upload a zipped shp
POST takes the zip, validates that it is a single-feature poly shp and returns KML
"""
user = request.user
if user.is_anonymous() or not user.is_authenticated():
return HttpResponse('You must be logged in', status=401)
form = UploadForm()
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
# Override the defulat form behavior and
# only allow single-feature polygon shps
form.multi_feature = False
form.supported_geomtypes = ['Polygon']
if form.is_valid():
layer = form.handle(request.FILES['file_obj'],user)
g = layer[0].geom
if g.srs:
g.transform_to(4326)
geoms = [g]
t = get_template('loadshp/loadshp.kml')
kml = t.render(Context({'username': user.username, 'geoms': geoms}))
json = simplejson.dumps({'input_kml': kml, 'status':'success'})
# Jquery Form plugin requires that we wrap this in a textarea
# otherwise it mangles the kml
return HttpResponse('<textarea>'+json+'</textarea>',mimetype="text/html")
else:
json = simplejson.dumps({'error_html': form.errors['file_obj'][0], 'status':'errors'})
return HttpResponse('<textarea>'+json+'</textarea>',mimetype="text/html")
elif request.method == 'GET':
return render_to_response('loadshp/upload.html', RequestContext(request,{'form': form,'action':request.path}))
else:
raise Exception("This URL does not support %s requests" % request.method)
def list_files(request, season):
season = get_object_or_404(Season, pk=int(season))
if request.method == 'POST':
if not request.user.has_perm('files.add_chorusfile'):
return HttpResponseNotFound("NO PERMISSION")
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
uploaded_file = request.FILES['file']
if form.cleaned_data['mass_upload']:
mass_upload(request, form)
else:
chorus_file = ChorusFile.objects.create(name=uploaded_file.name,
user=request.user,
comments=form.cleaned_data['comments'],
timestamp=datetime.datetime.now(),
purpose=form.cleaned_data['purpose'],
season=form.cleaned_data['season'],
voice=form.cleaned_data['voice'],
size=uploaded_file.size)
chorus_file.save_uploaded_file(uploaded_file=uploaded_file)
chorus_file.save()
season = form.cleaned_data['season']
if season is None:
url = reverse('files-select')
else:
url = reverse('files-list', kwargs=dict(season=season.pk))
return redirect(url)
else:
form = UploadForm()
# FIXME - limit files
files = ChorusFile.objects.filter(Q(season=None) | Q(season=season)).order_by('-season', 'voice', 'name', 'timestamp')
return render(request, 'files/list.html', {
'files': files,
'form': form,
'season': season,
})
def upload_file(request):
error_message = ""
if request.method == "POST":
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
doc_name = UploadedFile(request.FILES["doc_file"])
doc_uploaded_date = timezone.now()
doc = request.FILES["doc_file"]
if get_file_type(doc_name) == ".rtf":
result = Rtf15Reader.read(doc)
parser = LawHtmlParser(PlaintextWriter.write(result).read())
elif get_file_type(doc_name) == ".txt":
parser = LawHtmlParser(doc.read())
parsed_doc_content = parser.get_parsed_text()
new_doc = Document(name=doc_name, content=parsed_doc_content, uploaded_date=doc_uploaded_date, file=doc)
new_doc.save()
return HttpResponseRedirect(reverse("document:list"))
else:
error_message = "Please select a file."
form = UploadForm()
return render(request, "document/upload.html", {"form": form, "error_message": error_message})
def upload_file(request):
titulo = 'UpLoad'
tipo = 'Subir imagen de perfil'
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
username = request.user
filename = str(username)+'avi'
usuario.objects.filter(user=username).update(filename = filename, docfile = request.FILES['docfile'])
#Renombrar imagen
#filename_real = str(request.FILES['docfile'])
#auto_rename(settings.MEDIA_ROOT+'/img_avatar/', filename_real, filename)
#
#Enviar si es correcto
titulo = 'Foto correcta'
mensaje = 'Foto subida correctamente'
url = '/home/'
return render(request, 'correcto.html', {'titulo': titulo, 'mensaje':mensaje, 'url':url, 'username': username,})
else:
form = UploadForm()
#tambien se puede utilizar render_to_response
#return render_to_response('upload.html', {'form': form}, context_instance = RequestContext(request))
return render(request, 'upload.html', {'titulo':titulo, 'form': form, 'tipo':tipo})
def confirm_upload(request):
USER_NAME = request.user.username
fileName = str((request.FILES['upload_file']).name)
FILE_DIR = os.path.join(BASE_DIR, 'media/user/'+USER_NAME+"/"+'temporary_files/')+fileName
print type(request.FILES['upload_file'])
print pandas.read_csv(request.FILES['upload_file'])
if os.path.exists(FILE_DIR):
os.remove(FILE_DIR)
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
form.save()
args = {}
args.update(csrf(request))
if 'datavalue' in fileName :
importType = 'datavalues'
elif 'site' in fileName:
importType = 'sites'
elif 'method' in fileName:
importType = 'methods'
elif 'source' in fileName:
importType = 'sources'
elif 'variable' in fileName:
importType = 'variables'
args['fileName'] = fileName
return render_to_response('import_'+importType+'.html',args)
else:
form = UploadForm()
args = {}
args['filename'] = filename
args.update(csrf(request))
args['form'] = form
return render_to_response('uploadfile.html',args,context_instance=RequestContext(request))
def upload(request):
ctoken = {}
ctoken.update(csrf(request))
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
shp = form.handle(request.FILES['file_obj'])
ds = gdal.DataSource(shp)
ct = CoordTransform(SpatialReference('EPSG:4326'), SpatialReference('EPSG:900913'))
dados=[]
for layer in ds[0]:
aux = layer.geom
aux.transform(ct)
dados.append(aux)
form = UploadForm()
return render_to_response('googlev3_upload.html',
RequestContext(request,{'form': form,
'dados': dados, 'token':ctoken}))
else:
form = UploadForm()
return render_to_response('googlev3_upload.html',
RequestContext(request,{'form': form}))
def upload(request):
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
form_data = form.cleaned_data
try:
d = Directory.objects.get(directory=form_data['directory'])
except:
return HttpResponseRedirect('../failed/?e=' + '文件夹不存在或密码错误')
if not d.check_password(form_data['password']):
return HttpResponseRedirect('../failed/?e=' + '文件夹不存在或密码错误')
f = request.FILES['file']
name = form_data['filename'] if form_data['filename'] <> '' else f.name
if UploadFile.objects.filter(directory=d, file_name=name).count() <> 0:
return HttpResponseRedirect('../failed/?e=' + '该文件名已存在')
if f.size > d.file_max_size * 1024 * 1024:
return HttpResponseRedirect('../failed/?e=' \
+ '文件大小超过文件夹允许单个文件的上限')
check_used(d)
if f.size + d.used_size > d.total_size * 1024 * 1024:
return HttpResponseRedirect('../failed/?e=' + '文件夹已满')
try:
handle_upload_file(d, f, name, form_data)
except:
return HttpResponseRedirect('../failed/?e=' + '保存文件失败')
return HttpResponseRedirect(
'../success/?u={0:.3f}&t={1}&d={2}&fs={3}&on={4}&nn={5}'.format(
d.used_size / 1024.0 / 1024, d.total_size, d, f.size,
f.name.encode('utf-8'), name.encode('utf-8')))
else:
form = UploadForm()
return render(request, 'fileupload/upload.html',
{'form': form,
'login_dir': request.session.get('dir', ''),
})
def list(request):
if request.is_ajax():
print "ajax entered"
print request.FILES
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
print 'form validated'
files = request.FILES.getlist('file')
for file in files:
path = MEDIA_ROOT + 'ebooks/' + str(file)
destination = open(path, 'wb+')
for chunk in file.chunks():
destination.write(chunk)
destination.close()
for file in files:
path = MEDIA_ROOT + 'ebooks/' + str(file)
destination = open(path, 'wb+')
a = destination.read()
print a
destination.close()
return HttpResponse('done \m/')
output = []
error = []
rlt = None
if request.method == 'POST':
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
file = Document(file=request.FILES['file'])
file.save()
files = request.FILES.getlist('file')
for file in files:
path = MEDIA_ROOT + 'ebooks/' + str(file)
destination = open(path, 'wb+')
for chunk in file.chunks():
destination.write(chunk)
destination.close()
for file in files:
path = MEDIA_ROOT + 'ebooks/' + str(file)
destination = open(path, 'r')
a = destination.read()
destination.close()
for file in files:
path = MEDIA_ROOT + 'ebooks/' + str(file)
a = b = ''
p = subprocess.Popen(['g++', path])
#a,b = p.communicate()
p.wait()
print a
print 'goo boy'
a = os.linesep.join([s for s in a.splitlines() if s])
b = os.linesep.join([s for s in b.splitlines() if s])
output.append(a)
error.append(b)
if not b:
pr = subprocess.call(['./a.out'])
file = open('output.txt', 'r')
print file.read()
file.close()
file = open('1.txt', 'r')
print file.read()
file.close()
rlt = filecmp.cmp('output.txt', '1.txt', shallow=False)
print 'pramod'
print rlt
"""
import subprocess
basename = "CodeGenTest";
execname = basename;
srcname = basename + ".cpp";
codeList = [];
codeList.append("#include<iostream>")
codeList.append("#include <stdio.h>");
codeList.append("using namespace std;int main(int argc, char *argv[])\n{");
codeList.append("printf(\"Hello world.\\n\");");
codeList.append("int a;cin>>a;");
codeList.append("}");
# Convert codelist to string.
codeList.append("");
codeString = "\n".join(codeList);
# Print code to output source file
outfile=open(srcname,'w');
outfile.write(codeString);
outfile.close();
print "Compile.";
cmd = ["g++", srcname, "-o", execname];
p = subprocess.Popen(cmd);
p.wait();
subprocess.call(["./"+execname,'<','input.txt','>','output.txt']);
"""
else:
form = UploadForm()
dir_path = os.path.join(MEDIA_ROOT, 'ebooks/')
files = []
for file in os.listdir(dir_path):
files.append(os.path.join(file))
return render_to_response('ebooks/list.html', {
'files': tuple(files),
'error': error,
'output': output,
'form': form
},
context_instance=RequestContext(request))
