def upload(): user = User.query.get(session['userID']) files = request.files.getlist("inputFiles") url = request.form.get('url', False) if len(files): for file in files: f = File.query.filter( and_(File.owner == user, File.url == url, File.isFile == True, File.filename == file.filename)) if f.count(): continue newFile = File(filename=file.filename, url=url, owner=user) db.session.add(newFile) path = app.config['UPLOADS'] + "/" + user.username + url file.save(os.path.join(path, file.filename)) else: folderName = request.form.get('folderName', False) if len(folderName): newFolder = File(filename=folderName, url=url, owner=user, isFile=False) db.session.add(newFolder) try: os.mkdir(app.config['UPLOADS'] + "/" + user.username + url + "/" + folderName) except: return "Folder already exists!" else: return "Please enter name" db.session.commit() return "1"
def uploadFile(f, comment=None, groups=None): ''' Storing file and writing information into database. :param f: storing file. :param comment: comments for file. :param group: share with group. :return: True if ok, otherwise False. ''' checksum = hashlib.md5(f.read()).hexdigest() # getting file size f.seek(0, os.SEEK_END) file_size = f.tell() # save file ot disk path = os.path.join(application.config.get('WEB_UPLOAD_DIR'), checksum) if not os.path.exists(path): f.seek(0) f.save(path) if not groups: upload_file = File(name=secure_filename(f.filename), checksum=checksum, timestamp=datetime.now(), comment=comment, size=file_size) upload_file.account = current_user try: db.session.add(upload_file) db.session.commit() except IntegrityError as ex: application.logger.error(ex) db.session.rollback() else: for group in groups: upload_file = File(name=secure_filename(f.filename), checksum=checksum, timestamp=datetime.now(), comment=comment, size=file_size) # owner & group upload_file.account = current_user upload_file.group = group try: db.session.add(upload_file) db.session.commit() except IntegrityError as ex: application.logger.error(ex) db.session.rollback() return checksum
def upload(): """ upload file and save file in local disk. http-request's form should have [file] part :return: """ if request.files: try: file_name = request.files['file'].filename #无需考虑文件名重复的问题 hex = secure_name(file_name) cate = auto_category(hex) file.save(request.files['file'], name=hex) try: f = File(name=file_name, hex=hex, category=cate) db.session.add(f) db.session.commit() except OperationalError: db.session.rollback() return http_response(250, 'bad', 'database not exist') return http_response(200, 'ok', 'file uploaded') except UploadNotAllowed: http_response(250, 'bad', 'file ext not allowed') return http_response(250, 'bad', 'file upload filed')
def sendRequestgetSB2(idProject): """First request to getSB2""" getRequestSb2 = "http://getsb2-drscratch.herokuapp.com/" + idProject fileURL = idProject + ".sb2" # Create DB of files now = datetime.now() fileName = File(filename=fileURL, method="url", time=now) fileName.save() dir_zips = os.path.dirname(os.path.dirname(__file__)) + "/uploads/" fileSaved = dir_zips + str(fileName.id) + ".sb2" pathLog = os.path.dirname(os.path.dirname(__file__)) + "/log/" logFile = open(pathLog + "logFile.txt", "a") logFile.write("FileName: " + str(fileName.filename) + "\t\t\t" + "ID: " + \ str(fileName.id) + "\t\t\t" + "Method: " + str(fileName.method) + "\t\t\t" + \ "Time: " + str(fileName.time) + "\n") # Save file in server counter = 0 file_name = handler_upload(fileSaved, counter) outputFile = open(file_name, 'wb') sb2File = urllib2.urlopen(getRequestSb2) outputFile.write(sb2File.read()) outputFile.close() return (file_name, fileName)
def post(self): file = request.files['file'] f = File() f.set_file(file) db.session.add(f) db.session.commit() return f, 201
def setUp(self): app.config.from_object(TestConfig) db.session.remove() db.drop_all() self.app = app.test_client() db.create_all() data = [] data.append(File(filename="default.png")) data.append(Rol(descripcion="administrador")) db.session.add_all(data) db.session.commit() rolAdm = Rol.query.filter_by(descripcion="administrador").first() administrador = User(username="******", nombre="Super", apellido="admin", email="*****@*****.**", rol_id=rolAdm.id, ultimo_acceso=datetime.utcnow()) administrador.set_password("admin") db.session.add(administrador) db.session.commit() self.user_data = self.login_refresh() headers = { 'Authorization': 'Bearer {}'.format(self.user_data["access_token"]) } self.headers = headers
def upload_file(): form=UploadForm() if form.validate_on_submit(): if form.file.data is None or form.file.data.filename =='': flash('No selected file.') return redirect(url_for('upload')) file=request.files['file'] if file and allowed_file(file.filename): filename = secure_filename(file.filename) filetype=filename.rsplit('.',1)[1].lower() directory=app.config['UPLOAD_FOLDER'] + hashlib.md5(current_user.username).hexdigest() if not os.path.exists(directory): os.mkdir(directory) file.save(os.path.join(directory,filename)) filehash=None with open(os.path.join(directory,filename)) as f: filehash = hashlib.md5(f.read(400)).hexdigest() f.close() os.rename(os.path.join(directory,filename),os.path.join(directory,filehash+'.'+filetype)) f=File(file_name=filename,file_hash=filehash,file_type=filetype,uploader=current_user.get_id()) db.session.add(f) db.session.commit() current_user.set_hashed_name() db.session.add(current_user) db.session.commit() if(form.prof_pic.data is True): current_user.set_profile_image(f.id) db.session.add(current_user) db.session.commit() return redirect(url_for('user',username=current_user.username)) return render_template('upload.html',title='Upload',form=form)
def upload(): form = UploadForm() if form.validate_on_submit(): f = form.file.data file_name = f.filename file_name = secure_filename(f.filename) # Real filename file = File.query.filter_by(file_name=file_name).first() if file in File.query.all(): flash('Ya existe un archivo con ese nombre.') return render_template('500.html'), 500 upload_folder = app.config['UPLOAD_FOLDER'] if os.path.isdir(upload_folder) == False: os.makedirs(upload_folder) file_path = os.path.join(upload_folder, file_name) # filename f.save(file_path) new_file = File(file_name=file_name, upload_date=datetime.utcnow()) new_file.path = os.path.abspath(file_path) new_file.size = os.path.getsize(file_path) new_file.user_id = current_user.id new_file.description = form.description.data new_file.hash_sha = new_file.encrypt_string(new_file.file_name) db.session.add(new_file) db.session.commit() flash(f'{file_name} was successfully uploaded!!') return redirect(url_for('index')) return render_template('upload.html', form=form)
def upload_files(): user = token_auth.current_user() if not user.verified: return error_response(403, 'Email not confirmed') if 'files' not in request.files: return bad_request('No files to upload') uploaded = [] errors = [] files = request.files.getlist('files') for file in files: file_data = upload_file(user, file) if 'error' in file_data: errors.append(file_data['error']) continue file_model = File() file_model.from_dict(file_data) db.session.add(file_model) db.session.commit() uploaded.append(file_model.to_dict()) response = jsonify({'uploaded_files': uploaded, 'errors': errors}) response.status_code = 201 return response
def upload_group_file(path): form = UploadForm() user = User.query.get(current_user.id) if form.validate_on_submit(): f = request.files['upload'] emails = form.email.data users = [user] for email in emails.split(","): u = User.query.filter_by(email=email).first() if not u or u not in currentFolder.AccessFolder: flash( "Please enter correct user emails and users with rights to the directory" ) return render_template( 'fileModification/upload_group/upload_group_file.html', title='Upload Group File', form=form, path=path) users.append(u) currentFolder = Folder.query.filter_by(id=path).first() fileDb = File(name=f.filename, parent=currentFolder, AccessFile=users, groupFile=True) fileDb.lastRequest = "upload" fileDb.idAcceptance = str(user.id) db.session.add(fileDb) f.save(os.path.join(returnPathOfFolder(currentFolder.id), f.filename)) db.session.commit() return redirect(url_for('index')) return render_template( 'fileModification/upload_group/upload_group_file.html', title='Upload Group File', form=form, path=path)
def upload_normal_file(path): form = UploadForm() user = User.query.get(current_user.id) if form.validate_on_submit(): f = request.files['upload'] emails = form.email.data users = [user] for email in emails.split(","): u = User.query.filter_by(email=email).first() if u and u in currentFolder.AccessFolder: users.append(u) currentFolder = Folder.query.filter_by(id=path).one() fileDb = File(name=f.filename, parent=currentFolder, AccessFile=users) db.session.add(fileDb) path = returnPathOfFolder(currentFolder.id) name = f.filename files = f.read() key = Fernet.generate_key() fernet = Fernet(key) fileDb.encryptionKey = key encrypted = fernet.encrypt(files) with open(os.path.join(path, name), 'wb') as fa: fa.write(encrypted) db.session.commit() return redirect(url_for('index')) return render_template( 'fileModification/upload_normal/upload_normal_file.html', title='Upload Normal file', form=form, path=path)
def route_v2_project_project_id_files_add(project_id): project = Project.query.get(project_id) if project is None: abort(404) form = CreateFileForm() if form.validate_on_submit(): try: filename = form.filename.data file_content = open(filename, encoding='utf-8').read() file = File(filename=filename, content=file_content, project_id=project.id) db.session.add(file) db.session.commit() flash('File <samp>{filename}</samp> successfully added to project.'.format(filename=file.filename), category='message') return redirect(url_for('route_v2_project_project_id', project_id=project.id)) except FileNotFoundError: flash('File <samp>{filename}</samp> not found.'.format(filename=form.filename.data), category='error') for field, error_msg in form.errors.items(): flash('Error in field "{field}": {error_msg}'.format( field=field, error_msg=' '.join(error_msg) ), category='error') return render_template('v2_add_file_to_project.html', form=form, project=project)
def sendRequestgetJSON(idProject): """First request to getJSON""" fileURL = idProject + ".json" # Create DB of files now = datetime.now() fileName = File(filename=fileURL, method="url", time=now) fileName.save() dir_zips = os.path.dirname(os.path.dirname(__file__)) + "/uploads/" fileSaved = dir_zips + str(fileName.id) + ".json" pathLog = os.path.dirname(os.path.dirname(__file__)) + "/log/" logFile = open(pathLog + "logFile.txt", "a") logFile.write("FileName: " + str(fileName.filename) + "\t\t\t" + "ID: " + \ str(fileName.id) + "\t\t\t" + "Method: " + str(fileName.method) + "\t\t\t" + \ "Time: " + str(fileName.time) + "\n") # Save file in server counter = 0 file_name = handler_upload(fileSaved, counter) outputFile = open(file_name, 'wb') print "Retrieving: ", idProject jsonFile = urllib2.urlopen(idProject) outputFile.write(jsonFile.read()) outputFile.close() return (file_name, fileName)
def uploadFile(self, file): file = self.request.FILES[file] fsys = FileSystemStorage() fullfilename = os.getcwd() + settings.MEDIA_DIR + str( self.id) + "\\" + file.name if os.path.isfile(fullfilename): fsys.delete(fullfilename) filename = fsys.save(fullfilename, file) upload_file_url = fsys.url(filename) scanned = self.scanfileforvirus(file, fullfilename) if scanned['response_code'] == 1: if len(File.objects.filter(path=fullfilename).values()) < 1: f = File() f.path = fullfilename f.virusscan_resource = scanned['resource'] f.file_type = 't' f.client_id = Client.objects.filter(id=self.id)[0] f.save() else: self.getReports() else: print('deleted') fsys.delete(fullfilename)
def create(): """File creating""" if request.method == 'POST': if 'file' not in request.files: flash('No file part', 'warning') return redirect(request.url) file = request.files['file'] if file.filename == '': flash('No file selected', 'warning') return redirect(request.url) if file and allowed_file(file.filename): filename = file.filename if request.form['title']: title = request.form['title'] url = quote(title.strip().lower().replace(" ", "_")) filename = secure_filename('%s.%s' % (url, filename.rsplit('.', 1)[1])) else: title = filename.rsplit('.', 1)[0] file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) db_file = File() db_file.title = title db_file.user_id = current_user.id db_file.path = filename db.session.add(db_file) db.session.commit() flash('File "%s" successfully uploaded' % db_file.title, 'success') return redirect(url_for('backend_file.view', file_id=db_file.id)) return render_template('file/create.j2')
def upload(): form = UploadForm() # form.validate_on_submit() # 无错误或者不出售价钱为空 # if form.is_submitted() and \ # (len(form.errors) == 0 or (len(form.errors) == 1 and form.price.data is None and not form.for_sell.data)): price = form.price.data if form.is_submitted() and not price: price = 0 if form.validate_on_submit(): hash = keccak_256(form.file.data.stream.read()).hexdigest() filename = form.filename.data.encode('utf-8') description = form.description.data.encode('utf-8') for_sell = form.for_sell.data file = File(hash=hash, filename=filename, description=description, for_sell=for_sell, price=price) # file.owner_user = current_user file.owner = current_user.username # file.time = datetime.now() file.txhash = submit_file(current_user, file) db.session.add(file) # print(file) # reset stream index form.file.data.stream.seek(0) saved_filename = app.upload_files.save(form.file.data, name=hash + '.') file_url = app.upload_files.url(saved_filename) return redirect(url_for('showcase.show_file', hash=file.hash)) else: file_url = None return render_template('upload.html', form=form, file_url=file_url)
def save_attachment(f, mediatype, db_object, folder): filename = secure_filename(f.filename) filename = '%s_%s' % (datetime.now( app.config['TZ']).isoformat()[:19], filename) filepath = os.path.join( os.path.abspath( os.path.join(app.instance_path, '../%s/%s' % (app.config['UPLOAD_FOLDER'], folder))), filename) f.save(filepath) new_file = File(filename=filename, mimetype=f.headers[1][1], mediatype=mediatype) db.session.add(new_file) db.session.commit() # Link attachment to payment in the database # If the db object is a User, then save as FK and store the id if isinstance(db_object, User): db_object.image = new_file.id db.session.commit() # Elif this is a Payment, then save as many-to-many and we need to append elif isinstance(db_object, Payment): db_object.attachments.append(new_file) db.session.commit()
def submit_task(request, team_name_t): if logged_in(request): if read_access(request,team_name_t): if request.method=="POST": task_object=Task.objects.get(task_id=request.POST['task_id']) task_object.submittion_time=timezone.localtime(timezone.now()) task_object.last_modified_time=timezone.localtime(timezone.now()) task_object.submitted=True task_object.save() uploaded_file = request.FILES['file_submit'] file_text = uploaded_file.read() file_object=File(file_name=uploaded_file.name,task=task_object) with open('files/'+str(file_object.file_id),'w') as f: f.write(file_text) file_object.save() return HttpResponse("<html><h1>Successfully submitted</h1></html>") else: all_tasks = Task.objects.filter(assigned_to=User.objects.get(uname=request.COOKIES.get("username"))) context = { "tasks": all_tasks, "team": str(team_name_t), "round": get_formatted_team_name(team_name_t), } return render(request, 'home/tasks.html', context) else: raise Http404 else: return redirect("/")
def upload_file(): if request.method == 'POST': file = request.files['file'] query = File(name=file.filename) if not re.search(r"\.txt", file.filename): return "error: wrong file format" if File.query.filter_by(name=file.filename).first(): return 'error: file already exists' else: file.save(file.filename) with open('./' + file.filename) as text: lines = [line.rstrip() for line in text] os.remove('./' + file.filename) for line in lines: print(line) reg = re.search(r"\A\+[0-9]{11}\z", line) if not reg: return "error: wrong number " + line db.session.add(query) db.session.commit() for line in lines: filename = File.query.filter_by(name=file.filename).first() query = FileData(number=line, file_id=filename.id) db.session.add(query) db.session.commit() return 'file uploaded successfully'
def upload_file(): user = current_user if request.method == 'POST': new_file = request.files['file'] # if file and allowed_file(file.filename): if new_file: insecure_filename = new_file.filename filename = secure_filename(new_file.filename) upload_folder = app.config['UPLOAD_FOLDER'] user_id = str(current_user.id) unique_part = str(uuid.uuid4()) save_dir = os.path.join(upload_folder, user_id, unique_part) full_path = os.path.join(save_dir, filename) #filename = file.filename if not os.path.exists(save_dir): os.makedirs(save_dir) new_file.save(os.path.join(save_dir, filename)) url = ''.join(['/', full_path]) file = File(filename=insecure_filename, url=url, user_id=current_user.id) db.session.add(file) db.session.commit() # url='/static/uploads/'user.id'/' return render_template('file_uploaded.html', filename=full_path, user=user) else: return render_template('file_upload.html', user=user) return render_template('file_upload.html', user=user)
def files(): """ Uploads a new file if the filename does not exist in the current users filenames. """ if request.method == 'POST': try: file_text = request.form['text'] file = request.files['file'] file_date = request.form['date'] except KeyError: return jsonify({'msg': 'Missing part of your form'}), 400 if file.filename == '': return jsonify({'msg': 'missing file name'}), 400 # Must secure filename before checking if it already exists filename = secure_filename(file.filename) file_names = [file.name for file in current_user.files] if filename in file_names: return jsonify({ 'msg': 'You already have a file with that name. \ File names must be unique' }), 400 if len(file_text) > MAX_FILE_DESC_LEN: return jsonify({ 'msg': 'File description must be less than {} characters'.format( MAX_FILE_DESC_LEN) }), 400 if not allowed_file(file.filename): return jsonify({'msg': 'Invalid file type'}), 400 key_str = "{0}/{1}".format(current_user.username, filename) s3.Bucket(current_app.config['S3_BUCKET']).put_object( Key=key_str, Body=request.files['file'].stream.read()) # Add a new file new_file = File(name=filename, body=file_text, date=file_date, key=key_str, author=current_user) db.session.add(new_file) db.session.commit() return jsonify({'msg': 'Uploaded {0}'.format(filename)}) user_files = [{ 'name': file.name, 'body': file.body, "id": file.id } for file in current_user.files] user_files.reverse() return jsonify({'files': user_files})
def saveFile(f, comment=None, groups=None): checksum = hashlib.md5(f.read()).hexdigest() file_size = writeFile(f, checksum) uploaded = File.query.filter_by(checksum=checksum).first() if not uploaded: uploaded = File(name=secure_filename(f.filename), checksum=checksum, timestamp=datetime.now(), comment=comment, size=file_size) uploaded.account = current_user db.session.add(uploaded) uploaded.groups.extend(groups) try: db.session.commit() except IntegrityError as ex: application.logger.error(ex) db.session.rollback() return False return True
def drive(): if not current_user.verified: return render_template('main/unverified.html') form = FileUploadForm() if form.validate_on_submit(): errors = [] files = request.files.getlist('files') for file in files: file_data = upload_file(current_user, file) if 'error' in file_data: errors.append(file_data['error']) continue file_model = File() file_model.from_dict(file_data) db.session.add(file_model) db.session.commit() for error in errors: flash(error) return redirect(url_for('main.drive')) files = File.query.filter_by(user_id=current_user.id).all() print(files) return render_template('main/drive.html', form=form, files=files)
def create_file(user_id, folder_id, name, text): # Make sure user and folder exist user = User.objects.filter(id=user_id).first() folder = Folder.objects.filter(id=folder_id).first() if not user or not folder: return None # Ensure that the input folder is owned by the input user if folder.owner.id != user.id: return None # Validate that a file with this name does not already exist owned_file_names = [folder.name for folder in folder.owned_files.all()] if name in owned_file_names: return None # Create the new file with transaction.atomic(): new_file = File(name=name, belong=folder) new_file.save() new_content = Content(text=text, version=0, file=new_file) new_content.save() # Serialize new file and content to JSON return FileRepo.to_json(new_file, new_content)
def upload_normal_directory(path): form = UploadDirectoryForm() user = User.query.get(current_user.id) currentFolder = Folder.query.filter_by(id=path).first() if form.validate_on_submit(): emails = form.email.data users = [user] for email in emails.split(","): u = User.query.filter_by(email=email).first() if u and u in currentFolder.AccessFolder: users.append(u) uploaded_files = request.files.getlist("files") for f in uploaded_files: filename = secure_filename(f.filename.split("/")[-1]) uploadFile = File(name=filename, parent=currentFolder, AccessFile=users) db.session.add(uploadFile) db.session.commit() f.save(os.path.join(returnPathOfFolder(currentFolder.id), filename)) return redirect(url_for('index')) return render_template( 'fileModification/upload_normal/upload_normal_directory.html', title='Upload Normal file', form=form, path=path)
def post(self): title = self.request.get('title') link = self.request.get('link') comment = self.request.get('comment') file_post = File(title=title, link=link, comment=comment) file_post.put() self.redirect('/')
async def add_to_db(self): file = File(file_id=self.file_id, file_name=self.file_name, file_key=self.__key) self.__session = self.scoped_session() self.__session.add(file) self.__session.commit() self.scoped_session.remove()
def new_file(file, path, selected_size=None): # We save it file.seek(0) file.save(path) # Convert whatever format this has to UTF-8 convert_file_to_utf8(path) fix_file(path) hash = utils.hash(file) if selected_size is not None: # We get the amount of sentences we want crop_path = "{}.crop".format(path) if offset: crop_proccess = subprocess.Popen( "cat {} " "| head -n {} " "| tail -n {} > {}".format( path, int(offset) + int(selected_size), selected_size, crop_path), shell=True) crop_proccess.wait() else: crop_proccess = subprocess.Popen( "cat {} | head -n {} > {}".format(path, selected_size, crop_path), shell=True) crop_proccess.wait() os.remove(path) shutil.move(crop_path, path) with open(path, 'r') as crop_file: hash = utils.hash(crop_file) # Get file stats wc_output = subprocess.check_output('wc -lwc {}'.format(path), shell=True) wc_output_search = re.search(r'^(\s*)(\d+)(\s+)(\d+)(\s+)(\d+)(.*)$', wc_output.decode("utf-8")) lines, words, chars = wc_output_search.group( 2), wc_output_search.group(4), wc_output_search.group(6) # Save in DB db_file = File(path=path, name=file.filename, user_language_id=language, hash=hash, uploader_id=user_id, lines=lines, words=words, chars=chars, uploaded=datetime.datetime.utcnow()) return db_file
def upload_file(self, file): """ Accepts FileStorage object Saves original uploaded file and serialized DataFrame for this file. Creates records in database :param file: FileStorage :return: IDs of created data set and file """ # Get check sum of file hashed_file_name = f'{self.get_file_checksum(file)}' # Change file name and save it under this name file_extension = self.get_file_extension(file.filename) file_full_name = f'{hashed_file_name}.{file_extension}' file_path = os.path.join(self.files_dir, file_full_name) # Send existing file instead of uploading a new one if file_full_name in self.files: _file = File.query.filter(File.path == file_full_name).first() _dataset = Dataset.query.filter( Dataset.file_id == _file.id).first() logger.info( 'User {0} uploaded which already existed under id {1}'.format( self.user_id, _file.id)) return 'Uploaded', _file.id, _dataset.id file.seek(0) file.save(file_path) # Serialize uploaded file as DataFrame (Update when DataFrame interface is ready) shape = self.serialize(file_full_name) # Get attributes of file file_attributes = self.get_attributes(file_path) file_attributes['name'] = file.filename file_attributes['rows'] = shape[0] file_attributes['cols'] = shape[1] # Save to db, update when dbm is ready new_file = File(path=file_full_name, attributes=file_attributes) db.session.add(new_file) db.session.flush() new_dataset = Dataset(user_id=self.user_id, file_id=new_file.id) db.session.add(new_dataset) db.session.commit() logger.info('User {0} uploaded a new file {1}'.format( self.user_id, new_file.id)) response = { 'file': { 'id': new_file.id, 'name': new_file.attributes['name'], 'size': new_file.attributes['size'], 'rows': new_file.attributes['rows'] }, 'dataset_id': new_dataset.id } return response
def uploaded_file(fileID): file = File().query.get(int(fileID)) if file is None or file.user_id != current_user.id: flash("You don't have permission to view this page !", 'error') else: fileurl = 'https://chemicallocha.herokuapp.com/site/uploads/' + file.filename return render_template('site/fileupload.html', title='File Uploaded Successfully', filename=file.filename, fileurl=fileurl)