def decorator(*args, **kwargs):
length = {
'username': lambda value: 4 <= len(value) <= 20,
'password': lambda value: 4 <= len(value) <= 20,
}
babel = {
'username': _("Username"),
'password': _("Password"),
'email': _("Email"),
'captcha': _("Captcha")
}
keys.append('captcha')
post_data = request.json
for key in keys:
if not post_data.get(key):
msg = _('The %(key)s is required', key=babel[key])
return HTTP.BAD_REQUEST(message=msg)
if not length.get(key, lambda value: True)(post_data[key]):
msg = _(
"The %(key)s's length must be between 4 to 20 characters",
key=babel[key])
return HTTP.BAD_REQUEST(message=msg)
captcha = post_data['captcha']
if captcha.lower() != session.pop('captcha', '00000').lower():
msg = _('The captcha is error')
return HTTP.BAD_REQUEST(message=msg)
return func(*args, **kwargs)
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 get(self):
query_dict = request.data
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)
if query_dict.pop('from', None) == 'blog':
return HTTP.HTML('timeline/macro.html', timelines=timelines)
return HTTP.HTML('timeline/itemlist.html', timelines=timelines)
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 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 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 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
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):
page, number = self.pageinfo
params = {'is_hidden': False}
order_by = ('-created_at', )
timelines = TimeLine.query.filter_by(**params).order_by(
*order_by).paginate(page, number)
return HTTP.HTML('timelines.html', timelines=timelines)
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 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 abort(self, key, value, message):
if self._abort is not None:
if callable(self._abort):
return self._abort(key, value, message)
return self._abort
if not message:
message = "{0} params error".format(key)
return flask_abort(HTTP.BAD_REQUEST(message=message))
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, 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):
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 decorator(*args, **kwargs):
if req is not None:
request_data = req
else:
request_data = request.data
for key in keys:
if not request_data.get(key):
return HTTP.BAD_REQUEST(message='{0} required'.format(key))
return func(*args, **kwargs)
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):
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 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 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 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 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 get(self):
request_data = request.data
page, number = self.pageinfo
kwargs = filter_maybe(
request_data, {
"tag": "tags__name",
"category": "category__name",
"title": "title__contains",
"year": "created_at__year",
"month": "created_at__month"
})
order_by = ("-created_at", )
ins = Blog.query.filter_by(**kwargs).order_by(*order_by).paginate(
page, number)
return HTTP.HTML('blog/itemlist.html', blogs=ins)
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 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)
return HTTP.HTML('articles.html', articles=ins)
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)
