Upload 10 files

app.py

@@ -0,0 +1,33 @@
+from flask import Flask
+from flask_cors import CORS
+from config.database import init_db
+from routes.auth import auth_bp
+from routes.recommend import recommend_bp
+from routes.history import history_bp
+from routes.user import user_bp
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+app = Flask(__name__)
+app.config['SECRET_KEY'] = os.getenv('SECRET_KEY')
+
+# Enable CORS
+CORS(app)
+
+# Initialize MongoDB
+init_db()
+
+# Register blueprints
+app.register_blueprint(auth_bp, url_prefix='/auth')
+app.register_blueprint(recommend_bp)
+app.register_blueprint(history_bp)
+app.register_blueprint(user_bp, url_prefix='/user')
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    return {"status": "healthy", "message": "Flask backend is running"}, 200
+
+if __name__ == "__main__":
+    app.run(port=5000, debug=True)

config/database.py

@@ -0,0 +1,41 @@
+from pymongo import MongoClient
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+client = None
+db = None
+
+def init_db():
+    global client, db
+    
+    MONGO_URI = os.getenv('MONGO_URI')
+    DATABASE_NAME = os.getenv('DATABASE_NAME', 'recommendation_system')
+    
+    if not MONGO_URI:
+        raise ValueError("MONGO_URI environment variable is required")
+    
+    try:
+        client = MongoClient(MONGO_URI)
+        db = client[DATABASE_NAME]
+        
+        # Test connection
+        client.admin.command('ping')
+        print(f"Connected to MongoDB database: {DATABASE_NAME}")
+        
+        # Create indexes for performance
+        db.users.create_index("email", unique=True)
+        db.users.create_index("username", unique=True)
+        db.history.create_index([("user_id", 1), ("timestamp", -1)])
+        
+        return db
+    except Exception as e:
+        print(f"Failed to connect to MongoDB: {e}")
+        raise e
+
+def get_db():
+    global db
+    if db is None:
+        init_db()
+    return db

models/history.py

@@ -0,0 +1,84 @@
+from datetime import datetime, timezone
+from config.database import get_db
+from bson import ObjectId
+
+class History:
+    def __init__(self, user_id, recommendation_type, genre, items, query_params=None):
+        self.user_id = ObjectId(user_id)
+        self.recommendation_type = recommendation_type
+        self.genre = genre
+        self.items = items
+        self.query_params = query_params or {}
+        self.timestamp = datetime.now(timezone.utc)
+        
+    def save(self):
+        db = get_db()
+        history_data = {
+            "user_id": self.user_id,
+            "recommendation_type": self.recommendation_type,
+            "genre": self.genre,
+            "items": self.items,
+            "query_params": self.query_params,
+            "timestamp": self.timestamp
+        }
+        result = db.history.insert_one(history_data)
+        return str(result.inserted_id)
+    
+    @staticmethod
+    def get_user_history(user_id, limit=50, offset=0):
+        db = get_db()
+        try:
+            history = list(db.history.find(
+                {"user_id": ObjectId(user_id)}
+            ).sort("timestamp", -1).skip(offset).limit(limit))
+            
+            # Convert ObjectId to string for JSON serialization
+            for item in history:
+                item["_id"] = str(item["_id"])
+                item["user_id"] = str(item["user_id"])
+                
+            return history
+        except:
+            return []
+    
+    @staticmethod
+    def get_user_stats(user_id):
+        db = get_db()
+        try:
+            # Type statistics
+            type_pipeline = [
+                {"$match": {"user_id": ObjectId(user_id)}},
+                {"$group": {
+                    "_id": "$recommendation_type",
+                    "count": {"$sum": 1},
+                    "last_accessed": {"$max": "$timestamp"}
+                }}
+            ]
+            type_stats = list(db.history.aggregate(type_pipeline))
+            
+            # Genre preferences - handle both string and array genres
+            genre_pipeline = [
+                {"$match": {"user_id": ObjectId(user_id)}},
+                {"$unwind": "$genre"},
+                {"$group": {
+                    "_id": "$genre",
+                    "count": {"$sum": 1}
+                }},
+                {"$sort": {"count": -1}},
+                {"$limit": 10}
+            ]
+            genre_stats = list(db.history.aggregate(genre_pipeline))
+            
+            total_count = db.history.count_documents({"user_id": ObjectId(user_id)})
+            
+            return {
+                "type_stats": type_stats,
+                "genre_preferences": genre_stats,
+                "total_recommendations": total_count
+            }
+        except:
+            return {
+                "type_stats": [],
+                "genre_preferences": [],
+                "total_recommendations": 0
+            }

