breakpilot-lehrer/school-service/internal/handlers/timetable_handlers.go

package handlers

import (
	"net/http"

	"github.com/breakpilot/school-service/internal/models"
	"github.com/gin-gonic/gin"
)

// ---------- Classes ----------

func (h *Handler) CreateTimetableClass(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	var req models.CreateTimetableClassRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		respondError(c, http.StatusBadRequest, "Invalid request: "+err.Error())
		return
	}
	out, err := h.timetableService.CreateClass(c.Request.Context(), uid, &req)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to create class: "+err.Error())
		return
	}
	respondCreated(c, out)
}

func (h *Handler) ListTimetableClasses(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	out, err := h.timetableService.ListClasses(c.Request.Context(), uid)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to list classes: "+err.Error())
		return
	}
	respondSuccess(c, out)
}

func (h *Handler) DeleteTimetableClass(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	if err := h.timetableService.DeleteClass(c.Request.Context(), c.Param("id"), uid); err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to delete class: "+err.Error())
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "Class deleted"})
}

// ---------- Periods ----------

func (h *Handler) CreateTimetablePeriod(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	var req models.CreateTimetablePeriodRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		respondError(c, http.StatusBadRequest, "Invalid request: "+err.Error())
		return
	}
	out, err := h.timetableService.CreatePeriod(c.Request.Context(), uid, &req)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to create period: "+err.Error())
		return
	}
	respondCreated(c, out)
}

func (h *Handler) ListTimetablePeriods(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	out, err := h.timetableService.ListPeriods(c.Request.Context(), uid)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to list periods: "+err.Error())
		return
	}
	respondSuccess(c, out)
}

func (h *Handler) DeleteTimetablePeriod(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	if err := h.timetableService.DeletePeriod(c.Request.Context(), c.Param("id"), uid); err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to delete period: "+err.Error())
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "Period deleted"})
}

// ---------- Rooms ----------

func (h *Handler) CreateTimetableRoom(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	var req models.CreateTimetableRoomRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		respondError(c, http.StatusBadRequest, "Invalid request: "+err.Error())
		return
	}
	out, err := h.timetableService.CreateRoom(c.Request.Context(), uid, &req)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to create room: "+err.Error())
		return
	}
	respondCreated(c, out)
}

func (h *Handler) ListTimetableRooms(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	out, err := h.timetableService.ListRooms(c.Request.Context(), uid)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to list rooms: "+err.Error())
		return
	}
	respondSuccess(c, out)
}

func (h *Handler) DeleteTimetableRoom(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	if err := h.timetableService.DeleteRoom(c.Request.Context(), c.Param("id"), uid); err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to delete room: "+err.Error())
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "Room deleted"})
}

// ---------- Subjects ----------

func (h *Handler) CreateTimetableSubject(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	var req models.CreateTimetableSubjectRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		respondError(c, http.StatusBadRequest, "Invalid request: "+err.Error())
		return
	}
	out, err := h.timetableService.CreateSubject(c.Request.Context(), uid, &req)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to create subject: "+err.Error())
		return
	}
	respondCreated(c, out)
}

func (h *Handler) ListTimetableSubjects(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	out, err := h.timetableService.ListSubjects(c.Request.Context(), uid)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to list subjects: "+err.Error())
		return
	}
	respondSuccess(c, out)
}

func (h *Handler) DeleteTimetableSubject(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	if err := h.timetableService.DeleteSubject(c.Request.Context(), c.Param("id"), uid); err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to delete subject: "+err.Error())
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "Subject deleted"})
}

// ---------- Teachers ----------

func (h *Handler) CreateTimetableTeacher(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	var req models.CreateTimetableTeacherRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		respondError(c, http.StatusBadRequest, "Invalid request: "+err.Error())
		return
	}
	out, err := h.timetableService.CreateTeacher(c.Request.Context(), uid, &req)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to create teacher: "+err.Error())
		return
	}
	respondCreated(c, out)
}

func (h *Handler) ListTimetableTeachers(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	out, err := h.timetableService.ListTeachers(c.Request.Context(), uid)
	if err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to list teachers: "+err.Error())
		return
	}
	respondSuccess(c, out)
}

func (h *Handler) DeleteTimetableTeacher(c *gin.Context) {
	uid := getUserID(c)
	if uid == "" {
		respondError(c, http.StatusUnauthorized, "User not authenticated")
		return
	}
	if err := h.timetableService.DeleteTeacher(c.Request.Context(), c.Param("id"), uid); err != nil {
		respondError(c, http.StatusInternalServerError, "Failed to delete teacher: "+err.Error())
		return
	}
	c.JSON(http.StatusOK, gin.H{"message": "Teacher deleted"})
}