feat: Delete markdown block (#131)

* feat(blocks): Add endpoint to delete markdown block

* test(blocks): Add test to ensure teachers can delete markdown blocks

__tests__/integration/blocks_test.go

@@ -27,7 +27,7 @@ func TestUpdateMarkdownBlockContent(t *testing.T) {
 		"name":         "Update markdown block content test - laboratory",
 		"course_uuid":  courseUUID,
 		"opening_date": "2023-12-01T08:00",
-		"due_date":     "2023-12-01T12:00",
+		"due_date":     "3023-12-01T12:00",
 	})
 	c.Equal(http.StatusCreated, status)
 	laboratoryUUID := laboratoryCreationResponse["uuid"].(string)
@@ -68,6 +68,51 @@ func TestUpdateMarkdownBlockContent(t *testing.T) {
 	c.Equal("# Updated main title", block["content"].(string))
 }
 
+func TestDeleteMarkdownBlock(t *testing.T) {
+	c := require.New(t)
+
+	// Login as a teacher
+	w, r := PrepareRequest("POST", "/api/v1/session/login", map[string]interface{}{
+		"email":    registeredTeacherEmail,
+		"password": registeredTeacherPass,
+	})
+	router.ServeHTTP(w, r)
+	cookie := w.Result().Cookies()[0]
+
+	// Create a course
+	courseUUID, status := CreateCourse("Delete markdown block test - course")
+	c.Equal(http.StatusCreated, status)
+
+	// Create a laboratory
+	laboratoryCreationResponse, status := CreateLaboratory(cookie, map[string]interface{}{
+		"name":         "Delete markdown block test - laboratory",
+		"course_uuid":  courseUUID,
+		"opening_date": "2023-12-01T08:00",
+		"due_date":     "3023-12-01T12:00",
+	})
+	c.Equal(http.StatusCreated, status)
+	laboratoryUUID := laboratoryCreationResponse["uuid"].(string)
+
+	// Create a markdown block
+	blockCreationResponse, status := CreateMarkdownBlock(cookie, laboratoryUUID)
+	c.Equal(http.StatusCreated, status)
+	markdownBlockUUID := blockCreationResponse["uuid"].(string)
+
+	// Get the laboratory
+	response, status := GetLaboratoryByUUID(cookie, laboratoryUUID)
+	c.Equal(http.StatusOK, status)
+	c.Equal(1, len(response["markdown_blocks"].([]interface{})))
+
+	// Delete the markdown block
+	_, status = DeleteMarkdownBlock(cookie, markdownBlockUUID)
+	c.Equal(http.StatusNoContent, status)
+
+	// Verify that the block was deleted
+	response, status = GetLaboratoryByUUID(cookie, laboratoryUUID)
+	c.Equal(http.StatusOK, status)
+	c.Equal(0, len(response["markdown_blocks"].([]interface{})))
+}
+
 func TestUpdateTestBlock(t *testing.T) {
 	c := require.New(t)
 

__tests__/integration/blocks_utils_test.go

@@ -20,6 +20,16 @@ func UpdateMarkdownBlockContent(cookie *http.Cookie, blockUUID string, payload m
 	return jsonResponse, w.Code
 }
 
+func DeleteMarkdownBlock(cookie *http.Cookie, blockUUID string) (response map[string]interface{}, statusCode int) {
+	endpoint := fmt.Sprintf("/api/v1/blocks/markdown_blocks/%s", blockUUID)
+	w, r := PrepareRequest("DELETE", endpoint, nil)
+	r.AddCookie(cookie)
+	router.ServeHTTP(w, r)
+
+	jsonResponse := ParseJsonResponse(w.Body)
+	return jsonResponse, w.Code
+}
+
 type UpdateTestBlockUtilsDTO struct {
 	blockUUID    string
 	languageUUID string

__tests__/integration/laboratorires_test.go

@@ -38,7 +38,7 @@ func TestCreateLaboratory(t *testing.T) {
 				"name":         "Create laboratory test - laboratory",
 				"course_uuid":  courseUUID,
 				"opening_date": "2023-12-01T08:00",
-				"due_date":     "2023-12-01T12:00",
+				"due_date":     "3023-12-01T12:00",
 			},
 			ExpectedStatusCode: http.StatusCreated,
 		},
@@ -231,7 +231,7 @@ func TestCreateMarkdownBlock(t *testing.T) {
 		"name":         "Create markdown block test - laboratory",
 		"course_uuid":  courseUUID,
 		"opening_date": "2023-12-01T08:00",
-		"due_date":     "2023-12-01T12:00",
+		"due_date":     "3023-12-01T12:00",
 	})
 	laboratoryUUID := laboratoryCreationResponse["uuid"].(string)
 	c.Equal(http.StatusCreated, status)

