def obj_get(self, bundle, **kwargs):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
lemma = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + kwargs['pk'] + '/')
# ge the data of the word
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = lemma.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
# get the values
values = lemma.relationships.outgoing(types=["values"])
valuesArray = []
for v in range(0, len(values), 1):
val = values[v].end
val.properties['resource_uri'] = API_PATH + 'word/' + str(val.id) + '/'
val.properties['translations'] = []
# get the full translation # force API into full representation if cache is enabled
if bundle.request.GET.get('full'):
translations = gdb.query("""MATCH (d:`Word`)-[:translation]->(w:`Word`) WHERE d.CTS='""" + val.properties['CTS'] + """' RETURN DISTINCT w ORDER BY ID(w)""")
translationArray = []
for t in translations:
trans = t[0]
transurl = trans['self'].split('/')
trans['data']['resource_uri'] = API_PATH + 'word/' + transurl[len(transurl)-1] + '/'
translationArray.append(trans['data'])
val.properties['translations'] = translationArray
valuesArray.append(val.properties)
new_obj.__dict__['_data']['values'] = valuesArray
return new_obj
def obj_get(self, bundle, **kwargs):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
document = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + kwargs['pk'] + '/')
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = document.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
new_obj.__dict__['_data']['user'] = str(document.relationships.incoming(types=["owns"])[0].start.properties['username'])
sentences = gdb.query("""MATCH (u:`User`)-[:owns]->(d:`UserDocument`)-[:sentences]->(s:`UserSentence`) WHERE d.CTS='""" +document.properties['CTS']+ """' RETURN DISTINCT s ORDER BY ID(s)""")
sentenceArray = []
for s in sentences:
sent = s[0]
url = sent['self'].split('/')
# this might seems a little hacky, but API resources are very decoupled,
# which gives us great performance instead of creating relations amongst objects and referencing/dereferencing foreign keyed fields
sent['data']['resource_uri'] = API_PATH + 'user_sentence/' + url[len(url)-1] + '/'
sentenceArray.append(sent['data'])
new_obj.__dict__['_data']['sentences'] = sentenceArray
# get a dictionary of related translations of this document
relatedDocuments = gdb.query("""MATCH (d:`UserDocument`)-[:sentences]->(s:`UserSentence`)-[:words]->(w:`Word`)-[:translation]->(t:`Word`)<-[:words]-(s1:`Sentence`)<-[:sentences]-(d1:`Document`) WHERE HAS (d.CTS) AND d.CTS='""" + document.properties['CTS'] + """' RETURN DISTINCT d1 ORDER BY ID(d1)""")
new_obj.__dict__['_data']['translations']={}
for rd in relatedDocuments:
doc = rd[0]
url = doc['self'].split('/')
if doc['data']['lang'] in CTS_LANG:
new_obj.__dict__['_data']['translations'][doc['data']['lang']] = doc['data']
new_obj.__dict__['_data']['translations'][doc['data']['lang']]['resource_uri']= API_PATH + 'document/' + url[len(url)-1] +'/'
return new_obj
def obj_get(self, bundle, **kwargs):
# query parameters (optional) for short sentence approach
attrlist = ['CTS', 'length', 'case', 'dialect', 'head', 'form', 'posClass', 'cid', 'gender', 'tbwid', 'pos', 'value', 'degree', 'number','lemma', 'relation', 'isIndecl', 'ref', 'posAdd', 'mood', 'tense', 'voice', 'person']
query_params = {}
for obj in bundle.request.GET.keys():
if obj in attrlist and bundle.request.GET.get(obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
elif obj.split('__')[0] in attrlist and bundle.request.GET.get(obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
sentence = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + kwargs['pk'] + '/')
documentNode = sentence.relationships.incoming(types=["sentences"])[0].start
# get the sentence parameters
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = sentence.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
new_obj.__dict__['_data']['document_resource_uri'] = API_PATH + 'user_document/' + str(sentence.relationships.incoming(types=["sentences"])[0].start.id) + '/'
new_obj.__dict__['_data']['user'] = str(documentNode.relationships.incoming(types=["owns"])[0].start.properties['username'])
# get a dictionary of related translation of this sentence # shall this be more strict (only user)
relatedSentences = gdb.query("""MATCH (s:`UserSentence`)-[:words]->(w:`Word`)-[:translation]->(t:`Word`)<-[:words]-(s1:`Sentence`) WHERE HAS (s.CTS) AND s.CTS='""" + sentence.properties['CTS'] + """' RETURN DISTINCT s1 ORDER BY ID(s1)""")
new_obj.__dict__['_data']['translations']={}
for rs in relatedSentences:
sent = rs[0]
url = sent['self'].split('/')
for lang in CTS_LANG:
if sent['data']['CTS'].find(lang) != -1:
new_obj.__dict__['_data']['translations'][lang] = API_PATH + 'sentence/' + url[len(url)-1] +'/'
# get the words and related information
words = gdb.query("""MATCH (d:`UserSentence`)-[:words]->(w:`Word`) WHERE d.CTS='""" +sentence.properties['CTS']+ """' RETURN DISTINCT w ORDER BY ID(w)""")
wordArray = []
for w in words:
word = w[0]
url = word['self'].split('/')
word['data']['resource_uri'] = API_PATH + 'word/' + url[len(url)-1] + '/'
wordNode = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + url[len(url)-1] + '/')
# get the full translation
if bundle.request.GET.get('full'):
translations = gdb.query("""MATCH (d:`Word`)-[:translation]->(w:`Word`) WHERE d.CTS='""" +wordNode.properties['CTS']+ """' RETURN DISTINCT w ORDER BY ID(w)""")
translationArray = []
for t in translations:
trans = t[0]
transurl = trans['self'].split('/')
trans['data']['resource_uri'] = API_PATH + 'word/' + transurl[len(transurl)-1] + '/'
translationArray.append(trans['data'])
word['data']['translations'] = translationArray
wordArray.append(word['data'])
new_obj.__dict__['_data']['words'] = wordArray
return new_obj
def obj_get(self, bundle, **kwargs):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
submission = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + kwargs['pk'] + '/')
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = submission.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
try:
auth_result = self._meta.authorization.read_detail(new_obj, bundle)
except Unauthorized as e:
self.unauthorized_result(e)
return auth_result
def obj_get(self, bundle, **kwargs):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
submission = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" +
kwargs['pk'] + '/')
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = submission.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
try:
auth_result = self._meta.authorization.read_detail(new_obj, bundle)
except Unauthorized as e:
self.unauthorized_result(e)
return auth_result
def obj_get(self, bundle, **kwargs):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
word = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + kwargs['pk'] +
'/')
# ge the data of the word
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = word.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
new_obj.__dict__['_data'][
'sentence_resource_uri'] = API_PATH + 'sentence/' + str(
word.relationships.incoming(types=["words"])[0].start.id) + '/'
# get the lemma
lemmaRels = word.relationships.incoming(types=["values"])
if len(lemmaRels) > 0:
new_obj.__dict__['_data'][
'lemma_resource_uri'] = API_PATH + 'lemma/' + str(
lemmaRels[0].start.id) + '/'
translations = gdb.query(
"""MATCH (d:`Word`)-[:translation]->(w:`Word`) WHERE d.CTS='""" +
word.properties['CTS'] + """' RETURN DISTINCT w ORDER BY ID(w)""")
translationArray = []
for t in translations:
trans = t[0]
url = trans['self'].split('/')
trans['data']['resource_uri'] = API_PATH + 'word/' + url[len(url) -
1] + '/'
translationArray.append(trans['data'])
new_obj.__dict__['_data']['translations'] = translationArray
return new_obj
def obj_get(self, bundle, **kwargs):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
lemma = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" +
kwargs['pk'] + '/')
# ge the data of the word
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = lemma.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
# get the values
values = lemma.relationships.outgoing(types=["values"])
valuesArray = []
for v in range(0, len(values), 1):
val = values[v].end
val.properties['resource_uri'] = API_PATH + 'word/' + str(
val.id) + '/'
val.properties['translations'] = []
# get the full translation # force API into full representation if cache is enabled
if bundle.request.GET.get('full'):
translations = gdb.query(
"""MATCH (d:`Word`)-[:translation]->(w:`Word`) WHERE d.CTS='"""
+ val.properties['CTS'] +
"""' RETURN DISTINCT w ORDER BY ID(w)""")
translationArray = []
for t in translations:
trans = t[0]
transurl = trans['self'].split('/')
trans['data'][
'resource_uri'] = API_PATH + 'word/' + transurl[
len(transurl) - 1] + '/'
translationArray.append(trans['data'])
val.properties['translations'] = translationArray
valuesArray.append(val.properties)
new_obj.__dict__['_data']['values'] = valuesArray
return new_obj
def obj_get(self, bundle, **kwargs):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
word = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + kwargs['pk'] + '/')
# ge the data of the word
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = word.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
new_obj.__dict__['_data']['sentence_resource_uri'] = API_PATH + 'sentence/' + str(word.relationships.incoming(types=["words"])[0].start.id) + '/'
# get the lemma
lemmaRels = word.relationships.incoming(types=["values"])
if len(lemmaRels) > 0:
new_obj.__dict__['_data']['lemma_resource_uri'] = API_PATH + 'lemma/' + str(lemmaRels[0].start.id) + '/'
translations = gdb.query("""MATCH (d:`Word`)-[:translation]->(w:`Word`) WHERE d.CTS='""" +word.properties['CTS']+ """' RETURN DISTINCT w ORDER BY ID(w)""")
translationArray = []
for t in translations:
trans = t[0]
url = trans['self'].split('/')
trans['data']['resource_uri'] = API_PATH + 'word/' + url[len(url)-1] + '/'
translationArray.append(trans['data'])
new_obj.__dict__['_data']['translations'] = translationArray
return new_obj
def obj_get(self, bundle, **kwargs):
# get the actually cached objects
if cache.get("sentence_%s" %
kwargs['pk']) is not None and not bundle.request.GET.get(
'full') and not bundle.request.GET.get('short'):
return cache.get("sentence_%s" % kwargs['pk'])
elif bundle.request.GET.get(
'short') and not bundle.request.GET.get('full') and cache.get(
"sentence_short_%s" % kwargs['pk']) is not None:
return cache.get("sentence_short_%s" % kwargs['pk'])
elif bundle.request.GET.get(
'full') and not bundle.request.GET.get('short') and cache.get(
"sentence_full_%s" % kwargs['pk']) is not None:
return cache.get("sentence_full_%s" % kwargs['pk'])
elif cache.get(
"sentence_full_short%s" %
kwargs['pk']) is not None and not bundle.request.GET.get(
'full') and not bundle.request.GET.get('short'):
return cache.get("sentence_full_short_%s" % kwargs['pk'])
# query parameters (optional) for short sentence approach
attrlist = [
'CTS', 'length', 'case', 'dialect', 'head', 'form', 'posClass',
'cid', 'gender', 'tbwid', 'pos', 'value', 'degree', 'number',
'lemma', 'relation', 'isIndecl', 'ref', 'posAdd', 'mood', 'tense',
'voice', 'person'
]
query_params = {}
for obj in bundle.request.GET.keys():
if obj in attrlist and bundle.request.GET.get(obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
elif obj.split('__')[0] in attrlist and bundle.request.GET.get(
obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
sentence = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" +
kwargs['pk'] + '/')
# get the sentence parameters
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = sentence.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
new_obj.__dict__['_data'][
'document_resource_uri'] = API_PATH + 'document/' + str(
sentence.relationships.incoming(
types=["sentences"])[0].start.id) + '/'
# get a dictionary of related translation of this sentence
relatedSentences = gdb.query(
"""MATCH (s:`Sentence`)-[:words]->(w:`Word`)-[:translation]->(t:`Word`)<-[:words]-(s1:`Sentence`) WHERE HAS (s.CTS) AND s.CTS='"""
+ sentence.properties['CTS'] +
"""' RETURN DISTINCT s1 ORDER BY ID(s1)""")
new_obj.__dict__['_data']['translations'] = {}
for rs in relatedSentences:
sent = rs[0]
url = sent['self'].split('/')
for lang in CTS_LANG:
if sent['data']['CTS'].find("-" + lang + ":") != -1:
new_obj.__dict__['_data']['translations'][
lang] = API_PATH + 'sentence/' + url[len(url) -
1] + '/'
# get the words and lemma resource uri of the sentence
words = gdb.query(
"""MATCH (d:`Sentence`)-[:words]->(w:`Word`) WHERE d.CTS='""" +
sentence.properties['CTS'] +
"""' RETURN DISTINCT w ORDER BY ID(w)""")
wordArray = []
for w in words:
word = w[0]
url = word['self'].split('/')
word['data']['resource_uri'] = API_PATH + 'word/' + url[len(url) -
1] + '/'
wordNode = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" +
url[len(url) - 1] + '/')
# get the lemma
lemmaRels = wordNode.relationships.incoming(types=["values"])
if len(lemmaRels) > 0:
word['data']['lemma_resource_uri'] = API_PATH + 'lemma/' + str(
lemmaRels[0].start.id) + '/'
# get the translations of a word if parameter is set
if bundle.request.GET.get('full'):
translations = gdb.query(
"""MATCH (d:`Word`)-[:translation]->(w:`Word`) WHERE d.CTS='"""
+ wordNode.properties['CTS'] +
"""' RETURN DISTINCT w ORDER BY ID(w)""")
translationArray = []
for t in translations:
trans = t[0]
transurl = trans['self'].split('/')
trans['data'][
'resource_uri'] = API_PATH + 'word/' + transurl[
len(transurl) - 1] + '/'
translationArray.append(trans['data'])
word['data']['translations'] = translationArray
wordArray.append(word['data'])
wordArray = sort_words(wordArray)
# if short=True return only words of the short sentence
if bundle.request.GET.get('short'):
wordArray = self.shorten(wordArray, query_params)
if wordArray is None:
#return None
raise BadRequest("Sentence doesn't hit your query.")
new_obj.__dict__['_data']['words'] = wordArray
# deal with caching here -> all are different objects
if bundle.request.GET.get('full') and bundle.request.GET.get('short'):
if cache.get("sentence_full_short_%s" % kwargs['pk']) is None:
cache.set("sentence_full_short_%s" % kwargs['pk'], new_obj,
None)
if bundle.request.GET.get('short'):
if cache.get("sentence_short_%s" % kwargs['pk']) is None:
cache.set("sentence_short_%s" % kwargs['pk'], new_obj, None)
elif bundle.request.GET.get('full'):
if cache.get("sentence_full_%s" % kwargs['pk']) is None:
cache.set("sentence_full_%s" % kwargs['pk'], new_obj, None)
else:
if cache.get("sentence_%s" % kwargs['pk']) is None:
cache.set("sentence_%s" % kwargs['pk'], new_obj, None)
return new_obj
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['CTS', 'length', 'sentence']
sentences = []
query_params = {}
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(
obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (d:`Document`)-[:sentences]->(s:`Sentence`) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """=~'""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """' AND """
elif key.split('__')[1] == 'gt':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split('__')[
0] + """>""" + query_params[key] + """ AND """
elif key.split('__')[1] == 'lt':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split('__')[
0] + """<""" + query_params[key] + """ AND """
elif key.split('__')[1] == 'isnot':
if key.split('__')[0] == 'length':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """<>""" + query_params[
key] + """ AND """
else:
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """<>'""" + query_params[
key] + """' AND """
else:
if key == 'length':
q = q + """HAS (s.""" + key + """) AND s.""" + key + """=""" + query_params[
key] + """ AND """
else:
q = q + """HAS (s.""" + key + """) AND s.""" + key + """='""" + query_params[
key] + """' AND """
q = q[:len(q) - 4]
q = q + """RETURN s, d ORDER BY ID(s)"""
table = gdb.query(q)
# default querying
else:
table = gdb.query(
"""MATCH (d:`Document`)-[:sentences]->(s:`Sentence`) WHERE HAS (s.CTS) RETURN s, d ORDER BY ID(s)"""
)
# create the objects which was queried for and set all necessary attributes
for t in table:
sentence = t[0]
document = t[1]
url = sentence['self'].split('/')
urlDoc = document['self'].split('/')
new_obj = DataObject(url[len(url) - 1])
new_obj.__dict__['_data'] = sentence['data']
new_obj.__dict__['_data']['id'] = url[len(url) - 1]
new_obj.__dict__['_data'][
'document_resource_uri'] = API_PATH + 'document/' + urlDoc[
len(urlDoc) - 1] + '/'
sentences.append(new_obj)
if ENABLE_DISPLAYING_LONG_DOCUMENTS:
if len(sentences) > 500:
return sentences
else:
return sort_sentences(sentences)
else:
return sort_sentences(sentences)
return sort_sentences(sentences)
def read_list(self, object_list, bundle):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['response', 'task', 'ref', 'user', 'starttime', 'timestamp', 'accuracy']
query_params = {}
for obj in bundle.request.GET.keys():
if obj in attrlist and bundle.request.GET.get(obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
elif obj.split('__')[0] in attrlist and bundle.request.GET.get(obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (u:`User`)-[:submits]->(s:`Submission`) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """' AND """
elif key.split('__')[1] == 'isnot':
if key.split('__')[0] == 'accuracy':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<>""" +query_params[key]+ """ AND """
else:
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<>'""" +query_params[key]+ """' AND """
elif key.split('__')[1] == 'gt':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """>""" +query_params[key]+ """ AND """
elif key.split('__')[1] == 'lt':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<""" +query_params[key]+ """ AND """
else:
if key == 'accuracy':
q = q + """HAS (s.""" +key+ """) AND s.""" +key+ """=""" +query_params[key]+ """ AND """
else:
q = q + """HAS (s.""" +key+ """) AND s.""" +key+ """='""" +query_params[key]+ """' AND """
q = q[:len(q)-4]
q = q + """RETURN s"""
table = gdb.query(q)
# ordinary querying
else:
table = gdb.query("""MATCH (u:`User`)-[:submits]->(s:`Submission`) WHERE HAS (u.username) AND u.username='******' RETURN s""")
# create the objects which was queried for and set all necessary attributes
submissions = []
for s in table:
submission = s[0]
url = submission['self'].split('/')
new_obj = DataObject(url[len(url)-1])
new_obj.__dict__['_data'] = submission['data']
new_obj.__dict__['_data']['id'] = url[len(url)-1]
new_obj.__dict__['_data']['user'] = bundle.request.user.username
submissions.append(new_obj)
return submissions
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['CTS', 'length', 'sentence']
sentences = []
query_params = {}
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (u:`User`)-[:owns]->(d:UserDocument)-[:sentences]->(s:UserSentence) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """' AND """
elif key.split('__')[1] == 'gt':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """>""" +query_params[key]+ """ AND """
elif key.split('__')[1] == 'lt':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<""" +query_params[key]+ """ AND """
elif key.split('__')[1] == 'isnot':
if key.split('__')[0] == 'length':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<>""" +query_params[key]+ """ AND """
else:
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<>'""" +query_params[key]+ """' AND """
else:
if key == 'length':
q = q + """HAS (s.""" +key+ """) AND s.""" +key+ """=""" +query_params[key]+ """ AND """
else:
q = q + """HAS (s.""" +key+ """) AND s.""" +key+ """='""" +query_params[key]+ """' AND """
# is user set if params not empty?
if request.GET.get('user'):
q = q + """ u.username='******'user') + """' RETURN s, d, u.username ORDER BY ID(s)"""
else:
q = q[:len(q)-4]
q = q + """RETURN s, d, u.username ORDER BY ID(s)"""
table = gdb.query(q)
# default querying
else:
# is user set if params are empty?
if request.GET.get('user'):
table = gdb.query("""MATCH (u:`User`)-[:owns]->(d:`UserDocument`)-[:sentences]->(s:UserSentence) WHERE u.username='******'user') + """' RETURN DISTINCT s, d, u.username ORDER BY ID(d)""")
else:
table = gdb.query("""MATCH (u:`User`)-[:owns]->(d:UserDocument)-[:sentences]->(s:UserSentence) RETURN s, d, u.username ORDER BY ID(s)""")
# create the objects which was queried for and set all necessary attributes
for t in table:
sentence = t[0]
document = t[1]
user = t[2]
url = sentence['self'].split('/')
urlDoc = document['self'].split('/')
new_obj = DataObject(url[len(url)-1])
new_obj.__dict__['_data'] = sentence['data']
new_obj.__dict__['_data']['id'] = url[len(url)-1]
new_obj.__dict__['_data']['document_resource_uri'] = API_PATH + 'user_document/' + urlDoc[len(urlDoc)-1] +'/'
new_obj.__dict__['_data']['user'] = user
sentences.append(new_obj)
return sentences
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['CITE', 'value', 'posAdd', 'frequency']
lemmas = []
query_params = {}
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (l:`Lemma`)-[:values]->(w:`Word`) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (l.""" +key.split('__')[0]+ """) AND l.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (l.""" +key.split('__')[0]+ """) AND l.""" +key.split('__')[0]+ """=~'""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (l.""" +key.split('__')[0]+ """) AND l.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """' AND """
elif key.split('__')[1] == 'isnot':
if key == 'frequency':
q = q + """HAS (l.""" +key.split('__')[0]+ """) AND l.""" +key.split('__')[0]+ """<>""" +query_params[key]+ """ AND """
else:
q = q + """HAS (l.""" +key.split('__')[0]+ """) AND l.""" +key.split('__')[0]+ """<>'""" +query_params[key]+ """' AND """
elif key.split('__')[1] == 'gt':
q = q + """HAS (l.""" +key.split('__')[0]+ """) AND l.""" +key.split('__')[0]+ """>""" +query_params[key]+ """ AND """
elif key.split('__')[1] == 'lt':
q = q + """HAS (l.""" +key.split('__')[0]+ """) AND l.""" +key.split('__')[0]+ """<""" +query_params[key]+ """ AND """
else:
if key == 'frequency':
q = q + """HAS (l.""" +key+ """) AND l.""" +key+ """=""" +query_params[key]+ """ AND """
else:
q = q + """HAS (l.""" +key+ """) AND l.""" +key+ """='""" +query_params[key]+ """' AND """
q = q[:len(q)-4]
q = q + """RETURN DISTINCT l ORDER BY ID(l)"""
table = gdb.query(q)
# default querying
else:
table = gdb.query("""MATCH (l:`Lemma`)-[:values]->(w:`Word`) WHERE HAS (l.CITE) RETURN DISTINCT l ORDER BY ID(l)""")
# create the objects which was queried for and set all necessary attributes
for t in table:
lemma = t[0]
url = lemma['self'].split('/')
new_obj = DataObject(url[len(url)-1])
new_obj.__dict__['_data'] = lemma['data']
new_obj.__dict__['_data']['id'] = url[len(url)-1]
# get the word as a node to query relations
lemmaNode = gdb.nodes.get(lemma['self'])
values = lemmaNode.relationships.outgoing(types=["values"])
valuesArray = []
for v in range(0, len(values), 1):
val = values[v].end
val.properties['resource_uri'] = API_PATH + 'word/' + str(val.id) + '/'
valuesArray.append(val.properties)
new_obj.__dict__['_data']['values'] = valuesArray
lemmas.append(new_obj)
return lemmas
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['lang','CTS', 'length', 'case', 'dialect', 'head', 'form', 'posClass', 'cid', 'gender', 'tbwid', 'pos', 'value', 'degree', 'number','lemma', 'relation', 'isIndecl', 'ref', 'posAdd', 'mood', 'tense', 'voice', 'person']
words = []
query_params = {}
if request.GET.get('ref'):
try:
grammarParams = Grammar.objects.filter(ref=request.GET.get('ref'))[0].query.split('&')
for pair in grammarParams:
query_params[pair.split('=')[0]] = pair.split('=')[1]
except KeyError as k:
return words
# query by ordinary filters
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (s:`Sentence`)-[:words]->(w:`Word`) WHERE """
# filter word on parameters
for key in query_params:
# fuzzy match
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
# multi values
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w."""+key.split('__')[0]+ """=~'.*""" +chunk+ """.*' OR """
q = q[:len(q)-3]
q = q + """) AND """
# one value
else:
q = q + """HAS (w.""" +key.split('__')[0]+ """) AND w.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'startswith':
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w."""+key.split('__')[0]+ """=~'""" +chunk+ """.*' OR """
q = q[:len(q)-3]
q = q + """) AND """
else:
q = q + """HAS (w.""" +key.split('__')[0]+ """) AND w.""" +key.split('__')[0]+ """=~'""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'endswith':
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w."""+key.split('__')[0]+ """=~'.*""" +chunk+ """' OR """
q = q[:len(q)-3]
q = q + """) AND """
else:
q = q + """HAS (w.""" +key.split('__')[0]+ """) AND w.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """' AND """
# only for integer values
elif key.split('__')[1] == 'gt':
q = q + """HAS (w.""" +key.split('__')[0]+ """) AND w.""" +key.split('__')[0]+ """>""" +query_params[key]+ """ AND """
# only for integer values
elif key.split('__')[1] == 'lt':
q = q + """HAS (w.""" +key.split('__')[0]+ """) AND w.""" +key.split('__')[0]+ """<""" +query_params[key]+ """ AND """
# negated match
elif key.split('__')[1] == 'isnot':
# integer values
if key.split('__')[0] in ['tbwid', 'head', 'length', 'cid']:
# multiple values
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w."""+key.split('__')[0]+ """<>""" +chunk+ """ OR """
q = q[:len(q)-3]
q = q + """) AND """
# one value
else:
q = q + """HAS (w.""" +key.split('__')[0]+ """) AND w.""" +key.split('__')[0]+ """<>""" +query_params[key]+ """ AND """
# string values
else:
# multi values
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w."""+key.split('__')[0]+ """<>'""" +chunk+ """' OR """
q = q[:len(q)-3]
q = q + """) AND """
# one value
else:
q = q + """HAS (w.""" +key.split('__')[0]+ """) AND w.""" +key.split('__')[0]+ """<>'""" +query_params[key]+ """' AND """
# perfect match
else:
# integer values
if key in ['tbwid', 'head', 'length', 'cid']:
# multi values
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w."""+key.split('__')[0]+ """=""" +chunk+ """ OR """
q = q[:len(q)-3]
q = q + """) AND """
# one value
else:
q = q + """HAS (w.""" +key+ """) AND w.""" +key+ """=""" +query_params[key]+ """ AND """
# string values
else:
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w."""+key.split('__')[0]+ """='""" +chunk+ """' OR """
q = q[:len(q)-3]
q = q + """) AND """
else:
q = q + """HAS (w.""" +key+ """) AND w.""" +key+ """='""" +query_params[key]+ """' AND """
q = q[:len(q)-4]
q = q + """RETURN w, s ORDER BY ID(w)"""
table = gdb.query(q)
# create the objects which was queried for and set all necessary attributes
for t in table:
word = t[0]
sentence = t[1]
url = word['self'].split('/')
urlSent = sentence['self'].split('/')
new_obj = DataObject(url[len(url)-1])
new_obj.__dict__['_data'] = word['data']
new_obj.__dict__['_data']['id'] = url[len(url)-1]
new_obj.__dict__['_data']['sentence_resource_uri'] = API_PATH + 'sentence/' + urlSent[len(urlSent)-1] +'/'
words.append(new_obj)
if ENABLE_WORD_LIST_SORTING:
return sort_object_words(words[:500])
else:
return words
#return words
# default querying on big dataset (CTS required)
elif request.GET.get('document_CTS'):
# delted this so our word list is smaller
#documentTable = gdb.query("""MATCH (n:`Document`) RETURN n ORDER BY ID(n)""")
#for d in documentTable:
#document = d[0]
wordTable = gdb.query("""MATCH (d:`Document`)-[:sentences]->(s:`Sentence`)-[:words]->(w:`Word`) WHERE d.CTS = '""" + request.GET.get('document_CTS') + """' RETURN w,s ORDER BY ID(w)""")
# get sent id
for w in wordTable:
word = w[0]
sentence = w[1]
url = word['self'].split('/')
urlSent = sentence['self'].split('/')
new_obj = DataObject(url[len(url)-1])
new_obj.__dict__['_data'] = word['data']
new_obj.__dict__['_data']['id'] = url[len(url)-1]
new_obj.__dict__['_data']['sentence_resource_uri'] = API_PATH + 'sentence/' + urlSent[len(urlSent)-1] +'/'
words.append(new_obj)
if ENABLE_WORD_LIST_SORTING:
return sort_object_words(words[:500])
else:
return words
# no parameter for filtering, return empty
else:
return words
def obj_get(self, bundle, **kwargs):
# get the actually cached objects
if cache.get("sentence_%s"%kwargs['pk']) is not None and not bundle.request.GET.get('full') and not bundle.request.GET.get('short'):
return cache.get("sentence_%s"%kwargs['pk'])
elif bundle.request.GET.get('short') and not bundle.request.GET.get('full') and cache.get("sentence_short_%s"%kwargs['pk']) is not None:
return cache.get("sentence_short_%s"%kwargs['pk'])
elif bundle.request.GET.get('full') and not bundle.request.GET.get('short') and cache.get("sentence_full_%s"%kwargs['pk']) is not None:
return cache.get("sentence_full_%s"%kwargs['pk'])
elif cache.get("sentence_full_short%s"%kwargs['pk']) is not None and not bundle.request.GET.get('full') and not bundle.request.GET.get('short'):
return cache.get("sentence_full_short_%s"%kwargs['pk'])
# query parameters (optional) for short sentence approach
attrlist = ['CTS', 'length', 'case', 'dialect', 'head', 'form', 'posClass', 'cid', 'gender', 'tbwid', 'pos', 'value', 'degree', 'number','lemma', 'relation', 'isIndecl', 'ref', 'posAdd', 'mood', 'tense', 'voice', 'person']
query_params = {}
for obj in bundle.request.GET.keys():
if obj in attrlist and bundle.request.GET.get(obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
elif obj.split('__')[0] in attrlist and bundle.request.GET.get(obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
sentence = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + kwargs['pk'] + '/')
# get the sentence parameters
new_obj = DataObject(kwargs['pk'])
new_obj.__dict__['_data'] = sentence.properties
new_obj.__dict__['_data']['id'] = kwargs['pk']
new_obj.__dict__['_data']['document_resource_uri'] = API_PATH + 'document/' + str(sentence.relationships.incoming(types=["sentences"])[0].start.id) + '/'
# get a dictionary of related translation of this sentence
relatedSentences = gdb.query("""MATCH (s:`Sentence`)-[:words]->(w:`Word`)-[:translation]->(t:`Word`)<-[:words]-(s1:`Sentence`) WHERE HAS (s.CTS) AND s.CTS='"""+ sentence.properties['CTS'] + """' RETURN DISTINCT s1 ORDER BY ID(s1)""")
new_obj.__dict__['_data']['translations']={}
for rs in relatedSentences:
sent = rs[0]
url = sent['self'].split('/')
for lang in CTS_LANG:
if sent['data']['CTS'].find("-"+lang+":") != -1:
new_obj.__dict__['_data']['translations'][lang] = API_PATH + 'sentence/' + url[len(url)-1] +'/'
# get the words and lemma resource uri of the sentence
words = gdb.query("""MATCH (d:`Sentence`)-[:words]->(w:`Word`) WHERE d.CTS='""" +sentence.properties['CTS']+ """' RETURN DISTINCT w ORDER BY ID(w)""")
wordArray = []
for w in words:
word = w[0]
url = word['self'].split('/')
word['data']['resource_uri'] = API_PATH + 'word/' + url[len(url)-1] + '/'
wordNode = gdb.nodes.get(GRAPH_DATABASE_REST_URL + "node/" + url[len(url)-1] + '/')
# get the lemma
lemmaRels = wordNode.relationships.incoming(types=["values"])
if len(lemmaRels) > 0:
word['data']['lemma_resource_uri'] = API_PATH + 'lemma/' + str(lemmaRels[0].start.id) + '/'
# get the translations of a word if parameter is set
if bundle.request.GET.get('full'):
translations = gdb.query("""MATCH (d:`Word`)-[:translation]->(w:`Word`) WHERE d.CTS='""" +wordNode.properties['CTS']+ """' RETURN DISTINCT w ORDER BY ID(w)""")
translationArray = []
for t in translations:
trans = t[0]
transurl = trans['self'].split('/')
trans['data']['resource_uri'] = API_PATH + 'word/' + transurl[len(transurl)-1] + '/'
translationArray.append(trans['data'])
word['data']['translations'] = translationArray
wordArray.append(word['data'])
wordArray = sort_words(wordArray)
# if short=True return only words of the short sentence
if bundle.request.GET.get('short'):
wordArray = self.shorten(wordArray, query_params)
if wordArray is None:
#return None
raise BadRequest("Sentence doesn't hit your query.")
new_obj.__dict__['_data']['words'] = wordArray
# deal with caching here -> all are different objects
if bundle.request.GET.get('full') and bundle.request.GET.get('short'):
if cache.get("sentence_full_short_%s"%kwargs['pk']) is None:
cache.set("sentence_full_short_%s"%kwargs['pk'], new_obj, None)
if bundle.request.GET.get('short'):
if cache.get("sentence_short_%s"%kwargs['pk']) is None:
cache.set("sentence_short_%s"%kwargs['pk'], new_obj, None)
elif bundle.request.GET.get('full'):
if cache.get("sentence_full_%s"%kwargs['pk']) is None:
cache.set("sentence_full_%s"%kwargs['pk'], new_obj, None)
else:
if cache.get("sentence_%s"%kwargs['pk']) is None:
cache.set("sentence_%s"%kwargs['pk'], new_obj, None)
return new_obj
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['CTS', 'name', 'name_eng', 'lang', 'author']
documents = []
query_params = {}
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(
obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (d:`Document`)-[:sentences]->(s:`Sentence`) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (d.""" + key.split(
'__')[0] + """) AND d.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (d.""" + key.split(
'__')[0] + """) AND d.""" + key.split(
'__')[0] + """=~'""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (d.""" + key.split(
'__')[0] + """) AND d.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """' AND """
elif key.split('__')[1] == 'isnot':
q = q + """HAS (d.""" + key.split(
'__')[0] + """) AND d.""" + key.split(
'__'
)[0] + """<>'""" + query_params[key] + """' AND """
else:
q = q + """HAS (d.""" + key + """) AND d.""" + key + """='""" + query_params[
key] + """' AND """
q = q[:len(q) - 4]
q = q + """RETURN DISTINCT d ORDER BY ID(d)"""
table = gdb.query(q)
# default querying
else:
table = gdb.query(
"""MATCH (d:`Document`) RETURN DISTINCT d ORDER BY ID(d)""")
# create the objects which was queried for and set all necessary attributes
for t in table:
document = t[0]
urlDoc = document['self'].split('/')
new_obj = DataObject(urlDoc[len(urlDoc) - 1])
new_obj.__dict__['_data'] = document['data']
new_obj.__dict__['_data']['id'] = urlDoc[len(urlDoc) - 1]
sentences = gdb.query(
"""MATCH (d:`Document`)-[:sentences]->(s:`Sentence`) WHERE d.CTS='"""
+ document['data']['CTS'] +
"""' RETURN DISTINCT s ORDER BY ID(s)""")
sentenceArray = []
for s in sentences:
sent = s[0]
url = sent['self'].split('/')
sent_cts = sent['data']['CTS']
sent['data'] = {}
sent['data']['resource_uri'] = API_PATH + 'sentence/' + url[
len(url) - 1] + '/'
sent['data']['CTS'] = sent_cts
sentenceArray.append(sent['data'])
if ENABLE_DISPLAYING_LONG_DOCUMENTS:
if len(sentenceArray) > 500:
new_obj.__dict__['_data']['sentences'] = sentenceArray
else:
new_obj.__dict__['_data']['sentences'] = sort_sentences(
sentenceArray)
else:
new_obj.__dict__['_data']['sentences'] = sort_sentences(
sentenceArray)
documents.append(new_obj)
return documents
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['CTS', 'name', 'name_eng', 'lang', 'author']
documents = []
query_params = {}
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (d:`Document`)-[:sentences]->(s:`Sentence`) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (d.""" +key.split('__')[0]+ """) AND d.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (d.""" +key.split('__')[0]+ """) AND d.""" +key.split('__')[0]+ """=~'""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (d.""" +key.split('__')[0]+ """) AND d.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """' AND """
elif key.split('__')[1] == 'isnot':
q = q + """HAS (d.""" +key.split('__')[0]+ """) AND d.""" +key.split('__')[0]+ """<>'""" +query_params[key]+ """' AND """
else:
q = q + """HAS (d.""" +key+ """) AND d.""" +key+ """='""" +query_params[key]+ """' AND """
q = q[:len(q)-4]
q = q + """RETURN DISTINCT d ORDER BY ID(d)"""
table = gdb.query(q)
# default querying
else:
table = gdb.query("""MATCH (d:`Document`) RETURN DISTINCT d ORDER BY ID(d)""")
# create the objects which was queried for and set all necessary attributes
for t in table:
document = t[0]
urlDoc = document['self'].split('/')
new_obj = DataObject(urlDoc[len(urlDoc)-1])
new_obj.__dict__['_data'] = document['data']
new_obj.__dict__['_data']['id'] = urlDoc[len(urlDoc)-1]
sentences = gdb.query("""MATCH (d:`Document`)-[:sentences]->(s:`Sentence`) WHERE d.CTS='""" +document['data']['CTS']+ """' RETURN DISTINCT s ORDER BY ID(s)""")
sentenceArray = []
for s in sentences:
sent = s[0]
url = sent['self'].split('/')
sent_cts = sent['data']['CTS']
sent['data'] = {}
sent['data']['resource_uri'] = API_PATH + 'sentence/' + url[len(url)-1] + '/'
sent['data']['CTS'] = sent_cts
sentenceArray.append(sent['data'])
if ENABLE_DISPLAYING_LONG_DOCUMENTS:
if len(sentenceArray) > 500:
new_obj.__dict__['_data']['sentences'] = sentenceArray
else:
new_obj.__dict__['_data']['sentences'] = sort_sentences(sentenceArray)
else:
new_obj.__dict__['_data']['sentences'] = sort_sentences(sentenceArray)
documents.append(new_obj)
return documents
def read_list(self, object_list, bundle):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = [
'response', 'task', 'ref', 'user', 'starttime', 'timestamp',
'accuracy'
]
query_params = {}
for obj in bundle.request.GET.keys():
if obj in attrlist and bundle.request.GET.get(obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
elif obj.split('__')[0] in attrlist and bundle.request.GET.get(
obj) is not None:
query_params[obj] = bundle.request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (u:`User`)-[:submits]->(s:`Submission`) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """=~'""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """' AND """
elif key.split('__')[1] == 'isnot':
if key.split('__')[0] == 'accuracy':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """<>""" + query_params[
key] + """ AND """
else:
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split(
'__')[0] + """<>'""" + query_params[
key] + """' AND """
elif key.split('__')[1] == 'gt':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split('__')[
0] + """>""" + query_params[key] + """ AND """
elif key.split('__')[1] == 'lt':
q = q + """HAS (s.""" + key.split(
'__')[0] + """) AND s.""" + key.split('__')[
0] + """<""" + query_params[key] + """ AND """
else:
if key == 'accuracy':
q = q + """HAS (s.""" + key + """) AND s.""" + key + """=""" + query_params[
key] + """ AND """
else:
q = q + """HAS (s.""" + key + """) AND s.""" + key + """='""" + query_params[
key] + """' AND """
q = q[:len(q) - 4]
q = q + """RETURN s"""
table = gdb.query(q)
# ordinary querying
else:
table = gdb.query(
"""MATCH (u:`User`)-[:submits]->(s:`Submission`) WHERE HAS (u.username) AND u.username='******' RETURN s""")
# create the objects which was queried for and set all necessary attributes
submissions = []
for s in table:
submission = s[0]
url = submission['self'].split('/')
new_obj = DataObject(url[len(url) - 1])
new_obj.__dict__['_data'] = submission['data']
new_obj.__dict__['_data']['id'] = url[len(url) - 1]
new_obj.__dict__['_data']['user'] = bundle.request.user.username
submissions.append(new_obj)
return submissions
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['CITE', 'value', 'posAdd', 'frequency']
lemmas = []
query_params = {}
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(
obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (l:`Lemma`)-[:values]->(w:`Word`) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (l.""" + key.split(
'__')[0] + """) AND l.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (l.""" + key.split(
'__')[0] + """) AND l.""" + key.split(
'__')[0] + """=~'""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (l.""" + key.split(
'__')[0] + """) AND l.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """' AND """
elif key.split('__')[1] == 'isnot':
if key == 'frequency':
q = q + """HAS (l.""" + key.split(
'__')[0] + """) AND l.""" + key.split(
'__')[0] + """<>""" + query_params[
key] + """ AND """
else:
q = q + """HAS (l.""" + key.split(
'__')[0] + """) AND l.""" + key.split(
'__')[0] + """<>'""" + query_params[
key] + """' AND """
elif key.split('__')[1] == 'gt':
q = q + """HAS (l.""" + key.split(
'__')[0] + """) AND l.""" + key.split('__')[
0] + """>""" + query_params[key] + """ AND """
elif key.split('__')[1] == 'lt':
q = q + """HAS (l.""" + key.split(
'__')[0] + """) AND l.""" + key.split('__')[
0] + """<""" + query_params[key] + """ AND """
else:
if key == 'frequency':
q = q + """HAS (l.""" + key + """) AND l.""" + key + """=""" + query_params[
key] + """ AND """
else:
q = q + """HAS (l.""" + key + """) AND l.""" + key + """='""" + query_params[
key] + """' AND """
q = q[:len(q) - 4]
q = q + """RETURN DISTINCT l ORDER BY ID(l)"""
table = gdb.query(q)
# default querying
else:
table = gdb.query(
"""MATCH (l:`Lemma`)-[:values]->(w:`Word`) WHERE HAS (l.CITE) RETURN DISTINCT l ORDER BY ID(l)"""
)
# create the objects which was queried for and set all necessary attributes
for t in table:
lemma = t[0]
url = lemma['self'].split('/')
new_obj = DataObject(url[len(url) - 1])
new_obj.__dict__['_data'] = lemma['data']
new_obj.__dict__['_data']['id'] = url[len(url) - 1]
# get the word as a node to query relations
lemmaNode = gdb.nodes.get(lemma['self'])
values = lemmaNode.relationships.outgoing(types=["values"])
valuesArray = []
for v in range(0, len(values), 1):
val = values[v].end
val.properties['resource_uri'] = API_PATH + 'word/' + str(
val.id) + '/'
valuesArray.append(val.properties)
new_obj.__dict__['_data']['values'] = valuesArray
lemmas.append(new_obj)
return lemmas
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
# cannot put 'ref' from morpheus in here, because smyth was renamed to ref
attrlist = [
'lang', 'CTS', 'length', 'case', 'dialect', 'head', 'form',
'posClass', 'cid', 'gender', 'tbwid', 'pos', 'value', 'degree',
'number', 'lemma', 'relation', 'isIndecl', 'posAdd', 'mood',
'tense', 'voice', 'person'
]
words = []
query_params = {}
if request.GET.get('ref'):
try:
grammarParams = Grammar.objects.filter(
ref=request.GET.get('ref'))[0].query.split('&')
for pair in grammarParams:
query_params[pair.split('=')[0]] = pair.split('=')[1]
except KeyError as k:
return words
# query by ordinary filters
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(
obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (s:`Sentence`)-[:words]->(w:`Word`) WHERE """
# filter word on parameters
for key in query_params:
# fuzzy match
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
# multi values
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w.""" + key.split('__')[
0] + """=~'.*""" + chunk + """.*' OR """
q = q[:len(q) - 3]
q = q + """) AND """
# one value
else:
q = q + """HAS (w.""" + key.split(
'__')[0] + """) AND w.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'startswith':
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w.""" + key.split('__')[
0] + """=~'""" + chunk + """.*' OR """
q = q[:len(q) - 3]
q = q + """) AND """
else:
q = q + """HAS (w.""" + key.split(
'__')[0] + """) AND w.""" + key.split(
'__')[0] + """=~'""" + query_params[
key] + """.*' AND """
elif key.split('__')[1] == 'endswith':
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w.""" + key.split('__')[
0] + """=~'.*""" + chunk + """' OR """
q = q[:len(q) - 3]
q = q + """) AND """
else:
q = q + """HAS (w.""" + key.split(
'__')[0] + """) AND w.""" + key.split(
'__')[0] + """=~'.*""" + query_params[
key] + """' AND """
# only for integer values
elif key.split('__')[1] == 'gt':
q = q + """HAS (w.""" + key.split(
'__')[0] + """) AND w.""" + key.split('__')[
0] + """>""" + query_params[key] + """ AND """
# only for integer values
elif key.split('__')[1] == 'lt':
q = q + """HAS (w.""" + key.split(
'__')[0] + """) AND w.""" + key.split('__')[
0] + """<""" + query_params[key] + """ AND """
# negated match
elif key.split('__')[1] == 'isnot':
# integer values
if key.split('__')[0] in [
'tbwid', 'head', 'length', 'cid'
]:
# multiple values
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w.""" + key.split('__')[
0] + """<>""" + chunk + """ OR """
q = q[:len(q) - 3]
q = q + """) AND """
# one value
else:
q = q + """HAS (w.""" + key.split(
'__')[0] + """) AND w.""" + key.split(
'__')[0] + """<>""" + query_params[
key] + """ AND """
# string values
else:
# multi values
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w.""" + key.split('__')[
0] + """<>'""" + chunk + """' OR """
q = q[:len(q) - 3]
q = q + """) AND """
# one value
else:
q = q + """HAS (w.""" + key.split(
'__')[0] + """) AND w.""" + key.split(
'__')[0] + """<>'""" + query_params[
key] + """' AND """
# perfect match
else:
# integer values
if key in ['tbwid', 'head', 'length', 'cid']:
# multi values
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w.""" + key.split(
'__')[0] + """=""" + chunk + """ OR """
q = q[:len(q) - 3]
q = q + """) AND """
# one value
else:
q = q + """HAS (w.""" + key + """) AND w.""" + key + """=""" + query_params[
key] + """ AND """
# string values
else:
if "__" in query_params[key]:
q = q + """("""
chunks = query_params[key].split('__')
for chunk in chunks:
q = q + """ w.""" + key.split(
'__')[0] + """='""" + chunk + """' OR """
q = q[:len(q) - 3]
q = q + """) AND """
else:
q = q + """HAS (w.""" + key + """) AND w.""" + key + """='""" + query_params[
key] + """' AND """
q = q[:len(q) - 4]
q = q + """RETURN w, s ORDER BY ID(w)"""
table = gdb.query(q)
# create the objects which was queried for and set all necessary attributes
for t in table:
word = t[0]
sentence = t[1]
url = word['self'].split('/')
urlSent = sentence['self'].split('/')
new_obj = DataObject(url[len(url) - 1])
new_obj.__dict__['_data'] = word['data']
new_obj.__dict__['_data']['id'] = url[len(url) - 1]
new_obj.__dict__['_data'][
'sentence_resource_uri'] = API_PATH + 'sentence/' + urlSent[
len(urlSent) - 1] + '/'
words.append(new_obj)
if ENABLE_WORD_LIST_SORTING:
return sort_object_words(words[:500])
else:
return words
#return words
# default querying on big dataset (CTS required)
elif request.GET.get('document_CTS'):
# delted this so our word list is smaller
#documentTable = gdb.query("""MATCH (n:`Document`) RETURN n ORDER BY ID(n)""")
#for d in documentTable:
#document = d[0]
wordTable = gdb.query(
"""MATCH (d:`Document`)-[:sentences]->(s:`Sentence`)-[:words]->(w:`Word`) WHERE d.CTS = '"""
+ request.GET.get('document_CTS') +
"""' RETURN w,s ORDER BY ID(w)""")
# get sent id
for w in wordTable:
word = w[0]
sentence = w[1]
url = word['self'].split('/')
urlSent = sentence['self'].split('/')
new_obj = DataObject(url[len(url) - 1])
new_obj.__dict__['_data'] = word['data']
new_obj.__dict__['_data']['id'] = url[len(url) - 1]
new_obj.__dict__['_data'][
'sentence_resource_uri'] = API_PATH + 'sentence/' + urlSent[
len(urlSent) - 1] + '/'
words.append(new_obj)
if ENABLE_WORD_LIST_SORTING:
return sort_object_words(words[:500])
else:
return words
# no parameter for filtering, return empty
else:
return words
def get_object_list(self, request):
gdb = GraphDatabase(GRAPH_DATABASE_REST_URL)
attrlist = ['CTS', 'length', 'sentence']
sentences = []
query_params = {}
for obj in request.GET.keys():
if obj in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
elif obj.split('__')[0] in attrlist and request.GET.get(obj) is not None:
query_params[obj] = request.GET.get(obj)
# implement filtering
if len(query_params) > 0:
# generate query
q = """MATCH (d:`Document`)-[:sentences]->(s:`Sentence`) WHERE """
# filter word on parameters
for key in query_params:
if len(key.split('__')) > 1:
if key.split('__')[1] == 'contains':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'startswith':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'""" +query_params[key]+ """.*' AND """
elif key.split('__')[1] == 'endswith':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """=~'.*""" +query_params[key]+ """' AND """
elif key.split('__')[1] == 'gt':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """>""" +query_params[key]+ """ AND """
elif key.split('__')[1] == 'lt':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<""" +query_params[key]+ """ AND """
elif key.split('__')[1] == 'isnot':
if key.split('__')[0] == 'length':
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<>""" +query_params[key]+ """ AND """
else:
q = q + """HAS (s.""" +key.split('__')[0]+ """) AND s.""" +key.split('__')[0]+ """<>'""" +query_params[key]+ """' AND """
else:
if key == 'length':
q = q + """HAS (s.""" +key+ """) AND s.""" +key+ """=""" +query_params[key]+ """ AND """
else:
q = q + """HAS (s.""" +key+ """) AND s.""" +key+ """='""" +query_params[key]+ """' AND """
q = q[:len(q)-4]
q = q + """RETURN s, d ORDER BY ID(s)"""
table = gdb.query(q)
# default querying
else:
table = gdb.query("""MATCH (d:`Document`)-[:sentences]->(s:`Sentence`) WHERE HAS (s.CTS) RETURN s, d ORDER BY ID(s)""")
# create the objects which was queried for and set all necessary attributes
for t in table:
sentence = t[0]
document = t[1]
url = sentence['self'].split('/')
urlDoc = document['self'].split('/')
new_obj = DataObject(url[len(url)-1])
new_obj.__dict__['_data'] = sentence['data']
new_obj.__dict__['_data']['id'] = url[len(url)-1]
new_obj.__dict__['_data']['document_resource_uri'] = API_PATH + 'document/' + urlDoc[len(urlDoc)-1] +'/'
sentences.append(new_obj)
if ENABLE_DISPLAYING_LONG_DOCUMENTS:
if len(sentences) > 500:
return sentences
else:
return sort_sentences(sentences)
else:
return sort_sentences(sentences)
return sort_sentences(sentences)
