15892480990

Committed 26 Jun 2025 03:46AM UTC coverage: 74.755% (-2.0%) from 76.8%

Build # 15892480990

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #47 from classconnect-grupo3/features/log-aux-teachers-activity

Features/log aux teachers activity

Run Details

133 of 299 new or added lines in 10 files covered. (44.48%)

10 existing lines in 3 files now uncovered.

4051 of 5419 relevant lines covered (74.76%)

0.83 hits per line

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

78.99

/src/controller/assignments_controller.go

package controller

import (
        "fmt"
        "log"
        "log/slog"
        "net/http"

        "courses-service/src/queues"
        "courses-service/src/schemas"
        "courses-service/src/service"

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

type AssignmentsController struct {
        service            service.AssignmentServiceInterface
        notificationsQueue queues.NotificationsQueueInterface
        activityService    service.TeacherActivityServiceInterface
}

func NewAssignmentsController(
        service service.AssignmentServiceInterface,
        notificationsQueue queues.NotificationsQueueInterface,
        activityService service.TeacherActivityServiceInterface,
) *AssignmentsController {
        return &AssignmentsController{
                service:            service,
                notificationsQueue: notificationsQueue,
                activityService:    activityService,
        }
}

// @Summary Get all assignments
// @Description Get all assignments
// @Tags assignments
// @Accept json
// @Produce json
// @Router /assignments [get]
// @Success 200 {array} model.Assignment
func (c *AssignmentsController) GetAssignments(ctx *gin.Context) {
        slog.Debug("Getting assignments")

        assignments, err := c.service.GetAssignments()
        if err != nil {
                slog.Error("Error getting assignments", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        slog.Debug("Assignments retrieved", "assignments", assignments)
        ctx.JSON(http.StatusOK, assignments)
}

// @Summary Create an assignment
// @Description Create an assignment
// @Tags assignments
// @Accept json
// @Produce json
// @Param assignment body schemas.CreateAssignmentRequest true "Assignment to create"
// @Success 201 {object} model.Assignment
// @Router /assignments [post]
func (c *AssignmentsController) CreateAssignment(ctx *gin.Context) {
        log.Println("Creating assignment")

        var assignment schemas.CreateAssignmentRequest
        if err := ctx.ShouldBindJSON(&assignment); err != nil {
                log.Println("Error binding JSON:", err)
                ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
                return
        }

        createdAssignment, err := c.service.CreateAssignment(assignment)
        if err != nil {
                log.Println("Error creating assignment:", 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(
                        createdAssignment.CourseID,
                        teacherUUID,
                        "CREATE_ASSIGNMENT",
                        fmt.Sprintf("Created assignment: %s", createdAssignment.Title),
                )
        }

        queueMessage := queues.NewAssignmentCreatedMessage(
                createdAssignment.CourseID,
                createdAssignment.ID.Hex(),
                createdAssignment.Title,
                createdAssignment.DueDate,
        )
        err = c.notificationsQueue.Publish(queueMessage)
        if err != nil {
                log.Println("Error publishing message:", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        log.Println("Assignment created:", createdAssignment.ID)
        ctx.JSON(http.StatusCreated, createdAssignment)
}

// @Summary Get an assignment by ID
// @Description Get an assignment by ID
// @Tags assignments
// @Accept json
// @Produce json
// @Param assignmentId path string true "Assignment ID"
// @Success 200 {object} model.Assignment
// @Router /assignments/{assignmentId} [get]
func (c *AssignmentsController) GetAssignmentById(ctx *gin.Context) {
        slog.Debug("Getting assignment by ID")
        id := ctx.Param("assignmentId")

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

        if assignment == nil {
                ctx.JSON(http.StatusNotFound, gin.H{"error": "assignment not found"})
                return
        }

        slog.Debug("Assignment retrieved", "assignment", assignment)
        ctx.JSON(http.StatusOK, assignment)
}

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

        assignments, err := c.service.GetAssignmentsByCourseId(courseId)
        if err != nil {
                slog.Error("Error getting assignments", "error", err)
                ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
                return
        }

        slog.Debug("Assignments retrieved", "assignments", assignments)
        ctx.JSON(http.StatusOK, assignments)
}

// @Summary Update an assignment
// @Description Update an assignment by ID
// @Tags assignments
// @Accept json
// @Produce json
// @Param assignmentId path string true "Assignment ID"
// @Param assignment body schemas.UpdateAssignmentRequest true "Assignment to update"
// @Success 200 {object} model.Assignment
// @Router /assignments/{assignmentId} [put]
func (c *AssignmentsController) UpdateAssignment(ctx *gin.Context) {
        slog.Debug("Updating assignment")
        id := ctx.Param("assignmentId")

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

        updatedAssignment, err := c.service.UpdateAssignment(id, updateAssignmentRequest)
        if err != nil {
                slog.Error("Error updating assignment", "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(
                        updatedAssignment.CourseID,
                        teacherUUID,
                        "UPDATE_ASSIGNMENT",
                        fmt.Sprintf("Updated assignment: %s", updatedAssignment.Title),
                )
        }

        slog.Debug("Assignment updated", "assignment", updatedAssignment)
        ctx.JSON(http.StatusOK, updatedAssignment)
}

// @Summary Delete an assignment
// @Description Delete an assignment by ID
// @Tags assignments
// @Accept json
// @Produce json
// @Param assignmentId path string true "Assignment ID"
// @Success 200 {string} string "Assignment deleted successfully"
// @Router /assignments/{assignmentId} [delete]
func (c *AssignmentsController) DeleteAssignment(ctx *gin.Context) {
        slog.Debug("Deleting assignment")
        id := ctx.Param("assignmentId")

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

        if err := c.service.DeleteAssignment(id); err != nil {
                slog.Error("Error deleting assignment", "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 != "" && assignment != nil {
                c.activityService.LogActivityIfAuxTeacher(
                        assignment.CourseID,
                        teacherUUID,
                        "DELETE_ASSIGNMENT",
                        fmt.Sprintf("Deleted assignment: %s", assignment.Title),
                )
        }

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

1	package controller
2
3	import (
4	"fmt"
5	"log"
6	"log/slog"
7	"net/http"
8
9	"courses-service/src/queues"
10	"courses-service/src/schemas"
11	"courses-service/src/service"
12
13	"github.com/gin-gonic/gin"
14	)
15
16	type AssignmentsController struct {
17	service service.AssignmentServiceInterface
18	notificationsQueue queues.NotificationsQueueInterface
19	activityService service.TeacherActivityServiceInterface
20	}
21
22	func NewAssignmentsController(
23	service service.AssignmentServiceInterface,
24	notificationsQueue queues.NotificationsQueueInterface,
25	activityService service.TeacherActivityServiceInterface,
26	) *AssignmentsController {	1✔
27	return &AssignmentsController{	1✔
28	service: service,	1✔
29	notificationsQueue: notificationsQueue,	1✔
30	activityService: activityService,	1✔
31	}	1✔
32	}	1✔
33
34	// @Summary Get all assignments
35	// @Description Get all assignments
36	// @Tags assignments
37	// @Accept json
38	// @Produce json
39	// @Router /assignments [get]
40	// @Success 200 {array} model.Assignment
41	func (c AssignmentsController) GetAssignments(ctx gin.Context) {	1✔
42	slog.Debug("Getting assignments")	1✔
43		1✔
44	assignments, err := c.service.GetAssignments()	1✔
45	if err != nil {	2✔
46	slog.Error("Error getting assignments", "error", err)	1✔
47	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
48	return	1✔
49	}	1✔
50
51	slog.Debug("Assignments retrieved", "assignments", assignments)	1✔
52	ctx.JSON(http.StatusOK, assignments)	1✔
53	}
54
55	// @Summary Create an assignment
56	// @Description Create an assignment
57	// @Tags assignments
58	// @Accept json
59	// @Produce json
60	// @Param assignment body schemas.CreateAssignmentRequest true "Assignment to create"
61	// @Success 201 {object} model.Assignment
62	// @Router /assignments [post]
63	func (c AssignmentsController) CreateAssignment(ctx gin.Context) {	1✔
64	log.Println("Creating assignment")	1✔
65		1✔
66	var assignment schemas.CreateAssignmentRequest	1✔
67	if err := ctx.ShouldBindJSON(&assignment); err != nil {	2✔
68	log.Println("Error binding JSON:", err)	1✔
69	ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})	1✔
70	return	1✔
71	}	1✔
72
73	createdAssignment, err := c.service.CreateAssignment(assignment)	1✔
74	if err != nil {	2✔
75	log.Println("Error creating assignment:", err)	1✔
76	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
77	return	1✔
78	}	1✔
79
80	// Log activity if teacher is auxiliary
81	teacherUUID := ctx.GetHeader("X-Teacher-UUID")	1✔
82	if teacherUUID != "" {	1✔
NEW 83	c.activityService.LogActivityIfAuxTeacher(	×
NEW 84	createdAssignment.CourseID,	×
NEW 85	teacherUUID,	×
NEW 86	"CREATE_ASSIGNMENT",	×
NEW 87	fmt.Sprintf("Created assignment: %s", createdAssignment.Title),	×
NEW 88	)	×
NEW 89	}	×
90
91	queueMessage := queues.NewAssignmentCreatedMessage(	1✔
92	createdAssignment.CourseID,	1✔
93	createdAssignment.ID.Hex(),	1✔
94	createdAssignment.Title,	1✔
95	createdAssignment.DueDate,	1✔
96	)	1✔
97	err = c.notificationsQueue.Publish(queueMessage)	1✔
98	if err != nil {	1✔
99	log.Println("Error publishing message:", err)	×
100	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	×
101	return	×
102	}	×
103
104	log.Println("Assignment created:", createdAssignment.ID)	1✔
105	ctx.JSON(http.StatusCreated, createdAssignment)	1✔
106	}
107
108	// @Summary Get an assignment by ID
109	// @Description Get an assignment by ID
110	// @Tags assignments
111	// @Accept json
112	// @Produce json
113	// @Param assignmentId path string true "Assignment ID"
114	// @Success 200 {object} model.Assignment
115	// @Router /assignments/{assignmentId} [get]
116	func (c AssignmentsController) GetAssignmentById(ctx gin.Context) {	1✔
117	slog.Debug("Getting assignment by ID")	1✔
118	id := ctx.Param("assignmentId")	1✔
119		1✔
120	assignment, err := c.service.GetAssignmentById(id)	1✔
121	if err != nil {	2✔
122	slog.Error("Error getting assignment", "error", err)	1✔
123	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
124	return	1✔
125	}	1✔
126
127	if assignment == nil {	2✔
128	ctx.JSON(http.StatusNotFound, gin.H{"error": "assignment not found"})	1✔
129	return	1✔
130	}	1✔
131
132	slog.Debug("Assignment retrieved", "assignment", assignment)	1✔
133	ctx.JSON(http.StatusOK, assignment)	1✔
134	}
135
136	// @Summary Get assignments by course ID
137	// @Description Get assignments by course ID
138	// @Tags assignments
139	// @Accept json
140	// @Produce json
141	// @Param courseId path string true "Course ID"
142	// @Success 200 {array} model.Assignment
143	// @Router /assignments/course/{courseId} [get]
144	func (c AssignmentsController) GetAssignmentsByCourseId(ctx gin.Context) {	1✔
145	slog.Debug("Getting assignments by course ID")	1✔
146	courseId := ctx.Param("courseId")	1✔
147		1✔
148	assignments, err := c.service.GetAssignmentsByCourseId(courseId)	1✔
149	if err != nil {	2✔
150	slog.Error("Error getting assignments", "error", err)	1✔
151	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
152	return	1✔
153	}	1✔
154
155	slog.Debug("Assignments retrieved", "assignments", assignments)	1✔
156	ctx.JSON(http.StatusOK, assignments)	1✔
157	}
158
159	// @Summary Update an assignment
160	// @Description Update an assignment by ID
161	// @Tags assignments
162	// @Accept json
163	// @Produce json
164	// @Param assignmentId path string true "Assignment ID"
165	// @Param assignment body schemas.UpdateAssignmentRequest true "Assignment to update"
166	// @Success 200 {object} model.Assignment
167	// @Router /assignments/{assignmentId} [put]
168	func (c AssignmentsController) UpdateAssignment(ctx gin.Context) {	1✔
169	slog.Debug("Updating assignment")	1✔
170	id := ctx.Param("assignmentId")	1✔
171		1✔
172	var updateAssignmentRequest schemas.UpdateAssignmentRequest	1✔
173	if err := ctx.ShouldBindJSON(&updateAssignmentRequest); err != nil {	2✔
174	slog.Error("Error binding JSON", "error", err)	1✔
175	ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})	1✔
176	return	1✔
177	}	1✔
178
179	updatedAssignment, err := c.service.UpdateAssignment(id, updateAssignmentRequest)	1✔
180	if err != nil {	2✔
181	slog.Error("Error updating assignment", "error", err)	1✔
182	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
183	return	1✔
184	}	1✔
185
186	// Log activity if teacher is auxiliary
187	teacherUUID := ctx.GetHeader("X-Teacher-UUID")	1✔
188	if teacherUUID != "" {	1✔
NEW 189	c.activityService.LogActivityIfAuxTeacher(	×
NEW 190	updatedAssignment.CourseID,	×
NEW 191	teacherUUID,	×
NEW 192	"UPDATE_ASSIGNMENT",	×
NEW 193	fmt.Sprintf("Updated assignment: %s", updatedAssignment.Title),	×
NEW 194	)	×
NEW 195	}	×
196
197	slog.Debug("Assignment updated", "assignment", updatedAssignment)	1✔
198	ctx.JSON(http.StatusOK, updatedAssignment)	1✔
199	}
200
201	// @Summary Delete an assignment
202	// @Description Delete an assignment by ID
203	// @Tags assignments
204	// @Accept json
205	// @Produce json
206	// @Param assignmentId path string true "Assignment ID"
207	// @Success 200 {string} string "Assignment deleted successfully"
208	// @Router /assignments/{assignmentId} [delete]
209	func (c AssignmentsController) DeleteAssignment(ctx gin.Context) {	1✔
210	slog.Debug("Deleting assignment")	1✔
211	id := ctx.Param("assignmentId")	1✔
212		1✔
213	// Get assignment info before deleting for logging	1✔
214	assignment, err := c.service.GetAssignmentById(id)	1✔
215	if err != nil {	2✔
216	slog.Error("Error getting assignment for deletion", "error", err)	1✔
217	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	1✔
218	return	1✔
219	}	1✔
220
221	if err := c.service.DeleteAssignment(id); err != nil {	1✔
UNCOV 222	slog.Error("Error deleting assignment", "error", err)	×
UNCOV 223	ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})	×
UNCOV 224	return	×
UNCOV 225	}	×
226
227	// Log activity if teacher is auxiliary
228	teacherUUID := ctx.GetHeader("X-Teacher-UUID")	1✔
229	if teacherUUID != "" && assignment != nil {	1✔
NEW 230	c.activityService.LogActivityIfAuxTeacher(	×
NEW 231	assignment.CourseID,	×
NEW 232	teacherUUID,	×
NEW 233	"DELETE_ASSIGNMENT",	×
NEW 234	fmt.Sprintf("Deleted assignment: %s", assignment.Title),	×
NEW 235	)	×
NEW 236	}	×
237
238	slog.Debug("Assignment deleted")	1✔
239	ctx.JSON(http.StatusNoContent, nil)	1✔
240	}

classconnect-grupo3 / courses-service / 15892480990

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