views.py

from flask import Blueprint, jsonify, request
from . import db
from .models import MOVIE_DETAILS, USER_DETAILS, REVIEW_DETAILS
from flask_cors import CORS
import base64

main = Blueprint('main', __name__)
CORS(main, supports_credentials=True)

@main.route('/addreview', methods=['POST'])
def addReview():
    movieID = request.get_json()
    movieToReview = db.session.query((MOVIE_DETAILS.id),(MOVIE_DETAILS.category),(MOVIE_DETAILS.title),(MOVIE_DETAILS.coverPhoto),(MOVIE_DETAILS.rating),(MOVIE_DETAILS.longDescription),(MOVIE_DETAILS.release),(MOVIE_DETAILS.movieLength)).filter(MOVIE_DETAILS.id==movieID).all()
    thisMovie = []
    
    for movie in movieToReview:
        thisMovie.append({  'movieId' : movie.id,
                            'title': movie.title,
                            'rating': movie.rating,
                            'category': movie.category,
                            'coverPhoto': movie.coverPhoto,
                            'longDescription': movie.longDescription,
                            'release': movie.release,
                            'movieLength': movie.movieLength})
    
    return jsonify ({'thisMovie': thisMovie[0]})

@main.route('/addnewreview', methods=['POST'])
def addnewreview():
    details = request.get_json()
    print(details)
    newReview = REVIEW_DETAILS(rating=details[0],review=details[1],userId=details[2],movieId=details[3],reviewDate=details[4])
    db.session.add(newReview)
    db.session.commit()
    return jsonify ()

@main.route('/removereview', methods=['POST'])
def removereview():
    details = request.get_json()
    print(details)
    REVIEW_DETAILS.query.filter(REVIEW_DETAILS.userId == details["userID"]).filter(REVIEW_DETAILS.movieId == details["movieId"]).delete()
    db.session.commit()
    return 'Done', 201

@main.route('/movies')
def movies():
    movie_list = db.session.query((MOVIE_DETAILS.id),
                                      (MOVIE_DETAILS.title),
                                      (MOVIE_DETAILS.release),
                                      (MOVIE_DETAILS.description),
                                      (MOVIE_DETAILS.category),
                                      (MOVIE_DETAILS.movieLength),
                                      (MOVIE_DETAILS.coverPhoto),
                                      (MOVIE_DETAILS.pagePhoto),
                                      (MOVIE_DETAILS.longDescription),
                                      (REVIEW_DETAILS.review),
                                      (REVIEW_DETAILS.reviewDate),
                                      (REVIEW_DETAILS.userId),db.func.avg(REVIEW_DETAILS.rating).label('averageRating'),).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.id).order_by(REVIEW_DETAILS.rating.desc()).all()

    movies = []
    
    for movie in movie_list:
        movies.append({ 'id' : movie.id, 
                       'title' : movie.title, 
                       'release' : movie.release, 
                       'description' : movie.description, 
                       'rating' : movie.averageRating, 
                       'movieLength' : movie.movieLength,
                       'category' : movie.category,
                       'coverPhoto' : movie.coverPhoto,
                       'pagePhoto' : movie.pagePhoto,
                       'longDescription' : movie.longDescription})

    return jsonify ({'movies': movies})

@main.route('/users')
def users():
    user_list = USER_DETAILS.query.all()
    users = []
    
    for user in user_list:
        users.append({ 'id' : user.id, 
                       'userName' : user.userName, 
                       'userPassword' : user.userPassword})

    return jsonify ({'users': users})

@main.route('/register', methods=['POST'])
def addUser():
    details = request.get_json()
    print(details)
    check = db.session.query((USER_DETAILS.id)).filter(USER_DETAILS.userName==details[0]).all()
    print(check)
    if len(check)==1:
        return jsonify ({'userID': None})
    newUser = USER_DETAILS(userName=details[0],userPassword=details[1],joinDate=details[2])
    db.session.add(newUser)
    db.session.commit()
    userID = db.session.query(USER_DETAILS.id).filter(USER_DETAILS.userName==details[0]).all()
    print(userID)
    return jsonify ({'userID': userID[0][0]})
    

