feat: add cabinet management functionality

internal/mapper/cabinet_mapper.go

@@ -0,0 +1,43 @@
+package mapper
+
+import (
+	"wm-backend/internal/models"
+	db "wm-backend/sqlc_gen"
+
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+func ToDomainCabinet(r db.Cabinet) *models.Cabinet {
+	return &models.Cabinet{
+		ID:          r.ID,
+		RoomID:      r.RoomID,
+		Name:        r.Name,
+		Description: r.Description.String,
+		CreatedAt:   r.CreatedAt,
+		UpdatedAt:   r.UpdatedAt,
+	}
+}
+
+func ToModelCabinet(r *models.Cabinet) *db.CreateCabinetParams {
+	return &db.CreateCabinetParams{
+		RoomID: r.RoomID,
+		Name:   r.Name,
+		Description: pgtype.Text{
+			String: r.Description,
+			Valid:  r.Description != "",
+		},
+		CreatedAt: r.CreatedAt,
+	}
+}
+
+func ToUpdateModelCabinet(r *models.Cabinet) *db.UpdateCabinetParams {
+	return &db.UpdateCabinetParams{
+		Name: r.Name,
+		Description: pgtype.Text{
+			String: r.Description,
+			Valid:  r.Description != "",
+		},
+		UpdatedAt: r.UpdatedAt,
+		ID:        r.ID,
+	}
+}

internal/models/cabinet_model.go

@@ -0,0 +1,12 @@
+package models
+
+import "time"
+
+type Cabinet struct {
+	ID          int64     `json:"id"`
+	RoomID      int64     `json:"roomId"`
+	Name        string    `json:"name"`
+	Description string    `json:"description"`
+	CreatedAt   time.Time `json:"createdAt"`
+	UpdatedAt   time.Time `json:"updatedAt"`
+}

internal/models/requests/cabinet_request.go

@@ -0,0 +1,12 @@
+package requests
+
+type CreateCabinetRequest struct {
+	RoomID      int64  `json:"roomId" binding:"required"`
+	Name        string `json:"name" binding:"required"`
+	Description string `json:"description"`
+}
+
+type UpdateCabinetRequest struct {
+	Name        string `json:"name"`
+	Description string `json:"description"`
+}

internal/models/responses/cabinet_response.go

@@ -0,0 +1,12 @@
+package responses
+
+type CreateCabinetResponse struct {
+	ID int64 `json:"id"`
+}
+
+type UpdateCabinetResponse struct {
+	ID          int64  `json:"id"`
+	RoomID      int64  `json:"roomId"`
+	Name        string `json:"name"`
+	Description string `json:"description"`
+}

internal/repositories/cabinet_repository.go

@@ -0,0 +1,48 @@
+package repositories
+
+import (
+	"context"
+	"wm-backend/internal/mapper"
+	"wm-backend/internal/models"
+	db "wm-backend/sqlc_gen"
+)
+
+func CreateCabinet(ctx context.Context, queries *db.Queries, body models.Cabinet) (models.Cabinet, error) {
+	result, err := queries.CreateCabinet(ctx, *mapper.ToModelCabinet(&body))
+	if err != nil {
+		return models.Cabinet{}, err
+	}
+	return *mapper.ToDomainCabinet(result), nil
+}
+
+func GetCabinetByID(ctx context.Context, queries *db.Queries, id int64) (models.Cabinet, error) {
+	result, err := queries.GetCabinetByID(ctx, id)
+	if err != nil {
+		return models.Cabinet{}, err
+	}
+	return *mapper.ToDomainCabinet(result), nil
+}
+
+func ListCabinets(ctx context.Context, queries *db.Queries) ([]models.Cabinet, error) {
+	results, err := queries.ListCabinets(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var items []models.Cabinet
+	for _, r := range results {
+		items = append(items, *mapper.ToDomainCabinet(r))
+	}
+	return items, nil
+}
+
+func UpdateCabinet(ctx context.Context, queries *db.Queries, body models.Cabinet) (models.Cabinet, error) {
+	result, err := queries.UpdateCabinet(ctx, *mapper.ToUpdateModelCabinet(&body))
+	if err != nil {
+		return models.Cabinet{}, err
+	}
+	return *mapper.ToDomainCabinet(result), nil
+}
+
+func DeleteCabinet(ctx context.Context, queries *db.Queries, id int64) error {
+	return queries.DeleteCabinet(ctx, id)
+}

internal/routers/router.go

@@ -46,6 +46,15 @@ func NewRouter() *gin.Engine {
 			room.PUT("/:id", utils.AsyncHandler(services.RoomUpdate))
 			room.DELETE("/:id", utils.AsyncHandler(services.RoomDelete))
 		}
+
+		cabinet := v1.Group(constants.API_GROUP_CABINET)
+		{
+			cabinet.GET("", utils.AsyncHandler(services.CabinetList))
+			cabinet.GET("/:id", utils.AsyncHandler(services.CabinetGetByID))
+			cabinet.POST("", utils.AsyncHandler(services.CabinetCreate))
+			cabinet.PUT("/:id", utils.AsyncHandler(services.CabinetUpdate))
+			cabinet.DELETE("/:id", utils.AsyncHandler(services.CabinetDelete))
+		}
 	}
 
 	r.GET(constants.API_PATH_PING, services.PingHandler)

internal/services/cabinet_service.go

@@ -0,0 +1,181 @@
+package services
+
+import (
+	"net/http"
+	"strconv"
+	"time"
+	"wm-backend/global"
+	"wm-backend/internal/models"
+	"wm-backend/internal/models/requests"
+	"wm-backend/internal/models/responses"
+	"wm-backend/internal/repositories"
+	"wm-backend/pkg/helper"
+	"wm-backend/response"
+
+	"github.com/gin-gonic/gin"
+	"github.com/rs/zerolog/log"
+)
+
+// CabinetCreate creates a new cabinet.
+// It validates the request body and creates the cabinet in the database.
+//
+// @Summary      Create a new cabinet
+// @Description  Create a new cabinet with the provided details
+// @Tags         cabinet
+// @Accept       json
+// @Produce      json
+// @Param        body  body  requests.CreateCabinetRequest  true  "Cabinet request body"
+// @Success      201   {object}  response.SuccessResponse{data=responses.CreateCabinetResponse}
+// @Failure      400   {object}  response.ErrorResponse
+// @Failure      500   {object}  response.ErrorResponse
+// @Router       /v1/cabinets [post]
+func CabinetCreate(c *gin.Context) error {
+	requestBody := requests.CreateCabinetRequest{}
+	if helper.IsShouldBindJSON(c, &requestBody) {
+		return nil
+	}
+	cabinetModel := &models.Cabinet{
+		RoomID:      requestBody.RoomID,
+		Name:        requestBody.Name,
+		Description: requestBody.Description,
+		CreatedAt:   time.Now(),
+	}
+	cabinet, err := repositories.CreateCabinet(c.Request.Context(), global.Queries, *cabinetModel)
+	if err != nil {
+		log.Error().Err(err).Msg("Failed to create cabinet")
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to create cabinet")
+		return nil
+	}
+	response.Created(c, "Cabinet created successfully", &responses.CreateCabinetResponse{
+		ID: cabinet.ID,
+	})
+	return nil
+}
+
+// CabinetGetByID retrieves a single cabinet by its ID.
+//
+// @Summary      Get cabinet by ID
+// @Description  Retrieve a single cabinet using its unique identifier
+// @Tags         cabinet
+// @Accept       json
+// @Produce      json
+// @Param        id   path      int  true  "Cabinet ID"
+// @Success      200  {object}  response.SuccessResponse{data=models.Cabinet}
+// @Failure      400  {object}  response.ErrorResponse
+// @Failure      404  {object}  response.ErrorResponse
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /v1/cabinets/{id} [get]
+func CabinetGetByID(c *gin.Context) error {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		response.BadRequestError(c, http.StatusBadRequest, "Invalid ID")
+		return nil
+	}
+	cabinet, err := repositories.GetCabinetByID(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		log.Error().Err(err).Msgf("Failed to get cabinet by ID: %d", id)
+		response.NotFoundError(c, http.StatusNotFound, "Cabinet not found")
+		return nil
+	}
+	response.Ok(c, "Success", cabinet)
+	return nil
+}
+
+// CabinetList retrieves all cabinets.
+//
+// @Summary      List all cabinets
+// @Description  Retrieve a list of all cabinets ordered by creation date
+// @Tags         cabinet
+// @Accept       json
+// @Produce      json
+// @Success      200  {object}  response.SuccessResponse{data=[]models.Cabinet}
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /v1/cabinets [get]
+func CabinetList(c *gin.Context) error {
+	cabinets, err := repositories.ListCabinets(c.Request.Context(), global.Queries)
+	if err != nil {
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to list cabinets")
+		return nil
+	}
+	response.Ok(c, "Success", cabinets)
+	return nil
+}
+
+// CabinetUpdate updates an existing cabinet by its ID.
+// It validates the request body, fetches the existing record,
+// merges non-empty fields from the request, and updates the cabinet in the database.
+//
+// @Summary      Update cabinet
+// @Description  Update an existing cabinet by its ID. Only non-empty fields will be updated.
+// @Tags         cabinet
+// @Accept       json
+// @Produce      json
+// @Param        id    path      int                           true  "Cabinet ID"
+// @Param        body  body      requests.UpdateCabinetRequest  true  "Cabinet request body"
+// @Success      200   {object}  response.SuccessResponse{data=responses.UpdateCabinetResponse}
+// @Failure      400   {object}  response.ErrorResponse
+// @Failure      404   {object}  response.ErrorResponse
+// @Failure      500   {object}  response.ErrorResponse
+// @Router       /v1/cabinets/{id} [put]
+func CabinetUpdate(c *gin.Context) error {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		response.BadRequestError(c, http.StatusBadRequest, "Invalid ID")
+		return nil
+	}
+	requestBody := requests.UpdateCabinetRequest{}
+	if helper.IsShouldBindJSON(c, &requestBody) {
+		return nil
+	}
+	existing, err := repositories.GetCabinetByID(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		response.NotFoundError(c, http.StatusNotFound, "Cabinet not found")
+		return nil
+	}
+	if requestBody.Name != "" {
+		existing.Name = requestBody.Name
+	}
+	if requestBody.Description != "" {
+		existing.Description = requestBody.Description
+	}
+	existing.UpdatedAt = time.Now()
+	cabinet, err := repositories.UpdateCabinet(c.Request.Context(), global.Queries, existing)
+	if err != nil {
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to update cabinet")
+		return nil
+	}
+	response.Ok(c, "Cabinet updated successfully", &responses.UpdateCabinetResponse{
+		ID:          cabinet.ID,
+		RoomID:      cabinet.RoomID,
+		Name:        cabinet.Name,
+		Description: cabinet.Description,
+	})
+	return nil
+}
+
+// CabinetDelete deletes a cabinet by its ID.
+//
+// @Summary      Delete cabinet
+// @Description  Delete a cabinet by its unique identifier
+// @Tags         cabinet
+// @Accept       json
+// @Produce      json
+// @Param        id   path      int  true  "Cabinet ID"
+// @Success      200  {object}  response.SuccessResponse
+// @Failure      400  {object}  response.ErrorResponse
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /v1/cabinets/{id} [delete]
+func CabinetDelete(c *gin.Context) error {
+	id, err := strconv.ParseInt(c.Param("id"), 10, 64)
+	if err != nil {
+		response.BadRequestError(c, http.StatusBadRequest, "Invalid ID")
+		return nil
+	}
+	err = repositories.DeleteCabinet(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to delete cabinet")
+		return nil
+	}
+	response.Ok(c, "Đã xóa thành công", nil)
+	return nil
+}

internal/services/room_service.go

@@ -141,6 +141,7 @@ func RoomUpdate(c *gin.Context) error {
 	existing.UpdatedAt = time.Now()
 	room, err := repositories.UpdateRoom(c.Request.Context(), global.Queries, existing)
 	if err != nil {
+		log.Error().Err(err).Msgf("Failed to update room with ID: %d", id)
 		response.InternalServerError(c, http.StatusInternalServerError, "Failed to update room")
 		return nil
 	}
@@ -173,6 +174,7 @@ func RoomDelete(c *gin.Context) error {
 	}
 	err = repositories.DeleteRoom(c.Request.Context(), global.Queries, id)
 	if err != nil {
+		log.Error().Err(err).Msgf("Failed to delete room with ID: %d", id)
 		response.InternalServerError(c, http.StatusInternalServerError, "Failed to delete room")
 		return nil
 	}