Ana antic

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,165 @@
+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(dictionary=True)
+    cursor.execute(query, (coopPositionId,))
+    theData = cursor.fetchall()
+
+    return make_response(jsonify(theData), 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,134 @@
+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 *
+        FROM companyProfiles
+        WHERE companyProfileId = %s
+    '''.format(companyProfileId)
+
+    cursor = db.get_db().cursor()
+    cursor.execute(query)
+    columns = [col[0] for col in cursor.description]
+    theData = [dict(zip(columns, row)) for row in 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)
+    columns = [col[0] for col in cursor.description]
+    theData = [dict(zip(columns, row)) for row in cursor.fetchall()]
+
+    the_response = make_response(jsonify(theData))
+    the_response.status_code = 200
+    return the_response
+
+# Advisor views all company profiles sorted by their rating
+@companyProfiles.route('/companyProfiles/rating', methods=['GET'])
+def get_company_profiles_by_rating():
+    query = '''
+            SELECT com.name AS companyName,
+                   com.industry AS companyIndustry,
+                   com.websiteLink AS companyWebsite,
+                   AVG(wp.companyRating) AS avgCompanyRating,
+                   COUNT(wp.companyRating) AS ratingCount
+            FROM workedAtPos wp
+            JOIN coopPositions cp ON wp.coopPositionId = cp.coopPositionId
+            JOIN createsPos cr ON cp.coopPositionId = cr.coopPositionId
+            JOIN users u ON cr.employerId = u.userId
+            JOIN companyProfiles com ON u.companyProfileId = com.companyProfileId
+            WHERE wp.companyRating IS NOT NULL
+            GROUP BY com.name, com.industry, com.websiteLink
+            HAVING COUNT(wp.companyRating) > 0
+            ORDER BY avgCompanyRating DESC;
+    '''    
+
+    #  SELECT com.name AS companyName,
+    #        AVG(wp.companyRating) AS avgCompanyRating
+    # FROM workedAtPos wp
+    # JOIN coopPositions cp ON wp.coopPositionId = cp.coopPositionId
+    # JOIN createsPos cr ON cp.coopPositionId = cr.coopPositionId
+    # JOIN users u ON cr.employerId = u.userId
+    # JOIN companyProfiles com ON u.companyProfileId = com.companyProfileId
+    # GROUP BY com.name
+    # ORDER BY avgCompanyRating DESC;
+
+    cursor = db.get_db().cursor()
+    cursor.execute(query)
+    columns = [col[0] for col in cursor.description]
+    theData = [dict(zip(columns, row)) for row in cursor.fetchall()]
+    the_response = make_response(jsonify(theData))
+    the_response.status_code = 200
+    return the_response
+
+# Employer creates a company profile
+@companyProfiles.route('/companyProfiles/create/<companyProfileId>', methods=['POST'])
+def createCompanyProfile(companyProfileId):
+
+    the_data = request.json
+    current_app.logger.info(the_data)
+
+    name = the_data['company_name']
+    bio = the_data['company_bio']
+    industry = the_data['company_industry']
+    websiteLink = the_data['website_link']
+
+    query = f'''
+    INSERT INTO companyProfiles (name, bio, industry, websiteLink)
+    VALUE( '{name}', '{bio}', '{industry}', '{websiteLink}')
+    '''
+
+    current_app.logger.info(query)
+    cursor = db.get_db().cursor()
+    cursor.execute(query)
+    db.get_db().commit()
+
+    response = make_response("Created company profile")
+    response.status_code = 200
+    return response
+
+# Employer updates/edits company information
+@companyProfiles.route('/companyProfiles/update/<companyProfileId>', methods=['PUT'])
+def updateCompanyProfile(companyProfileId):
+    current_app.logger.info('PUT /companyProfiles/update/<companyProfileId> route')
+
+    company_info = request.json
+    companyId = company_info['id']
+    companyName = company_info['name']
+    companyBio = company_info['bio']
+    companyIndustry = company_info['industry']
+    companyWebsite = company_info['website_link']
+
+    query = '''
+        UPDATE companyProfiles
+        SET name = %s,
+            bio = %s,
+            industry = %s,
+            websiteLink = %s
+        WHERE companyProfileId = %s
+    '''
+    data = (companyName, companyBio, companyIndustry, companyWebsite, companyId)
+    cursor = db.get_db().cursor()
+    r = cursor.execute(query, data)
+    db.get_db().commit()
+    return 'Updated company profile!'