def search_records(cls, query):
c = DemographicConnector()
res = c.sparql(query)
m = parse_rdf(res)
# for each person, look up their demographics object.
from smart.models.record_object import RecordObject
people = m.triples((None, rdf['type'], sp.Demographics))
pobj = RecordObject[sp.Demographics]
return_graph = bound_graph()
for person in people:
p = person[0] # subject
# Connect to RDF Store
pid = re.search("\/records\/(.*?)\/demographics", str(p)).group(1)
print "matched ", p," to ", pid
c = RecordStoreConnector(Record.objects.get(id=pid))
# Pull out demographics
p_uri = p.n3() # subject URI
p_subgraph = parse_rdf(c.sparql(pobj.query_one(p_uri)))
print "subq: " , pobj.query_one(p_uri)
print "subgraph: ", serialize_rdf(p_subgraph)
# Append to search result graph
return_graph += p_subgraph
print "got", serialize_rdf(return_graph)
return serialize_rdf(return_graph)
def record_get_allergies(request, *args, **kwargs):
record_id = kwargs['record_id']
a = RecordObject["http://smartplatforms.org/terms#Allergy"]
ae = RecordObject["http://smartplatforms.org/terms#AllergyException"]
c = RecordStoreConnector(Record.objects.get(id=record_id))
ma = c.sparql(a.query_all())
m = parse_rdf(ma)
mae = c.sparql(ae.query_all())
parse_rdf(mae, model=m)
return rdf_response(serialize_rdf(m))
def rdf_to_objects(cls, res):
m = parse_rdf(res)
print "Got", res
people = m.triples((None, rdf['type'], sp.Demographics))
record_list = []
for p in people:
record = Record()
print "working with person ", p
record.id = re.search("\/records\/(.*?)\/demographics", str(p[0])).group(1)
record.fn = str(list(m.triples((p[0], foaf['givenName'], None)))[0][2])
record.ln = (list(m.triples((p[0], foaf['familyName'], None)))[0][2])
print "found the snames ", record.fn, record.ln, record.id
dob = str(list(m.triples((p[0], sp['birthday'], None)))[0][2])
record.dob = dob
gender = str(list(m.triples((p[0], foaf['gender'], None)))[0][2])
record.gender = gender
zipcode = str(list(m.triples((p[0], sp['zipcode'], None)))[0][2])
record.zipcode = zipcode
record_list.append(record)
return record_list
def from_rdf(cls, rdfstring, record, app):
s = parse_rdf(rdfstring)
q = """
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX sp: <http://smartplatforms.org/terms#>
SELECT ?notes ?severity
WHERE {
?a rdf:type sp:Alert.
?a sp:notes ?notes.
?a sp:severity ?scv.
?scv sp:code ?severity.
}"""
r = list(s.query(q))
assert len(r) == 1, "Expected one alert in post, found %s"%len(r)
(notes, severity) = r[0]
assert type(notes) == Literal
spcodes = Namespace("http://smartplatforms.org/terms/code/alertLevel#")
assert severity in [spcodes.information, spcodes.warning, spcodes.critical]
a = RecordAlert(record=record,
alert_text=str(notes),
triggering_app=app)
a.save()
return a
def rdf_delete(record_connector, query, save=True):
to_delete = parse_rdf(record_connector.sparql(query))
deleted = bound_graph()
for r in to_delete:
deleted.add(r)
record_connector.pending_removes.append(r)
if (save): record_connector.execute_transaction()
return rdf_response(serialize_rdf(deleted))
def __init__(self, filename, target_id=None):
# 0. Read supplied data
self.target_id = target_id
self.data = parse_rdf(open(filename).read())
# 1. For each known data type, extract relevant nodes
var_bindings = {'record_id': self.target_id}
ro = RecordObject[sp.MedicalDataElement]
ro.prepare_graph(self.data, None, var_bindings)
# 2. Copy extracted nodes to permanent RDF store
self.write_to_record()
def internal_id(self, record_connector, external_id):
idquery = """
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
CONSTRUCT {%s <http://smartplatforms.org/terms#externalIDFor> ?o.}
FROM $context
WHERE {
%s <http://smartplatforms.org/terms#externalIDFor> ?o.
} """%(external_id.n3(), external_id.n3())
print "querying", idquery
id_graph = parse_rdf(record_connector.sparql(idquery))
l = list(id_graph)
if len(l) > 1:
raise Exception( "MORE THAN ONE ENTITY WITH EXTERNAL ID %s : %s"%(external_id, ", ".join([str(x[0]) for x in l])))
try:
s = l[0][2]
print "FOUND an internal id", s
return s
except:
return None
