Merge branch 'development' into add-approve-button-in-labor-history-form

Author: Meatchema

app/controllers/main_routes/main_routes.py

@@ -1,15 +1,18 @@
-from flask import render_template, request, json, redirect, url_for, send_file, g, flash
-from peewee import fn
+from flask import render_template, request, json, redirect, url_for, send_file, g, flash, jsonify
+from peewee import JOIN
+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
+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
@@ -31,47 +34,16 @@ def supervisorPortal():
 
         return render_template('errors/403.html'), 403
 
-    terms = LaborStatusForm.select(LaborStatusForm.termCode).distinct().order_by(LaborStatusForm.termCode.desc())
-    allSupervisors = Supervisor.select()
-    supervisorFirstName = fn.COALESCE(Supervisor.preferred_name, Supervisor.legal_name)
-    studentFirstName = fn.COALESCE(Student.preferred_name, Student.legal_name)
-    department = None
+    if request.method == 'POST':
+        return getDatatableData(request)
+    
     if currentUser.isLaborAdmin or currentUser.isFinancialAidAdmin or currentUser.isSaasAdmin:
         departments = list(Department.select().order_by(Department.isActive.desc(), Department.DEPT_NAME.asc()))
-        supervisors = (Supervisor.select(Supervisor, supervisorFirstName)
-                                 .order_by(Supervisor.isActive.desc(), supervisorFirstName.contains("Unknown"), supervisorFirstName, Supervisor.LAST_NAME))
-        students = (Student.select(Student, studentFirstName)
-                           .order_by(studentFirstName.contains("Unknown"), studentFirstName, Student.LAST_NAME))
-
     else:
         departments = list(getDepartmentsForSupervisor(currentUser).order_by(Department.isActive.desc(), Department.DEPT_NAME.asc()))
-        deptNames = [department.DEPT_NAME for department in departments]
-
-        supervisorPrimaryDepartment = Department.select().join(SupervisorDepartment) # count up all forms for a supervisor in department and get the max
-
-        supervisors = (Supervisor.select(Supervisor, supervisorFirstName)
-                                 .join_from(Supervisor, LaborStatusForm)
-                                 .join_from(LaborStatusForm, Department)
-                                 .where(Department.DEPT_NAME.in_(deptNames))
-                                 .distinct()
-                                 .order_by(Supervisor.isActive.desc(), supervisorFirstName.contains("Unknown"), supervisorFirstName, Supervisor.LAST_NAME))
-        
-        students = (Student.select(Student, studentFirstName)
-                           .join_from(Student, LaborStatusForm)
-                           .join_from(LaborStatusForm, Department)
-                           .where(Department.DEPT_NAME.in_(deptNames))
-                           .order_by(studentFirstName.contains("Unknown"), studentFirstName, Student.LAST_NAME)
-                           .distinct())
-    if request.method == 'POST':
-        return getDatatableData(request)
 
     return render_template('main/supervisorPortal.html',
-                            terms = terms,
-                            supervisors = supervisors,
-                            allSupervisors = allSupervisors,
-                            students = students,
                             departments = departments,
-                            department = department,
                             currentUser = currentUser
                             )
 
@@ -112,7 +84,21 @@ def downloadSupervisorPortalResults():
     )
     return send_file(excel.relativePath, as_attachment=True, attachment_filename=excel.relativePath.split('/').pop())
 
-@main_bp.route('/lsf/<formHistoryId>/submitToBanner', methods=['GET'])
+@main_bp.route('/supervisorPortal/liveSearch', methods=['GET'])
+def SupervisorPortalSearch():
+    """
+    Returns a list of users that match a given string
+    """
+    searchType = request.args.get("searchType")
+    userInput = request.args.get("userInput")
+
+    if not searchType or not userInput:
+        return jsonify({}), 400
+    currentUser = require_login()
+    userList = searchSupervisorPortal(currentUser, searchType, userInput)
+    return jsonify(userList)
+
+@main_bp.route('/lsf/<formHistoryId>/submitToBanner', methods=['GET']) 
 def submitToBanner(formHistoryId):
     if not (g.currentUser.isLaborAdmin or g.currentUser.isLaborDepartmentStudent):
         return render_template('errors/403.html'), 403      

app/logic/getTableData.py

@@ -1,9 +1,9 @@
 import operator
-from datetime import datetime, date
+from datetime import date
 from functools import reduce
 
 from flask import json, jsonify, g, make_response
-from peewee import fn, Case
+from peewee import fn, SQL
 
 from app.controllers.admin_routes.allPendingForms import checkAdjustment
 from app.logic.search import getDepartmentsForSupervisor
@@ -40,7 +40,7 @@ def getDatatableData(request):
     if termCode == "currentTerm":
         termCode = g.openTerm
     elif termCode == "activeTerms":
