238 lines
10 KiB
Go
238 lines
10 KiB
Go
package handlers
|
|
|
|
import (
|
|
"Yimaru-Backend/internal/domain"
|
|
"Yimaru-Backend/internal/services/courses"
|
|
"Yimaru-Backend/internal/services/lessons"
|
|
"Yimaru-Backend/internal/services/modules"
|
|
"Yimaru-Backend/internal/services/practices"
|
|
"context"
|
|
"errors"
|
|
"strconv"
|
|
|
|
"github.com/gofiber/fiber/v2"
|
|
)
|
|
|
|
// CreatePractice godoc
|
|
// @Tags practices
|
|
// @Accept json
|
|
// @Param body body domain.CreatePracticeInput true "Practice (parent_kind: COURSE | MODULE | LESSON)"
|
|
// @Router /api/v1/practices [post]
|
|
func (h *Handler) CreatePractice(c *fiber.Ctx) error {
|
|
var req domain.CreatePracticeInput
|
|
if err := c.BodyParser(&req); err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
|
|
Message: "Invalid request body",
|
|
Error: err.Error(),
|
|
})
|
|
}
|
|
if valErrs, ok := h.validator.Validate(c, req); !ok {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{
|
|
Message: "Validation failed",
|
|
Error: firstValidationError(valErrs),
|
|
})
|
|
}
|
|
p, err := h.practiceSvc.Create(c.Context(), req)
|
|
if err != nil {
|
|
switch {
|
|
case errors.Is(err, courses.ErrCourseNotFound):
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Course not found", Error: err.Error()})
|
|
case errors.Is(err, modules.ErrModuleNotFound):
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Module not found", Error: err.Error()})
|
|
case errors.Is(err, lessons.ErrLessonNotFound):
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Lesson not found", Error: err.Error()})
|
|
case errors.Is(err, practices.ErrQuestionSetNotFound):
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Question set not found", Error: err.Error()})
|
|
case errors.Is(err, domain.ErrUserNotFound):
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Persona user not found", Error: err.Error()})
|
|
case errors.Is(err, practices.ErrInvalidPracticeParent):
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{Message: "Invalid parent", Error: err.Error()})
|
|
}
|
|
return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{Message: "Failed to create practice", Error: err.Error()})
|
|
}
|
|
actorID := c.Locals("user_id").(int64)
|
|
actorRole := string(c.Locals("role").(domain.Role))
|
|
ip := c.IP()
|
|
ua := c.Get("User-Agent")
|
|
rid := p.ID
|
|
go h.activityLogSvc.RecordAction(context.Background(), &actorID, &actorRole, domain.ActionPracticeCreated, domain.ResourcePractice, &rid, "Created practice: "+p.Title, nil, &ip, &ua)
|
|
|
|
return c.Status(fiber.StatusCreated).JSON(domain.Response{
|
|
Message: "Practice created successfully",
|
|
Data: p,
|
|
Success: true,
|
|
StatusCode: fiber.StatusCreated,
|
|
})
|
|
}
|
|
|
|
// ListPracticesByCourse godoc
|
|
// @Tags practices
|
|
// @Param id path int true "Course ID"
|
|
// @Router /api/v1/courses/{id}/practices [get]
|
|
func (h *Handler) ListPracticesByCourse(c *fiber.Ctx) error {
|
|
courseID, err := strconv.ParseInt(c.Params("id"), 10, 64)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{Message: "Invalid course id", Error: err.Error()})
|
|
}
|
|
limit, _ := strconv.Atoi(c.Query("limit", "20"))
|
|
offset, _ := strconv.Atoi(c.Query("offset", "0"))
|
|
items, total, err := h.practiceSvc.ListByCourse(c.Context(), courseID, int32(limit), int32(offset))
|
|
if err != nil {
|
|
if errors.Is(err, courses.ErrCourseNotFound) {
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Course not found", Error: err.Error()})
|
|
}
|
|
return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{Message: "Failed to list practices", Error: err.Error()})
|
|
}
|
|
return c.JSON(domain.Response{
|
|
Message: "Practices retrieved successfully",
|
|
Data: fiber.Map{
|
|
"practices": items,
|
|
"total_count": total,
|
|
"limit": limit,
|
|
"offset": offset,
|
|
},
|
|
Success: true,
|
|
StatusCode: fiber.StatusOK,
|
|
})
|
|
}
|
|
|
|
// ListPracticesByModule godoc
|
|
// @Tags practices
|
|
// @Param id path int true "Module ID"
|
|
// @Router /api/v1/modules/{id}/practices [get]
|
|
func (h *Handler) ListPracticesByModule(c *fiber.Ctx) error {
|
|
moduleID, err := strconv.ParseInt(c.Params("id"), 10, 64)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{Message: "Invalid module id", Error: err.Error()})
|
|
}
|
|
limit, _ := strconv.Atoi(c.Query("limit", "20"))
|
|
offset, _ := strconv.Atoi(c.Query("offset", "0"))
|
|
items, total, err := h.practiceSvc.ListByModule(c.Context(), moduleID, int32(limit), int32(offset))
|
|
if err != nil {
|
|
if errors.Is(err, modules.ErrModuleNotFound) {
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Module not found", Error: err.Error()})
|
|
}
|
|
return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{Message: "Failed to list practices", Error: err.Error()})
|
|
}
|
|
return c.JSON(domain.Response{
|
|
Message: "Practices retrieved successfully",
|
|
Data: fiber.Map{
|
|
"practices": items,
|
|
"total_count": total,
|
|
"limit": limit,
|
|
"offset": offset,
|
|
},
|
|
Success: true,
|
|
StatusCode: fiber.StatusOK,
|
|
})
|
|
}
|
|
|
|
// ListPracticesByLesson godoc
|
|
// @Tags practices
|
|
// @Param id path int true "Lesson ID"
|
|
// @Router /api/v1/lessons/{id}/practices [get]
|
|
func (h *Handler) ListPracticesByLesson(c *fiber.Ctx) error {
|
|
lessonID, err := strconv.ParseInt(c.Params("id"), 10, 64)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{Message: "Invalid lesson id", Error: err.Error()})
|
|
}
|
|
limit, _ := strconv.Atoi(c.Query("limit", "20"))
|
|
offset, _ := strconv.Atoi(c.Query("offset", "0"))
|
|
items, total, err := h.practiceSvc.ListByLesson(c.Context(), lessonID, int32(limit), int32(offset))
|
|
if err != nil {
|
|
if errors.Is(err, lessons.ErrLessonNotFound) {
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Lesson not found", Error: err.Error()})
|
|
}
|
|
return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{Message: "Failed to list practices", Error: err.Error()})
|
|
}
|
|
return c.JSON(domain.Response{
|
|
Message: "Practices retrieved successfully",
|
|
Data: fiber.Map{
|
|
"practices": items,
|
|
"total_count": total,
|
|
"limit": limit,
|
|
"offset": offset,
|
|
},
|
|
Success: true,
|
|
StatusCode: fiber.StatusOK,
|
|
})
|
|
}
|
|
|
|
// GetPractice godoc
|
|
// @Tags practices
|
|
// @Param id path int true "Practice ID"
|
|
// @Router /api/v1/practices/{id} [get]
|
|
func (h *Handler) GetPractice(c *fiber.Ctx) error {
|
|
id, err := strconv.ParseInt(c.Params("id"), 10, 64)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{Message: "Invalid practice id", Error: err.Error()})
|
|
}
|
|
p, err := h.practiceSvc.GetByID(c.Context(), id)
|
|
if err != nil {
|
|
if errors.Is(err, practices.ErrPracticeNotFound) {
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Practice not found", Error: err.Error()})
|
|
}
|
|
return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{Message: "Failed to load practice", Error: err.Error()})
|
|
}
|
|
return c.JSON(domain.Response{Message: "Practice retrieved successfully", Data: p, Success: true, StatusCode: fiber.StatusOK})
|
|
}
|
|
|
|
// UpdatePractice godoc
|
|
// @Tags practices
|
|
// @Param id path int true "Practice ID"
|
|
// @Param body body domain.UpdatePracticeInput true "Fields to update (parent is immutable)"
|
|
// @Router /api/v1/practices/{id} [put]
|
|
func (h *Handler) UpdatePractice(c *fiber.Ctx) error {
|
|
id, err := strconv.ParseInt(c.Params("id"), 10, 64)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{Message: "Invalid practice id", Error: err.Error()})
|
|
}
|
|
var req domain.UpdatePracticeInput
|
|
if err := c.BodyParser(&req); err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{Message: "Invalid request body", Error: err.Error()})
|
|
}
|
|
p, err := h.practiceSvc.Update(c.Context(), id, req)
|
|
if err != nil {
|
|
if errors.Is(err, practices.ErrPracticeNotFound) {
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Practice not found", Error: err.Error()})
|
|
}
|
|
if errors.Is(err, practices.ErrQuestionSetNotFound) {
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Question set not found", Error: err.Error()})
|
|
}
|
|
if errors.Is(err, domain.ErrUserNotFound) {
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Persona user not found", Error: err.Error()})
|
|
}
|
|
return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{Message: "Failed to update practice", Error: err.Error()})
|
|
}
|
|
actorID := c.Locals("user_id").(int64)
|
|
actorRole := string(c.Locals("role").(domain.Role))
|
|
ip := c.IP()
|
|
ua := c.Get("User-Agent")
|
|
rid := p.ID
|
|
go h.activityLogSvc.RecordAction(context.Background(), &actorID, &actorRole, domain.ActionPracticeUpdated, domain.ResourcePractice, &rid, "Updated practice: "+p.Title, nil, &ip, &ua)
|
|
return c.JSON(domain.Response{Message: "Practice updated successfully", Data: p, Success: true, StatusCode: fiber.StatusOK})
|
|
}
|
|
|
|
// DeletePractice godoc
|
|
// @Tags practices
|
|
// @Param id path int true "Practice ID"
|
|
// @Router /api/v1/practices/{id} [delete]
|
|
func (h *Handler) DeletePractice(c *fiber.Ctx) error {
|
|
id, err := strconv.ParseInt(c.Params("id"), 10, 64)
|
|
if err != nil {
|
|
return c.Status(fiber.StatusBadRequest).JSON(domain.ErrorResponse{Message: "Invalid practice id", Error: err.Error()})
|
|
}
|
|
if err := h.practiceSvc.Delete(c.Context(), id); err != nil {
|
|
if errors.Is(err, practices.ErrPracticeNotFound) {
|
|
return c.Status(fiber.StatusNotFound).JSON(domain.ErrorResponse{Message: "Practice not found", Error: err.Error()})
|
|
}
|
|
return c.Status(fiber.StatusInternalServerError).JSON(domain.ErrorResponse{Message: "Failed to delete practice", Error: err.Error()})
|
|
}
|
|
actorID := c.Locals("user_id").(int64)
|
|
actorRole := string(c.Locals("role").(domain.Role))
|
|
ip := c.IP()
|
|
ua := c.Get("User-Agent")
|
|
go h.activityLogSvc.RecordAction(context.Background(), &actorID, &actorRole, domain.ActionPracticeDeleted, domain.ResourcePractice, &id, "Deleted practice", nil, &ip, &ua)
|
|
return c.JSON(domain.Response{Message: "Practice deleted successfully", Success: true, StatusCode: fiber.StatusOK})
|
|
}
|