Saumya

api/.env.template

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

api/backend/advisoradvisee/advisoradvisee_routes.py

@@ -0,0 +1,56 @@
+from flask import Blueprint
+from flask import request
+from flask import jsonify
+from flask import make_response
+from flask import current_app
+from backend.db_connection import db
+
+advisoradvisee = Blueprint('advisoradvisee', __name__)
+
+# Advisor identifies students with too few applications
+@advisoradvisee.route('/advisor/<advisorID>/students/low-applications', methods=['GET'])
+def get_students_with_low_applications(advisorID):
+    current_app.logger.info('GET /advisor/<advisorID>/students/low-applications route')
+
+    query = '''
+        SELECT u.userId,
+               u.firstName,
+               u.lastName,
+               COUNT(apps.applicationId) AS totalApps
+        FROM advisor_advisee aa
+                JOIN users u ON u.userId = aa.studentId
+                LEFT JOIN appliesToApp ata ON ata.studentId = u.userId
+                LEFT JOIN applications apps ON ata.applicationId = apps.applicationId
+        WHERE aa.advisorId = {0}
+        GROUP BY u.userId, u.firstName, u.lastName
+        HAVING COUNT(apps.applicationId) < 5
+        ORDER BY totalApps ASC, u.lastName;
+        '''.format(advisorID)
+
+    cursor = db.get_db().cursor()
+    cursor.execute(query)
+    theData = cursor.fetchall()
+
+    the_response = make_response(jsonify(theData))
+    the_response.status_code = 200
+    return the_response
+
+# Admin reassigns students to different advisors as needed
+@advisoradvisee.route('/admin/<studentId>/<advisorId>', 
+                      methods = ['PUT'])
+def reassignAdvisor():
+    current_app.logger.info('PUT /admin/<studentId>/<advisorId> route')
+    advisorId = request.json
+    studentId = request.json
+
+    query = '''
+    UPDATE advisor_advisee
+            SET advisorId = %s
+            WHERE studentId = %s;
+            '''
+    data=(advisorId, studentId)
+    cursor = db.get_db().cursor()
+    r = cursor.execute(query, data)
+    db.get_db().commit()
+    return 'advisor reassigned successfully'
+

api/backend/applications/applications_routes.py

