Merge branch 'ericnew' of https://github.com/Ben-Sicat/Study_hub into ericnew

Author: ericramos-07

backend/app/app.py

@@ -1,14 +1,15 @@
 from flask import Flask, jsonify, make_response, request
-from flask_jwt_extended import JWTManager, create_access_token
+from flask_jwt_extended import JWTManager, create_access_token, decode_token
 import mysql.connector
 from flask_cors import CORS
+from apscheduler.schedulers.background import BackgroundScheduler
+from datetime import datetime, timedelta
 
 app = Flask(__name__)
-CORS(app, resources={r"/api/*": {"origins": "http://localhost:3000"}})
-app.config["JWT_SECRET_KEY"] = "your-secret-key"  # Change this to a secure and secret key
+CORS(app, resources={r"/api/*": {"origins": "http://localhost:3000"}}) 
 jwt = JWTManager(app)
 
-# Database configuration
+# Database configurations
 db_config = {
     'user': 'root',
     'password': 'root',
@@ -17,37 +18,48 @@
     'database': 'BrewandBrain'
 }
 
-def get_db_connection():
+warehouse_db_config = {
+    'user': 'root',
+    'password': 'root',
+    'host': 'warehouse_db',
+    'port': '3308',
+    'database': 'BrewandBrain_warehouse'
+}
+
+
+def get_db_connection(config):
     try:
-        connection = mysql.connector.connect(**db_config)
+        connection = mysql.connector.connect(**config)
         return connection
     except mysql.connector.Error as err:
         print(f"Error connecting to the database: {err}")
         return None
 
 # User-related functions
 def write_to_users(data):
-    connection = get_db_connection()
+    connection = get_db_connection(db_config)
     if connection:
         try:
             cursor = connection.cursor()
             query = """
                 INSERT INTO Users 
-                (GoogleID, Username, Email, Password, FirstName, LastName, PhoneNumber, UName, Birthday, Gender, School)
+                (GoogleID, Username, Email, Password, FirstName, LastName, PhoneNumber, UName, Birthday, Gender, Occupation)
                 VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
             """
+            
             values = (
-                data['google_id'], data['username'], data['email'], data['password'],
-                data['first_name'], data['last_name'], data['phone_number'], 'UName', '2003-03-05', 'Male', 'Sample School'
+                1, data['username'], data['email'], data['password'],
+                data['firstName'], data['lastName'], data['phoneNumber'], 'UName', data['birthdate'], data['gender'], data['occupation']
             )
             cursor.execute(query, values)
             connection.commit()
             cursor.close()
             connection.close()
         except mysql.connector.Error as err:
             print(f"Error writing to Users table: {err}")
+
 def update_user_details(user_id, updated_data):
-    connection= get_db_connection()
+    connection = get_db_connection(db_config)
     if connection:
         try:
             cursor = connection.cursor()
@@ -66,8 +78,9 @@ def update_user_details(user_id, updated_data):
             connection.close()
         except mysql.connector.Error as err:
             print(f"Error updating user details: {err}")
+
 def get_all_users():
-    connection = get_db_connection()
+    connection = get_db_connection(db_config)
     if connection:
         try:
             cursor = connection.cursor(dictionary=True)
@@ -78,13 +91,14 @@ def get_all_users():
             return results
         except mysql.connector.Error as err:
             print(f"Error: {err}")
+
 def get_user_by_id(user_id):
-    connection = get_db_connection()
+    connection = get_db_connection(db_config)
     if connection:
         try:
             cursor = connection.cursor(dictionary=True)
             query = """
-                SELECT UserID, GoogleID, Username, Email, FirstName, LastName, PhoneNumber, UName, Birthday, Gender, School
+                SELECT UserID, GoogleID, Username, Email, FirstName, LastName, PhoneNumber, UName, Birthday, Gender, Occupation
                 FROM Users
                 WHERE UserID = %s
             """
@@ -96,14 +110,13 @@ def get_user_by_id(user_id):
         except mysql.connector.Error as err:
             print(f"Error fetching user by ID: {err}")
 
-
 def get_user_by_email_or_username(email_or_username):
-    connection = get_db_connection()
+    connection = get_db_connection(db_config)
     if connection:
         try:
             cursor = connection.cursor(dictionary=True)
             query = """
-                SELECT UserID, GoogleID, Username, Password, Email, UName, Birthday, Gender, School
+                SELECT UserID, GoogleID, Username, Password, Email, UName, Birthday, Gender, Occupation
                 FROM Users
                 WHERE Email = %s OR Username = %s
             """
@@ -114,63 +127,69 @@ def get_user_by_email_or_username(email_or_username):
             return result
         except mysql.connector.Error as err:
             print(f"Error fetching user by email or username: {err}")
