Token and session implementation with Redis

2026-05-08 18:41:14 +07:00
parent fe57aab3b4
commit 3c103b7692
20 changed files with 545 additions and 90 deletions
@@ -6,6 +6,7 @@ import (
 	"apskel-pos-be/internal/entities"
 	"apskel-pos-be/internal/logger"
 	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/pkg/tabletoken"
 	"apskel-pos-be/internal/processor"
 	"apskel-pos-be/internal/repository"
 	"apskel-pos-be/internal/service"
@@ -25,6 +26,7 @@ type SelfOrderHandler struct {
 	tableRepo       repository.TableRepositoryInterface
 	outletRepo      processor.OutletRepository
 	userRepo        processor.UserRepository
+	sessionRepo     repository.SessionRepository
 }

 func NewSelfOrderHandler(
@@ -34,6 +36,7 @@ func NewSelfOrderHandler(
 	tableRepo repository.TableRepositoryInterface,
 	outletRepo processor.OutletRepository,
 	userRepo processor.UserRepository,
+	sessionRepo repository.SessionRepository,
 ) *SelfOrderHandler {
 	return &SelfOrderHandler{
 		orderService:    orderService,
@@ -42,9 +45,107 @@ func NewSelfOrderHandler(
 		tableRepo:       tableRepo,
 		outletRepo:      outletRepo,
 		userRepo:        userRepo,
+		sessionRepo:     sessionRepo,
 	}
 }

+func (h *SelfOrderHandler) ValidateToken(c *gin.Context) {
+	ctx := c.Request.Context()
+	token := c.Param("token")
+
+	if token == "" {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "token is required"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	tableID, orgID, outletID, err := tabletoken.Decode(token)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> invalid token")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, "invalid table token"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	table, err := h.tableRepo.GetByID(ctx, tableID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> table not found")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "table not found"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	if !table.IsActive {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.TableEntity, "table is not active"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	if table.OrganizationID != orgID || table.OutletID != outletID {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.ValidationErrorCode, constants.TableEntity, "token does not match table"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	outlet, err := h.outletRepo.GetByID(ctx, table.OutletID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> outlet not found")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.OrderServiceEntity, "outlet not found"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	existingSession, err := h.sessionRepo.GetActiveByTableID(ctx, table.ID)
+	if err != nil {
+		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> failed to check session")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.InternalServerErrorCode, constants.OrderServiceEntity, "failed to check session"),
+		}), "SelfOrderHandler::ValidateToken")
+		return
+	}
+
+	var sessionStatus string
+	var sessionID string
+
+	if existingSession != nil {
+		sessionStatus = "joined_session"
+		sessionID = existingSession.ID
+	} else {
+		session := &models.SelfOrderSession{
+			TableID:        table.ID,
+			OrganizationID: table.OrganizationID,
+			OutletID:       table.OutletID,
+		}
+		if err := h.sessionRepo.Create(ctx, session); err != nil {
+			logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ValidateToken -> failed to create session")
+			util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+				contract.NewResponseError(constants.InternalServerErrorCode, constants.OrderServiceEntity, "failed to create session"),
+			}), "SelfOrderHandler::ValidateToken")
+			return
+		}
+		sessionStatus = "new_session"
+		sessionID = session.ID
+	}
+
+	resp := &contract.SelfOrderTableTokenResponse{
+		SessionID:      sessionID,
+		TableID:        table.ID.String(),
+		OrganizationID: table.OrganizationID.String(),
+		OutletID:       table.OutletID.String(),
+		TableName:      table.TableName,
+		OutletName:     outlet.Name,
+		Status:         sessionStatus,
+	}
+
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(resp), "SelfOrderHandler::ValidateToken")
+}
+
 func (h *SelfOrderHandler) GetMenu(c *gin.Context) {
 	ctx := c.Request.Context()

@@ -57,41 +158,16 @@ func (h *SelfOrderHandler) GetMenu(c *gin.Context) {
 		return
 	}

-	if req.TableID == uuid.Nil {
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "table_id is required"),
-		}), "SelfOrderHandler::GetMenu")
-		return
-	}
-
-	if req.CustomerName == "" {
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "customer_name is required"),
-		}), "SelfOrderHandler::GetMenu")
-		return
-	}
-
-	table, err := h.tableRepo.GetByID(ctx, req.TableID)
+	session, table, outlet, err := h.resolveSession(ctx, req.SessionID)
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::GetMenu -> table not found")
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "table not found"),
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error()),
 		}), "SelfOrderHandler::GetMenu")
 		return
 	}
-
-	if !table.IsActive {
+	if session == nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.ValidationErrorCode, constants.TableEntity, "table is not active"),
-		}), "SelfOrderHandler::GetMenu")
-		return
-	}
-
-	outlet, err := h.outletRepo.GetByID(ctx, table.OutletID)
-	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::GetMenu -> outlet not found")
-		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.NotFoundErrorCode, constants.OrderServiceEntity, "outlet not found"),
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.RequestEntity, "session not found or expired"),
 		}), "SelfOrderHandler::GetMenu")
 		return
 	}
