fix: pod search bug with others

CK-7vn · CK-7vn · commit 00a9f458cc23 · 2026-01-28T16:01:15.000-05:00
diff --git a/backend/src/database/class_enrollments.go b/backend/src/database/class_enrollments.go
@@ -36,7 +36,7 @@ func (db *DB) GetEnrollmentsForClass(page, perPage, classId int) (int64, []model
 	if err := tx.Count(&total).Error; err != nil {
 		return 0, nil, newNotFoundDBError(err, "program class enrollments")
 	}
-	if err := tx.Find(&content).Limit(page).Offset(calcOffset(page, perPage)).Error; err != nil {
+	if err := tx.Limit(perPage).Offset(calcOffset(page, perPage)).Find(&content).Error; err != nil {
 		return 0, nil, newNotFoundDBError(err, "program class enrollments")
 	}
 	return total, content, nil
@@ -110,43 +110,56 @@ func (db *DB) DeleteProgramClassEnrollments(id int) error {
 }
 
 func (db *DB) GraduateEnrollments(adminEmail string, userIds []int, classId int) error {
-	enrollment := models.ProgramClassEnrollment{}
-	// begin transaction
 	tx := db.Begin()
 
-	// preload necessary relationships
+	var enrollments []models.ProgramClassEnrollment
 	err := tx.Model(&models.ProgramClassEnrollment{}).
 		Preload("User.Facility").
 		Preload("Class.Program.ProgramCreditTypes").
 		Preload("Class.FacilityProg").
-		First(&enrollment, "class_id = ?", classId).Error
+		Where("class_id = ? AND user_id IN (?)", classId, userIds).
+		Find(&enrollments).Error
 	if err != nil {
 		tx.Rollback()
 		return newNotFoundDBError(err, "class enrollment")
 	}
+	if len(enrollments) == 0 {
+		tx.Rollback()
+		return newNotFoundDBError(fmt.Errorf("no enrollments found"), "class enrollment")
+	}
+
+	enrollmentMap := make(map[uint]models.ProgramClassEnrollment)
+	for _, e := range enrollments {
+		enrollmentMap[e.UserID] = e
+	}
 
+	firstEnrollment := enrollments[0]
 	creditType := ""
-	for i, ct := range enrollment.Class.Program.ProgramCreditTypes {
-		if i == len(enrollment.Class.Program.ProgramCreditTypes)-1 {
+	for i, ct := range firstEnrollment.Class.Program.ProgramCreditTypes {
+		if i == len(firstEnrollment.Class.Program.ProgramCreditTypes)-1 {
 			creditType += string(ct.CreditType)
 		} else {
 			creditType += fmt.Sprintf("%s,", ct.CreditType)
 		}
 	}
 
 	completions := make([]models.ProgramCompletion, 0, len(userIds))
-	for i := range userIds {
+	for _, uid := range userIds {
+		enrollment, exists := enrollmentMap[uint(uid)]
+		if !exists {
+			continue
+		}
 		completions = append(completions, models.ProgramCompletion{
 			ProgramClassID:      uint(classId),
 			FacilityName:        enrollment.User.Facility.Name,
-			ProgramName:         enrollment.Class.Program.Name,
-			ProgramOwner:        enrollment.Class.FacilityProg.ProgramOwner,
-			ProgramID:           enrollment.Class.ProgramID,
+			ProgramName:         firstEnrollment.Class.Program.Name,
+			ProgramOwner:        firstEnrollment.Class.FacilityProg.ProgramOwner,
+			ProgramID:           firstEnrollment.Class.ProgramID,
 			AdminEmail:          adminEmail,
-			ProgramClassStartDt: enrollment.Class.StartDt,
+			ProgramClassStartDt: firstEnrollment.Class.StartDt,
 			CreditType:          creditType,
-			ProgramClassName:    enrollment.Class.Name,
-			UserID:              uint(userIds[i]),
+			ProgramClassName:    firstEnrollment.Class.Name,
+			UserID:              uint(uid),
 			EnrolledOnDt:        enrollment.CreatedAt,
 		})
 	}
diff --git a/backend/src/database/class_events.go b/backend/src/database/class_events.go
@@ -180,10 +180,6 @@ func (db *DB) CreateOverrideEvents(ctx *models.QueryContext, overrideEvents []*m
 			return newCreateDBError(err, "program_class_event_overrides")
 		}
 		if overrideEvent.IsCancelled && len(overrideEvents) < 2 { //only add log for cancelled event
-			if err != nil {
-				trans.Rollback()
-				return NewDBError(err, "unable to parse override date")
-			}
 			changeLogEntry.FieldName = "event_cancelled"
 			changeLogEntry.OldValue = models.StringPtr("")
 			changeLogEntry.ParentRefID = overrideEvent.ClassID
@@ -199,14 +195,14 @@ func (db *DB) CreateOverrideEvents(ctx *models.QueryContext, overrideEvents []*m
 			changeLogEntry.NewValue = eventSummary
 		} else if overrideEvent.IsCancelled { //not logging the cancelled one from rescheduling action
 			linkedOverrideID = &overrideEvent.ID
-			if err != nil {
-				trans.Rollback()
-				return NewDBError(err, "unable to parse override date")
-			}
 			changeLogEntry.OldValue = &overrideEvent.OverrideRrule
 		}
 		if overrideEvent.IsCancelled || isOverrideUpdate { //delete attendance
 			eventDate, err = overrideEvent.GetFormattedOverrideDate("2006-01-02")
+			if err != nil {
+				trans.Rollback()
+				return NewDBError(err, "unable to parse override date")
+			}
 			if err := deleteEventAttedanceByDate(trans, overrideEvent.EventID, *eventDate); err != nil {
 				trans.Rollback()
 				return err
diff --git a/backend/src/database/events_attendance.go b/backend/src/database/events_attendance.go
@@ -376,6 +376,9 @@ func (db *DB) GetMissingAttendance(classID int, args *models.QueryContext) (int,
 		// count enrolled students on this specific date
 		enrolledCountOnDate := 0
 		for _, student := range students {
+			if student.EnrolledAt == nil {
+				continue
+			}
 			if !student.EnrolledAt.After(eventDate.StartTime) && // enrolled before or on this date
 				(student.EnrollmentEndedAt == nil || student.EnrollmentEndedAt.After(eventDate.StartTime.AddDate(0, 0, -1))) { // not ended before this date
 				enrolledCountOnDate++
diff --git a/backend/src/database/program_classes.go b/backend/src/database/program_classes.go
@@ -30,11 +30,14 @@ func (db *DB) GetClassByID(id int) (*models.ProgramClass, error) {
 
 func (db *DB) GetClassesForFacility(args *models.QueryContext) ([]models.ProgramClass, error) {
 	content := []models.ProgramClass{}
-	tx := db.WithContext(args.Ctx).Find(&content, "facility_id = ?", args.FacilityID)
+	tx := db.WithContext(args.Ctx).Model(&models.ProgramClass{}).Where("facility_id = ?", args.FacilityID)
 	if args.Search != "" {
 		tx = tx.Where("LOWER(name) LIKE ?", args.SearchQuery())
 	}
-	if err := tx.Count(&args.Total).Limit(args.PerPage).Offset(args.CalcOffset()).Error; err != nil {
+	if err := tx.Count(&args.Total).Error; err != nil {
+		return nil, newGetRecordsDBError(err, "program classes")
+	}
+	if err := tx.Limit(args.PerPage).Offset(args.CalcOffset()).Find(&content).Error; err != nil {
 		return nil, newGetRecordsDBError(err, "program classes")
 	}
 	return content, nil
@@ -187,6 +190,9 @@ func (db *DB) GetProgramClassDetailsByID(id int, args *models.QueryContext) ([]m
 		Where(`ps.program_id = ?
 			and ps.facility_id = ?`, id, args.FacilityID).
 		Group("ps.id,fac.name")
+	if args.Search != "" {
+		query = query.Where("LOWER(ps.name) LIKE ? OR LOWER(ps.description) LIKE ?", args.SearchQuery(), args.SearchQuery())
+	}
 	if err := query.Count(&args.Total).Error; err != nil {
 		return nil, newGetRecordsDBError(err, "programs")
 	}
diff --git a/backend/src/database/programs.go b/backend/src/database/programs.go
@@ -133,6 +133,7 @@ func (db *DB) UpdateProgram(program *models.Program, facilityIds []int) (*models
 	}
 	allChanges = append(allChanges, creditTypeLogEntries...)
 	if err := trans.Omit("Facilities", "CreatedAt").Select("IsActive", "Name", "Description", "FundingType", "UpdateUserID").Updates(&updatePrg).Error; err != nil {
+		trans.Rollback()
 		return nil, newUpdateDBError(err, "programs")
 	}
 
diff --git a/backend/src/handlers/programs_handler.go b/backend/src/handlers/programs_handler.go
@@ -196,7 +196,7 @@ func (srv *Server) handleUpdateProgram(w http.ResponseWriter, r *http.Request, l
 
 	updated, updateErr := srv.WithUserContext(r).UpdateProgram(&theProg, programForm.Facilities)
 	if updateErr != nil {
-		return newDatabaseServiceError(err)
+		return newDatabaseServiceError(updateErr)
 	}
 	return writeJsonResponse(w, http.StatusOK, updated)
 }
diff --git a/frontend/src/Pages/ProgramOverviewDashboard.tsx b/frontend/src/Pages/ProgramOverviewDashboard.tsx
@@ -81,7 +81,7 @@ export default function ProgramOverviewDashboard() {
         mutate: mutateClasses,
         isLoading
     } = useSWR<ServerResponseMany<Class>, Error>(
-        `/api/programs/${program_id}/classes?page=${page}&per_page=${perPage}&order_by=${sortQuery}`
+        `/api/programs/${program_id}/classes?page=${page}&per_page=${perPage}&order_by=${sortQuery}&search=${searchTerm}`
     );
 
     useEffect(() => {

Original file line number	Diff line number	Diff line change
`@@ -133,6 +133,7 @@ func (db DB) UpdateProgram(program models.Program, facilityIds []int) (*models`
`133`	`133`	`}`
`134`	`134`	`allChanges = append(allChanges, creditTypeLogEntries...)`
`135`	`135`	`if err := trans.Omit("Facilities", "CreatedAt").Select("IsActive", "Name", "Description", "FundingType", "UpdateUserID").Updates(&updatePrg).Error; err != nil {`
	`136`	`+ trans.Rollback()`
`136`	`137`	`return nil, newUpdateDBError(err, "programs")`
`137`	`138`	`}`
`138`	`139`
Original file line number	Diff line number	Diff line change
`@@ -196,7 +196,7 @@ func (srv Server) handleUpdateProgram(w http.ResponseWriter, r http.Request, l`
`196`	`196`
`197`	`197`	`updated, updateErr := srv.WithUserContext(r).UpdateProgram(&theProg, programForm.Facilities)`
`198`	`198`	`if updateErr != nil {`
`199`		`- return newDatabaseServiceError(err)`
	`199`	`+ return newDatabaseServiceError(updateErr)`
`200`	`200`	`}`
`201`	`201`	`return writeJsonResponse(w, http.StatusOK, updated)`
`202`	`202`	`}`