-def create_reservation(user_id, reservation_data):
-    connection = get_db_connection()
-    if connection:
-        try:
-            cursor = connection.cursor()
-            query = """
-                INSERT INTO Reservations 
-                (UserID, StartTime, EndTime, Seat)
-                VALUES (%s, %s, %s, %s)
-            """
-            values = (
-                    user_id,
-                    reservation_data['STime'],
-                    reservation_data['ETime'],
-                    reservation_data['Seat'],
-                )
-            cursor.execute(query, values)
-            connection.commit()
-            cursor.close()
-            connection.close()
-        except mysql.connector.Error as err:
-            print(f"Error creating reservation: {err}")
-def get_user_reservations(user_id):
-    connection = get_db_connection()
-    if connection:
-        try:
-            cursor = connection.cursor(dictionary=True)
-            query = """
-                SELECT ReservationID, StartTime, EndTime, Seat
-                FROM Reservations
-                WHERE UserID = %s
-            """
-            cursor.execute(query, (user_id,))
-            results = cursor.fetchall()
-            cursor.close()
-            connection.close()
-            return results
-        except mysql.connector.Error as err:
-            print(f"Error fetching user reservations: {err}")
-            
-@app.route('/api/sign-in', methods=['POST'])
-def sign_in():
-    data = request.get_json()
-    user = get_user_by_email_or_username(data['login'])
-    
-    if user and user['Password'] == data['password']:
-        access_token = create_access_token(identity=user['Username'])
-        
-        # Create a response object
-        response = make_response(jsonify(access_token=access_token), 200)
-        
-        # Set HttpOnly flag for the access token cookie
-        response.set_cookie('access_token', value=access_token, httponly=True)
-        
-        return response
-    else:
-        return jsonify({"message": "Invalid login credentials"}), 401
+
+def perform_warehouse_process():
+    try:
+        # Connect to operational database
+        operational_connection = get_db_connection(db_config)
+        if operational_connection:
+            operational_cursor = operational_connection.cursor(dictionary=True)
+
+            # Connect to warehouse database
+            warehouse_connection = get_db_connection(warehouse_db_config)
+            if warehouse_connection:
+                warehouse_cursor = warehouse_connection.cursor()
+
+                try:
+                    # Extract data from the operational database
+                    operational_cursor.execute("""
+                        SELECT UserID, School, Occupation
+                        FROM Users
+                    """)
+                    users_data = operational_cursor.fetchall()
+
+                    # Transform and load data into the warehouse
+                    for user in users_data:
+                        # Fetch reservations for the current user
+                        operational_cursor.execute("""
+                            SELECT StartTime, EndTime
+                            FROM Reservations
+                            WHERE UserID = %s
+                        """, (user['UserID'],))
+                        reservations_data = operational_cursor.fetchall()
+
+                        # Insert user and reservation data into the warehouse
+                        for reservation in reservations_data:
+                            warehouse_cursor.execute(
+                                """
+                                INSERT INTO UserSummary (UserID, School, Occupation, StartTime, EndTime)
+                                VALUES (%s, %s, %s, %s, %s)
+                                """,
+                                (user['UserID'], user['School'], user['Occupation'],
+                                 reservation['StartTime'], reservation['EndTime'])
+                            )
+
+                    # Commit changes to the warehouse database
+                    warehouse_connection.commit()
+                    print("Warehouse process completed successfully.")
+                except Exception as e:
+                    print(f"Error during ETL process: {e}")
+                    warehouse_connection.rollback()  # Rollback changes in case of an error
+
+                warehouse_cursor.close()
+                warehouse_connection.close()
+
+            operational_cursor.close()
+            operational_connection.close()
+
+    except Exception as e:
+        print(f"Error performing warehouse process: {e}")
+
+# Initialize the BackgroundScheduler
+scheduler = BackgroundScheduler()
+
+# Add the scheduled job to run the ETL process every 168 hours or 1 week
+scheduler.add_job(perform_warehouse_process, 'interval', hours=168)
 
 @app.route('/api/create-account', methods=['POST'])
 def create_account():
@@ -183,7 +202,43 @@ def create_account():
         print(f"Error creating account: {e}")
         return jsonify(message='Error creating account'), 500
 
-@app.route('/api/update-account/<int:user_id>', methods=['PUT'])
+
+@app.route('/api/sign-in', methods=['POST'])
+def sign_in():
+    data = request.get_json()
+    user = get_user_by_email_or_username(data['login'])
+    
+    if user and user['Password'] == data['password']:
+        
+        # token = create_access_token(identity=user['Username'])
+        
+        # # Access the access_token directly from create_access_token
+        # access_token = decode_token(token)['identity']
+        # print(access_token)
+
+        # Fetch additional user data
+        user_data = get_user_by_id(user['UserID'])
+
+        # Create a response object
+        response_data = {
+            'user_data': {
+                'UserID': user_data['UserID'],
+                'Username': user_data['Username'],
+                'Email': user_data['Email'],
+                'PhoneNumber': user_data['PhoneNumber'],
+                'Gender': user_data['Gender'],
+                'Occupation': user_data['Occupation'],
+                
+                # Add other user data fields as needed
+            }
+        }
+
+        response = make_response(jsonify(response_data), 200)
+        
+        return response
+    else:
+        return jsonify({"message": "Invalid login credentials"}), 401    
+@app.route('/api/update-account/', methods=['PUT'])
 def update_account(user_id):
     try:
         updated_data = request.get_json()