@main.route('/login',methods=['GET'])
def login():
    userID=None
    token = request.headers.get('Authorization')
    print(token)
    [type,hash]=token.split()
    print(hash)
    decryptedHash=base64.b64decode(hash.encode('ascii'))
    print(decryptedHash)
    decryptedHashArray=((decryptedHash).decode('utf-8')).split(':')
    print(decryptedHashArray)
    checkUserName = db.session.query((USER_DETAILS.id),(USER_DETAILS.userPassword)).filter(USER_DETAILS.userName==decryptedHashArray[0]).all()
    print(checkUserName)
    if len(checkUserName)==1:
        if checkUserName[0][1]==decryptedHashArray[1]:
            userID=checkUserName[0][0]
    return jsonify ({'userID': userID})
    

@main.route('/reviews')
def reviews():
    review_list = REVIEW_DETAILS.query.all()
    reviews = []
    
    for review in review_list:
        reviews.append({ 'reviewId' : review.reviewId, 
                       'movieId' : review.movieId, 
                       'userId' : review.userId, 
                       'rating' : review.rating, 
                       'review' : review.review,
                       'reviewDate' : review.reviewDate})

    return jsonify ({'reviews': reviews})



@main.route('/recommended',  methods=['POST'])
def recommended():
    id = request.get_json()
    print(id)
    recommended_list = db.session.query((MOVIE_DETAILS.category)).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.category).filter(REVIEW_DETAILS.userId==id).all()
    moviesRecommended = []
    
    for movie in recommended_list:
        movie_list = db.session.query((MOVIE_DETAILS.id),
                                      (MOVIE_DETAILS.title),
                                      (MOVIE_DETAILS.release),
                                      (MOVIE_DETAILS.description),
                                      (MOVIE_DETAILS.category),
                                      (MOVIE_DETAILS.movieLength),
                                      (MOVIE_DETAILS.coverPhoto),
                                      (MOVIE_DETAILS.pagePhoto),
                                      (MOVIE_DETAILS.longDescription),
                                      (REVIEW_DETAILS.rating),
                                      (REVIEW_DETAILS.review),
                                      (REVIEW_DETAILS.reviewDate),
                                      (REVIEW_DETAILS.userId),db.func.avg(REVIEW_DETAILS.rating).label('averageRating'),).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.id).order_by(REVIEW_DETAILS.rating.desc()).filter(MOVIE_DETAILS.category==movie.category).all()

        movies = []
        for movie2 in movie_list:
            movies.append({ 'id' : movie2.id, 
                       'title' : movie2.title, 
                       'release' : movie2.release, 
                       'description' : movie2.description, 
                       'rating' : movie2.averageRating, 
                       'movieLength' : movie2.movieLength,
                       'category' : movie2.category,
                       'coverPhoto' : movie2.coverPhoto,
                       'pagePhoto' : movie2.pagePhoto,
                       'longDescription' : movie2.longDescription})
        moviesRecommended.append({'category' : movie.category, 'movies' : movies})
    
    return jsonify ({'moviesRecommended': moviesRecommended})

@main.route('/myReviews')
def myReviews():
    userId=None
    token = request.headers.get('Authorization')
    [type,hash]=token.split()
    print(hash)
    decryptedHash=base64.b64decode(hash.encode('ascii'))
    print(decryptedHash)
    decryptedHashArray=((decryptedHash).decode('utf-8')).split(':')
    checkUserName = db.session.query((USER_DETAILS.id),(USER_DETAILS.userPassword)).filter(USER_DETAILS.userName==decryptedHashArray[0]).all()
    userId = checkUserName[0][0]
    myReview_list = db.session.query((MOVIE_DETAILS.id),
                                     (MOVIE_DETAILS.category),
                                     (MOVIE_DETAILS.coverPhoto),
                                     (REVIEW_DETAILS.rating).label('reviewRating'),
                                     (REVIEW_DETAILS.review),
                                     (REVIEW_DETAILS.reviewDate),
                                     (REVIEW_DETAILS.userId)).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.id).filter(REVIEW_DETAILS.userId==userId).order_by(REVIEW_DETAILS.rating.desc()).all()
    myreviews = []
    
    for review in myReview_list:
            averageRating = db.session.query((MOVIE_DETAILS.id),db.func.avg(REVIEW_DETAILS.rating).label('averageRating'),).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.id).order_by(REVIEW_DETAILS.rating.desc()).filter(REVIEW_DETAILS.movieId==review.id).all()
            print(averageRating)
            print(userId,review.userId)
            myreviews.append({  'movieId' : review.id, 
                                'averageRating': averageRating[0][1],
                                'reviewRating' : review.reviewRating,
                                'review' : review.review,
                                'userId' : review.userId,
                                'reviewDate' : review.reviewDate,
                                'coverPhoto' : review.coverPhoto})
        
    return jsonify ({'myReviews': myreviews})

