apksel-dev/apskel-pos-backend
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update

Browse Source
This commit is contained in:
Aditya Siregar
2025-08-03 00:34:25 +07:00
parent a759e0f57c
commit 96743cf50b
25 changed files with 2049 additions and 2141 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/service/table_service.go
+71 -99
View File
@@ -1,115 +1,84 @@
package service
import (
"apskel-pos-be/internal/appcontext"
"apskel-pos-be/internal/constants"
"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 {
type TableServiceImpl struct {
tableProcessor *processor.TableProcessor
tableTransformer *transformer.TableTransformer
}
func NewTableService(tableProcessor *processor.TableProcessor, tableTransformer *transformer.TableTransformer) *TableService {
return &TableService{
func NewTableService(tableProcessor *processor.TableProcessor, tableTransformer *transformer.TableTransformer) *TableServiceImpl {
return &TableServiceImpl{
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,
}
func (s *TableServiceImpl) CreateTable(ctx context.Context, apctx *appcontext.ContextInfo, req *contract.CreateTableRequest) *contract.Response {
modelReq := transformer.CreateTableRequestToModel(apctx, req)
response, err := s.tableProcessor.Create(ctx, modelReq, organizationID)
response, err := s.tableProcessor.Create(ctx, modelReq, apctx.OrganizationID)
if err != nil {
return nil, err
errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.TableEntity, err.Error())
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
return s.tableTransformer.ToContract(*response), nil
contractResponse := s.tableTransformer.ToContract(*response)
return contract.BuildSuccessResponse(contractResponse)
}
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
}
func (s *TableServiceImpl) UpdateTable(ctx context.Context, id uuid.UUID, req *contract.UpdateTableRequest) *contract.Response {
modelReq := transformer.UpdateTableRequestToModel(req)
response, err := s.tableProcessor.Update(ctx, id, modelReq)
if err != nil {
return nil, err
errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.TableEntity, err.Error())
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
return s.tableTransformer.ToContract(*response), nil
contractResponse := s.tableTransformer.ToContract(*response)
return contract.BuildSuccessResponse(contractResponse)
}
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)
func (s *TableServiceImpl) DeleteTable(ctx context.Context, id uuid.UUID) *contract.Response {
err := s.tableProcessor.Delete(ctx, id)
if err != nil {
return nil, err
errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.TableEntity, err.Error())
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
return contract.BuildSuccessResponse(map[string]interface{}{
"message": "Table deleted successfully",
})
}
func (s *TableServiceImpl) GetTableByID(ctx context.Context, id uuid.UUID) *contract.Response {
response, err := s.tableProcessor.GetByID(ctx, id)
if err != nil {
errorResp := contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "Table not found")
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
contractResponse := s.tableTransformer.ToContract(*response)
return contract.BuildSuccessResponse(contractResponse)
}
func (s *TableServiceImpl) ListTables(ctx context.Context, req *contract.ListTablesQuery) *contract.Response {
modelReq := transformer.ListTablesQueryToModel(req)
response, err := s.tableProcessor.List(ctx, modelReq)
if err != nil {
errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.TableEntity, err.Error())
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
contractTables := make([]contract.TableResponse, len(response.Tables))
@@ -117,46 +86,48 @@ func (s *TableService) List(ctx context.Context, query contract.ListTablesQuery)
contractTables[i] = *s.tableTransformer.ToContract(table)
}
return &contract.ListTablesResponse{
contractResponse := &contract.ListTablesResponse{
Tables: contractTables,
TotalCount: response.TotalCount,
Page: response.Page,
Limit: response.Limit,
TotalPages: response.TotalPages,
}, nil
}
return contract.BuildSuccessResponse(contractResponse)
}
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,
}
func (s *TableServiceImpl) OccupyTable(ctx context.Context, tableID uuid.UUID, req *contract.OccupyTableRequest) *contract.Response {
modelReq := transformer.OccupyTableRequestToModel(req)
response, err := s.tableProcessor.OccupyTable(ctx, tableID, modelReq)
if err != nil {
return nil, err
errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.TableEntity, err.Error())
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
return s.tableTransformer.ToContract(*response), nil
contractResponse := s.tableTransformer.ToContract(*response)
return contract.BuildSuccessResponse(contractResponse)
}
func (s *TableService) ReleaseTable(ctx context.Context, tableID uuid.UUID, req contract.ReleaseTableRequest) (*contract.TableResponse, error) {
modelReq := models.ReleaseTableRequest{
PaymentAmount: req.PaymentAmount,
}
func (s *TableServiceImpl) ReleaseTable(ctx context.Context, tableID uuid.UUID, req *contract.ReleaseTableRequest) *contract.Response {
modelReq := transformer.ReleaseTableRequestToModel(req)
response, err := s.tableProcessor.ReleaseTable(ctx, tableID, modelReq)
if err != nil {
return nil, err
errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.TableEntity, err.Error())
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
return s.tableTransformer.ToContract(*response), nil
contractResponse := s.tableTransformer.ToContract(*response)
return contract.BuildSuccessResponse(contractResponse)
}
func (s *TableService) GetAvailableTables(ctx context.Context, outletID uuid.UUID) ([]contract.TableResponse, error) {
func (s *TableServiceImpl) GetAvailableTables(ctx context.Context, outletID uuid.UUID) *contract.Response {
tables, err := s.tableProcessor.GetAvailableTables(ctx, outletID)
if err != nil {
return nil, err
errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.TableEntity, err.Error())
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
responses := make([]contract.TableResponse, len(tables))
@@ -164,13 +135,14 @@ func (s *TableService) GetAvailableTables(ctx context.Context, outletID uuid.UUI
responses[i] = *s.tableTransformer.ToContract(table)
}
return responses, nil
return contract.BuildSuccessResponse(responses)
}
func (s *TableService) GetOccupiedTables(ctx context.Context, outletID uuid.UUID) ([]contract.TableResponse, error) {
func (s *TableServiceImpl) GetOccupiedTables(ctx context.Context, outletID uuid.UUID) *contract.Response {
tables, err := s.tableProcessor.GetOccupiedTables(ctx, outletID)
if err != nil {
return nil, err
errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.TableEntity, err.Error())
return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
}
responses := make([]contract.TableResponse, len(tables))
@@ -178,5 +150,5 @@ func (s *TableService) GetOccupiedTables(ctx context.Context, outletID uuid.UUID
responses[i] = *s.tableTransformer.ToContract(table)
}
return responses, nil
return contract.BuildSuccessResponse(responses)
}