feat: add necessary wiring and formatting to make page mirror figma

Author: carddev81

backend/src/database/class_events.go

@@ -830,6 +830,10 @@ func generateEventInstances(event models.ProgramClassEvent, startDate, endDate t
 	return eventInstances
 }
 
+func GenerateEventInstances(event models.ProgramClassEvent, startDate, endDate time.Time) []models.EventInstance {
+	return generateEventInstances(event, startDate, endDate)
+}
+
 // GetClassEventInstancesWithAttendanceForRecurrence returns all occurrences for events
 // for a given class based on each event's recurrence rule (from DTSTART until UNTIL)
 // along with their associated attendance records.

backend/src/database/dashboard.go

@@ -0,0 +1,71 @@
+package database
+
+import (
+	"UnlockEdv2/src/models"
+)
+
+func (db *DB) GetClassDashboardMetrics(ctx *models.QueryContext, facilityID *uint) (int64, int64, int64, int64, error) {
+	var activeClasses int64
+	var totalEnrollments int64
+	var totalSeats int64
+	var attendanceConcerns int64
+
+	classQuery := db.WithContext(ctx.Ctx).
+		Model(&models.ProgramClass{}).
+		Where("status = ?", models.Active).
+		Where("archived_at IS NULL")
+	if facilityID != nil {
+		classQuery = classQuery.Where("facility_id = ?", *facilityID)
+	}
+
+	if err := classQuery.Count(&activeClasses).Error; err != nil {
+		return 0, 0, 0, 0, err
+	}
+
+	if err := classQuery.Select("COALESCE(SUM(capacity), 0)").Scan(&totalSeats).Error; err != nil {
+		return 0, 0, 0, 0, err
+	}
+
+	enrollmentQuery := db.WithContext(ctx.Ctx).
+		Table("program_class_enrollments e").
+		Select("COUNT(*)").
+		Joins("JOIN program_classes c ON c.id = e.class_id").
+		Where("e.enrollment_status = ?", models.Enrolled).
+		Where("c.status = ?", models.Active).
+		Where("c.archived_at IS NULL")
+	if facilityID != nil {
+		enrollmentQuery = enrollmentQuery.Where("c.facility_id = ?", *facilityID)
+	}
+	if err := enrollmentQuery.Scan(&totalEnrollments).Error; err != nil {
+		return 0, 0, 0, 0, err
+	}
+
+	attendanceSQL := `
+SELECT COUNT(DISTINCT c.id)
+FROM program_classes c
+JOIN program_class_enrollments e ON e.class_id = c.id
+WHERE c.status = ?
+AND c.archived_at IS NULL
+AND e.enrollment_status = ?
+`
+	args := []any{models.Active, models.Enrolled}
+	if facilityID != nil {
+		attendanceSQL += "AND c.facility_id = ?\n"
+		args = append(args, *facilityID)
+	}
+	attendanceSQL += `
+AND (
+	select count(*)
+	from program_class_events evt
+	inner join program_class_event_attendance att on att.event_id = evt.id
+	where evt.class_id = c.id
+		and att.user_id = e.user_id
+		and att.attendance_status = 'absent_unexcused'
+) >= 3
+`
+	if err := db.WithContext(ctx.Ctx).Raw(attendanceSQL, args...).Scan(&attendanceConcerns).Error; err != nil {
+		return 0, 0, 0, 0, err
+	}
+
+	return activeClasses, totalEnrollments, totalSeats, attendanceConcerns, nil
+}

backend/src/database/events_attendance.go

@@ -399,6 +399,68 @@ func (db *DB) GetMissingAttendance(classID int, args *models.QueryContext) (int,
 	return missingAttendanceCount, nil
 }
 