-        termCode = list(Term.select(Term.termCode).where(Term.termEnd >= datetime.now()))
+        termCode = list(Term.select(Term.termCode).where(Term.termEnd >= date.today()))
     departmentId = queryFilterDict.get('departmentID', "")
     supervisorId = queryFilterDict.get('supervisorID', "")
     if supervisorId == "currentUser":
@@ -82,10 +82,9 @@ def getDatatableData(request):
     if clauses:
         formSearchResults = formSearchResults.where(reduce(operator.and_, clauses))
     if not g.currentUser.isLaborAdmin:
-        supervisorDepartments = [d.departmentID for d in getDepartmentsForSupervisor(g.currentUser)]
+        supervisorDepartments = getDepartmentsForSupervisor(g.currentUser)
         formSearchResults = formSearchResults.where(FormHistory.formID.department.in_(supervisorDepartments)) 
-    recordsTotal = len(formSearchResults)
-
+    recordsTotal = formSearchResults.count()
     # this checks and finds the first value that is not null of preferred_name, legal_name and last_name.
     # including last_name is necessary because there are like 4 cases where someone has no first name or last name, instead their full name is
     # stored in last_name

app/logic/search.py

@@ -4,6 +4,11 @@
 from app.models.laborStatusForm import LaborStatusForm
 from app.models.department import Department
 from app.models.formHistory import FormHistory
+from app.models.term import Term
+
+from functools import reduce
+import operator
+from peewee import JOIN
 
 def limitSearchByUserDepartment(students, currentUser):
     """
@@ -62,4 +67,71 @@ def getDepartmentsForSupervisor(currentUser):
 
 def getSupervisorsForDepartment(departmentId):
     departmentSupervisors = Supervisor.select().join(SupervisorDepartment).where(SupervisorDepartment.department == departmentId).order_by(Supervisor.LAST_NAME).execute()
-    return departmentSupervisors
+    return departmentSupervisors
+
+def searchSupervisorPortal(currentUser, searchType, userInput):
+    if currentUser.isLaborAdmin or currentUser.isFinancialAidAdmin or currentUser.isSaasAdmin:
+        allowed_departments = None  # unrestricted
+    else:
+        allowed_departments = [dept.DEPT_NAME for dept in getDepartmentsForSupervisor(currentUser)]
+
+    if searchType == "termSelect":
+        terms = Term.select().where(Term.termName.contains(userInput)).order_by(Term.termCode.desc())
+        return [{'termCode': term.termCode, 'termName': term.termName} for term in terms]
+
+    elif searchType == "departmentSelect":
+        query = Department.select().where(Department.DEPT_NAME.contains(userInput))
+        if allowed_departments is not None:
+            query = query.where(Department.DEPT_NAME.in_(allowed_departments))
+        query = query.order_by(Department.isActive.desc(), Department.DEPT_NAME.asc()).limit(10)
+        return [
+            {'DEPT_NAME': dept.DEPT_NAME, 'id': dept.departmentID, 'isActive': dept.isActive} 
+            for dept in query
+        ]
+
+    elif searchType == "supervisorSelect":
+        supervisor_query = searchPerson(Supervisor, userInput, allowed_departments)
+        supervisor_query = supervisor_query.order_by(Supervisor.isActive.desc()).limit(10)
+        return [
+            {'id': sup.ID, 'FIRST_NAME': sup.FIRST_NAME, "LAST_NAME": sup.LAST_NAME, "isActive": sup.isActive} 
+            for sup in supervisor_query
+        ]
+
+    elif searchType == "studentSelect":
+        student_query = searchPerson(Student, userInput, allowed_departments)
+        student_query = student_query.order_by(Student.LAST_NAME.asc()).limit(10)
+        return [
+            {'id': stu.ID, 'FIRST_NAME': stu.FIRST_NAME, 'LAST_NAME': stu.LAST_NAME} 
+            for stu in student_query
+        ]
+
+    return []
+
+def searchPerson(model, userInput, allowed_departments=None):
+    """
+    Returns a Peewee SelectObject filtered so that all words in userInput
+    must appear in at least one of the model's fields.
+    """
+    words = userInput.strip().split()
+
+    word_conditions = []
+    for word in words:
+        word_conditions.append(
+            (model.preferred_name.contains(word)) |
+            (model.legal_name.contains(word)) |
+            (model.LAST_NAME.contains(word)) |
+            (model.ID.contains(word))
+        )
+
+    query = model.select().where(reduce(operator.and_, word_conditions))
+
+    if allowed_departments is not None:
+        query = (
+            query
+            .join_from(model, LaborStatusForm, JOIN.LEFT_OUTER)
+            .join_from(LaborStatusForm, Department, JOIN.LEFT_OUTER)
+            .where(Department.DEPT_NAME.in_(allowed_departments))
+            .distinct()
+        )
+
+    return query