def rated_movie(username, skip):
    query = ''' MATCH(n: User
    {username: {username}})-[r: RATED]->(m: Movie) with count(m) as total  return total'''
    count = graph.run(query, username=username)
    for x in count:
        resultscount = x['total']

    query = '''MATCH (n:User{username:{username}})-[r:RATED]->(m:Movie) return m.title as title ,m.imdbId as imdbId ,m.imageUrl as imageUrl, r.stars as stars Skip {skip} Limit 102'''
    results = graph.run(query, username=username, skip=skip)
    return results, resultscount
def genres_list(genre_name, limit, skip):

    query = '''
                MATCH (n:Movie)where n.genre={genre_name} with count(n) as total  return total     '''

    count = graph.run(query, genre_name=genre_name)

    query = '''MATCH (m:Movie) where m.genre={genre_name}  RETURN m.title as title ,m.imdbId as imdbId ,m.imageUrl as imageUrl Skip {skip} Limit {limit}'''
    results = graph.run(query, genre_name=genre_name, limit=limit, skip=skip)
    for x in count:
        resultscount = x['total']

    return results, resultscount
Пример #3
0
def get_recent_posts(username):
    query = '''
    MATCH (user:User)-[:PUBLISHED]->(post:Post)<-[:TAGGED]-(tag:Tag)
    WHERE user.username = {username}
    RETURN post, COLLECT(tag.name) AS tags
    ORDER BY post.timestamp DESC LIMIT 5
    '''

    return graph.run(query, username=username)
def my_books(username):
    query = '''

        MATCH(n: User{username: {username}})-[: STATUS{status:'Read'}]->(book: Book)<-[: author]-(a:author)
        return book.title as title,book.year as year, book.isbn as isbn ,book.imageurl as imageurl ,a.name as author'''

    result1 = graph.run(query, username=username)

    return result1
Пример #5
0
def get_todays_recent_posts():
    query = '''
    MATCH (user:User)-[:PUBLISHED]->(post:Post)<-[:TAGGED]-(tag:Tag)
    WHERE post.date = {today}
    RETURN user.username AS username, post, COLLECT(tag.name) AS tags
    ORDER BY post.timestamp DESC LIMIT 5
    '''

    return graph.run(query, today=date())
def update_similarity():
    query = '''MATCH (p1:User)-[x:RATED]->(m:Movie)<-[y:RATED]-(p2:User)
          WITH  SUM(x.stars * y.stars) AS xyDotProduct,
          SQRT(REDUCE(xDot = 0.0, a IN COLLECT(x.stars) | xDot + a^2)) AS xLength,
          SQRT(REDUCE(yDot = 0.0, b IN COLLECT(y.stars) | yDot + b^2)) AS yLength,
          p1, p2
          MERGE (p1)-[s:SIMILARITY]-(p2)
          SET   s.similarity = xyDotProduct / (xLength * yLength)

    '''
    results = graph.run(query)
def book_recommendations(username):

    query = '''

    MATCH(n: User{username: {username}})-[: STATUS]->(: Book)<-[: author]-(a:author)-[: author]->(book:Book) where  not (n: User{username: {username}})-[: STATUS]->(book: Book)
     return DISTINCT book.title as title,book.year as year, book.isbn as isbn ,book.imageurl as imageurl ,a.name as author

    '''

    results = graph.run(query, username=username)

    return results
Пример #8
0
def get_commonality_of_user(username, other):
    # Find how many of the logged-in user's posts the other user
    # has liked and which tags they've both blogged about.
    query = '''
    MATCH (they:User {username: {they} })
    MATCH (you:User {username: {you} })
    OPTIONAL MATCH (they)-[:PUBLISHED]->(:Post)<-[:TAGGED]-(tag:Tag),
                   (you)-[:PUBLISHED]->(:Post)<-[:TAGGED]-(tag)
    RETURN SIZE((they)-[:LIKED]->(:Post)<-[:PUBLISHED]-(you)) AS likes,
           COLLECT(DISTINCT tag.name) AS tags
    '''

    return graph.run(query, they=other, you=username).next
def similar_movies(username):
    query = ''' MATCH (b:User)-[r:RATED]->(m:Movie), (b)-[s:SIMILARITY]-(a:User {username:{username}})
WHERE NOT((a)-[:RATED]->(m))
WITH m, s.similarity AS similarity, r.stars AS stars
ORDER BY m.title, similarity DESC
WITH m.title AS movie,m.imageUrl AS imageUrl,m.description AS description ,COLLECT(stars)[0..3] AS ratings
WITH movie,imageUrl,description, REDUCE(s = 0, i IN ratings | s + i)*1.0 / SIZE(ratings) AS reco
ORDER BY reco DESC
RETURN movie AS title, reco AS Recommendation ,imageUrl,description LIMIT 200

    '''
    results = graph.run(query, username=username)

    return results
