Adding the Manage Members Page

app/controllers/main_routes/__init__.py

@@ -1,19 +1,32 @@
+from datetime import date
 from flask import render_template
 from flask import Blueprint
 from app.login_manager import require_login
 import os
 
 main_bp = Blueprint('main', __name__)
+
+def currentAcademicYear():
+    today = date.today()
+    currentYear = today.year
+
+    if today.month < 7:
+        return currentYear - 1, currentYear
+
+    return currentYear, currentYear + 1
+
 @main_bp.context_processor
 def injectGlobalData():
     currentUser = require_login()
     lastStaticUpdate = str(max(os.path.getmtime(os.path.join(root_path, f))
                    for root_path, dirs, files in os.walk('app/static')
                    for f in files))
     return {'currentUser': currentUser,
-            'lastStaticUpdate': lastStaticUpdate}
+            'lastStaticUpdate': lastStaticUpdate,
+            'currentAcademicYear': currentAcademicYear()}
 
 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 +1,161 @@
-from flask import render_template
+from flask import g, jsonify, redirect, render_template, request, url_for
+
+from app.controllers.main_routes import main_bp
+from app.models.supervisor import Supervisor
+from app.models.supervisorDepartment import SupervisorDepartment
+from app.logic.manageMembers import *
+from app.logic.search import searchPerson
+
+
+@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))
+
+    if not (currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent):
+        return render_template('errors/403.html'), 403
+
+    dept, members = getCurrentDeptMembers(org, account)
+    counts = getStudentCounts(dept)
+    members = attachPositionCounts(members, counts)
+
+    return render_template(
+        'main/manageMembers.html',
+        members=members,
+        department=dept,
+    )
+
+
+
+@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):
+        return render_template('errors/403.html'), 403
+
+    supervisors = (
+        searchPerson(Supervisor, query)
+        .order_by(Supervisor.LAST_NAME.asc())
+        .limit(10)
+    )
+
+    supervisors = list(map(supervisorsDbToDict, supervisors))
+
+    return jsonify(supervisors)
+
+@main_bp.route('/members/update_coordinator', methods=['POST'])
+def updateCoordinator():
+    """
+    Assigns or unassignes a supervisor as a Labor Coordinator. 
+    """
+    currentUser = g.currentUser
+
+    if not (currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent):
+        return render_template('errors/403.html'), 403
+
+    supervisorID = request.form.get("supervisorID")
+    departmentID = request.form.get("departmentID")
+    isCoordinator = request.form.get("isCoordinator") == "true"
+
+    if not supervisorID or not departmentID:
+        return "", 400
+
+    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):
+        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):
+        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
+
+    if not (currentUser.isLaborAdmin or currentUser.isLaborDepartmentStudent):
+        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
+
+    try:
+        supervisorDeptRecord = SupervisorDepartment.get_or_none(supervisor=supervisorID, department=departmentID)
+
+        if supervisorDeptRecord:
+            return "False"
+
+        if not Supervisor.get_or_none(Supervisor.ID == supervisorID):
+            return "", 400
+
+        SupervisorDepartment.create(supervisor=supervisorID, department=departmentID)
+
+        return "True"
+
+    except Exception as e:
+        print(f'Could not add user to department: {e}')
+        return "", 500

app/controllers/main_routes/main_routes.py

@@ -54,40 +54,31 @@ def supervisorPortal():
 @main_bp.route('/department/<org>', methods=['GET'])
 @main_bp.route('/department/<org>/<account>', methods=['GET'])
 def departmentPortal(org=None,account=None):
-    try:
-        dept = Department.get(Department.ORG == org, Department.ACCOUNT == account)
-    except (NameError, DoesNotExist):
+    currentUser = g.currentUser
+    if org and account:
+        try:
+            dept = Department.get(Department.ORG == org, Department.ACCOUNT == account)
+        except (NameError, DoesNotExist):
+            dept = None
+    else:
         dept = None
+
 
 
-    if g.currentUser.isLaborAdmin:
+    if currentUser.isLaborAdmin:
         departments = list(Department.select().order_by(Department.isActive.desc(), Department.DEPT_NAME.asc()))
     else:
-        departments = list(getDepartmentsForSupervisor(g.currentUser).order_by(Department.isActive.desc(), Department.DEPT_NAME.asc()))
+        departments = list(getDepartmentsForSupervisor(currentUser).order_by(Department.isActive.desc(), Department.DEPT_NAME.asc()))
 
     positionsList, posURL = getActivePositions(dept)
 
     return render_template('main/departmentPortal.html', 
                            departments = departments,
                            department = dept,
+                           currentUser=currentUser,
                            positions = positionsList,
                            posURL = posURL)
 
-@main_bp.route('/supervisorPortal/addUserToDept', methods=['GET', 'POST'])
-def addUserToDept():
-    userDeptData = request.form
-    supervisorDeptRecord = SupervisorDepartment.get_or_none(supervisor = userDeptData['supervisorID'], department = userDeptData['departmentID'])
-    try:
-        if supervisorDeptRecord:
-            return "False"
-
-        else:
-            SupervisorDepartment.create(supervisor=userDeptData['supervisorID'], department=userDeptData['departmentID'])
-            return "True"
-
-    except Exception as e:
-        print(f'Could not add user to department: {e}')
-        return "", 500
 
 @main_bp.route('/supervisorPortal/download', methods=['POST'])
 def downloadSupervisorPortalResults():

app/logic/manageMembers.py

@@ -0,0 +1,115 @@
+from datetime import date
+
+from flask import abort
+from peewee import Case, DoesNotExist, fn
+
+from app.logic.search import usernameFromEmail
+from app.models.department import Department
+from app.models.formHistory import FormHistory
+from app.models.laborReleaseForm import LaborReleaseForm
+from app.models.laborStatusForm import LaborStatusForm
+from app.models.supervisor import Supervisor
+from app.models.supervisorDepartment import SupervisorDepartment
+
+
+def supervisorsDbToDict(supervisor):
+    """
+    Given a supervisor object it will return a mapped Dict with supervisor data.
+    """
+    dbToDict = {
+        'username': usernameFromEmail(supervisor.EMAIL.strip()),
+        'firstName': supervisor.FIRST_NAME.strip(),
+        'lastName': supervisor.LAST_NAME.strip(),
+        'bnumber': supervisor.ID.strip(),
+        'department': supervisor.DEPT_NAME.strip(),
+        'type': 'Supervisor'
+    }
+    return dbToDict
+
+
+def getCurrentDeptMembers(org, account):
+    """Return the current department and its supervisor-department rows."""
+    try:
+        dept = Department.get(Department.ORG == org, Department.ACCOUNT == account)
+    except (NameError, DoesNotExist):
+        abort(404)
+
+    members = list(
+        SupervisorDepartment
+        .select(SupervisorDepartment, Supervisor)
+        .join(Supervisor)
+        .where(SupervisorDepartment.department == dept)
+    )
+
+    return dept, members
+
+
+def getStudentCounts(dept):
+    """Active/pending primary/secondary position counts, keyed by (dept, supervisor)."""
+    today = date.today()
+
+    releasedFormIds = (
+        FormHistory
+        .select(FormHistory.formID)
+        .join(LaborReleaseForm)
+        .where(
+            (FormHistory.historyType == "Labor Release Form") &
+            (FormHistory.status == "Approved") &
+            (LaborReleaseForm.releaseDate <= today)
+        )
+    )
+
+    activePrimaries = (
+        (LaborStatusForm.jobType == 'Primary') &
+        (LaborStatusForm.studentConfirmation == True)
+    )
+    pendingPrimaries = (
+        (LaborStatusForm.jobType == 'Primary') &
+        (LaborStatusForm.studentConfirmation.is_null(True))
+    )
+    activeSecondaries = (
+        (LaborStatusForm.jobType == 'Secondary') &
+        (LaborStatusForm.studentConfirmation == True)
+    )
+    pendingSecondaries = (
+        (LaborStatusForm.jobType == 'Secondary') &
+        (LaborStatusForm.studentConfirmation.is_null(True))
+    )
+
+    rows = list(
+        LaborStatusForm
+        .select(
+            fn.SUM(Case(None, ((activePrimaries, 1),), 0)).alias("active_primary_positions"),
+            fn.SUM(Case(None, ((pendingPrimaries, 1),), 0)).alias("pending_primary_positions"),
+            fn.SUM(Case(None, ((activeSecondaries, 1),), 0)).alias("active_secondary_positions"),
+            fn.SUM(Case(None, ((pendingSecondaries, 1),), 0)).alias("pending_secondary_positions"),
+            LaborStatusForm.department,
+            LaborStatusForm.supervisor
+        )
+        .where(
+            (LaborStatusForm.department == dept) &
+            (LaborStatusForm.laborStatusFormID.not_in(releasedFormIds))
+        )
+        .group_by(LaborStatusForm.department, LaborStatusForm.supervisor)
+        .dicts()
+    )
+
+    return {(row["department"], row["supervisor"]): row for row in rows}
+
+
+def attachPositionCounts(members, counts):
+    """Attach position counts to each supervisor-department row."""
+    fields = [
+        "active_primary_positions",
+        "pending_primary_positions",
+        "active_secondary_positions",
+        "pending_secondary_positions",
+    ]
+
+    for member in members:
+        row = counts.get((member.department_id, member.supervisor_id), {})
+
+        for field in fields:
+            setattr(member, field, row.get(field, 0))
+
+    return members