@@ -194,16 +249,25 @@ def update_account(user_id):
         print(f"Error updating account: {e}")
         return jsonify(message='Error updating account'), 500
 
-@app.route('/api/reservations', methods=['POST'])
-def make_reservation():
-    try:
-        data = request.get_json()
-        user_id = 1  # Replace with the actual user ID; you need to identify the user somehow
-        result = create_reservation(user_id, data)
-        return jsonify(result)
-    except Exception as e:
-        print(f"Error creating reservation: {e}")
-        return jsonify(error='Error creating reservation'), 500 
+# @app.route('/api/get-reservations/<int:user_id>', methods=['GET'])
+# def get_reservations(user_id):
+#     try:
+#         reservations = get_user_reservations(user_id)
+#         return jsonify(reservations)
+#     except Exception as e:
+#         print(f"Error fetching reservations: {e}")
+#         return jsonify(error='Error fetching reservations'), 500
+
+# @app.route('/api/reservations', methods=['POST'])
+# def make_reservation():
+#     try:
+#         data = request.get_json()
+#         user_id = 5  # Replace with the actual user ID; you need to identify the user somehow
+#         result = create_reservation(user_id, data)
+#         return jsonify(result)
+#     except Exception as e:
+#         print(f"Error creating reservation: {e}")
+#         return jsonify(error='Error creating reservation'), 500 
 
 
 # Additional user-related functions
@@ -227,4 +291,5 @@ def index():
     return jsonify({'User Data': 'Sample user created'})
 
 if __name__ == '__main__':
+    scheduler.start()
     app.run(host='0.0.0.0', debug=True)

backend/app/requirements.txt

@@ -3,3 +3,4 @@ mysql-connector-python
 Flask-JWT-Extended
 bcrypt
 Flask-CORS
+APScheduler

backend/app/tempCodeRunnerFile.py

@@ -1,7 +1 @@
-@app.route('/test', methods=['GET'])
-# def test_route():
-#     return jsonify(message='Test route works!')
-
-# @app.route('/test-post', methods=['POST'])
-# def test_route():
-#     return jsonify(message='Test route works!')
+sign

backend/db/init.sql

@@ -12,19 +12,19 @@ CREATE TABLE Users (
   LastName VARCHAR(100) NOT NULL,
   PhoneNumber VARCHAR(20),
   UName VARCHAR(225) NOT NULL,
-  Birthday DATE,
+  Birthday VARCHAR(225),
   Gender ENUM('Male', 'Female', 'Other'),
   School VARCHAR(225),
+  Occupation VARCHAR(225),
   Level ENUM('User', 'Admin', 'Employee') DEFAULT 'User'
 );
 
 CREATE TABLE Reservations (
   ReservationID INT AUTO_INCREMENT PRIMARY KEY,
   UserID INT, 
-  StartTime TIME NOT NULL,
+  StartTime VARCHAR(255) NOT NULL,
   EndTime VARCHAR(225) NOT NULL,
-  Seat VARCHAR(50),
-  FOREIGN KEY (UserID) REFERENCES Users(UserID)
+  Seat VARCHAR(50)
 );
 
 
@@ -35,5 +35,3 @@ CREATE TABLE QR_Codes (
     FOREIGN KEY (ReservationID) REFERENCES Reservations(ReservationID)
 );
 
-INSERT INTO Users (GoogleID, Username, Email, FirstName, LastName, PhoneNumber, UName, Birthday, Gender, School)
-VALUES ('mel.id', 'mlss_riri', 'melaixrio@gmail.com', 'Melaissa', 'Rioveros', '1234567890', 'Melaissa Rioveros', '2003-03-05', 'Female', 'Adamson University');

backend/db/warehouse_init.sql

@@ -0,0 +1,14 @@
+CREATE DATABASE BrewandBrain_warehouse;
+
+USE BrewandBrain_warehouse;
+
+CREATE TABLE IF NOT EXISTS UserSummary(
+    UserID INT NOT NULL,
+    School VARCHAR (100),
+    Occupation VARCHAR(100),
+    StartTime DATETIME,
+    EndTime DATETIME,
+    PRIMARY KEY (UserID)
+);
+
+CREATE INDEX idx_UserSumamry_UserID ON UserSummary(UserID);