@main.route('/categories', methods=['POST'])
def categories():
    category = request.get_json()
    print(category)
    movie_list = db.session.query((MOVIE_DETAILS.id),
                                      (MOVIE_DETAILS.title),
                                      (MOVIE_DETAILS.release),
                                      (MOVIE_DETAILS.description),
                                      (MOVIE_DETAILS.category),
                                      (MOVIE_DETAILS.movieLength),
                                      (MOVIE_DETAILS.coverPhoto),
                                      (MOVIE_DETAILS.pagePhoto),
                                      (MOVIE_DETAILS.longDescription),
                                      (REVIEW_DETAILS.rating),
                                      (REVIEW_DETAILS.review),
                                      (REVIEW_DETAILS.reviewDate),
                                      (REVIEW_DETAILS.userId),db.func.avg(REVIEW_DETAILS.rating).label('averageRating'),).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.id).order_by(REVIEW_DETAILS.rating.desc()).filter(MOVIE_DETAILS.category==category).all()

    
    movies = []
    print(movies)
    
    for movie in movie_list:
        movies.append({ 'id' : movie.id, 
                       'title' : movie.title, 
                       'release' : movie.release, 
                       'description' : movie.description, 
                       'rating' : movie.averageRating, 
                       'movieLength' : movie.movieLength,
                       'category' : movie.category,
                       'coverPhoto' : movie.coverPhoto,
                       'pagePhoto' : movie.pagePhoto,
                       'longDescription' : movie.longDescription})
    
    return jsonify ({'categories': movies})

@main.route('/search', methods=['POST'])
def search():
    searchTerm = request.get_json()
    print(searchTerm)
    movie_list = db.session.query((MOVIE_DETAILS.id),
                                      (MOVIE_DETAILS.title),
                                      (MOVIE_DETAILS.release),
                                      (MOVIE_DETAILS.description),
                                      (MOVIE_DETAILS.category),
                                      (MOVIE_DETAILS.movieLength),
                                      (MOVIE_DETAILS.coverPhoto),
                                      (MOVIE_DETAILS.pagePhoto),
                                      (MOVIE_DETAILS.longDescription),
                                      (REVIEW_DETAILS.rating),
                                      (REVIEW_DETAILS.review),
                                      (REVIEW_DETAILS.reviewDate),
                                      (REVIEW_DETAILS.userId),db.func.avg(REVIEW_DETAILS.rating).label('averageRating'),).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.id).order_by(REVIEW_DETAILS.rating.desc()).filter(MOVIE_DETAILS.title.contains(searchTerm)).all()

    movies = []
    print(movies)
    
    for movie in movie_list:
        movies.append({ 'id' : movie.id, 
                       'title' : movie.title, 
                       'release' : movie.release, 
                       'description' : movie.description, 
                       'rating' : movie.averageRating, 
                       'movieLength' : movie.movieLength,
                       'category' : movie.category,
                       'coverPhoto' : movie.coverPhoto,
                       'pagePhoto' : movie.pagePhoto,
                       'longDescription' : movie.longDescription})
    
    return jsonify ({'searchResults': movies})