docs/bruno/blocks/delete-markdown-block.bru

@@ -0,0 +1,11 @@
+meta {
+  name: delete-markdown-block
+  type: http
+  seq: 2
+}
+
+delete {
+  url: {{BASE_URL}}/blocks/markdown_blocks/eb4ef0ee-3865-44c3-8d52-2620fb2653e5
+  body: none
+  auth: none
+}

src/blocks/application/use_cases.go

@@ -62,3 +62,18 @@ func (useCases *BlocksUseCases) UpdateTestBlock(dto dtos.UpdateTestBlockDTO) (er
 	// Update the block
 	return useCases.BlocksRepository.UpdateTestBlock(&dto)
 }
+
+func (useCases *BlocksUseCases) DeleteMarkdownBlock(dto dtos.DeleteBlockDTO) (err error) {
+	// Validate the teacher is the owner of the block
+	ownsBlock, err := useCases.BlocksRepository.DoesTeacherOwnsMarkdownBlock(dto.TeacherUUID, dto.BlockUUID)
+	if err != nil {
+		return err
+	}
+
+	if !ownsBlock {
+		return errors.TeacherDoesNotOwnBlock{}
+	}
+
+	// Delete the block
+	return useCases.BlocksRepository.DeleteMarkdownBlock(dto.BlockUUID)
+}

src/blocks/domain/definitions/blocks_repository.go

@@ -10,7 +10,7 @@ type BlockRepository interface {
 	// Update the markdown text of a markdown block
 	UpdateMarkdownBlockContent(blockUUID string, content string) (err error)
 
-	// Functions to check blocks ownership
+	// Check blocks ownership
 	DoesTeacherOwnsMarkdownBlock(teacherUUID string, blockUUID string) (bool, error)
 	DoesTeacherOwnsTestBlock(teacherUUID string, blockUUID string) (bool, error)
 
@@ -25,4 +25,8 @@ type BlockRepository interface {
 
 	// Update the test block information in the database
 	UpdateTestBlock(*dtos.UpdateTestBlockDTO) (err error)
+
+	// Delete blocks
+	DeleteMarkdownBlock(blockUUID string) (err error)
+	DeleteTestBlock(blockUUID string) (err error)
 }

src/blocks/domain/dtos/blocks_dtos.go

@@ -15,3 +15,8 @@ type UpdateTestBlockDTO struct {
 	Name           string
 	NewTestArchive *multipart.File
 }
+
+type DeleteBlockDTO struct {
+	TeacherUUID string
+	BlockUUID   string
+}

src/blocks/infrastructure/http/controllers.go

@@ -125,3 +125,28 @@ func (controller *BlocksController) HandleUpdateTestBlock(c *gin.Context) {
 
 	c.Status(http.StatusNoContent)
 }
+
+func (controller *BlocksController) HandleDeleteMarkdownBlock(c *gin.Context) {
+	teacherUUID := c.GetString("session_uuid")
+	blockUUID := c.Param("block_uuid")
+
+	// Validate the block UUID
+	if err := sharedInfrastructure.GetValidator().Var(blockUUID, "uuid4"); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"message": "Block UUID is not valid",
+		})
+		return
+	}
+
+	// Delete the block
+	err := controller.UseCases.DeleteMarkdownBlock(dtos.DeleteBlockDTO{
+		TeacherUUID: teacherUUID,
+		BlockUUID:   blockUUID,
+	})
+	if err != nil {
+		c.Error(err)
+		return
+	}
+
+	c.Status(http.StatusNoContent)
+}

src/blocks/infrastructure/http/routes.go

@@ -33,4 +33,11 @@ func StartBlocksRoutes(g *gin.RouterGroup) {
 		sharedInfrastructure.WithAuthorizationMiddleware([]string{"teacher"}),
 		controller.HandleUpdateTestBlock,
 	)
