init

internal/service/table_service.go

@@ -0,0 +1,182 @@
+package service
+
+import (
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/processor"
+	"apskel-pos-be/internal/transformer"
+	"context"
+	"strconv"
+
+	"github.com/google/uuid"
+)
+
+type TableService struct {
+	tableProcessor   *processor.TableProcessor
+	tableTransformer *transformer.TableTransformer
+}
+
+func NewTableService(tableProcessor *processor.TableProcessor, tableTransformer *transformer.TableTransformer) *TableService {
+	return &TableService{
+		tableProcessor:   tableProcessor,
+		tableTransformer: tableTransformer,
+	}
+}
+
+func (s *TableService) Create(ctx context.Context, req contract.CreateTableRequest, organizationID uuid.UUID) (*contract.TableResponse, error) {
+	modelReq := models.CreateTableRequest{
+		OutletID:  req.OutletID,
+		TableName: req.TableName,
+		PositionX: req.PositionX,
+		PositionY: req.PositionY,
+		Capacity:  req.Capacity,
+		Metadata:  req.Metadata,
+	}
+
+	response, err := s.tableProcessor.Create(ctx, modelReq, organizationID)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.tableTransformer.ToContract(*response), nil
+}
+
+func (s *TableService) GetByID(ctx context.Context, id uuid.UUID) (*contract.TableResponse, error) {
+	response, err := s.tableProcessor.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.tableTransformer.ToContract(*response), nil
+}
+
+func (s *TableService) Update(ctx context.Context, id uuid.UUID, req contract.UpdateTableRequest) (*contract.TableResponse, error) {
+	modelReq := models.UpdateTableRequest{
+		TableName: req.TableName,
+		PositionX: req.PositionX,
+		PositionY: req.PositionY,
+		Capacity:  req.Capacity,
+		IsActive:  req.IsActive,
+		Metadata:  req.Metadata,
+	}
+
+	if req.Status != nil {
+		status := models.TableStatus(*req.Status)
+		modelReq.Status = &status
+	}
+
+	response, err := s.tableProcessor.Update(ctx, id, modelReq)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.tableTransformer.ToContract(*response), nil
+}
+
+func (s *TableService) Delete(ctx context.Context, id uuid.UUID) error {
+	return s.tableProcessor.Delete(ctx, id)
+}
+
+func (s *TableService) List(ctx context.Context, query contract.ListTablesQuery) (*contract.ListTablesResponse, error) {
+	req := models.ListTablesRequest{
+		Page:   query.Page,
+		Limit:  query.Limit,
+		Search: query.Search,
+	}
+
+	if query.OrganizationID != "" {
+		if orgID, err := uuid.Parse(query.OrganizationID); err == nil {
+			req.OrganizationID = &orgID
+		}
+	}
+
+	if query.OutletID != "" {
+		if outletID, err := uuid.Parse(query.OutletID); err == nil {
+			req.OutletID = &outletID
+		}
+	}
+
+	if query.Status != "" {
+		status := models.TableStatus(query.Status)
+		req.Status = &status
+	}
+
+	if query.IsActive != "" {
+		if isActive, err := strconv.ParseBool(query.IsActive); err == nil {
+			req.IsActive = &isActive
+		}
+	}
+
+	response, err := s.tableProcessor.List(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	contractTables := make([]contract.TableResponse, len(response.Tables))
+	for i, table := range response.Tables {
+		contractTables[i] = *s.tableTransformer.ToContract(table)
+	}
+
+	return &contract.ListTablesResponse{
+		Tables:     contractTables,
+		TotalCount: response.TotalCount,
+		Page:       response.Page,
+		Limit:      response.Limit,
+		TotalPages: response.TotalPages,
+	}, nil
+}
+
+func (s *TableService) OccupyTable(ctx context.Context, tableID uuid.UUID, req contract.OccupyTableRequest) (*contract.TableResponse, error) {
+	modelReq := models.OccupyTableRequest{
+		OrderID:   req.OrderID,
+		StartTime: req.StartTime,
+	}
+
+	response, err := s.tableProcessor.OccupyTable(ctx, tableID, modelReq)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.tableTransformer.ToContract(*response), nil
+}
+
+func (s *TableService) ReleaseTable(ctx context.Context, tableID uuid.UUID, req contract.ReleaseTableRequest) (*contract.TableResponse, error) {
+	modelReq := models.ReleaseTableRequest{
+		PaymentAmount: req.PaymentAmount,
+	}
+
+	response, err := s.tableProcessor.ReleaseTable(ctx, tableID, modelReq)
+	if err != nil {
+		return nil, err
+	}
+
+	return s.tableTransformer.ToContract(*response), nil
+}
+
+func (s *TableService) GetAvailableTables(ctx context.Context, outletID uuid.UUID) ([]contract.TableResponse, error) {
+	tables, err := s.tableProcessor.GetAvailableTables(ctx, outletID)
+	if err != nil {
+		return nil, err
+	}
+
+	responses := make([]contract.TableResponse, len(tables))
+	for i, table := range tables {
+		responses[i] = *s.tableTransformer.ToContract(table)
+	}
+
+	return responses, nil
+}
+
+func (s *TableService) GetOccupiedTables(ctx context.Context, outletID uuid.UUID) ([]contract.TableResponse, error) {
+	tables, err := s.tableProcessor.GetOccupiedTables(ctx, outletID)
+	if err != nil {
+		return nil, err
+	}
+
+	responses := make([]contract.TableResponse, len(tables))
+	for i, table := range tables {
+		responses[i] = *s.tableTransformer.ToContract(table)
+	}
+
+	return responses, nil
+}

internal/service/user_processor.go

@@ -19,4 +19,5 @@ type UserProcessor interface {
 	ChangePassword(ctx context.Context, userID uuid.UUID, req *models.ChangePasswordRequest) error
 	ActivateUser(ctx context.Context, userID uuid.UUID) error
 	DeactivateUser(ctx context.Context, userID uuid.UUID) error
+	UpdateUserOutlet(ctx context.Context, userID uuid.UUID, req *models.UpdateUserOutletRequest) (*models.UserResponse, error)
 }

internal/service/user_service.go

@@ -99,3 +99,15 @@ func (s *UserServiceImpl) ActivateUser(ctx context.Context, userID uuid.UUID) er
 func (s *UserServiceImpl) DeactivateUser(ctx context.Context, userID uuid.UUID) error {
 	return s.userProcessor.DeactivateUser(ctx, userID)
 }
+
+func (s *UserServiceImpl) UpdateUserOutlet(ctx context.Context, userID uuid.UUID, req *contract.UpdateUserOutletRequest) (*contract.UserResponse, error) {
+	modelReq := transformer.UpdateUserOutletRequestToModel(req)
+
+	userResponse, err := s.userProcessor.UpdateUserOutlet(ctx, userID, modelReq)
+	if err != nil {
+		return nil, err
+	}
+
+	contractResponse := transformer.UserModelResponseToResponse(userResponse)
+	return contractResponse, nil
+}