Add over-allocation warning on labor status form (#615)

app/controllers/main_routes/departmentPortal.py

@@ -0,0 +1 @@
+from flask import render_template

app/controllers/main_routes/laborStatusForm.py

@@ -14,14 +14,15 @@
 from flask import json, jsonify
 from flask import request
 from datetime import datetime, date, timedelta
-from flask import Flask, redirect, url_for, flash
+from flask import Flask, redirect, url_for, flash, g
 from app.logic.emailHandler import*
 from app.logic.userInsertFunctions import*
 from app.models.supervisor import Supervisor
 from app.logic.tracy import Tracy
 from app.controllers.main_routes.laborReleaseForm import createLaborReleaseForm
 from app.logic.allPendingForms import saveStatus
 from app.logic.statusFormFunctions import *
+from app.logic.allocation import getBandAllocationStatus
 
 
 @main_bp.route('/laborstatusform', methods=['GET'])
@@ -170,6 +171,15 @@ def checkTotalHours(termCode, student, hours):
     totalHours = totalHours + int(hours)
     return json.dumps(totalHours)
 
+@main_bp.route("/laborstatusform/checkallocation/<departmentOrg>/<departmentAcct>/<jobType>/<hours>", methods=["GET"])
+def checkAllocation(departmentOrg, departmentAcct, jobType, hours):
+    """ Checks the department's allocation status for the hour-band being submitted. """
+    dept = Department.get_or_none(Department.ORG == departmentOrg, Department.ACCOUNT == departmentAcct)
+    if not dept:
+        return jsonify(None)
+    status = getBandAllocationStatus(dept, g.openTerm, jobType, int(hours))
+    return jsonify(status)
+
 @main_bp.route("/laborStatusForm/modal/releaseAndRehire", methods=['POST'])
 def releaseAndRehire():
     try:

app/controllers/main_routes/main_routes.py

@@ -1,21 +1,21 @@
 from flask import render_template, request, json, redirect, url_for, send_file, g, flash, jsonify
-from peewee import JOIN
+from peewee import JOIN, DoesNotExist
 from functools import reduce
 import operator
 from app.models.department import Department
 from app.models.supervisor import Supervisor
 from app.models.supervisorDepartment import SupervisorDepartment
 from app.models.student import Student
-from app.models.laborStatusForm import LaborStatusForm
 from app.models.formHistory import FormHistory
-from app.models.term import Term
 from app.controllers.admin_routes.allPendingForms import checkAdjustment
 from app.controllers.main_routes import main_bp
 from app.logic.download import CSVMaker, saveFormSearchResult, retrieveFormSearchResult
 from app.logic.search import getDepartmentsForSupervisor, searchPerson, searchSupervisorPortal
 from app.login_manager import require_login, logout
 from app.logic.getTableData import getDatatableData
 from app.logic.banner import Banner
+from app.logic.tracy import Tracy
+from app.logic.allocation import getAllocationSummary
 
 @main_bp.route('/logout', methods=['GET'])
 def triggerLogout():
@@ -47,6 +47,67 @@ def supervisorPortal():
                             currentUser = currentUser
                             )
 
+@main_bp.route('/department', methods=['GET'])
+@main_bp.route('/department/<org>', methods=['GET'])
+@main_bp.route('/department/<org>/<account>', methods=['GET'])
+def departmentPortal(org=None,account=None):
+    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:
+        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()))
+
+    pos = Tracy().getPositionsFromDepartment(org, account)
+    positions = []
+    if pos == []:
+        positions = ["No Positions for this Department"]
+    else:
+        for i in pos:
+            positions.append(i.POSN_TITLE + "" + "(" + i.WLS + ")")
+
+    staff = Tracy().getSupervisors()
+    supervisors = []
+
+    for i in staff:
+        if i.ORG == org:
+            supervisors.append(i.FIRST_NAME + " " + i.LAST_NAME + " (" + i.EMAIL + ")")
+
+    allocationSummary = getAllocationSummary(dept, g.openTerm)
+
+    return render_template('main/departmentPortal.html',
+                           departments = departments,
+                           department = dept,
+                           positions = positions,
+                           supervisors = supervisors,
+                           allocation = allocationSummary['allocation'],
+                           allocationBands = allocationSummary['allocationBands'],
+                           totalPositionsAllocated = allocationSummary['totalPositionsAllocated'],
+                           totalPositionsUsed = allocationSummary['totalPositionsUsed'],
+                           breakHoursUsed = allocationSummary['breakHoursUsed'],
+                           currentTerm = g.openTerm)
+
+@main_bp.route('/department/<org>/<account>/managepositions', methods=['GET'])
+def managePositions(org, account):
+    try:
+        dept = Department.get(Department.ORG == org, Department.ACCOUNT == account)
+    except DoesNotExist:
+        return render_template('errors/404.html'), 404
+
+    positions = Tracy().getPositionsFromDepartment(org, account)
+    print(positions)
+    return render_template('main/managepositions.html',
+                           department = dept,
+                           department_name = dept.DEPT_NAME,
+                           positions = positions
+                           )
+
 @main_bp.route('/supervisorPortal/addUserToDept', methods=['GET', 'POST'])
 def addUserToDept():
     userDeptData = request.form