@@ -208,11 +284,16 @@ func (h *SelfOrderHandler) CreateOrder(c *gin.Context) {
 		return
 	}

-	table, err := h.tableRepo.GetByID(ctx, req.TableID)
+	session, table, _, err := h.resolveSession(ctx, req.SessionID)
 	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::CreateOrder -> table not found")
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "table not found"),
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error()),
+		}), "SelfOrderHandler::CreateOrder")
+		return
+	}
+	if session == nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.RequestEntity, "session not found or expired"),
 		}), "SelfOrderHandler::CreateOrder")
 		return
 	}
@@ -245,21 +326,17 @@ func (h *SelfOrderHandler) CreateOrder(c *gin.Context) {

 	metadata := make(map[string]interface{})
 	metadata["self_order"] = true
-	metadata["customer_name"] = req.CustomerName
-	if req.Phone != nil {
-		metadata["customer_phone"] = *req.Phone
-	}
+	metadata["session_id"] = session.ID

-	tableID := req.TableID
+	tableID := table.ID
 	modelReq := &models.CreateOrderRequest{
-		OutletID:     table.OutletID,
-		UserID:       userID,
-		TableID:      &tableID,
-		TableNumber:  &table.TableName,
-		OrderType:    constants.OrderTypeDineIn,
-		OrderItems:   orderItems,
-		CustomerName: &req.CustomerName,
-		Metadata:     metadata,
+		OutletID:    table.OutletID,
+		UserID:      userID,
+		TableID:     &tableID,
+		TableNumber: &table.TableName,
+		OrderType:   constants.OrderTypeDineIn,
+		OrderItems:  orderItems,
+		Metadata:    metadata,
 	}

 	response, err := h.orderService.CreateOrder(ctx, modelReq, table.OrganizationID)
@@ -276,11 +353,8 @@ func (h *SelfOrderHandler) CreateOrder(c *gin.Context) {
 }

 func (h *SelfOrderHandler) validateCreateOrderRequest(req *contract.SelfOrderCreateOrderRequest) error {
-	if req.TableID == uuid.Nil {
-		return fmt.Errorf("table_id is required")
-	}
-	if req.CustomerName == "" {
-		return fmt.Errorf("customer_name is required")
+	if req.SessionID == "" {
+		return fmt.Errorf("session_id is required")
 	}
 	if len(req.OrderItems) == 0 {
 		return fmt.Errorf("at least one order item is required")
@@ -308,26 +382,23 @@ func (h *SelfOrderHandler) ListCategories(c *gin.Context) {
 		return
 	}

-	if req.TableID == "" {
+	if req.SessionID == "" {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "table_id is required"),
+			contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, "session_id is required"),
 		}), "SelfOrderHandler::ListCategories")
 		return
 	}

-	parsedTableID, err := uuid.Parse(req.TableID)
+	session, table, _, err := h.resolveSession(ctx, req.SessionID)
 	if err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, "table_id must be a valid UUID"),
+			contract.NewResponseError(constants.ValidationErrorCode, constants.RequestEntity, err.Error()),
 		}), "SelfOrderHandler::ListCategories")
 		return
 	}
-
-	table, err := h.tableRepo.GetByID(ctx, parsedTableID)
-	if err != nil {
-		logger.FromContext(ctx).WithError(err).Error("SelfOrderHandler::ListCategories -> table not found")
+	if session == nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{
-			contract.NewResponseError(constants.NotFoundErrorCode, constants.TableEntity, "table not found"),
+			contract.NewResponseError(constants.NotFoundErrorCode, constants.RequestEntity, "session not found or expired"),
 		}), "SelfOrderHandler::ListCategories")
 		return
 	}
@@ -366,6 +437,31 @@ func (h *SelfOrderHandler) ListCategories(c *gin.Context) {
 	}), "SelfOrderHandler::ListCategories")
 }

+func (h *SelfOrderHandler) resolveSession(ctx context.Context, sessionID string) (*models.SelfOrderSession, *entities.Table, *entities.Outlet, error) {
+	session, err := h.sessionRepo.GetByID(ctx, sessionID)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("failed to get session: %w", err)
+	}
+	if session == nil {
+		return nil, nil, nil, nil
+	}
+	if session.Status != "active" {
+		return nil, nil, nil, fmt.Errorf("session is no longer active")
+	}
+
+	table, err := h.tableRepo.GetByID(ctx, session.TableID)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("table not found for session")
+	}
+
+	outlet, err := h.outletRepo.GetByID(ctx, table.OutletID)
+	if err != nil {
+		return nil, nil, nil, fmt.Errorf("outlet not found for session")
+	}
+
+	return session, table, outlet, nil
+}
+
 func (h *SelfOrderHandler) resolveOrgUser(ctx context.Context, organizationID uuid.UUID) (uuid.UUID, error) {
 	users, err := h.userRepo.GetByOrganizationID(ctx, organizationID)
 	if err != nil {