models/user.py

@@ -0,0 +1,96 @@
+from datetime import datetime, timezone
+from werkzeug.security import generate_password_hash, check_password_hash
+from config.database import get_db
+from bson import ObjectId
+
+class User:
+    def __init__(self, username=None, email=None, password=None, preferences=None):
+        self.username = username
+        self.email = email
+        self.password_hash = generate_password_hash(password) if password else None
+        self.preferences = preferences or {"genres": [], "types": []}
+        self.created_at = datetime.now(timezone.utc)
+        self.last_login = None
+        
+    def save(self):
+        db = get_db()
+        user_data = {
+            "username": self.username,
+            "email": self.email,
+            "password_hash": self.password_hash,
+            "preferences": self.preferences,
+            "created_at": self.created_at,
+            "last_login": self.last_login
+        }
+        result = db.users.insert_one(user_data)
+        return str(result.inserted_id)
+    
+    @staticmethod
+    def find_by_email(email):
+        db = get_db()
+        user_data = db.users.find_one({"email": email})
+        if user_data:
+            user = User()
+            user._id = user_data["_id"]
+            user.username = user_data["username"]
+            user.email = user_data["email"]
+            user.password_hash = user_data["password_hash"]
+            user.preferences = user_data.get("preferences", {"genres": [], "types": []})
+            user.created_at = user_data["created_at"]
+            user.last_login = user_data.get("last_login")
+            return user
+        return None
+    
+    @staticmethod
+    def find_by_username(username):
+        db = get_db()
+        user_data = db.users.find_one({"username": username})
+        if user_data:
+            user = User()
+            user._id = user_data["_id"]
+            user.username = user_data["username"]
+            user.email = user_data["email"]
+            user.password_hash = user_data["password_hash"]
+            user.preferences = user_data.get("preferences", {"genres": [], "types": []})
+            user.created_at = user_data["created_at"]
+            user.last_login = user_data.get("last_login")
+            return user
+        return None
+    
+    @staticmethod
+    def find_by_id(user_id):
+        db = get_db()
+        try:
+            user_data = db.users.find_one({"_id": ObjectId(user_id)})
+            if user_data:
+                user = User()
+                user._id = user_data["_id"]
+                user.username = user_data["username"]
+                user.email = user_data["email"]
+                user.password_hash = user_data["password_hash"]
+                user.preferences = user_data.get("preferences", {"genres": [], "types": []})
+                user.created_at = user_data["created_at"]
+                user.last_login = user_data.get("last_login")
+                return user
+        except:
+            pass
+        return None
+    
+    def check_password(self, password):
+        return check_password_hash(self.password_hash, password)
+    
+    def update_last_login(self):
+        db = get_db()
+        self.last_login = datetime.now(timezone.utc)
+        db.users.update_one(
+            {"_id": self._id},
+            {"$set": {"last_login": self.last_login}}
+        )
+    
+    def update_preferences(self, preferences):
+        db = get_db()
+        self.preferences = preferences
+        db.users.update_one(
+            {"_id": self._id},
+            {"$set": {"preferences": preferences}}
+        )

requirements.txt

