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): 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): # 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) 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 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 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 (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 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 (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 = ['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