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 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 update_user_info(): """ Input - profile_picture (optional): base64 of the profile picture. Set to null to remove the profile picture - name (optional) """ user = g.user data = request.get_json() or {} if "profile_picture" in data: if data["profile_picture"] is None: if user.profile_picture_id: file = user.profile_picture user.profile_picture_id = None Session.flush() if file: File.delete(file.id) s3.delete(file.path) Session.flush() else: raw_data = base64.decodebytes(data["profile_picture"].encode()) file_path = random_string(30) file = File.create(user_id=user.id, path=file_path) Session.flush() s3.upload_from_bytesio(file_path, BytesIO(raw_data)) user.profile_picture_id = file.id Session.flush() if "name" in data: user.name = data["name"] Session.commit() return jsonify(user_to_dict(user))
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 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 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 zip_upload(file): """ Save the uploaded file as a zip file """ app.logger.warn('generating zip from upload') if not file: return None # Allow uploading zip file. if file.filename.endswith('.zip'): app.logger.warn('zip file, validate contents') zipFile = ZipFile(file.stream, 'r', ZIP_DEFLATED) if (len(zipFile.infolist()) != 1): app.logger.error('wrong number of files in zip') raise BadRequest('ZIP uploads must contain exactly one file') app.logger.warn('valid zip') return File.fromUpload(file, File.MODELS_DIR) # Zip source file & save to large file storage app.logger.warn('create empty zip') zip = File.fromName(file.filename + '.zip', File.MODELS_DIR) zip.mime_type = 'application/zip' filename, fileExt = os.path.splitext(file.filename) with tempfile.NamedTemporaryFile(suffix=fileExt) as uploadFile: app.logger.warn('save upload to temp') file.save(uploadFile.name) with ZipFile(zip.getAbsolutePath(), 'w', ZIP_DEFLATED) as zipFile: app.logger.warn('write temp file to zip') zipFile.write(uploadFile.name, file.filename) app.logger.warn('set zip size') zip.size = os.stat(zip.getAbsolutePath()).st_size app.logger.warn('generated zip') return zip
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 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 mutate(self, info, **kwargs): user = info.context.user post = {} if "content" in kwargs: post["content"] = kwargs["content"] if "picture" in kwargs: picture = File.filter_permissions( File.objects, File.permission_filters(user))\ .get(pk=kwargs["picture"]) post["picture"] = picture if "createdBy" in kwargs: created_by = User.filter_permissions( User.objects, User.permission_filters(user))\ .get(pk=kwargs["createdBy"]) post["created_by"] = created_by post = Post.objects.create(**post) if "likedBy" in kwargs: post.liked_by.clear() for liked_by_id in kwargs["likedBy"]: liked_by = User.filter_permissions( User.objects, User.permission_filters(user))\ .get(pk=liked_by_id) post.liked_by.add(liked_by) post.save() return SavePostMutation(post=post)
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 init(): '''Init the database''' db.drop_all() db.create_all() Role.insert_roles() u = User(email='*****@*****.**', nickname='Admin', password='******', confirmed=True, role=Role.query.filter_by(name='Administrator').first(), about_me='Wait for updating') db.session.add(u) u = User(email='*****@*****.**', nickname='testuser', password='******', confirmed=True, role=Role.query.filter_by(name='User').first(), about_me='this is a test user') db.session.add(u) db.session.commit() CFILE.generate_fake(5) # 随机生成 5 个 实体文件 User.generate_fake(5) # 随机生成 5 个 用户 File.generate_fake(100) # 随机生成 100 条文件记录 Comment.generate_fake(70) # 随机生成 100 条评论 Message.generate_fake(100) # 随机生成 100 条消息
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_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_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 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 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 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 post(self): file = request.files['file'] f = File() f.set_file(file) db.session.add(f) db.session.commit() return f, 201
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('/')
def validate(self): """ Uploads the file :return: "upload.html" """ file_path = FilesPath() # Set file model attributes file = self.form.file.data filename = self.form.filename.data or file.filename repo = self.form.repo.data ext = file_path.get_ext(filename=filename.lower()) # Create dir if not file_path.isdir(): file_path.newdir() user = User.query.filter_by(username=current_user.username).first() file_db = File(filename=filename, repo=repo, uploader=user) db = Database() db.add(file_db) type = None ext_list = [Extensions.document_list, Extensions.image_list, Extensions.audio_list, Extensions.video_list] if any(ext in ext_check for ext_check in ext_list): token = Tokens(length=7) filename_save = str(file_db.id) + ext if ext in ext_list[0]: type = "document" elif ext in ext_list[1]: type = "image" elif ext in ext_list[2]: type = "audio" elif ext in ext_list[3]: type = "video" file_db.type = type token_db = Token(token=token.token, type=type, auth=user, file=file_db) db.add(file_db, token_db) else: type = "misc" filename_save = str(file_db.id) if file_db.repo == "public": file_db.path = file_path.public(filename=filename_save, type=type) db.add(file_db) file.save(file_path.public(filename=filename_save, type=type)) elif file_db.repo == "private": file_db.path = file_path.private(filename=filename_save, type=type) db.add(file_db) file.save(file_path.private(filename=filename_save, type=type)) flash('File {} uploaded successfully!'.format(file.filename)) return url_for('upload')
def file_view(request, filename=None): if request.method == 'GET': if request.user.is_authenticated: files = File.objects.filter( Q(owner=request.user) | Q(private=False)) else: files = File.objects.filter(private=False) if 'search' in request.GET: files = files.filter(name__icontains=request.GET['search']) if filename: try: file = files.get(unique_name=filename) except ObjectDoesNotExist: file = None file_full_path = os.path.join(settings.MEDIA_ROOT, filename) if file and os.path.isfile(file_full_path): response = StreamingHttpResponse( (line for line in open(file_full_path, 'rb'))) response[ 'Content-Disposition'] = "attachment; filename={0}".format( file.name) response['Content-Length'] = os.path.getsize(file_full_path) return response else: return JsonResponse( {'error': 'The file is not found or is deleted.'}) else: files = files.order_by('-create') return JsonResponse(list(files), encoder=UploaderEncoder, safe=False) elif request.method == 'POST': if 'file' not in request.FILES or 'private' not in request.POST: return JsonResponse( { 'error': "Please provide the file and whether it should be private." }, status=400) file = request.FILES['file'] is_private = json.loads(request.POST['private']) fs = FileSystemStorage(location=settings.MEDIA_ROOT) filename = fs.save(file.name, file) f = File(owner=request.user, name=file.name, private=is_private, unique_name=filename) f.save() return JsonResponse(f, encoder=UploaderEncoder, safe=False)
def create_file(name, username, user_id, id=0, desc=""): try: file = File(id=id, name=name, key="{0}/{1}".format(username, name), body=desc) file.user_id = user_id return file except Exception as err: print("Unexpected error creating File: ", err) raise
def index_file(filename): f = File(filename) filepath = os.path.join(app.root_path, app.config['FILE_FOLDER'], filename) try: st = os.stat(filepath) f.size = st[ST_SIZE] except IOError: pass db.session.add(f) db.session.commit()
def save_photo(update, context): """ Add given photo to current directory """ # create new record about the file in the DB photo = File(telegram_id=update.message.message_id) photo.save() # attach new file to current directory directory = Directory.objects.get( name=context.chat_data.get('current_directory'), user_id=Directory.encrypt_user_id(update.effective_user.id)) directory.update(add_to_set__contains_files=photo) directory.save() update.message.reply_text( f'Your file now live in directory {directory.name}')
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 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 handle(self, *args, **options): source = options['source'] if not source or not os.path.exists(os.path.expanduser(source)): raise Exception('{0} is not a valid CSV path'.format(source)) functions = set() files = set() with open(source) as file_: reader = csv.reader(file_) for row in reader: if 'Function' in row[0]: name = row[1] file = row[2] sloc = int(row[3]) function = Function() function.name = name function.file = file function.sloc = sloc if function not in functions: functions.add(function) else: functions = self._update(function, functions) elif 'File' in row[0]: name = row[2] sloc = int(row[3]) file_ = File() file_.name = name file_.sloc = sloc if file_ not in files: files.add(file_) else: files = self._update(file_, files) if len(functions) > 0: logger.debug('Adding {0} functions.'.format(len(functions))) Function.objects.bulk_create(functions) logger.info('Loaded {0} functions.'.format(len(functions))) if len(files) > 0: logger.debug('Adding {0} files.'.format(len(files))) File.objects.bulk_create(files) logger.info('Loaded {0} files.'.format(len(files)))
def prepare(mode): if mode == "append": fmode = "a" elif mode == "refresh": fmode = "w" else: return "Wrong mode specifier" # Get data as strings data = json.loads(request.data.decode('utf-8')) username = data['user'] user = db.session.query(User).filter_by(username=username).scalar() if not user: return "User can't be found" raw = data['raw'].encode('utf-8') key = user.key encoder = Fernet(key) # Check credentials raw = encoder.decrypt(raw).decode('utf-8') if not raw.startswith(username): return "Auth error" else: raw = raw[len(username):] info = json.loads(raw) # Create project if doesn't exist project_name = info[0] pr = user.projects.filter_by(name=project_name).scalar() if not pr: pr = Project(name=project_name, user_id=user.id) db.session.add(pr) file_names = info[1] bad_files = pr.files.filter(~File.name.in_(file_names)).all() for file in bad_files: path = file.get_path() if os.path.exists(path): os.remove(path) db.session.delete(file) for fname in file_names: file = pr.files.filter_by(name=fname).scalar() if not file: file = File(name=fname, project_id=pr.id) db.session.add(file) open(file.get_path(), fmode).close() db.session.commit() return "Project is ready for work"
def post(self, filename): extension = filename.split('.')[-1] f = File() db.session.add(f) db.session.commit() with open( os.path.join(app.config['UPLOAD_DIRECTORY'], '.'.join([str(f.id), extension])), "wb") as file: file.write(request.data) response = jsonify(f.as_dict()) response.status_code = 201 f.extension = extension thread = threading.Thread(f.process()) thread.start() return response
def tcm_exclusions(): page = request.args.get("page", 1, type=int) quality_threshold = (db.session.query(RefQuality.preference).filter( RefQuality.quality_title == "HDTV-720p").subquery()) ranked_files = File.get_ranked_files() library = (db.session.query(File, Movie, RefQuality).outerjoin( Movie, (Movie.id == File.movie_id)).join( RefQuality, (RefQuality.id == File.quality_id)).join( ranked_files, (ranked_files.c.id == File.id)).filter( File.feature_type == None).filter( ranked_files.c.rank == 1).filter( RefQuality.preference >= quality_threshold.c.preference).filter( File.media_library == "Movies").order_by( File.plex_filename).paginate( page, current_app.config["RESULTS_PER_PAGE"], False)) prev_url = (url_for("main.tcm_exclusions", page=library.prev_num) if library.has_prev else None) next_url = (url_for("main.tcm_exclusions", page=library.next_num) if library.has_next else None) return render_template( "tcm_exclusions.html", title="TCM Exclusion List", library=library.items, prev_url=prev_url, next_url=next_url, )
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 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 test_import_no_mailboxes(flask_client): # Create user user = login(flask_client) # Check start state assert len(Alias.filter_by(user_id=user.id).all()) == 1 # Onboarding alias # Create domain CustomDomain.create( user_id=user.id, domain="my-domain.com", ownership_verified=True ) Session.commit() alias_data = [ "alias,note", "[email protected],Used on eBay", '[email protected],"Used on Facebook, Instagram."', ] file = File.create(path="/test", commit=True) batch_import = BatchImport.create(user_id=user.id, file_id=file.id) import_from_csv(batch_import, user, alias_data) assert len(Alias.filter_by(user_id=user.id).all()) == 3 # +2
def mytask(request, team_name_t): if logged_in(request): if read_access(request,team_name_t): if request.method=='POST': task_object=Task.objects.get( assigned_to=User.objects.get(uname=request.COOKIES['username']), 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() if not 'file_submit' in request.FILES: return HttpResponse("<html><h1>No file selected</h1></html>") uploaded_file = request.FILES['file_submit'] file_text = uploaded_file.read() if File.objects.filter(task=task_object,file_name=uploaded_file.name).exists(): file_object=File.objects.get(task=task_object,file_name=uploaded_file.name) file_object.accepted=False file_object.submitted_time=timezone.localtime(timezone.now()) file_object.save() else: file_object=File(file_name=uploaded_file.name,task=task_object,tags=request.POST['tags']) file_object.save() f = open('files/'+str(file_object.file_id),'w+') f.write(file_text) f.close() return HttpResponse("<html><h1>File Submitted</h1></html>") my_tasks = Task.objects.prefetch_related('file_set').filter( assigned_to=User.objects.get(uname=request.COOKIES.get("username")), team=Team.objects.get(team_name=team_name_t) ).order_by('-task_id') context = { "team": team_name_t, "tasks": my_tasks, "user": User.objects.get(uname=request.COOKIES['username']), "round": get_formatted_team_name(team_name_t), "is_admin": is_admin(request,team_name_t), } return render(request, 'home/mytask.html', context) else: raise Http404 else: return redirect("/")
def images_index(request): query = __store_session_query(request, File.get_all_images()) try: del request.session['random_list'] except KeyError: pass per_page = 24 paginator = Paginator(query, per_page) page = request.GET.get('page') try: files = paginator.page(page) except PageNotAnInteger: files = paginator.page(1) page = 1 except EmptyPage: files = paginator.page(paginator.num_pages) page = paginator.num_pages page = int(page) page_range = [] threshold = 10 threshold_size = (threshold*2) + 1 # build initial page range list for i in xrange(1, paginator.num_pages+1): if i+threshold >= page and i <= page: page_range.append(i) elif i-threshold <= page and i >= page: page_range.append(i) # if the length of page_range is less than the threshold size, add to it if len(page_range) < threshold_size: if page <= threshold: i = page_range[-1] while len(page_range) < threshold_size and i < paginator.num_pages: i = i + 1 page_range.append(i) else: i = page_range[0] while len(page_range) < threshold_size and i > 1: i = i - 1 page_range.insert(0, i) if page_range[0] != 1: page_range.insert(0, '...') if page_range[-1] != paginator.num_pages: page_range.append('...') i = per_page * (page-1) + 1 for f in files: f.num = i i = i + 1 context = {'files': files, 'page_range': page_range} if request.GET.get('view') == 'list': context['view'] = 'list' return render(request, 'images/index.html', context)
def uploader(request): form = FileForm() if request.method == 'POST': if form.validate(request.form, request.files): file = File(comment=form['comment'], tags=form['tags'], name=request.files['file'].filename) file.put() data = form['file'] chunk_size = 1000000 for i in xrange(int(len(data)/chunk_size)+1): chunk = Chunk(file=file, data=data[i*chunk_size:(i+1)*chunk_size], index=i) chunk.put() return redirect(url_for('app/uploader')) query = File.all().order('-created') files = create_paginator_page(request, query) return render_to_response('app/uploader/index.html', {'files': files, 'paginator': render_paginator(files), 'form': form.as_widget()})
def sendRequestgetJSON(idProject): """First request to getJSON""" fileURL = idProject + ".json" #http://sarabc.pencilcode.net/load/first.json print fileURL # Create DB of files now = datetime.now() fileName = File (filename = fileURL, method = "url", time = now, score = 0, abstraction = 0, parallelism = 0, logic = 0, synchronization = 0, flowControl = 0, userInteractivity = 0, dataRepresentation = 0) print "GUARDADO EN LA BASE DE DATOS --> ", fileName # Guardamos en la base de datos. fileName.save() dir_zips = os.path.dirname(os.path.dirname(__file__)) + "/uploads/" fileSaved = dir_zips + str(fileName.id) + ".json" #fileName.id -> models añaden el campo id automaticamente. # /home/sara/drPencilcode-master/uploads/15.json # Log 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) # /home/sara/drPencilcode-master/uploads/15.json outputFile = open(file_name, 'wb') # print "Retrieving: ", idProject jsonFile = urllib2.urlopen(idProject) # http://sarabc.pencilcode.net/load/first # abre la url(urlopen) y lee los datos de esa url(urllib2). outputFile.write(jsonFile.read()) outputFile.close() #lo escribe todo en un .json. return (file_name, fileName)
def index(): file_names = [] file_paths = [] files_ = File.get_all() for f in files_: file_names.append(f.file_name) file_paths.append(f.file_path) # pages = [i for i in range(int(len(file_names)/20))] return render_template( 'index.html', files=zip(file_names, file_paths))
def save(self): filename = self.f with open(self.path, 'wb') as f: f.write(self.f.value) if not self.id: entry = File() entry.name = self.filename entry.type = self.type entry.base = self.base entry.filename = self.base + self.ext entry.size = len(self.f.value) entry.mime = self.mimetype entry.save() self.id = entry.id return self.base
def download_file(url, user, password, filename, dest, strongest_site_id): """ Download a specific file. If the file is already downloaded ask the user if the file shoule be downloaded again """ from ftplib import FTP from datetime import date from app.models import File from app import db name = '{}.xml'.format(date.today()) dest = '{}'.format(os.path.join(dest, name)) f = File(name=name, path=dest) try: ftp = FTP(host=url, user=user, passwd=password) except Exception as e: logger.error("There was an error when loggin to ftp server {}".format(e)) f.error = True f.error_message = "{}".format(e) db.session.add(f) db.session.commit() raise FTPError(e) logger.debug("Filename: {}".format(filename)) cmd = 'RETR {}'.format(filename) logger.debug("CMD {}".format(cmd)) logger.info("Start Downloading file {}".format(filename)) file = open(dest, 'wb') try: ftp.retrbinary(cmd, file.write, blocksize=2048) except Exception as e: f.error = True f.error_message = "{}".format(e) db.session.add(f) db.session.commit() raise FTPError(e) logger.info("File successfully downloaded") f.error = False db.session.add(f) db.session.commit() # Import file import_xml.delay(f.id, strongest_site_id) logger.info("Start import the downloaded file")
def uploader_delete(request, id): file = File.get_by_id(id) if request.user == file.user or request.user.id_admin: db.delete(file.chunks) db.delete(file) return redirect(url_for('app/uploader'))
def get_file(base): try: f = File.get(File.base == base) except File.DoesNotExist: return None return f
def uploader_download(request, id, filename): file = File.get_by_id(id) data = ''.join(chunk.data for chunk in file.chunks.order('index')) return Response(mimetype=mimetypes.guess_type(file.name)[0], response=data)
def uploadUnregistered(request): """Upload file from form POST for unregistered users""" if request.method == 'POST': #Revise the form in main #If user doesn't complete all the fields,it'll show a warning try: file = request.FILES['zipFile'] except: d = {'Error': 'MultiValueDict'} return d # Create DB of files now = datetime.now() fileName = File (filename = file.name.encode('utf-8'), method = "project" , time = now) fileName.save() dir_zips = os.path.dirname(os.path.dirname(__file__)) + "/uploads/" # Version of Scratch 1.4Vs2.0 version = checkVersion(fileName.filename) if version == "1.4": fileSaved = dir_zips + str(fileName.id) + ".sb" else: fileSaved = dir_zips + str(fileName.id) + ".sb2" # Create log 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) with open(file_name, 'wb+') as destination: for chunk in file.chunks(): destination.write(chunk) #Create 2.0Scratch's File file_name = changeVersion(request, file_name) # Analyze the scratch project try: d = analyzeProject(request, file_name) except: #There ir an error with kutz or hairball #We save the project in folder called error_analyzing fileName.method = 'project/error' fileName.save() oldPathProject = fileSaved newPathProject = fileSaved.split("/uploads/")[0] + \ "/error_analyzing/" + \ fileSaved.split("/uploads/")[1] shutil.copy(oldPathProject, newPathProject) d = {'Error': 'analyzing'} return d # Show the dashboard # Redirect to dashboard for unregistered user d['Error'] = 'None' return d else: return HttpResponseRedirect('/')
def uploader_check_delete(request, id): return render_to_response('app/uploader/delete.html', {'file': File.get_by_id(id)})
thumb_dir = mk_md5_dir(md5, settings.MAIO_SETTINGS['thumbnail_directory']) thumb = os.path.join(thumb_dir, md5 + '.jpg') if not os.path.isfile(thumb): im.thumbnail((128, 128), Image.ANTIALIAS) im.save(thumb) print md5sum.hexdigest(), mimetype, file_path # save file information to the database try: file_path_hash = hashlib.md5() file_path_hash.update(file_path.encode('utf-8')) fph = file_path_hash.hexdigest() f = File(mime_type=mimetype, size=sfile.st_size, mtime=sfile.st_mtime, md5sum=md5, tn_path=thumb, file_path=file_path, file_path_hash=fph) f.save() except django.db.utils.IntegrityError: f = File.objects.get(file_path_hash=fph) if sfile.st_mtime == f.mtime: print "Already in database and up-to-date, skipping %s ..." % (file_path,) continue f.mime_type = mimetype f.size = sfile.st_size f.mtime = sfile.st_mtime f.md5sum = md5 f.tn_path = thumb f.save() except: raise