@@ -0,0 +1,256 @@
+from flask import Blueprint
+from flask import request
+from flask import jsonify
+from flask import make_response
+from flask import current_app
+from backend.db_connection import db
+import pymysql
+
+# New Blueprint for applications
+applications = Blueprint('applications', __name__)
+
+
+# Student viewing their own application statuses
+@applications.route('/student/<studentID>/applications', methods=['GET'])
+def get_student_applications(studentID):
+    current_app.logger.info(f'GET /student/{studentID}/applications route')
+
+    query = '''
+        SELECT u.userId,
+               u.firstName,
+               u.lastName,
+               a.applicationId,
+               a.status AS applicationStatus,
+               a.resume,
+               a.coverLetter,
+               a.gpa,
+               cp.title AS positionTitle,
+               cp.deadline AS applicationDeadline,
+               a.dateTimeApplied,
+               cp.description AS positionDescription
+        FROM users u
+        JOIN appliesToApp ata ON u.userId = ata.studentId
+        JOIN applications a ON ata.applicationId = a.applicationId
+        JOIN coopPositions cp ON a.coopPositionId = cp.coopPositionId
+        WHERE u.userId = %s
+        ORDER BY a.dateTimeApplied DESC, cp.deadline ASC
+    '''
+
+    connection = db.get_db()
+
+    cursor = connection.cursor(pymysql.cursors.DictCursor)
+    cursor.execute(query, (studentID,))
+    theData = cursor.fetchall()
+
+    return make_response(jsonify(theData), 200)
+
+# student sees how many positions they have applied to
+@applications.route('/student/<studentID>/applications/summary', methods=['GET'])
+def get_numb_apps(studentID):
+    current_app.logger.info('GET /student/<studentID>/applications route')
+
+    query = '''
+        SELECT a.status, 
+            COUNT(*) AS ApplicationCount
+        FROM applications a
+            JOIN appliesToApp ata ON a.applicationId = ata.applicationId
+        WHERE ata.studentId = %s
+        GROUP BY a.status
+
+    '''
+
+    cursor = db.get_db().cursor()
+    cursor.execute(query, (studentID,))
+    theData = cursor.fetchall()
+
+    the_response = make_response(jsonify(theData))
+    the_response.status_code = 200
+    return the_response
+
+
+
+# Advisor viewing all their advisees' application statuses
+@applications.route('/advisor/<advisorID>/students/applications', methods=['GET'])
+def get_advisor_student_applications(advisorID):
+    current_app.logger.info('GET /advisor/<advisorID>/students/applications route')
+
+    query = '''
+        SELECT aa.advisorId,
+               u.userId,
+               u.firstName,
+               u.lastName,
+               a.applicationId,
+               a.status    AS applicationStatus,
+               cp.title    AS positionTitle,
+               cp.deadline AS applicationDeadline,
+               com.name    AS companyName,
+               a.dateApplied
+        FROM advisor_advisee aa
+                 JOIN users u ON aa.studentId = u.userId
+                 JOIN appliesToApp ata ON u.userId = ata.studentId
+                 JOIN applications a ON ata.applicationId = a.applicationId
+                 JOIN coopPositions cp ON a.coopPositionId = cp.coopPositionId
+                 JOIN companyProfiles com ON cp.companyProfileId = com.companyProfileId
+                 LEFT JOIN workedAtPos wp ON u.userId = wp.studentId AND wp.coopPositionId = cp.coopPositionId
+        WHERE aa.advisorId = {0}
+        ORDER BY u.lastName, u.firstName, a.dateApplied DESC
+    '''.format(advisorID)
+
+    cursor = db.get_db().cursor()
+    cursor.execute(query)
+    theData = cursor.fetchall()
+
+    the_response = make_response(jsonify(theData))
+    the_response.status_code = 200
+    return the_response
+
+# Employer views all applications of a posting
+@applications.route('/applications/<int:coopPositionId>', methods=['GET'])
+def get_applications(coopPositionId):
+    current_app.logger.info('GET /applications/%s', coopPositionId)
+
+    query = '''
+        SELECT a.dateTimeApplied, a.status, a.resume, a.gpa, a.coverLetter,
+               a.coopPositionId, a.applicationId
+        FROM applications a
+        JOIN coopPositions cp ON a.coopPositionId = cp.coopPositionId
+        WHERE a.coopPositionId = %s
+        ORDER BY a.dateTimeApplied DESC;
+    '''
+    cursor = db.get_db().cursor()
+    cursor.execute(query, (coopPositionId,))
+    theData = cursor.fetchall()
+
+    return make_response(jsonify(theData), 200)
+
+# NEW ENDPOINT: Employer views all applications with student details for a specific position
+@applications.route('/applications/<int:coopPositionId>/with-students', methods=['GET'])
+def get_applications_with_students(coopPositionId):
+    current_app.logger.info('GET /applications/%s/with-students', coopPositionId)
+
+    query = '''
+        SELECT a.dateTimeApplied, a.status, a.resume, a.gpa, a.coverLetter,
+               a.coopPositionId, a.applicationId,
+               u.userId as studentId, u.firstName, u.lastName, u.email,
+               u.major, u.minor, u.college, u.gradYear, u.grade
+        FROM applications a
+        JOIN appliesToApp ata ON a.applicationId = ata.applicationId
+        JOIN users u ON ata.studentId = u.userId
+        JOIN coopPositions cp ON a.coopPositionId = cp.coopPositionId
+        WHERE a.coopPositionId = %s
+        ORDER BY a.dateTimeApplied DESC;
+    '''
+    cursor = db.get_db().cursor()
+    cursor.execute(query, (coopPositionId,))
+    theData = cursor.fetchall()
+
+    return make_response(jsonify(theData), 200)
+
+# NEW ENDPOINT: Update application status (for employers)
+@applications.route('/applications/<int:applicationId>/status', methods=['PUT'])
+def update_application_status(applicationId):
+    current_app.logger.info('PUT /applications/%s/status', applicationId)
+
+    try:
+        request_data = request.json
+        new_status = request_data.get('status')
+
+        if not new_status:
+            return make_response(jsonify({"error": "Status is required"}), 400)
+
+        # Validate status values
+        valid_statuses = ['Draft', 'Submitted', 'Under Review', 'Accepted', 'Rejected']
+        if new_status not in valid_statuses:
+            return make_response(jsonify({"error": "Invalid status"}), 400)
+
+        query = '''
+            UPDATE applications
+            SET status = %s
+            WHERE applicationId = %s
+        '''
+
+        cursor = db.get_db().cursor()
+        cursor.execute(query, (new_status, applicationId))
+
+        if cursor.rowcount == 0:
+            return make_response(jsonify({"error": "Application not found"}), 404)
+
+        db.get_db().commit()
+
+        return make_response(jsonify({
+            "success": True,
+            "applicationId": applicationId,
+            "newStatus": new_status
+        }), 200)
+
+    except Exception as e:
+        current_app.logger.error(f"Error updating application status: {e}")
+        return make_response(jsonify({"error": "Internal server error"}), 500)
+
+# NEW ENDPOINT: Get single application details by application ID
+@applications.route('/applications/<int:applicationId>/details', methods=['GET'])
+def get_application_details(applicationId):
+    current_app.logger.info('GET /applications/%s/details', applicationId)
+
+    query = '''
+        SELECT a.applicationId, a.dateTimeApplied, a.status, a.resume, a.gpa, a.coverLetter,
+               a.coopPositionId, cp.title as positionTitle, cp.location, cp.hourlyPay,
+               cp.deadline, cp.industry, cp.description as positionDescription,
+               u.userId as studentId, u.firstName, u.lastName, u.email,
+               u.major, u.minor, u.college, u.gradYear, u.grade
+        FROM applications a
+        JOIN appliesToApp ata ON a.applicationId = ata.applicationId
+        JOIN users u ON ata.studentId = u.userId
+        JOIN coopPositions cp ON a.coopPositionId = cp.coopPositionId
+        WHERE a.applicationId = %s
+    '''
+
+    cursor = db.get_db().cursor()
+    cursor.execute(query, (applicationId,))
+    theData = cursor.fetchall()
+
+    if not theData:
+        return make_response(jsonify({"error": "Application not found"}), 404)
+
+    return make_response(jsonify(theData[0]), 200)
+
+# Student applies to a position
+@applications.route('/applications/new', methods=['POST'])
+def create_application():
+    current_app.logger.info('POST /applications/new')
+
+    data = request.json
+    required_fields = ['coopPositionId', 'studentId']
+
+    if not all(field in data for field in required_fields):
+        current_app.logger.warning('POST /applications/new missing required fields')
+        return make_response(jsonify({"error": "coopPositionId and studentId are required"}), 400)
+
+    try:
+        cursor = db.get_db().cursor()
+
+        # Insert application
+        cursor.execute('''
+            INSERT INTO applications (resume, gpa, coverLetter, coopPositionId)
+            VALUES (%s, %s, %s, %s)
+        ''', (
+            data.get('resume', ''),
+            data.get('gpa'),
+            data.get('coverLetter', ''),
+            data['coopPositionId']
+        ))
+
+        application_id = cursor.lastrowid
+
+        # Link student to application
+        cursor.execute('''
+            INSERT INTO appliesToApp (applicationId, studentId)
+            VALUES (%s, %s)
+        ''', (application_id, data['studentId']))
+
+        db.get_db().commit()
+        return jsonify({"message": "Application submitted", "applicationId": application_id}), 201
+
+    except Exception as e:
+        current_app.logger.error(f"❌ Error creating application: {e}")
+        return jsonify({"error": str(e)}), 500  # Temporarily return full error for debugging

