def instance(): """ Responds with one of a number of HTTP responses according to an allowed model and format of this object in the graph :return: and HTTP response """ # must have the URI of an object in the graph instance_uri = request.args.get('_uri') try: g = get_class_object(instance_uri) if not g: return client_error_response( 'No URI of an object in the provenance database was supplied. ' 'Expecting a query string argument \'_uri\'.') except ConnectionError: return render_template('error_db_connection.html'), 500 # the URI is of something in the graph so now we validate the requested model and format # find the class of the URI for s, p, o in g: if str(p) == 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type': # validate this request's model and format class_uri = str(o) views_formats = objects_functions.get_classes_views_formats().get( class_uri) try: view, mime_format = LDAPI.get_valid_view_and_format( request.args.get('_view'), request.args.get('_format'), views_formats) # if alternates model, return this info from file if view == 'alternates': instance_uri_encoded = urllib.parse.quote_plus( request.args.get('_uri')) class_uri_encoded = urllib.parse.quote_plus(class_uri) del views_formats['renderer'] return api_functions.render_alternates_view( class_uri, class_uri_encoded, instance_uri, instance_uri_encoded, views_formats, mime_format) else: # chooses a class to render this instance based on the specified renderer in # classes_views_formats.json # no need for further validation as instance_uri, model & format are already validated renderer = getattr(__import__('model'), views_formats['renderer']) endpoints = { 'instance': url_for('.instance'), 'sparql': url_for('api.sparql') } return renderer(instance_uri, endpoints).render(view, mime_format) except LdapiParameterError as e: return client_error_response(e)
def register(): """ Responds with a Register model response for classes listed in the graph Supported classes statically loaded from classes_views_formats.json In the future, we will dynamically work out which classes are supported. :param class_name: the name of a class of object in the graph db :return: an HTTP message based on a particular model and format of the class """ # check for a class URI uri = request.args.get('_uri') # ensure the class URI is one of the classes in the views_formats class_uris = objects_functions.get_class_uris() if uri not in class_uris: return client_error_response( 'No URI of a class in the provenance database was supplied. Expecting a query string argument \'_uri\' ' 'equal to one of the following: ' + ', '.join(class_uris) ) # validate this request's model and format class_uri = 'http://purl.org/linked-data/registry#Register' views_formats = objects_functions.get_classes_views_formats().get(class_uri) try: view, mime_format = LDAPI.get_valid_view_and_format( request.args.get('_view'), request.args.get('_format'), views_formats ) except LdapiParameterError as e: return client_error_response(e) # if alternates model, return this info from file if view == 'alternates': del views_formats['renderer'] return api_functions.render_alternates_view(uri, uriparse.parse.quote_plus(uri), None, None, views_formats, mime_format) # get the register of this class of thing from the provenance database try: class_register = get_class_register(uri) except ConnectionError: return render_template('error_db_connection.html'), 500 # since everything's valid, use the Renderer to return a response endpoints = { 'instance': url_for('.instance'), 'sparql': url_for('api.sparql') } return model.RegisterRenderer(request, uri, endpoints, class_register).render(view, mime_format)
def instance(): """ Responds with one of a number of HTTP responses according to an allowed model and format of this object in the graph :return: and HTTP response """ # must have the URI of an object in the graph instance_uri = request.args.get('_uri') try: g = get_class_object(instance_uri) if not g: return client_error_response( 'No URI of an object in the provenance _database was supplied. ' 'Expecting a query string argument \'_uri\'.') except ConnectionError: return render_template('error_db_connection.html'), 500 # the URI is of something in the graph so now we validate the requested model and format # find the class of the URI q = ''' SELECT DISTINCT ?o WHERE { <%s> a ?o . } ''' % instance_uri for r in g.query(q): class_uri = str(str(r['o'])) # first preference render if class_uri in [ 'http://www.w3.org/ns/prov#Activity', 'http://www.w3.org/ns/prov#Agent', 'http://www.w3.org/ns/prov#Entity', 'http://promsns.org/def/proms#BasicReport', 'http://promsns.org/def/proms#ExternalReport', 'http://promsns.org/def/proms#InternalReport', 'http://promsns.org/def/proms#ReportingSystem' ]: # validate this request's model and format views_formats = objects_functions.get_classes_views_formats().get(class_uri) try: view, mime_format = LDAPI.get_valid_view_and_format( request.args.get('_view'), request.args.get('_format'), views_formats ) # if alternates model, return this info from file if view == 'alternates': instance_uri_encoded = uriparse.quote_plus(request.args.get('_uri')) class_uri_encoded = uriparse.quote_plus(class_uri) del views_formats['renderer'] return api_functions.render_alternates_view( class_uri, class_uri_encoded, instance_uri, instance_uri_encoded, views_formats, mime_format ) else: # chooses a class to render this instance based on the specified renderer in # classes_views_formats.json # no need for further validation as instance_uri, model & format are already validated renderer = getattr(__import__('model'), views_formats['renderer']) endpoints = { 'instance': url_for('.instance'), 'sparql': url_for('api.sparql') } return renderer( instance_uri, endpoints ).render(view, mime_format) except LdapiParameterError as e: return client_error_response(e)