@@ -0,0 +1,7 @@
+Flask==2.3.3
+pymongo==4.5.0
+PyJWT==2.8.0
+Werkzeug==2.3.7
+python-dotenv==1.0.0
+requests==2.31.0
+flask-cors==4.0.0

routes/auth.py

@@ -0,0 +1,109 @@
+from flask import Blueprint, request, jsonify
+from models.user import User
+from utils.jwt_helper import generate_jwt
+import re
+
+auth_bp = Blueprint('auth', __name__)
+
+def validate_email(email):
+    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+    return re.match(pattern, email) is not None
+
+def validate_password(password):
+    return len(password) >= 6
+
+@auth_bp.route('/signup', methods=['POST'])
+def signup():
+    try:
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+        
+        username = data.get('username', '').strip()
+        email = data.get('email', '').strip().lower()
+        password = data.get('password', '')
+        preferences = data.get('preferences', {"genres": [], "types": []})
+        
+        # Validation
+        if not username or not email or not password:
+            return jsonify({"error": "Username, email, and password are required"}), 400
+        
+        if len(username) < 3:
+            return jsonify({"error": "Username must be at least 3 characters long"}), 400
+        
+        if not validate_email(email):
+            return jsonify({"error": "Invalid email format"}), 400
+        
+        if not validate_password(password):
+            return jsonify({"error": "Password must be at least 6 characters long"}), 400
+        
+        # Check if user already exists
+        if User.find_by_email(email):
+            return jsonify({"error": "Email already registered"}), 409
+        
+        if User.find_by_username(username):
+            return jsonify({"error": "Username already taken"}), 409
+        
+        # Create new user
+        user = User(username=username, email=email, password=password, preferences=preferences)
+        user_id = user.save()
+        
+        # Generate JWT token
+        token = generate_jwt(user_id, username, email)
+        
+        return jsonify({
+            "message": "User created successfully",
+            "token": token,
+            "user": {
+                "id": user_id,
+                "username": username,
+                "email": email,
+                "preferences": preferences
+            }
+        }), 201
+        
+    except Exception as e:
+        print(f"Signup error: {e}")
+        return jsonify({"error": "Internal server error"}), 500
+
+@auth_bp.route('/login', methods=['POST'])
+def login():
+    try:
+        data = request.get_json()
+        
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+        
+        email = data.get('email', '').strip().lower()
+        password = data.get('password', '')
+        
+        if not email or not password:
+            return jsonify({"error": "Email and password are required"}), 400
+        
+        # Find user by email
+        user = User.find_by_email(email)
+        if not user or not user.check_password(password):
+            return jsonify({"error": "Invalid email or password"}), 401
+        
+        # Update last login
+        user.update_last_login()
+        
+        # Generate JWT token
+        token = generate_jwt(user._id, user.username, user.email)
+        
+        return jsonify({
+            "message": "Login successful",
+            "token": token,
+            "user": {
+                "id": str(user._id),
+                "username": user.username,
+                "email": user.email,
+                "preferences": user.preferences,
+                "last_login": user.last_login.isoformat() if user.last_login else None
+            }
+        }), 200
+        
+    except Exception as e:
+        print(f"Login error: {e}")
+        return jsonify({"error": "Internal server error"}), 500

routes/history.py

