def get(self, tag_id1, tag_id2): req = "MATCH (find:tag {tag_id: %d}) RETURN find" % tag_id1 result = neo4j.query_neo4j(req) tag1 = result.single()['find'].properties req = "MATCH (find:tag {tag_id: %d}) RETURN find" % tag_id2 result = neo4j.query_neo4j(req) tag2 = result.single()['find'].properties response = {} if tag1['tag_id'] <= tag2['tag_id']: response['tag_src'] = tag1 response['tag_dst'] = tag2 else: response['tag_src'] = tag2 response['tag_dst'] = tag1 req = "match (t1: tag {tag_id: %d})<-[:REFERS_TO]-(a: annotation)-[:ANNOTATES]->(e) " % tag_id1 req += "match (e)<-[:ANNOTATES]-(a2: annotation)-[:REFERS_TO]->(t2: tag {tag_id: %d}) " % tag_id2 req += "match (e)<-[:AUTHORSHIP]-(u: user) " req += "return distinct t1.tag_id, CASE e.post_id when null then e.comment_id else e.post_id end as id, CASE e.post_id WHEN null THEN 'comment' ELSE 'post' END as entity_type, e.timestamp as timestamp, e.label as label, u.user_id as user_id, u.label as user_label, t2.tag_id ORDER BY e.timestamp DESC" result = neo4j.query_neo4j(req) tags = [] for record in result: tags.append({'id': record['id'], "entity_type": record['entity_type'], "timestamp": record['timestamp'], 'label': record['label'], 'user_id': record['user_id'], 'user_label': record['user_label']}) response['list'] = tags try: tags except ResultError: return makeResponse("ERROR",500) return makeResponse(response, 200)
def create_tags(self): query_neo4j("CREATE CONSTRAINT ON (t:tag) ASSERT t.tag_id IS UNIQUE") print('Import tags') Continue = True page_val = 0 while Continue: tag_url = config['importer_discourse']['abs_path'] + config[ 'importer_discourse']['codes_rel_path'] + ".json?api_key=" + config[ 'importer_discourse'][ 'admin_api_key'] + "&api_username="******"&per_page=5000&page=" + str( page_val) not_ok = True while not_ok: try: tag_req = requests.get(tag_url) except: print('request problem on tag page ' + str(page_val)) time.sleep(2) continue try: tag_json = tag_req.json() except: print("failed read tag on page " + str(page_val)) time.sleep(2) continue not_ok = False # get all tags for tag in tag_json: # create tag if not existing if not (tag['id'] in self.existing_elements['tags']): # handle multilingual values if len(tag['names']) < 1: continue tag['name'] = tag['names'][0]['name'].lower() for tmp_i in range(len(tag['names'])): if tag['names'][tmp_i]['locale'] == 'en': tag['name'] = tag['names'][tmp_i]['name'].lower() break if not (tag['name'] in self.tags): self.createTag(tag['id'], tag['name']) self.map_tag_to_tag[tag['id']] = tag['id'] self.tags[tag['name']] = tag['id'] else: # if duplicate using mapping # tag_n = self.existing_elements['tags'][self.tags[tag['name'].lower()]] self.map_tag_to_tag[tag['id']] = self.tags[tag['name']] # self.existing_elements['tags'][tag['id']] = tag_n self.existing_elements['tags'].append(tag['id']) # no need to create tag hierarchy as the route does not give ancestry info if len(tag_json) == 5000: page_val += 1 else: Continue = False break
def get(self, user_id): # Get user properties req = "MATCH (find:user {user_id: %d}) RETURN find" % user_id result = neo4j.query_neo4j(req) user = result.single()['find'].properties # Get user's posts req = "MATCH (find:user {user_id: %d})" % user_id req += " MATCH (find)-[:AUTHORSHIP]->(p:post)" req += ' RETURN p.post_id AS post_id, p.label AS post_label, p.timestamp AS timestamp ORDER BY p.timestamp DESC' result = neo4j.query_neo4j(req) posts = [] posts_id = [] for record in result: try: if record['post_id'] and record['post_id'] not in posts_id: post = {} post['post_id'] = record['post_id'] post['label'] = record['post_label'] post['timestamp'] = record['timestamp'] posts.append(post) posts_id.append(post['post_id']) except KeyError: pass # Get user's comments req = "MATCH (find:user {user_id: %d})" % user_id req += " MATCH (find)-[:AUTHORSHIP]->(c:comment)" req += " OPTIONAL MATCH (c)-[:COMMENTS]->(p:post)" req += ' RETURN c.comment_id AS comment_id, c.label AS comment_label, c.timestamp AS timestamp, p.post_id AS comment_parent_post_id, p.label AS comment_parent_post_label ORDER BY c.timestamp DESC' result = neo4j.query_neo4j(req) comments_id = [] comments = [] for record in result: try: if record['comment_id'] and record['comment_id'] not in comments_id: comment = {} comment['comment_id'] = record['comment_id'] comment['label'] = record['comment_label'] comment['timestamp'] = record['timestamp'] comment['comment_parent_post_id'] = record['comment_parent_post_id'] comment['comment_parent_post_label'] = record['comment_parent_post_label'] comments.append(comment) comments_id.append(comment['comment_id']) except KeyError: pass try: user except NameError: return makeResponse("ERROR : Cannot find user with user_id: %d" % user_id, 204) user['posts'] = posts user['comments'] = comments return makeResponse(user, 200)
def create_tags(self): query_neo4j("CREATE CONSTRAINT ON (t:tag) ASSERT t.tag_id IS UNIQUE") print('Import tags') Continue = True page_val = 0 while Continue: tag_url = config['importer_discourse']['abs_path']+config['importer_discourse']['codes_rel_path']+".json?per_page=5000&page="+str(page_val) headers = {'Api-Key': config['importer_discourse']['admin_api_key']} not_ok = True while not_ok: try: tag_req = requests.get(tag_url, headers=headers) except: print('request problem on tag page '+str(page_val)) time.sleep(2) continue try: tag_json = tag_req.json() except: print("failed read tag on page "+str(page_val)) time.sleep(2) continue not_ok = False # get all tags for tag in tag_json: # create tag if not existing if not(tag['id'] in self.existing_elements['tags']): # Use the English code name if available, otherwise the first code name. english_name = next((tag_name['name'] for tag_name in tag['names'] if tag_name['locale'] == 'en'), '') tag['name'] = tag['names'][0]['name'] if english_name == '' else english_name if not(tag['name'].lower() in self.tags): self.createTag(tag['id'], tag['name'].lower()) self.map_tag_to_tag[tag['id']] = tag['id'] self.tags[tag['name'].lower()] = tag['id'] else: # if duplicate using mapping # tag_n = self.existing_elements['tags'][self.tags[tag['name'].lower()]] self.map_tag_to_tag[tag['id']] = self.tags[tag['name'].lower()] # self.existing_elements['tags'][tag['id']] = tag_n self.existing_elements['tags'].append(tag['id']) # no need to create tag hierarchy as the route does not give ancestry info if len(tag_json) == 5000: page_val += 1 else: Continue = False break
def get(self, annotation_id): req = "MATCH (find:annotation {annotation_id: %d})" % annotation_id req += "MATCH (find)-[:ANNOTATES]->(x)" req += 'RETURN find, labels(x) as test' result = neo4j.query_neo4j(req) #annotation = result.single()['find'].properties annotateComment = False for record in result: annotation = record['find'].properties try: if "comment" in record["test"]: annotateComment = True except KeyError: return makeResponse( "ERROR : Impossible to identify 'entity_type' for annotation with aid: %d" % annotation_id, 205) if annotateComment: req = "MATCH (find:annotation {annotation_id: %d})-[:REFERS_TO]->(t: tag) " % annotation_id req += "MATCH (find)-[:ANNOTATES]->(c:comment)" req += "MATCH (c)<-[:AUTHORSHIP]-(u:user)" req += 'RETURN find, c.comment_id as entity_id, c.title as entity_title, c.timestamp as entity_timestamp, u.user_id as user_id, u.name as user_name, "comment" as entity_type, t.tag_id as tag_id, t.label as tag_label ORDER BY c.timestamp DESC' else: req = "MATCH (find:annotation {annotation_id: %d})-[:REFERS_TO]->(t: tag) " % annotation_id req += "MATCH (find)-[:ANNOTATES]->(p:post)" req += "MATCH (p)<-[:AUTHORSHIP]-(u:user)" req += 'RETURN find, p.post_id as entity_id, p.title as entity_title, p.timestamp as entity_timestamp, u.user_id as user_id, u.name as user_name, "post" as entity_type, t.tag_id as tag_id, t.label as tag_label ORDER BY p.timestamp DESC' result = neo4j.query_neo4j(req) for record in result: try: annotation['user_id'] = record['user_id'] annotation['user_name'] = record['user_name'] annotation['entity_id'] = record['entity_id'] annotation['entity_title'] = record['entity_title'] annotation['entity_timestamp'] = record['entity_timestamp'] annotation['entity_type'] = record['entity_type'] annotation['tag_id'] = record['tag_id'] annotation['tag_label'] = record['tag_label'] except KeyError: return makeResponse( "ERROR : Cannot find annotation with aid: %d" % annotation_id, 203) try: annotation except NameError: return makeResponse( "ERROR : Cannot find annotation with aid: %d" % annotation_id, 204) return makeResponse(annotation, 200)
def get(self): req = "MATCH (p:post) WHERE NOT (p)<-[:ANNOTATES]- (: annotation) RETURN p.post_id AS post_id,p.label AS label, p.timestamp AS timestamp ORDER BY timestamp DESC" result = neo4j.query_neo4j(req) posts = [] for record in result: posts.append({'post_id': record['post_id'], "label": record['label'], "timestamp": record['timestamp']}) req = "MATCH (c:comment) WHERE NOT (c)<-[:ANNOTATES]- (: annotation) RETURN c.comment_id AS comment_id, c.label AS label, c.timestamp AS timestamp ORDER BY timestamp DESC" result = neo4j.query_neo4j(req) comments = [] for record in result: comments.append({'comment_id': record['comment_id'], "label": record['label'], "timestamp": record['timestamp']}) return makeResponse({'posts': posts, "comments": comments}, 200)
def get(self, user_id): req = "MATCH (a:annotation)<-[:AUTHORSHIP]-(:user {user_id: %d}) RETURN count(a) AS nb_annotations" % user_id result = neo4j.query_neo4j(req) try: return makeResponse(result.single()['nb_annotations'], 200) except ResultError: return makeResponse("ERROR", 500)
def get(self, comment_id): req = "MATCH (a:annotation)-[:ANNOTATES]->(:comment {comment_id: %d}) RETURN count(a) AS nb_annotations" % comment_id result = neo4j.query_neo4j(req) try: return makeResponse(result.single()['nb_annotations'], 200) except ResultError: return makeResponse("ERROR", 500)
def get(self): req = "MATCH (p:post) <-[:AUTHORSHIP]- (u: user) RETURN p.post_id AS post_id,p.label AS post_label, u.user_id AS user_id, u.label AS user_label, p.timestamp AS timestamp ORDER BY timestamp DESC LIMIT 5" result = neo4j.query_neo4j(req) posts = [] for record in result: posts.append({'post_id': record['post_id'], "post_label": record['post_label'], "user_id": record['user_id'], "user_label": record['user_label'], "timestamp": record['timestamp']}) return makeResponse(posts, 200)
def get(self): req = "MATCH (find:annotation) -[:ANNOTATES]-> (:post) RETURN find.annotation_id AS annotation_id, find.quote AS quote" result = neo4j.query_neo4j(req) annots = [] for record in result: annots.append({'annotation_id': record['annotation_id'], "quote": record['quote']}) return makeResponse(annots, 200)
def get(self): req = "MATCH (:post) RETURN count(*) AS nb_posts" result = neo4j.query_neo4j(req) try: return makeResponse(result.single()['nb_posts'], 200) except ResultError: return makeResponse("ERROR", 500)
def get(self, parent_tag_id): req = "MATCH (t:tag {tag_id : %d})<-[:IS_CHILD]-(:tag) RETURN count(*) AS nb_child" % parent_tag_id result = neo4j.query_neo4j(req) try: return makeResponse(result.single()['nb_child'], 200) except ResultError: return makeResponse("ERROR", 500)
def get(self, user_id): req = "MATCH (find:user {user_id: %d}) RETURN find" % user_id result = neo4j.query_neo4j(req) try: return makeResponse(result.single()['find'].properties, 200) except ResultError: return makeResponse("ERROR : Cannot find user with uid: %d" % user_id, 204)
def get(self, author_id): req = "MATCH (author:user {user_id : %d})-[:AUTHORSHIP]->(:post) RETURN count(*) AS nb_posts" % author_id result = neo4j.query_neo4j(req) try: return makeResponse(result.single()['nb_posts'], 200) except ResultError: return makeResponse("ERROR", 500)
def get(self, parent_tag_id): req = "MATCH (parent:tag {tag_id : %d})<-[:IS_CHILD]-(child:tag) RETURN child" % parent_tag_id result = neo4j.query_neo4j(req) tags = [] for record in result: tags.append(record['child'].properties) return makeResponse(tags, 200)
def get(self): parser.add_argument('uid', action='append') args = parser.parse_args() if args['uid']: req = "MATCH (n:post_type)<-[r:TYPE_IS]-(p:post) " req += addTimeFilter() for user in args['uid']: req += "OPTIONAL MATCH (n)<-[r%s:TYPE_IS]-(p:post)<-[]-(u%s:user {uid: %s}) " % ( user, user, user) req += "RETURN n, count(r) AS nb_posts" for user in args['uid']: req += ", count(r%s) AS u%s_posts" % (user, user) else: req = "MATCH (n:post_type)<-[r:TYPE_IS]-(p:post) " req += addTimeFilter() req += "RETURN n, count(r) AS nb_posts" result = neo4j.query_neo4j(req) labels = [] data = [[]] if args['uid']: for user in args['uid']: data.append([]) for record in result: labels.append(record['n'].properties['name']) data[0].append(record['nb_posts']) if args['uid']: count = 1 for user in args['uid']: data[count].append(record['u%s_posts' % user]) count += 1 return makeResponse({'labels': labels, 'data': data}, 200)
def get(self): importer = ImportFromJson(False) # no user update # first update tag req = requests.get(config['importer_edgeryders']['json_tags_path']) json_file = req.json() importer.create_tags(json_file) # then the rest updateList = ['post', 'comment', 'annotation'] for elem in updateList: req = "MATCH (n:" + elem + ") RETURN max(n.timestamp) AS max" result = neo4j.query_neo4j(req) try: most_recent = time.gmtime(int(result.single()['max']) / 1000) except ResultError: print("Problem from neo4j request.") since_str = time.strftime('%Y%m%d', most_recent) req = requests.get(config['importer_edgeryders']['json_' + elem + 's_path'] + "?since=" + since_str) json_file = req.json() if elem == 'post': importer.create_posts(json_file) if elem == 'comment': importer.create_comments(json_file) if elem == 'annotation': importer.create_annotations(json_file) return makeResponse(importer.end_import(), 200)
def get(self, author_id): req = "MATCH (author:user {user_id: %d})-[:AUTHORSHIP]->(p:post) RETURN p" % author_id req += addargs() result = neo4j.query_neo4j(req) posts = [] for record in result: posts.append(record['p'].properties) return makeResponse(posts, 200)
def get(self, post_type): req = "MATCH (find:post {type: '%s'}) RETURN find" % post_type req += addargs() result = neo4j.query_neo4j(req) posts = [] for record in result: posts.append(record['find'].properties) return makeResponse(posts, 200)
def get(self, post_id): result = neo4j.query_neo4j( "MATCH (find:post {post_id: %d}) RETURN find" % post_id) try: return makeResponse(result.single()['find'].properties, 200) except ResultError: return makeResponse( "ERROR : Cannot find post with pid: %d" % post_id, 204)
def get(self, comment_id): req = "MATCH (find:comment {comment_id: %d}) RETURN find" % comment_id result = neo4j.query_neo4j(req) try: return makeResponse(result.single()['find'].properties, 200) except ResultError: return makeResponse( "ERROR : Cannot find comment with cid: %d" % comment_id, 204)
def get(self, comment_id): req = "MATCH (c:comment)-[:COMMENTS]->(comment:comment { comment_id: %d}) RETURN c" % comment_id req += addargs() result = neo4j.query_neo4j(req) comments = [] for record in result: comments.append(record['c'].properties) return makeResponse(comments, 200)
def get(self): req = "MATCH (n:user) RETURN n.user_id AS user_id, n.label AS label" req += addargs() result = neo4j.query_neo4j(req) users = [] for record in result: users.append({'user_id': record['user_id'], "label": record['label']}) return makeResponse(users, 200)
def get(self, tag_id): result = neo4j.query_neo4j( "MATCH (find:tag {tag_id: %d}) RETURN find" % tag_id) try: return makeResponse(result.single()['find'].properties, 200) except ResultError: return makeResponse( "ERROR : Cannot find tag with tid: %d" % tag_id, 204)
def get(self): req = "MATCH (t:tag) RETURN t.tag_id AS tag_id, t.label AS label" req += addargs() result = neo4j.query_neo4j(req) tags = [] for record in result: tags.append({'tag_id': record['tag_id'], "label": record['label']}) return makeResponse(tags, 200)
def get(self): req = "MATCH (p:post) RETURN p.post_id AS post_id, p.title AS title" req += addargs() result = neo4j.query_neo4j(req) posts = [] for record in result: posts.append({'post_id': record['post_id'], "title": record['title']}) return makeResponse(posts, 200)
def get(self): req = "MATCH (a:annotation)-[:REFERS_TO]->(t:tag) MATCH (a)-[:ANNOTATES]-(x) RETURN a.annotation_id AS annotation_id, a.quote AS quote, t.tag_id AS tag_id, CASE x.post_id WHEN null THEN 'comment' ELSE 'post' END AS entity_type, CASE x.post_id WHEN null THEN x.comment_id ELSE x.post_id END AS entity_id" req += addargs() result = neo4j.query_neo4j(req) annots = [] for record in result: annots.append({'annotation_id': record['annotation_id'], "quote": record['quote'], "tag_id": record['tag_id'], "entity_type": record["entity_type"], "entity_id": record["entity_id"]}) return makeResponse(annots, 200)
def get(self, comment_id): req = "MATCH (c:comment {comment_id: %d})<-[:ANNOTATES]-(a:annotation) RETURN a" % comment_id req += addargs() result = neo4j.query_neo4j(req) annots = [] for record in result: annots.append(record['a'].properties) return makeResponse(annots, 200)
def get(self, user_id): req = "MATCH (:user {user_id: %d})-[:AUTHORSHIP]->(a:annotation) RETURN a" % user_id req += addargs() result = neo4j.query_neo4j(req) annots = [] for record in result: annots.append(record['a'].properties) return makeResponse(annots, 200)
def get(self, annot_id): result = neo4j.query_neo4j( "MATCH (find:annotation {annotation_id: %d}) RETURN find" % annot_id) try: return makeResponse(result.single()['find'].properties, 200) except ResultError: return makeResponse( "ERROR : Cannot find annotation with id: %d" % annot_id, 204)