Adding the Manage Members Page

app/__init__.py

@@ -1,9 +1,9 @@
 import os
-
-from flask import Flask
-from flask_restful import Api
+from datetime import date
+from flask import Flask, g, request, session
 from flask_bootstrap import Bootstrap
-from playhouse.shortcuts import model_to_dict, dict_to_model
+from flask_restful import Api
+from playhouse.shortcuts import dict_to_model, model_to_dict
 
 
 app = Flask(__name__)
@@ -55,17 +55,27 @@ def new_execute(*args, **kwargs):
 from app.controllers.api_routes.routes import initializeApiRoutes
 initializeApiRoutes(api)
 
-from flask import g
 from app.models.user import User
-from app.login_manager import require_login
+from app.login_manager import getUsernameFromEnv, require_login
 @app.before_request
 def load_user():
-    try: 
-        g.currentUser = dict_to_model(User, session['currentUser'])
+    requestUsername = getUsernameFromEnv(request.environ)
+    try:
+        cachedUser = session['currentUser']
+
+        if cachedUser.get('username') == requestUsername:
+            g.currentUser = dict_to_model(User, cachedUser)
+            return
+
+        session.pop('currentUser', None)
+        session.pop('username', None)
+
     except Exception as e:
-        user = require_login()
-        session['currentUser'] = model_to_dict(user)
-        g.currentUser = user
+        pass
+
+    user = require_login()
+    session['currentUser'] = model_to_dict(user)
+    g.currentUser = user
 
 from app.models.term import Term
 from app.login_manager import getOpenTerm
@@ -79,6 +89,20 @@ def load_openTerm():
             session['openTerm'] = model_to_dict(term)
         g.openTerm = term
 
+def getCurrentYear():
+    today = date.today()
+    year = today.year
+
+    if today.month < 7:
+        return year - 1, year
+
+    return year, year + 1
+
+@app.before_request
+def load_currentYear():
+    g.currentYear = getCurrentYear()
+
+
 @app.context_processor
 def inject_environment():
     return dict(env=app.config['ENV'])

app/controllers/main_routes/__init__.py

@@ -14,6 +14,7 @@ def injectGlobalData():
             'lastStaticUpdate': lastStaticUpdate}
 
 from app.controllers.main_routes import main_routes
+from app.controllers.main_routes import departmentPortal
 from app.controllers.main_routes import laborStatusForm
 from app.controllers.main_routes import laborHistory
 from app.controllers.main_routes import alterLSF

app/controllers/main_routes/departmentPortal.py

@@ -1,10 +1,44 @@
-from flask import render_template, g
+from flask import abort, g, jsonify, redirect, render_template, request, url_for
+from peewee import DoesNotExist
+
 from app.controllers.main_routes import main_bp
 from app.logic.getPositions import getPositions
-from peewee import DoesNotExist
+from app.logic.getSupervisors import buildSupervisorDisplay, getSupervisorDepartments
+from app.logic.manageMembers import attachPositionCounts, getActivePendingPositionCounts  
+from app.logic.search import searchPerson
 from app.models.department import Department
+from app.models.supervisor import Supervisor
 from app.models.supervisorDepartment import SupervisorDepartment
 
+
+@main_bp.route('/department/<org>/<account>/members', methods=['GET'])
+def manageMembers(org=None, account=None):
+    """Generates the Manage Members page."""
+    currentUser = g.currentUser
+
+    if not currentUser.supervisor:
+        return redirect(url_for('main.laborhistory', id=currentUser.student.ID))
+
+    dept = Department.get_or_none(Department.ORG == org, Department.ACCOUNT == account)
+
+    if not dept:
+        abort(404)
+
+    departmentMembers = getSupervisorDepartments(dept)
+    supervisorDeptRecord = SupervisorDepartment.get_or_none(supervisor=currentUser.supervisor, department=dept)
+
+    if not ( currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent or supervisorDeptRecord):
+        return render_template('errors/403.html'), 403
+
+    activePendingPositionCounts = getActivePendingPositionCounts(dept, g.currentYear)
+    departmentMembers = attachPositionCounts(departmentMembers, activePendingPositionCounts)
+
+    return render_template(
+        'main/manageMembers.html',
+        members=departmentMembers,
+        department=dept,
+    )
+
 @main_bp.route('/department/<org>/<account>/positions', methods=['GET'])
 def managePositions(org, account):
     try:
