def edit_instance(query_params, instance_data):
if not are_there_label_properties_in(instance_data):
raise HTTPError(
400,
log_message=
_(u"Label properties like rdfs:label or its subproperties are required"
))
if must_retrieve_graph_and_class_uri(query_params):
triplestore_response = get_class_and_graph(query_params)
bindings = triplestore_response['results']['bindings']
query_params['graph_uri'] = extract_graph_uri(bindings)
query_params['class_uri'] = extract_class_uri(bindings)
try:
instance_uri = query_params['instance_uri']
graph_uri = query_params['graph_uri']
class_uri = query_params['class_uri']
except KeyError as ex:
raise HTTPError(
404,
log_message=_(
u"Parameter <{0:s}> is missing in order to update instance.".
format(ex)))
class_object = get_cached_schema(query_params)
try:
triples = create_explicit_triples(instance_uri, instance_data,
class_object, graph_uri,
query_params)
except InstanceError, exception:
raise HTTPError(400, log_message=exception.message)
def build_json(items_list, query_params):
class_url = build_class_url(query_params)
schema_url = unquote(build_schema_url_for_instance(query_params, class_url))
class_properties = get_class.get_cached_schema(query_params)["properties"]
items_list = cast_items_values(items_list, class_properties)
json = {
'_schema_url': schema_url,
'pattern': '',
'_class_prefix': expand_uri(query_params['class_prefix']),
'_base_url': remove_last_slash(query_params.base_url),
'items': items_list,
'@context': {"@language": query_params.get("lang")},
'@id': query_params['class_uri']
}
def calculate_total_items():
result_dict = query_count_filter_instances(query_params)
total_items = int(get_one_value(result_dict, 'total'))
return total_items
decorate_dict_with_pagination(json, query_params, calculate_total_items)
return json
def put(self, context_name, class_name, instance_id):
valid_params = INSTANCE_PARAMS
with safe_params(valid_params):
self.query_params = ParamDict(self,
context_name=context_name,
class_name=class_name,
instance_id=instance_id,
**valid_params)
del context_name
del class_name
del instance_id
instance_data = get_json_request_as_dict(self.request.body)
instance_data = normalize_all_uris_recursively(instance_data)
rdf_type_error = is_rdf_type_invalid(self.query_params, instance_data)
if rdf_type_error:
raise HTTPError(400, log_message=rdf_type_error)
try:
if not instance_exists(self.query_params):
try:
schema = schema_resource.get_cached_schema(
self.query_params)
except SchemaNotFound:
schema = None
if schema is None:
msg = _(u"Class {0} doesn't exist in graph {1}.")
raise HTTPError(404,
log_message=msg.format(
self.query_params["class_uri"],
self.query_params["graph_uri"]))
instance_uri, instance_id = create_instance(
self.query_params, instance_data,
self.query_params["instance_uri"])
resource_url = self.request.full_url()
status = 201
self.set_header("location", resource_url)
self.set_header("X-Brainiak-Resource-URI", instance_uri)
else:
edit_instance(self.query_params, instance_data)
status = 200
except InstanceError as ex:
raise HTTPError(400, log_message=str(ex))
except SchemaNotFound as ex:
raise HTTPError(404, log_message=str(ex))
cache.purge_an_instance(self.query_params['instance_uri'])
self.query_params["expand_object_properties"] = "1"
instance_data = get_instance(self.query_params)
if instance_data and settings.NOTIFY_BUS:
self.query_params["instance_uri"] = instance_data["@id"]
self._notify_bus(action="PUT", instance_data=instance_data)
self.finalize(status)
def get_instance_class_schema(es_response_item, query_params):
index_name = es_response_item["_index"]
graph_uri = convert_index_name_to_graph_uri(index_name)
class_uri = es_response_item["_type"]
item_params = copy(query_params)
item_params["graph_uri"] = graph_uri
item_params["class_uri"] = class_uri
schema = get_cached_schema(item_params)
return schema
def get_instance_class_schema(es_response_item, query_params):
index_name = es_response_item["_index"]
graph_uri = convert_index_name_to_graph_uri(index_name)
class_uri = es_response_item["_type"]
item_params = copy(query_params)
item_params["graph_uri"] = graph_uri
item_params["class_uri"] = class_uri
schema = get_cached_schema(item_params)
return schema
def test_get_cached_schema_hit(self, settings_mock, get_schema_mock, retrieve_mock):
uri = "http://example.onto/Place/_schema"
query_params = {
'class_uri': u'http://example.onto/Place',
'do_item_count': '0',
'expand_uri': '0',
'graph_uri': u'http://example.onto/',
'lang': 'pt',
'request': MockRequest(uri=uri)
}
schema = get_cached_schema(query_params)
self.assertEqual(schema, {"cached": "true"})
def post(self, context_name, class_name):
valid_params = CLASS_PARAMS
with safe_params(valid_params):
self.query_params = ParamDict(self,
context_name=context_name,
class_name=class_name,
**valid_params)
del context_name
del class_name
try:
schema = schema_resource.get_cached_schema(self.query_params)
except SchemaNotFound:
schema = None
if schema is None:
class_uri = self.query_params["class_uri"]
graph_uri = self.query_params["graph_uri"]
raise HTTPError(
404,
log_message=_(
u"Class {0} doesn't exist in context {1}.").format(
class_uri, graph_uri))
try:
instance_data = json.loads(self.request.body)
except ValueError:
raise HTTPError(400,
log_message=_(u"No JSON object could be decoded"))
instance_data = normalize_all_uris_recursively(instance_data)
try:
(instance_uri,
instance_id) = create_instance(self.query_params, instance_data)
except InstanceError as ex:
raise HTTPError(500, log_message=unicode(ex))
instance_url = self.build_resource_url(instance_id)
self.set_header("location", instance_url)
self.set_header("X-Brainiak-Resource-URI", instance_uri)
self.query_params["instance_uri"] = instance_uri
self.query_params["instance_id"] = instance_id
self.query_params["expand_object_properties"] = "1"
instance_data = get_instance(self.query_params)
if settings.NOTIFY_BUS:
self._notify_bus(action="POST", instance_data=instance_data)
self.finalize(201)
def get(self, context_name, class_name):
self.request.query = unquote(self.request.query)
with safe_params():
self.query_params = ParamDict(self,
context_name=context_name,
class_name=class_name)
del context_name
del class_name
try:
response = schema_resource.get_cached_schema(self.query_params, include_meta=True)
except schema_resource.SchemaNotFound, e:
raise HTTPError(404, log_message=e.message)
def get(self, context_name, class_name):
self.request.query = unquote(self.request.query)
with safe_params():
self.query_params = ParamDict(self,
context_name=context_name,
class_name=class_name)
del context_name
del class_name
try:
response = schema_resource.get_cached_schema(self.query_params,
include_meta=True)
except schema_resource.SchemaNotFound, e:
raise HTTPError(404, log_message=e.message)
def create_instance(query_params, instance_data, instance_uri=None):
class_uri = query_params["class_uri"]
graph_uri = query_params["graph_uri"]
if not are_there_label_properties_in(instance_data):
raise HTTPError(400, log_message=_(u"Label properties like rdfs:label or its subproperties are required"))
if not instance_uri:
instance_uri = create_instance_uri(class_uri)
class_object = get_cached_schema(query_params)
try:
triples = create_explicit_triples(instance_uri, instance_data, class_object, graph_uri, query_params)
except InstanceError, exception:
raise HTTPError(400, log_message=exception.message)
def test_get_cached_schema_raise_schema_not_found_exception(self, settings_mock, get_schema_mock):
uri = "http://example.onto/Place/_schema"
query_params = {
'class_uri': u'http://example.onto/Place',
'do_item_count': '0',
'expand_uri': '0',
'graph_uri': u'http://example.onto/',
'lang': 'pt',
'request': MockRequest(uri=uri)
}
with self.assertRaises(SchemaNotFound) as exception:
schema = get_cached_schema(query_params)
del schema
self.assertEqual(
"SchemaNotFound: The class definition for http://example.onto/Place was not found in graph http://example.onto/",
str(exception.exception)
)
def post(self, context_name, class_name):
valid_params = CLASS_PARAMS
with safe_params(valid_params):
self.query_params = ParamDict(self,
context_name=context_name,
class_name=class_name,
**valid_params)
del context_name
del class_name
try:
schema = schema_resource.get_cached_schema(self.query_params)
except SchemaNotFound:
schema = None
if schema is None:
class_uri = self.query_params["class_uri"]
graph_uri = self.query_params["graph_uri"]
raise HTTPError(404, log_message=_(u"Class {0} doesn't exist in context {1}.").format(class_uri, graph_uri))
try:
instance_data = json.loads(self.request.body)
except ValueError:
raise HTTPError(400, log_message=_(u"No JSON object could be decoded"))
instance_data = normalize_all_uris_recursively(instance_data)
try:
(instance_uri, instance_id) = create_instance(self.query_params, instance_data)
except InstanceError as ex:
raise HTTPError(500, log_message=unicode(ex))
instance_url = self.build_resource_url(instance_id)
self.set_header("location", instance_url)
self.set_header("X-Brainiak-Resource-URI", instance_uri)
self.query_params["instance_uri"] = instance_uri
self.query_params["instance_id"] = instance_id
self.query_params["expand_object_properties"] = "1"
instance_data = get_instance(self.query_params)
if settings.NOTIFY_BUS:
self._notify_bus(action="POST", instance_data=instance_data)
self.finalize(201)
def get(self, context_name, class_name):
self.request.query = unquote(self.request.query)
with safe_params():
self.query_params = ParamDict(self,
context_name=context_name,
class_name=class_name)
del context_name
del class_name
try:
response = schema_resource.get_cached_schema(self.query_params, include_meta=True)
except schema_resource.SchemaNotFound as e:
raise HTTPError(404, log_message=e.message)
if self.query_params['expand_uri'] == "0":
response = normalize_all_uris_recursively(response, mode=SHORTEN)
self.add_cache_headers(response['meta'])
self.finalize(response['body'])
def get_instance(query_params):
"""
Given a URI, verify that the type corresponds to the class being passed as a parameter
Retrieve all properties and objects of this URI (subject)
"""
if must_retrieve_graph_and_class_uri(query_params):
query_result_dict = get_class_and_graph(query_params)
bindings = query_result_dict['results']['bindings']
query_params["graph_uri"] = extract_graph_uri(bindings)
query_params["class_uri"] = extract_class_uri(bindings)
query_result_dict = query_all_properties_and_objects(query_params)
if is_result_empty(query_result_dict):
return None
else:
class_schema = get_class.get_cached_schema(query_params)
return assemble_instance_json(query_params, query_result_dict,
class_schema)
def get_instance(query_params):
"""
Given a URI, verify that the type corresponds to the class being passed as a parameter
Retrieve all properties and objects of this URI (subject)
"""
if must_retrieve_graph_and_class_uri(query_params):
query_result_dict = get_class_and_graph(query_params)
bindings = query_result_dict['results']['bindings']
query_params["graph_uri"] = extract_graph_uri(bindings)
query_params["class_uri"] = extract_class_uri(bindings)
query_result_dict = query_all_properties_and_objects(query_params)
if is_result_empty(query_result_dict):
return None
else:
class_schema = get_class.get_cached_schema(query_params)
return assemble_instance_json(query_params,
query_result_dict,
class_schema)
def create_instance(query_params, instance_data, instance_uri=None):
class_uri = query_params["class_uri"]
graph_uri = query_params["graph_uri"]
if not are_there_label_properties_in(instance_data):
raise HTTPError(
400,
log_message=
_("Label properties like rdfs:label or its subproperties are required"
))
if not instance_uri:
instance_uri = create_instance_uri(class_uri)
class_object = get_cached_schema(query_params)
try:
triples = create_explicit_triples(instance_uri, instance_data,
class_object, graph_uri,
query_params)
except InstanceError as exception:
raise HTTPError(400, log_message=str(exception.args))
implicit_triples = create_implicit_triples(instance_uri, class_uri)
triples.extend(implicit_triples)
string_triples = join_triples(triples)
prefixes = instance_data.get("@context", {})
string_prefixes = join_prefixes(prefixes)
query_params.update({"triples": string_triples, "prefix": string_prefixes})
response = query_create_instances(query_params)
if not is_insert_response_successful(response):
raise HTTPError(500,
log_message=_("Triplestore could not insert triples."))
instance_id = extract_instance_id(instance_uri)
return (instance_uri, instance_id)
def schema(query_params):
context_name = query_params['context_name']
class_name = query_params['class_name']
class_prefix = query_params.get('class_prefix', None)
args = (context_name, class_name, class_prefix)
class_schema = get_cached_schema(query_params)
if class_prefix is not None:
schema_ref = u"/{0}/{1}/_schema?class_prefix={2}".format(*args)
href = u"/{0}/{1}?class_prefix={2}".format(*args)
link = u"/{0}/{1}/{{resource_id}}?class_prefix={{class_prefix}}&instance_prefix={{instance_prefix}}".format(
*args)
else:
schema_ref = u'/{0}/{1}/_schema'.format(*args)
href = u'/{0}/{1}'.format(*args)
link = u"/{0}/{1}/{{resource_id}}?class_prefix={{class_prefix}}&instance_prefix={{instance_prefix}}".format(
*args)
base = {
"$schema":
"http://json-schema.org/draft-04/schema#",
"title":
class_schema.get('title', ''),
"type":
"object",
"required": ["items", "_class_prefix", "@id"],
"properties": {
"_class_prefix": {
"type": "string"
},
"pattern": {
"type": "string"
}, # used in _search service responses
"do_item_count": {
"type": "integer"
},
"item_count": {
"type": "integer"
},
"@id": {
"type": "string",
"format": "uri"
},
"items": {
"type": "array",
"items": {
"type":
"object",
"title":
class_schema.get('title', ''),
"required":
["title", "@id", "resource_id", "instance_prefix"],
"properties": {
"title": {
"type": "string"
},
"@id": {
"type": "string"
},
"resource_id": {
"type": "string"
},
"instance_prefix": {
"type": "string",
"format": "uri"
},
},
"links": [{
"href": link,
"method": "GET",
"rel": "item"
}, {
"href": link,
"method": "GET",
"rel": "instance"
}]
}
},
},
"links": [{
"href": "{+_base_url}",
"method": "GET",
"rel": "self"
}, {
"href": "{+_schema_url}",
"method": "GET",
"rel": "class"
}, {
"href": u"/{0}".format(context_name),
"method": "GET",
"rel": "context"
}, {
"href": href,
"method": "POST",
"rel": "add",
"schema": {
"$ref": schema_ref
}
}, {
"href":
"/{0}/{1}/_search?graph_uri={2}&class_uri={3}&pattern={{pattern}}".
format(context_name, class_name, query_params['graph_uri'],
query_params['class_uri']),
"method":
"GET",
"rel":
"search",
"schema":
SEARCH_PARAM_SCHEMA
}]
}
base_pagination_url = u'/{0}/{1}'.format(context_name, class_name)
extra_url_params = '&class_prefix={_class_prefix}'
pagination_dict = pagination_schema(base_pagination_url, extra_url_params)
merge_schemas(base, pagination_dict)
return base
def schema(query_params):
context_name = query_params['context_name']
class_name = query_params['class_name']
class_prefix = query_params.get('class_prefix', None)
if (class_prefix is not None) and query_params.get('expand_uri') == '0':
class_prefix = shorten_uri(class_prefix)
args = (context_name, class_name, class_prefix)
class_schema = get_cached_schema(query_params)
if class_prefix is not None:
schema_ref = u"/{0}/{1}/_schema?class_prefix={2}".format(*args)
href = u"/{0}/{1}?class_prefix={2}".format(*args)
else:
schema_ref = u'/{0}/{1}/_schema'.format(*args)
href = u'/{0}/{1}'.format(*args)
if 'expand_uri' in query_params:
expand_uri_param = 'expand_uri={0}'.format(query_params['expand_uri'])
schema_ref = append_param(schema_ref, expand_uri_param)
href = append_param(href, expand_uri_param)
link = build_link(query_params)
base = {
"$schema": "http://json-schema.org/draft-04/schema#",
"title": class_schema.get('title', ''),
"type": "object",
"required": ["items", "_class_prefix", "@id"],
"properties": {
"_class_prefix": {"type": "string"},
"pattern": {"type": "string"}, # used in _search service responses
"do_item_count": {"type": "integer"},
"item_count": {"type": "integer"},
"@id": {"type": "string", "format": "uri"},
"items": {
"type": "array",
"items": {
"type": "object",
"title": class_schema.get('title', ''),
"required": ["title", "@id", "resource_id", "instance_prefix"],
"properties": {
"title": {"type": "string"},
"@id": {"type": "string"},
"resource_id": {"type": "string"},
"instance_prefix": {"type": "string", "format": "uri"},
},
"links": [
{
"href": link,
"method": "GET",
"rel": "item"
},
{
"href": link,
"method": "GET",
"rel": "instance"
}
]
}
},
},
"links": [
{
"href": "{+_base_url}",
"method": "GET",
"rel": "self"
},
{
"href": "{+_schema_url}",
"method": "GET",
"rel": "class"
},
{
"href": u"/{0}".format(context_name),
"method": "GET",
"rel": "context"
},
{
"href": href,
"method": "POST",
"rel": "add",
"schema": {"$ref": schema_ref}
},
{
"href": "/{0}/{1}/_search?graph_uri={2}&class_uri={3}&pattern={{pattern}}".format(
context_name,
class_name,
query_params['graph_uri'],
query_params['class_uri']),
"method": "GET",
"rel": "search",
"schema": SEARCH_PARAM_SCHEMA
}
]
}
base_pagination_url = u'/{0}/{1}'.format(context_name, class_name)
extra_url_params = '&class_prefix={_class_prefix}'
pagination_dict = pagination_schema(base_pagination_url, extra_url_params)
merge_schemas(base, pagination_dict)
return base
def put(self, context_name, class_name, instance_id):
valid_params = INSTANCE_PARAMS
with safe_params(valid_params):
self.query_params = ParamDict(self,
context_name=context_name,
class_name=class_name,
instance_id=instance_id,
**valid_params)
del context_name
del class_name
del instance_id
try:
instance_data = json.loads(self.request.body)
except ValueError:
raise HTTPError(400,
log_message=_("No JSON object could be decoded"))
instance_data = normalize_all_uris_recursively(instance_data)
RDFS_TYPE = "http://www.w3.org/2000/01/rdf-schema#type"
rdfs_type = instance_data.get(RDFS_TYPE)
if rdfs_type:
class_uri = self.query_params["class_uri"]
if (rdfs_type == class_uri):
instance_data.pop(RDFS_TYPE)
else:
msg = u"Incompatible values for rdfs:type <{0}> and class URI <{1}>"
msg = msg.format(rdfs_type, class_uri)
raise HTTPError(400, log_message=msg)
try:
if not instance_exists(self.query_params):
try:
schema = schema_resource.get_cached_schema(
self.query_params)
except SchemaNotFound:
schema = None
if schema is None:
msg = _(u"Class {0} doesn't exist in graph {1}.")
raise HTTPError(404,
log_message=msg.format(
self.query_params["class_uri"],
self.query_params["graph_uri"]))
instance_uri, instance_id = create_instance(
self.query_params, instance_data,
self.query_params["instance_uri"])
resource_url = self.request.full_url()
status = 201
self.set_header("location", resource_url)
self.set_header("X-Brainiak-Resource-URI", instance_uri)
else:
edit_instance(self.query_params, instance_data)
status = 200
except InstanceError as ex:
raise HTTPError(400, log_message=unicode(ex))
except SchemaNotFound as ex:
raise HTTPError(404, log_message=unicode(ex))
cache.purge_an_instance(self.query_params['instance_uri'])
self.query_params["expand_object_properties"] = "1"
instance_data = get_instance(self.query_params)
if instance_data and settings.NOTIFY_BUS:
self.query_params["instance_uri"] = instance_data["@id"]
self._notify_bus(action="PUT", instance_data=instance_data)
self.finalize(status)
def put(self, context_name, class_name, instance_id):
valid_params = INSTANCE_PARAMS
with safe_params(valid_params):
self.query_params = ParamDict(self,
context_name=context_name,
class_name=class_name,
instance_id=instance_id,
**valid_params)
del context_name
del class_name
del instance_id
try:
instance_data = json.loads(self.request.body)
except ValueError:
raise HTTPError(400, log_message=_("No JSON object could be decoded"))
instance_data = normalize_all_uris_recursively(instance_data)
RDFS_TYPE = "http://www.w3.org/2000/01/rdf-schema#type"
rdfs_type = instance_data.get(RDFS_TYPE)
if rdfs_type:
class_uri = self.query_params["class_uri"]
if (rdfs_type == class_uri):
instance_data.pop(RDFS_TYPE)
else:
msg = u"Incompatible values for rdfs:type <{0}> and class URI <{1}>"
msg = msg.format(rdfs_type, class_uri)
raise HTTPError(400, log_message=msg)
try:
if not instance_exists(self.query_params):
try:
schema = schema_resource.get_cached_schema(self.query_params)
except SchemaNotFound:
schema = None
if schema is None:
msg = _(u"Class {0} doesn't exist in graph {1}.")
raise HTTPError(404, log_message=msg.format(self.query_params["class_uri"],
self.query_params["graph_uri"]))
instance_uri, instance_id = create_instance(self.query_params, instance_data, self.query_params["instance_uri"])
resource_url = self.request.full_url()
status = 201
self.set_header("location", resource_url)
self.set_header("X-Brainiak-Resource-URI", instance_uri)
else:
edit_instance(self.query_params, instance_data)
status = 200
except InstanceError as ex:
raise HTTPError(400, log_message=unicode(ex))
except SchemaNotFound as ex:
raise HTTPError(404, log_message=unicode(ex))
cache.purge_an_instance(self.query_params['instance_uri'])
self.query_params["expand_object_properties"] = "1"
instance_data = get_instance(self.query_params)
if instance_data and settings.NOTIFY_BUS:
self.query_params["instance_uri"] = instance_data["@id"]
self._notify_bus(action="PUT", instance_data=instance_data)
self.finalize(status)
