def get(self, id):
"""Get run by id"""
run = self.backend_store.get_run(id)
if not run:
return abort(404, message="Run {} doesn't exist".format(id))
return run_model.format_response(run)
python类abort()的实例源码
def delete(self, id):
"""Delete run by id"""
run = self.backend_store.get_run(id)
if not run:
return abort(404, message="Run {} doesn't exist".format(id))
if not self.manager.delete_run(run):
return abort(400, message="Failed to find the task queue "
"manager of run {}.".format(id))
def get(self, task_id):
"""
Returns information about task status.
"""
queue = rq.get_queue()
task = queue.fetch_job(task_id)
if task:
return {
"id": task.id,
"status": task.status,
"result_url": task.result
}
else:
return abort(404, message="Unknown task_id")
def put(self, issue_id, username):
if not current_user.is_authenticated:
return abort(401, message='permission denied')
issue = issues_service.get(issue_id)
if issue is None:
return abort(400, message='issue not found')
user = users_service.get_by_username(username)
if user is None:
return abort(400, message='user not found')
args = self.parser.parse_args()
action = args.get('action')
action = 'upvote' if action is None else action
value = -1 if action == 'downvote' else 1
voter = voters_service.get(user, issue)
if voter is None:
if current_user.points - points.VOTE < 0:
return abort(403, message='points are not enough')
current_user.points -= points.VOTE
log = PointLog(action, points.VOTE, user, issue)
voter = Voter(user, issue)
db.session.add(voter)
db.session.add(log)
issue.points += value
elif voter.value != value:
issue.points += value
voter.value = value
else:
return voter
try:
db.session.commit()
except:
db.session.rollback()
return abort(500, message='operation failed')
return voter
def parse_args(self, req=None, strict=False):
"""Parse all arguments from the provided request and return the results
as a Namespace
:param strict: if req includes args not in parser, throw 400 BadRequest exception
"""
if req is None:
req = request
namespace = self.namespace_class()
# A record of arguments not yet parsed; as each is found
# among self.args, it will be popped out
req.unparsed_arguments = dict(self.argument_class('').source(req)) if strict else {}
errors = {}
for arg in self.args:
value, found = arg.parse(req, self.bundle_errors)
if isinstance(value, ValueError):
errors.update(found)
found = None
if found or arg.store_missing:
namespace[arg.dest or arg.name] = value
if errors:
flask_restful.abort(400, message=errors)
if strict and req.unparsed_arguments:
raise exceptions.BadRequest('Unknown arguments: %s'
% ', '.join(req.unparsed_arguments.keys()))
return namespace
def get(group_id):
try:
args = parser.parse_args()
except BadRequest:
return abort(400, message="Invalid arguments")
with db:
with db.cursor() as cursor:
user_id = id_from_token(args['token'])
if user_id is None:
return abort(403, message="Token is not allowed to view this group")
cursor.execute("SELECT id FROM groups_rel WHERE user_id=%s AND groups_rel.group_id=%s",
[user_id, group_id])
group = cursor.fetchone()
if group is None:
return abort(403, message="Token is not allowed to view this group")
cursor.execute("SELECT recipe_id, title, upvotes, veto, image, cheap, vegan, vegetarian, duration FROM group_recipes "
"LEFT JOIN rec_recipes ON group_recipes.recipe_id = rec_recipes.id "
"WHERE group_id=%s", [group_id])
recipes = []
for recipe in cursor.fetchall():
recipes.append({
'id': recipe[0],
'title': recipe[1],
'desc': None,
'upvotes': recipe[2],
'veto': recipe[3],
'image': recipe[4],
'cheap': recipe[5],
'vegan': recipe[6],
'vegetarian': recipe[7],
'duration': recipe[8]
})
return recipes
def delete(self, ean):
try:
args = parser.parse_args()
except Exception:
return abort(400, message="Invalid arguments")
with db:
with db.cursor() as cursor:
user_id = id_from_token(args['token'])
cursor.execute("DELETE FROM fridge_items WHERE ean=%s AND fridge_items.user_id=%s", [ean, user_id])
if cursor.rowcount == 1:
return None, 200
else:
abort(404, message="Fridge item does not exist")
def get(group_id):
try:
args = parser.parse_args()
except BadRequest:
return abort(400, message="Invalid arguments")
with db:
with db.cursor() as cursor:
user_id = id_from_token(args['token'])
if user_id is None:
return abort(403, message="Token is not allowed to view this group")
cursor.execute("SELECT day, COUNT(CASE WHEN invited THEN 1 END) AS invited, "
"COUNT(CASE WHEN accepted THEN 1 END) AS accepted, "
# Only if user is Group Member this will be 1
"COUNT(CASE WHEN user_id=%s THEN 1 END) = 1 AS allowed "
"FROM groups "
"JOIN groups_rel ON groups.id = groups_rel.group_id "
"WHERE groups.id=%s "
"GROUP BY groups.id ", [user_id, group_id])
group = cursor.fetchone()
if group is None:
return abort(404, message="Group not found")
if not group[3]:
return abort(403, message="Token is not allowed to view this group")
return {
'invited': group[1],
'accepted': group[2],
'day': str(group[0]),
}
def parse_args(self, req=None, strict=False):
"""Parse all arguments from the provided request and return the results
as a Namespace
:param strict: if req includes args not in parser, throw 400 BadRequest exception
"""
if req is None:
req = request
namespace = self.namespace_class()
# A record of arguments not yet parsed; as each is found
# among self.args, it will be popped out
req.unparsed_arguments = dict(self.argument_class('').source(req)) if strict else {}
errors = {}
for arg in self.args:
value, found = arg.parse(req, self.bundle_errors)
if isinstance(value, ValueError):
errors.update(found)
found = None
if found or arg.store_missing:
namespace[arg.dest or arg.name] = value
if errors:
flask_restful.abort(400, message=errors)
if strict and req.unparsed_arguments:
raise exceptions.BadRequest('Unknown arguments: %s'
% ', '.join(req.unparsed_arguments.keys()))
return namespace
def parse_args(self, req=None, strict=False):
"""Parse all arguments from the provided request and return the results
as a Namespace
:param strict: if req includes args not in parser, throw 400 BadRequest exception
"""
if req is None:
req = request
namespace = self.namespace_class()
# A record of arguments not yet parsed; as each is found
# among self.args, it will be popped out
req.unparsed_arguments = dict(self.argument_class('').source(req)) if strict else {}
errors = {}
for arg in self.args:
value, found = arg.parse(req, self.bundle_errors)
if isinstance(value, ValueError):
errors.update(found)
found = None
if found or arg.store_missing:
namespace[arg.dest or arg.name] = value
if errors:
flask_restful.abort(400, message=errors)
if strict and req.unparsed_arguments:
raise exceptions.BadRequest('Unknown arguments: %s'
% ', '.join(req.unparsed_arguments.keys()))
return namespace
def get(self, user_id=None, username=None):
"""Get a specific user's info by user ID
*or* username.
This returns a 400 if neither user_id nor
username was provided. Returns a 404 if
cannot find a user by the provided user ID
or username.
Arguments:
user_id (int|None): --
username (str|None): --
Warning:
If both `user_id` and `username` are specified,
user_id will be used.
Returns:
None: If aborted.
dict: If such a user is found, the return value
is a dictionary describing the user.
"""
if user_id is not None:
user = db.session.query(models.User).get(user_id)
if user is None:
message = "No user matching ID: %s" % user_id
flask_restful.abort(404, message=message)
elif username is not None:
user = (db.session.query(models.User)
.filter(models.User.username == username).first())
if user is None:
message = "No user matching username: %s" % username
flask_restful.abort(404, message=message)
else:
message = "Must specify user_id or username."
flask_restful.abort(400, message=message)
return user.to_dict()
def post(self):
"""
Recieves file and options, checks file mimetype,
validates options and creates converting task
"""
if "file" not in request.files:
return abort(400, message="file field is required")
else:
with NamedTemporaryFile(delete=False, prefix=app.config["MEDIA_PATH"]) as tmp_file:
request.files["file"].save(tmp_file)
remove_file.schedule(
datetime.timedelta(seconds=app.config["ORIGINAL_FILE_TTL"])
, tmp_file.name)
with Magic() as magic: # detect mimetype
mimetype = magic.from_file(tmp_file.name)
if mimetype not in app.config["SUPPORTED_MIMETYPES"]:
return abort(400, message="Not supported mimetype: '{0}'".format(mimetype))
options = request.form.get("options", None)
if options: # options validation
options = ujson.loads(options)
formats = options.get("formats", None)
if not isinstance(formats, list) or not formats:
return abort(400, message="Invalid 'formats' value")
else:
for fmt in formats:
supported = (fmt in app.config["SUPPORTED_MIMETYPES"][mimetype]["formats"])
if not supported:
message = "'{0}' mimetype can't be converted to '{1}'"
return abort(400, message=message.format(mimetype, fmt))
thumbnails = options.get("thumbnails", None)
if thumbnails:
if not isinstance(thumbnails, dict):
return abort(400, message="Invalid 'thumbnails' value")
else:
thumbnails_size = thumbnails.get("size", None)
if not isinstance(thumbnails_size, str) or not thumbnails_size:
return abort(400, message="Invalid 'size' value")
else:
try:
(width, height) = map(int, thumbnails_size.split("x"))
except ValueError:
return abort(400, message="Invalid 'size' value")
else:
options["thumbnails"]["size"] = (width, height)
else:
if mimetype == "application/pdf":
options = {
"formats": ["html"]
}
else:
options = app.config["DEFAULT_OPTIONS"]
task = process_document.queue(tmp_file.name, options, {
"mimetype": mimetype,
})
return {
"id": task.id,
"status": task.status,
}