@@ -22,7 +56,135 @@ def managePositions(org, account):
     positions = getPositions(dept)
 
     return render_template('main/managePositions.html',
-                           department = dept,
-                           department_name = dept.DEPT_NAME,
-                           positions = positions
+                           department=dept,
+                           department_name=dept.DEPT_NAME,
+                           positions=positions
                            )
+
+
+@main_bp.route('/members/search/<query>', methods=['GET'])
+def searchMember(query=None):
+    """Search supervisors by name or B-number."""
+    currentUser = g.currentUser
+
+    if not (currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent or currentUser.supervisor ):
+        return render_template('errors/403.html'), 403
+
+    supervisors = (
+        searchPerson(Supervisor, query)
+        .order_by(Supervisor.LAST_NAME.asc())
+        .limit(10)
+    )
+
+    supervisors = [buildSupervisorDisplay(supervisor) for supervisor in supervisors]
+    supervisors = [supervisor for supervisor in supervisors if supervisor is not None]
+
+    return jsonify(supervisors)
+
+
+@main_bp.route('/members/update_coordinator', methods=['POST'])
+def updateCoordinator():
+    """Assigns or unassigns a supervisor as a Labor Coordinator."""
+    currentUser = g.currentUser
+
+    supervisorID = request.form.get("supervisorID")
+    departmentID = request.form.get("departmentID")
+    isCoordinator = request.form.get("isCoordinator") == "true"
+
+    if not supervisorID or not departmentID:
+        return "", 400
+
+    supervisorDeptRecord = None
+
+    if currentUser.supervisor:
+        supervisorDeptRecord = SupervisorDepartment.get_or_none( (SupervisorDepartment.supervisor == currentUser.supervisor) & (SupervisorDepartment.department == departmentID))
+
+    if not (currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent or supervisorDeptRecord ):
+        return render_template('errors/403.html'), 403
+
+    member = SupervisorDepartment.get((SupervisorDepartment.supervisor == supervisorID) & (SupervisorDepartment.department == departmentID))
+
+    member.isCoordinator = isCoordinator
+    member.save()
+
+    return "", 200
+
+
+@main_bp.route('/members/update_eligibility', methods=['POST'])
+def updateEligibility():
+    """Updates a supervisor's eligibility status."""
+    currentUser = g.currentUser
+
+    if not ( currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent or currentUser.supervisor):
+        return render_template('errors/403.html'), 403
+
+    supervisorID = request.form.get("supervisorID")
+
+    if not supervisorID:
+        return "", 400
+
+    member = Supervisor.get(Supervisor.ID == supervisorID)
+    member.isBanned = not member.isBanned
+    member.save()
+
+    return "", 200
+
+
+@main_bp.route('/members/remove', methods=['DELETE'])
+def removeMember():
+    """Removes a staff member from a department."""
+    currentUser = g.currentUser
+
+    if not ( currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent or currentUser.supervisor):
+        return render_template('errors/403.html'), 403
+
+    supervisorID = request.form.get("supervisorID")
+    departmentID = request.form.get("departmentID")
+
+    if not supervisorID or not departmentID:
+        return "", 400
+
+    member = SupervisorDepartment.get((SupervisorDepartment.supervisor == supervisorID) & (SupervisorDepartment.department == departmentID))
+
+    member.delete_instance()
+
+    return "", 200
+
+
+@main_bp.route('/members/add', methods=['POST'])
+def addUserToDept():
+    """Adds a user to a department."""
+    currentUser = g.currentUser
+    supervisorID = request.form.get("supervisorID")
+    departmentID = request.form.get("departmentID")
+
+    if not supervisorID or not departmentID:
+        return jsonify(success=False, message="Missing supervisor or department."), 400
+
+    if not (currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent or currentUser.supervisor):
+        return render_template('errors/403.html'), 403
+
+    try:
+        supervisor = Supervisor.get_or_none(Supervisor.ID == supervisorID)
+
+        if not supervisor:
+            return jsonify(success=False, message="Supervisor not found."), 404
+
+        supervisorDeptRecord = SupervisorDepartment.get_or_none( supervisor=supervisor, department=departmentID )
+
+        if supervisorDeptRecord:
+            return jsonify(
+                success=False,
+                message="Supervisor already exists in this department."
+            ), 200
+
+        SupervisorDepartment.create( supervisor=supervisor, department=departmentID)
+
+        return jsonify(success=True, message="Supervisor added to department."), 200
+
+    except Exception as e:
+        print(f'Could not add user to department: {e}')
+        return jsonify(
+            success=False,
+            message="Could not add supervisor to department."
+        ), 500

