Merge pull request #1804 from BCStudentSoftwareDevTeam/development

Dev -> Prod 2026-09-09

Author: BrianRamsay

app/__init__.py

@@ -77,13 +77,8 @@ def load_user():
 from app.logic.loginManager import getCurrentTerm
 @app.before_request
 def load_currentTerm():
-    # An exception handles both current_term not being set and a mismatch between models
-    try:
-        g.current_term = dict_to_model(Term, session['current_term'])
-    except Exception as e:
-        term = getCurrentTerm()
-        session['current_term'] = model_to_dict(term)
-        g.current_term = term
+    # Query the current term from the database on each request to avoid stale session data
+    g.current_term = getCurrentTerm()
 
 import datetime
 @app.before_request

app/config/default.yml

@@ -7,6 +7,8 @@ support_email_contact: "support@bereacollege.onmicrosoft.com"
 show_queries: True
 test_entry: "Default"
 
+lsf_url: "USE local-override.yml"
+
 db:
     name: "celts"
     host: "db"

app/controllers/admin/routes.py

@@ -373,7 +373,7 @@ def eventDisplay(eventId):
 
         currentEventRsvpAmount = getEventRsvpCount(event.id)
 
-        userParticipatedTrainingEvents = getParticipationStatusForTrainings(eventData['program'], [g.current_user], g.current_term)
+        userParticipatedTrainingEvents = getParticipationStatusForTrainings(eventData['program'], [g.current_user], g.current_term, includeFutureEvents = False)
 
         return render_template("events/eventView.html",
                                 eventData=eventData,

app/controllers/main/routes.py

@@ -24,7 +24,6 @@
 from app.models.programManager import ProgramManager
 from app.models.backgroundCheck import BackgroundCheck
 from app.models.emergencyContact import EmergencyContact
-from app.models.eventParticipant import EventParticipant
 from app.models.courseInstructor import CourseInstructor
 from app.models.backgroundCheckType import BackgroundCheckType
 
@@ -39,7 +38,7 @@
 from app.logic.landingPage import getManagerProgramDict, getActiveEventTab
 from app.logic.minor import toggleMinorInterest, declareMinorInterest, getCommunityEngagementByTerm, getEngagementTotal
 from app.logic.participants import hasGoneToTraining, unattendedRequiredEvents, getParticipationStatusForTrainings, checkUserRsvp, addPersonToEvent
-from app.logic.users import addUserInterest, isBannedFromEvent, removeUserInterest, banUser, unbanUser, isEligibleForProgram, getUserBGCheckHistory, addProfileNote, deleteProfileNote, updateDietInfo, trainedParticipants
+from app.logic.users import *
 
 @main_bp.route('/logout', methods=['GET'])
 def redirectToLogout():
@@ -234,8 +233,8 @@ def viewUsersProfile(username):
         managersProgramDict = getManagerProgramDict(g.current_user)
         managersList = [id[1] for id in managersProgramDict.items()]
         totalSustainedEngagements = getEngagementTotal(getCommunityEngagementByTerm(volunteer))
-        handbookOverdue = getHandbookStatus(volunteer)
 
+        handbookOverdue = getHandbookStatus(volunteer)
         training = hasGoneToTraining(g.current_user, g.current_term)
 
         return render_template ("/main/userProfile.html",
@@ -390,22 +389,34 @@ def eventTravelForm(eventID):
                            userList = userList,
                            )
 
-@main_bp.route('/profile/addNote', methods=['POST'])
+@main_bp.route("/profile/addNote", methods=["POST"])
 def addNote():
-    """
-    This function adds a note to the user's profile.
-    """
-    postData = request.form
     try:
-        note = addProfileNote(postData["visibility"], postData["bonner"] == "yes", postData["noteTextbox"], postData["username"])
+        noteData = getProfileNoteData(
+            request.form,
+            includeUsername=True,
+        )
+        addProfileNote(**noteData)
         flash("Successfully added profile note", "success")
-        return redirect(url_for("main.viewUsersProfile", username=postData["username"]))
-    except Exception as e:
-        print("Error adding note", e)
+    except Exception as error:
+        print("Error adding profile note:", error)
         flash("Failed to add profile note", "danger")
-        return "Failed to add profile note", 500
-
-    
+        return str(error), 500
+    return "success"
+@main_bp.route("/<username>/editNote", methods=["POST"])
+def editProfileNote(username):
+    try:
+        noteData = getProfileNoteData( request.form,  includeId=True, )
+        profileNote = ProfileNote.get_by_id(noteData["profileNoteID"]  )
+        if (profileNote.user.username != username or (profileNote.note.createdBy != g.current_user and not g.current_user.isCeltsAdmin) ):
+            abort(403)
+        updateProfileNote(**noteData)
+        flash("Successfully updated profile note", "success")
+    except Exception as error:
+        print("Error updating profile note:", error)
+        flash("Failed to update profile note", "danger")
+        return str(error), 500
+    return "success"  
 @main_bp.route('/<username>/deleteNote', methods=['POST'])
 def deleteNote(username):
     """

app/controllers/minor/routes.py

@@ -29,6 +29,9 @@ def viewCceMinor(username):
     """
     Load minor management page with community engagements and summer experience
     """
+    if not (g.current_user.isAdmin or g.current_user.username == username or g.current_user.isCeltsStudentStaff):
+        return abort(403)
+
     sustainedEngagementByTerm = getCommunityEngagementByTerm(username)
 
     activeTab = request.args.get("tab", "sustainedCommunityEngagements")

app/logic/celtsLabor.py

@@ -97,13 +97,16 @@ def refreshCeltsLaborRecords(laborDict):
         for positionTitle, termNames in value.items():
             for term in termNames: 
                 termTableMatch = Term.select() 
-                if term[0].isalpha(): 
+                isAcademicYear = False
+
+                if term[0].isalpha(): # Fall, Spring, Summer
                     termTableMatch = termTableMatch.where(Term.description == term)
-                else:
+                else: # e.g., 2025-2026
                     termTableMatch = termTableMatch.where(Term.academicYear == term, Term.description % "Fall%")
+                    isAcademicYear = True
+
                 try:
                     laborTerm = termTableMatch.get()
-                    isAcademicYear = not laborTerm.isSummer
                     celtsLabor.append({"user": key,
                                        "positionTitle": positionTitle,
                                        "term": laborTerm,
@@ -117,14 +120,13 @@ def refreshCeltsLaborRecords(laborDict):
 def getCeltsLaborHistory(volunteer):
 
     laborHistoryList = list(CeltsLabor.select(CeltsLabor.positionTitle, 
+                                              CeltsLabor.id,
+                                              CeltsLabor.isAcademicYear,
                                               Term.description, 
                                               Term.academicYear, 
                                               Term.isSummer)
                                       .join(Term, on=(CeltsLabor.term == Term.id))
-                                      .where(CeltsLabor.user == volunteer))
-    
-    laborHistoryDict= {}
-    for position in laborHistoryList: 
-        laborHistoryDict[position.positionTitle] = position.term.description if position.term.isSummer else position.term.academicYear
+                                      .where(CeltsLabor.user == volunteer)
+                                      .order_by(Term.termOrder.asc()))
 
-    return laborHistoryDict
+    return [(p.positionTitle, f"AY {p.term.academicYear}" if p.isAcademicYear else p.term.description) for p in laborHistoryList]

app/logic/events.py

@@ -411,22 +411,32 @@ def getParticipatedEventsForUser(user):
         :return: A list of Event objects
     """
 
-    # Does this handle labor only and/or includes labor events?
-    participatedEvents = (Event.select(Event, Program.programName, Case(None, (
-                               ((Event.allowsLabor | Event.name.contains("Labor")) & Event.isService, "Labor & Volunteer"), 
-                               ((Event.allowsLabor | Event.isLaborOnly | Event.name.contains("Labor")), "Labor"),
-                               (Event.isService, "Volunteer")), "Attendee").alias("participatedType"))
+    eventName = fn.LOWER(Event.name)
+    checkIfLaborMeeting = eventName.contains("labor meeting")
+
+    participatedEvents = (Event.select(Event, 
+                                       Program.programName, 
+                                       Case(None,
+                                            (
+                                              ((Event.allowsLabor | Event.name.contains("Labor")) & Event.isService, "Labor & Volunteer"),
+                                              ((Event.allowsLabor | Event.isLaborOnly | Event.name.contains("Labor")), "Labor"),
+                                              (Event.isService, "Volunteer")
+                                            ), 
+                                            "Attendee").alias("participatedType"), 
+                                       EventParticipant.hoursEarned
+                                      )
                                .join(Program, JOIN.LEFT_OUTER).switch()
                                .join(EventParticipant)
                                .where(EventParticipant.user == user,
                                       Event.isAllVolunteerTraining == False, Event.deletionDate == None, Event.isCeltsTraining == False)
                                .order_by(Event.startDate, Event.name))
-    allVolunteer = (Event.select(Event, "", Value("Volunteer").alias("participatedType"))
+
+    allVolunteer = (Event.select(Event, "", Value("Volunteer").alias("participatedType"), Value(0).alias("hoursEarned"))
                          .join(EventParticipant)
                          .where(Event.isAllVolunteerTraining == True,
                                 EventParticipant.user == user))
     union = participatedEvents.union_all(allVolunteer)
-    unionParticipationWithVolunteer = list(union.select_from(union.c.id, union.c.programName, union.c.startDate, union.c.name, union.c.participatedType).order_by(union.c.startDate, union.c.name).execute())
+    unionParticipationWithVolunteer = list(union.select_from(union.c.id, union.c.isService, union.c.programName, union.c.startDate, union.c.name, union.c.participatedType, union.c.hoursEarned).order_by(union.c.startDate, union.c.name).execute())
     return unionParticipationWithVolunteer
 
 def validateNewEventData(data):

app/logic/participants.py

@@ -116,7 +116,7 @@ def getEventParticipants(event):
 
     return [p for p in eventParticipants]
 
-def getParticipationStatusForTrainings(program, userList, term, returnStr = True):
+def getParticipationStatusForTrainings(program, userList, term, includeFutureEvents = True):
     """
     This function returns a dictionary of all trainings for a program and
     whether the current user participated in them.
@@ -130,7 +130,10 @@ def getParticipationStatusForTrainings(program, userList, term, returnStr = True
                              .join(EventRsvp, JOIN.LEFT_OUTER).switch()
                              .join(Term)
                              .where(isRelevantTraining, (Event.isCanceled != True)).order_by(Event.startDate))
-
+    if not includeFutureEvents:
+        programTrainings = programTrainings.where(
+            (Event.startDate < datetime.now().date()) | 
+            ((Event.startDate == datetime.now().date()) & (Event.timeStart <= datetime.now().time())))
     # Create a dictionary where the keys are trainings and values are a set of those who attended
     trainingData = defaultdict(set)
     for training in programTrainings:
@@ -151,7 +154,7 @@ def getParticipationStatusForTrainings(program, userList, term, returnStr = True
         for user in userList:
             if training.name not in userParticipationStatus[user.username] or user.username in attendeeList:
                 userParticipationStatus[user.username][training.name] = [training, user.username in attendeeList]
-    if returnStr:
+    if includeFutureEvents:
         return {user.username: list(userParticipationStatus[user.username].values()) for user in userList}
     else:
         return {user: list(userParticipationStatus[user.username].values()) for user in userList}
@@ -178,7 +181,7 @@ def getTrainingsForInterestedParticipants(programID, interestedUsers):
 
     Gracefully handles multiple trainings of the same type (e.g., two All Volunteers Trainings)
     """
-    trainedUsers = getParticipationStatusForTrainings(programID, interestedUsers, g.current_term, returnStr = False)
+    trainedUsers = getParticipationStatusForTrainings(programID, interestedUsers, g.current_term, includeFutureEvents = False)
     now = datetime.now()
     bannedUsers = list(User
                .select(User.username)
@@ -207,7 +210,7 @@ def getTrainingsForInterestedParticipants(programID, interestedUsers):
             for event in trainedUsers[interestedUser]:
                 if not event[1]: # they didn't attend this training
                     continue
-                elif event[0].isAllVolunteerTraining:   # They attended AVT
+                elif event[0].isAllVolunteerTraining or event[0].isCeltsTraining:   # They attended AVT or ACT
                     trainedAndInterested[interestedUser.username]["allVolunteer"] = True                    
                 elif event[0].isTraining:           # They attended the Program-specific training
                     trainedAndInterested[interestedUser.username]["programSpecific"] = True                    
@@ -241,7 +244,10 @@ def getParticipantsForProgramForAY(program, academicYear):
                             .where(Program.id == program, 
                                    Term.academicYear == academicYear, 
                                    User.hasGraduated == False, 
-                                   EventParticipant.hoursEarned > 0)
+                                   EventParticipant.hoursEarned > 0,
+                                   # Only include currently enrolled undergraduate students.
+                                   # This prevents alumni and past participants from appearing in the older reports.
+                                   User.rawClassLevel.in_(["Freshman", "Sophomore", "Junior", "Senior"]))
                             .distinct()
                             )
     return participants

app/logic/searchUsers.py

@@ -1,3 +1,4 @@
+from peewee import fn
 from playhouse.shortcuts import model_to_dict
 from app.models.user import User
 def searchUsers(query, category=None):
@@ -6,15 +7,19 @@ def searchUsers(query, category=None):
 
         MySQL LIKE is case insensitive
     '''
-    # add wildcards to each piece of the query
     splitSearch = query.strip().split()
-    firstName = splitSearch[0] + "%"
-    lastName = " ".join(splitSearch[1:]) +"%"
-
-    if len(splitSearch) == 1: # search for query in first OR last name
-        searchWhere = (User.firstName ** firstName | User.lastName ** firstName | User.username ** splitSearch)
-    else:                     # search for first AND last name
-        searchWhere = (User.firstName ** firstName & User.lastName ** lastName)
+    if not splitSearch:
+        return User.select().where(False)
+    searchWhere = None
+    for namePart in splitSearch:
+        nameSearch = namePart + "%"
+        # This individual search term can match the user's first name, last name, or username.
+        namePartWhere = (User.firstName.contains(namePart) | User.lastName.contains(namePart) | User.username.contains(namePart))
+        # For the first search term, initialize the WHERE condition.
+        if searchWhere is None:
+            searchWhere = namePartWhere
+        else:
+            searchWhere &= namePartWhere # Require every search term to match at least one of the first name, last name, or username fields.
 
     if category == "instructor":
         userWhere = (User.isFaculty | User.isStaff)
@@ -26,12 +31,21 @@ def searchUsers(query, category=None):
         userWhere = (User.isCeltsOperationsTeam)
     elif category == "celtsLinkAdmin":
         userWhere = (User.isFaculty | User.isStaff | User.isCeltsStudentStaff | User.isCeltsOperationsTeam)
+    elif category == "currentStudents":
+        userWhere = (User.rawClassLevel.in_(["Freshman", "Sophomore", "Junior", "Senior"]))
     elif category == "all":
         userWhere = (True)
     else:
         userWhere = (User.isStudent)
 
+    fullSearchText = " ".join(splitSearch)
     # Combine into query
-    searchResults = User.select().where(searchWhere, userWhere)
+    searchResults = User.select().where(searchWhere, userWhere).order_by(
+        fn.CONCAT(User.firstName, " ", User.lastName).contains(fullSearchText).desc(),
+        User.firstName.startswith(fullSearchText).desc(),
+        User.lastName.startswith(fullSearchText).desc(),
+        User.lastName,
+        User.firstName
+    )
 
     return { user.username : model_to_dict(user) for user in searchResults }

app/logic/users.py

@@ -91,7 +91,7 @@ def getProgramInterest(program):
     Parameters:
     program: Program object
     """
-    return User.select().join(Interest).where(Interest.program == program)
+    return User.select().join(Interest).where(Interest.program == program, User.rawClassLevel.in_(["Freshman", "Sophomore", "Junior", "Senior"]))
 
 def getBannedUsers(program):
     """
@@ -196,20 +196,48 @@ def getUserBGCheckHistory(username):
     for row in allBackgroundChecks:
         bgHistory[row.type_id].append(row)
     return bgHistory
-
-def addProfileNote(visibility, bonner, noteTextbox, username):
+def getProfileNoteData(formData, includeUsername=False, includeId=False):
+    noteData = {
+        "visibility": int(formData.get("visibility", 1)),
+        "bonner": formData.get("bonner") == "yes",
+        "cceMinor": formData.get("cceMinor") == "yes",
+        "noteTextbox": formData.get("noteTextbox", "").strip(),
+    }
+    if not noteData["noteTextbox"]:
+        raise ValueError("Note cannot be empty")
+    if includeUsername:
+        noteData["username"] = formData.get("username")
+        if not noteData["username"]:
+            raise ValueError("Missing username")
+    if includeId:
+        noteData["profileNoteID"] = formData.get("id")
+        if not noteData["profileNoteID"]:
+            raise ValueError("Missing profile note ID")
+    return noteData
+
+def addProfileNote(visibility, bonner, cceMinor, noteTextbox, username):
+    user = User.get(User.username == username)
+    visibility = int(visibility)
     if bonner:
-        visibility = 1 # bonner notes are always admins and the student
+        visibility = 1
 
-    noteForDb = Note.create(createdBy = g.current_user,
-                            createdOn = datetime.datetime.now(),
-                            noteContent = noteTextbox,
-                            noteType = "profile")
-    createProfileNote = ProfileNote.create(user = User.get(User.username == username),
-                                           note = noteForDb,
-                                           isBonnerNote = bonner,
-                                           viewTier = visibility)
-    return createProfileNote
+    noteForDb = Note.create( createdBy=g.current_user, createdOn=datetime.datetime.now(),  noteContent=noteTextbox, noteType="profile" )
+    profileNote = ProfileNote.create( user=user, note=noteForDb, isBonnerNote=bonner, isCCEMinorNote=cceMinor, viewTier=visibility, )
+    return profileNote
+
+def updateProfileNote( profileNoteID, visibility, bonner, cceMinor, noteTextbox):
+    profileNote = ProfileNote.get_by_id(profileNoteID)
+    visibility = int(visibility)
+    if bonner:
+        visibility = 1
+    note = profileNote.note
+    note.noteContent = noteTextbox
+    note.save()
+    profileNote.viewTier = visibility
+    profileNote.isBonnerNote = bonner
+    profileNote.isCCEMinorNote = cceMinor
+    profileNote.save()
+    return profileNote
 
 def deleteProfileNote(noteId):
     return ProfileNote.delete().where(ProfileNote.id == noteId).execute()