Create a page for departments to view their allocations

app/controllers/main_routes/main_routes.py

@@ -11,6 +11,7 @@
 from app.models.formHistory import FormHistory
 from app.models.term import Term
 from app.models.positionHistory import PositionHistory
+from app.models.allocation import Allocation
 
 from app.controllers.admin_routes.allPendingForms import checkAdjustment
 from app.controllers.main_routes import main_bp
@@ -22,6 +23,8 @@
 from app.logic.banner import Banner
 from app.logic.getSupervisors import getSupervisors
 from app.logic.getPositions import getActivePositions
+from app.logic.allocationManager import getBreakContracts, getContractedAllocations, getTotalAllocations
+from app.logic.getCurrentTerms import getCurrentTerms
 
 
 @main_bp.route('/logout', methods=['GET'])
@@ -82,6 +85,43 @@ def departmentPortal(org=None,account=None):
                            positions = positionsList,
                            posURL = posURL)
 
+@main_bp.route('/department/<org>/<account>/allocations', methods=['GET'])
+def allocationTable(org=None, account=None):
+    currentUser = g.currentUser
+    try:
+        dept = Department.get(Department.ORG == org, Department.ACCOUNT == account)
+    except (NameError, DoesNotExist):
+        return render_template('errors/404.html'), 404
+
+    if not currentUser.isLaborAdmin:
+        allowedDepartmentIds = [d.departmentID for d in getDepartmentsForSupervisor(currentUser)]
+        if dept.departmentID not in allowedDepartmentIds:
+            return render_template('errors/403.html'), 403
+
+    currentAY, fallTerm, springTerm = getCurrentTerms()
+
+    allocationDict = getTotalAllocations(currentAY.termCode, dept)
+    fallContracts = getContractedAllocations(fallTerm.termCode, dept)
+    springContracts = getContractedAllocations(springTerm.termCode, dept)
+
+    breakContracts = {
+        "total": 0,
+        "thanksgiving":getBreakContracts(currentAY.termCode + 1, dept),
+        "winter": getBreakContracts(currentAY.termCode + 2, dept),
+        "spring": getBreakContracts(currentAY.termCode + 3, dept),
+        "fall":getBreakContracts(currentAY.termCode + 4, dept),
+        "summer": getBreakContracts(currentAY.termCode + 13, dept)
+        }
+    breakContracts["total"] = sum(breakContracts.values())
+    return render_template('main/allocationTable.html',
+                           department = dept,
+                           currentAY = currentAY,
+                           allocations = allocationDict,
+                           fallContracts = fallContracts,
+                           springContracts = springContracts,
+                           breakContracts = breakContracts)
+
+
 @main_bp.route('/supervisorPortal/download', methods=['POST'])
 def downloadSupervisorPortalResults():
     '''

app/logic/allocationManager.py

@@ -12,20 +12,24 @@ def getAllocation(termCode: int, dept: int, isFinal = True):
     This function returns a peewee object containing the selected allocation for given 
     department and term. If you want the pending allocation, pass in False for isFinal.
     '''
-    academicYearCode = int(str(termCode)[:4] + "00")
-    allocationObject = Allocation.select().where(
-        Allocation.termCode.in_([termCode,academicYearCode]),
-        Allocation.department == dept, 
-        Allocation.isFinal == isFinal).dicts().get()
-    return allocationObject 
+    try:
+        academicYearCode = int(str(termCode)[:4] + "00")
+        allocationObject = Allocation.select().where(
+            Allocation.termCode.in_([termCode,academicYearCode]),
+            Allocation.department == dept, 
+            Allocation.isFinal == isFinal).dicts().get()
+        return allocationObject 
+    except:
+        return 0 
 
 
 def getTotalAllocations(termCode: int, dept: int):
     '''
     This function returns a dictionary representation of the given department's allocation for the given term.
     '''
