def download():
'''Grabs the latest.'''
# Download Files
date_str = date.today().strftime("%Y_%m_%d")
new_folder_path = "data/downloaded_%s" % date_str
download_files(new_folder_path)
# Delete if already exist in database
for path, subdirs, files in os.walk(new_folder_path):
for f in files:
if already_downloaded(path + '/' + f):
print "Didn't save '%s' because it was already in the database." % f
os.remove(path + '/' + f)
else:
print "Saved new file '%s/%s'" % (path, f)
File.create(
name = f,
years=next(re.finditer(r'\d{4}_\d{4}', f)),
sha1 = sha1OfFile(path + '/' + f),
updated = date.today(),
ingested = False
)
async def file_create(token: Optional[str] = Header(None), file: bytes = FastFile(...)):
print(token, len(file))
"""
创建文件
"""
user = security.get_current_user(token)
file = File.create('', '', user.id, file, '')
return {"file": file.id}
def folder(folder_name):
try:
folder = Folder.get(Folder.name == folder_name)
except peewee.DoesNotExist:
return jsonify(message="error"), 404
if request.method == "GET":
return jsonify(message="OK", data=model_to_dict(folder, backrefs=True))
if request.method == "POST":
f = request.files["file"]
if f:
actual_filename = generate_filename(folder_name, f.filename)
target_file = os.path.join(
os.path.expanduser(config.UPLOAD_FOLDER), actual_filename)
if os.path.exists(target_file):
return jsonify(message="error"), 409
try:
f.save(target_file)
f2 = File.create(folder=folder,
filename=f.filename,
public_share_url=generate_url(),
open_public_share=False)
f2.save()
except Exception as e:
print(e)
return jsonify(message="error"), 500
return jsonify(message="OK"), 201
if request.method == "DELETE":
try:
for f in folder.files:
actual_filename = generate_filename(folder_name, f.filename)
target_file = os.path.join(
os.path.expanduser(config.UPLOAD_FOLDER), actual_filename)
f2 = File.get(File.filename == f.filename)
f2.delete_instance()
if os.path.exists(target_file):
os.remove(target_file)
folder.delete_instance()
except Exception as e:
return jsonify(message="error"), 409
return jsonify(message="OK")
def folder(folder_name):
try:
f = Folder.get(name=folder_name)
except peewee.DoesNotExist:
return jsonify(message='error'), 404
if request.method == 'POST':
file = request.files['file']
if file:
actual_filename = secure_filename(
folder_name + '_' + file.filename)
if os.path.exists(os.path.join(app.config['UPLOAD_FOLDER'], actual_filename)):
return jsonify(message='error'), 409
file.save(
os.path.join(app.config['UPLOAD_FOLDER'], actual_filename))
f2 = File.create(folder=folder_name,
filename=file.filename,
public_share_url=generate_url(),
private_share_url=generate_url(),
private_share_password=generate_password(),
open_public_share=False,
open_private_share=False)
f2.save()
return jsonify(message='OK'), 201
if request.method == 'GET':
files = File.select().where(File.folder == folder_name)
items = [{
'filename': x.filename,
'public': x.public_share_url,
'private': x.private_share_url,
'password': x.private_share_password,
'openPublic': x.open_public_share,
'openPrivate': x.open_private_share
} for x in files]
return jsonify(message='OK', items=items)
if request.method == 'DELETE':
try:
f.delete_instance()
except peewee.IntegrityError:
return jsonify(message='error'), 409
return jsonify(message='OK')
def add_file(**kwargs):
file = File.create(**kwargs)
return file
def create_file(args):
fingerprint = user = None
if args.authorization is not None:
try:
user = helpers.get_user(args.authorization)
except:
raise ApiError('Invalid Authentication')
if args.fingerprint is not None and user is None:
fingerprint = args.fingerprint
min_vanity = max_vanity = args.vanity.count('/')
for part in args.vanity.split('/'):
minv, maxv = parse_vanity_part(part)
min_vanity += minv
max_vanity += maxv
if min_vanity < MIN_VANITY_LENGTH or MAX_VANITY_LENGTH < max_vanity:
raise ApiError(
'Vanity has to be at least or in between {} and {} characters long'
.format(MIN_VANITY_LENGTH, MAX_VANITY_LENGTH))
fextension = None
if args.type == 'multipart':
storage = next(request.files.values(), None)
if storage is None:
raise ApiError('A file must be uploaded')
if args.filename is None:
args.filename = storage.filename
else:
# get original extension from uploaded file
# just incase we generate filename in future
if '.' in storage.filename:
fextension = storage.filename.split('.')[-1]
mimetype = storage.mimetype
stream = storage.stream
stream.seek(0, 2)
fsize = stream.tell()
stream.seek(0)
elif args.type == 'raw':
mimetype = request.mimetype
stream = request.stream
fsize = request.content_length
else:
raise ApiError('Invalid Upload Type')
#check filesize
fname = None
if args.filename is None:
fname = [generate_vanity()]
else:
fname = args.filename.split('.')
if 1 < len(fname):
# do we want to use the original filename's extension all the time?
if fextension is None:
fextension = fname.pop(-1)
elif fextension.lower() == fname[-1].lower():
fextension = fname.pop(-1)
mime = Mimetype.get_or_none(id=mimetype)
if mime is None:
if fextension is None:
raise InvalidMimetype()
mextension = MimetypeExtension.get_or_none(
extension=fextension.lower())
if mextension is None:
raise InvalidMimetype()
# mime = mextension.mime
mimetype = mextension.mimetype_id
else:
# use extension to determine filetype
if mime.id == 'application/octet-stream':
if fextension is not None:
mextension = MimetypeExtension.get_or_none(
extension=fextension.lower())
if mextension is not None:
mimetype = mextension.mimetype_id
# check flags
if fextension is not None:
mextension = MimetypeExtension.get_or_none(
mimetype=mimetype, extension=fextension.lower())
# keep extension incase its not found
if mextension is None:
fname.append(fextension)
fextension = None
else:
# set it to the stored version, just this or fextension.lower()
fextension = mextension.extension
if fextension is None:
mextension = (MimetypeExtension.select().where(
MimetypeExtension.mimetype == mimetype).order_by(
MimetypeExtension.priority.desc()).limit(1).execute())
if mextension:
fextension = mextension[0].extension
else:
if mimetype.endswith('+json'):
fextension = 'json'
elif mimetype.endswith('+xml'):
fextension = 'xml'
fname = '.'.join(fname)[:256] # just incase they send a huge text lol
while '{random}' in fname:
fname = fname.replace('{random}', generate_vanity(), 1)
fname = re.sub(FILENAME_REGEX, '_', fname[:128])
# we read the filedata now to get the hashes of it
fdata = stream.read(fsize)
hblake2b = hashlib.blake2b(fdata).hexdigest()
hmd5 = hashlib.md5(fdata).hexdigest()
hsha1 = hashlib.sha1(fdata).hexdigest()
fid = Snowflake.generate()
fhash = FileHash.get_or_none(blake2b=hblake2b, md5=hmd5, sha1=hsha1)
if fhash is None:
fhash = FileHash.create(
id=Snowflake.generate(),
blake2b=hblake2b,
md5=hmd5,
sha1=hsha1,
size=fsize,
)
# upload it now
bucket = current_app.gcs.get_bucket(current_app.config.storage_bucket)
blob = bucket.blob('files/{}'.format(fhash.id))
blob.upload_from_string(fdata,
content_type='application/octet-stream',
predefined_acl='publicRead')
unique = False
while not unique:
fvanity = generate_vanity(args.vanity)
unique = bool(File.get_or_none(vanity=fvanity) is None)
fobj = File.create(
id=fid,
vanity=fvanity,
mimetype=mimetype,
extension=fextension,
filename=fname,
hash=fhash,
user=user,
fingerprint=fingerprint,
)
return ApiResponse(fobj.to_dict())
users[0].email = '*****@*****.**'
print(classes[0])
print(users[1].classes)
users[1].classes.append(classes[0])
users[2].user_classes.append(UserClass(classes[0], users[2], 'teacher'))
session.add_all(users)
session.add_all(classes)
session.commit()
mimi = User.create('*****@*****.**', '123456')
mimi.name = 'Mimi'
file1 = File.create('image.png', '', mimi.id, b'12345', 'image/png')
file2 = File.create('image.png', '', mimi.id, b'67890', 'image/png')
print(File.get_file_by_id(file1.id))
print(File.get_files_by_owner(mimi.id))
file1.update(file1.name, 'This is an image', file1.owner, file1.content,
file1.mime)
print(file1.description)
session.commit()
for instance in session.query(User).order_by(User.id):
print(instance)
print(User.get_user_by_name('Mimi2'))
