def serve(iuid):
"""Return dataset's information (metadata), update it, or delete it.
The content of the dataset cannot be updated via this resource.
"""
try:
dataset = get_dataset(iuid)
except ValueError as error:
flask.abort(http.client.NOT_FOUND)
if utils.http_GET():
if not allow_view(dataset):
flask.abort(http.client.FORBIDDEN)
set_links(dataset)
return utils.jsonify(dataset,
schema=flask.url_for("api_schema.dataset",
_external=True))
elif utils.http_POST(csrf=False):
if not allow_edit(dataset):
flask.abort(http.client.FORBIDDEN)
try:
data = flask.request.get_json()
with DatasetSaver(dataset) as saver:
try:
saver.set_title(data["title"])
except KeyError:
pass
try:
saver.set_description(data["description"])
except KeyError:
pass
try:
saver.set_public(data["public"])
except KeyError:
pass
try:
saver.set_vega_lite_types(data["meta"])
except KeyError:
pass
except ValueError as error:
return str(error), http.client.BAD_REQUEST
dataset = saver.doc
set_links(dataset)
return utils.jsonify(dataset,
schema=flask.url_for("api_schema.dataset",
_external=True))
elif utils.http_DELETE():
if not possible_delete(dataset):
flask.abort(http.client.FORBIDDEN)
if not allow_delete(dataset):
flask.abort(http.client.FORBIDDEN)
flask.g.db.delete(dataset)
for log in utils.get_logs(dataset["_id"], cleanup=False):
flask.g.db.delete(log)
return "", http.client.NO_CONTENT
def serve(iuid):
"Return graphic information, update it, or delete it."
try:
graphic = get_graphic(iuid)
except ValueError as error:
flask.abort(http.client.NOT_FOUND)
if utils.http_GET():
if not allow_view(graphic):
flask.abort(http.client.FORBIDDEN)
set_links(graphic)
return utils.jsonify(graphic,
schema=flask.url_for("api_schema.graphic",
_external=True))
elif utils.http_POST(csrf=False):
if not allow_edit(graphic):
flask.abort(http.client.FORBIDDEN)
try:
data = flask.request.get_json()
with GraphicSaver(graphic) as saver:
try:
saver.set_title(data["title"])
except KeyError:
pass
try:
saver.set_description(data["description"])
except KeyError:
pass
try:
saver.set_public(data["public"])
except KeyError:
pass
try:
saver.set_specification(data["specification"])
except KeyError:
pass
except ValueError as error:
return str(error), http.client.BAD_REQUEST
graphic = saver.doc
set_links(graphic)
return utils.jsonify(graphic,
schema=flask.url_for("api_schema.graphic",
_external=True))
elif utils.http_DELETE():
if not allow_delete(graphic):
flask.abort(http.client.FORBIDDEN)
flask.g.db.delete(graphic)
for log in utils.get_logs(graphic["_id"], cleanup=False):
flask.g.db.delete(log)
return "", http.client.NO_CONTENT
def create():
"Create a graphic."
if not flask.g.current_user:
flask.abort(http.client.FORBIDDEN)
data = flask.request.get_json()
try:
dataset = datagraphics.dataset.get_dataset(data.get("dataset"))
if not datagraphics.dataset.allow_view(dataset):
raise ValueError("View access to dataset not allowed.")
with GraphicSaver() as saver:
saver.set_title(data.get("title"))
saver.set_description(data.get("description"))
saver.set_public(data.get("public"))
saver.set_dataset(dataset)
saver.set_specification(data.get("specification"))
except ValueError as error:
return str(error), http.client.BAD_REQUEST
graphic = saver.doc
graphic["$id"] = flask.url_for("api_graphic.serve",
iuid=graphic["_id"],
_external=True)
set_links(graphic)
return utils.jsonify(graphic,
schema=flask.url_for("api_schema.graphic",
_external=True))
def all():
"Map of all JSON schemas for DataGraphics."
return utils.jsonify(
{
"title": "Map of available JSON schemas.",
"schemas": {
"root": {
"href": flask.url_for("api_schema.root", _external=True),
"title": api_root.schema["title"]
},
"about": {
"href": flask.url_for("api_schema.about", _external=True),
"title": api_about.schema["title"]
},
"dataset": {
"href": flask.url_for("api_schema.dataset",
_external=True),
"title": api_dataset.schema["title"]
},
"datasets": {
"href": flask.url_for("api_schema.datasets",
_external=True),
"title": api_datasets.schema["title"]
},
"graphic": {
"href": flask.url_for("api_schema.graphic",
_external=True),
"title": api_graphic.schema["title"]
},
"graphics": {
"href": flask.url_for("api_schema.graphics",
_external=True),
"title": api_graphics.schema["title"]
},
"user": {
"href": flask.url_for("api_schema.user", _external=True),
"title": api_user.schema["title"]
},
"users": {
"href": flask.url_for("api_schema.users", _external=True),
"title": api_users.schema["title"]
},
"schemas": {
"href": flask.url_for("api_schema.schemas",
_external=True),
"title": schema["title"]
},
"logs": {
"href": flask.url_for("api_schema.logs", _external=True),
"title": logs_schema["title"]
},
}
},
schema=flask.url_for("api_schema.schemas", _external=True))
def all():
"Information about all users."
if not flask.g.am_admin:
flask.abort(http.client.FORBIDDEN)
users = []
for user in datagraphics.user.get_users():
users.append({"href": flask.url_for("api_user.serve",
username=user["username"],
_external=True),
"username": user["username"]})
return utils.jsonify({"users": users},
schema=flask.url_for("api_schema.users",
_external=True))
def public():
"Get all public datasets."
datasets = []
for dataset in get_datasets_public(full=True):
datasets.append({"href": flask.url_for("api_dataset.serve",
iuid=dataset["_id"],
_external=True),
"title": dataset["title"],
"owner": dataset["owner"],
"modified": dataset["modified"]})
return utils.jsonify({"datasets": datasets},
schema=flask.url_for("api_schema.datasets",
_external=True))
def software():
"API About: Information about the system software and versions."
result = {
"title":
__doc__,
"software": [{
"name": s[0],
"version": s[1],
"href": s[2]
} for s in datagraphics.about.get_software()]
}
return utils.jsonify(result,
schema=flask.url_for("api_schema.about",
_external=True))
def editor(username):
"Get the datasets which the given user is editor of."
if not datagraphics.user.am_admin_or_self(username=username):
flask.abort(http.client.FORBIDDEN)
datasets = []
for iuid, title, modified in get_datasets_editor(username):
datasets.append({"href": flask.url_for("api_dataset.serve",
iuid=iuid,
_external=True),
"title": title,
"modified": modified})
return utils.jsonify({"datasets": datasets},
schema=flask.url_for("api_schema.datasets",
_external=True))
def serve(username):
"Information about the given user."
user = datagraphics.user.get_user(username=username)
if not user:
flask.abort(http.client.NOT_FOUND)
# XXX Use 'allow' function
if not datagraphics.user.am_admin_or_self(user):
flask.abort(http.client.FORBIDDEN)
user.pop("password", None)
user.pop("apikey", None)
set_links(user)
return utils.jsonify(user,
schema=flask.url_for("api_schema.user",
_external=True))
def all():
"Get all datasets."
if not flask.g.am_admin:
flask.abort(http.client.FORBIDDEN)
datasets = []
for iuid, title, owner, modified in get_datasets_all():
datasets.append({"href": flask.url_for("api_dataset.serve",
iuid=iuid,
_external=True),
"title": title,
"owner": owner,
"modified": modified})
return utils.jsonify({"datasets": datasets},
schema=flask.url_for("api_schema.datasets",
_external=True))
def user(username):
if not datagraphics.user.am_admin_or_self(username=username):
flask.abort(http.client.FORBIDDEN)
graphics = []
for iuid, title, modified in get_graphics_owner(username):
graphics.append({
"href":
flask.url_for("api_graphic.serve", iuid=iuid, _external=True),
"title":
title,
"modified":
modified
})
return utils.jsonify({"graphics": graphics},
schema=flask.url_for("api_schema.graphics",
_external=True))
def logs(username):
"Return all log entries for the given user."
user = datagraphics.user.get_user(username=username)
if not user:
flask.abort(http.client.NOT_FOUND)
# XXX Use 'allow' function
if not datagraphics.user.am_admin_or_self(user):
flask.abort(http.client.FORBIDDEN)
entity = {"type": "user",
"username": user["username"],
"href": flask.url_for(".serve",
username=user["username"],
_external=True)}
return utils.jsonify({"entity": entity,
"logs": utils.get_logs(user["_id"])},
schema=flask.url_for("api_schema.logs",_external=True))
def root():
"API Root; links to other resources."
items = {
"version": constants.VERSION,
"title": __doc__,
"schemas": {
"href": flask.url_for("api_schema.all", _external=True)},
"software": {
"href": flask.url_for("api_about.software", _external=True)},
"datasets": {
"public":
{"count": count_datasets_public(),
"href": flask.url_for("api_datasets.public", _external=True)}},
"graphics": {
"public":
{"count": count_graphics_public(),
"href": flask.url_for("api_graphics.public", _external=True)}}
}
if flask.g.current_user:
username = flask.g.current_user["username"]
items["datasets"]["owner"] = {"count": count_datasets_owner(username),
"href": flask.url_for("api_datasets.user",
username=username,
_external=True)}
items["graphics"]["owner"] = {"count": count_graphics_owner(username),
"href": flask.url_for("api_graphics.user",
username=username,
_external=True)}
items["user"] = {
"username": flask.g.current_user["username"],
"href": flask.url_for("api_user.serve",
username=flask.g.current_user["username"],
_external=True)
}
if flask.g.am_admin:
items["datasets"]["all"] = {"count": count_datasets_all(),
"href": flask.url_for("api_datasets.all",
_external=True)}
items["graphics"]["all"] = {"count": count_graphics_all(),
"href": flask.url_for("api_graphics.all",
_external=True)}
items["users"] = {
"all": {"href": flask.url_for("api_users.all", _external=True)}
}
return utils.jsonify(items,
schema=flask.url_for("api_schema.root",_external=True))
def public():
graphics = []
for graphic in get_graphics_public(full=True):
graphics.append({
"href":
flask.url_for("api_graphic.serve",
iuid=graphic["_id"],
_external=True),
"title":
graphic["title"],
"owner":
graphic["owner"],
"modified":
graphic["modified"]
})
return utils.jsonify({"graphics": graphics},
schema=flask.url_for("api_schema.graphics",
_external=True))
def all():
if not flask.g.am_admin:
flask.abort(http.client.FORBIDDEN)
graphics = []
for iuid, title, owner, modified in get_graphics_all():
graphics.append({
"href":
flask.url_for("api_graphic.serve", iuid=iuid, _external=True),
"title":
title,
"owner":
owner,
"modified":
modified
})
return utils.jsonify({"graphics": graphics},
schema=flask.url_for("api_schema.graphics",
_external=True))
def logs(iuid):
"Return all log entries for the given dataset."
try:
dataset = get_dataset(iuid)
except ValueError as error:
flask.abort(http.client.NOT_FOUND)
if not allow_view(dataset):
flask.abort(http.client.FORBIDDEN)
entity = {
"type": "dataset",
"iuid": iuid,
"href": flask.url_for("api_dataset.serve", iuid=iuid, _external=True)
}
return utils.jsonify(
{
"entity": entity,
"logs": utils.get_logs(dataset["_id"])
},
schema=flask.url_for("api_schema.logs", _external=True))
def create():
"Create an empty dataset."
if not flask.g.current_user:
flask.abort(http.client.FORBIDDEN)
data = flask.request.get_json()
try:
with DatasetSaver() as saver:
saver.set_title(data.get("title"))
saver.set_description(data.get("description"))
saver.set_public(data.get("public"))
except ValueError as error:
return str(error), http.client.BAD_REQUEST
dataset = saver.doc
dataset["$id"] = flask.url_for("api_dataset.serve",
iuid=dataset["_id"],
_external=True)
set_links(dataset)
return utils.jsonify(dataset,
schema=flask.url_for("api_schema.dataset",
_external=True))
def users():
"JSON schema for API Users resource."
return utils.jsonify(api_users.schema, schema=constants.JSON_SCHEMA_URL)
def dataset():
"JSON schema for API Dataset resource."
return utils.jsonify(api_dataset.schema, schema=constants.JSON_SCHEMA_URL)
def about():
"JSON schema for API About resource."
return utils.jsonify(api_about.schema, schema=constants.JSON_SCHEMA_URL)
def root():
"JSON schema for API Root resource."
return utils.jsonify(api_root.schema, schema=constants.JSON_SCHEMA_URL)
def schemas():
"JSON schema for API Schema resource."
return utils.jsonify(schema, schema=constants.JSON_SCHEMA_URL)
def logs():
"JSON schema for API Logs resource."
return utils.jsonify(logs_schema, schema=constants.JSON_SCHEMA_URL)
def graphics():
"JSON schema for API Graphics resource."
return utils.jsonify(api_graphics.schema, schema=constants.JSON_SCHEMA_URL)
