mm

README.md

@@ -1,6 +1,17 @@
-# Fall 2024 CS 3200 Project Template Repository
+# Fall 2024 CS 3200 SyncSpace Repository
 
-This repo is a template for your semester project.  It includes most of the infrastructure setup (containers) and sample code and data throughout.  Explore it fully and ask questions.
+# Welcome to our guidebook for everything and anything SyncSpace! 
+This guidebook is inclusive of the details of our project and all the information you need to build/start the containers. We hope you enjoy exploring!
+
+By Team Fontenators: Christine Ahn, Praytusha Chamarthi, Mika Nguyen, Yugeun Park, Xavier Yu
+
+## About SyncSpace
+Our app SyncSpace is a data-driven virtual community that aims to connect students going on co-ops and internships, helping them make the most of their experience. Students often feel isolated or overwhelmed when relocating for work, facing the challenges of finding housing, arranging transportation, and locating familiar faces nearby. SyncSpace solves this by using curated feedback, data, and shared interests/community forums to match students with ‘co-op buddies’ in their area, helping them form connections, navigate new cities, and share resources for housing and commuting. 
+
+Designed for students and co-op advisors, SyncSpace offers real-time data insights that help students connect with each other and thrive professionally. With personalized interest-based groups, housing and transportation forums, and a hub for professional events, students can access networking, guidance, and new friendships anytime they need it. Co-op advisors and system admin staff can effortlessly organize and track engagement, while gaining valuable data on student satisfaction, activity trends, and engagement levels. By building a vibrant, supportive community, we hope to empower students to make meaningful connections and maximize their co-op and internship experiences. 
+
+## Link to our demo
+https://youtu.be/8xzt0m0avSg 
 
 ## Prerequisites
 
@@ -17,12 +28,6 @@ Currently, there are three major components which will each run in their own Doc
 - Flask REST api in the `./api` directory
 - SQL files for your data model and data base in the `./database-files` directory
 
-## Suggestion for Learning the Project Code Base
-
-If you are not familiar with web app development, this code base might be confusing. You will probably want two versions though:
-1. One version for you to explore, try things, break things, etc. We'll call this your **Personal Repo** 
-1. One version of the repo that your team will share.  We'll call this the **Team Repo**. 
-
 
 ### Setting Up Your Personal Repo
 
@@ -32,15 +37,6 @@ If you are not familiar with web app development, this code base might be confus
 1. Set up the `.env` file in the `api` folder based on the `.env.template` file.
 1. Start the docker containers. 
 
-### Setting Up Your Team Repo 
-
-Before you start: As a team, one person needs to assume the role of *Team Project Repo Owner*. 
-
-1. The Team Project Repo Owner needs to fork this template repo into their own GitHub account **and give the repo a name consistent with your project's name**.  If you're worried that the repo is public, don't.  Every team is doing a different project. 
-1. In the newly forked team repo, the Team Project Repo Owner should go to the **Settings** tab, choose **Collaborators and Teams** on the left-side panel. Add each of your team members to the repository with Write access. 
-1. Each of the other team members will receive an invitation to join.  Obviously accept the invite. 
-1. Once that process is complete, each team member, including the repo owner, should clone the Team's Repo to their local machines (in a different location than your Personal Project Repo).  
-
 ## Controlling the Containers
 
 - `docker compose up -d` to start all the containers in the background
@@ -49,30 +45,11 @@ Before you start: As a team, one person needs to assume the role of *Team Projec
 - `docker compose stop` to "turn off" the containers but not delete them. 
 
 
-## Handling User Role Access and Control
-
-In most applications, when a user logs in, they assume a particular role.  For instance, when one logs in to a stock price prediction app, they may be a single investor, a portfolio manager, or a corporate executive (of a publicly traded company).  Each of those *roles* will likely present some similar features as well as some different features when compared to the other roles. So, how do you accomplish this in Streamlit?  This is sometimes called Role-based Access Control, or **RBAC** for short. 
-
-The code in this project demonstrates how to implement a simple RBAC system in Streamlit but without actually using user authentication (usernames and passwords).  The Streamlit pages from the original template repo are split up among 3 roles - Political Strategist, USAID Worker, and a System Administrator role (this is used for any sort of system tasks such as re-training ML model, etc.). It also demonstrates how to deploy an ML model. 
 