@@ -0,0 +1,66 @@
+from flask import Blueprint, request, jsonify
+from utils.jwt_helper import decode_jwt
+from models.history import History
+
+history_bp = Blueprint('history', __name__)
+
+@history_bp.route('/history', methods=['GET'])
+def get_history():
+    try:
+        # JWT Authentication
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            return jsonify({"error": "Missing or invalid Authorization header"}), 401
+
+        token = auth_header.split(" ")[1]
+        try:
+            user_data = decode_jwt(token)
+            user_id = user_data.get("user_id")
+        except Exception as e:
+            return jsonify({"error": "Invalid or expired token"}), 401
+
+        # Get query parameters
+        limit = min(int(request.args.get('limit', 20)), 100)  # Max 100 items
+        offset = int(request.args.get('offset', 0))
+
+        # Get user history
+        history = History.get_user_history(user_id, limit=limit, offset=offset)
+
+        return jsonify({
+            "status": "success",
+            "history": history,
+            "count": len(history),
+            "limit": limit,
+            "offset": offset
+        }), 200
+
+    except Exception as e:
+        print(f"History error: {e}")
+        return jsonify({"error": "Internal server error"}), 500
+
+@history_bp.route('/history/stats', methods=['GET'])
+def get_history_stats():
+    try:
+        # JWT Authentication
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            return jsonify({"error": "Missing or invalid Authorization header"}), 401
+
+        token = auth_header.split(" ")[1]
+        try:
+            user_data = decode_jwt(token)
+            user_id = user_data.get("user_id")
+        except Exception as e:
+            return jsonify({"error": "Invalid or expired token"}), 401
+
+        # Get user stats
+        stats = History.get_user_stats(user_id)
+
+        return jsonify({
+            "status": "success",
+            "stats": stats
+        }), 200
+
+    except Exception as e:
+        print(f"Stats error: {e}")
+        return jsonify({"error": "Internal server error"}), 500

routes/recommend.py

