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