@@ -113,4 +174,5 @@ def submitToBanner(formHistoryId):
     if save_form_status:
         return "Form successfully submitted to Banner.", 200
     else:
-        return "Submitting to Banner failed.", 500
+        return "Submitting to Banner failed.", 500
+

app/logic/allPendingForms.py

@@ -1,6 +1,6 @@
 import json
 from datetime import date
-from flask import jsonify
+from flask import jsonify, g, flash
 from app.models.formHistory import FormHistory
 from app.models.status import Status
 from app.logic.banner import Banner
@@ -14,9 +14,11 @@
 from app.models.overloadForm import OverloadForm
 from app.models.notes import Notes
 from app.login_manager import DoesNotExist, render_template
+from app.logic.allocation import getAllocationWarning
 
 
 def saveStatus(new_status, formHistoryIds, currentUser):
+    approvedDepartments = {}
     try:
         if new_status == 'Denied by Admin':
             # Index 1 will always hold the reject reason in the list, so we can
@@ -66,6 +68,8 @@ def saveStatus(new_status, formHistoryIds, currentUser):
                     email.laborStatusFormRejected()
                 if new_status == "Approved" and formType == "Labor Status Form":
                     email.laborStatusFormApproved()
+                    dept = formHistory.formID.department
+                    approvedDepartments[dept.departmentID] = dept
                 if new_status == "Approved" and formType == "Labor Adjustment Form":
                     # This function is triggered whenever an adjustment form is approved.
                     # The following function overrides the original data in lsf with the new data from adjustment form.
@@ -80,6 +84,16 @@ def saveStatus(new_status, formHistoryIds, currentUser):
         print("Error preparing form for status update:", e)
         return jsonify({"success": False}), 500
 
+    # After approving, let the admin know right away if any affected department
+    # is now over its allocated positions or break hours (informational only).
+    for dept in approvedDepartments.values():
+        warning = getAllocationWarning(dept, g.openTerm)
+        if warning and warning['isOverAllocated']:
+            messageParts = [f"{b['label']} ({b['used']}/{b['allocated']})" for b in warning['overAllocatedBands']]
+            if warning['isBreakHoursOverAllocated']:
+                messageParts.append(f"break hours ({warning['breakHoursUsed']}/{warning['breakHoursAllocated']})")
+            flash(f"{dept.DEPT_NAME} is now over its allocation for: {', '.join(messageParts)}.", "warning")
+
     return jsonify({"success": True})
 
 def overrideOriginalStatusFormOnAdjustmentFormApproval(form, LSF):
