feat: add invoice-config-items management functionality

internal/mapper/invoice_config_item_mapper.go

@@ -0,0 +1,50 @@
+package mapper
+
+import (
+	"wm-backend/internal/models"
+	db "wm-backend/sqlc_gen"
+
+	"github.com/jackc/pgx/v5/pgtype"
+)
+
+func ToDomainInvoiceConfigItem(r db.InvoiceConfigItem) *models.InvoiceConfigItem {
+	return &models.InvoiceConfigItem{
+		ID:               r.ID,
+		InvoiceConfigID:  r.InvoiceConfigID,
+		ComponentID:      r.ComponentID,
+		RequiredQuantity: r.RequiredQuantity,
+		AllowAlternative: r.AllowAlternative,
+		PriorityOrder:    r.PriorityOrder,
+		Note:             r.Note.String,
+		Metadata:         r.Metadata,
+	}
+}
+
+func ToModelInvoiceConfigItem(r *models.InvoiceConfigItem) *db.CreateInvoiceConfigItemParams {
+	return &db.CreateInvoiceConfigItemParams{
+		InvoiceConfigID:  r.InvoiceConfigID,
+		ComponentID:      r.ComponentID,
+		RequiredQuantity: r.RequiredQuantity,
+		AllowAlternative: r.AllowAlternative,
+		PriorityOrder:    r.PriorityOrder,
+		Note: pgtype.Text{
+			String: r.Note,
+			Valid:  r.Note != "",
+		},
+		Metadata: r.Metadata,
+	}
+}
+
+func ToUpdateModelInvoiceConfigItem(r *models.InvoiceConfigItem) *db.UpdateInvoiceConfigItemParams {
+	return &db.UpdateInvoiceConfigItemParams{
+		RequiredQuantity: r.RequiredQuantity,
+		AllowAlternative: r.AllowAlternative,
+		PriorityOrder:    r.PriorityOrder,
+		Note: pgtype.Text{
+			String: r.Note,
+			Valid:  r.Note != "",
+		},
+		Metadata: r.Metadata,
+		ID:       r.ID,
+	}
+}

internal/models/invoice_config_item_model.go

@@ -0,0 +1,12 @@
+package models
+
+type InvoiceConfigItem struct {
+	ID               int64  `json:"id"`
+	InvoiceConfigID  int64  `json:"invoiceConfigId"`
+	ComponentID      int64  `json:"componentId"`
+	RequiredQuantity int32  `json:"requiredQuantity"`
+	AllowAlternative bool   `json:"allowAlternative"`
+	PriorityOrder    int32  `json:"priorityOrder"`
+	Note             string `json:"note"`
+	Metadata         []byte `json:"metadata"`
+}

internal/models/requests/invoice_config_item_request.go

@@ -0,0 +1,17 @@
+package requests
+
+type CreateInvoiceConfigItemRequest struct {
+	InvoiceConfigID  int64  `json:"invoiceConfigId" binding:"required"`
+	ComponentID      int64  `json:"componentId" binding:"required"`
+	RequiredQuantity int32  `json:"requiredQuantity" binding:"required"`
+	AllowAlternative bool   `json:"allowAlternative"`
+	PriorityOrder    int32  `json:"priorityOrder" binding:"required"`
+	Note             string `json:"note"`
+}
+
+type UpdateInvoiceConfigItemRequest struct {
+	RequiredQuantity *int32 `json:"requiredQuantity"`
+	AllowAlternative *bool  `json:"allowAlternative"`
+	PriorityOrder    *int32 `json:"priorityOrder"`
+	Note             string `json:"note"`
+}

internal/models/responses/invoice_config_item_response.go

@@ -0,0 +1,15 @@
+package responses
+
+type CreateInvoiceConfigItemResponse struct {
+	ID int64 `json:"id"`
+}
+
+type UpdateInvoiceConfigItemResponse struct {
+	ID               int64  `json:"id"`
+	InvoiceConfigID  int64  `json:"invoiceConfigId"`
+	ComponentID      int64  `json:"componentId"`
+	RequiredQuantity int32  `json:"requiredQuantity"`
+	AllowAlternative bool   `json:"allowAlternative"`
+	PriorityOrder    int32  `json:"priorityOrder"`
+	Note             string `json:"note"`
+}

internal/repositories/invoice_config_item_repository.go

@@ -0,0 +1,52 @@
+package repositories
+
+import (
+	"context"
+	"wm-backend/internal/mapper"
+	"wm-backend/internal/models"
+	db "wm-backend/sqlc_gen"
+)
+
+func CreateInvoiceConfigItem(ctx context.Context, queries *db.Queries, body models.InvoiceConfigItem) (models.InvoiceConfigItem, error) {
+	result, err := queries.CreateInvoiceConfigItem(ctx, *mapper.ToModelInvoiceConfigItem(&body))
+	if err != nil {
+		return models.InvoiceConfigItem{}, err
+	}
+	return *mapper.ToDomainInvoiceConfigItem(result), nil
+}
+
+func GetInvoiceConfigItemByID(ctx context.Context, queries *db.Queries, id int64) (models.InvoiceConfigItem, error) {
+	result, err := queries.GetInvoiceConfigItemByID(ctx, id)
+	if err != nil {
+		return models.InvoiceConfigItem{}, err
+	}
+	return *mapper.ToDomainInvoiceConfigItem(result), nil
+}
+
+func ListInvoiceConfigItems(ctx context.Context, queries *db.Queries) ([]models.InvoiceConfigItem, error) {
+	results, err := queries.ListInvoiceConfigItems(ctx)
+	if err != nil {
+		return nil, err
+	}
+	var items []models.InvoiceConfigItem
+	for _, r := range results {
+		items = append(items, *mapper.ToDomainInvoiceConfigItem(r))
+	}
+	return items, nil
+}
+
+func UpdateInvoiceConfigItem(ctx context.Context, queries *db.Queries, body models.InvoiceConfigItem) (models.InvoiceConfigItem, error) {
+	result, err := queries.UpdateInvoiceConfigItem(ctx, *mapper.ToUpdateModelInvoiceConfigItem(&body))
+	if err != nil {
+		return models.InvoiceConfigItem{}, err
+	}
+	return *mapper.ToDomainInvoiceConfigItem(result), nil
+}
+
+func DeleteInvoiceConfigItem(ctx context.Context, queries *db.Queries, id int64) (int64, error) {
+	rowsAffected, err := queries.DeleteInvoiceConfigItem(ctx, id)
+	if err != nil {
+		return rowsAffected, err
+	}
+	return rowsAffected, nil
+}

internal/routers/router.go

@@ -120,6 +120,15 @@ func NewRouter() *gin.Engine {
 			invoiceConfig.PUT("/:id", utils.AsyncHandler(services.InvoiceConfigUpdate))
 			invoiceConfig.DELETE("/:id", utils.AsyncHandler(services.InvoiceConfigDelete))
 		}
+
+		invoiceConfigItem := v1.Group(constants.API_GROUP_INVOICE_CONFIG_ITEM)
+		{
+			invoiceConfigItem.GET("", utils.AsyncHandler(services.InvoiceConfigItemList))
+			invoiceConfigItem.GET("/:id", utils.AsyncHandler(services.InvoiceConfigItemGetByID))
+			invoiceConfigItem.POST("", utils.AsyncHandler(services.InvoiceConfigItemCreate))
+			invoiceConfigItem.PUT("/:id", utils.AsyncHandler(services.InvoiceConfigItemUpdate))
+			invoiceConfigItem.DELETE("/:id", utils.AsyncHandler(services.InvoiceConfigItemDelete))
+		}
 	}
 
 	r.GET(constants.API_PATH_PING, services.PingHandler)

internal/services/invoice_config_item_service.go

@@ -0,0 +1,193 @@
+package services
+
+import (
+	"net/http"
+	"strconv"
+	"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"
+)
+
+// InvoiceConfigItemCreate creates a new invoice config item.
+//
+// @Summary      Create a new invoice config item
+// @Description  Create a new invoice config item with the provided details
+// @Tags         invoice-config-item
+// @Accept       json
+// @Produce      json
+// @Param        body  body  requests.CreateInvoiceConfigItemRequest  true  "Invoice config item request body"
+// @Success      201   {object}  response.SuccessResponse{data=responses.CreateInvoiceConfigItemResponse}
+// @Failure      400   {object}  response.ErrorResponse
+// @Failure      500   {object}  response.ErrorResponse
+// @Router       /v1/invoice-config-items [post]
+func InvoiceConfigItemCreate(c *gin.Context) error {
+	requestBody := requests.CreateInvoiceConfigItemRequest{}
+	if helper.IsShouldBindJSON(c, &requestBody) {
+		return nil
+	}
+	invoiceConfigItemModel := &models.InvoiceConfigItem{
+		InvoiceConfigID:  requestBody.InvoiceConfigID,
+		ComponentID:      requestBody.ComponentID,
+		RequiredQuantity: requestBody.RequiredQuantity,
+		AllowAlternative: requestBody.AllowAlternative,
+		PriorityOrder:    requestBody.PriorityOrder,
+		Note:             requestBody.Note,
+	}
+	invoiceConfigItem, err := repositories.CreateInvoiceConfigItem(c.Request.Context(), global.Queries, *invoiceConfigItemModel)
+	if err != nil {
+		log.Error().Err(err).Msg("Failed to create invoice config item")
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to create invoice config item")
+		return nil
+	}
+	response.Created(c, "Invoice config item created successfully", &responses.CreateInvoiceConfigItemResponse{
+		ID: invoiceConfigItem.ID,
+	})
+	return nil
+}
+
+// InvoiceConfigItemGetByID retrieves a single invoice config item by its ID.
+//
+// @Summary      Get invoice config item by ID
+// @Description  Retrieve a single invoice config item using its unique identifier
+// @Tags         invoice-config-item
+// @Accept       json
+// @Produce      json
+// @Param        id   path      int  true  "Invoice config item ID"
+// @Success      200  {object}  response.SuccessResponse{data=models.InvoiceConfigItem}
+// @Failure      400  {object}  response.ErrorResponse
+// @Failure      404  {object}  response.ErrorResponse
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /v1/invoice-config-items/{id} [get]
+func InvoiceConfigItemGetByID(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
+	}
+	invoiceConfigItem, err := repositories.GetInvoiceConfigItemByID(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		log.Error().Err(err).Msgf("Failed to get invoice config item by ID: %d", id)
+		response.NotFoundError(c, http.StatusNotFound, "Invoice config item not found")
+		return nil
+	}
+	response.Ok(c, "Success", invoiceConfigItem)
+	return nil
+}
+
+// InvoiceConfigItemList retrieves all invoice config items.
+//
+// @Summary      List all invoice config items
+// @Description  Retrieve a list of all invoice config items
+// @Tags         invoice-config-item
+// @Accept       json
+// @Produce      json
+// @Success      200  {object}  response.SuccessResponse{data=[]models.InvoiceConfigItem}
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /v1/invoice-config-items [get]
+func InvoiceConfigItemList(c *gin.Context) error {
+	invoiceConfigItems, err := repositories.ListInvoiceConfigItems(c.Request.Context(), global.Queries)
+	if err != nil {
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to list invoice config items")
+		return nil
+	}
+	response.Ok(c, "Success", invoiceConfigItems)
+	return nil
+}
+
+// InvoiceConfigItemUpdate updates an existing invoice config item by its ID.
+//
+// @Summary      Update invoice config item
+// @Description  Update an existing invoice config item by its ID. Only non-empty fields will be updated.
+// @Tags         invoice-config-item
+// @Accept       json
+// @Produce      json
+// @Param        id    path      int                                  true  "Invoice config item ID"
+// @Param        body  body      requests.UpdateInvoiceConfigItemRequest  true  "Invoice config item request body"
+// @Success      200   {object}  response.SuccessResponse{data=responses.UpdateInvoiceConfigItemResponse}
+// @Failure      400   {object}  response.ErrorResponse
+// @Failure      404   {object}  response.ErrorResponse
+// @Failure      500   {object}  response.ErrorResponse
+// @Router       /v1/invoice-config-items/{id} [put]
+func InvoiceConfigItemUpdate(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.UpdateInvoiceConfigItemRequest{}
+	if helper.IsShouldBindJSON(c, &requestBody) {
+		return nil
+	}
+	existing, err := repositories.GetInvoiceConfigItemByID(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		response.NotFoundError(c, http.StatusNotFound, "Invoice config item not found")
+		return nil
+	}
+	if requestBody.RequiredQuantity != nil {
+		existing.RequiredQuantity = *requestBody.RequiredQuantity
+	}
+	if requestBody.AllowAlternative != nil {
+		existing.AllowAlternative = *requestBody.AllowAlternative
+	}
+	if requestBody.PriorityOrder != nil {
+		existing.PriorityOrder = *requestBody.PriorityOrder
+	}
+	if requestBody.Note != "" {
+		existing.Note = requestBody.Note
+	}
+	invoiceConfigItem, err := repositories.UpdateInvoiceConfigItem(c.Request.Context(), global.Queries, existing)
+	if err != nil {
+		log.Error().Err(err).Msgf("Failed to update invoice config item with ID: %d", id)
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to update invoice config item")
+		return nil
+	}
+	response.Ok(c, "Invoice config item updated successfully", &responses.UpdateInvoiceConfigItemResponse{
+		ID:               invoiceConfigItem.ID,
+		InvoiceConfigID:  invoiceConfigItem.InvoiceConfigID,
+		ComponentID:      invoiceConfigItem.ComponentID,
+		RequiredQuantity: invoiceConfigItem.RequiredQuantity,
+		AllowAlternative: invoiceConfigItem.AllowAlternative,
+		PriorityOrder:    invoiceConfigItem.PriorityOrder,
+		Note:             invoiceConfigItem.Note,
+	})
+	return nil
+}
+
+// InvoiceConfigItemDelete deletes an invoice config item by its ID.
+//
+// @Summary      Delete invoice config item
+// @Description  Delete an invoice config item by its unique identifier
+// @Tags         invoice-config-item
+// @Accept       json
+// @Produce      json
+// @Param        id   path      int  true  "Invoice config item ID"
+// @Success      200  {object}  response.SuccessResponse
+// @Failure      400  {object}  response.ErrorResponse
+// @Failure      500  {object}  response.ErrorResponse
+// @Router       /v1/invoice-config-items/{id} [delete]
+func InvoiceConfigItemDelete(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.DeleteInvoiceConfigItem(c.Request.Context(), global.Queries, id)
+	if err != nil {
+		log.Error().Err(err).Msgf("Failed to delete invoice config item with ID: %d", id)
+		response.InternalServerError(c, http.StatusInternalServerError, "Failed to delete invoice config item")
+		return nil
+	}
+	if rowsAffected == 0 {
+		response.NotFoundError(c, http.StatusNotFound, "Invoice config item not found")
+		return nil
+	}
+	response.Ok(c, "Delete Success", nil)
+	return nil
+}