-    allocationObject = getAllocation(termCode, dept)
-    allocationDict = {"primary_10": allocationObject["primary_10"],
+    try:
+        allocationObject = getAllocation(termCode, dept)
+        allocationDict = {"primary_10": allocationObject["primary_10"],
                     "primary_12": allocationObject["primary_12"],
                     "primary_15": allocationObject["primary_15"],
                     "primary_20": allocationObject["primary_20"],
@@ -35,15 +39,49 @@ def getTotalAllocations(termCode: int, dept: int):
                     "totalPrimaries": (allocationObject["primary_10"] + allocationObject["primary_12"] + allocationObject["primary_15"] + allocationObject["primary_20"]),
                     "totalSecondaries": (allocationObject["secondary_5"] + allocationObject["secondary_10"]),
                     "totalAllocations": (allocationObject["primary_10"] + allocationObject["primary_12"] + allocationObject["primary_15"] + allocationObject["primary_20"] + allocationObject["secondary_5"] + allocationObject["secondary_10"] )}
+    except:
+        allocationDict = {"primary_10": "",
+                    "primary_12": "",
+                    "primary_15": "",
+                    "primary_20": "",
+                    "secondary_5": "",
+                    "secondary_10": "", 
+                    "breakHours": "No Allocations Found", 
+                    "totalPrimaries": "", 
+                    "totalSecondaries": "",
+                    "totalAllocations": "No Allocations Found"}
     return allocationDict 
 
-def countContracts(jobType: str, weeklyContractHours: int, termCode: int, dept: int):
+def countContracts(jobType: str, weeklyContractHours: int, termCode: int, dept: int, AYtermCode: int = None):
     '''
     This function counts the number of positions of a given type in a given department.
     For example, countContracts('secondary', 5, 202511, 1) returns the number of secondary 
     5-hour positions in the CS department for the 2025 Fall term.
     '''
     academicYearCode = int(str(termCode)[:4] + "00") 
+
+    # This sets the date condition to determine whether the form is within the boundaries of the term
+    # Fall only contracts end before spring, spring contracts start after fall.
+    fallMonths = ["07","08","09","10","11","12"]
+    springMonths = ["01","02","03","04","05","06"]
+    if str(termCode).endswith("11"):
+        dateCondition = (
+            (LaborStatusForm.endDate.month.in_(fallMonths)) |
+            (LaborStatusForm.startDate.month.in_(fallMonths) & # Reused check for year-long positions
+                LaborStatusForm.endDate.month.in_(springMonths))
+            )
+    elif str(termCode).endswith("12"):
+        dateCondition = (
+            (LaborStatusForm.startDate.month.in_(springMonths)) |
+            (LaborStatusForm.startDate.month.in_(fallMonths) &
+                LaborStatusForm.endDate.month.in_(springMonths))
+            )
+    else:
+        dateCondition = (
+            (LaborStatusForm.startDate.month.in_(fallMonths) &
+                LaborStatusForm.endDate.month.in_(springMonths))
+            )
+
     lsfCountPositions = FormHistory.select(
                             ).join(LaborStatusForm
                             ).join(Department
@@ -54,6 +92,7 @@ def countContracts(jobType: str, weeklyContractHours: int, termCode: int, dept:
                                 LaborStatusForm.jobType == jobType, # 'primary' or 'secondary'
                                 LaborStatusForm.weeklyHours == weeklyContractHours, # 5, 10, 12, 15, or 20
                                 Department.departmentID == dept,
+                                dateCondition,
                             ).count()
     return lsfCountPositions 
 
@@ -105,4 +144,18 @@ def getContractedAllocations(termCode: int, dept: int):
     usedPositions["used_primaries"] = sum(list(usedPositions.values())[:4])
     usedPositions["used_secondaries"] = sum(list(usedPositions.values())[4:6])
     usedPositions["used_total"] = sum(list(usedPositions.values())[:6])
-    return usedPositions
+    return usedPositions
+
+def getBreakContracts(termCode, dept):
+    break_allocation = FormHistory.select(fn.SUM(LaborStatusForm.contractHours)
+    ).join(LaborStatusForm
+    ).where(
+        FormHistory.historyType == "Labor Status Form",
+        FormHistory.status.in_(["Approved", "Pending", "Pre-Student Approval"]),
+        LaborStatusForm.termCode == termCode,
+        LaborStatusForm.department == dept,
+        LaborStatusForm.contractHours.is_null(False)).scalar()
+    if break_allocation != None:
+        return break_allocation
+    else:
+        return 0

app/logic/getCurrentTerms.py

@@ -0,0 +1,24 @@
+from app.models.term import Term
+from datetime import datetime, date
+
+def getCurrentTerms():
+    '''
+    Gets 3 primary terms for the current Academic Year (AY)
+    This means it attempt to get an AY, fall term, and spring term
+    This returns all three objects individually for each of the terms.
+    '''
+    currentDate = date.today()
+    if currentDate.month <= 6:
+        # If it is the spring semester, then the term code is 1 year behind. e.g. 2025-2026 term code is 202500. Thus the - 100 in the spring term.
+        # The (year * 100) turns the year into an AY term code, 2025 -> 202500. The + 12/11 turns it into a fall or spring term.
+        springTerm = Term.select().where(Term.termCode == currentDate.year * 100 + 12 - 100).get()
+        currentAY = Term.select().where(Term.termCode == currentDate.year * 100 - 100).get()
+        fallTerm = Term.select().where(Term.termCode == currentDate.year * 100 + 11 - 100).get()
+        return currentAY, fallTerm, springTerm
+
+    else:
+        fallTerm = Term.select().where(Term.termCode == currentDate.year * 100 + 11).get()
+        currentAY = Term.select().where(Term.termCode == currentDate.year * 100).get()
+        springTerm = Term.select().where(Term.termCode == currentDate.year * 100 + 12).get()
+        return currentAY, fallTerm, springTerm
+

app/static/css/allocationTable.css

@@ -0,0 +1,65 @@
+.grid-container {
+  display: grid;
+  grid-template-columns: 1fr 1fr;    
+}
+.btn-success{
+    align-self: center;
+    justify-self: end;
+}
+.card-header {
+  background-color: #efebeb;
+  margin-bottom: 7px;
+  height: 6rem;
+}
+.mb-0, .collapsed {
+  outline-color: none;
+  color: black;
+  font-size: 18px;
+  font-weight: 525;
+}
+.accordion{
+  padding-left: 5%;
+  padding-right: 5%;
+}
+.table-striped {
+    table-layout:fixed;
+    width:100%;
+}
+.table-striped tbody tr:nth-of-type(odd) {
+    background-color: #f2f2f2;
+}
+.btn-info{
+    justify-self:flex-end;
+    align-self: center;
+    margin-left: 4px
+}
+.accordion-arrow {
+  display: inline-block;
+  transition: transform 0.2s ease-in-out;
+}
+.btn.collapsed .accordion-arrow {
+  transform: rotate(-90deg);
+}
+.btn:not(.collapsed) .accordion-arrow {
+  transform: rotate(0deg);
+}
+.button-container {
+  display:flex;
+  justify-content:end;
+}
+.btn-block{
+  align-items: center;
+  align-self: center;
+  text-align: left;
+  justify-content: center;
+  height: 100%
+}
+.termDisplay{
+  margin-right:auto;
+}
+.bi-info-circle {
+    padding: 3px 3.5px 1.5px 3.5px;
+    font-size: 1.5rem;
+    vertical-align: middle;
+    color:#6e6e6e;
+}

app/static/js/allocationTable.js

@@ -0,0 +1,22 @@
+$(document).ready( function(){
+    function initTable(selector) {
+        return $(selector).DataTable({
+            pageLength: 25,
+            info: false,
+            lengthChange: false,
+            searching: false,
+            paging: false,
+            order: []
+        });
+    }
+
+    const fallTermPrimaries = initTable('#fallTermPrimaries');
+    const fallTermSecondaries = initTable('#fallTermSecondaries');
+    const springTermPrimaries = initTable('#springTermPrimaries');
+    const springTermSecondaries = initTable('#springTermSecondaries');
+    const breakTable = initTable('#breakTable');
+});
+
+$(function () {
+  $('[data-toggle="tooltip"]').tooltip()
+})