@@ -196,9 +210,8 @@ def laborAdminOverloadApproval(rsp, historyForm, status, currentUser, currentDat
 
 # extract data from the database to populate pending form approval modal
 def modal_approval_and_denial_data(formHistoryIdList):
-    ''' This method grabs the data that populated the on approve modal for lsf'''
-
     details_list = []
+    allocationWarningsByDept = {}
     for fhID in formHistoryIdList:
         formHistory = FormHistory.get(FormHistory.formHistoryID == fhID)
         lsf = formHistory.formID
@@ -208,7 +221,8 @@ def modal_approval_and_denial_data(formHistoryIdList):
         supervisorName = f"{lsf.supervisor.FIRST_NAME} {lsf.supervisor.LAST_NAME}"
         weeklyHours = lsf.weeklyHours
         contractHours = lsf.contractHours
-        deptName = lsf.department.DEPT_NAME
+        dept = lsf.department
+        deptName = dept.DEPT_NAME
 
         if formHistory.adjustedForm:
             match formHistory.adjustedForm.fieldAdjusted:
@@ -223,11 +237,17 @@ def modal_approval_and_denial_data(formHistoryIdList):
                 case "contractHours":
                     contractHours = formHistory.adjustedForm.newValue
                 case "department":
-                    deptName = Department.get(Department.ORG==formHistory.adjustedForm.newValue).DEPT_NAME
+                    dept = Department.get(Department.ORG==formHistory.adjustedForm.newValue)
+                    deptName = dept.DEPT_NAME
 
         details_list.append([studentName, deptName, position, str(weeklyHours),str(contractHours), supervisorName])
 
-    return details_list
+        if dept.departmentID not in allocationWarningsByDept:
+            warning = getAllocationWarning(dept, g.openTerm)
+            if warning:
+                allocationWarningsByDept[dept.departmentID] = warning
+
+    return {"details": details_list, "allocationWarnings": list(allocationWarningsByDept.values())}
 
 
 def financialAidSAASOverloadApproval(historyForm, rsp, status, currentUser, currentDate):

app/logic/allocation.py

@@ -0,0 +1,123 @@
+from peewee import fn
+from app.models.allocation import Allocation
+from app.models.laborStatusForm import LaborStatusForm
+from app.models.formHistory import FormHistory
+from app.models.term import Term
+
+# Each entry is (Allocation field name, LaborStatusForm.jobType, LaborStatusForm.weeklyHours)
+ALLOCATION_BAND_FIELDS = [
+    ('primary_10', 'Primary', 10),
+    ('primary_12', 'Primary', 12),
+    ('primary_15', 'Primary', 15),
+    ('primary_20', 'Primary', 20),
+    ('secondary_5', 'Secondary', 5),
+    ('secondary_10', 'Secondary', 10),
+]
+
+BAND_LABELS = {fieldName: f"{hours} Hour {jobType}" for fieldName, jobType, hours in ALLOCATION_BAND_FIELDS}
+
+
+def getAllocationSummary(dept, term):
+    summary = {
+        'allocation': None,
+        'allocationBands': None,
+        'totalPositionsAllocated': None,
+        'totalPositionsUsed': None,
+        'breakHoursUsed': None,
+    }
+
+    if not (dept and term):
+        return summary
+
+    allocation = Allocation.get_or_none(Allocation.department == dept, Allocation.termCode == term)
+    summary['allocation'] = allocation
+    if not allocation:
+        return summary
+
+    allocationBands = {}
+    for fieldName, jobType, hours in ALLOCATION_BAND_FIELDS:
+        used = (LaborStatusForm
+                .select()
+                .join(FormHistory, on=(FormHistory.formID == LaborStatusForm.laborStatusFormID))
+                .where(LaborStatusForm.department == dept,
+                       LaborStatusForm.termCode == term,
+                       LaborStatusForm.jobType == jobType,
+                       LaborStatusForm.weeklyHours == hours,
+                       FormHistory.historyType == "Labor Status Form",
+                       ~(FormHistory.status % "Denied%"))
+                .distinct()
+                .count())
+        allocationBands[fieldName] = {'used': used, 'allocated': getattr(allocation, fieldName)}
+
+    summary['allocationBands'] = allocationBands
+    summary['totalPositionsAllocated'] = sum(band['allocated'] for band in allocationBands.values())
+    summary['totalPositionsUsed'] = sum(band['used'] for band in allocationBands.values())
+
+    # Break hours are tracked on separate break-term rows (e.g. Thanksgiving Break)
+    # that share the same academic year prefix as the given AY term.
+    yearPrefix = str(term.termCode)[:-2]
+    breakTermCodes = [t.termCode for t in Term.select().where(Term.isBreak == True)
+                      if str(t.termCode).startswith(yearPrefix)]
+    summary['breakHoursUsed'] = (LaborStatusForm
+                                 .select(fn.SUM(LaborStatusForm.contractHours))
+                                 .join(FormHistory, on=(FormHistory.formID == LaborStatusForm.laborStatusFormID))
+                                 .where(LaborStatusForm.department == dept,
+                                        LaborStatusForm.termCode.in_(breakTermCodes),
+                                        FormHistory.historyType == "Labor Status Form",
+                                        ~(FormHistory.status % "Denied%"))
+                                 .scalar()) or 0
+
+    return summary
+
+
+def getBandAllocationStatus(dept, term, jobType, hours):
+    fieldName = next((f for f, j, h in ALLOCATION_BAND_FIELDS if j == jobType and h == hours), None)
+    if not fieldName:
+        return None
+
+    summary = getAllocationSummary(dept, term)
+    if not summary['allocationBands']:
+        return None
+
+    band = summary['allocationBands'][fieldName]
+    return {
+        'label': BAND_LABELS[fieldName],
+        'used': band['used'],
+        'allocated': band['allocated'],
+        'remaining': band['allocated'] - band['used'],
+        'isOverAllocated': band['used'] > band['allocated'],
+    }
+
+
+def getAllocationWarning(dept, term):
+    summary = getAllocationSummary(dept, term)
+    if not summary['allocation']:
+        return None
+
+    positionsRemaining = summary['totalPositionsAllocated'] - summary['totalPositionsUsed']
+    breakHoursRemaining = summary['allocation'].breakHours - summary['breakHoursUsed']
+
+    # A department can be within its total position count while still exceeding
+    # one specific hour-band (e.g. over on 10-hour Primary but under on others),
+    # so each band needs to be checked individually, not just the aggregate total.
+    overAllocatedBands = [
+        {'label': BAND_LABELS[fieldName], 'used': band['used'], 'allocated': band['allocated']}
+        for fieldName, band in summary['allocationBands'].items()
+        if band['used'] > band['allocated']
+    ]
+    isPositionsOverAllocated = positionsRemaining < 0 or bool(overAllocatedBands)
+    isBreakHoursOverAllocated = breakHoursRemaining < 0
+
+    return {
+        'departmentName': dept.DEPT_NAME,
+        'totalPositionsAllocated': summary['totalPositionsAllocated'],
+        'totalPositionsUsed': summary['totalPositionsUsed'],
+        'positionsRemaining': positionsRemaining,
+        'isPositionsOverAllocated': isPositionsOverAllocated,
+        'overAllocatedBands': overAllocatedBands,
+        'breakHoursAllocated': summary['allocation'].breakHours,
+        'breakHoursUsed': summary['breakHoursUsed'],
+        'breakHoursRemaining': breakHoursRemaining,
+        'isBreakHoursOverAllocated': isBreakHoursOverAllocated,
+        'isOverAllocated': isPositionsOverAllocated or isBreakHoursOverAllocated,
+    }

app/models/allocation.py

@@ -0,0 +1,23 @@
+from app.models import *
+from app.models.department import Department
+from app.models.supervisor import Supervisor
+from app.models.term import Term
+
+class Allocation(baseModel):
+    termCode       = ForeignKeyField(Term)
+    department     = ForeignKeyField(Department)
+    isFinal        = BooleanField(default=False)
+    approvedOn     = DateField(null=True)
+    approvedBy     = ForeignKeyField(Supervisor, null=True)
+    justification  = TextField()
+    primary_10     = IntegerField()
+    primary_12     = IntegerField()
+    primary_15     = IntegerField()
+    primary_20     = IntegerField()
+    secondary_5    = IntegerField()
+    secondary_10   = IntegerField()
+    breakHours     = IntegerField()
+
+    class Meta:
+        indexes = ( (('termCode', 'department', 'isFinal'), True), )
+

app/models/positionHistory.py

@@ -0,0 +1,13 @@
+from app.models import *
+from app.models.department import Department
+
+class PositionHistory(baseModel):
+    positionCode       = CharField()
+    department         = ForeignKeyField(Department)
+    status             = CharField()
+    wls                = IntegerField()
+    revisionDate       = DateField()
+    description        = TextField(default=None)
+
+    class Meta:
+        indexes = ( (('positionCode', 'revisionDate', 'status'), True), )

app/models/supervisor.py

@@ -16,6 +16,7 @@ class Supervisor(baseModel):
     legal_name      = CharField(null=True)
     preferred_name  = CharField(null=True)
     isActive        = BooleanField(default=False)
+    isBanned        = BooleanField(default=False)
 
 
     @property