api/backend/companyProfiles/companyProfiles_routes.py

@@ -0,0 +1,42 @@
+from flask import Blueprint
+from flask import request
+from flask import jsonify
+from flask import make_response
+from flask import current_app
+from backend.db_connection import db
+
+companyProfiles = Blueprint('companyProfiles', __name__)
+
+# Student/Advisor views a company profile
+@companyProfiles.route('/companyProfiles/<companyProfileId>', methods=['GET'])
+def get_company_profile(companyProfileId):
+    query = '''
+        SELECT companyProfileId, name, bio, industry, websiteLink
+        FROM companyProfiles
+        WHERE companyProfileId = %s
+    '''
+
+    cursor = db.get_db().cursor()
+    cursor.execute(query, (companyProfileId,))
+    theData = cursor.fetchall()
+
+    the_response = make_response(jsonify(theData))
+    the_response.status_code = 200
+    return the_response
+
+# Advisor views all company profiles
+@companyProfiles.route('/companyProfiles', methods=['GET'])
+def get_all_company_profiles():
+    query = '''
+        SELECT companyProfileId, name, bio, industry, websiteLink
+        FROM companyProfiles
+        ORDER BY name
+    '''
+
+    cursor = db.get_db().cursor()
+    cursor.execute(query)
+    theData = cursor.fetchall()
+
+    the_response = make_response(jsonify(theData))
+    the_response.status_code = 200
+    return the_response