app/controllers/main_routes/main_routes.py

@@ -59,10 +59,14 @@ def supervisorPortal():
 @main_bp.route('/department/<org>/<account>', methods=['GET'])
 def departmentPortal(org=None,account=None):
     currentUser = g.currentUser
-    try:
-        dept = Department.get(Department.ORG == org, Department.ACCOUNT == account)
-    except (NameError, DoesNotExist):
+    if org and account:
+        try:
+            dept = Department.get(Department.ORG == org, Department.ACCOUNT == account)
+        except (NameError, DoesNotExist):
+            dept = None
+    else:
         dept = None
+
 
     if currentUser.isLaborAdmin:
         departments = list(Department.select().order_by(Department.isActive.desc(), Department.DEPT_NAME.asc()))

app/logic/getSupervisors.py

@@ -1,43 +1,65 @@
+from app.logic.search import usernameFromEmail
 from app.models.supervisor import Supervisor
 from app.models.supervisorDepartment import SupervisorDepartment
-from peewee import fn
-
 
 
 def buildSupervisorDisplay(supervisor):
-    try:
-        firstName = supervisor.FIRST_NAME 
-        lastName = supervisor.LAST_NAME
-        if not (firstName and lastName):
-            raise NameError("First name and last name are required")
+    """Build supervisor data used by portal displays and search results."""
+    firstName = (
+        supervisor.preferred_name or
+        supervisor.legal_name or
+        ""
+    ).strip()
+    lastName = (supervisor.LAST_NAME or "").strip()
+    email = supervisor.EMAIL.strip() if supervisor.EMAIL else None
 
-    except NameError as e:
+    if not firstName or not lastName:
         return None
 
     return {
-        "name": f"{firstName} {lastName}".strip(),
-        "email": supervisor.EMAIL
+        "name": f"{firstName} {lastName}",
+        "email": email,
+        "username": usernameFromEmail(email) if email else None,
+        "firstName": firstName,
+        "lastName": lastName,
+        "bnumber": supervisor.ID.strip(),
+        "department": (supervisor.DEPT_NAME or "").strip(),
+        "type": "Supervisor"
     }
-def getSupervisors(dept):    
+
+
+def getSupervisorDepartments(dept):
+    """Return supervisor-department records for a department."""
+    if dept is None:
+        return []
+
+    return list(
+        SupervisorDepartment
+        .select(SupervisorDepartment, Supervisor)
+        .join(Supervisor)
+        .where(SupervisorDepartment.department == dept)
+        .order_by(Supervisor.LAST_NAME.asc())
+    )
+
+
+def getSupervisors(dept):
     laborCoordinators = []
     supervisors = []
-
-    # Avoid querying department members unless the selected department exists.
-    if dept is not None:
-        supervisorDepartments = (SupervisorDepartment.select().join(Supervisor).where(SupervisorDepartment.department == dept)
-            .order_by(Supervisor.LAST_NAME.asc()))
-        for supervisorDepartment in supervisorDepartments:
-            supervisor = supervisorDepartment.supervisor
-            if supervisor is None:
-                continue
-
-            supervisorDisplay = buildSupervisorDisplay(supervisor)
-            if not supervisorDisplay:
-                continue
-
-            if supervisorDepartment.isCoordinator:
-                laborCoordinators.append(supervisorDisplay)
-            else:
-                supervisors.append(supervisorDisplay)
+
+    for supervisorDepartment in getSupervisorDepartments(dept):
+        supervisor = supervisorDepartment.supervisor
+
+        if supervisor is None:
+            continue
+
+        supervisorDisplay = buildSupervisorDisplay(supervisor)
+
+        if not supervisorDisplay:
+            continue
+
+        if supervisorDepartment.isCoordinator:
+            laborCoordinators.append(supervisorDisplay)
+        else:
+            supervisors.append(supervisorDisplay)
 
     return supervisors, laborCoordinators