@main.route('/movieReviews', methods=['POST'])
def movieReviews():
    id = request.get_json()
    print(id)
    movie_list = db.session.query((MOVIE_DETAILS.id),
                                      (MOVIE_DETAILS.title),
                                      (MOVIE_DETAILS.release),
                                      (MOVIE_DETAILS.description),
                                      (MOVIE_DETAILS.category),
                                      (MOVIE_DETAILS.movieLength),
                                      (MOVIE_DETAILS.coverPhoto),
                                      (MOVIE_DETAILS.pagePhoto),
                                      (MOVIE_DETAILS.longDescription),
                                      (REVIEW_DETAILS.rating),
                                      (REVIEW_DETAILS.review),
                                      (REVIEW_DETAILS.reviewDate),
                                      (REVIEW_DETAILS.userId),db.func.avg(REVIEW_DETAILS.rating).label('averageRating'),).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.id).order_by(REVIEW_DETAILS.rating.desc()).filter(MOVIE_DETAILS.id==id).all()

    
    review_list = db.session.query((REVIEW_DETAILS.rating),(REVIEW_DETAILS.review),(REVIEW_DETAILS.reviewDate),(REVIEW_DETAILS.userId),
                                   (REVIEW_DETAILS.reviewId),(REVIEW_DETAILS.movieId),(USER_DETAILS.userName)).outerjoin(USER_DETAILS).filter(REVIEW_DETAILS.movieId==id).all()
    movies = []
    
    for movie in movie_list:
        movies.append({ 'id' : movie.id, 
                       'title' : movie.title, 
                       'release' : movie.release, 
                       'description' : movie.description, 
                       'rating' : movie.averageRating, 
                       'movieLength' : movie.movieLength,
                       'category' : movie.category,
                       'coverPhoto' : movie.coverPhoto,
                       'pagePhoto' : movie.pagePhoto,
                       'longDescription' : movie.longDescription})
        
    reviews = []
    
    for review in review_list:
        reviews.append({ 'reviewId' : review.reviewId, 
                       'movieId' : review.movieId, 
                       'userId' : review.userId, 
                       'rating' : review.rating, 
                       'review' : review.review,
                       'reviewDate' : review.reviewDate,
                       'userName' : review.userName})
    
    return jsonify ({'movieDetails': movies,'movieReviews': reviews})

@main.route('/myaccount', methods=['POST'])
def myaccount():
    userID = request.get_json()
    print(userID)
    user_list = USER_DETAILS.query.filter(USER_DETAILS.id==userID).all()
    
    review_list = db.session.query((REVIEW_DETAILS.rating),
                                   (REVIEW_DETAILS.review),
                                   (REVIEW_DETAILS.reviewDate),
                                   (REVIEW_DETAILS.userId),
                                   (REVIEW_DETAILS.reviewId),
                                   (REVIEW_DETAILS.movieId),
                                   (USER_DETAILS.userName)).outerjoin(USER_DETAILS).filter(REVIEW_DETAILS.userId==userID).all()
    
    reviews = []
    
    for review in review_list:
        reviews.append({ 'reviewId' : review.reviewId, 
                       'movieId' : review.movieId, 
                       'userId' : review.userId, 
                       'rating' : review.rating, 
                       'review' : review.review,
                       'reviewDate' : review.reviewDate,
                       'userName' : review.userName})
    
    movieID=(reviews[-1])['movieId']
    print(movieID)
    
    movie_list = db.session.query((MOVIE_DETAILS.id),
                                      (MOVIE_DETAILS.title),
                                      (MOVIE_DETAILS.release),
                                      (MOVIE_DETAILS.description),
                                      (MOVIE_DETAILS.category),
                                      (MOVIE_DETAILS.movieLength),
                                      (MOVIE_DETAILS.coverPhoto),
                                      (MOVIE_DETAILS.pagePhoto),
                                      (MOVIE_DETAILS.longDescription),
                                      (REVIEW_DETAILS.review),
                                      (REVIEW_DETAILS.reviewDate),
                                      (REVIEW_DETAILS.userId),db.func.avg(REVIEW_DETAILS.rating).label('averageRating'),).outerjoin(REVIEW_DETAILS).group_by(MOVIE_DETAILS.id).order_by(REVIEW_DETAILS.rating.desc()).filter(REVIEW_DETAILS.movieId==movieID).all()

    print(movieID)

    users = []
    
    for user in user_list:
        users.append({ 'id' : user.id, 
                       'userName' : user.userName, 
                       'userPassword' : user.userPassword,
                       'joinDate' : user.joinDate})
    
    movies = []
    
    for movie in movie_list:
        movies.append({ 'id' : movie.id, 
                       'title' : movie.title, 
                       'release' : movie.release, 
                       'description' : movie.description, 
                       'rating' : movie.averageRating, 
                       'movieLength' : movie.movieLength,
                       'category' : movie.category,
                       'coverPhoto' : movie.coverPhoto})
        
    
    
    
    return jsonify ({'movieDetails': movies,'userDetails': users,'userReviews': reviews})