def post(self):
"""Create a article tag.
Accept tag as a dict that looks like:
{
"tag": {
"name": "db",
}
}
"""
result = self.post_schema.load(g.tag)
if result.errors:
return make_error_response(400, result.errors)
try:
tag = result.data
db.session.add(tag)
db.session.commit()
except IntegrityError as ex:
db.session.rollback()
reason = str(ex.orig)
if any(word in reason.lower() for word in ["duplicate", "unique"]):
return make_error_response(409, reason)
LOG.exception("An unknown db error occurred")
return make_error_response(500, "DB Error", ex.code)
else:
return {
"tag": tag.to_dict()
}
def put(self, tag_id):
"""Update the editable attributes of an exitsing tag.
:param tag_id: an exitsing tag id.
"""
result = self.put_schema.load(g.tag)
if result.errors:
return make_error_response(400, result.errors)
tag = Tag.query.get(tag_id)
if not tag:
return make_error_response(404, "Tag %r not found" % tag_id)
try:
tag.update(**result.data)
except IntegrityError as ex:
db.session.rollback()
reason = str(ex.orig)
if any(word in reason.lower() for word in ["duplicate", "unique"]):
return make_error_response(409, reason)
LOG.exception("An unknown db error occurred")
return make_error_response(500, "DB Error", ex.code)
else:
return {
"tag": tag.to_dict()
}
def post(self):
"""Create a user.
Accept category as a dict that looks like:
{
"user": {
"name": "zhangsan",
"display_name": "san zhang",
"email": "*****@*****.**",
"password": "******",
"enabled": True,
"role_id": "2",
}
}
"""
print("here")
result = self.post_schema.load(g.user)
if result.errors:
return make_error_response(400, result.errors)
try:
user = result.data
db.session.add(user)
db.session.commit()
except IntegrityError as ex:
db.session.rollback()
reason = str(ex.orig)
if any(word in reason.lower() for word in ["duplicate", "unique"]):
return make_error_response(409, reason)
LOG.exception("An unknown db error occurred")
return make_error_response(500, "DB Error", ex.code)
else:
return {"user": self._user_to_dict(user)}
def custom_error_handler(_orig, e):
if isinstance(e, HTTPException):
return make_error_response(e.code, e.description)
else:
# TODO: further break down the error
LOG.exception('Unknown internal server error.')
return make_error_response(500, 'Internal Server Error')
def delete(self, user_id):
"""Delete a exitsing user.
:param tag_id: an exitsing user id.
"""
user = User.query.get(user_id)
if not user:
return make_error_response(404, "User %r not found" % user_id)
try:
user.delete()
except DatabaseError as ex:
LOG.exception("An unknown db error occurred")
return make_error_response(500, "DB Error", ex.code)
else:
return None, 204
def delete(self, article_id):
"""Delete a exitsing article.
:param article_id: an exitsing article id.
"""
article = Article.query.get(article_id)
if not article:
return make_error_response(404, "Article %r not found" % article_id)
try:
article.delete()
except DatabaseError as ex:
LOG.exception("An unknown db error occurred")
return make_error_response(500, "DB Error", ex.code)
else:
return None, 204
def put(self, user_id):
"""Update the editable attributes of an exitsing user.
:param user_id: an exitsing user id.
"""
result = self.put_schema.load(g.user)
if result.errors:
return make_error_response(400, result.errors)
user = User.query.get(user_id)
if not user:
return make_error_response(404, "User %r not found" % user_id)
try:
user.update(**result.data)
except IntegrityError as ex:
db.session.rollback()
reason = str(ex.orig)
if any(word in reason.lower() for word in ["duplicate", "unique"]):
return make_error_response(409, reason)
LOG.exception("An unknown db error occurred")
return make_error_response(500, "DB Error", ex.code)
else:
return {"user": self._user_to_dict(user)}
def handle_unauthorized():
"""Callback for auth's unauthorized event."""
return make_error_response(401, 'Unauthorized Access')
def get(self, user_id=None):
if user_id:
return self._get_by_id(user_id)
# TODO: DB QUERY OPTIMIZE
query = User.query.join(User.local_user)
# filter by name or email
name = request.args.get("name")
if name is not None:
# regexp maybe not supported, use like instead
exp = LocalUser.name.like(''.join(['%', name, '%']))
query = query.filter(exp)
email = request.args.get("email")
if email is not None:
exp = LocalUser.email.like(''.join(['%', email, '%']))
query = query.filter(exp)
# since
since = request.args.get("since")
if since is not None:
try:
since = parse_isotime(since)
except ValueError as ex:
return make_error_response(400, str(ex))
else:
query = query.filter(LocalUser.created_at >= since)
# order by related
sort = request.args.get("sort", "updated_at")
sort_attribute = getattr(LocalUser, sort, None)
if not isinstance(sort_attribute, InstrumentedAttribute):
return make_error_response(400, "Unknown sort %r" % sort)
direction = request.args.get("direction", "desc")
try:
sort_method = getattr(sort_attribute, direction)
sort_exp = sort_method()
if not isinstance(sort_exp, UnaryExpression):
raise TypeError("Not a unary expression!")
except (AttributeError, TypeError):
return make_error_response(400, "Unknown direction %r" % direction)
else:
query = query.order_by(sort_exp)
# before offset and limit, we get the entry total number
total = query.count()
# offset limit related
page = request.args.get("page", None)
pagesize = request.args.get("pagesize", None)
if page and pagesize:
try:
page = int(page)
except ValueError:
return make_error_response(400, "Unknown page %r" % page)
try:
pagesize = int(pagesize)
except ValueError:
return make_error_response(400,
"Unknown pagesize %r" % pagesize)
offset = (page - 1) * pagesize # page starts from 1
if offset < 0:
offset = 0
query = query.offset(offset).limit(pagesize)
users = query.options(db.joinedload(User.local_user)).options(
db.joinedload(User.role)).all()
return {
"users": [self._user_to_dict(user) for user in users],
"total": total,
}
def _get_by_id(self, user_id):
user = User.get(user_id)
if not user:
return make_error_response(404, "User %r not found" % user_id)
return {"user": self._user_to_dict(user)}
def _get_by_id(source_id):
source = Source.query.get(source_id)
if not source:
return make_error_response(404, "Source %r not found" % source_id)
return {"source": source.to_dict()}
