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

Token and session implementation with Redis

Browse Source
This commit is contained in:
ryan
2026-05-08 18:41:14 +07:00
parent fe57aab3b4
commit 3c103b7692
20 changed files with 545 additions and 90 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/app/app.go
+15 -9
View File
@@ -20,20 +20,23 @@ import (
"apskel-pos-be/internal/service"
"apskel-pos-be/internal/validator"
"github.com/redis/go-redis/v9"
"gorm.io/gorm"
)
type App struct {
server *http.Server
db *gorm.DB
router *router.Router
shutdown chan os.Signal
server *http.Server
db *gorm.DB
redisClient *redis.Client
router *router.Router
shutdown chan os.Signal
}
func NewApp(db *gorm.DB) *App {
func NewApp(db *gorm.DB, redisClient *redis.Client) *App {
return &App{
db: db,
shutdown: make(chan os.Signal, 1),
db: db,
redisClient: redisClient,
shutdown: make(chan os.Signal, 1),
}
}
@@ -51,6 +54,7 @@ func (a *App) Initialize(cfg *config.Config) error {
repos.tableRepo,
repos.outletRepo,
repos.userRepo,
repos.sessionRepo,
)
a.router = router.NewRouter(
@@ -200,6 +204,7 @@ type repositories struct {
customerAuthRepo repository.CustomerAuthRepository
customerPointsRepo repository.CustomerPointsRepository
otpRepo repository.OtpRepository
sessionRepo repository.SessionRepository
txManager *repository.TxManager
}
@@ -246,6 +251,7 @@ func (a *App) initRepositories() *repositories {
customerAuthRepo: repository.NewCustomerAuthRepository(a.db),
customerPointsRepo: repository.NewCustomerPointsRepository(a.db),
otpRepo: repository.NewOtpRepository(a.db),
sessionRepo: repository.NewSessionRepository(a.redisClient),
txManager: repository.NewTxManager(a.db),
}
}
@@ -384,7 +390,7 @@ func (a *App) initServices(processors *processors, repos *repositories, cfg *con
productService := service.NewProductService(processors.productProcessor)
productVariantService := service.NewProductVariantService(processors.productVariantProcessor)
inventoryService := service.NewInventoryService(processors.inventoryProcessor)
orderService := service.NewOrderServiceImpl(processors.orderProcessor, repos.tableRepo, nil, processors.orderIngredientTransactionProcessor, *repos.productRecipeRepo, repos.txManager) // Will be updated after orderIngredientTransactionService is created
orderService := service.NewOrderServiceImpl(processors.orderProcessor, repos.tableRepo, nil, processors.orderIngredientTransactionProcessor, *repos.productRecipeRepo, repos.txManager, repos.sessionRepo) // Will be updated after orderIngredientTransactionService is created
paymentMethodService := service.NewPaymentMethodService(processors.paymentMethodProcessor)
fileService := service.NewFileServiceImpl(processors.fileProcessor)
var customerService service.CustomerService = service.NewCustomerService(processors.customerProcessor)
@@ -409,7 +415,7 @@ func (a *App) initServices(processors *processors, repos *repositories, cfg *con
spinGameService := service.NewSpinGameService(processors.gamePlayProcessor, repos.txManager)
// Update order service with order ingredient transaction service
orderService = service.NewOrderServiceImpl(processors.orderProcessor, repos.tableRepo, orderIngredientTransactionService, processors.orderIngredientTransactionProcessor, *repos.productRecipeRepo, repos.txManager)
orderService = service.NewOrderServiceImpl(processors.orderProcessor, repos.tableRepo, orderIngredientTransactionService, processors.orderIngredientTransactionProcessor, *repos.productRecipeRepo, repos.txManager, repos.sessionRepo)
return &services{
userService: service.NewUserService(processors.userProcessor),
internal/contract/self_order_contract.go
+14 -8
View File
@@ -4,10 +4,18 @@ import (
"github.com/google/uuid"
)
type SelfOrderTableTokenResponse struct {
SessionID string `json:"session_id"`
TableID string `json:"table_id"`
OrganizationID string `json:"organization_id"`
OutletID string `json:"outlet_id"`
TableName string `json:"table_name"`
OutletName string `json:"outlet_name"`
Status string `json:"status"`
}
type SelfOrderMenuRequest struct {
TableID uuid.UUID `json:"table_id" validate:"required"`
CustomerName string `json:"customer_name" validate:"required"`
Phone *string `json:"phone,omitempty"`
SessionID string `json:"session_id" validate:"required"`
}
type SelfOrderMenuResponse struct {
@@ -40,10 +48,8 @@ type SelfOrderMenuVariant struct {
}
type SelfOrderCreateOrderRequest struct {
TableID uuid.UUID `json:"table_id" validate:"required"`
CustomerName string `json:"customer_name" validate:"required"`
Phone *string `json:"phone,omitempty"`
OrderItems []SelfOrderCreateOrderItem `json:"order_items" validate:"required,min=1,dive"`
SessionID string `json:"session_id" validate:"required"`
OrderItems []SelfOrderCreateOrderItem `json:"order_items" validate:"required,min=1,dive"`
}
type SelfOrderCreateOrderItem struct {
@@ -54,7 +60,7 @@ type SelfOrderCreateOrderItem struct {
}
type SelfOrderListCategoriesRequest struct {
TableID string `form:"table_id" validate:"required"`
SessionID string `form:"session_id" validate:"required"`
}
type SelfOrderCategoryItem struct {
internal/db/redis.go
+30
View File
@@ -0,0 +1,30 @@
package db
import (
"apskel-pos-be/config"
"fmt"
"github.com/redis/go-redis/v9"
)
func NewRedisClient(c config.Redis) (*redis.Client, error) {
opts := &redis.Options{
Addr: c.Addr(),
Password: c.Password,
DB: c.DB,
DialTimeout: c.ParseDialTimeout(),
ReadTimeout: c.ParseReadTimeout(),
WriteTimeout: c.ParseWriteTimeout(),
}
if c.PoolSize > 0 {
opts.PoolSize = c.PoolSize
}
if c.MinIdleConnections > 0 {
opts.MinIdleConns = c.MinIdleConnections
}
client := redis.NewClient(opts)
fmt.Println("Successfully connected to Redis")
return client, nil
}
internal/entities/table.go
+5
View File
@@ -1,6 +1,7 @@
package entities
import (
"apskel-pos-be/internal/pkg/tabletoken"
"time"
"github.com/google/uuid"
@@ -12,6 +13,7 @@ type Table struct {
OrganizationID uuid.UUID `gorm:"type:uuid;not null;index" json:"organization_id" validate:"required"`
OutletID uuid.UUID `gorm:"type:uuid;not null;index" json:"outlet_id" validate:"required"`
TableName string `gorm:"not null;size:100" json:"table_name" validate:"required"`
Token string `gorm:"uniqueIndex;not null;size:255" json:"token"`
StartTime *time.Time `gorm:"" json:"start_time"`
Status string `gorm:"default:'available';size:50" json:"status"`
OrderID *uuid.UUID `gorm:"type:uuid;index" json:"order_id"`
@@ -33,6 +35,9 @@ func (t *Table) BeforeCreate(tx *gorm.DB) error {
if t.ID == uuid.Nil {
t.ID = uuid.New()
}
if t.Token == "" {
t.Token = tabletoken.Encode(t.ID, t.OrganizationID, t.OutletID)
}
return nil
}
internal/handler/self_order_handler.go
+155 -59
View File
@@ -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 {
internal/models/session.go
+18
View File
@@ -0,0 +1,18 @@
package models
import (
"time"
"github.com/google/uuid"
)
type SelfOrderSession struct {
ID string `json:"id"`
TableID uuid.UUID `json:"table_id"`
OrganizationID uuid.UUID `json:"organization_id"`
OutletID uuid.UUID `json:"outlet_id"`
Status string `json:"status"`
CustomerName string `json:"customer_name"`
CreatedAt time.Time `json:"created_at"`
ClosedAt *time.Time `json:"closed_at,omitempty"`
}
internal/pkg/tabletoken/token.go
+43
View File
@@ -0,0 +1,43 @@
package tabletoken
import (
"encoding/base64"
"encoding/json"
"fmt"
"github.com/google/uuid"
)
type TableTokenPayload struct {
TableID uuid.UUID `json:"table_id"`
OrganizationID uuid.UUID `json:"organization_id"`
OutletID uuid.UUID `json:"outlet_id"`
}
func Encode(tableID, organizationID, outletID uuid.UUID) string {
payload := TableTokenPayload{
TableID: tableID,
OrganizationID: organizationID,
OutletID: outletID,
}
jsonBytes, _ := json.Marshal(payload)
return base64.URLEncoding.EncodeToString(jsonBytes)
}
func Decode(token string) (tableID, organizationID, outletID uuid.UUID, err error) {
jsonBytes, err := base64.URLEncoding.DecodeString(token)
if err != nil {
return uuid.Nil, uuid.Nil, uuid.Nil, fmt.Errorf("invalid token encoding: %w", err)
}
var payload TableTokenPayload
if err := json.Unmarshal(jsonBytes, &payload); err != nil {
return uuid.Nil, uuid.Nil, uuid.Nil, fmt.Errorf("invalid token format: %w", err)
}
if payload.TableID == uuid.Nil || payload.OrganizationID == uuid.Nil || payload.OutletID == uuid.Nil {
return uuid.Nil, uuid.Nil, uuid.Nil, fmt.Errorf("token missing required fields")
}
return payload.TableID, payload.OrganizationID, payload.OutletID, nil
}
internal/repository/session_repository.go
+141
View File
@@ -0,0 +1,141 @@
package repository
import (
"apskel-pos-be/internal/models"
"context"
"encoding/json"
"fmt"
"time"
"github.com/google/uuid"
"github.com/redis/go-redis/v9"
)
const (
sessionKeyPrefix = "self_order:session:"
tableSessionKeyPrefix = "self_order:table_session:"
sessionTTL = 24 * time.Hour
sessionStatusActive = "active"
sessionStatusClosed = "closed"
)
type SessionRepository interface {
Create(ctx context.Context, session *models.SelfOrderSession) error
GetByID(ctx context.Context, sessionID string) (*models.SelfOrderSession, error)
GetActiveByTableID(ctx context.Context, tableID uuid.UUID) (*models.SelfOrderSession, error)
Close(ctx context.Context, sessionID string) error
CloseByTableID(ctx context.Context, tableID uuid.UUID) error
}
type sessionRepository struct {
client *redis.Client
}
func NewSessionRepository(client *redis.Client) SessionRepository {
return &sessionRepository{client: client}
}
func (r *sessionRepository) Create(ctx context.Context, session *models.SelfOrderSession) error {
if session.ID == "" {
session.ID = uuid.New().String()
}
session.Status = sessionStatusActive
session.CreatedAt = time.Now()
data, err := json.Marshal(session)
if err != nil {
return fmt.Errorf("failed to marshal session: %w", err)
}
sessionKey := sessionKeyPrefix + session.ID
tableSessionKey := tableSessionKeyPrefix + session.TableID.String()
pipe := r.client.Pipeline()
pipe.Set(ctx, sessionKey, data, sessionTTL)
pipe.Set(ctx, tableSessionKey, session.ID, sessionTTL)
if _, err := pipe.Exec(ctx); err != nil {
return fmt.Errorf("failed to store session in redis: %w", err)
}
return nil
}
func (r *sessionRepository) GetByID(ctx context.Context, sessionID string) (*models.SelfOrderSession, error) {
data, err := r.client.Get(ctx, sessionKeyPrefix+sessionID).Bytes()
if err != nil {
if err == redis.Nil {
return nil, nil
}
return nil, fmt.Errorf("failed to get session: %w", err)
}
var session models.SelfOrderSession
if err := json.Unmarshal(data, &session); err != nil {
return nil, fmt.Errorf("failed to unmarshal session: %w", err)
}
return &session, nil
}
func (r *sessionRepository) GetActiveByTableID(ctx context.Context, tableID uuid.UUID) (*models.SelfOrderSession, error) {
sessionID, err := r.client.Get(ctx, tableSessionKeyPrefix+tableID.String()).Result()
if err != nil {
if err == redis.Nil {
return nil, nil
}
return nil, fmt.Errorf("failed to get session for table: %w", err)
}
session, err := r.GetByID(ctx, sessionID)
if err != nil {
return nil, err
}
if session != nil && session.Status != sessionStatusActive {
return nil, nil
}
return session, nil
}
func (r *sessionRepository) Close(ctx context.Context, sessionID string) error {
session, err := r.GetByID(ctx, sessionID)
if err != nil {
return err
}
if session == nil {
return fmt.Errorf("session not found")
}
now := time.Now()
session.Status = sessionStatusClosed
session.ClosedAt = &now
data, err := json.Marshal(session)
if err != nil {
return fmt.Errorf("failed to marshal session: %w", err)
}
pipe := r.client.Pipeline()
pipe.Set(ctx, sessionKeyPrefix+session.ID, data, sessionTTL)
pipe.Del(ctx, tableSessionKeyPrefix+session.TableID.String())
if _, err := pipe.Exec(ctx); err != nil {
return fmt.Errorf("failed to close session: %w", err)
}
return nil
}
func (r *sessionRepository) CloseByTableID(ctx context.Context, tableID uuid.UUID) error {
session, err := r.GetActiveByTableID(ctx, tableID)
if err != nil {
return err
}
if session == nil {
return nil
}
return r.Close(ctx, session.ID)
}
internal/repository/table_repository.go
+14
View File
@@ -36,6 +36,20 @@ func (r *TableRepository) GetByID(ctx context.Context, id uuid.UUID) (*entities.
return &table, nil
}
func (r *TableRepository) GetByToken(ctx context.Context, token string) (*entities.Table, error) {
var table entities.Table
err := r.db.WithContext(ctx).
Preload("Organization").
Preload("Outlet").
Preload("Order").
Where("token = ?", token).
First(&table).Error
if err != nil {
return nil, err
}
return &table, nil
}
func (r *TableRepository) GetByOutletID(ctx context.Context, outletID uuid.UUID) ([]entities.Table, error) {
var tables []entities.Table
err := r.db.WithContext(ctx).
internal/repository/table_repository_interface.go
+1
View File
@@ -13,6 +13,7 @@ import (
type TableRepositoryInterface interface {
Create(ctx context.Context, table *entities.Table) error
GetByID(ctx context.Context, id uuid.UUID) (*entities.Table, error)
GetByToken(ctx context.Context, token string) (*entities.Table, error)
GetByOutletID(ctx context.Context, outletID uuid.UUID) ([]entities.Table, error)
GetByOrganizationID(ctx context.Context, organizationID uuid.UUID) ([]entities.Table, error)
Update(ctx context.Context, table *entities.Table) error
internal/router/router.go
+2 -1
View File
@@ -149,9 +149,10 @@ func (r *Router) addAppRoutes(rg *gin.Engine) {
selfOrder := v1.Group("/self-order")
{
selfOrder.GET("/table/:token", r.selfOrderHandler.ValidateToken)
selfOrder.GET("/categories", r.selfOrderHandler.ListCategories)
selfOrder.POST("/menu", r.selfOrderHandler.GetMenu)
selfOrder.POST("/order", r.selfOrderHandler.CreateOrder)
selfOrder.POST("/orders", r.selfOrderHandler.CreateOrder)
}
organizations := v1.Group("/organizations")
internal/service/order_service.go
+9 -1
View File
@@ -37,9 +37,10 @@ type OrderServiceImpl struct {
orderIngredientTransactionProcessor processor.OrderIngredientTransactionProcessor
productRecipeRepo repository.ProductRecipeRepository
txManager *repository.TxManager
sessionRepo repository.SessionRepository
}
func NewOrderServiceImpl(orderProcessor processor.OrderProcessor, tableRepo repository.TableRepositoryInterface, orderIngredientTransactionService *OrderIngredientTransactionService, orderIngredientTransactionProcessor processor.OrderIngredientTransactionProcessor, productRecipeRepo repository.ProductRecipeRepository, txManager *repository.TxManager) *OrderServiceImpl {
func NewOrderServiceImpl(orderProcessor processor.OrderProcessor, tableRepo repository.TableRepositoryInterface, orderIngredientTransactionService *OrderIngredientTransactionService, orderIngredientTransactionProcessor processor.OrderIngredientTransactionProcessor, productRecipeRepo repository.ProductRecipeRepository, txManager *repository.TxManager, sessionRepo repository.SessionRepository) *OrderServiceImpl {
return &OrderServiceImpl{
orderProcessor: orderProcessor,
tableRepo: tableRepo,
@@ -47,6 +48,7 @@ func NewOrderServiceImpl(orderProcessor processor.OrderProcessor, tableRepo repo
orderIngredientTransactionProcessor: orderIngredientTransactionProcessor,
productRecipeRepo: productRecipeRepo,
txManager: txManager,
sessionRepo: sessionRepo,
}
}
@@ -621,6 +623,12 @@ func (s *OrderServiceImpl) handleTableReleaseOnPayment(ctx context.Context, orde
if err := s.tableRepo.ReleaseTable(ctx, table.ID, order.TotalAmount); err != nil {
return fmt.Errorf("failed to release table: %w", err)
}
if s.sessionRepo != nil {
if err := s.sessionRepo.CloseByTableID(ctx, table.ID); err != nil {
fmt.Printf("Warning: failed to close self-order session for table %s: %v\n", table.ID, err)
}
}
}
}