fix: pod search bug with others

Author: CK-7vn

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,60 @@ 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
+	// fetch ALL enrollments for the users being graduated
+	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")
+	}
 
+	// build map for quick lookup by user ID
+	enrollmentMap := make(map[uint]models.ProgramClassEnrollment)
+	for _, e := range enrollments {
+		enrollmentMap[e.UserID] = e
+	}
+
+	// use the first enrollment for shared class data (program, credit types, etc.)
+	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 // skip users not found in enrollments
+		}
 		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,
 		})
 	}

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

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 // skip students without enrollment date (enrolled in Scheduled class)
+			}
 			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++

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")
 	}

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")
 	}
 

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)
 }

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(() => {