+
+	blocksGroup.DELETE(
+		"/markdown_blocks/:block_uuid",
+		sharedInfrastructure.WithAuthenticationMiddleware(),
+		sharedInfrastructure.WithAuthorizationMiddleware([]string{"teacher"}),
+		controller.HandleDeleteMarkdownBlock,
+	)
 }

src/blocks/infrastructure/implementations/blocks_repository.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/UPB-Code-Labs/main-api/src/blocks/domain/dtos"
 	"github.com/UPB-Code-Labs/main-api/src/blocks/domain/errors"
+	laboratoriesDomainErrors "github.com/UPB-Code-Labs/main-api/src/laboratories/domain/errors"
 	sharedDomainErrors "github.com/UPB-Code-Labs/main-api/src/shared/domain/errors"
 	sharedInfrastructure "github.com/UPB-Code-Labs/main-api/src/shared/infrastructure"
 )
@@ -64,7 +65,7 @@ func (repository *BlocksPostgresRepository) DoesTeacherOwnsMarkdownBlock(teacher
 	var laboratoryUUID string
 	if err := row.Scan(&laboratoryUUID); err != nil {
 		if err == sql.ErrNoRows {
-			return false, nil
+			return false, errors.BlockNotFound{}
 		}
 	}
 
@@ -83,7 +84,7 @@ func (repository *BlocksPostgresRepository) DoesTeacherOwnsMarkdownBlock(teacher
 	var laboratoryTeacherUUID string
 	if err := row.Scan(&laboratoryTeacherUUID); err != nil {
 		if err == sql.ErrNoRows {
-			return false, nil
+			return false, laboratoriesDomainErrors.LaboratoryNotFoundError{}
 		}
 	}
 
@@ -105,7 +106,7 @@ func (repository *BlocksPostgresRepository) DoesTeacherOwnsTestBlock(teacherUUID
 	var laboratoryUUID string
 	if err := row.Scan(&laboratoryUUID); err != nil {
 		if err == sql.ErrNoRows {
-			return false, nil
+			return false, &errors.BlockNotFound{}
 		}
 	}
 
@@ -124,7 +125,7 @@ func (repository *BlocksPostgresRepository) DoesTeacherOwnsTestBlock(teacherUUID
 	var laboratoryTeacherUUID string
 	if err := row.Scan(&laboratoryTeacherUUID); err != nil {
 		if err == sql.ErrNoRows {
-			return false, nil
+			return false, laboratoriesDomainErrors.LaboratoryNotFoundError{}
 		}
 	}
 
@@ -334,3 +335,80 @@ func (repository *BlocksPostgresRepository) UpdateTestBlock(dto *dtos.UpdateTest
 
 	return nil
 }
+
+func (repository *BlocksPostgresRepository) DeleteMarkdownBlock(blockUUID string) (err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+
+	// Get the UUID of the block index
+	query := `
+		SELECT block_index_id
+		FROM markdown_blocks
+		WHERE id = $1
+	`
+
+	row := repository.Connection.QueryRowContext(ctx, query, blockUUID)
+	var blockIndexUUID string
+	if err := row.Scan(&blockIndexUUID); err != nil {
+		if err == sql.ErrNoRows {
+			return &errors.BlockNotFound{}
+		}
+
+		return err
+	}
+
+	// After deleting the block index, the block will be deleted automatically due to the `ON DELETE CASCADE` constraint
+	err = repository.deleteBlockIndex(blockIndexUUID)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (repository *BlocksPostgresRepository) DeleteTestBlock(blockUUID string) (err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+
+	// Get the UUID of the block index
+	query := `
+		SELECT block_index_id
+		FROM test_blocks
+		WHERE id = $1
+	`
+
+	row := repository.Connection.QueryRowContext(ctx, query, blockUUID)
+	var blockIndexUUID string
+	if err := row.Scan(&blockIndexUUID); err != nil {
+		if err == sql.ErrNoRows {
+			return &errors.BlockNotFound{}
+		}
+
+		return err
+	}
+
+	// After deleting the block index, the block will be deleted automatically due to the `ON DELETE CASCADE` constraint
+	err = repository.deleteBlockIndex(blockIndexUUID)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (repository *BlocksPostgresRepository) deleteBlockIndex(blockIndexUUID string) (err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
+	defer cancel()
+
+	query := `
+		DELETE FROM blocks_index
+		WHERE id = $1
+	`
+
+	_, err = repository.Connection.ExecContext(ctx, query, blockIndexUUID)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}