apskel-pos-backend/internal/transformer/table_transformer.go

package transformer

import (
	"apskel-pos-be/internal/contract"
	"apskel-pos-be/internal/models"
)

type TableTransformer struct{}

func NewTableTransformer() *TableTransformer {
	return &TableTransformer{}
}

func (t *TableTransformer) ToContract(model models.TableResponse) *contract.TableResponse {
	response := &contract.TableResponse{
		ID:             model.ID,
		OrganizationID: model.OrganizationID,
		OutletID:       model.OutletID,
		TableName:      model.TableName,
		StartTime:      model.StartTime,
		Status:         string(model.Status),
		OrderID:        model.OrderID,
		PaymentAmount:  model.PaymentAmount,
		PositionX:      model.PositionX,
		PositionY:      model.PositionY,
		Capacity:       model.Capacity,
		IsActive:       model.IsActive,
		Metadata:       model.Metadata,
		CreatedAt:      model.CreatedAt,
		UpdatedAt:      model.UpdatedAt,
	}

	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),
			Status:         string(model.Order.Status),
			Subtotal:       model.Order.Subtotal,
			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,
		}
	}

	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,
	}

	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,
		}
	}

	return response
}