+func (db *DB) GetActiveClassesForMissingAttendance(args *models.QueryContext, facilityID *uint) ([]models.MissingAttendanceClass, error) {
+	var missClasses []models.MissingAttendanceClass
+	classQuery := db.WithContext(args.Ctx).
+		Table("program_classes c").
+		Select("c.id, c.name, f.name as facility_name").
+		Joins("JOIN facilities f ON f.id = c.facility_id").
+		Where("c.status = ?", models.Active).
+		Where("c.archived_at IS NULL")
+	if facilityID != nil {
+		classQuery = classQuery.Where("c.facility_id = ?", *facilityID)
+	}
+	if err := classQuery.Find(&missClasses).Error; err != nil {
+		return nil, newGetRecordsDBError(err, "program_classes")
+	}
+	return missClasses, nil
+}
+
+func (db *DB) GetClassEventsWithOverrides(args *models.QueryContext, classIDs []uint) ([]models.ProgramClassEvent, error) {
+	var events []models.ProgramClassEvent
+	if err := db.WithContext(args.Ctx).
+		Model(&models.ProgramClassEvent{}).
+		Preload("Overrides").
+		Preload("RoomRef").
+		Where("class_id IN ?", classIDs).
+		Find(&events).Error; err != nil {
+		return nil, newGetRecordsDBError(err, "program_class_events")
+	}
+	return events, nil
+}
+
+type AttendanceCount struct {
+	EventID uint   `json:"event_id"`
+	Date    string `json:"date"`
+	Count   int64  `json:"count"`
+}
+
+func (db *DB) GetAttendanceCountsForEvents(args *models.QueryContext, eventIDs []uint, dates []string) ([]AttendanceCount, error) {
+	var attendanceCounts []AttendanceCount
+	if err := db.WithContext(args.Ctx).
+		Model(&models.ProgramClassEventAttendance{}).
+		Select("event_id, date, COUNT(*) as count").
+		Where("event_id IN ? AND date IN ?", eventIDs, dates).
+		Group("event_id, date").
+		Scan(&attendanceCounts).Error; err != nil {
+		return nil, newGetRecordsDBError(err, "program_class_event_attendance")
+	}
+	return attendanceCounts, nil
+}
+
+func (db *DB) GetActiveEnrollmentsForClasses(args *models.QueryContext, classIDs []uint) ([]models.ProgramClassEnrollment, error) {
+	var enrollments []models.ProgramClassEnrollment
+	if err := db.WithContext(args.Ctx).
+		Model(&models.ProgramClassEnrollment{}).
+		Select("class_id, enrolled_at, enrollment_ended_at").
+		Where("class_id IN ?", classIDs).
+		Where("enrollment_status = ?", models.Enrolled).
+		Find(&enrollments).Error; err != nil {
+		return nil, newGetRecordsDBError(err, "program_class_enrollments")
+	}
+	return enrollments, nil
+}
+
 func (db *DB) CreateAttendanceAuditTrail(ctx context.Context, att *models.ProgramClassEventAttendance, adminID *uint, className string) error {
 
 	sessionDateParsed, err := time.ParseInLocation("2006-01-02", att.Date, time.Local)

backend/src/database/program_classes.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"context"
+
 	log "github.com/sirupsen/logrus"
 	"github.com/teambition/rrule-go"
 	"gorm.io/gorm"
@@ -65,7 +66,12 @@ func (db *DB) GetClassesForFacility(args *models.QueryContext) ([]models.Program
 	if err := tx.Count(&args.Total).Error; err != nil {
 		return nil, newGetRecordsDBError(err, "program classes")
 	}
-	if err := tx.Preload("Events").Preload("Events.RoomRef").Limit(args.PerPage).Offset(args.CalcOffset()).Find(&content).Error; err != nil {
+
+	tx = tx.Preload("Events").Preload("Events.RoomRef")
+	if !args.All {
+		tx = tx.Limit(args.PerPage).Offset(args.CalcOffset())
+	}
+	if err := tx.Find(&content).Error; err != nil {
 		return nil, newGetRecordsDBError(err, "program classes")
 	}
 	return content, nil

backend/src/handlers/classes_handler.go

@@ -3,6 +3,7 @@ package handlers
 import (
 	"UnlockEdv2/src/database"
 	"UnlockEdv2/src/models"
+	"UnlockEdv2/src/services"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -41,6 +42,7 @@ func (srv *Server) registerClassesRoutes() []routeDef {
 		validatedFeatureRoute("GET /api/program-classes/{class_id}", srv.handleGetClass, axx, resolver),
 		adminValidatedFeatureRoute("GET /api/programs/{program_id}/classes/outcomes", srv.handleGetProgramClassOutcomes, axx, validateFacility("")),
 		adminValidatedFeatureRoute("GET /api/program-classes/{class_id}/attendance-flags", srv.handleGetAttendanceFlagsForClass, axx, resolver),
+		adminFeatureRoute("GET /api/program-classes/missing-attendance", srv.handleGetMissingAttendanceForFacility, axx),
 		adminValidatedFeatureRoute("GET /api/program-classes/{class_id}/missing-attendance", srv.handleGetMissingAttendance, axx, resolver),
 		adminValidatedFeatureRoute("GET /api/program-classes/{class_id}/attendance-rate", srv.handleGetCumulativeAttendanceRate, axx, resolver),
 		adminValidatedFeatureRoute("GET /api/program-classes/{class_id}/history", srv.handleGetClassHistory, axx, resolver),
@@ -331,6 +333,49 @@ func (srv *Server) handleGetMissingAttendance(w http.ResponseWriter, r *http.Req
 	return writeJsonResponse(w, http.StatusOK, totalMissing)
 }
 
+func (srv *Server) handleGetMissingAttendanceForFacility(w http.ResponseWriter, r *http.Request, log sLog) error {
+	args := srv.getQueryContext(r)
+	facility := r.URL.Query().Get("facility")
+	var facilityId *uint
+	switch facility {
+	case "all":
+		facilityId = nil
+	case "":
+		facilityId = &args.FacilityID
+	default:
+		facilityId = &args.FacilityID
+	}
+
+	days := 3
+	if daysQuery := r.URL.Query().Get("days"); daysQuery != "" {
+		if parsedDays, err := strconv.Atoi(daysQuery); err == nil {
+			days = parsedDays
+		}
+	}
+
+	service := services.NewClassesService(srv.Db)
+	items, err := service.GetMissingAttendanceForFacility(&args, facilityId, days)
+	if err != nil {
+		return newDatabaseServiceError(err)
+	}
+
+	args.Total = int64(len(items))
+	if !args.All {
+		start := args.CalcOffset()
+		if start < len(items) {
+			end := start + args.PerPage
+			if end > len(items) {
+				end = len(items)
+			}
+			items = items[start:end]
+		} else {
+			items = []models.MissingAttendanceItem{}
+		}
+	}
+
+	return writePaginatedResponse(w, http.StatusOK, items, args.IntoMeta())
+}
+
 func (srv *Server) handleGetCumulativeAttendanceRate(w http.ResponseWriter, r *http.Request, log sLog) error {
 	classID, err := strconv.Atoi(r.PathValue("class_id"))
 	if err != nil {

backend/src/handlers/dashboard.go

@@ -18,6 +18,7 @@ func (srv *Server) registerDashboardRoutes() []routeDef {
 	resolver := UserRoleResolver("id")
 	return []routeDef{
 		newAdminRoute("GET /api/department-metrics", srv.handleDepartmentMetrics),
+		newAdminRoute("GET /api/dashboard/class-metrics", srv.handleClassDashboardMetrics),
 		newAdminRoute("GET /api/users/{id}/admin-layer2", srv.handleAdminLayer2),
 		validatedFeatureRoute("GET /api/users/{id}/catalog", srv.handleUserCatalog, axx, resolver),
 		validatedFeatureRoute("GET /api/users/{id}/courses", srv.handleUserCourses, axx, resolver),
@@ -132,6 +133,13 @@ type DashboardMetrics struct {
 	PeakLoginTimes    []models.LoginActivity `json:"peak_login_times"`
 }
 
+type ClassDashboardMetrics struct {
+	ActiveClasses      int64 `json:"active_classes"`
+	TotalEnrollments   int64 `json:"total_enrollments"`
+	TotalSeats         int64 `json:"total_seats"`
+	AttendanceConcerns int64 `json:"attendance_concerns"`
+}
+
 func (srv *Server) handleDepartmentMetrics(w http.ResponseWriter, r *http.Request, log sLog) error {
 	args := srv.getQueryContext(r)
 	facility := r.URL.Query().Get("facility")
@@ -237,6 +245,37 @@ func (srv *Server) handleDepartmentMetrics(w http.ResponseWriter, r *http.Reques
 	return writeJsonResponse(w, http.StatusOK, cachedData)
 }
 
+func (srv *Server) handleClassDashboardMetrics(w http.ResponseWriter, r *http.Request, log sLog) error {
+	args := srv.getQueryContext(r)
+	facility := r.URL.Query().Get("facility")
+	var facilityId *uint
+	switch facility {
+	case "all":
+		facilityId = nil
+	default:
+		facilityId = &args.FacilityID
+	}
+
+	activeClasses, totalEnrollments, totalSeats, attendanceConcerns, err := srv.Db.GetClassDashboardMetrics(&args, facilityId)
+	if err != nil {
+		return newDatabaseServiceError(err)
+	}
+
+	response := struct {
+		ActiveClasses      int64 `json:"active_classes"`
+		TotalEnrollments   int64 `json:"total_enrollments"`
+		TotalSeats         int64 `json:"total_seats"`
+		AttendanceConcerns int64 `json:"attendance_concerns"`
+	}{
+		ActiveClasses:      activeClasses,
+		TotalEnrollments:   totalEnrollments,
+		TotalSeats:         totalSeats,
+		AttendanceConcerns: attendanceConcerns,
+	}
+
+	return writeJsonResponse(w, http.StatusOK, response)
+}
+
 /**
 * GET: /api/users/{id}/catalog
 * @Query Params:

backend/src/models/class_event.go

@@ -255,6 +255,21 @@ type AttendanceFlag struct {
 	FlagType  AttendanceFlagType `json:"flag_type"`
 }
 
+type MissingAttendanceItem struct {
+	ClassID      uint   `json:"class_id"`
+	ClassName    string `json:"class_name"`
+	FacilityName string `json:"facility_name,omitempty"`
+	EventID      uint   `json:"event_id"`
+	Date         string `json:"date"`
+	StartTime    string `json:"start_time"`
+}
+
+type MissingAttendanceClass struct {
+	ID           uint   `json:"id"`
+	Name         string `json:"name"`
+	FacilityName string `json:"facility_name"`
+}
+
 type EventDates struct {
 	EventID   uint   `json:"event_id"`
 	Date      string `json:"date"`