Update

2025-08-03 00:34:25 +07:00
parent a759e0f57c
commit 96743cf50b
25 changed files with 2049 additions and 2141 deletions
@@ -1,9 +1,12 @@
 package handler

 import (
+	"apskel-pos-be/internal/appcontext"
+	"apskel-pos-be/internal/constants"
 	"apskel-pos-be/internal/contract"
-	"apskel-pos-be/internal/service"
-	"net/http"
+	"apskel-pos-be/internal/logger"
+	"apskel-pos-be/internal/util"
+	"apskel-pos-be/internal/validator"
 	"strconv"

 	"github.com/gin-gonic/gin"
@@ -11,189 +14,126 @@ import (
 )

 type TableHandler struct {
-	tableService *service.TableService
+	tableService   TableService
+	tableValidator *validator.TableValidator
 }

-func NewTableHandler(tableService *service.TableService) *TableHandler {
+func NewTableHandler(tableService TableService, tableValidator *validator.TableValidator) *TableHandler {
 	return &TableHandler{
-		tableService: tableService,
+		tableService:   tableService,
+		tableValidator: tableValidator,
 	}
 }

-// CreateTable godoc
-// @Summary Create a new table
-// @Description Create a new table for the organization
-// @Tags tables
-// @Accept json
-// @Produce json
-// @Param table body contract.CreateTableRequest true "Table data"
-// @Success 201 {object} contract.TableResponse
-// @Failure 400 {object} contract.ResponseError
-// @Failure 401 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /tables [post]
 func (h *TableHandler) Create(c *gin.Context) {
+	ctx := c.Request.Context()
+	contextInfo := appcontext.FromGinContext(ctx)
+
 	var req contract.CreateTableRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid request body",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::Create -> request binding failed")
+		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::Create")
 		return
 	}

-	organizationID := c.GetString("organization_id")
-	orgID, err := uuid.Parse(organizationID)
-	if err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid organization ID",
-			Message: err.Error(),
-		})
+	if err := h.tableValidator.ValidateCreateTableRequest(req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::Create -> validation failed")
+		validationResponseError := contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::Create")
 		return
 	}

-	response, err := h.tableService.Create(c.Request.Context(), req, orgID)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, contract.ResponseError{
-			Error:   "Failed to create table",
-			Message: err.Error(),
-		})
-		return
+	response := h.tableService.CreateTable(ctx, contextInfo, &req)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::Create -> service failed")
 	}

-	c.JSON(http.StatusCreated, response)
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::Create")
 }

-// GetTable godoc
-// @Summary Get table by ID
-// @Description Get table details by ID
-// @Tags tables
-// @Produce json
-// @Param id path string true "Table ID"
-// @Success 200 {object} contract.TableResponse
-// @Failure 400 {object} contract.ResponseError
-// @Failure 404 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /tables/{id} [get]
 func (h *TableHandler) GetByID(c *gin.Context) {
+	ctx := c.Request.Context()
+
 	id := c.Param("id")
 	tableID, err := uuid.Parse(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid table ID",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::GetByID -> Invalid table ID")
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid table ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::GetByID")
 		return
 	}

-	response, err := h.tableService.GetByID(c.Request.Context(), tableID)
-	if err != nil {
-		c.JSON(http.StatusNotFound, contract.ResponseError{
-			Error:   "Table not found",
-			Message: err.Error(),
-		})
-		return
+	response := h.tableService.GetTableByID(ctx, tableID)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::GetByID -> service failed")
 	}

-	c.JSON(http.StatusOK, response)
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::GetByID")
 }

-// UpdateTable godoc
-// @Summary Update table
-// @Description Update table details
-// @Tags tables
-// @Accept json
-// @Produce json
-// @Param id path string true "Table ID"
-// @Param table body contract.UpdateTableRequest true "Table update data"
-// @Success 200 {object} contract.TableResponse
-// @Failure 400 {object} contract.ResponseError
-// @Failure 404 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /tables/{id} [put]
 func (h *TableHandler) Update(c *gin.Context) {
+	ctx := c.Request.Context()
+
 	id := c.Param("id")
 	tableID, err := uuid.Parse(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid table ID",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::Update -> Invalid table ID")
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid table ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::Update")
 		return
 	}

 	var req contract.UpdateTableRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid request body",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::Update -> request binding failed")
+		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::Update")
 		return
 	}

-	response, err := h.tableService.Update(c.Request.Context(), tableID, req)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, contract.ResponseError{
-			Error:   "Failed to update table",
-			Message: err.Error(),
-		})
+	if err := h.tableValidator.ValidateUpdateTableRequest(req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::Update -> validation failed")
+		validationResponseError := contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::Update")
 		return
 	}

-	c.JSON(http.StatusOK, response)
+	response := h.tableService.UpdateTable(ctx, tableID, &req)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::Update -> service failed")
+	}
+
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::Update")
 }

-// DeleteTable godoc
-// @Summary Delete table
-// @Description Delete table by ID
-// @Tags tables
-// @Produce json
-// @Param id path string true "Table ID"
-// @Success 204 "No Content"
-// @Failure 400 {object} contract.ResponseError
-// @Failure 404 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /tables/{id} [delete]
 func (h *TableHandler) Delete(c *gin.Context) {
+	ctx := c.Request.Context()
+
 	id := c.Param("id")
 	tableID, err := uuid.Parse(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid table ID",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::Delete -> Invalid table ID")
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid table ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::Delete")
 		return
 	}

-	err = h.tableService.Delete(c.Request.Context(), tableID)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, contract.ResponseError{
-			Error:   "Failed to delete table",
-			Message: err.Error(),
-		})
-		return
+	response := h.tableService.DeleteTable(ctx, tableID)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::Delete -> service failed")
 	}

-	c.Status(http.StatusNoContent)
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::Delete")
 }

-// ListTables godoc
-// @Summary List tables
-// @Description Get paginated list of tables
-// @Tags tables
-// @Produce json
-// @Param organization_id query string false "Organization ID"
-// @Param outlet_id query string false "Outlet ID"
-// @Param status query string false "Table status"
-// @Param is_active query string false "Is active"
-// @Param search query string false "Search term"
-// @Param page query int false "Page number" default(1)
-// @Param limit query int false "Page size" default(10)
-// @Success 200 {object} contract.ListTablesResponse
-// @Failure 400 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /tables [get]
 func (h *TableHandler) List(c *gin.Context) {
+	ctx := c.Request.Context()
+
 	query := contract.ListTablesQuery{
 		OrganizationID: c.Query("organization_id"),
 		OutletID:       c.Query("outlet_id"),
@@ -216,170 +156,132 @@ func (h *TableHandler) List(c *gin.Context) {
 		}
 	}

-	response, err := h.tableService.List(c.Request.Context(), query)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, contract.ResponseError{
-			Error:   "Failed to list tables",
-			Message: err.Error(),
-		})
+	if err := h.tableValidator.ValidateListTablesQuery(query); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::List -> validation failed")
+		validationResponseError := contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::List")
 		return
 	}

-	c.JSON(http.StatusOK, response)
+	response := h.tableService.ListTables(ctx, &query)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::List -> service failed")
+	}
+
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::List")
 }

-// OccupyTable godoc
-// @Summary Occupy table
-// @Description Occupy a table with an order
-// @Tags tables
-// @Accept json
-// @Produce json
-// @Param id path string true "Table ID"
-// @Param request body contract.OccupyTableRequest true "Occupy table data"
-// @Success 200 {object} contract.TableResponse
-// @Failure 400 {object} contract.ResponseError
-// @Failure 404 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /tables/{id}/occupy [post]
 func (h *TableHandler) OccupyTable(c *gin.Context) {
+	ctx := c.Request.Context()
+
 	id := c.Param("id")
 	tableID, err := uuid.Parse(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid table ID",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::OccupyTable -> Invalid table ID")
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid table ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::OccupyTable")
 		return
 	}

 	var req contract.OccupyTableRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid request body",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::OccupyTable -> request binding failed")
+		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::OccupyTable")
 		return
 	}

-	response, err := h.tableService.OccupyTable(c.Request.Context(), tableID, req)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, contract.ResponseError{
-			Error:   "Failed to occupy table",
-			Message: err.Error(),
-		})
+	if err := h.tableValidator.ValidateOccupyTableRequest(req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::OccupyTable -> validation failed")
+		validationResponseError := contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::OccupyTable")
 		return
 	}

-	c.JSON(http.StatusOK, response)
+	response := h.tableService.OccupyTable(ctx, tableID, &req)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::OccupyTable -> service failed")
+	}
+
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::OccupyTable")
 }

-// ReleaseTable godoc
-// @Summary Release table
-// @Description Release a table and record payment amount
-// @Tags tables
-// @Accept json
-// @Produce json
-// @Param id path string true "Table ID"
-// @Param request body contract.ReleaseTableRequest true "Release table data"
-// @Success 200 {object} contract.TableResponse
-// @Failure 400 {object} contract.ResponseError
-// @Failure 404 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /tables/{id}/release [post]
 func (h *TableHandler) ReleaseTable(c *gin.Context) {
+	ctx := c.Request.Context()
+
 	id := c.Param("id")
 	tableID, err := uuid.Parse(id)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid table ID",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::ReleaseTable -> Invalid table ID")
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid table ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::ReleaseTable")
 		return
 	}

 	var req contract.ReleaseTableRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid request body",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::ReleaseTable -> request binding failed")
+		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::ReleaseTable")
 		return
 	}

-	response, err := h.tableService.ReleaseTable(c.Request.Context(), tableID, req)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, contract.ResponseError{
-			Error:   "Failed to release table",
-			Message: err.Error(),
-		})
+	if err := h.tableValidator.ValidateReleaseTableRequest(req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::ReleaseTable -> validation failed")
+		validationResponseError := contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::ReleaseTable")
 		return
 	}

-	c.JSON(http.StatusOK, response)
+	response := h.tableService.ReleaseTable(ctx, tableID, &req)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::ReleaseTable -> service failed")
+	}
+
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::ReleaseTable")
 }

-// GetAvailableTables godoc
-// @Summary Get available tables
-// @Description Get list of available tables for an outlet
-// @Tags tables
-// @Produce json
-// @Param outlet_id path string true "Outlet ID"
-// @Success 200 {array} contract.TableResponse
-// @Failure 400 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /outlets/{outlet_id}/tables/available [get]
 func (h *TableHandler) GetAvailableTables(c *gin.Context) {
+	ctx := c.Request.Context()
+
 	outletIDStr := c.Param("outlet_id")
 	outletID, err := uuid.Parse(outletIDStr)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid outlet ID",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::GetAvailableTables -> Invalid outlet ID")
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::GetAvailableTables")
 		return
 	}

-	tables, err := h.tableService.GetAvailableTables(c.Request.Context(), outletID)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, contract.ResponseError{
-			Error:   "Failed to get available tables",
-			Message: err.Error(),
-		})
-		return
+	response := h.tableService.GetAvailableTables(ctx, outletID)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::GetAvailableTables -> service failed")
 	}

-	c.JSON(http.StatusOK, tables)
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::GetAvailableTables")
 }

-// GetOccupiedTables godoc
-// @Summary Get occupied tables
-// @Description Get list of occupied tables for an outlet
-// @Tags tables
-// @Produce json
-// @Param outlet_id path string true "Outlet ID"
-// @Success 200 {array} contract.TableResponse
-// @Failure 400 {object} contract.ResponseError
-// @Failure 500 {object} contract.ResponseError
-// @Router /outlets/{outlet_id}/tables/occupied [get]
 func (h *TableHandler) GetOccupiedTables(c *gin.Context) {
+	ctx := c.Request.Context()
+
 	outletIDStr := c.Param("outlet_id")
 	outletID, err := uuid.Parse(outletIDStr)
 	if err != nil {
-		c.JSON(http.StatusBadRequest, contract.ResponseError{
-			Error:   "Invalid outlet ID",
-			Message: err.Error(),
-		})
+		logger.FromContext(ctx).WithError(err).Error("TableHandler::GetOccupiedTables -> Invalid outlet ID")
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "TableHandler::GetOccupiedTables")
 		return
 	}

-	tables, err := h.tableService.GetOccupiedTables(c.Request.Context(), outletID)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, contract.ResponseError{
-			Error:   "Failed to get occupied tables",
-			Message: err.Error(),
-		})
-		return
+	response := h.tableService.GetOccupiedTables(ctx, outletID)
+	if response.HasErrors() {
+		errorResp := response.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("TableHandler::GetOccupiedTables -> service failed")
 	}

-	c.JSON(http.StatusOK, tables)
+	util.HandleResponse(c.Writer, c.Request, response, "TableHandler::GetOccupiedTables")
 }