15914461874

Committed 26 Jun 2025 11:20PM UTC coverage: 81.843% (-5.9%) from 87.722%

Build # 15914461874

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #49 from classconnect-grupo3/develop

Final merge (thank you for the ride)

Run Details

1542 of 2153 new or added lines in 24 files covered. (71.62%)

16 existing lines in 5 files now uncovered.

4548 of 5557 relevant lines covered (81.84%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.88

/src/controller/module_controller.go

package controller

import (
        "courses-service/src/model"
        "courses-service/src/schemas"
        "courses-service/src/service"
        "fmt"
        "log"
        "log/slog"
        "net/http"

        "github.com/gin-gonic/gin"
)

type ModuleController struct {
        service         service.ModuleServiceInterface
        activityService service.TeacherActivityServiceInterface
}

func NewModuleController(service service.ModuleServiceInterface, activityService service.TeacherActivityServiceInterface) *ModuleController {
        return &ModuleController{
                service:         service,
                activityService: activityService,
        }
}

// @Summary Module creation
// @Description Create a new module
// @Tags modules
// @Accept json
// @Produce json
// @Param module body schemas.CreateModuleRequest true "Module to create"
// @Success 201 {object} model.Module
// @Router /modules [post]
func (c *ModuleController) CreateModule(ctx *gin.Context) {
        slog.Debug("Creating module")

        var module schemas.CreateModuleRequest
        if err := ctx.ShouldBindJSON(&module); err != nil {
                slog.Error("Error binding JSON", "error", err)
                ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
                return
        }
        log.Printf("module: %v\n", module)

        createdModule, err := c.service.CreateModule(module)
        if err != nil {
                slog.Error("Error creating module", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        // Log activity if teacher is auxiliary
        teacherUUID := ctx.GetHeader("X-Teacher-UUID")
        if teacherUUID != "" {
                c.activityService.LogActivityIfAuxTeacher(
                        createdModule.CourseID,
                        teacherUUID,
                        "CREATE_MODULE",
                        fmt.Sprintf("Created module: %s", createdModule.Title),
                )
        }

        slog.Debug("Module created", "module", createdModule)
        ctx.JSON(http.StatusCreated, createdModule)
}

// @Summary Get modules by course ID
// @Description Get modules by course ID
// @Tags modules
// @Accept json
// @Produce json
// @Param courseId path string true "Course ID"
// @Success 200 {array} model.Module
// @Router /modules/course/{courseId} [get]
func (c *ModuleController) GetModulesByCourseId(ctx *gin.Context) {
        slog.Debug("Getting modules by course ID")
        courseId := ctx.Param("courseId")

        modules, err := c.service.GetModulesByCourseId(courseId)
        if err != nil {
                slog.Error("Error getting modules by course ID", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        slog.Debug("Modules retrieved", "modules", modules)
        ctx.JSON(http.StatusOK, modules)
}

// @Summary Get a module by ID
// @Description Get a module by ID
// @Tags modules
// @Accept json
// @Produce json
// @Param id path string true "Module ID"
// @Success 200 {object} model.Module
// @Router /modules/{id} [get]
func (c *ModuleController) GetModuleById(ctx *gin.Context) {
        slog.Debug("Getting module by ID")
        id := ctx.Param("id")

        module, err := c.service.GetModuleById(id)
        if err != nil {
                slog.Error("Error getting module by ID", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        slog.Debug("Module retrieved", "module", module)
        ctx.JSON(http.StatusOK, module)
}

// @Summary Update a module
// @Description Update a module by ID
// @Tags modules
// @Accept json
// @Produce json
// @Param id path string true "Module ID"
// @Param module body schemas.UpdateModuleRequest true "Module to update"
// @Success 200 {object} model.Module
// @Router /modules/{id} [put]
func (c *ModuleController) UpdateModule(ctx *gin.Context) {
        slog.Debug("Updating module")
        id := ctx.Param("id")

        var module model.Module
        if err := ctx.ShouldBindJSON(&module); err != nil {
                slog.Error("Error binding JSON", "error", err)
                ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
                return
        }

        updatedModule, err := c.service.UpdateModule(id, module)
        if err != nil {
                slog.Error("Error updating module", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        // Log activity if teacher is auxiliary
        teacherUUID := ctx.GetHeader("X-Teacher-UUID")
        if teacherUUID != "" {
                c.activityService.LogActivityIfAuxTeacher(
                        updatedModule.CourseID,
                        teacherUUID,
                        "UPDATE_MODULE",
                        fmt.Sprintf("Updated module: %s", updatedModule.Title),
                )
        }

        slog.Debug("Module updated", "module", updatedModule)
        ctx.JSON(http.StatusOK, updatedModule)
}

// @Summary Delete a module
// @Description Delete a module by ID
// @Tags modules
// @Accept json
// @Produce json
// @Param id path string true "Module ID"
// @Success 204 {string} string "Module deleted successfully"
// @Router /modules/{id} [delete]
func (c *ModuleController) DeleteModule(ctx *gin.Context) {
        slog.Debug("Deleting module")
        id := ctx.Param("id")

        // Get module info before deleting for logging
        moduleToDelete, err := c.service.GetModuleById(id)
        if err != nil {
                slog.Error("Error getting module for deletion", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        err = c.service.DeleteModule(id)
        if err != nil {
                slog.Error("Error deleting module", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        // Log activity if teacher is auxiliary
        teacherUUID := ctx.GetHeader("X-Teacher-UUID")
        if teacherUUID != "" && moduleToDelete != nil {
                c.activityService.LogActivityIfAuxTeacher(
                        moduleToDelete.CourseID,
                        teacherUUID,
                        "DELETE_MODULE",
                        fmt.Sprintf("Deleted module: %s", moduleToDelete.Title),
                )
        }

        slog.Debug("Module deleted", "id", id)
        ctx.JSON(http.StatusNoContent, nil)
}

1	package controller
2
3	import (
4	"courses-service/src/model"
5	"courses-service/src/schemas"
6	"courses-service/src/service"
7	"fmt"
8	"log"
9	"log/slog"
10	"net/http"
11
12	"github.com/gin-gonic/gin"
13	)
14
15	type ModuleController struct {
16	service service.ModuleServiceInterface
17	activityService service.TeacherActivityServiceInterface
18	}
19
20	func NewModuleController(service service.ModuleServiceInterface, activityService service.TeacherActivityServiceInterface) *ModuleController {	1✔
21	return &ModuleController{	1✔
22	service: service,	1✔
23	activityService: activityService,	1✔
24	}	1✔
25	}	1✔
26
27	// @Summary Module creation
28	// @Description Create a new module
29	// @Tags modules
30	// @Accept json
31	// @Produce json
32	// @Param module body schemas.CreateModuleRequest true "Module to create"
33	// @Success 201 {object} model.Module
34	// @Router /modules [post]
35	func (c ModuleController) CreateModule(ctx gin.Context) {	1✔
36	slog.Debug("Creating module")	1✔
37		1✔
38	var module schemas.CreateModuleRequest	1✔
39	if err := ctx.ShouldBindJSON(&module); err != nil {	2✔
40	slog.Error("Error binding JSON", "error", err)	1✔
41	ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})	1✔
42	return	1✔
43	}	1✔
44	log.Printf("module: %v\n", module)	1✔
45		1✔
46	createdModule, err := c.service.CreateModule(module)	1✔
47	if err != nil {	2✔
48	slog.Error("Error creating module", "error", err)	1✔
49	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
50	return	1✔
51	}	1✔
52
53	// Log activity if teacher is auxiliary
54	teacherUUID := ctx.GetHeader("X-Teacher-UUID")	1✔
55	if teacherUUID != "" {	1✔
NEW 56	c.activityService.LogActivityIfAuxTeacher(	×
NEW 57	createdModule.CourseID,	×
NEW 58	teacherUUID,	×
NEW 59	"CREATE_MODULE",	×
NEW 60	fmt.Sprintf("Created module: %s", createdModule.Title),	×
NEW 61	)	×
NEW 62	}	×
63
64	slog.Debug("Module created", "module", createdModule)	1✔
65	ctx.JSON(http.StatusCreated, createdModule)	1✔
66	}
67
68	// @Summary Get modules by course ID
69	// @Description Get modules by course ID
70	// @Tags modules
71	// @Accept json
72	// @Produce json
73	// @Param courseId path string true "Course ID"
74	// @Success 200 {array} model.Module
75	// @Router /modules/course/{courseId} [get]
76	func (c ModuleController) GetModulesByCourseId(ctx gin.Context) {	1✔
77	slog.Debug("Getting modules by course ID")	1✔
78	courseId := ctx.Param("courseId")	1✔
79		1✔
80	modules, err := c.service.GetModulesByCourseId(courseId)	1✔
81	if err != nil {	2✔
82	slog.Error("Error getting modules by course ID", "error", err)	1✔
83	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
84	return	1✔
85	}	1✔
86
87	slog.Debug("Modules retrieved", "modules", modules)	1✔
88	ctx.JSON(http.StatusOK, modules)	1✔
89	}
90
91	// @Summary Get a module by ID
92	// @Description Get a module by ID
93	// @Tags modules
94	// @Accept json
95	// @Produce json
96	// @Param id path string true "Module ID"
97	// @Success 200 {object} model.Module
98	// @Router /modules/{id} [get]
99	func (c ModuleController) GetModuleById(ctx gin.Context) {	1✔
100	slog.Debug("Getting module by ID")	1✔
101	id := ctx.Param("id")	1✔
102		1✔
103	module, err := c.service.GetModuleById(id)	1✔
104	if err != nil {	2✔
105	slog.Error("Error getting module by ID", "error", err)	1✔
106	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
107	return	1✔
108	}	1✔
109
110	slog.Debug("Module retrieved", "module", module)	1✔
111	ctx.JSON(http.StatusOK, module)	1✔
112	}
113
114	// @Summary Update a module
115	// @Description Update a module by ID
116	// @Tags modules
117	// @Accept json
118	// @Produce json
119	// @Param id path string true "Module ID"
120	// @Param module body schemas.UpdateModuleRequest true "Module to update"
121	// @Success 200 {object} model.Module
122	// @Router /modules/{id} [put]
123	func (c ModuleController) UpdateModule(ctx gin.Context) {	1✔
124	slog.Debug("Updating module")	1✔
125	id := ctx.Param("id")	1✔
126		1✔
127	var module model.Module	1✔
128	if err := ctx.ShouldBindJSON(&module); err != nil {	2✔
129	slog.Error("Error binding JSON", "error", err)	1✔
130	ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})	1✔
131	return	1✔
132	}	1✔
133
134	updatedModule, err := c.service.UpdateModule(id, module)	1✔
135	if err != nil {	2✔
136	slog.Error("Error updating module", "error", err)	1✔
137	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
138	return	1✔
139	}	1✔
140
141	// Log activity if teacher is auxiliary
142	teacherUUID := ctx.GetHeader("X-Teacher-UUID")	1✔
143	if teacherUUID != "" {	1✔
NEW 144	c.activityService.LogActivityIfAuxTeacher(	×
NEW 145	updatedModule.CourseID,	×
NEW 146	teacherUUID,	×
NEW 147	"UPDATE_MODULE",	×
NEW 148	fmt.Sprintf("Updated module: %s", updatedModule.Title),	×
NEW 149	)	×
NEW 150	}	×
151
152	slog.Debug("Module updated", "module", updatedModule)	1✔
153	ctx.JSON(http.StatusOK, updatedModule)	1✔
154	}
155
156	// @Summary Delete a module
157	// @Description Delete a module by ID
158	// @Tags modules
159	// @Accept json
160	// @Produce json
161	// @Param id path string true "Module ID"
162	// @Success 204 {string} string "Module deleted successfully"
163	// @Router /modules/{id} [delete]
164	func (c ModuleController) DeleteModule(ctx gin.Context) {	1✔
165	slog.Debug("Deleting module")	1✔
166	id := ctx.Param("id")	1✔
167		1✔
168	// Get module info before deleting for logging	1✔
169	moduleToDelete, err := c.service.GetModuleById(id)	1✔
170	if err != nil {	2✔
171	slog.Error("Error getting module for deletion", "error", err)	1✔
172	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
173	return	1✔
174	}	1✔
175
176	err = c.service.DeleteModule(id)	1✔
177	if err != nil {	1✔
UNCOV 178	slog.Error("Error deleting module", "error", err)	×
UNCOV 179	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	×
UNCOV 180	return	×
UNCOV 181	}	×
182
183	// Log activity if teacher is auxiliary
184	teacherUUID := ctx.GetHeader("X-Teacher-UUID")	1✔
185	if teacherUUID != "" && moduleToDelete != nil {	1✔
NEW 186	c.activityService.LogActivityIfAuxTeacher(	×
NEW 187	moduleToDelete.CourseID,	×
NEW 188	teacherUUID,	×
NEW 189	"DELETE_MODULE",	×
NEW 190	fmt.Sprintf("Deleted module: %s", moduleToDelete.Title),	×
NEW 191	)	×
NEW 192	}	×
193
194	slog.Debug("Module deleted", "id", id)	1✔
195	ctx.JSON(http.StatusNoContent, nil)	1✔
196	}

classconnect-grupo3 / courses-service / 15914461874

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous