feat: add component_codes management functionality

internal/mapper/component_code_mapper.go

@@ -0,0 +1,54 @@
+package mapper
+
+import (
+	"wm-backend/internal/models"
+	db "wm-backend/sqlc_gen"
+
+	"encoding/json"
+
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+func ToDomainComponentCode(r db.ComponentCode) *models.ComponentCode {
+	return &models.ComponentCode{
+		ID:          r.ID,
+		ComponentID: r.ComponentID,
+		Code:        r.Code,
+		CodeType:    r.CodeType.String,
+		IsPrimary:   r.IsPrimary,
+		Metadata:    json.RawMessage(r.Metadata),
+		CreatedAt:   r.CreatedAt,
+	}
+}
+
+func ToModelComponentCode(r *models.ComponentCode) *db.CreateComponentCodeParams {
+	return &db.CreateComponentCodeParams{
+		ComponentID: r.ComponentID,
+		Code:        r.Code,
+		CodeType: pgtype.Text{
+			String: r.CodeType,
+			Valid:  r.CodeType != "",
+		},
+		IsPrimary: r.IsPrimary,
+		Metadata:  []byte(r.Metadata),
+		CreatedAt: r.CreatedAt,
+	}
+}
+
+func ToUpdateModelComponentCode(r *models.ComponentCode) *db.UpdateComponentCodeParams {
+	var metadata []byte
+	if len(r.Metadata) > 0 {
+		metadata = []byte(r.Metadata)
+	}
+	return &db.UpdateComponentCodeParams{
+		Code:        r.Code,
+		ComponentID: r.ComponentID,
+		CodeType: pgtype.Text{
+			String: r.CodeType,
+			Valid:  r.CodeType != "",
+		},
+		IsPrimary: r.IsPrimary,
+		Metadata:  metadata,
+		ID:        r.ID,
+	}
+}

internal/models/component_code_model.go

@@ -0,0 +1,16 @@
+package models
+
+import (
+	"encoding/json"
+	"time"
+)
+
+type ComponentCode struct {
+	ID          int64           `json:"id"`
+	ComponentID int64           `json:"componentId"`
+	Code        string          `json:"code"`
+	CodeType    string          `json:"codeType"`
+	IsPrimary   bool            `json:"isPrimary"`
+	Metadata    json.RawMessage `json:"metadata"`
+	CreatedAt   time.Time       `json:"createdAt"`
+}

internal/models/requests/component_code_request.go

@@ -0,0 +1,19 @@
+package requests
+
+import "encoding/json"
+
+type CreateComponentCodeRequest struct {
+	ComponentID int64           `json:"componentId" binding:"required"`
+	Code        string          `json:"code" binding:"required"`
+	CodeType    string          `json:"codeType"`
+	IsPrimary   bool            `json:"isPrimary"`
+	Metadata    json.RawMessage `json:"metadata"`
+}
+
+type UpdateComponentCodeRequest struct {
+	ComponentID int64           `json:"componentId"`
+	Code        string          `json:"code"`
+	CodeType    string          `json:"codeType"`
+	IsPrimary   *bool           `json:"isPrimary"`
+	Metadata    json.RawMessage `json:"metadata"`
+}

internal/models/responses/component_code_response.go

@@ -0,0 +1,13 @@
+package responses
+
+type CreateComponentCodeResponse struct {
+	ID int64 `json:"id"`
+}
+
+type UpdateComponentCodeResponse struct {
+	ID          int64  `json:"id"`
+	ComponentID int64  `json:"componentId"`
+	Code        string `json:"code"`
+	CodeType    string `json:"codeType"`
+	IsPrimary   bool   `json:"isPrimary"`
+}

internal/repositories/component_code_repository.go

@@ -0,0 +1,52 @@
+package repositories
+
+import (
+	"context"
+	"wm-backend/internal/mapper"
+	"wm-backend/internal/models"
+	db "wm-backend/sqlc_gen"
+)
+
+func CreateComponentCode(ctx context.Context, queries *db.Queries, body models.ComponentCode) (models.ComponentCode, error) {
+	result, err := queries.CreateComponentCode(ctx, *mapper.ToModelComponentCode(&body))
+	if err != nil {
+		return models.ComponentCode{}, err
+	}
+	return *mapper.ToDomainComponentCode(result), nil
+}
+
+func GetComponentCodeByID(ctx context.Context, queries *db.Queries, id int64) (models.ComponentCode, error) {
+	result, err := queries.GetComponentCodeByID(ctx, id)
+	if err != nil {
+		return models.ComponentCode{}, err
+	}
+	return *mapper.ToDomainComponentCode(result), nil
+}
+
+func ListComponentCodes(ctx context.Context, queries *db.Queries) ([]models.ComponentCode, error) {
+	results, err := queries.ListComponentCodes(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var items []models.ComponentCode
+	for _, r := range results {
+		items = append(items, *mapper.ToDomainComponentCode(r))
+	}
+	return items, nil
+}
+
+func UpdateComponentCode(ctx context.Context, queries *db.Queries, body models.ComponentCode) (models.ComponentCode, error) {
+	result, err := queries.UpdateComponentCode(ctx, *mapper.ToUpdateModelComponentCode(&body))
+	if err != nil {
+		return models.ComponentCode{}, err
+	}
+	return *mapper.ToDomainComponentCode(result), nil
+}
+
+func DeleteComponentCode(ctx context.Context, queries *db.Queries, id int64) (int64, error) {
+	rowsAffected, err := queries.DeleteComponentCode(ctx, id)
+	if err != nil {
+		return rowsAffected, err
+	}
+	return rowsAffected, nil
+}

internal/routers/router.go

@@ -91,6 +91,15 @@ func NewRouter() *gin.Engine {
 			component.PUT("/:id", utils.AsyncHandler(services.ComponentUpdate))
 			component.DELETE("/:id", utils.AsyncHandler(services.ComponentDelete))
 		}
+
+		componentCode := v1.Group(constants.API_GROUP_COMPONENT_CODE)
+		{
+			componentCode.GET("", utils.AsyncHandler(services.ComponentCodeList))
+			componentCode.GET("/:id", utils.AsyncHandler(services.ComponentCodeGetByID))
+			componentCode.POST("", utils.AsyncHandler(services.ComponentCodeCreate))
+			componentCode.PUT("/:id", utils.AsyncHandler(services.ComponentCodeUpdate))
+			componentCode.DELETE("/:id", utils.AsyncHandler(services.ComponentCodeDelete))
+		}
 	}
 
 	r.GET(constants.API_PATH_PING, services.PingHandler)

internal/services/component_code_service.go

@@ -0,0 +1,195 @@
+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"
+)
+
+// ComponentCodeCreate creates a new component code.
+// It validates the request body and creates the component code in the database.
+//
+// @Summary      Create a new component code
+// @Description  Create a new component code with the provided details
+// @Tags         component-code
+// @Accept       json
+// @Produce      json
+// @Param        body  body  requests.CreateComponentCodeRequest  true  "Component code request body"
+// @Success      201   {object}  response.SuccessResponse{data=responses.CreateComponentCodeResponse}
+// @Failure      400   {object}  response.ErrorResponse
+// @Failure      500   {object}  response.ErrorResponse
+// @Router       /api/v1/component-codes [post]
+func ComponentCodeCreate(c *gin.Context) error {
+	requestBody := requests.CreateComponentCodeRequest{}
+	if helper.IsShouldBindJSON(c, &requestBody) {
+		return nil
+	}
+	componentCodeModel := &models.ComponentCode{
+		ComponentID: requestBody.ComponentID,
+		Code:        requestBody.Code,
+		CodeType:    requestBody.CodeType,
+		IsPrimary:   requestBody.IsPrimary,
+		Metadata:    requestBody.Metadata,
+		CreatedAt:   time.Now(),
+	}
+	componentCode, err := repositories.CreateComponentCode(c.Request.Context(), global.Queries, *componentCodeModel)
+	if err != nil {
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to create component code")
+		return nil
+	}
+	response.Created(c, "Component code created successfully", &responses.CreateComponentCodeResponse{
+		ID: componentCode.ID,
+	})
+	return nil
+}
+
+// ComponentCodeGetByID retrieves a single component code by its ID.
+//
+// @Summary      Get component code by ID
+// @Description  Retrieve a single component code using its unique identifier
+// @Tags         component-code
+// @Accept       json
+// @Produce      json
+// @Param        id   path      int  true  "Component code ID"
+// @Success      200  {object}  response.SuccessResponse{data=models.ComponentCode}
+// @Failure      400  {object}  response.ErrorResponse
+// @Failure      404  {object}  response.ErrorResponse
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /api/v1/component-codes/{id} [get]
+func ComponentCodeGetByID(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
+	}
+	componentCode, err := repositories.GetComponentCodeByID(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		response.NotFoundError(c, http.StatusNotFound, "Component code not found")
+		return nil
+	}
+	response.Ok(c, "Success", componentCode)
+	return nil
+}
+
+// ComponentCodeList retrieves all component codes.
+//
+// @Summary      List all component codes
+// @Description  Retrieve a list of all component codes ordered by creation date
+// @Tags         component-code
+// @Accept       json
+// @Produce      json
+// @Success      200  {object}  response.SuccessResponse{data=[]models.ComponentCode}
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /api/v1/component-codes [get]
+func ComponentCodeList(c *gin.Context) error {
+	componentCodes, err := repositories.ListComponentCodes(c.Request.Context(), global.Queries)
+	if err != nil {
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to list component codes")
+		return nil
+	}
+	response.Ok(c, "Success", componentCodes)
+	return nil
+}
+
+// ComponentCodeUpdate updates an existing component code by its ID.
+// It validates the request body, fetches the existing record,
+// merges non-empty fields from the request, and updates the component code in the database.
+//
+// @Summary      Update component code
+// @Description  Update an existing component code by its ID. Only non-empty fields will be updated.
+// @Tags         component-code
+// @Accept       json
+// @Produce      json
+// @Param        id    path      int                                true  "Component code ID"
+// @Param        body  body      requests.UpdateComponentCodeRequest  true  "Component code request body"
+// @Success      200   {object}  response.SuccessResponse{data=responses.UpdateComponentCodeResponse}
+// @Failure      400   {object}  response.ErrorResponse
+// @Failure      404   {object}  response.ErrorResponse
+// @Failure      500   {object}  response.ErrorResponse
+// @Router       /api/v1/component-codes/{id} [put]
+func ComponentCodeUpdate(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.UpdateComponentCodeRequest{}
+	if helper.IsShouldBindJSON(c, &requestBody) {
+		return nil
+	}
+	existing, err := repositories.GetComponentCodeByID(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		response.NotFoundError(c, http.StatusNotFound, "Component code not found")
+		return nil
+	}
+	if requestBody.ComponentID != 0 {
+		existing.ComponentID = requestBody.ComponentID
+	}
+	if requestBody.Code != "" {
+		existing.Code = requestBody.Code
+	}
+	if requestBody.CodeType != "" {
+		existing.CodeType = requestBody.CodeType
+	}
+	if requestBody.IsPrimary != nil {
+		existing.IsPrimary = *requestBody.IsPrimary
+	}
+	if len(requestBody.Metadata) > 0 {
+		existing.Metadata = requestBody.Metadata
+	}
+	componentCode, err := repositories.UpdateComponentCode(c.Request.Context(), global.Queries, existing)
+	if err != nil {
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to update component code")
+		return nil
+	}
+	response.Ok(c, "Component code updated successfully", &responses.UpdateComponentCodeResponse{
+		ID:          componentCode.ID,
+		ComponentID: componentCode.ComponentID,
+		Code:        componentCode.Code,
+		CodeType:    componentCode.CodeType,
+		IsPrimary:   componentCode.IsPrimary,
+	})
+	return nil
+}
+
+// ComponentCodeDelete deletes a component code by its ID.
+//
+// @Summary      Delete component code
+// @Description  Delete a component code by its unique identifier
+// @Tags         component-code
+// @Accept       json
+// @Produce      json
+// @Param        id   path      int  true  "Component code ID"
+// @Success      200  {object}  response.SuccessResponse
+// @Failure      400  {object}  response.ErrorResponse
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /api/v1/component-codes/{id} [delete]
+func ComponentCodeDelete(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
+	}
+	rowsAffected, err := repositories.DeleteComponentCode(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		log.Error().Err(err).Msgf("Failed to delete component code with ID: %d", id)
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to delete component code")
+		return nil
+	}
+	if rowsAffected == 0 {
+		response.NotFoundError(c, http.StatusNotFound, "Component code not found")
+		return nil
+	}
+	response.Ok(c, "Delete Success", nil)
+	return nil
+}