def delete(self, pk):
ins = self._self.model.query.filter_by(**{
self._self.pk: pk
}).get_or_404()
serializer = self._self.serializer(ins)
ins.delete()
return HTTP.OK(data=serializer.data)
def post(self):
post_data = request.data
nullable_columns = self._self.column.nullable_columns
unique_columns = self._self.column.unique_columns
notnullable_columns = self._self.column.notnullable_columns
for column in notnullable_columns:
if column.name not in post_data:
return jsonify(msg='{} is required'.format(column.name))
for column in unique_columns:
name = column.name
if self._self.model.query.filter_by(**{
name: post_data.get(name)
}).exists():
return jsonify(msg='{} is exists'.format(name))
params = {
column.name: post_data.get(column.name)
for column in notnullable_columns
}
params.update(
**{
column.name: post_data.get(column.name)
for column in nullable_columns if column.name in post_data
})
instance = self._self.model(**params)
self._set_releation_columns(instance, post_data)
instance.save()
serializer = self._self.serializer(instance)
return HTTP.OK(data=serializer.data)
def get(self, pk):
'''
显示图片
'''
user = request.user
image = Image.query.filter_by(id=pk, user=user).get_or_404('图片不存在')
serializer = ImageSerializer(image)
return HTTP.OK(data=serializer.data)
def get(self, pk):
'''
获取具体相册
'''
user = request.user
album = Album.query.filter_by(id=pk, user=user).get_or_404('相册不存在')
serializer = AlbumSerializer(album)
return HTTP.OK(data=serializer.data)
def get(self):
data = request.data
user = request.user
page, number = self.pageinfo
params = filter_maybe(data, {"name": "name__contains"})
ins = user.buckets.filter_by(**params).paginate(page, number)
serializer = BucketSerializer(ins)
return HTTP.OK(data=serializer.data)
def post(self, bucket):
user = request.user
bucket = user.buckets.filter_by(
name=bucket).get_or_404("bucket not found")
path = request.data["path"]
filepath = bucket.get_root_path(path, True)
serializer = FilePathSerializer(filepath)
return HTTP.OK(data=serializer.data)
def get(self):
data = request.data
page, number = self.pageinfo
params = filter_maybe(data, {"username": "******"})
ins = User.query.filter_by(**params).paginate(page, number, False)
rep = Serializer(
ins,
exclude=["articles", "buckets", "timelines"],
).data
return HTTP.OK(data=rep, pageinfo=ins.pages)
def put(self, pk):
user = request.user
data = request.data
ins = user.buckets.filter_by(id=pk).get_or_404("bucket not found")
ins = update_maybe(ins, data, ["name", "description"])
ins.save()
rep = BucketSerializer(ins).data
return HTTP.OK(data=rep)
def get(self):
page, number = self.pageinfo
filter_dict = {'is_hidden': False}
order_by = ('-created_at', )
timelines = TimeLine.query.filter_by(**filter_dict).order_by(
*order_by).paginate(page, number)
serializer = Serializer(timelines,
exclude=['user', 'user_id', 'is_hidden'],
extra=['datetime_format'])
return HTTP.OK(data=serializer.data)
def post(self):
data = request.data
username = data['username']
password = data['password']
remember = data.pop('remember', True)
user = User.query.filter_by(username=username).first()
if not user or not user.check_password(password):
return HTTP.BAD_REQUEST(message=_('Username or Password Error'))
user.login(remember)
return HTTP.OK(data={"username": user.username, "token": user.token})
def post(self):
request_data = request.data
password = request_data.pop('password', '')
content = request_data.pop('content', '')
if not password or not content:
return HTTP.BAD_REQUEST(message="params required.")
ec = Encrypt(password, current_app.config['SECRET_KEY_SALT'])
try:
return HTTP.OK(data=ec.decrypt(content))
except InvalidToken:
return HTTP.BAD_REQUEST(message="password is not correct")
def get(self):
_self = self._self
query_dict = request.data
page, number = self.pageinfo
filter_params = _self.get_filter_params(query_dict)
orderby_params = _self.get_orderby_params(query_dict)
instances = _self.get_instances(filter_params, orderby_params, page,
number)
serializer = _self.serializer(instances)
pageinfo = PageInfo(instances).as_dict()
return HTTP.OK(data=serializer.data, pageinfo=pageinfo)
def post(self):
data = request.data
user = request.user
ins = Article(
title=data["title"],
content=data["content"],
user_id=user.id,
)
ins.save()
serializer = ArticleSerializer(ins)
return HTTP.OK(data=serializer.data)
def put(self, bucket):
data = request.data
user = request.user
bucket = user.buckets.filter_by(
name=bucket).get_or_404("bucket not found")
path = data["path"]
filepath = bucket.get_root_path(path)
if not filepath or filepath.is_root_path:
msg = "{0} path not found"
return HTTP.BAD_REQUEST(message=msg)
action = data.get("action", "rename")
if action not in ["rename", "move", "copy"]:
return HTTP.BAD_REQUEST()
if action == "rename":
newname = data.get("newname")
if not newname or newname == filepath.name:
return HTTP.OK(message="filepath not change")
serializer = FilePathSerializer(filepath.rename(newname))
return HTTP.OK(data=serializer.data)
newpath = data.get("newpath")
if not newpath:
return HTTP.BAD_REQUEST(message="newpath is required")
newfilepath = bucket.get_root_path(newpath)
if not newfilepath:
msg = "{0} path not found"
return HTTP.BAD_REQUEST(message=msg)
if action == "move":
nfilepath = filepath.move(newfilepath)
else:
nfilepath = filepath.copy(newfilepath)
serializer = FilePathSerializer(nfilepath)
return HTTP.OK(data=serializer.data)
def post(self):
post_data = request.json
username = post_data['username']
password = post_data['password']
remember = post_data.pop('remember', True)
user = User.query.filter_by(username=username).first()
if not user or not user.check_password(password):
msg = _('Username or Password Error')
return HTTP.BAD_REQUEST(message=msg)
user.login(remember)
serializer = user.serializer() if hasattr(
user, 'serializer') else Serializer(user, depth=1)
return HTTP.OK(data=serializer.data)
def delete(self, bucket):
data = request.data
user = request.user
bucket = user.buckets.filter_by(
name=bucket).get_or_404("bucket not found")
path = data["path"]
filepath = bucket.get_root_path(path)
if not filepath:
msg = "{0} path not found"
return HTTP.BAD_REQUEST(message=msg)
filepath.delete()
return HTTP.OK()
def post(self):
data = request.data
name = data.get('name')
description = data.get('description')
if Bucket.query.filter_by(name=name).exists():
return HTTP.BAD_REQUEST(message="bucket is exists")
bucket = Bucket(name=name)
if description:
bucket.description = description
bucket.save()
rep = BucketSerializer(bucket).data
return HTTP.OK(data=rep)
def get(self):
'''
获取相册列表
'''
query_dict = request.data
user = request.user
page, number = self.page_info
keys = ['name', 'description']
order_by = gen_order_by(query_dict, keys)
filter_dict = gen_filter_dict(query_dict, keys, user=user)
albums = Album.query.filter_by(
**filter_dict).order_by(*order_by).paginate(page, number)
serializer = AlbumSerializer(albums.items, True)
pageinfo = PageInfo(albums)
return HTTP.OK(data=serializer.data, pageinfo=pageinfo)
def post(self):
post_data = request.json
email = post_data['email']
user = User.query.filter_by(email=email).first()
if not user:
msg = _('The email is error')
return HTTP.BAD_REQUEST(message=msg)
password = ''.join(sample(ascii_letters + digits, 8))
user.set_password(password)
user.save()
self.send_email(user, password)
flash(
_('An email has been sent to you.'
'Please receive and update your password in time'))
return HTTP.OK()
def post(self):
'''
登陆
'''
post_data = request.data
username = post_data.pop('username', None)
password = post_data.pop('password', None)
remember = post_data.pop('remember', True)
if username and password:
user = User.query.filter_by(username=username).first()
if user and user.check_password(password):
user.login(remember)
serializer = UserSerializer(user)
return HTTP.OK(data=serializer.data)
return HTTP.UNAUTHORIZED(message='用户名或密码错误')
def get(self, bucket):
data = request.data
user = request.user
page, number = self.pageinfo
bucket = user.buckets.filter_by(
name=bucket).get_or_404("bucket not found")
path = request.data.get("path", "/")
params = filter_maybe(data, {
"name": "name__contains",
})
rootpath = bucket.get_root_path(path)
paths = rootpath.child_paths.filter_by(**params).paginate(page, number)
serializer = FilePathSerializer(paths)
return HTTP.OK(data=serializer.data)
def post(self):
'''
新建相册
'''
post_data = request.data
user = request.user
name = post_data.pop('name', None)
description = post_data.pop('description', None)
if name is None:
return HTTP.BAD_REQUEST(message='相册名称不能为空')
album = Album(name=name, user=user)
if description is not None:
album.description = description
album.save()
serializer = AlbumSerializer(album)
return HTTP.OK(data=serializer.data)
def put(self, pk):
'''
修改图片信息
'''
post_data = request.data
user = request.user
name = post_data.pop('name', None)
description = post_data.pop('description', None)
image = Image.query.filter_by(id=pk, user=user).get_or_404('图片不存在')
if name is not None:
image.name = name
image.url = os.path.join(image.path, name)
if description is not None:
image.description = description
image.save()
serializer = ImageSerializer(image)
return HTTP.OK(data=serializer.data)
def put(self, pk):
'''
修改相册
'''
post_data = request.data
user = request.user
name = post_data.pop('name', None)
description = post_data.pop('description', None)
album = Album.query.filter_by(id=pk, user=user).get_or_404('相册不存在')
if name is not None:
album.name = name
if description is not None:
album.description = description
album.save()
serializer = AlbumSerializer(album)
album.delete()
return HTTP.OK(data=serializer.data)
def get(self):
data = request.data
page, number = self.pageinfo
params = filter_maybe(
data, {
"tag": "tags__name",
"category": "category__name",
"title": "title__contains",
"year": "created_at__year",
"month": "created_at__month"
})
order_by = ("-created_at", )
ins = Article.query.filter_by(**params).order_by(*order_by).paginate(
page, number)
serializer = ArticleSerializer(ins)
return HTTP.OK(data=serializer.data)
def get(self):
'''
获取图片列表
'''
query_dict = request.data
user = request.user
page, number = self.page_info
keys = ['name', 'description']
order_by = gen_order_by(query_dict, keys)
filter_dict = gen_filter_dict(query_dict, keys, user=user)
album = query_dict.pop('album', None)
if album is not None:
filter_dict.update(album__id=album)
images = Image.query.filter_by(
**filter_dict).order_by(*order_by).paginate(page, number)
serializer = ImageSerializer(images.items, True)
pageinfo = PageInfo(images)
return HTTP.OK(data=serializer.data, pageinfo=pageinfo)
def wrapper(*args, **kwargs):
form = form_class()
if form.validate_on_submit():
return func(*args, **kwargs)
elif form.errors:
if f is not None:
if callable(f):
flash(f())
elif f == '':
flash_errors(form)
else:
flash(f)
if error is not None:
return error()
return return_errors(form)
if success is not None:
return success()
return HTTP.OK()
def delete(self, pk):
'''
删除图片
'''
user = request.user
image = Image.query.filter_by(id=pk, user=user).get_or_404('图片不存在')
serializer = ImageSerializer(image)
img_path = os.path.join(current_app.config['UPLOAD_FOLDER_ROOT'],
image.url)
# 删除原图
if os.path.exists(img_path):
os.remove(img_path)
# 删除缩略图
thumb_path = os.path.join(current_app.config['UPLOAD_FOLDER_ROOT'],
image.url.replace('photo', 'thumb'))
if os.path.exists(thumb_path):
os.remove(thumb_path)
image.delete()
return HTTP.OK(data=serializer.data)
def post(self):
post_data = request.json
username = post_data['username']
password = post_data['password']
email = post_data['email']
if User.query.filter_by(email=email).exists():
msg = _('The email has been registered')
return HTTP.BAD_REQUEST(message=msg)
if User.query.filter_by(username=username).exists():
msg = _('The username has been registered')
return HTTP.BAD_REQUEST(message=msg)
user = User(username=username, email=email)
user.set_password(password)
user.save()
user.login(True)
self.send_email(user)
flash(_('An email has been sent to your.Please receive'))
serializer = user.serializer() if hasattr(
user, 'serializer') else Serializer(user, depth=1)
return HTTP.OK(data=serializer.data)
def put(self, pk):
post_data = request.data
ins = self._self.model.query.filter_by(**{
self._self.pk: pk
}).get_or_404()
needed_columns = set(self._self.column.columns) ^ set(
self._self.column.primary_columns) ^ set(
self._self.column.foreign_keys)
datetime_columns = self._self.column.datetime_columns
for column in needed_columns:
param = post_data.pop(column.name, None)
if param is not None:
setattr(
ins, column.name,
datetime.strptime(param, '%Y-%m-%d %H:%M:%S')
if column in datetime_columns else param)
self._set_releation_columns(ins, post_data)
ins.save()
serializer = self._self.serializer(ins)
return HTTP.OK(data=serializer.data)