@@ -0,0 +1,222 @@
+from flask import Blueprint, request, jsonify
+import requests
+import os
+from dotenv import load_dotenv
+from utils.jwt_helper import decode_jwt
+from models.history import History
+
+load_dotenv()
+
+recommend_bp = Blueprint('recommend', __name__)
+
+RECOMMENDER_ENDPOINTS = {
+    "movie": os.getenv("MOVIE_RECOMMENDER_URL"),
+    "book": os.getenv("BOOK_RECOMMENDER_URL"),
+    "tv": os.getenv("TV_RECOMMENDER_URL")
+}
+
+RESPONSE_KEYS = {
+    "movie": "movies",
+    "book": "books",
+    "tv": "shows"
+}
+
+@recommend_bp.route('/recommend/tvshowrec', methods=['POST'])
+def recommend():
+    try:
+        data = request.get_json()
+
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+
+        rec_type = data.get('type')
+        genre = data.get('genre')
+        top_k = data.get('top_k', 10)
+
+        if not rec_type or not genre:
+            return jsonify({"error": "Missing 'type' or 'genre'"}), 400
+
+        if rec_type not in RECOMMENDER_ENDPOINTS or not RECOMMENDER_ENDPOINTS[rec_type]:
+            return jsonify({"error": "Invalid or missing recommender URL for type."}), 400
+
+        # JWT Authentication
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            return jsonify({"error": "Missing or invalid Authorization header"}), 401
+
+        token = auth_header.split(" ")[1]
+        try:
+            user_data = decode_jwt(token)
+            user_id = user_data.get("user_id")
+        except Exception as e:
+            return jsonify({"error": "Invalid or expired token"}), 401
+
+        # Process genres
+        genres_list = [g.strip() for g in genre.split(",")] if isinstance(genre, str) else genre
+
+        # Call microservice
+        try:
+            recommender_url = RECOMMENDER_ENDPOINTS[rec_type]
+            response = requests.post(
+                recommender_url,
+                json={"genres": genres_list},
+                timeout=10
+            )
+
+            if not response.ok:
+                return jsonify({
+                    "error": f"{rec_type} service error", 
+                    "details": response.text,
+                    "status_code": response.status_code
+                }), 500
+
+            result = response.json()
+            if result.get("status") != "success":
+                return jsonify({"error": result.get("message", "Unknown error")}), 500
+
+            raw_items = result.get(RESPONSE_KEYS.get(rec_type, "items"), [])
+
+            # Normalize response format
+            normalized = []
+            for item in raw_items:
+                normalized.append({
+                    "type": rec_type,
+                    "name": item.get("name") or item.get("title"),  
+                    "creator": item.get("director") or item.get("author") or item.get("creator"),
+                    "description": item.get("description", ""),
+                    "genre": item.get("genre", []),
+                    "rating": item.get("rating"),
+                    "year": item.get("year"),
+                    "image_url": item.get("image_url")
+                })
+
+            # Save to history
+            try:
+                history = History(
+                    user_id=user_id,
+                    recommendation_type=rec_type,
+                    genre=genres_list,
+                    items=normalized,
+                    query_params={"top_k": top_k}
+                )
+                history.save()
+                print(f"Saved recommendation history for user {user_id}")
+            except Exception as e:
+                print(f"Failed to save history: {e}")
+                # Don't fail the request if history saving fails
+
+            return jsonify({
+                "status": "success",
+                "recommendations": normalized,
+                "count": len(normalized),
+                "type": rec_type,
+                "genres": genres_list
+            }), 200
+
+        except requests.exceptions.Timeout:
+            return jsonify({"error": f"{rec_type} service timeout"}), 504
+        except requests.exceptions.RequestException as e:
+            return jsonify({"error": f"Failed to connect to {rec_type} service", "details": str(e)}), 503
+
+    except Exception as e:
+        print(f"Recommend error: {e}")
+        return jsonify({"error": "Internal server error"}), 500
+
+@recommend_bp.route('/recommend/movies', methods=['POST'])
+def recommend():
+    try:
+        data = request.get_json()
+
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+
+        rec_type = data.get('type')
+        genre = data.get('genre')
+        top_k = data.get('top_k', 10)
+
+        if not rec_type or not genre:
+            return jsonify({"error": "Missing 'type' or 'genre'"}), 400
+
+        if rec_type not in RECOMMENDER_ENDPOINTS or not RECOMMENDER_ENDPOINTS[rec_type]:
+            return jsonify({"error": "Invalid or missing recommender URL for type."}), 400
+
+        # JWT Authentication
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            return jsonify({"error": "Missing or invalid Authorization header"}), 401
+
+        token = auth_header.split(" ")[1]
+        try:
+            user_data = decode_jwt(token)
+            user_id = user_data.get("user_id")
+        except Exception as e:
+            return jsonify({"error": "Invalid or expired token"}), 401
+
+        # Process genres
+        genres_list = [g.strip() for g in genre.split(",")] if isinstance(genre, str) else genre
+
+        # Call microservice
+        try:
+            recommender_url = RECOMMENDER_ENDPOINTS[rec_type]
+            response = requests.post(
+                recommender_url,
+                json={"genres": genres_list, "top_k": top_k},
+                timeout=10
+            )
+
+            if not response.ok:
+                return jsonify({
+                    "error": f"{rec_type} service error", 
+                    "details": response.text,
+                    "status_code": response.status_code
+                }), 500
+
+            result = response.json()
+            if result.get("status") != "success":
+                return jsonify({"error": result.get("message", "Unknown error")}), 500
+
+            raw_items = result.get(RESPONSE_KEYS.get(rec_type, "items"), [])
+
+            # Normalize response format
+            normalized = []
+            for item in raw_items:
+                normalized.append({
+                    "type": rec_type,
+                    "name": item.get("name") or item.get("title"),  
+                    "creator": item.get("director") or item.get("author") or item.get("creator"),
+                    "description": item.get("description", ""),
+                    "genre": item.get("genre", []),
+                    "rating": item.get("rating")
+                })
+
+            # Save to history
+            try:
+                history = History(
+                    user_id=user_id,
+                    recommendation_type=rec_type,
+                    genre=genres_list,
+                    items=normalized,
+                    query_params={"top_k": top_k}
+                )
+                history.save()
+                print(f"Saved recommendation history for user {user_id}")
+            except Exception as e:
+                print(f"Failed to save history: {e}")
+                # Don't fail the request if history saving fails
+
+            return jsonify({
+                "status": "success",
+                "recommendations": normalized,
+                "count": len(normalized),
+                "type": rec_type,
+                "genres": genres_list
+            }), 200
+
+        except requests.exceptions.Timeout:
+            return jsonify({"error": f"{rec_type} service timeout"}), 504
+        except requests.exceptions.RequestException as e:
+            return jsonify({"error": f"Failed to connect to {rec_type} service", "details": str(e)}), 503
+
+    except Exception as e:
+        print(f"Recommend error: {e}")
+        return jsonify({"error": "Internal server error"}), 500