-Wrapping your head around this will take a little time and exploration of this code base.  Some highlights are below. 
 
-### Getting Started with the RBAC 
-1. We need to turn off the standard panel of links on the left side of the Streamlit app. This is done through the `app/src/.streamlit/config.toml` file.  So check that out. We are turning it off so we can control directly what links are shown. 
-1. Then I created a new python module in `app/src/modules/nav.py`.  When you look at the file, you will se that there are functions for basically each page of the application. The `st.sidebar.page_link(...)` adds a single link to the sidebar. We have a separate function for each page so that we can organize the links/pages by role. 
-1. Next, check out the `app/src/Home.py` file. Notice that there are 3 buttons added to the page and when one is clicked, it redirects via `st.switch_page(...)` to that Roles Home page in `app/src/pages`.  But before the redirect, I set a few different variables in the Streamlit `session_state` object to track role, first name of the user, and that the user is now authenticated.  
-1. Notice near the top of `app/src/Home.py` and all other pages, there is a call to `SideBarLinks(...)` from the `app/src/nav.py` module.  This is the function that will use the role set in `session_state` to determine what links to show the user in the sidebar. 
-1. The pages are organized by Role.  Pages that start with a `0` are related to the *Political Strategist* role.  Pages that start with a `1` are related to the *USAID worker* role.  And, pages that start with a `2` are related to The *System Administrator* role. 
 
 
-## Deploying An ML Model (Totally Optional for CS3200 Project)
 
-*Note*: This project only contains the infrastructure for a hypothetical ML model. 
 
-1. Build, train, and test your ML model in a Jupyter Notebook. 
-1. Once you're happy with the model's performance, convert your Jupyter Notebook code for the ML model to a pure python script.  You can include the `training` and `testing` functionality as well as the `prediction` functionality.  You may or may not need to include data cleaning, though. 
-1. Check out the  `api/backend/ml_models` module.  In this folder, I've put a sample (read *fake*) ML model in `model01.py`.  The `predict` function will be called by the Flask REST API to perform '*real-time*' prediction based on model parameter values that are stored in the database.  **Important**: you would never want to hard code the model parameter weights directly in the prediction function.  tl;dr - take some time to look over the code in `model01.py`.  
-1. The prediction route for the REST API is in `api/backend/customers/customer_routes.py`. Basically, it accepts two URL parameters and passes them to the `prediction` function in the `ml_models` module. The `prediction` route/function packages up the value(s) it receives from the model's `predict` function and send its back to Streamlit as JSON. 
-1. Back in streamlit, check out `app/src/pages/11_Prediction.py`.  Here, I create two numeric input fields.  When the button is pressed, it makes a request to the REST API URL `/c/prediction/.../...` function and passes the values from the two inputs as URL parameters.  It gets back the results from the route and displays them. Nothing fancy here. 
 
 

api/.env.template

@@ -2,5 +2,7 @@ SECRET_KEY=someCrazyS3cR3T!Key.!
 DB_USER=root
 DB_HOST=db
 DB_PORT=3306
-DB_NAME=northwind
+DB_NAME=SyncSpace
 MYSQL_ROOT_PASSWORD=<put a good password here>
+
+

api/app.py

@@ -0,0 +1,35 @@
+'''
+from flask import Flask
+from backend.db_connection import init_app
+from backend.advisor.co_op_advisor_routes import advisor
+from backend.students.student_routes import students
+
+
+
+app = Flask(__name__)
+
+init_app(app)
+
+
+
+@@ -15,6 +17,7 @@ init_app(app)
+
+# Register blueprints
+app.register_blueprint(advisor, url_prefix='/api')
+app.register_blueprint(tech_support_analyst, url_prefix='/api')
+app.register_blueprint(students, url_prefix='/api')
+
+
+
+# Register blueprints
+app.register_blueprint(advisor, url_prefix='/api/advisor')
+app.register_blueprint(tech_support_analyst, url_prefix='/api/tech_support_analyst')
+app.register_blueprint(students, url_prefix='/api/students')
+
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=4000)
+'''
+
+
+

