def view_task(request, uid, return_context=False):
task = Task.get(uid)[0]
# Replace newlines with <br>, etc.
task["definition"] = clean_html(task["definition"])
contrasts = Task.get_contrasts(task["id"])
# Make a lookup dictionary based on concept id
concept_lookup = dict()
for contrast in contrasts:
contrast_concepts = Contrast.get_concepts(contrast["contrast_id"])
for concept in contrast_concepts:
concept_lookup = update_lookup(concept_lookup,
concept["concept_id"], contrast)
# Retrieve conditions, make associations with contrasts
conditions = Task.get_conditions(uid)
context = {
"task": task,
"concepts": concept_lookup,
"contrasts": contrasts,
"conditions": conditions,
"domain": DOMAIN
}
if return_context == True:
return context
return render(request, 'atlas/view_task.html', context)
def test_all_tasks(self):
task = Task()
count = task.count()
response = self.client.get(reverse('all_tasks'))
self.assertEqual(response.context['term_type'], 'task')
self.assertEqual(len(response.context['nodes']), count)
self.assertEqual(response.status_code, 200)
def test_add_task_concept(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
concept = Concept()
contrast = Contrast()
tsk = task.create('test_add_task_concept', {'prop': 'prop'})
con = concept.create('test_add_task_concept', {'prop': 'prop'})
cont = contrast.create('test_add_task_concept', {'prop': 'prop'})
concept.link(con.properties['id'],
cont.properties['id'],
"HASCONTRAST",
endnode_type='contrast')
response = self.client.post(
reverse('add_task_concept', kwargs={'uid': tsk.properties['id']}),
{'concept_selection': con.properties['id']})
self.assertEqual(response.status_code, 200)
response = self.client.get(
reverse('task', kwargs={'uid': tsk.properties['id']}))
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.context['task']['relations']['ASSERTS']),
1)
self.assertEqual(
response.context['task']['relations']['ASSERTS'][0]['id'],
con.properties['id'])
tsk.delete_related()
con.delete_related()
tsk.delete()
con.delete()
cont.delete()
def task_gist(request, uid, query=None, return_gist=False):
'''task_gist will return a cypher gist for a task, including nodes and relations
:param uid: the uid for the task
:param query: a custom query. If not defined, will show a table of concepts asserted.
:param return_gist: if True, will return the context with all needed variables
'''
task_cypher, lookup = Task.cypher(uid, return_lookup=True)
task_cypher = add_cypher_relations(task_cypher, lookup)
task = Task.get(uid)[0]
if query is None:
query = "MATCH (t:task)-[r:ASSERTS]->(c:concept) RETURN t.name as task_name,c.name as concept_name;"
# Join by newline
task_cypher["links"] = "\n".join(task_cypher["links"])
task_cypher["nodes"] = "\n".join(task_cypher["nodes"])
context = {
"relations": task_cypher["links"],
"nodes": task_cypher["nodes"],
"node_type": "task",
"node_name": task["name"],
"query": query
}
if return_gist is True:
return context
return render(request, 'graph/gist.html', context)
def task_gist(request,uid,query=None,return_gist=False):
'''task_gist will return a cypher gist for a task, including nodes and relations
:param uid: the uid for the task
:param query: a custom query. If not defined, will show a table of concepts asserted.
:param return_gist: if True, will return the context with all needed variables
'''
task_cypher,lookup = Task.cypher(uid,return_lookup=True)
task_cypher = add_cypher_relations(task_cypher,lookup)
task = Task.get(uid)[0]
if query == None:
query = "MATCH (t:task)-[r:ASSERTS]->(c:concept) RETURN t.name as task_name,c.name as concept_name;"
# Join by newline
task_cypher["links"] = "\n".join(task_cypher["links"])
task_cypher["nodes"] = "\n".join(task_cypher["nodes"])
context = {"relations":task_cypher["links"],
"nodes":task_cypher["nodes"],
"node_type":"task",
"node_name":task["name"],
"query":query}
if return_gist == True:
return context
return render(request,'graph/gist.html',context)
def test_taskapilist(self):
task = Task()
count = task.count()
response = self.client.get(reverse('task_api_list'))
content = json.loads(response.content.decode('utf-8'))
self.assertEqual(len(content), count)
self.assertEqual(response.status_code, 200)
def __init__(self, *args, **kwargs):
super(ConceptTaskForm, self).__init__(*args, **kwargs)
tasks = Task()
choices = [(x['id'], x['name']) for x in tasks.all()]
self.fields['tasks'] = forms.ChoiceField(choices=choices)
self.helper = FormHelper()
self.helper.form_class = "hidden"
self.helper.add_input(Submit('submit', 'Submit'))
self.helper.add_input(Reset('battery-cancel', 'Cancel', type="button"))
def test_view_task(self):
task = Task()
tsk = task.create("test_view_task", {
"prop": "prop",
"definition": "definition"
})
uid = tsk.properties['id']
response = self.client.get(reverse('task', kwargs={'uid': uid}))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['task']['id'], uid)
# should also test linked concepts and contrasts
tsk.delete()
def add_task_concept(request, uid):
'''add_task_concept will add a cognitive concept to the list on a task page, making the assertion that the concept
is associated with the task.
:param uid: the unique id of the task, for returning to the task page when finished
'''
if request.method == "POST":
relation_type = "ASSERTS" #task --asserts-> concept
concept_selection = request.POST.get('concept_selection', '')
Task.link(uid,
concept_selection,
relation_type,
endnode_type="concept")
return view_task(request, uid)
def test_update_task(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
tsk = task.create('test_update_task', {'prop': 'prop'})
response = self.client.post(
reverse('update_task', kwargs={'uid': tsk.properties['id']}),
{'definition_text': 'new def'})
self.assertEqual(response.status_code, 200)
self.assertEqual('new def',
response.context['task']['definition_text'])
tsk.delete()
def add_condition(request, task_id):
'''add_condition will add a condition associated with a task
:param task_id: the uid of the task, to return to the correct page after creation
'''
if request.method == "POST":
relation_type = "HASCONDITION" #task --HASCONDITION-> condition
condition_name = request.POST.get('condition_name', '')
if condition_name != "":
condition = Condition.create(name=condition_name)
Task.link(task_id,
condition["id"],
relation_type,
endnode_type="condition")
return view_task(request, task_id)
def __init__(self, task_id, concept_id, *args, **kwargs):
super(ConceptContrastForm, self).__init__(*args, **kwargs)
tasks = Task()
contrasts = tasks.get_relation(task_id, "HASCONTRAST")
choices = [(x['id'], x['name']) for x in contrasts]
self.fields['contrasts'] = forms.ChoiceField(choices=choices)
self.helper = FormHelper()
self.helper.add_input(Submit('submit', 'Submit'))
self.helper.add_input(Reset('battery-cancel', 'Cancel', type="button"))
self.helper.form_action = reverse('add_concept_contrast',
kwargs={
'uid': concept_id,
'tid': task_id
})
def add_cypher_relations(cypher, lookup):
'''add_cypher_relations will look up relations for connected nodes returned from an object. This is akin to
adding one layer of the tree to the graph (and the function could be modified to add more)
:param cypher: the cypher object, a dictionary with nodes and links as keys, each a list of them.
'''
node_types = list(lookup)
for node_type in node_types:
for term in lookup[node_type]:
if node_type == "condition":
new_cypher, lookup = Condition.cypher(term,
lookup=lookup,
return_lookup=True)
elif node_type == "task":
new_cypher, lookup = Task.cypher(term,
lookup=lookup,
return_lookup=True)
elif node_type == "contrast":
new_cypher, lookup = Contrast.cypher(term,
lookup=lookup,
return_lookup=True)
elif node_type == "concept":
new_cypher, lookup = Concept.cypher(term,
lookup=lookup,
return_lookup=True)
cypher = merge_cypher(cypher, new_cypher)
return cypher
def test_taskapidetail_by_name(self):
task = Task()
response = self.client.get(reverse('task_api_list'),
{'name': self.task.properties['name']})
content = json.loads(response.content.decode('utf-8'))
self.assertEqual(content['name'], self.task.properties['name'])
self.assertEqual(response.status_code, 200)
def add_task_contrast(request, uid):
'''add_task_contrast will display the view to add a contrast to a task, meaning a set of conditions
and an operator over the conditions. This view is a box over the faded out view_task page
:param uid: the unique id of the task
'''
context = view_task(request, uid, return_context=True)
context["conditions"] = Task.get_conditions(uid)
return render(request, 'atlas/add_contrast.html', context)
def test_add_task_contrast(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
condition = Condition()
tsk = task.create('test_add_task_contrast', {'prop': 'prop'})
cond1 = condition.create('test_add_task_contrast_cond1',
{'prop': 'prop'})
cond2 = condition.create('test_add_task_contrast_cond2',
{'prop': 'prop'})
cond_names = [
'test_add_task_contrast_cond1', 'test_add_task_contrast_cond2'
]
task.link(tsk.properties['id'],
cond1.properties['id'],
'HASCONDITION',
endnode_type='condition')
task.link(tsk.properties['id'],
cond2.properties['id'],
'HASCONDITION',
endnode_type='condition')
response = self.client.get(
reverse('add_task_contrast', kwargs={'uid': tsk.properties['id']}))
self.assertEqual(response.status_code, 200)
self.assertIn(response.context['conditions'][0]['condition_name'],
cond_names)
self.assertIn(response.context['conditions'][1]['condition_name'],
cond_names)
self.assertEqual(len(response.context['conditions']), 2)
tsk.delete_related()
tsk.delete()
cond1.delete()
cond2.delete()
def test_add_term_task(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
task_name = 'test_add_term_concept'
definition = 'task definition'
response = self.client.post(reverse('add_term'), {
'term_type': 'task',
'term_name': task_name,
'definition_text': definition
},
follow=True)
self.assertEqual(response.status_code, 200)
uid = response.context['task']['id']
tsk = task.get(uid)
self.assertEqual(len(tsk), 1)
tsk = task.graph.find_one('task', 'id', uid)
def setUp(self):
self.task = Task()
self.node_name = "test_name"
self.node_properties = {'test_key': 'test_value'}
self.graph = Graph("http://graphdb:7474/db/data/")
self.task1 = self.task.create(
name=self.node_name,
properties=self.node_properties)
self.task2 = self.task.create(
name=self.node_name,
properties=self.node_properties)
condition = Condition()
self.cond = condition.create(
name=self.node_name,
properties=self.node_properties)
contrast = Contrast()
self.cont = contrast.create(
name=self.node_name,
properties=self.node_properties)
concept = Concept()
self.con = concept.create(
name=self.node_name,
properties=self.node_properties)
self.task.link(
self.task1.properties['id'],
self.cond.properties['id'],
"HASCONDITION",
endnode_type='condition')
self.task.link(
self.task1.properties['id'],
self.con.properties['id'],
"ASSERTS",
endnode_type='concept')
condition.link(
self.cond.properties['id'],
self.cont.properties['id'],
"HASCONTRAST",
endnode_type='contrast')
concept.link(
self.con.properties['id'],
self.cont.properties['id'],
"MEASUREDBY",
endnode_type='contrast')
def test_add_task_indicator(self):
task = Task()
tsk = task.create('test_add_task_indicator', {'prop': 'prop'})
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
data = {
'type': 'add_task_indicator',
}
response = self.client.post(
reverse('add_task_indicator',
kwargs={'task_id': tsk.properties['id']}), data)
self.assertEqual(response.status_code, 200)
ind = task.get_relation(tsk.properties['id'], "HASINDICATOR")
self.assertEqual(len(ind), 1)
self.assertEqual(ind[0]['name'], 'add_task_indicator')
tsk.delete_related()
tsk.delete()
ind = graph.find_one("indicator", "id", ind[0]['id'])
def test_add_task_dataset(self):
task = Task()
tsk = task.create('test_add_task_dataset', {'prop': 'prop'})
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
data = {
'dataset_uri': 'http://example.com',
'dataset_name': 'add_task_dataset',
}
response = self.client.post(
reverse('add_task_dataset',
kwargs={'task_id': tsk.properties['id']}), data)
self.assertEqual(response.status_code, 200)
ds = task.get_relation(tsk.properties['id'], "HASEXTERNALDATASET")
self.assertEqual(len(ds), 1)
self.assertEqual(ds[0]['name'], 'add_task_dataset')
tsk.delete_related()
tsk.delete()
ds = graph.find_one("external_dataset", "id", ds[0]['id'])
def __init__(self, task_id, *args, **kwargs):
super(TaskConceptForm, self).__init__(*args, **kwargs)
concept = Concept()
tasks = Task()
contrasts = tasks.get_relation(task_id, "HASCONTRAST")
cont_choices = [(x['id'], x['name']) for x in contrasts]
self.fields['concept-contrasts'] = forms.ChoiceField(
choices=cont_choices)
concept_choices = [(x['id'], x['name']) for x in concept.all()]
self.fields['concept'] = forms.ChoiceField(choices=concept_choices)
self.helper = FormHelper()
self.helper.attrs = {'id': 'concept-form'}
self.helper.form_class = "hidden"
self.helper.form_action = reverse('add_task_concept',
kwargs={'uid': task_id})
self.helper.add_input(Submit('submit', 'Submit'))
self.helper.add_input(Reset('task-concept-cancel', 'Cancel'))
def test_add_task_implementation(self):
task = Task()
tsk = task.create('test_add_task_implementation', {'prop': 'prop'})
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
data = {
'implementation_uri': 'http://example.com',
'implementation_name': 'add_task_implementation',
'implementation_description': 'task imp desc'
}
response = self.client.post(
reverse('add_task_implementation',
kwargs={'task_id': tsk.properties['id']}), data)
self.assertEqual(response.status_code, 200)
imp = task.get_relation(tsk.properties['id'], "HASIMPLEMENTATION")
self.assertEqual(len(imp), 1)
self.assertEqual(imp[0]['name'], 'add_task_implementation')
tsk.delete_related()
tsk.delete()
imp = graph.find_one("implementation", "id", imp[0]['id'])
def test_add_condition(self):
self.assertTrue(
self.client.login(username=self.user.username,
password=self.password))
task = Task()
condition = Condition()
tsk = task.create("test_add_condition_task", {
"prop": "prop",
"definition": "definition"
})
uid = tsk.properties['id']
response = self.client.post(
reverse('add_condition', kwargs={'task_id': uid}),
{'condition_name': 'test_add_condition'})
self.assertEqual(response.status_code, 200)
relation = task.get_conditions(uid)
self.assertEqual(len(relation), 1)
self.assertEqual(relation[0]['condition_name'], 'test_add_condition')
con = condition.graph.find_one('condition', 'id',
relation[0]['condition_id'])
tsk.delete_related()
tsk.delete()
con.delete()
def __init__(self, task_id, *args, **kwargs):
super(TaskDisorderForm, self).__init__(*args, **kwargs)
disorders = Disorder()
behaviors = query.Behavior()
traits = query.Trait()
tasks = Task()
contrasts = tasks.get_relation(task_id, "HASCONTRAST")
cont_choices = [(x['id'], x['name']) for x in contrasts]
self.fields['contrasts'] = forms.ChoiceField(choices=cont_choices)
pheno_choices = []
pheno_choices.extend([(x['id'], ''.join([x['name'], " (Disorder)"]))
for x in disorders.all()])
pheno_choices.extend([(x['id'], ''.join([x['name'], " (Behavior)"]))
for x in behaviors.all()])
pheno_choices.extend([(x['id'], ''.join([x['name'], " (Trait)"]))
for x in traits.all()])
self.fields['disorders'] = forms.ChoiceField(choices=pheno_choices)
self.helper = FormHelper()
self.helper.form_tag = False
self.helper.add_input(Submit('submit', 'Submit'))
self.helper.add_input(Reset('task-disorder-cancel', 'Cancel'))
def add_cypher_relations(cypher,lookup):
'''add_cypher_relations will look up relations for connected nodes returned from an object. This is akin to
adding one layer of the tree to the graph (and the function could be modified to add more)
:param cypher: the cypher object, a dictionary with nodes and links as keys, each a list of them.
'''
node_types = list(lookup)
for node_type in node_types:
for term in lookup[node_type]:
if node_type == "condition":
new_cypher,lookup = Condition.cypher(term,lookup=lookup,return_lookup=True)
elif node_type == "task":
new_cypher,lookup = Task.cypher(term,lookup=lookup,return_lookup=True)
elif node_type == "contrast":
new_cypher,lookup = Contrast.cypher(term,lookup=lookup,return_lookup=True)
elif node_type == "concept":
new_cypher,lookup = Concept.cypher(term,lookup=lookup,return_lookup=True)
cypher = merge_cypher(cypher,new_cypher)
return cypher
def base(request):
# We only need id and name for the home page
fields = ["id","name"]
concepts = Concept.all(limit=10,order_by="last_updated",fields=fields)
tasks = Task.all(limit=10,order_by="last_updated",fields=fields)
disorders = Disorder.all(limit=10,order_by="last_updated",fields=fields)
theories = Theory.all(limit=7,order_by="last_updated",fields=fields)
appname = "The Cognitive Atlas"
context = {'appname': appname,
'active':'homepage',
'concepts':concepts,
'tasks':tasks,
'theories':theories,
'disorders':disorders}
return context
def add_term(request):
'''add_term will add a new term to the atlas
'''
if request.method == "POST":
term_type = request.POST.get('term_type', '')
term_name = request.POST.get('term_name', '')
definition_text = request.POST.get('definition_text', '')
properties = None
if definition_text != '':
properties = {"definition": definition_text}
if term_type == "concept":
node = Concept.create(name=term_name, properties=properties)
return view_concept(request, node["id"])
elif term_type == "task":
node = Task.create(name=term_name, properties=properties)
return view_task(request, node["id"])
class NodeChildrenTest(TestCase):
def setUp(self):
self.task = Task()
self.node_name = "test_name"
self.node_properties = {'test_key': 'test_value'}
self.graph = Graph("http://graphdb:7474/db/data/")
self.task1 = self.task.create(
name=self.node_name,
properties=self.node_properties)
self.task2 = self.task.create(
name=self.node_name,
properties=self.node_properties)
condition = Condition()
self.cond = condition.create(
name=self.node_name,
properties=self.node_properties)
contrast = Contrast()
self.cont = contrast.create(
name=self.node_name,
properties=self.node_properties)
concept = Concept()
self.con = concept.create(
name=self.node_name,
properties=self.node_properties)
self.task.link(
self.task1.properties['id'],
self.cond.properties['id'],
"HASCONDITION",
endnode_type='condition')
self.task.link(
self.task1.properties['id'],
self.con.properties['id'],
"ASSERTS",
endnode_type='concept')
condition.link(
self.cond.properties['id'],
self.cont.properties['id'],
"HASCONTRAST",
endnode_type='contrast')
concept.link(
self.con.properties['id'],
self.cont.properties['id'],
"MEASUREDBY",
endnode_type='contrast')
def tearDown(self):
self.task1.delete_related()
self.task2.delete_related()
self.cond.delete_related()
self.cont.delete_related()
self.con.delete_related()
self.task1.delete()
self.task2.delete()
self.cond.delete()
self.cont.delete()
self.con.delete()
def test_task_get_contrasts(self):
contrasts = self.task.get_contrasts(self.task1.properties['id'])
self.assertEqual(len(contrasts), 1)
self.assertEqual(
contrasts[0]['contrast_id'],
self.cont.properties['id'])
def test_task_get_conditions(self):
conditions = self.task.get_conditions(self.task1.properties['id'])
self.assertEqual(len(conditions), 1)
self.assertEqual(
conditions[0]['condition_id'],
self.cond.properties['id'])
def test_contrast_get_conditions(self):
contrast = Contrast()
conditions = contrast.get_conditions(self.cont.properties['id'])
self.assertEqual(len(conditions), 1)
self.assertEqual(
conditions[0]['condition_id'],
self.cond.properties['id'])
def test_contrast_get_concepts(self):
contrast = Contrast()
concepts = contrast.get_concepts(self.cont.properties['id'])
self.assertEqual(len(concepts), 1)
self.assertEqual(concepts[0]['concept_id'], self.con.properties['id'])
def test_contrast_get_tasks(self):
contrast = Contrast()
tasks = contrast.get_tasks(self.cont.properties['id'])
self.assertEqual(len(tasks), 1)
self.assertEqual(tasks[0]['task_id'], self.task1.properties['id'])
def task_json(request,uid):
nodes = Task.graph(uid)
return JsonResponse(nodes)
def setUp(self):
task = Task()
self.task = task.create("test_view_task", {
"prop": "prop",
"definition": "definition"
})
from cognitive.apps.atlas.query import Concept, Task, Disorder, Theory, Battery
Concept = Concept()
Task = Task()
Disorder = Disorder()
Theory = Theory()
Battery = Battery()
# Needed on all pages
counts = {"disorders":Disorder.count(),
"tasks":Task.count(),
"concepts":Concept.count(),
"theories":Theory.count(),
"batteries":Battery.count()}
def counts_processor(request):
return {'counts': counts}
def task_json(request, uid):
nodes = Task.get_full(uid, 'id')
return JsonResponse(nodes)
def task_graph(request,uid):
nodes = Task.graph(uid)
context = {"graph":nodes}
return render(request,"graph/task.html",context)
class GraphUtilsTest(TestCase):
def setUp(self):
self.task = Task()
self.node_name = "test_name"
self.node_properties = {'test_key': 'test_value'}
self.graph = Graph("http://graphdb:7474/db/data/")
self.task1 = self.task.create(
name=self.node_name,
properties=self.node_properties)
self.task2 = self.task.create(
name=self.node_name,
properties=self.node_properties)
condition = Condition()
self.cond = condition.create(
name=self.node_name,
properties=self.node_properties)
contrast = Contrast()
self.cont = contrast.create(
name=self.node_name,
properties=self.node_properties)
concept = Concept()
self.con = concept.create(
name=self.node_name,
properties=self.node_properties)
self.task.link(
self.task1.properties['id'],
self.cond.properties['id'],
"HASCONDITION",
endnode_type='condition')
self.task.link(
self.task1.properties['id'],
self.con.properties['id'],
"ASSERTS",
endnode_type='concept')
condition.link(
self.cond.properties['id'],
self.cont.properties['id'],
"HASCONTRAST",
endnode_type='contrast')
concept.link(
self.con.properties['id'],
self.cont.properties['id'],
"MEASUREDBY",
endnode_type='contrast')
def tearDown(self):
self.task1.delete_related()
self.task2.delete_related()
self.cond.delete_related()
self.cont.delete_related()
self.con.delete_related()
self.task1.delete()
self.task2.delete()
self.cond.delete()
self.cont.delete()
self.con.delete()
def test_search(self):
# we create 5 nodes all with the same name, this should find them all
result = search('test_name')
self.assertEqual(len(result), 5)
'''
def test_get(self):
result = get(self.task1.properties['name'])
self.assertEqual(len(result), 1)
'''
''' ignoring gist functions for now
from cognitive.apps.atlas.query import Concept, Task, Disorder, Theory, Battery
from django.shortcuts import render, render_to_response
from django.template import RequestContext
from cognitive.settings import DOMAIN
from django.shortcuts import render
from django.template import loader
Concept = Concept()
Task = Task()
Disorder = Disorder()
Theory = Theory()
Battery = Battery()
def base(request):
# We only need id and name for the home page
fields = ["id","name"]
concepts = Concept.all(limit=10,order_by="last_updated",fields=fields)
tasks = Task.all(limit=10,order_by="last_updated",fields=fields)
disorders = Disorder.all(limit=10,order_by="last_updated",fields=fields)
theories = Theory.all(limit=7,order_by="last_updated",fields=fields)
appname = "The Cognitive Atlas"
context = {'appname': appname,
'active':'homepage',
'concepts':concepts,
'tasks':tasks,
'theories':theories,
'disorders':disorders}