routes/user.py

@@ -0,0 +1,82 @@
+from flask import Blueprint, request, jsonify
+from utils.jwt_helper import decode_jwt
+from models.user import User
+
+user_bp = Blueprint('user', __name__)
+
+@user_bp.route('/profile', methods=['GET'])
+def get_profile():
+    try:
+        # JWT Authentication
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            return jsonify({"error": "Missing or invalid Authorization header"}), 401
+
+        token = auth_header.split(" ")[1]
+        try:
+            user_data = decode_jwt(token)
+            user_id = user_data.get("user_id")
+        except Exception as e:
+            return jsonify({"error": "Invalid or expired token"}), 401
+
+        # Get user profile
+        user = User.find_by_id(user_id)
+        if not user:
+            return jsonify({"error": "User not found"}), 404
+
+        return jsonify({
+            "status": "success",
+            "user": {
+                "id": str(user._id),
+                "username": user.username,
+                "email": user.email,
+                "preferences": user.preferences,
+                "created_at": user.created_at.isoformat(),
+                "last_login": user.last_login.isoformat() if user.last_login else None
+            }
+        }), 200
+
+    except Exception as e:
+        print(f"Profile error: {e}")
+        return jsonify({"error": "Internal server error"}), 500
+
+@user_bp.route('/preferences', methods=['PUT'])
+def update_preferences():
+    try:
+        # JWT Authentication
+        auth_header = request.headers.get('Authorization')
+        if not auth_header or not auth_header.startswith('Bearer '):
+            return jsonify({"error": "Missing or invalid Authorization header"}), 401
+
+        token = auth_header.split(" ")[1]
+        try:
+            user_data = decode_jwt(token)
+            user_id = user_data.get("user_id")
+        except Exception as e:
+            return jsonify({"error": "Invalid or expired token"}), 401
+
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No data provided"}), 400
+            
+        preferences = data.get('preferences')
+
+        if not preferences or not isinstance(preferences, dict):
+            return jsonify({"error": "Valid preferences object is required"}), 400
+
+        # Update user preferences
+        user = User.find_by_id(user_id)
+        if not user:
+            return jsonify({"error": "User not found"}), 404
+
+        user.update_preferences(preferences)
+
+        return jsonify({
+            "status": "success",
+            "message": "Preferences updated successfully",
+            "preferences": preferences
+        }), 200
+
+    except Exception as e:
+        print(f"Preferences error: {e}")
+        return jsonify({"error": "Internal server error"}), 500

utils/jwt_helper.py

@@ -0,0 +1,27 @@
+import jwt
+import os
+from datetime import datetime, timedelta, timezone
+from dotenv import load_dotenv
+
+load_dotenv()
+
+SECRET_KEY = os.getenv("SECRET_KEY")
+
+def generate_jwt(user_id, username, email):
+    payload = {
+        "user_id": str(user_id),
+        "username": username,
+        "email": email,
+        "exp": datetime.now(timezone.utc) + timedelta(days=7),
+        "iat": datetime.now(timezone.utc)
+    }
+    return jwt.encode(payload, SECRET_KEY, algorithm="HS256")
+
+def decode_jwt(token):
+    try:
+        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
+        return payload
+    except jwt.ExpiredSignatureError:
+        raise Exception("Token has expired")
+    except jwt.InvalidTokenError:
+        raise Exception("Invalid token")