api/backend/advisor/__init__.py

@@ -0,0 +1 @@
+# This can be empty, just needs to exist

api/backend/advisor/co_op_advisor_routes.py

@@ -0,0 +1,271 @@
+from flask import Blueprint
+from flask import request
+from flask import jsonify
+from flask import make_response
+from datetime import datetime
+
+from backend.db_connection import db
+
+advisor = Blueprint('advisor', __name__)
+
+
+@advisor.route('/advisor/tasks', methods=['GET'])
+def get_all_tasks():
+    query = '''
+    SELECT 
+        t.TaskID,
+        s.StudentID,
+        s.Name as student_name,
+        t.Status as task_status,
+        t.Description,
+        t.Reminder,
+        t.DueDate
+    FROM Task t
+    JOIN Student s ON t.AssignedTo = s.StudentID
+    ORDER BY t.DueDate ASC
+
+
+        '''
+    cursor = db.get_db().cursor()
+    cursor.execute(query)
+    theData = cursor.fetchall()
+    response = make_response(jsonify(theData))
+    response.status_code = 200
+    return response
+
+
+
+@advisor.route('/advisor/notifications', methods=['GET'])
+def get_notifications():
+    try:
+        cursor = db.get_db().cursor()
+        query = '''
+        SELECT 
+            s.Name as student_name,
+            t.Status as notification_status,
+            t.Reminder as date_assigned,
+            t.Description as description
+        FROM Task t
+        JOIN Student s ON t.AssignedTo = s.StudentID
+        ORDER BY t.Reminder DESC
+        '''
+        cursor.execute(query)
+        theData = cursor.fetchall()
+
+        response = make_response(jsonify(theData))
+        response.status_code = 200
+        return response
+    except Exception as e:
+        print(f"Database error: {str(e)}")
+        return jsonify({'error': 'Failed to fetch notifications'}), 500
+
+
+
+@advisor.route('/advisor/tasks/<task_id>', methods=['PUT'])
+def update_task_status(task_id):
+    try:
+        # Parse JSON data from request
+        data = request.json
+        new_status = data.get('status')
+
+        # Validate that status is provided
+        if not new_status:
+            return make_response(jsonify({"error": "Status is required"}), 400)
+
+        # Build the SQL query to update the task status
+        query = '''
+            UPDATE Task
+            SET Status = %s
+            WHERE TaskID = %s
+        '''
+        values = (new_status, task_id)
+
+        # Execute the query
+        cursor = db.get_db().cursor()
+        cursor.execute(query, values)
+
+        # Check if any rows were affected
+        if cursor.rowcount == 0:
+            db.get_db().rollback()
+            return make_response(jsonify({
+                "error": f"No task found with ID {task_id}"
+            }), 404)
+
+        db.get_db().commit()
+        print(f"Successfully updated status for task {task_id} to {new_status}")  # Debug log
+
+        # Return success response
+        return make_response(jsonify({
+            "message": "Task status updated successfully",
+            "task_id": task_id,
+            "new_status": new_status
+        }), 200)
+
+    except Exception as e:
+        print(f"Error updating task status: {str(e)}")  # Debug log
+        db.get_db().rollback()
+        return make_response(jsonify({"error": str(e)}), 500)
+
+
+@advisor.route('/advisor/tasks/<task_id>/reminder', methods=['PUT'])
+def update_task_reminder(task_id):
+    try:
+        # Get the new reminder date from request body
+        data = request.get_json()
+        new_reminder = data.get('reminder')
+
+        # Validate the reminder date format
+        try:
+            # Convert string to datetime object to validate format
+            reminder_date = datetime.strptime(new_reminder, '%Y-%m-%d')
+        except ValueError:
+            return jsonify({
+                'error': 'Invalid date format. Please use YYYY-MM-DD format'
+            }), 400
+
+        # Update using the correct column name (Reminder)
+        query = '''
+        UPDATE Task 
+        SET Reminder = %s
+        WHERE TaskID = %s
+        '''
+        cursor = db.get_db().cursor()
+        cursor.execute(query, (reminder_date, task_id))
+        db.get_db().commit()
+
+        return jsonify({
+            'message': 'Task reminder updated successfully',
+            'task_id': task_id,
+            'new_reminder': new_reminder
+        }), 200
+
+    except Exception as e:
+        db.get_db().rollback()
+        return jsonify({'error': str(e)}), 500
+
+
+@advisor.route('/advisor/events', methods=['POST'])
+def create_event():
+    try:
+        data = request.get_json()
+        print("Received data:", data)  # Log the received data
+
+        query = '''
+        INSERT INTO Events (
+            CommunityID,
+            Date,
+            Name,
+            Description
+        ) VALUES (%s, %s, %s, %s)
+        '''
+
+        cursor = db.get_db().cursor()
+        print("Executing query:", query)  # Log the query
+        cursor.execute(query, (
+            data.get('community_id'),
+            data.get('date'),
+            data.get('name'),
+            data.get('description')
+        ))
+        db.get_db().commit()
+        print("Event created successfully")  # Log success
+
+        return jsonify({
+            'message': 'Event created successfully'
+        }), 201
+
+    except Exception as e:
+        print(f"Error creating event: {str(e)}")  # Log the error
+        db.get_db().rollback()
+        return jsonify({'error': str(e)}), 500
+
+@advisor.route('/advisor/events/<event_id>', methods=['PUT'])
+def update_event(event_id):
+    try:
+        data = request.get_json()
+
+        query = '''
+        UPDATE Events 
+        SET CommunityID = %s,
+            Date = %s,
+            Name = %s,
+            Description = %s
+        WHERE EventID = %s
+        '''
+
+        cursor = db.get_db().cursor()
+        cursor.execute(query, (
+            data.get('community_id'),
+            data.get('date'),
+            data.get('name'),
+            data.get('description'),
+            event_id
+        ))
+        db.get_db().commit()
+
+        return jsonify({
+            'message': 'Event updated successfully'
+        }), 200
+
+    except Exception as e:
+        db.get_db().rollback()
+        return jsonify({'error': str(e)}), 500
+
+@advisor.route('/advisor/events/<event_id>', methods=['DELETE'])
+def delete_event(event_id):
+    try:
+        query = '''
+        DELETE FROM Events 
+        WHERE EventID = %s
+        '''
+
+        cursor = db.get_db().cursor()
+        cursor.execute(query, (event_id,))
+        db.get_db().commit()
+
+        return jsonify({
+            'message': 'Event deleted successfully'
+        }), 200
+
+    except Exception as e:
+        db.get_db().rollback()
+        return jsonify({'error': str(e)}), 500
+
+@advisor.route('/advisor/events/<event_id>', methods=['GET'])
+def get_event(event_id):
+    try:
+        query = '''
+        SELECT 
+            EventID,
+            CommunityID,
+            Date,
+            Name,
+            Description
+        FROM Events 
+        WHERE EventID = %s
+        '''
+
+        cursor = db.get_db().cursor()
+        cursor.execute(query, (event_id,))
+        event = cursor.fetchone()
+
+        if event:
+            # Convert the result to a dictionary with proper keys
+            event_dict = {
+                'EventID': event['EventID'],
+                'CommunityID': event['CommunityID'],
+                'Date': event['Date'].strftime('%Y-%m-%d') if event['Date'] else None,
+                'Name': event['Name'],
+                'Description': event['Description']
+            }
+            return jsonify(event_dict), 200
+        else:
+            return jsonify({'error': 'Event not found'}), 404
+
+    except Exception as e:
+        print(f"Error fetching event: {str(e)}")  # Add debugging
+        return jsonify({'error': str(e)}), 500
+
+
+
+