def test_pack_unpacked_payload(self):
form = Form()
payload = StoragePayload(form)
about = "urn:rho:identified_by:asdf"
see_also = "urn:rho.value"
mbox = "mailto:[email protected]"
create_if_missing = True
payload.about = about
payload.add_type(FOAF.Person)
payload.add_property(RDFS.seeAlso, see_also)
payload.add_reference(FOAF.mbox, mbox)
payload.add_flag(FindFlags.CREATE_IF_MISSING, create_if_missing)
content = payload.populate_payload()
second_payload = StoragePayload(content)
second_content = second_payload.populate_payload()
self.assertIsNotNone(second_content)
self.assertEqual(second_content.get_fields()[str(RDF.about)].get_value(), about)
self.assertEqual(second_content.get_fields()[str(RDFS.seeAlso)].get_value(), [see_also])
self.assertEqual(second_content.get_fields()[str(FOAF.mbox)].get_value(), [mbox])
self.assertEqual(second_content.get_fields()[FindFlags.CREATE_IF_MISSING.var].get_value(), create_if_missing)
def test_unpack(self):
form = Form()
payload = StoragePayload(form)
about = "urn:rho:identified_by:asdf"
see_also = "urn:rho.value"
mbox = "mailto:[email protected]"
create_if_missing = True
payload.about = about
payload.add_type(FOAF.Person)
payload.add_property(RDFS.seeAlso, see_also)
payload.add_reference(FOAF.mbox, mbox)
payload.add_flag(FindFlags.CREATE_IF_MISSING, create_if_missing)
content = payload.populate_payload()
second_payload = StoragePayload(content)
self.assertEqual(second_payload.about, about)
self.assertIn(str(FOAF.Person), second_payload.types)
self.assertEqual(second_payload.properties[str(RDFS.seeAlso)], [see_also])
self.assertEqual(second_payload.references[str(FOAF.mbox)], [mbox])
self.assertEqual(FindFlags.CREATE_IF_MISSING.fetch_from(second_payload.flags), create_if_missing)
def convert_rdf_json_to_storage(
definition, store_types=True, store_properties=True, store_bnodes=True, bnode_mappings=None
):
"""
Convert RDF JSON values into a storage payload.
:param definition: dictionary containing the json data.
:param store_types: should store the type values of the definition.
:param store_properties: should store the property values of the definition.
:param store_bnodes: should store the bnodes of the definition.
:param bnode_mappings: dictionary containing a translation key for the bnodes.
:return: newly created storage payload object.
"""
if not bnode_mappings:
bnode_mappings = {}
result = StoragePayload()
for node_uri, values in definition.iteritems():
if node_uri == str(RDF.type):
if store_types:
for value in values:
result.add_type(value["value"])
else:
for value in values:
if store_properties and value["type"] == "literal":
result.add_property(node_uri, value["value"])
elif store_bnodes and value["type"] == "bnode":
if value["value"] in bnode_mappings:
result.add_reference(node_uri, bnode_mappings[value["value"]])
else:
logger.error("Couldn't find bnode mapping for: %s" % value["value"])
return result
def _create_event(self, session, form_payload):
"""
Convert the form payload into a storage payload for creating a new event.
:param session:
:param form_payload:
:return:
"""
create_event_payload = StoragePayload()
create_event_payload.add_type(EVENT.Event)
create_event_payload.add_reference(key=EVENT.agent, value=session['owner'])
create_event_payload.add_reference(key=DCTERMS.creator, value=self._representation_manager.representation_uri)
if 'title' in form_payload.get_values():
create_event_payload.add_property(key=DC.title, value=form_payload.get_values()['title'])
if 'description' in form_payload.get_values():
create_event_payload.add_property(key=DC.description, value=form_payload.get_values()['description'])
if session['location']:
create_event_payload.add_reference(key=EVENT.place, value=session['location'])
if session['interval']:
create_event_payload.add_reference(key=EVENT.time, value=session['interval'])
promise = self._storage_client.create_node(create_event_payload)
return promise
def _handle_create_and_update_session(_result):
timeline = _result.results[0].about
update_payload = StoragePayload()
update_payload.about = timeline_map.about
update_payload.add_reference(TIMELINE.rangeTimeLine, timeline)
# Publish the create event
self._rdf_publish.publish_all_results(_result, created=True)
_promise = self._storage_client.update_node(update_payload)
_promise = _promise.then(
self._scheduler.generate_promise_handler(self._rdf_publish.publish_all_results, created=False)
)
_promise = _promise.then(lambda s: timeline)
return _promise
def _update_interval(self, session):
"""
Now that the timeline stuff has been found, update the interval as well.
:param session:
:return:
"""
def return_session(result):
self._rdf_publish.publish_all_results(result, created=False)
return session
update_payload = StoragePayload()
update_payload.about = session["node"].about
update_payload.add_reference(TIMELINE.timeline, session["timelines"])
update_payload.add_flag(UpdateFlags.REPLACE_DEFINED, True)
return self._storage_client.update_node(update_payload).then(return_session)
def command_start(self, iq, initial_session):
"""
Starting point for creating a new node.
:param iq:
:param initial_session:
:return:
"""
if not initial_session['payload']:
initial_session['notes'] = [('error', 'Cannot execute without a payload')]
else:
logger.info('Get Node iq: %s' % iq)
logger.info('Initial_session: %s' % initial_session)
payload = StoragePayload(initial_session['payload'])
logger.debug('about: %s' % payload.about)
node = self._command_handler.get_node(payload.about, create=False)
if node:
result_payload = StoragePayload()
result_payload.about = node.uri
# Get the types into place.
for label in node.labels:
result_payload.add_type(label)
# Gather up all of the references
for relationship in node.match_outgoing():
result_payload.add_reference(relationship.type, relationship.end_node.uri)
# Gather up all of the properties
for key, value in node.properties.iteritems():
if isinstance(value, list):
for val in value:
result_payload.add_property(key, val)
else:
result_payload.add_property(key, value)
initial_session['payload'] = result_payload.populate_payload()
return initial_session
def update_venue_details(venue):
# No point in continuing this exercise if certain requirements are not resolved.
if not venue:
raise RuntimeError('Venue identifier is not defined')
if not self._foursquare_client:
raise RuntimeError('Foursquare client is not defined')
# Finished checking requirements, fetch the details and update.
logger.debug('Looking up venue: %s' % venue)
venue_details = self._foursquare_client.venues(venue)
# Translate the venue details into a rdf storage payload for sending to update.
if 'venue' in venue_details:
storage_payload = StoragePayload()
foursquare_to_storage(venue_details['venue'], storage_payload)
storage_payload.about = node_uri
storage_payload.add_reference(DCTERMS.creator, self._representation_manager.representation_uri)
return self._storage_client.update_node(storage_payload)
def _get_range_timeline(self, timeline_map):
"""
Get or create the range timeline for the origin map that was previously found.
:param timeline_map: the timeline map.
:return:
"""
time_lines = timeline_map.references.get(str(TIMELINE.rangeTimeLine), None)
if time_lines:
return time_lines[0]
def _handle_create_and_update_session(_result):
timeline = _result.results[0].about
update_payload = StoragePayload()
update_payload.about = timeline_map.about
update_payload.add_reference(TIMELINE.rangeTimeLine, timeline)
# Publish the create event
self._rdf_publish.publish_all_results(_result, created=True)
_promise = self._storage_client.update_node(update_payload)
_promise = _promise.then(
self._scheduler.generate_promise_handler(self._rdf_publish.publish_all_results, created=False)
)
_promise = _promise.then(lambda s: timeline)
return _promise
# otherwise it needs to be created and then return.
create_payload = StoragePayload()
create_payload.add_type(TIMELINE.RelativeTimeLine)
create_payload.add_reference(DCTERMS.creator, self._representation_manager.representation_uri)
promise = self._storage_client.create_node(create_payload).then(_handle_create_and_update_session)
return promise