Пример #10
0
def delete_post(username, post_id):

    print(post_id)
    print("Jadkjsh dkdh fkdhf gjdf gdfk ")
    query = '''

    MATCH (user:User)-[:PUBLISHED]->(post:Post)<-[:TAGGED]-(tag:Tag)
    WHERE user.username ={username} AND post.id={post_id} Detach Delete post



    '''

    return graph.run(query, username=username, post_id=post_id)
Пример #11
0
def get_similar_users(username):
    # Find three users who are most similar to the logged-in user
    # based on tags they've both blogged about.
    query = '''
    MATCH (you:User)-[:PUBLISHED]->(:Post)<-[:TAGGED]-(tag:Tag),
          (they:User)-[:PUBLISHED]->(:Post)<-[:TAGGED]-(tag)
    WHERE you.username = {username} AND you <> they
    WITH they , COLLECT(DISTINCT tag.name) AS tags

    ORDER BY SIZE(tags) DESC LIMIT 3
    RETURN they.username AS similar_user, tags
    '''

    return graph.run(query, username=username)
def suggest_movies(username, gender, companion, emotions, criteria):

    query1 = query2 = ""
    if gender == 'female':
        query1, query2 = suggest_female_movies(companion, emotions)

    elif gender == 'male':
        query1, query2 = suggest_male_movies(companion, emotions)

    else:
        query1, query2 = suggest_general_movies(companion, emotions)

    if criteria == "both":

        results1 = graph.run(query1, username=username)
        results2 = graph.run(query2, username=username)

        set1 = set()
        set2 = set()

        for row in results1:

            set1.add(row)

        for row in results2:
            set2.add(row)

        movies = set1.intersection(set2)

    elif criteria == "emotion":
        movies = graph.run(query1, username=username)

    elif criteria == "companion":
        movies = graph.run(query2, username=username)
    else:
        results1 = graph.run(query1, username=username)
        results2 = graph.run(query2, username=username)

        set1 = set()
        set2 = set()

        for row in results1:
            set1.add(row)

        for row in results2:
            set2.add(row)

        movies = set1.union(set2)

    return movies
def listmovie(search):
    query = '''MATCH (author:author)-[:author]->(book:Book)<-[:Published]-(publisher:Publisher)
    where book.title STARTS WITH {search}
    return book.title as title , book.year as year, book.isbn as isbn ,book.imageurl as imageurl, publisher.name as publisher,author.name as author '''
    results = graph.run(query, search=search)
    return results
def rate_movie(username, imdbId, rating):

    query = '''MATCH (n:User{username:{username}}),(m:Movie{imdbId:{imdbId}})
    MERGE (n)-[r:RATED]->(m) set r.stars={rating} return r.stars as stars'''
    results = graph.run(query, username=username, imdbId=imdbId, rating=rating)
    return results
def random_movies(username):
    query = '''MATCH (m: Movie)where NOT (:User{username:{username}})-[:RATED]->(m:Movie)with m,
    rand() AS number return m.title as title , m.imdbId as imdbId ,m.imageUrl as imageUrl, m.description as description ,m.releaseDate as releaseDate ORDER BY number  LIMIT 10 '''
    results = graph.run(query, username=username)
    return results
def book_status(username, isbn, status):

    query = '''MATCH (n:User{username:{username}}),(b:Book{isbn:{isbn}})
    MERGE (n)-[r:STATUS]->(b) set r.status={status} return r.status as status'''
    results = graph.run(query, username=username, isbn=isbn, status=status)
    return results
def get_movies(limit):
    query = '''MATCH (m:Movie)<-[:ACTS_IN]-(a:Person)
             RETURN m.title as movie,m.imdbId as imdbId , m.imageUrl as imageUrl , collect(a.name) as cast Limit {limit}'''
    results = graph.run(query, limit=limit)
    return results
Пример #18
0
from views import app
from models import graph

# graph.cypher.execute("CREATE CONSTRAINT ON (n:User) ASSERT n.username IS UNIQUE")
# graph.cypher.execute("CREATE CONSTRAINT ON (n:Post) ASSERT n.id IS UNIQUE")
# graph.cypher.execute("CREATE CONSTRAINT ON (n:Tag) ASSERT n.name IS UNIQUE")
# TODO: What is the idea of the INDEX ON?
graph.run("CREATE INDEX ON :Post(date)")

users = ["pgenev", "kbori"]

# TODO (1): Find a way to implement these constraints
# TODO (1) answer: Not needed. Already implemented in the database.

# TODO: Check how bcrypt/passlib works
Пример #19
0
from models import graph
import json
import requests
import os


url = os.environ.get('GRAPHENEDB_URL', 'http://localhost:7474')
username = os.environ.get('neo4j')
password = os.environ.get('deepak007')

newgraph = Graph(url + '/db/data/', username=username, password=password)



query = '''MATCH (m:Movie) where m.imdbRating='Rating Not Available' RETURN m.title as movie,m.imdbId as imdbId'''
results = graph.run(query)

count=0
URL={}





for row in results:

    imdbId=(row['imdbId']).strip()


    if not (imdbId==''):
        try: