Update

internal/transformer/table_transformer.go

@@ -1,8 +1,13 @@
 package transformer
 
 import (
+	"apskel-pos-be/internal/appcontext"
+	"apskel-pos-be/internal/constants"
 	"apskel-pos-be/internal/contract"
 	"apskel-pos-be/internal/models"
+	"strconv"
+
+	"github.com/google/uuid"
 )
 
 type TableTransformer struct{}
@@ -33,10 +38,8 @@ func (t *TableTransformer) ToContract(model models.TableResponse) *contract.Tabl
 	if model.Order != nil {
 		response.Order = &contract.OrderResponse{
 			ID:             model.Order.ID,
-			OrganizationID: model.Order.OrganizationID,
 			OutletID:       model.Order.OutletID,
 			UserID:         model.Order.UserID,
-			CustomerID:     model.Order.CustomerID,
 			OrderNumber:    model.Order.OrderNumber,
 			TableNumber:    model.Order.TableNumber,
 			OrderType:      string(model.Order.OrderType),
@@ -45,17 +48,6 @@ func (t *TableTransformer) ToContract(model models.TableResponse) *contract.Tabl
 			TaxAmount:      model.Order.TaxAmount,
 			DiscountAmount: model.Order.DiscountAmount,
 			TotalAmount:    model.Order.TotalAmount,
-			TotalCost:      model.Order.TotalCost,
-			PaymentStatus:  string(model.Order.PaymentStatus),
-			RefundAmount:   model.Order.RefundAmount,
-			IsVoid:         model.Order.IsVoid,
-			IsRefund:       model.Order.IsRefund,
-			VoidReason:     model.Order.VoidReason,
-			VoidedAt:       model.Order.VoidedAt,
-			VoidedBy:       model.Order.VoidedBy,
-			RefundReason:   model.Order.RefundReason,
-			RefundedAt:     model.Order.RefundedAt,
-			RefundedBy:     model.Order.RefundedBy,
 			Metadata:       model.Order.Metadata,
 			CreatedAt:      model.Order.CreatedAt,
 			UpdatedAt:      model.Order.UpdatedAt,
@@ -65,56 +57,77 @@ func (t *TableTransformer) ToContract(model models.TableResponse) *contract.Tabl
 	return response
 }
 
-func (t *TableTransformer) ToModel(contract contract.TableResponse) *models.TableResponse {
-	response := &models.TableResponse{
-		ID:             contract.ID,
-		OrganizationID: contract.OrganizationID,
-		OutletID:       contract.OutletID,
-		TableName:      contract.TableName,
-		StartTime:      contract.StartTime,
-		Status:         models.TableStatus(contract.Status),
-		OrderID:        contract.OrderID,
-		PaymentAmount:  contract.PaymentAmount,
-		PositionX:      contract.PositionX,
-		PositionY:      contract.PositionY,
-		Capacity:       contract.Capacity,
-		IsActive:       contract.IsActive,
-		Metadata:       contract.Metadata,
-		CreatedAt:      contract.CreatedAt,
-		UpdatedAt:      contract.UpdatedAt,
+func CreateTableRequestToModel(apctx *appcontext.ContextInfo, req *contract.CreateTableRequest) models.CreateTableRequest {
+	return models.CreateTableRequest{
+		OutletID:  req.OutletID,
+		TableName: req.TableName,
+		PositionX: req.PositionX,
+		PositionY: req.PositionY,
+		Capacity:  req.Capacity,
+		Metadata:  req.Metadata,
+	}
+}
+
+func UpdateTableRequestToModel(req *contract.UpdateTableRequest) models.UpdateTableRequest {
+	modelReq := models.UpdateTableRequest{
+		TableName: req.TableName,
+		PositionX: req.PositionX,
+		PositionY: req.PositionY,
+		Capacity:  req.Capacity,
+		IsActive:  req.IsActive,
+		Metadata:  req.Metadata,
 	}
 
-	if contract.Order != nil {
-		response.Order = &models.OrderResponse{
-			ID:             contract.Order.ID,
-			OrganizationID: contract.Order.OrganizationID,
-			OutletID:       contract.Order.OutletID,
-			UserID:         contract.Order.UserID,
-			CustomerID:     contract.Order.CustomerID,
-			OrderNumber:    contract.Order.OrderNumber,
-			TableNumber:    contract.Order.TableNumber,
-			OrderType:      models.OrderType(contract.Order.OrderType),
-			Status:         models.OrderStatus(contract.Order.Status),
-			Subtotal:       contract.Order.Subtotal,
-			TaxAmount:      contract.Order.TaxAmount,
-			DiscountAmount: contract.Order.DiscountAmount,
-			TotalAmount:    contract.Order.TotalAmount,
-			TotalCost:      contract.Order.TotalCost,
-			PaymentStatus:  models.PaymentStatus(contract.Order.PaymentStatus),
-			RefundAmount:   contract.Order.RefundAmount,
-			IsVoid:         contract.Order.IsVoid,
-			IsRefund:       contract.Order.IsRefund,
-			VoidReason:     contract.Order.VoidReason,
-			VoidedAt:       contract.Order.VoidedAt,
-			VoidedBy:       contract.Order.VoidedBy,
-			RefundReason:   contract.Order.RefundReason,
-			RefundedAt:     contract.Order.RefundedAt,
-			RefundedBy:     contract.Order.RefundedBy,
-			Metadata:       contract.Order.Metadata,
-			CreatedAt:      contract.Order.CreatedAt,
-			UpdatedAt:      contract.Order.UpdatedAt,
+	if req.Status != nil {
+		status := constants.TableStatus(*req.Status)
+		modelReq.Status = &status
+	}
+
+	return modelReq
+}
+
+func OccupyTableRequestToModel(req *contract.OccupyTableRequest) models.OccupyTableRequest {
+	return models.OccupyTableRequest{
+		OrderID:   req.OrderID,
+		StartTime: req.StartTime,
+	}
+}
+
+func ReleaseTableRequestToModel(req *contract.ReleaseTableRequest) models.ReleaseTableRequest {
+	return models.ReleaseTableRequest{
+		PaymentAmount: req.PaymentAmount,
+	}
+}
+
+func ListTablesQueryToModel(req *contract.ListTablesQuery) models.ListTablesRequest {
+	modelReq := models.ListTablesRequest{
+		Page:   req.Page,
+		Limit:  req.Limit,
+		Search: req.Search,
+	}
+
+	if req.OrganizationID != "" {
+		if orgID, err := uuid.Parse(req.OrganizationID); err == nil {
+			modelReq.OrganizationID = &orgID
 		}
 	}
 
-	return response
+	if req.OutletID != "" {
+		if outletID, err := uuid.Parse(req.OutletID); err == nil {
+			modelReq.OutletID = &outletID
+		}
+	}
+
+	if req.Status != "" {
+		status := constants.TableStatus(req.Status)
+		modelReq.Status = &status
+	}
+
+	if req.IsActive != "" {
+		if isActive, err := strconv.ParseBool(req.IsActive); err == nil {
+			modelReq.IsActive = &isActive
+		}
+	}
+
+	return modelReq
 }