add filter order by outlet id

Revert "add list order by outlet id"
This reverts commit 7a737d7f83.
2026-05-14 15:15:32 +07:00 · 2026-05-14 14:46:32 +07:00 · 2026-05-14 14:41:50 +07:00 · 2026-05-14 14:22:07 +07:00 · 2026-05-14 13:54:15 +07:00 · 2026-05-14 01:40:17 +07:00
34 changed files with 1364 additions and 185 deletions
@@ -65,6 +65,7 @@ func (a *App) Initialize(cfg *config.Config) error {
 		repos.userRepo,
 		repos.sessionRepo,
 		repos.orderRepo,
+		services.productOutletPriceService,
 	)

 	a.router = router.NewRouter(
@@ -131,6 +132,8 @@ func (a *App) Initialize(cfg *config.Config) error {
 		validators.userDeviceValidator,
 		services.notificationService,
 		validators.notificationValidator,
+		services.productOutletPriceService,
+		validators.productOutletPriceValidator,
 		selfOrderHandler,
 	)

@@ -232,6 +235,7 @@ type repositories struct {
 	notificationRepo               *repository.NotificationRepositoryImpl
 	notificationReceiverRepo       *repository.NotificationReceiverRepositoryImpl
 	notificationDeliveryRepo       *repository.NotificationDeliveryRepositoryImpl
+	productOutletPriceRepo         *repository.ProductOutletPriceRepositoryImpl
 }

 func (a *App) initRepositories() *repositories {
@@ -283,6 +287,7 @@ func (a *App) initRepositories() *repositories {
 		notificationRepo:               repository.NewNotificationRepository(a.db),
 		notificationReceiverRepo:       repository.NewNotificationReceiverRepository(a.db),
 		notificationDeliveryRepo:       repository.NewNotificationDeliveryRepository(a.db),
+		productOutletPriceRepo:         repository.NewProductOutletPriceRepositoryImpl(a.db),
 	}
 }

@@ -327,6 +332,7 @@ type processors struct {
 	inventoryMovementService            service.InventoryMovementService
 	userDeviceProcessor                 *processor.UserDeviceProcessorImpl
 	notificationProcessor               *processor.NotificationProcessorImpl
+	productOutletPriceProcessor         processor.ProductOutletPriceProcessor
 }

 func (a *App) initProcessors(cfg *config.Config, repos *repositories) *processors {
@@ -341,10 +347,10 @@ func (a *App) initProcessors(cfg *config.Config, repos *repositories) *processor
 		outletProcessor:                     processor.NewOutletProcessorImpl(repos.outletRepo),
 		outletSettingProcessor:              processor.NewOutletSettingProcessorImpl(repos.outletSettingRepo, repos.outletRepo),
 		categoryProcessor:                   processor.NewCategoryProcessorImpl(repos.categoryRepo),
-		productProcessor:                    processor.NewProductProcessorImpl(repos.productRepo, repos.categoryRepo, repos.productVariantRepo, repos.inventoryRepo, repos.outletRepo),
+		productProcessor:                    processor.NewProductProcessorImpl(repos.productRepo, repos.categoryRepo, repos.productVariantRepo, repos.inventoryRepo, repos.outletRepo, repos.productOutletPriceRepo),
 		productVariantProcessor:             processor.NewProductVariantProcessorImpl(repos.productVariantRepo, repos.productRepo),
 		inventoryProcessor:                  processor.NewInventoryProcessorImpl(repos.inventoryRepo, repos.productRepo, repos.outletRepo, repos.ingredientRepo, repos.inventoryMovementRepo),
-		orderProcessor:                      processor.NewOrderProcessorImpl(repos.orderRepo, repos.orderItemRepo, repos.paymentRepo, repos.paymentOrderItemRepo, repos.productRepo, repos.paymentMethodRepo, repos.inventoryRepo, repos.inventoryMovementRepo, repos.productVariantRepo, repos.outletRepo, repos.customerRepo, repos.txManager, repos.productRecipeRepo, repos.ingredientRepo, inventoryMovementService),
+		orderProcessor:                      processor.NewOrderProcessorImpl(repos.orderRepo, repos.orderItemRepo, repos.paymentRepo, repos.paymentOrderItemRepo, repos.productRepo, repos.paymentMethodRepo, repos.inventoryRepo, repos.inventoryMovementRepo, repos.productVariantRepo, repos.outletRepo, repos.customerRepo, repos.txManager, repos.productRecipeRepo, repos.ingredientRepo, inventoryMovementService, repos.productOutletPriceRepo),
 		paymentMethodProcessor:              processor.NewPaymentMethodProcessorImpl(repos.paymentMethodRepo),
 		fileProcessor:                       processor.NewFileProcessorImpl(repos.fileRepo, fileClient),
 		customerProcessor:                   processor.NewCustomerProcessor(repos.customerRepo),
@@ -376,6 +382,7 @@ func (a *App) initProcessors(cfg *config.Config, repos *repositories) *processor
 		inventoryMovementService:            inventoryMovementService,
 		userDeviceProcessor:                 processor.NewUserDeviceProcessorImpl(repos.userDeviceRepo),
 		notificationProcessor:               buildNotificationProcessor(cfg, repos),
+		productOutletPriceProcessor:         processor.NewProductOutletPriceProcessorImpl(repos.productOutletPriceRepo, repos.productRepo, repos.outletRepo),
 	}
 }

@@ -414,6 +421,7 @@ type services struct {
 	spinGameService                   service.SpinGameService
 	userDeviceService                 service.UserDeviceService
 	notificationService               service.NotificationService
+	productOutletPriceService         service.ProductOutletPriceService
 }

 func (a *App) initServices(processors *processors, repos *repositories, cfg *config.Config) *services {
@@ -490,6 +498,7 @@ func (a *App) initServices(processors *processors, repos *repositories, cfg *con
 		spinGameService:                   spinGameService,
 		userDeviceService:                 userDeviceService,
 		notificationService:               notificationService,
+		productOutletPriceService:         service.NewProductOutletPriceService(processors.productOutletPriceProcessor),
 	}
 }

@@ -531,6 +540,7 @@ type validators struct {
 	customerAuthValidator               validator.CustomerAuthValidator
 	userDeviceValidator                 *validator.UserDeviceValidatorImpl
 	notificationValidator               *validator.NotificationValidatorImpl
+	productOutletPriceValidator         *validator.ProductOutletPriceValidatorImpl
 }

 func (a *App) initValidators() *validators {
@@ -560,6 +570,7 @@ func (a *App) initValidators() *validators {
 		customerAuthValidator:               validator.NewCustomerAuthValidator(),
 		userDeviceValidator:                 validator.NewUserDeviceValidator(),
 		notificationValidator:               validator.NewNotificationValidator(),
+		productOutletPriceValidator:         validator.NewProductOutletPriceValidator(),
 	}
 }

@@ -44,21 +44,22 @@ const (
 	IngredientCompositionServiceEntity   = "ingredient_composition_service"
 	TableEntity                          = "table"
 	// Gamification entities
-	CustomerPointsEntity      = "customer_points"
-	CustomerTokensEntity      = "customer_tokens"
-	TierEntity                = "tier"
-	GameEntity                = "game"
-	GamePrizeEntity           = "game_prize"
-	GamePlayEntity            = "game_play"
-	OmsetTrackerEntity        = "omset_tracker"
-	RewardEntity              = "reward"
-	CampaignEntity            = "campaign"
-	CampaignRuleEntity        = "campaign_rule"
-	CustomerEntity            = "customer"
-	SpinGameHandlerEntity     = "spin_game_handler"
-	UserDeviceServiceEntity   = "user_device_service"
-	NotificationServiceEntity = "notification_service"
-	NotificationHandlerEntity = "notification_handler"
+	CustomerPointsEntity            = "customer_points"
+	CustomerTokensEntity            = "customer_tokens"
+	TierEntity                      = "tier"
+	GameEntity                      = "game"
+	GamePrizeEntity                 = "game_prize"
+	GamePlayEntity                  = "game_play"
+	OmsetTrackerEntity              = "omset_tracker"
+	RewardEntity                    = "reward"
+	CampaignEntity                  = "campaign"
+	CampaignRuleEntity              = "campaign_rule"
+	CustomerEntity                  = "customer"
+	SpinGameHandlerEntity           = "spin_game_handler"
+	UserDeviceServiceEntity         = "user_device_service"
+	NotificationServiceEntity       = "notification_service"
+	NotificationHandlerEntity       = "notification_handler"
+	ProductOutletPriceServiceEntity = "product_outlet_price_service"
 )

 var HttpErrorMap = map[string]int{
@@ -56,24 +56,26 @@ type UpdateProductVariantRequest struct {
 }

 type ProductResponse struct {
-	ID             uuid.UUID                `json:"id"`
-	OrganizationID uuid.UUID                `json:"organization_id"`
-	CategoryID     uuid.UUID                `json:"category_id"`
-	CategoryName   string                   `json:"category_name"`
-	SKU            *string                  `json:"sku"`
-	Name           string                   `json:"name"`
-	Description    *string                  `json:"description"`
-	Price          float64                  `json:"price"`
-	Cost           float64                  `json:"cost"`
-	BusinessType   string                   `json:"business_type"`
-	ImageURL       *string                  `json:"image_url"`
-	PrinterType    string                   `json:"printer_type"`
-	Metadata       map[string]interface{}   `json:"metadata"`
-	IsActive       bool                     `json:"is_active"`
-	CreatedAt      time.Time                `json:"created_at"`
-	UpdatedAt      time.Time                `json:"updated_at"`
-	Category       *CategoryResponse        `json:"category,omitempty"`
-	Variants       []ProductVariantResponse `json:"variants,omitempty"`
+	ID             uuid.UUID                    `json:"id"`
+	OrganizationID uuid.UUID                    `json:"organization_id"`
+	CategoryID     uuid.UUID                    `json:"category_id"`
+	CategoryName   string                       `json:"category_name"`
+	SKU            *string                      `json:"sku"`
+	Name           string                       `json:"name"`
+	Description    *string                      `json:"description"`
+	Price          float64                      `json:"price"`
+	OutletPrice    *float64                     `json:"outlet_price,omitempty"`
+	OutletPrices   []ProductOutletPriceResponse `json:"outlet_prices,omitempty"`
+	Cost           float64                      `json:"cost"`
+	BusinessType   string                       `json:"business_type"`
+	ImageURL       *string                      `json:"image_url"`
+	PrinterType    string                       `json:"printer_type"`
+	Metadata       map[string]interface{}       `json:"metadata"`
+	IsActive       bool                         `json:"is_active"`
+	CreatedAt      time.Time                    `json:"created_at"`
+	UpdatedAt      time.Time                    `json:"updated_at"`
+	Category       *CategoryResponse            `json:"category,omitempty"`
+	Variants       []ProductVariantResponse     `json:"variants,omitempty"`
 }

 type ProductVariantResponse struct {
@@ -89,6 +91,7 @@ type ProductVariantResponse struct {

 type ListProductsRequest struct {
 	OrganizationID *uuid.UUID `json:"organization_id,omitempty"`
+	OutletID       *uuid.UUID `json:"outlet_id,omitempty"`
 	CategoryID     *uuid.UUID `json:"category_id,omitempty"`
 	BusinessType   string     `json:"business_type,omitempty"`
 	IsActive       *bool      `json:"is_active,omitempty"`
@@ -0,0 +1,42 @@
+package contract
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type CreateProductOutletPriceRequest struct {
+	ProductID uuid.UUID `json:"product_id" validate:"required"`
+	OutletID  uuid.UUID `json:"outlet_id" validate:"required"`
+	Price     float64   `json:"price" validate:"required,min=0"`
+}
+
+type UpdateProductOutletPriceRequest struct {
+	Price float64 `json:"price" validate:"required,min=0"`
+}
+
+type ProductOutletPriceResponse struct {
+	ID         uuid.UUID `json:"id,omitempty"`
+	ProductID  uuid.UUID `json:"product_id,omitempty"`
+	OutletID   uuid.UUID `json:"outlet_id"`
+	OutletName string    `json:"outlet_name,omitempty"`
+	Price      float64   `json:"price"`
+	CreatedAt  time.Time `json:"created_at,omitempty"`
+	UpdatedAt  time.Time `json:"updated_at,omitempty"`
+}
+
+type ListProductOutletPricesResponse struct {
+	Prices     []ProductOutletPriceResponse `json:"prices"`
+	TotalCount int                          `json:"total_count"`
+}
+
+type BulkCreateProductOutletPriceRequest struct {
+	ProductID uuid.UUID                                  `json:"product_id" validate:"required"`
+	Prices    []CreateProductOutletPricePerOutletRequest `json:"prices" validate:"required,dive"`
+}
+
+type CreateProductOutletPricePerOutletRequest struct {
+	OutletID uuid.UUID `json:"outlet_id" validate:"required"`
+	Price    float64   `json:"price" validate:"required,min=0"`
+}
@@ -41,6 +41,7 @@ func GetAllEntities() []interface{} {
 		&Notification{},
 		&NotificationReceiver{},
 		&NotificationDelivery{},
+		&ProductOutletPrice{},
 	}
 }

@@ -26,13 +26,13 @@ type Product struct {
 	CreatedAt      time.Time  `gorm:"autoCreateTime" json:"created_at"`
 	UpdatedAt      time.Time  `gorm:"autoUpdateTime" json:"updated_at"`

-	Organization       Organization        `gorm:"foreignKey:OrganizationID" json:"organization,omitempty"`
-	Category           Category            `gorm:"foreignKey:CategoryID" json:"category,omitempty"`
-	Unit               *Unit               `gorm:"foreignKey:UnitID" json:"unit,omitempty"`
-	ProductVariants    []ProductVariant    `gorm:"foreignKey:ProductID" json:"variants,omitempty"`
-	ProductRecipes []ProductRecipe `gorm:"foreignKey:ProductID" json:"product_recipes,omitempty"`
-	Inventory          []Inventory         `gorm:"foreignKey:ProductID" json:"inventory,omitempty"`
-	OrderItems         []OrderItem         `gorm:"foreignKey:ProductID" json:"order_items,omitempty"`
+	Organization    Organization     `gorm:"foreignKey:OrganizationID" json:"organization,omitempty"`
+	Category        Category         `gorm:"foreignKey:CategoryID" json:"category,omitempty"`
+	Unit            *Unit            `gorm:"foreignKey:UnitID" json:"unit,omitempty"`
+	ProductVariants []ProductVariant `gorm:"foreignKey:ProductID" json:"variants,omitempty"`
+	ProductRecipes  []ProductRecipe  `gorm:"foreignKey:ProductID" json:"product_recipes,omitempty"`
+	Inventory       []Inventory      `gorm:"foreignKey:ProductID" json:"inventory,omitempty"`
+	OrderItems      []OrderItem      `gorm:"foreignKey:ProductID" json:"order_items,omitempty"`
 }

 func (p *Product) BeforeCreate(tx *gorm.DB) error {
@@ -0,0 +1,31 @@
+package entities
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type ProductOutletPrice struct {
+	ID        uuid.UUID `gorm:"type:uuid;primary_key;default:gen_random_uuid()" json:"id"`
+	ProductID uuid.UUID `gorm:"type:uuid;not null;index" json:"product_id"`
+	OutletID  uuid.UUID `gorm:"type:uuid;not null;index" json:"outlet_id"`
+	Price     float64   `gorm:"type:decimal(10,2);not null" json:"price"`
+	CreatedAt time.Time `gorm:"autoCreateTime" json:"created_at"`
+	UpdatedAt time.Time `gorm:"autoUpdateTime" json:"updated_at"`
+
+	Product Product `gorm:"foreignKey:ProductID" json:"product,omitempty"`
+	Outlet  Outlet  `gorm:"foreignKey:OutletID" json:"outlet,omitempty"`
+}
+
+func (p *ProductOutletPrice) BeforeCreate(tx *gorm.DB) error {
+	if p.ID == uuid.Nil {
+		p.ID = uuid.New()
+	}
+	return nil
+}
+
+func (ProductOutletPrice) TableName() string {
+	return "product_outlet_prices"
+}
@@ -53,6 +53,14 @@ func (h *OrderHandler) CreateOrder(c *gin.Context) {
 }

 func (h *OrderHandler) GetOrderByID(c *gin.Context) {
+	ctx := c.Request.Context()
+	contextInfo := appcontext.FromGinContext(ctx)
+
+	if contextInfo.OutletID == uuid.Nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("invalid_request", "OrderHandler::GetOrderByID", "outlet ID is required")}), "OrderHandler::GetOrderByID")
+		return
+	}
+
 	idStr := c.Param("id")
 	id, err := uuid.Parse(idStr)
 	if err != nil {
@@ -60,7 +68,7 @@ func (h *OrderHandler) GetOrderByID(c *gin.Context) {
 		return
 	}

-	response, err := h.orderService.GetOrderByID(c.Request.Context(), id)
+	response, err := h.orderService.GetOrderByID(c.Request.Context(), id, contextInfo.OutletID)
 	if err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::GetOrderByID", err.Error())}), "OrderHandler::GetOrderByID")
 		return
@@ -71,6 +79,14 @@ func (h *OrderHandler) GetOrderByID(c *gin.Context) {
 }

 func (h *OrderHandler) UpdateOrder(c *gin.Context) {
+	ctx := c.Request.Context()
+	contextInfo := appcontext.FromGinContext(ctx)
+
+	if contextInfo.OutletID == uuid.Nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("invalid_request", "OrderHandler::UpdateOrder", "outlet ID is required")}), "OrderHandler::UpdateOrder")
+		return
+	}
+
 	idStr := c.Param("id")
 	id, err := uuid.Parse(idStr)
 	if err != nil {
@@ -85,7 +101,7 @@ func (h *OrderHandler) UpdateOrder(c *gin.Context) {
 	}

 	modelReq := transformer.UpdateOrderContractToModel(&req)
-	response, err := h.orderService.UpdateOrder(c.Request.Context(), id, modelReq)
+	response, err := h.orderService.UpdateOrder(c.Request.Context(), id, modelReq, contextInfo.OutletID)
 	if err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::UpdateOrder", err.Error())}), "OrderHandler::UpdateOrder")
 		return
@@ -96,6 +112,14 @@ func (h *OrderHandler) UpdateOrder(c *gin.Context) {
 }

 func (h *OrderHandler) AddToOrder(c *gin.Context) {
+	ctx := c.Request.Context()
+	contextInfo := appcontext.FromGinContext(ctx)
+
+	if contextInfo.OutletID == uuid.Nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("invalid_request", "OrderHandler::AddToOrder", "outlet ID is required")}), "OrderHandler::AddToOrder")
+		return
+	}
+
 	idStr := c.Param("id")
 	id, err := uuid.Parse(idStr)
 	if err != nil {
@@ -110,7 +134,7 @@ func (h *OrderHandler) AddToOrder(c *gin.Context) {
 	}

 	modelReq := transformer.AddToOrderContractToModel(&req)
-	response, err := h.orderService.AddToOrder(c.Request.Context(), id, modelReq)
+	response, err := h.orderService.AddToOrder(c.Request.Context(), id, modelReq, contextInfo.OutletID)
 	if err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::AddToOrder", err.Error())}), "OrderHandler::AddToOrder")
 		return
@@ -137,6 +161,9 @@ func (h *OrderHandler) ListOrders(c *gin.Context) {
 	}

 	modelReq.OrganizationID = &contextInfo.OrganizationID
+	if modelReq.OutletID == nil && contextInfo.OutletID != uuid.Nil {
+		modelReq.OutletID = &contextInfo.OutletID
+	}
 	response, err := h.orderService.ListOrders(c.Request.Context(), modelReq)
 	if err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::ListOrders", err.Error())}), "OrderHandler::ListOrders")
@@ -164,7 +191,7 @@ func (h *OrderHandler) VoidOrder(c *gin.Context) {
 	}

 	modelReq := transformer.VoidOrderContractToModel(&req)
-	if err := h.orderService.VoidOrder(ctx, modelReq, userID); err != nil {
+	if err := h.orderService.VoidOrder(ctx, modelReq, userID, contextInfo.OutletID); err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::VoidOrder", err.Error())}), "OrderHandler::VoidOrder")
 		return
 	}
@@ -197,7 +224,7 @@ func (h *OrderHandler) RefundOrder(c *gin.Context) {
 		return
 	}

-	if err := h.orderService.RefundOrder(ctx, id, modelReq, userID); err != nil {
+	if err := h.orderService.RefundOrder(ctx, id, modelReq, userID, contextInfo.OutletID); err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::RefundOrder", err.Error())}), "OrderHandler::RefundOrder")
 		return
 	}
@@ -206,6 +233,14 @@ func (h *OrderHandler) RefundOrder(c *gin.Context) {
 }

 func (h *OrderHandler) CreatePayment(c *gin.Context) {
+	ctx := c.Request.Context()
+	contextInfo := appcontext.FromGinContext(ctx)
+
+	if contextInfo.OutletID == uuid.Nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("invalid_request", "OrderHandler::CreatePayment", "outlet ID is required")}), "OrderHandler::CreatePayment")
+		return
+	}
+
 	var req contract.CreatePaymentRequest
 	if err := c.ShouldBindJSON(&req); err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("invalid_request", "OrderHandler::CreatePayment", err.Error())}), "OrderHandler::CreatePayment")
@@ -219,7 +254,7 @@ func (h *OrderHandler) CreatePayment(c *gin.Context) {

 	modelReq := transformer.CreatePaymentContractToModel(&req)

-	response, err := h.orderService.CreatePayment(c.Request.Context(), modelReq)
+	response, err := h.orderService.CreatePayment(c.Request.Context(), modelReq, contextInfo.OutletID)
 	if err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::CreatePayment", err.Error())}), "OrderHandler::CreatePayment")
 		return
@@ -257,7 +292,7 @@ func (h *OrderHandler) RefundPayment(c *gin.Context) {
 		return
 	}

-	if err := h.orderService.RefundPayment(ctx, paymentID, req.RefundAmount, req.Reason, userID); err != nil {
+	if err := h.orderService.RefundPayment(ctx, paymentID, req.RefundAmount, req.Reason, userID, contextInfo.OutletID); err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::RefundPayment", err.Error())}), "OrderHandler::RefundPayment")
 		return
 	}
@@ -284,7 +319,7 @@ func (h *OrderHandler) SetOrderCustomer(c *gin.Context) {

 	modelReq := transformer.SetOrderCustomerContractToModel(&req)

-	response, err := h.orderService.SetOrderCustomer(ctx, orderID, modelReq, contextInfo.OrganizationID)
+	response, err := h.orderService.SetOrderCustomer(ctx, orderID, modelReq, contextInfo.OrganizationID, contextInfo.OutletID)
 	if err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::SetOrderCustomer", err.Error())}), "OrderHandler::SetOrderCustomer")
 		return
@@ -311,7 +346,7 @@ func (h *OrderHandler) SplitBill(c *gin.Context) {

 	req.OrganizationID = contextInfo.OrganizationID
 	modelReq := transformer.SplitBillContractToModel(&req)
-	response, err := h.orderService.SplitBill(c.Request.Context(), modelReq)
+	response, err := h.orderService.SplitBill(c.Request.Context(), modelReq, contextInfo.OutletID)
 	if err != nil {
 		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "OrderHandler::SplitBill", err.Error())}), "OrderHandler::SplitBill")
 		return
@@ -117,6 +117,7 @@ func (h *ProductHandler) DeleteProduct(c *gin.Context) {

 func (h *ProductHandler) GetProduct(c *gin.Context) {
 	ctx := c.Request.Context()
+	contextInfo := appcontext.FromGinContext(ctx)

 	productIDStr := c.Param("id")
 	productID, err := uuid.Parse(productIDStr)
@@ -127,7 +128,7 @@ func (h *ProductHandler) GetProduct(c *gin.Context) {
 		return
 	}

-	productResponse := h.productService.GetProductByID(ctx, productID)
+	productResponse := h.productService.GetProductByID(ctx, productID, contextInfo.OutletID)
 	if productResponse.HasErrors() {
 		errorResp := productResponse.GetErrors()[0]
 		logger.FromContext(ctx).WithError(errorResp).Error("ProductHandler::GetProduct -> Failed to get product from service")
@@ -184,6 +185,97 @@ func (h *ProductHandler) ListProducts(c *gin.Context) {
 		}
 	}

+	if outletIDStr := c.Query("outlet_id"); outletIDStr != "" {
+		if outletID, err := uuid.Parse(outletIDStr); err == nil {
+			req.OutletID = &outletID
+		}
+	} else if contextInfo.OutletID != uuid.Nil {
+		req.OutletID = &contextInfo.OutletID
+	}
+
+	if minPriceStr := c.Query("min_price"); minPriceStr != "" {
+		if minPrice, err := strconv.ParseFloat(minPriceStr, 64); err == nil {
+			req.MinPrice = &minPrice
+		}
+	}
+
+	if maxPriceStr := c.Query("max_price"); maxPriceStr != "" {
+		if maxPrice, err := strconv.ParseFloat(maxPriceStr, 64); err == nil {
+			req.MaxPrice = &maxPrice
+		}
+	}
+
+	validationError, validationErrorCode := h.productValidator.ValidateListProductsRequest(req)
+	if validationError != nil {
+		logger.FromContext(ctx).WithError(validationError).Error("ProductHandler::ListProducts -> request validation failed")
+		validationResponseError := contract.NewResponseError(validationErrorCode, constants.RequestEntity, validationError.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductHandler::ListProducts")
+		return
+	}
+
+	productsResponse := h.productService.ListProducts(ctx, req)
+	if productsResponse.HasErrors() {
+		errorResp := productsResponse.GetErrors()[0]
+		logger.FromContext(ctx).WithError(errorResp).Error("ProductHandler::ListProducts -> Failed to list products from service")
+	}
+
+	util.HandleResponse(c.Writer, c.Request, productsResponse, "ProductHandler::ListProducts")
+}
+
+func (h *ProductHandler) ListProductAll(c *gin.Context) {
+	ctx := c.Request.Context()
+	contextInfo := appcontext.FromGinContext(ctx)
+
+	req := &contract.ListProductsRequest{
+		Page:           1,
+		Limit:          10,
+		OrganizationID: &contextInfo.OrganizationID,
+	}
+
+	if pageStr := c.Query("page"); pageStr != "" {
+		if page, err := strconv.Atoi(pageStr); err == nil {
+			req.Page = page
+		}
+	}
+
+	if limitStr := c.Query("limit"); limitStr != "" {
+		if limit, err := strconv.Atoi(limitStr); err == nil {
+			req.Limit = limit
+		}
+	}
+
+	if search := c.Query("search"); search != "" {
+		req.Search = search
+	}
+
+	if businessType := c.Query("business_type"); businessType != "" {
+		req.BusinessType = businessType
+	}
+
+	if organizationIDStr := c.Query("organization_id"); organizationIDStr != "" {
+		if organizationID, err := uuid.Parse(organizationIDStr); err == nil {
+			req.OrganizationID = &organizationID
+		}
+	}
+
+	if categoryIDStr := c.Query("category_id"); categoryIDStr != "" {
+		if categoryID, err := uuid.Parse(categoryIDStr); err == nil {
+			req.CategoryID = &categoryID
+		}
+	}
+
+	if isActiveStr := c.Query("is_active"); isActiveStr != "" {
+		if isActive, err := strconv.ParseBool(isActiveStr); err == nil {
+			req.IsActive = &isActive
+		}
+	}
+
+	if outletIDStr := c.Query("outlet_id"); outletIDStr != "" {
+		if outletID, err := uuid.Parse(outletIDStr); err == nil {
+			req.OutletID = &outletID
+		}
+	}
+
 	if minPriceStr := c.Query("min_price"); minPriceStr != "" {
 		if minPrice, err := strconv.ParseFloat(minPriceStr, 64); err == nil {
 			req.MinPrice = &minPrice
@@ -0,0 +1,135 @@
+package handler
+
+import (
+	"apskel-pos-be/internal/constants"
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/logger"
+	"apskel-pos-be/internal/service"
+	"apskel-pos-be/internal/util"
+	"apskel-pos-be/internal/validator"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type ProductOutletPriceHandler struct {
+	service   service.ProductOutletPriceService
+	validator validator.ProductOutletPriceValidator
+}
+
+func NewProductOutletPriceHandler(svc service.ProductOutletPriceService, v validator.ProductOutletPriceValidator) *ProductOutletPriceHandler {
+	return &ProductOutletPriceHandler{
+		service:   svc,
+		validator: v,
+	}
+}
+
+func (h *ProductOutletPriceHandler) Upsert(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	var req contract.CreateProductOutletPriceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("ProductOutletPriceHandler::Upsert -> request binding failed")
+		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Upsert")
+		return
+	}
+
+	if validationErr, code := h.validator.ValidateCreateRequest(&req); validationErr != nil {
+		validationResponseError := contract.NewResponseError(code, constants.RequestEntity, validationErr.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Upsert")
+		return
+	}
+
+	resp := h.service.Upsert(ctx, &req)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::Upsert")
+}
+
+func (h *ProductOutletPriceHandler) GetByProductAndOutlet(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	productIDStr := c.Param("product_id")
+	productID, err := uuid.Parse(productIDStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid product ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProductAndOutlet")
+		return
+	}
+
+	outletIDStr := c.Param("outlet_id")
+	outletID, err := uuid.Parse(outletIDStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProductAndOutlet")
+		return
+	}
+
+	resp := h.service.GetByProductAndOutlet(ctx, productID, outletID)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByProductAndOutlet")
+}
+
+func (h *ProductOutletPriceHandler) GetByProduct(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	productIDStr := c.Param("product_id")
+	productID, err := uuid.Parse(productIDStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid product ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByProduct")
+		return
+	}
+
+	resp := h.service.GetByProduct(ctx, productID)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByProduct")
+}
+
+func (h *ProductOutletPriceHandler) GetByOutlet(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	outletIDStr := c.Param("outlet_id")
+	outletID, err := uuid.Parse(outletIDStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid outlet ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::GetByOutlet")
+		return
+	}
+
+	resp := h.service.GetByOutlet(ctx, outletID)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::GetByOutlet")
+}
+
+func (h *ProductOutletPriceHandler) Delete(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	idStr := c.Param("id")
+	id, err := uuid.Parse(idStr)
+	if err != nil {
+		validationResponseError := contract.NewResponseError(constants.MalformedFieldErrorCode, constants.RequestEntity, "Invalid ID")
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::Delete")
+		return
+	}
+
+	resp := h.service.Delete(ctx, id)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::Delete")
+}
+
+func (h *ProductOutletPriceHandler) BulkUpsert(c *gin.Context) {
+	ctx := c.Request.Context()
+
+	var req contract.BulkCreateProductOutletPriceRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		logger.FromContext(ctx).WithError(err).Error("ProductOutletPriceHandler::BulkUpsert -> request binding failed")
+		validationResponseError := contract.NewResponseError(constants.MissingFieldErrorCode, constants.RequestEntity, err.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::BulkUpsert")
+		return
+	}
+
+	if validationErr, code := h.validator.ValidateBulkCreateRequest(&req); validationErr != nil {
+		validationResponseError := contract.NewResponseError(code, constants.RequestEntity, validationErr.Error())
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{validationResponseError}), "ProductOutletPriceHandler::BulkUpsert")
+		return
+	}
+
+	resp := h.service.BulkUpsert(ctx, &req)
+	util.HandleResponse(c.Writer, c.Request, resp, "ProductOutletPriceHandler::BulkUpsert")
+}
@@ -21,14 +21,15 @@ import (
 )

 type SelfOrderHandler struct {
-	orderService    service.OrderService
-	categoryService service.CategoryService
-	productService  service.ProductService
-	tableRepo       repository.TableRepositoryInterface
-	outletRepo      processor.OutletRepository
-	userRepo        processor.UserRepository
-	sessionRepo     repository.SessionRepository
-	orderRepo       repository.OrderRepository
+	orderService              service.OrderService
+	categoryService           service.CategoryService
+	productService            service.ProductService
+	tableRepo                 repository.TableRepositoryInterface
+	outletRepo                processor.OutletRepository
+	userRepo                  processor.UserRepository
+	sessionRepo               repository.SessionRepository
+	orderRepo                 repository.OrderRepository
+	productOutletPriceService service.ProductOutletPriceService
 }

 func NewSelfOrderHandler(
@@ -40,16 +41,18 @@ func NewSelfOrderHandler(
 	userRepo processor.UserRepository,
 	sessionRepo repository.SessionRepository,
 	orderRepo repository.OrderRepository,
+	productOutletPriceService service.ProductOutletPriceService,
 ) *SelfOrderHandler {
 	return &SelfOrderHandler{
-		orderService:    orderService,
-		categoryService: categoryService,
-		productService:  productService,
-		tableRepo:       tableRepo,
-		outletRepo:      outletRepo,
-		userRepo:        userRepo,
-		sessionRepo:     sessionRepo,
-		orderRepo:       orderRepo,
+		orderService:              orderService,
+		categoryService:           categoryService,
+		productService:            productService,
+		tableRepo:                 tableRepo,
+		outletRepo:                outletRepo,
+		userRepo:                  userRepo,
+		sessionRepo:               sessionRepo,
+		orderRepo:                 orderRepo,
+		productOutletPriceService: productOutletPriceService,
 	}
 }

@@ -216,16 +219,29 @@ func (h *SelfOrderHandler) GetMenu(c *gin.Context) {
 		return
 	}

-	menu := h.buildMenuResponse(outlet, table, catList.Categories, prodList.Products)
+	menu := h.buildMenuResponse(ctx, outlet, table, catList.Categories, prodList.Products)
 	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(menu), "SelfOrderHandler::GetMenu")
 }

 func (h *SelfOrderHandler) buildMenuResponse(
+	ctx context.Context,
 	outlet *entities.Outlet,
 	table *entities.Table,
 	categories []contract.CategoryResponse,
 	products []contract.ProductResponse,
 ) *contract.SelfOrderMenuResponse {
+	outletPriceMap := make(map[uuid.UUID]float64)
+	if h.productOutletPriceService != nil {
+		priceResp := h.productOutletPriceService.GetByOutlet(ctx, outlet.ID)
+		if priceResp != nil && !priceResp.HasErrors() {
+			if priceList, ok := priceResp.Data.(*contract.ListProductOutletPricesResponse); ok {
+				for _, p := range priceList.Prices {
+					outletPriceMap[p.ProductID] = p.Price
+				}
+			}
+		}
+	}
+
 	productMap := make(map[uuid.UUID][]contract.ProductResponse)
 	for _, p := range products {
 		productMap[p.CategoryID] = append(productMap[p.CategoryID], p)
@@ -236,11 +252,15 @@ func (h *SelfOrderHandler) buildMenuResponse(
 		menuItems := make([]contract.SelfOrderMenuItem, 0)
 		if prods, ok := productMap[cat.ID]; ok {
 			for _, p := range prods {
+				price := p.Price
+				if outletPrice, exists := outletPriceMap[p.ID]; exists {
+					price = outletPrice
+				}
 				item := contract.SelfOrderMenuItem{
 					ID:          p.ID,
 					Name:        p.Name,
 					Description: p.Description,
-					Price:       p.Price,
+					Price:       price,
 					ImageURL:    p.ImageURL,
 				}
 				for _, v := range p.Variants {
@@ -150,6 +150,11 @@ func (h *TableHandler) List(c *gin.Context) {
 		Limit:          100,
 	}

+	// Fallback to context outlet ID if not provided in query
+	if query.OutletID == "" && contextInfo.OutletID != uuid.Nil {
+		query.OutletID = contextInfo.OutletID.String()
+	}
+
 	if pageStr := c.Query("page"); pageStr != "" {
 		if page, err := strconv.Atoi(pageStr); err == nil && page > 0 {
 			query.Page = page
@@ -135,6 +135,7 @@ func ProductEntityToResponse(entity *entities.Product) *models.ProductResponse {
 		Name:           entity.Name,
 		Description:    entity.Description,
 		Price:          entity.Price,
+		OutletPrice:    nil, // populated by processor when outletID is available
 		Cost:           entity.Cost,
 		BusinessType:   constants.BusinessType(entity.BusinessType),
 		ImageURL:       entity.ImageURL,
@@ -0,0 +1,48 @@
+package mappers
+
+import (
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+)
+
+func ProductOutletPriceEntityToModel(entity *entities.ProductOutletPrice) *models.ProductOutletPrice {
+	if entity == nil {
+		return nil
+	}
+
+	return &models.ProductOutletPrice{
+		ID:        entity.ID,
+		ProductID: entity.ProductID,
+		OutletID:  entity.OutletID,
+		Price:     entity.Price,
+		CreatedAt: entity.CreatedAt,
+		UpdatedAt: entity.UpdatedAt,
+	}
+}
+
+func ProductOutletPriceModelToEntity(model *models.ProductOutletPrice) *entities.ProductOutletPrice {
+	if model == nil {
+		return nil
+	}
+
+	return &entities.ProductOutletPrice{
+		ID:        model.ID,
+		ProductID: model.ProductID,
+		OutletID:  model.OutletID,
+		Price:     model.Price,
+		CreatedAt: model.CreatedAt,
+		UpdatedAt: model.UpdatedAt,
+	}
+}
+
+func ProductOutletPriceEntitiesToModels(entities []*entities.ProductOutletPrice) []*models.ProductOutletPrice {
+	if entities == nil {
+		return nil
+	}
+
+	models := make([]*models.ProductOutletPrice, len(entities))
+	for i, entity := range entities {
+		models[i] = ProductOutletPriceEntityToModel(entity)
+	}
+	return models
+}
@@ -11,6 +11,7 @@ import (
 	"apskel-pos-be/internal/service"

 	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
 )

 type AuthMiddleware struct {
@@ -45,9 +46,13 @@ func (m *AuthMiddleware) RequireAuth() gin.HandlerFunc {
 		setKeyInContext(c, appcontext.OrganizationIDKey, userResponse.OrganizationID.String())
 		setKeyInContext(c, appcontext.UserIDKey, userResponse.ID.String())

-		if userResponse.Role != "superadmin" {
-			setKeyInContext(c, appcontext.OutletIDKey, userResponse.OutletID.String())
+		// Always override OutletID from token to prevent header injection.
+		// Set empty string if user has no outlet, so PopulateContext header value is ignored.
+		outletIDStr := ""
+		if userResponse.OutletID != nil && *userResponse.OutletID != uuid.Nil {
+			outletIDStr = userResponse.OutletID.String()
 		}
+		setKeyInContext(c, appcontext.OutletIDKey, outletIDStr)

 		logger.FromContext(c.Request.Context()).Infof("AuthMiddleware::RequireAuth -> User authenticated: %s", userResponse.Email)
 		c.Next()
@@ -100,6 +100,8 @@ type ProductResponse struct {
 	Name           string
 	Description    *string
 	Price          float64
+	OutletPrice    *float64      // outlet-specific price, nil if not set
+	OutletPrices   []OutletPrice // all outlet prices, populated when no outletID in context
 	Cost           float64
 	BusinessType   constants.BusinessType
 	ImageURL       *string
@@ -113,6 +115,12 @@ type ProductResponse struct {
 	Variants       []ProductVariantResponse
 }

+type OutletPrice struct {
+	OutletID   uuid.UUID
+	OutletName string
+	Price      float64
+}
+
 type ProductVariantResponse struct {
 	ID            uuid.UUID
 	ProductID     uuid.UUID
@@ -0,0 +1,35 @@
+package models
+
+import (
+	"time"
+
+	"github.com/google/uuid"
+)
+
+type ProductOutletPrice struct {
+	ID        uuid.UUID
+	ProductID uuid.UUID
+	OutletID  uuid.UUID
+	Price     float64
+	CreatedAt time.Time
+	UpdatedAt time.Time
+}
+
+type CreateProductOutletPriceRequest struct {
+	ProductID uuid.UUID `validate:"required"`
+	OutletID  uuid.UUID `validate:"required"`
+	Price     float64   `validate:"required,min=0"`
+}
+
+type UpdateProductOutletPriceRequest struct {
+	Price *float64 `validate:"required,min=0"`
+}
+
+type ProductOutletPriceResponse struct {
+	ID        uuid.UUID `json:"id"`
+	ProductID uuid.UUID `json:"product_id"`
+	OutletID  uuid.UUID `json:"outlet_id"`
+	Price     float64   `json:"price"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
@@ -17,33 +17,33 @@ import (

 type OrderProcessor interface {
 	CreateOrder(ctx context.Context, req *models.CreateOrderRequest, organizationID uuid.UUID) (*models.OrderResponse, error)
-	AddToOrder(ctx context.Context, orderID uuid.UUID, req *models.AddToOrderRequest) (*models.AddToOrderResponse, error)
-	UpdateOrder(ctx context.Context, id uuid.UUID, req *models.UpdateOrderRequest) (*models.OrderResponse, error)
-	GetOrderByID(ctx context.Context, id uuid.UUID) (*models.OrderResponse, error)
+	AddToOrder(ctx context.Context, orderID uuid.UUID, req *models.AddToOrderRequest, outletID uuid.UUID) (*models.AddToOrderResponse, error)
+	UpdateOrder(ctx context.Context, id uuid.UUID, req *models.UpdateOrderRequest, outletID uuid.UUID) (*models.OrderResponse, error)
+	GetOrderByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*models.OrderResponse, error)
 	ListOrders(ctx context.Context, req *models.ListOrdersRequest) (*models.ListOrdersResponse, error)
-	VoidOrder(ctx context.Context, req *models.VoidOrderRequest, voidedBy uuid.UUID) error
-	RefundOrder(ctx context.Context, id uuid.UUID, req *models.RefundOrderRequest, refundedBy uuid.UUID) error
-	CreatePayment(ctx context.Context, req *models.CreatePaymentRequest) (*models.PaymentResponse, error)
-	RefundPayment(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID) error
-	SetOrderCustomer(ctx context.Context, orderID uuid.UUID, req *models.SetOrderCustomerRequest, organizationID uuid.UUID) (*models.SetOrderCustomerResponse, error)
-	SplitBill(ctx context.Context, req *models.SplitBillRequest) (*models.SplitBillResponse, error)
+	VoidOrder(ctx context.Context, req *models.VoidOrderRequest, voidedBy uuid.UUID, outletID uuid.UUID) error
+	RefundOrder(ctx context.Context, id uuid.UUID, req *models.RefundOrderRequest, refundedBy uuid.UUID, outletID uuid.UUID) error
+	CreatePayment(ctx context.Context, req *models.CreatePaymentRequest, outletID uuid.UUID) (*models.PaymentResponse, error)
+	RefundPayment(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID, outletID uuid.UUID) error
+	SetOrderCustomer(ctx context.Context, orderID uuid.UUID, req *models.SetOrderCustomerRequest, organizationID uuid.UUID, outletID uuid.UUID) (*models.SetOrderCustomerResponse, error)
+	SplitBill(ctx context.Context, req *models.SplitBillRequest, outletID uuid.UUID) (*models.SplitBillResponse, error)
 }

 type OrderRepository interface {
 	Create(ctx context.Context, order *entities.Order) error
-	GetByID(ctx context.Context, id uuid.UUID) (*entities.Order, error)
-	GetWithRelations(ctx context.Context, id uuid.UUID) (*entities.Order, error)
+	GetByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*entities.Order, error)
+	GetWithRelations(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*entities.Order, error)
 	Update(ctx context.Context, order *entities.Order) error
-	UpdateStatusSuccess(ctx context.Context, id uuid.UUID, orderStatus entities.OrderStatus, paymentStatus entities.PaymentStatus) error
+	UpdateStatusSuccess(ctx context.Context, id uuid.UUID, orderStatus entities.OrderStatus, paymentStatus entities.PaymentStatus, outletID uuid.UUID) error
 	Delete(ctx context.Context, id uuid.UUID) error
 	List(ctx context.Context, filters map[string]interface{}, limit, offset int) ([]*entities.Order, int64, error)
 	GetByOrderNumber(ctx context.Context, orderNumber string) (*entities.Order, error)
 	ExistsByOrderNumber(ctx context.Context, orderNumber string) (bool, error)
-	VoidOrder(ctx context.Context, id uuid.UUID, reason string, voidedBy uuid.UUID) error
-	VoidOrderWithStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, reason string, voidedBy uuid.UUID) error
-	RefundOrder(ctx context.Context, id uuid.UUID, reason string, refundedBy uuid.UUID) error
-	UpdatePaymentStatus(ctx context.Context, id uuid.UUID, status entities.PaymentStatus) error
-	UpdateStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus) error
+	VoidOrder(ctx context.Context, id uuid.UUID, reason string, voidedBy uuid.UUID, outletID uuid.UUID) error
+	VoidOrderWithStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, reason string, voidedBy uuid.UUID, outletID uuid.UUID) error
+	RefundOrder(ctx context.Context, id uuid.UUID, reason string, refundedBy uuid.UUID, outletID uuid.UUID) error
+	UpdatePaymentStatus(ctx context.Context, id uuid.UUID, status entities.PaymentStatus, outletID uuid.UUID) error
+	UpdateStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, outletID uuid.UUID) error
 	GetNextOrderNumber(ctx context.Context, organizationID, outletID uuid.UUID) (string, error)
 }

@@ -108,6 +108,7 @@ type OrderProcessorImpl struct {
 	productRecipeRepo        *repository.ProductRecipeRepository
 	ingredientRepo           IngredientRepository
 	inventoryMovementService InventoryMovementService
+	productOutletPriceRepo   repository.ProductOutletPriceRepository
 }

 func NewOrderProcessorImpl(
@@ -126,6 +127,7 @@ func NewOrderProcessorImpl(
 	productRecipeRepo *repository.ProductRecipeRepository,
 	ingredientRepo IngredientRepository,
 	inventoryMovementService InventoryMovementService,
+	productOutletPriceRepo repository.ProductOutletPriceRepository,
 ) *OrderProcessorImpl {
 	return &OrderProcessorImpl{
 		orderRepo:                orderRepo,
@@ -144,6 +146,7 @@ func NewOrderProcessorImpl(
 		productRecipeRepo:        productRecipeRepo,
 		ingredientRepo:           ingredientRepo,
 		inventoryMovementService: inventoryMovementService,
+		productOutletPriceRepo:   productOutletPriceRepo,
 	}
 }

@@ -170,6 +173,12 @@ func (p *OrderProcessorImpl) CreateOrder(ctx context.Context, req *models.Create
 		unitPrice := product.Price
 		unitCost := product.Cost

+		if p.productOutletPriceRepo != nil {
+			if outletPrice, err := p.productOutletPriceRepo.GetByProductAndOutlet(ctx, itemReq.ProductID, req.OutletID); err == nil {
+				unitPrice = outletPrice.Price
+			}
+		}
+
 		if itemReq.ProductVariantID != nil {
 			variant, err := p.productVariantRepo.GetByID(ctx, *itemReq.ProductVariantID)
 			if err != nil {
@@ -251,7 +260,7 @@ func (p *OrderProcessorImpl) CreateOrder(ctx context.Context, req *models.Create
 		}
 	}

-	orderWithRelations, err := p.orderRepo.GetWithRelations(ctx, order.ID)
+	orderWithRelations, err := p.orderRepo.GetWithRelations(ctx, order.ID, uuid.Nil)
 	if err != nil {
 		return nil, fmt.Errorf("failed to retrieve created order: %w", err)
 	}
@@ -260,8 +269,8 @@ func (p *OrderProcessorImpl) CreateOrder(ctx context.Context, req *models.Create
 	return response, nil
 }

-func (p *OrderProcessorImpl) AddToOrder(ctx context.Context, orderID uuid.UUID, req *models.AddToOrderRequest) (*models.AddToOrderResponse, error) {
-	order, err := p.orderRepo.GetByID(ctx, orderID)
+func (p *OrderProcessorImpl) AddToOrder(ctx context.Context, orderID uuid.UUID, req *models.AddToOrderRequest, outletID uuid.UUID) (*models.AddToOrderResponse, error) {
+	order, err := p.orderRepo.GetByID(ctx, orderID, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("order not found: %w", err)
 	}
@@ -293,6 +302,12 @@ func (p *OrderProcessorImpl) AddToOrder(ctx context.Context, orderID uuid.UUID,
 		unitPrice := product.Price
 		unitCost := product.Cost

+		if p.productOutletPriceRepo != nil {
+			if outletPrice, err := p.productOutletPriceRepo.GetByProductAndOutlet(ctx, itemReq.ProductID, order.OutletID); err == nil {
+				unitPrice = outletPrice.Price
+			}
+		}
+
 		// Handle product variant if specified
 		if itemReq.ProductVariantID != nil {
 			variant, err := p.productVariantRepo.GetByID(ctx, *itemReq.ProductVariantID)
@@ -400,7 +415,7 @@ func (p *OrderProcessorImpl) AddToOrder(ctx context.Context, orderID uuid.UUID,
 		addedItemResponses = append(addedItemResponses, itemResponse)
 	}

-	orderWithRelations, err := p.orderRepo.GetWithRelations(ctx, orderID)
+	orderWithRelations, err := p.orderRepo.GetWithRelations(ctx, orderID, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to retrieve updated order: %w", err)
 	}
@@ -415,9 +430,8 @@ func (p *OrderProcessorImpl) AddToOrder(ctx context.Context, orderID uuid.UUID,
 	}, nil
 }

-func (p *OrderProcessorImpl) UpdateOrder(ctx context.Context, id uuid.UUID, req *models.UpdateOrderRequest) (*models.OrderResponse, error) {
-	// Get existing order
-	order, err := p.orderRepo.GetByID(ctx, id)
+func (p *OrderProcessorImpl) UpdateOrder(ctx context.Context, id uuid.UUID, req *models.UpdateOrderRequest, outletID uuid.UUID) (*models.OrderResponse, error) {
+	order, err := p.orderRepo.GetByID(ctx, id, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("order not found: %w", err)
 	}
@@ -462,11 +476,11 @@ func (p *OrderProcessorImpl) UpdateOrder(ctx context.Context, id uuid.UUID, req
 	order.Status = entities.OrderStatusCompleted
 	order.PaymentStatus = entities.PaymentStatusCompleted

-	if err := p.orderRepo.UpdateStatusSuccess(ctx, order.ID, order.Status, order.PaymentStatus); err != nil {
+	if err := p.orderRepo.UpdateStatusSuccess(ctx, order.ID, order.Status, order.PaymentStatus, outletID); err != nil {
 		return nil, fmt.Errorf("failed to update order: %w", err)
 	}

-	orderWithRelations, err := p.orderRepo.GetWithRelations(ctx, id)
+	orderWithRelations, err := p.orderRepo.GetWithRelations(ctx, id, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to retrieve updated order: %w", err)
 	}
@@ -475,8 +489,8 @@ func (p *OrderProcessorImpl) UpdateOrder(ctx context.Context, id uuid.UUID, req
 	return response, nil
 }

-func (p *OrderProcessorImpl) GetOrderByID(ctx context.Context, id uuid.UUID) (*models.OrderResponse, error) {
-	order, err := p.orderRepo.GetWithRelations(ctx, id)
+func (p *OrderProcessorImpl) GetOrderByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*models.OrderResponse, error) {
+	order, err := p.orderRepo.GetWithRelations(ctx, id, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("order not found: %w", err)
 	}
@@ -559,12 +573,12 @@ func (p *OrderProcessorImpl) ListOrders(ctx context.Context, req *models.ListOrd
 	}, nil
 }

-func (p *OrderProcessorImpl) VoidOrder(ctx context.Context, req *models.VoidOrderRequest, voidedBy uuid.UUID) error {
+func (p *OrderProcessorImpl) VoidOrder(ctx context.Context, req *models.VoidOrderRequest, voidedBy uuid.UUID, outletID uuid.UUID) error {
 	if req.OrderID != req.OrderID {
 		return fmt.Errorf("order ID mismatch: path parameter does not match request body")
 	}

-	order, err := p.orderRepo.GetByID(ctx, req.OrderID)
+	order, err := p.orderRepo.GetByID(ctx, req.OrderID, outletID)
 	if err != nil {
 		return fmt.Errorf("order not found: %w", err)
 	}
@@ -578,7 +592,7 @@ func (p *OrderProcessorImpl) VoidOrder(ctx context.Context, req *models.VoidOrde
 	}

 	if req.Type == "ALL" {
-		if err := p.orderRepo.VoidOrderWithStatus(ctx, req.OrderID, entities.OrderStatusCancelled, req.Reason, voidedBy); err != nil {
+		if err := p.orderRepo.VoidOrderWithStatus(ctx, req.OrderID, entities.OrderStatusCancelled, req.Reason, voidedBy, outletID); err != nil {
 			return fmt.Errorf("failed to void order: %w", err)
 		}
 	} else if req.Type == "ITEM" {
@@ -644,7 +658,7 @@ func (p *OrderProcessorImpl) VoidOrder(ctx context.Context, req *models.VoidOrde
 		}

 		if !hasActiveItems {
-			if err := p.orderRepo.VoidOrderWithStatus(ctx, req.OrderID, entities.OrderStatusCancelled, req.Reason, voidedBy); err != nil {
+			if err := p.orderRepo.VoidOrderWithStatus(ctx, req.OrderID, entities.OrderStatusCancelled, req.Reason, voidedBy, outletID); err != nil {
 				return fmt.Errorf("failed to void order after all items voided: %w", err)
 			}
 		}
@@ -655,8 +669,8 @@ func (p *OrderProcessorImpl) VoidOrder(ctx context.Context, req *models.VoidOrde
 	return nil
 }

-func (p *OrderProcessorImpl) RefundOrder(ctx context.Context, id uuid.UUID, req *models.RefundOrderRequest, refundedBy uuid.UUID) error {
-	order, err := p.orderRepo.GetWithRelations(ctx, id)
+func (p *OrderProcessorImpl) RefundOrder(ctx context.Context, id uuid.UUID, req *models.RefundOrderRequest, refundedBy uuid.UUID, outletID uuid.UUID) error {
+	order, err := p.orderRepo.GetWithRelations(ctx, id, outletID)
 	if err != nil {
 		return fmt.Errorf("order not found: %w", err)
 	}
@@ -688,7 +702,7 @@ func (p *OrderProcessorImpl) RefundOrder(ctx context.Context, id uuid.UUID, req
 		}

 		// Mark order as refunded
-		if err := p.orderRepo.RefundOrder(ctx, id, reason, refundedBy); err != nil {
+		if err := p.orderRepo.RefundOrder(ctx, id, reason, refundedBy, outletID); err != nil {
 			return fmt.Errorf("failed to mark order as refunded: %w", err)
 		}

@@ -742,7 +756,7 @@ func (p *OrderProcessorImpl) RefundOrder(ctx context.Context, id uuid.UUID, req
 		}

 		// Mark order as refunded
-		if err := p.orderRepo.RefundOrder(ctx, id, reason, refundedBy); err != nil {
+		if err := p.orderRepo.RefundOrder(ctx, id, reason, refundedBy, outletID); err != nil {
 			return fmt.Errorf("failed to mark order as refunded: %w", err)
 		}
 	}
@@ -750,8 +764,8 @@ func (p *OrderProcessorImpl) RefundOrder(ctx context.Context, id uuid.UUID, req
 	return nil
 }

-func (p *OrderProcessorImpl) CreatePayment(ctx context.Context, req *models.CreatePaymentRequest) (*models.PaymentResponse, error) {
-	order, err := p.orderRepo.GetByID(ctx, req.OrderID)
+func (p *OrderProcessorImpl) CreatePayment(ctx context.Context, req *models.CreatePaymentRequest, outletID uuid.UUID) (*models.PaymentResponse, error) {
+	order, err := p.orderRepo.GetByID(ctx, req.OrderID, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("order not found: %w", err)
 	}
@@ -788,7 +802,7 @@ func (p *OrderProcessorImpl) CreatePayment(ctx context.Context, req *models.Crea
 	return response, nil
 }

-func (p *OrderProcessorImpl) RefundPayment(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID) error {
+func (p *OrderProcessorImpl) RefundPayment(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID, outletID uuid.UUID) error {
 	payment, err := p.paymentRepo.GetByID(ctx, paymentID)
 	if err != nil {
 		return fmt.Errorf("payment not found: %w", err)
@@ -860,7 +874,7 @@ func (p *OrderProcessorImpl) updateOrderStatus(ctx context.Context, orderID uuid
 		PaymentStatus: entities.PaymentStatusCompleted,
 	}

-	if err := p.orderRepo.UpdateStatusSuccess(ctx, orderID, orderUpdate.Status, orderUpdate.PaymentStatus); err != nil {
+	if err := p.orderRepo.UpdateStatusSuccess(ctx, orderID, orderUpdate.Status, orderUpdate.PaymentStatus, uuid.Nil); err != nil {
 		return fmt.Errorf("failed to update order status: %w", err)
 	}

@@ -1056,7 +1070,7 @@ func (p *OrderProcessorImpl) processRefund(ctx context.Context, paymentID uuid.U
 }

 func (p *OrderProcessorImpl) updateOrderRefundAmount(ctx context.Context, orderID uuid.UUID, refundAmount float64) error {
-	order, err := p.orderRepo.GetByID(ctx, orderID)
+	order, err := p.orderRepo.GetByID(ctx, orderID, uuid.Nil)
 	if err != nil {
 		return fmt.Errorf("failed to get order: %w", err)
 	}
@@ -1069,8 +1083,8 @@ func (p *OrderProcessorImpl) updateOrderRefundAmount(ctx context.Context, orderI
 	return nil
 }

-func (p *OrderProcessorImpl) SetOrderCustomer(ctx context.Context, orderID uuid.UUID, req *models.SetOrderCustomerRequest, organizationID uuid.UUID) (*models.SetOrderCustomerResponse, error) {
-	order, err := p.orderRepo.GetByID(ctx, orderID)
+func (p *OrderProcessorImpl) SetOrderCustomer(ctx context.Context, orderID uuid.UUID, req *models.SetOrderCustomerRequest, organizationID uuid.UUID, outletID uuid.UUID) (*models.SetOrderCustomerResponse, error) {
+	order, err := p.orderRepo.GetByID(ctx, orderID, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("order not found: %w", err)
 	}
@@ -1104,8 +1118,8 @@ func (p *OrderProcessorImpl) SetOrderCustomer(ctx context.Context, orderID uuid.
 	return response, nil
 }

-func (p *OrderProcessorImpl) SplitBill(ctx context.Context, req *models.SplitBillRequest) (*models.SplitBillResponse, error) {
-	order, err := p.orderRepo.GetWithRelations(ctx, req.OrderID)
+func (p *OrderProcessorImpl) SplitBill(ctx context.Context, req *models.SplitBillRequest, outletID uuid.UUID) (*models.SplitBillResponse, error) {
+	order, err := p.orderRepo.GetWithRelations(ctx, req.OrderID, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("order not found: %w", err)
 	}
@@ -0,0 +1,121 @@
+package processor
+
+import (
+	"context"
+	"fmt"
+
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/mappers"
+	"apskel-pos-be/internal/models"
+	"apskel-pos-be/internal/repository"
+
+	"github.com/google/uuid"
+)
+
+type ProductOutletPriceProcessor interface {
+	Upsert(ctx context.Context, req *models.CreateProductOutletPriceRequest) (*models.ProductOutletPrice, error)
+	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*models.ProductOutletPrice, error)
+	GetByProduct(ctx context.Context, productID uuid.UUID) ([]*models.ProductOutletPrice, error)
+	GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*models.ProductOutletPrice, error)
+	Delete(ctx context.Context, id uuid.UUID) error
+	ResolvePrice(ctx context.Context, productID, outletID uuid.UUID, fallbackPrice float64) float64
+	BulkUpsert(ctx context.Context, productID uuid.UUID, prices []models.CreateProductOutletPriceRequest) ([]*models.ProductOutletPrice, error)
+}
+
+type ProductOutletPriceProcessorImpl struct {
+	repo        repository.ProductOutletPriceRepository
+	productRepo ProductRepository
+	outletRepo  OutletRepository
+}
+
+func NewProductOutletPriceProcessorImpl(repo repository.ProductOutletPriceRepository, productRepo ProductRepository, outletRepo OutletRepository) *ProductOutletPriceProcessorImpl {
+	return &ProductOutletPriceProcessorImpl{
+		repo:        repo,
+		productRepo: productRepo,
+		outletRepo:  outletRepo,
+	}
+}
+
+func (p *ProductOutletPriceProcessorImpl) Upsert(ctx context.Context, req *models.CreateProductOutletPriceRequest) (*models.ProductOutletPrice, error) {
+	if _, err := p.productRepo.GetByID(ctx, req.ProductID); err != nil {
+		return nil, fmt.Errorf("product not found: %w", err)
+	}
+
+	if _, err := p.outletRepo.GetByID(ctx, req.OutletID); err != nil {
+		return nil, fmt.Errorf("outlet not found: %w", err)
+	}
+
+	entity := &entities.ProductOutletPrice{
+		ProductID: req.ProductID,
+		OutletID:  req.OutletID,
+		Price:     req.Price,
+	}
+
+	if err := p.repo.Upsert(ctx, entity); err != nil {
+		return nil, fmt.Errorf("failed to upsert product outlet price: %w", err)
+	}
+
+	actual, err := p.repo.GetByProductAndOutlet(ctx, req.ProductID, req.OutletID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve upserted product outlet price: %w", err)
+	}
+
+	return mappers.ProductOutletPriceEntityToModel(actual), nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*models.ProductOutletPrice, error) {
+	entity, err := p.repo.GetByProductAndOutlet(ctx, productID, outletID)
+	if err != nil {
+		return nil, fmt.Errorf("product outlet price not found: %w", err)
+	}
+
+	return mappers.ProductOutletPriceEntityToModel(entity), nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) GetByProduct(ctx context.Context, productID uuid.UUID) ([]*models.ProductOutletPrice, error) {
+	entities, err := p.repo.GetByProduct(ctx, productID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get product outlet prices: %w", err)
+	}
+
+	return mappers.ProductOutletPriceEntitiesToModels(entities), nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*models.ProductOutletPrice, error) {
+	entities, err := p.repo.GetByOutlet(ctx, outletID)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get outlet prices: %w", err)
+	}
+
+	return mappers.ProductOutletPriceEntitiesToModels(entities), nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) Delete(ctx context.Context, id uuid.UUID) error {
+	if err := p.repo.Delete(ctx, id); err != nil {
+		return fmt.Errorf("failed to delete product outlet price: %w", err)
+	}
+	return nil
+}
+
+func (p *ProductOutletPriceProcessorImpl) ResolvePrice(ctx context.Context, productID, outletID uuid.UUID, fallbackPrice float64) float64 {
+	outletPrice, err := p.repo.GetByProductAndOutlet(ctx, productID, outletID)
+	if err != nil {
+		return fallbackPrice
+	}
+	return outletPrice.Price
+}
+
+func (p *ProductOutletPriceProcessorImpl) BulkUpsert(ctx context.Context, productID uuid.UUID, prices []models.CreateProductOutletPriceRequest) ([]*models.ProductOutletPrice, error) {
+	var results []*models.ProductOutletPrice
+
+	for _, req := range prices {
+		req.ProductID = productID
+		result, err := p.Upsert(ctx, &req)
+		if err != nil {
+			return nil, fmt.Errorf("failed to upsert price for outlet %s: %w", req.OutletID, err)
+		}
+		results = append(results, result)
+	}
+
+	return results, nil
+}
@@ -16,8 +16,9 @@ type ProductProcessor interface {
 	CreateProduct(ctx context.Context, req *models.CreateProductRequest) (*models.ProductResponse, error)
 	UpdateProduct(ctx context.Context, id uuid.UUID, req *models.UpdateProductRequest) (*models.ProductResponse, error)
 	DeleteProduct(ctx context.Context, id uuid.UUID) error
-	GetProductByID(ctx context.Context, id uuid.UUID) (*models.ProductResponse, error)
+	GetProductByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*models.ProductResponse, error)
 	ListProducts(ctx context.Context, filters map[string]interface{}, page, limit int) ([]models.ProductResponse, int, error)
+	ListProductsAll(ctx context.Context, filters map[string]interface{}, page, limit int) ([]models.ProductResponse, int, error)
 }

 type ProductRepository interface {
@@ -32,6 +33,7 @@ type ProductRepository interface {
 	Update(ctx context.Context, product *entities.Product) error
 	Delete(ctx context.Context, id uuid.UUID) error
 	List(ctx context.Context, filters map[string]interface{}, limit, offset int) ([]*entities.Product, int64, error)
+	ListWithOutletPrice(ctx context.Context, filters map[string]interface{}, outletID uuid.UUID, limit, offset int) ([]*entities.Product, int64, error)
 	Count(ctx context.Context, filters map[string]interface{}) (int64, error)
 	GetBySKU(ctx context.Context, organizationID uuid.UUID, sku string) (*entities.Product, error)
 	ExistsBySKU(ctx context.Context, organizationID uuid.UUID, sku string, excludeID *uuid.UUID) (bool, error)
@@ -47,15 +49,17 @@ type ProductProcessorImpl struct {
 	productVariantRepo repository.ProductVariantRepository
 	inventoryRepo      repository.InventoryRepository
 	outletRepo         OutletRepository
+	outletPriceRepo    repository.ProductOutletPriceRepository
 }

-func NewProductProcessorImpl(productRepo ProductRepository, categoryRepo CategoryRepository, productVariantRepo repository.ProductVariantRepository, inventoryRepo repository.InventoryRepository, outletRepo OutletRepository) *ProductProcessorImpl {
+func NewProductProcessorImpl(productRepo ProductRepository, categoryRepo CategoryRepository, productVariantRepo repository.ProductVariantRepository, inventoryRepo repository.InventoryRepository, outletRepo OutletRepository, outletPriceRepo repository.ProductOutletPriceRepository) *ProductProcessorImpl {
 	return &ProductProcessorImpl{
 		productRepo:        productRepo,
 		categoryRepo:       categoryRepo,
 		productVariantRepo: productVariantRepo,
 		inventoryRepo:      inventoryRepo,
 		outletRepo:         outletRepo,
+		outletPriceRepo:    outletPriceRepo,
 	}
 }

@@ -214,19 +218,79 @@ func (p *ProductProcessorImpl) DeleteProduct(ctx context.Context, id uuid.UUID)
 	return nil
 }

-func (p *ProductProcessorImpl) GetProductByID(ctx context.Context, id uuid.UUID) (*models.ProductResponse, error) {
+func (p *ProductProcessorImpl) GetProductByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*models.ProductResponse, error) {
 	productEntity, err := p.productRepo.GetWithCategory(ctx, id)
 	if err != nil {
 		return nil, fmt.Errorf("product not found: %w", err)
 	}

 	response := mappers.ProductEntityToResponse(productEntity)
+
+	if outletID != uuid.Nil {
+		// Attach outlet-specific price
+		outletPrice, err := p.outletPriceRepo.GetByProductAndOutlet(ctx, id, outletID)
+		if err == nil {
+			response.OutletPrice = &outletPrice.Price
+		}
+	} else {
+		// No outlet context — return all outlet prices for this product
+		outletPrices, err := p.outletPriceRepo.GetByProductWithOutlet(ctx, id)
+		if err == nil && len(outletPrices) > 0 {
+			prices := make([]models.OutletPrice, len(outletPrices))
+			for i, op := range outletPrices {
+				prices[i] = models.OutletPrice{
+					OutletID:   op.OutletID,
+					OutletName: op.Outlet.Name,
+					Price:      op.Price,
+				}
+			}
+			response.OutletPrices = prices
+		}
+	}
+
 	return response, nil
 }

 func (p *ProductProcessorImpl) ListProducts(ctx context.Context, filters map[string]interface{}, page, limit int) ([]models.ProductResponse, int, error) {
 	offset := (page - 1) * limit

+	// Extract outletID from filters — it's not a products column so remove it before querying
+	var outletID uuid.UUID
+	if oid, ok := filters["outlet_id"]; ok {
+		outletID = oid.(uuid.UUID)
+		delete(filters, "outlet_id")
+	}
+
+	// Use the JOIN-based query when an outlet is specified so we get outlet-specific
+	// prices in a single round-trip; fall back to the plain List otherwise.
+	var (
+		productEntities []*entities.Product
+		total           int64
+		err             error
+	)
+	if outletID != uuid.Nil {
+		productEntities, total, err = p.productRepo.ListWithOutletPrice(ctx, filters, outletID, limit, offset)
+	} else {
+		productEntities, total, err = p.productRepo.List(ctx, filters, limit, offset)
+	}
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to list products: %w", err)
+	}
+
+	responses := make([]models.ProductResponse, len(productEntities))
+	for i, entity := range productEntities {
+		response := mappers.ProductEntityToResponse(entity)
+		if response != nil {
+			responses[i] = *response
+		}
+	}
+
+	return responses, int(total), nil
+}
+
+func (p *ProductProcessorImpl) ListProductsAll(ctx context.Context, filters map[string]interface{}, page, limit int) ([]models.ProductResponse, int, error) {
+	offset := (page - 1) * limit
+
 	productEntities, total, err := p.productRepo.List(ctx, filters, limit, offset)
 	if err != nil {
 		return nil, 0, fmt.Errorf("failed to list products: %w", err)
@@ -137,7 +137,7 @@ func (p *TableProcessor) OccupyTable(ctx context.Context, tableID uuid.UUID, req
 	}

 	// Verify order exists
-	_, err = p.orderRepo.GetByID(ctx, req.OrderID)
+	_, err = p.orderRepo.GetByID(ctx, req.OrderID, uuid.Nil)
 	if err != nil {
 		return nil, errors.New("order not found")
 	}
@@ -13,19 +13,20 @@ import (

 type OrderRepository interface {
 	Create(ctx context.Context, order *entities.Order) error
-	GetByID(ctx context.Context, id uuid.UUID) (*entities.Order, error)
-	GetWithRelations(ctx context.Context, id uuid.UUID) (*entities.Order, error)
+	GetByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*entities.Order, error)
+	GetWithRelations(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*entities.Order, error)
 	Update(ctx context.Context, order *entities.Order) error
 	Delete(ctx context.Context, id uuid.UUID) error
 	List(ctx context.Context, filters map[string]interface{}, limit, offset int) ([]*entities.Order, int64, error)
 	ListBySessionID(ctx context.Context, sessionID string) ([]*entities.Order, error)
 	GetByOrderNumber(ctx context.Context, orderNumber string) (*entities.Order, error)
 	ExistsByOrderNumber(ctx context.Context, orderNumber string) (bool, error)
-	VoidOrder(ctx context.Context, id uuid.UUID, reason string, voidedBy uuid.UUID) error
-	VoidOrderWithStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, reason string, voidedBy uuid.UUID) error
-	RefundOrder(ctx context.Context, id uuid.UUID, reason string, refundedBy uuid.UUID) error
-	UpdatePaymentStatus(ctx context.Context, id uuid.UUID, status entities.PaymentStatus) error
-	UpdateStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus) error
+	VoidOrder(ctx context.Context, id uuid.UUID, reason string, voidedBy uuid.UUID, outletID uuid.UUID) error
+	VoidOrderWithStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, reason string, voidedBy uuid.UUID, outletID uuid.UUID) error
+	RefundOrder(ctx context.Context, id uuid.UUID, reason string, refundedBy uuid.UUID, outletID uuid.UUID) error
+	UpdatePaymentStatus(ctx context.Context, id uuid.UUID, status entities.PaymentStatus, outletID uuid.UUID) error
+	UpdateStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, outletID uuid.UUID) error
+	UpdateStatusSuccess(ctx context.Context, id uuid.UUID, orderStatus entities.OrderStatus, paymentStatus entities.PaymentStatus, outletID uuid.UUID) error
 	GetNextOrderNumber(ctx context.Context, organizationID, outletID uuid.UUID) (string, error)
 }

@@ -43,18 +44,27 @@ func (r *OrderRepositoryImpl) Create(ctx context.Context, order *entities.Order)
 	return r.db.WithContext(ctx).Create(order).Error
 }

-func (r *OrderRepositoryImpl) GetByID(ctx context.Context, id uuid.UUID) (*entities.Order, error) {
+func applyOutletFilter(query *gorm.DB, outletID uuid.UUID) *gorm.DB {
+	if outletID != uuid.Nil {
+		return query.Where("outlet_id = ?", outletID)
+	}
+	return query
+}
+
+func (r *OrderRepositoryImpl) GetByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*entities.Order, error) {
 	var order entities.Order
-	err := r.db.WithContext(ctx).First(&order, "id = ?", id).Error
+	query := r.db.WithContext(ctx)
+	query = applyOutletFilter(query, outletID)
+	err := query.First(&order, "id = ?", id).Error
 	if err != nil {
 		return nil, err
 	}
 	return &order, nil
 }

-func (r *OrderRepositoryImpl) GetWithRelations(ctx context.Context, id uuid.UUID) (*entities.Order, error) {
+func (r *OrderRepositoryImpl) GetWithRelations(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*entities.Order, error) {
 	var order entities.Order
-	err := r.db.WithContext(ctx).
+	query := r.db.WithContext(ctx).
 		Preload("Organization").
 		Preload("Outlet").
 		Preload("User").
@@ -63,8 +73,9 @@ func (r *OrderRepositoryImpl) GetWithRelations(ctx context.Context, id uuid.UUID
 		Preload("OrderItems.ProductVariant").
 		Preload("Payments").
 		Preload("Payments.PaymentMethod").
-		Preload("Payments.PaymentOrderItems").
-		First(&order, "id = ?", id).Error
+		Preload("Payments.PaymentOrderItems")
+	query = applyOutletFilter(query, outletID)
+	err := query.First(&order, "id = ?", id).Error
 	if err != nil {
 		return nil, err
 	}
@@ -80,10 +91,12 @@ func (r *OrderRepositoryImpl) UpdateStatusSuccess(
 	id uuid.UUID,
 	orderStatus entities.OrderStatus,
 	paymentStatus entities.PaymentStatus,
+	outletID uuid.UUID,
 ) error {
-	return r.db.WithContext(ctx).
-		Model(&entities.Order{}).
-		Where("id = ?", id.String()).
+	query := r.db.WithContext(ctx).
+		Model(&entities.Order{})
+	query = applyOutletFilter(query, outletID)
+	return query.Where("id = ?", id.String()).
 		Updates(map[string]interface{}{
 			"status":         orderStatus,
 			"payment_status": paymentStatus,
@@ -164,10 +177,11 @@ func (r *OrderRepositoryImpl) ExistsByOrderNumber(ctx context.Context, orderNumb
 	return count > 0, err
 }

-func (r *OrderRepositoryImpl) VoidOrder(ctx context.Context, id uuid.UUID, reason string, voidedBy uuid.UUID) error {
+func (r *OrderRepositoryImpl) VoidOrder(ctx context.Context, id uuid.UUID, reason string, voidedBy uuid.UUID, outletID uuid.UUID) error {
 	now := time.Now()
-	return r.db.WithContext(ctx).Model(&entities.Order{}).
-		Where("id = ?", id).
+	query := r.db.WithContext(ctx).Model(&entities.Order{})
+	query = applyOutletFilter(query, outletID)
+	return query.Where("id = ?", id).
 		Updates(map[string]interface{}{
 			"is_void":     true,
 			"void_reason": reason,
@@ -176,10 +190,11 @@ func (r *OrderRepositoryImpl) VoidOrder(ctx context.Context, id uuid.UUID, reaso
 		}).Error
 }

-func (r *OrderRepositoryImpl) VoidOrderWithStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, reason string, voidedBy uuid.UUID) error {
+func (r *OrderRepositoryImpl) VoidOrderWithStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, reason string, voidedBy uuid.UUID, outletID uuid.UUID) error {
 	now := time.Now()
-	return r.db.WithContext(ctx).Model(&entities.Order{}).
-		Where("id = ?", id).
+	query := r.db.WithContext(ctx).Model(&entities.Order{})
+	query = applyOutletFilter(query, outletID)
+	return query.Where("id = ?", id).
 		Updates(map[string]interface{}{
 			"status":      status,
 			"is_void":     true,
@@ -189,10 +204,11 @@ func (r *OrderRepositoryImpl) VoidOrderWithStatus(ctx context.Context, id uuid.U
 		}).Error
 }

-func (r *OrderRepositoryImpl) RefundOrder(ctx context.Context, id uuid.UUID, reason string, refundedBy uuid.UUID) error {
+func (r *OrderRepositoryImpl) RefundOrder(ctx context.Context, id uuid.UUID, reason string, refundedBy uuid.UUID, outletID uuid.UUID) error {
 	now := time.Now()
-	return r.db.WithContext(ctx).Model(&entities.Order{}).
-		Where("id = ?", id).
+	query := r.db.WithContext(ctx).Model(&entities.Order{})
+	query = applyOutletFilter(query, outletID)
+	return query.Where("id = ?", id).
 		Updates(map[string]interface{}{
 			"is_refund":     true,
 			"refund_reason": reason,
@@ -201,15 +217,17 @@ func (r *OrderRepositoryImpl) RefundOrder(ctx context.Context, id uuid.UUID, rea
 		}).Error
 }

-func (r *OrderRepositoryImpl) UpdatePaymentStatus(ctx context.Context, id uuid.UUID, status entities.PaymentStatus) error {
-	return r.db.WithContext(ctx).Model(&entities.Order{}).
-		Where("id = ?", id).
+func (r *OrderRepositoryImpl) UpdatePaymentStatus(ctx context.Context, id uuid.UUID, status entities.PaymentStatus, outletID uuid.UUID) error {
+	query := r.db.WithContext(ctx).Model(&entities.Order{})
+	query = applyOutletFilter(query, outletID)
+	return query.Where("id = ?", id).
 		Update("payment_status", status).Error
 }

-func (r *OrderRepositoryImpl) UpdateStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus) error {
-	return r.db.WithContext(ctx).Model(&entities.Order{}).
-		Where("id = ?", id).
+func (r *OrderRepositoryImpl) UpdateStatus(ctx context.Context, id uuid.UUID, status entities.OrderStatus, outletID uuid.UUID) error {
+	query := r.db.WithContext(ctx).Model(&entities.Order{})
+	query = applyOutletFilter(query, outletID)
+	return query.Where("id = ?", id).
 		Update("status", status).Error
 }

@@ -105,7 +105,7 @@ func (r *OrganizationRepositoryImpl) GetTotalOmset(ctx context.Context, organiza
 	var total float64
 	err := r.db.WithContext(ctx).
 		Table("orders").
-		Where("organization_id = ? AND payment_status = ?", organizationID, "completed").
+		Where("organization_id = ? AND payment_status = ? AND is_void = ? AND is_refund = ?", organizationID, "completed", false, false).
 		Select("COALESCE(SUM(total_amount), 0)").
 		Scan(&total).Error
 	return total, err
@@ -0,0 +1,85 @@
+package repository
+
+import (
+	"context"
+
+	"apskel-pos-be/internal/entities"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+type ProductOutletPriceRepository interface {
+	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*entities.ProductOutletPrice, error)
+	GetByProduct(ctx context.Context, productID uuid.UUID) ([]*entities.ProductOutletPrice, error)
+	GetByProductWithOutlet(ctx context.Context, productID uuid.UUID) ([]*entities.ProductOutletPrice, error)
+	GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*entities.ProductOutletPrice, error)
+	GetByProductsAndOutlet(ctx context.Context, productIDs []uuid.UUID, outletID uuid.UUID) ([]*entities.ProductOutletPrice, error)
+	Upsert(ctx context.Context, price *entities.ProductOutletPrice) error
+	Delete(ctx context.Context, id uuid.UUID) error
+	GetByID(ctx context.Context, id uuid.UUID) (*entities.ProductOutletPrice, error)
+}
+
+type ProductOutletPriceRepositoryImpl struct {
+	db *gorm.DB
+}
+
+func NewProductOutletPriceRepositoryImpl(db *gorm.DB) *ProductOutletPriceRepositoryImpl {
+	return &ProductOutletPriceRepositoryImpl{
+		db: db,
+	}
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*entities.ProductOutletPrice, error) {
+	var price entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).Where("product_id = ? AND outlet_id = ?", productID, outletID).First(&price).Error
+	if err != nil {
+		return nil, err
+	}
+	return &price, nil
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByProduct(ctx context.Context, productID uuid.UUID) ([]*entities.ProductOutletPrice, error) {
+	var prices []*entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).Where("product_id = ?", productID).Find(&prices).Error
+	return prices, err
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByOutlet(ctx context.Context, outletID uuid.UUID) ([]*entities.ProductOutletPrice, error) {
+	var prices []*entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).Where("outlet_id = ?", outletID).Find(&prices).Error
+	return prices, err
+}
+
+func (r *ProductOutletPriceRepositoryImpl) Upsert(ctx context.Context, price *entities.ProductOutletPrice) error {
+	return r.db.WithContext(ctx).Clauses(clause.OnConflict{
+		Columns:   []clause.Column{{Name: "product_id"}, {Name: "outlet_id"}},
+		DoUpdates: clause.AssignmentColumns([]string{"price", "updated_at"}),
+	}).Create(price).Error
+}
+
+func (r *ProductOutletPriceRepositoryImpl) Delete(ctx context.Context, id uuid.UUID) error {
+	return r.db.WithContext(ctx).Delete(&entities.ProductOutletPrice{}, "id = ?", id).Error
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByID(ctx context.Context, id uuid.UUID) (*entities.ProductOutletPrice, error) {
+	var price entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).First(&price, "id = ?", id).Error
+	if err != nil {
+		return nil, err
+	}
+	return &price, nil
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByProductsAndOutlet(ctx context.Context, productIDs []uuid.UUID, outletID uuid.UUID) ([]*entities.ProductOutletPrice, error) {
+	var prices []*entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).Where("product_id IN ? AND outlet_id = ?", productIDs, outletID).Find(&prices).Error
+	return prices, err
+}
+
+func (r *ProductOutletPriceRepositoryImpl) GetByProductWithOutlet(ctx context.Context, productID uuid.UUID) ([]*entities.ProductOutletPrice, error) {
+	var prices []*entities.ProductOutletPrice
+	err := r.db.WithContext(ctx).Preload("Outlet").Where("product_id = ?", productID).Find(&prices).Error
+	return prices, err
+}
@@ -189,3 +189,47 @@ func (r *ProductRepositoryImpl) GetLowCostProducts(ctx context.Context, organiza
 	err := r.db.WithContext(ctx).Where("organization_id = ? AND cost <= ? AND is_active = ?", organizationID, maxCost, true).Find(&products).Error
 	return products, err
 }
+
+// ListWithOutletPrice fetches products with the same filters as List, but overrides
+// each product's Price with the outlet-specific price from product_outlet_prices when
+// outletID is provided. A single LEFT JOIN is used so no second round-trip is needed.
+func (r *ProductRepositoryImpl) ListWithOutletPrice(ctx context.Context, filters map[string]interface{}, outletID uuid.UUID, limit, offset int) ([]*entities.Product, int64, error) {
+	var products []*entities.Product
+	var total int64
+
+	// Base query with category and variant preloads
+	query := r.db.WithContext(ctx).Model(&entities.Product{}).
+		Preload("Category").
+		Preload("ProductVariants")
+
+	// Apply filters
+	for key, value := range filters {
+		switch key {
+		case "search":
+			searchValue := "%" + value.(string) + "%"
+			query = query.Where("products.name ILIKE ? OR products.description ILIKE ? OR products.sku ILIKE ?", searchValue, searchValue, searchValue)
+		case "price_min":
+			query = query.Where("products.price >= ?", value)
+		case "price_max":
+			query = query.Where("products.price <= ?", value)
+		default:
+			query = query.Where("products."+key+" = ?", value)
+		}
+	}
+
+	// When outletID is provided, INNER JOIN product_outlet_prices so only products
+	// that have been explicitly assigned to this outlet are returned, with their
+	// outlet-specific price.
+	if outletID != uuid.Nil {
+		query = query.
+			Joins("INNER JOIN product_outlet_prices pop ON pop.product_id = products.id AND pop.outlet_id = ?", outletID).
+			Select("products.*, pop.price AS price")
+	}
+
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	err := query.Limit(limit).Offset(offset).Find(&products).Error
+	return products, total, err
+}
@@ -49,11 +49,12 @@ type Router struct {
 	userDeviceHandler                 *handler.UserDeviceHandler
 	notificationHandler               *handler.NotificationHandler
 	selfOrderHandler                  *handler.SelfOrderHandler
+	productOutletPriceHandler         *handler.ProductOutletPriceHandler
 	authMiddleware                    *middleware.AuthMiddleware
 	customerAuthMiddleware            *middleware.CustomerAuthMiddleware
 }

-func NewRouter(cfg *config.Config, healthHandler *handler.HealthHandler, authService service.AuthService, authMiddleware *middleware.AuthMiddleware, userService *service.UserServiceImpl, userValidator *validator.UserValidatorImpl, organizationService service.OrganizationService, organizationValidator validator.OrganizationValidator, outletService service.OutletService, outletValidator validator.OutletValidator, outletSettingService service.OutletSettingService, categoryService service.CategoryService, categoryValidator validator.CategoryValidator, productService service.ProductService, productValidator validator.ProductValidator, productVariantService service.ProductVariantService, productVariantValidator validator.ProductVariantValidator, inventoryService service.InventoryService, inventoryValidator validator.InventoryValidator, orderService service.OrderService, orderValidator validator.OrderValidator, fileService service.FileService, fileValidator validator.FileValidator, customerService service.CustomerService, customerValidator validator.CustomerValidator, paymentMethodService service.PaymentMethodService, paymentMethodValidator validator.PaymentMethodValidator, analyticsService *service.AnalyticsServiceImpl, reportService service.ReportService, tableService *service.TableServiceImpl, tableValidator *validator.TableValidator, unitService handler.UnitService, ingredientService handler.IngredientService, productRecipeService service.ProductRecipeService, vendorService service.VendorService, vendorValidator validator.VendorValidator, purchaseOrderService service.PurchaseOrderService, purchaseOrderValidator validator.PurchaseOrderValidator, unitConverterService service.IngredientUnitConverterService, unitConverterValidator validator.IngredientUnitConverterValidator, chartOfAccountTypeService service.ChartOfAccountTypeService, chartOfAccountTypeValidator validator.ChartOfAccountTypeValidator, chartOfAccountService service.ChartOfAccountService, chartOfAccountValidator validator.ChartOfAccountValidator, accountService service.AccountService, accountValidator validator.AccountValidator, orderIngredientTransactionService service.OrderIngredientTransactionService, orderIngredientTransactionValidator validator.OrderIngredientTransactionValidator, gamificationService service.GamificationService, gamificationValidator validator.GamificationValidator, rewardService service.RewardService, rewardValidator validator.RewardValidator, campaignService service.CampaignService, campaignValidator validator.CampaignValidator, customerAuthService service.CustomerAuthService, customerAuthValidator validator.CustomerAuthValidator, customerPointsService service.CustomerPointsService, spinGameService service.SpinGameService, customerAuthMiddleware *middleware.CustomerAuthMiddleware, userDeviceService service.UserDeviceService, userDeviceValidator validator.UserDeviceValidator, notificationService service.NotificationService, notificationValidator validator.NotificationValidator, selfOrderHandler *handler.SelfOrderHandler) *Router {
+func NewRouter(cfg *config.Config, healthHandler *handler.HealthHandler, authService service.AuthService, authMiddleware *middleware.AuthMiddleware, userService *service.UserServiceImpl, userValidator *validator.UserValidatorImpl, organizationService service.OrganizationService, organizationValidator validator.OrganizationValidator, outletService service.OutletService, outletValidator validator.OutletValidator, outletSettingService service.OutletSettingService, categoryService service.CategoryService, categoryValidator validator.CategoryValidator, productService service.ProductService, productValidator validator.ProductValidator, productVariantService service.ProductVariantService, productVariantValidator validator.ProductVariantValidator, inventoryService service.InventoryService, inventoryValidator validator.InventoryValidator, orderService service.OrderService, orderValidator validator.OrderValidator, fileService service.FileService, fileValidator validator.FileValidator, customerService service.CustomerService, customerValidator validator.CustomerValidator, paymentMethodService service.PaymentMethodService, paymentMethodValidator validator.PaymentMethodValidator, analyticsService *service.AnalyticsServiceImpl, reportService service.ReportService, tableService *service.TableServiceImpl, tableValidator *validator.TableValidator, unitService handler.UnitService, ingredientService handler.IngredientService, productRecipeService service.ProductRecipeService, vendorService service.VendorService, vendorValidator validator.VendorValidator, purchaseOrderService service.PurchaseOrderService, purchaseOrderValidator validator.PurchaseOrderValidator, unitConverterService service.IngredientUnitConverterService, unitConverterValidator validator.IngredientUnitConverterValidator, chartOfAccountTypeService service.ChartOfAccountTypeService, chartOfAccountTypeValidator validator.ChartOfAccountTypeValidator, chartOfAccountService service.ChartOfAccountService, chartOfAccountValidator validator.ChartOfAccountValidator, accountService service.AccountService, accountValidator validator.AccountValidator, orderIngredientTransactionService service.OrderIngredientTransactionService, orderIngredientTransactionValidator validator.OrderIngredientTransactionValidator, gamificationService service.GamificationService, gamificationValidator validator.GamificationValidator, rewardService service.RewardService, rewardValidator validator.RewardValidator, campaignService service.CampaignService, campaignValidator validator.CampaignValidator, customerAuthService service.CustomerAuthService, customerAuthValidator validator.CustomerAuthValidator, customerPointsService service.CustomerPointsService, spinGameService service.SpinGameService, customerAuthMiddleware *middleware.CustomerAuthMiddleware, userDeviceService service.UserDeviceService, userDeviceValidator validator.UserDeviceValidator, notificationService service.NotificationService, notificationValidator validator.NotificationValidator, productOutletPriceService service.ProductOutletPriceService, productOutletPriceValidator validator.ProductOutletPriceValidator, selfOrderHandler *handler.SelfOrderHandler) *Router {

 	return &Router{
 		config:                            cfg,
@@ -95,6 +96,7 @@ func NewRouter(cfg *config.Config, healthHandler *handler.HealthHandler, authSer
 		userDeviceHandler:                 handler.NewUserDeviceHandler(userDeviceService, userDeviceValidator),
 		notificationHandler:               handler.NewNotificationHandler(notificationService, notificationValidator),
 		selfOrderHandler:                  selfOrderHandler,
+		productOutletPriceHandler:         handler.NewProductOutletPriceHandler(productOutletPriceService, productOutletPriceValidator),
 	}
 }

@@ -223,11 +225,23 @@ func (r *Router) addAppRoutes(rg *gin.Engine) {
 			{
 				products.POST("", r.productHandler.CreateProduct)
 				products.GET("", r.productHandler.ListProducts)
+				products.GET("/all", r.productHandler.ListProductAll)
 				products.GET("/:id", r.productHandler.GetProduct)
 				products.PUT("/:id", r.productHandler.UpdateProduct)
 				products.DELETE("/:id", r.productHandler.DeleteProduct)
 			}

+			productOutletPrices := protected.Group("/product-outlet-prices")
+			productOutletPrices.Use(r.authMiddleware.RequireAdminOrManager())
+			{
+				productOutletPrices.POST("", r.productOutletPriceHandler.Upsert)
+				productOutletPrices.POST("/bulk", r.productOutletPriceHandler.BulkUpsert)
+				productOutletPrices.GET("/product/:product_id", r.productOutletPriceHandler.GetByProduct)
+				productOutletPrices.GET("/outlet/:outlet_id", r.productOutletPriceHandler.GetByOutlet)
+				productOutletPrices.GET("/product/:product_id/outlet/:outlet_id", r.productOutletPriceHandler.GetByProductAndOutlet)
+				productOutletPrices.DELETE("/:id", r.productOutletPriceHandler.Delete)
+			}
+
 			productVariants := protected.Group("/product-variants")
 			{
 				productVariants.POST("", r.productVariantHandler.CreateProductVariant)
@@ -23,16 +23,16 @@ type orderUserRepository interface {

 type OrderService interface {
 	CreateOrder(ctx context.Context, req *models.CreateOrderRequest, organizationID uuid.UUID) (*models.OrderResponse, error)
-	AddToOrder(ctx context.Context, orderID uuid.UUID, req *models.AddToOrderRequest) (*models.AddToOrderResponse, error)
-	UpdateOrder(ctx context.Context, id uuid.UUID, req *models.UpdateOrderRequest) (*models.OrderResponse, error)
-	GetOrderByID(ctx context.Context, id uuid.UUID) (*models.OrderResponse, error)
+	AddToOrder(ctx context.Context, orderID uuid.UUID, req *models.AddToOrderRequest, outletID uuid.UUID) (*models.AddToOrderResponse, error)
+	UpdateOrder(ctx context.Context, id uuid.UUID, req *models.UpdateOrderRequest, outletID uuid.UUID) (*models.OrderResponse, error)
+	GetOrderByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*models.OrderResponse, error)
 	ListOrders(ctx context.Context, req *models.ListOrdersRequest) (*models.ListOrdersResponse, error)
-	VoidOrder(ctx context.Context, req *models.VoidOrderRequest, voidedBy uuid.UUID) error
-	RefundOrder(ctx context.Context, id uuid.UUID, req *models.RefundOrderRequest, refundedBy uuid.UUID) error
-	CreatePayment(ctx context.Context, req *models.CreatePaymentRequest) (*models.PaymentResponse, error)
-	RefundPayment(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID) error
-	SetOrderCustomer(ctx context.Context, orderID uuid.UUID, req *models.SetOrderCustomerRequest, organizationID uuid.UUID) (*models.SetOrderCustomerResponse, error)
-	SplitBill(ctx context.Context, req *models.SplitBillRequest) (*models.SplitBillResponse, error)
+	VoidOrder(ctx context.Context, req *models.VoidOrderRequest, voidedBy uuid.UUID, outletID uuid.UUID) error
+	RefundOrder(ctx context.Context, id uuid.UUID, req *models.RefundOrderRequest, refundedBy uuid.UUID, outletID uuid.UUID) error
+	CreatePayment(ctx context.Context, req *models.CreatePaymentRequest, outletID uuid.UUID) (*models.PaymentResponse, error)
+	RefundPayment(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID, outletID uuid.UUID) error
+	SetOrderCustomer(ctx context.Context, orderID uuid.UUID, req *models.SetOrderCustomerRequest, organizationID uuid.UUID, outletID uuid.UUID) (*models.SetOrderCustomerResponse, error)
+	SplitBill(ctx context.Context, req *models.SplitBillRequest, outletID uuid.UUID) (*models.SplitBillResponse, error)
 }

 type OrderServiceImpl struct {
@@ -216,7 +216,7 @@ func (s *OrderServiceImpl) createIngredientTransactions(ctx context.Context, ord
 	return allTransactions, nil
 }

-func (s *OrderServiceImpl) AddToOrder(ctx context.Context, orderID uuid.UUID, req *models.AddToOrderRequest) (*models.AddToOrderResponse, error) {
+func (s *OrderServiceImpl) AddToOrder(ctx context.Context, orderID uuid.UUID, req *models.AddToOrderRequest, outletID uuid.UUID) (*models.AddToOrderResponse, error) {
 	if orderID == uuid.Nil {
 		return nil, fmt.Errorf("invalid order ID")
 	}
@@ -229,7 +229,7 @@ func (s *OrderServiceImpl) AddToOrder(ctx context.Context, orderID uuid.UUID, re
 	var ingredientTransactions []*contract.CreateOrderIngredientTransactionRequest

 	err := s.txManager.WithTransaction(ctx, func(txCtx context.Context) error {
-		addResp, err := s.orderProcessor.AddToOrder(txCtx, orderID, req)
+		addResp, err := s.orderProcessor.AddToOrder(txCtx, orderID, req, outletID)
 		if err != nil {
 			return fmt.Errorf("failed to add items to order: %w", err)
 		}
@@ -257,12 +257,12 @@ func (s *OrderServiceImpl) AddToOrder(ctx context.Context, orderID uuid.UUID, re
 	return response, nil
 }

-func (s *OrderServiceImpl) UpdateOrder(ctx context.Context, id uuid.UUID, req *models.UpdateOrderRequest) (*models.OrderResponse, error) {
+func (s *OrderServiceImpl) UpdateOrder(ctx context.Context, id uuid.UUID, req *models.UpdateOrderRequest, outletID uuid.UUID) (*models.OrderResponse, error) {
 	if err := s.validateUpdateOrderRequest(req); err != nil {
 		return nil, fmt.Errorf("validation error: %w", err)
 	}

-	response, err := s.orderProcessor.UpdateOrder(ctx, id, req)
+	response, err := s.orderProcessor.UpdateOrder(ctx, id, req, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to update order: %w", err)
 	}
@@ -270,12 +270,12 @@ func (s *OrderServiceImpl) UpdateOrder(ctx context.Context, id uuid.UUID, req *m
 	return response, nil
 }

-func (s *OrderServiceImpl) GetOrderByID(ctx context.Context, id uuid.UUID) (*models.OrderResponse, error) {
+func (s *OrderServiceImpl) GetOrderByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) (*models.OrderResponse, error) {
 	if id == uuid.Nil {
 		return nil, fmt.Errorf("invalid order ID")
 	}

-	response, err := s.orderProcessor.GetOrderByID(ctx, id)
+	response, err := s.orderProcessor.GetOrderByID(ctx, id, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to get order: %w", err)
 	}
@@ -296,7 +296,7 @@ func (s *OrderServiceImpl) ListOrders(ctx context.Context, req *models.ListOrder
 	return response, nil
 }

-func (s *OrderServiceImpl) VoidOrder(ctx context.Context, req *models.VoidOrderRequest, voidedBy uuid.UUID) error {
+func (s *OrderServiceImpl) VoidOrder(ctx context.Context, req *models.VoidOrderRequest, voidedBy uuid.UUID, outletID uuid.UUID) error {
 	if req.OrderID == uuid.Nil {
 		return fmt.Errorf("invalid order ID")
 	}
@@ -305,7 +305,7 @@ func (s *OrderServiceImpl) VoidOrder(ctx context.Context, req *models.VoidOrderR
 		return fmt.Errorf("invalid user ID")
 	}

-	if err := s.orderProcessor.VoidOrder(ctx, req, voidedBy); err != nil {
+	if err := s.orderProcessor.VoidOrder(ctx, req, voidedBy, outletID); err != nil {
 		return fmt.Errorf("failed to void order: %w", err)
 	}

@@ -316,7 +316,7 @@ func (s *OrderServiceImpl) VoidOrder(ctx context.Context, req *models.VoidOrderR
 	return nil
 }

-func (s *OrderServiceImpl) RefundOrder(ctx context.Context, id uuid.UUID, req *models.RefundOrderRequest, refundedBy uuid.UUID) error {
+func (s *OrderServiceImpl) RefundOrder(ctx context.Context, id uuid.UUID, req *models.RefundOrderRequest, refundedBy uuid.UUID, outletID uuid.UUID) error {
 	// Validate inputs
 	if id == uuid.Nil {
 		return fmt.Errorf("invalid order ID")
@@ -331,19 +331,19 @@ func (s *OrderServiceImpl) RefundOrder(ctx context.Context, id uuid.UUID, req *m
 	}

 	// Process order refund
-	if err := s.orderProcessor.RefundOrder(ctx, id, req, refundedBy); err != nil {
+	if err := s.orderProcessor.RefundOrder(ctx, id, req, refundedBy, outletID); err != nil {
 		return fmt.Errorf("failed to refund order: %w", err)
 	}

 	return nil
 }

-func (s *OrderServiceImpl) CreatePayment(ctx context.Context, req *models.CreatePaymentRequest) (*models.PaymentResponse, error) {
+func (s *OrderServiceImpl) CreatePayment(ctx context.Context, req *models.CreatePaymentRequest, outletID uuid.UUID) (*models.PaymentResponse, error) {
 	if err := s.validateCreatePaymentRequest(req); err != nil {
 		return nil, fmt.Errorf("validation error: %w", err)
 	}

-	response, err := s.orderProcessor.CreatePayment(ctx, req)
+	response, err := s.orderProcessor.CreatePayment(ctx, req, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create payment: %w", err)
 	}
@@ -355,7 +355,7 @@ func (s *OrderServiceImpl) CreatePayment(ctx context.Context, req *models.Create
 	return response, nil
 }

-func (s *OrderServiceImpl) RefundPayment(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID) error {
+func (s *OrderServiceImpl) RefundPayment(ctx context.Context, paymentID uuid.UUID, refundAmount float64, reason string, refundedBy uuid.UUID, outletID uuid.UUID) error {
 	// Validate inputs
 	if paymentID == uuid.Nil {
 		return fmt.Errorf("invalid payment ID")
@@ -368,14 +368,14 @@ func (s *OrderServiceImpl) RefundPayment(ctx context.Context, paymentID uuid.UUI
 	}

 	// Process payment refund
-	if err := s.orderProcessor.RefundPayment(ctx, paymentID, refundAmount, reason, refundedBy); err != nil {
+	if err := s.orderProcessor.RefundPayment(ctx, paymentID, refundAmount, reason, refundedBy, outletID); err != nil {
 		return fmt.Errorf("failed to refund payment: %w", err)
 	}

 	return nil
 }

-func (s *OrderServiceImpl) SetOrderCustomer(ctx context.Context, orderID uuid.UUID, req *models.SetOrderCustomerRequest, organizationID uuid.UUID) (*models.SetOrderCustomerResponse, error) {
+func (s *OrderServiceImpl) SetOrderCustomer(ctx context.Context, orderID uuid.UUID, req *models.SetOrderCustomerRequest, organizationID uuid.UUID, outletID uuid.UUID) (*models.SetOrderCustomerResponse, error) {
 	// Validate inputs
 	if orderID == uuid.Nil {
 		return nil, fmt.Errorf("invalid order ID")
@@ -391,7 +391,7 @@ func (s *OrderServiceImpl) SetOrderCustomer(ctx context.Context, orderID uuid.UU
 	}

 	// Process setting customer for order
-	response, err := s.orderProcessor.SetOrderCustomer(ctx, orderID, req, organizationID)
+	response, err := s.orderProcessor.SetOrderCustomer(ctx, orderID, req, organizationID, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to set customer for order: %w", err)
 	}
@@ -584,12 +584,12 @@ func (s *OrderServiceImpl) validateSetOrderCustomerRequest(req *models.SetOrderC
 	return nil
 }

-func (s *OrderServiceImpl) SplitBill(ctx context.Context, req *models.SplitBillRequest) (*models.SplitBillResponse, error) {
+func (s *OrderServiceImpl) SplitBill(ctx context.Context, req *models.SplitBillRequest, outletID uuid.UUID) (*models.SplitBillResponse, error) {
 	if err := s.validateSplitBillRequest(req); err != nil {
 		return nil, fmt.Errorf("validation error: %w", err)
 	}

-	response, err := s.orderProcessor.SplitBill(ctx, req)
+	response, err := s.orderProcessor.SplitBill(ctx, req, outletID)
 	if err != nil {
 		return nil, fmt.Errorf("failed to split bill: %w", err)
 	}
@@ -680,7 +680,7 @@ func (s *OrderServiceImpl) occupyTableWithOrder(ctx context.Context, tableID, or
 }

 func (s *OrderServiceImpl) handleTableReleaseOnPayment(ctx context.Context, orderID uuid.UUID) error {
-	order, err := s.orderProcessor.GetOrderByID(ctx, orderID)
+	order, err := s.orderProcessor.GetOrderByID(ctx, orderID, uuid.Nil)
 	if err != nil {
 		return fmt.Errorf("failed to get order: %w", err)
 	}
@@ -0,0 +1,125 @@
+package service
+
+import (
+	"context"
+	"errors"
+
+	"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"
+
+	"github.com/google/uuid"
+	"gorm.io/gorm"
+)
+
+type ProductOutletPriceService interface {
+	Upsert(ctx context.Context, req *contract.CreateProductOutletPriceRequest) *contract.Response
+	GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) *contract.Response
+	GetByProduct(ctx context.Context, productID uuid.UUID) *contract.Response
+	GetByOutlet(ctx context.Context, outletID uuid.UUID) *contract.Response
+	Delete(ctx context.Context, id uuid.UUID) *contract.Response
+	BulkUpsert(ctx context.Context, req *contract.BulkCreateProductOutletPriceRequest) *contract.Response
+}
+
+type ProductOutletPriceServiceImpl struct {
+	processor processor.ProductOutletPriceProcessor
+}
+
+func NewProductOutletPriceService(proc processor.ProductOutletPriceProcessor) *ProductOutletPriceServiceImpl {
+	return &ProductOutletPriceServiceImpl{
+		processor: proc,
+	}
+}
+
+func (s *ProductOutletPriceServiceImpl) Upsert(ctx context.Context, req *contract.CreateProductOutletPriceRequest) *contract.Response {
+	modelReq := transformer.CreateProductOutletPriceRequestToModel(req)
+
+	result, err := s.processor.Upsert(ctx, modelReq)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResp := transformer.ProductOutletPriceModelToResponse(result)
+	return contract.BuildSuccessResponse(contractResp)
+}
+
+func (s *ProductOutletPriceServiceImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) *contract.Response {
+	result, err := s.processor.GetByProductAndOutlet(ctx, productID, outletID)
+	if err != nil {
+		code := constants.InternalServerErrorCode
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			code = constants.NotFoundErrorCode
+		}
+		errorResp := contract.NewResponseError(code, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResp := transformer.ProductOutletPriceModelToResponse(result)
+	return contract.BuildSuccessResponse(contractResp)
+}
+
+func (s *ProductOutletPriceServiceImpl) GetByProduct(ctx context.Context, productID uuid.UUID) *contract.Response {
+	results, err := s.processor.GetByProduct(ctx, productID)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
+	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
+		Prices:     contractResps,
+		TotalCount: len(contractResps),
+	})
+}
+
+func (s *ProductOutletPriceServiceImpl) GetByOutlet(ctx context.Context, outletID uuid.UUID) *contract.Response {
+	results, err := s.processor.GetByOutlet(ctx, outletID)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
+	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
+		Prices:     contractResps,
+		TotalCount: len(contractResps),
+	})
+}
+
+func (s *ProductOutletPriceServiceImpl) Delete(ctx context.Context, id uuid.UUID) *contract.Response {
+	err := s.processor.Delete(ctx, id)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	return contract.BuildSuccessResponse(map[string]interface{}{
+		"message": "Product outlet price deleted successfully",
+	})
+}
+
+func (s *ProductOutletPriceServiceImpl) BulkUpsert(ctx context.Context, req *contract.BulkCreateProductOutletPriceRequest) *contract.Response {
+	prices := make([]models.CreateProductOutletPriceRequest, len(req.Prices))
+	for i, p := range req.Prices {
+		prices[i] = models.CreateProductOutletPriceRequest{
+			ProductID: req.ProductID,
+			OutletID:  p.OutletID,
+			Price:     p.Price,
+		}
+	}
+
+	results, err := s.processor.BulkUpsert(ctx, req.ProductID, prices)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	contractResps := transformer.ProductOutletPriceModelsToResponses(results)
+	return contract.BuildSuccessResponse(&contract.ListProductOutletPricesResponse{
+		Prices:     contractResps,
+		TotalCount: len(contractResps),
+	})
+}
@@ -16,8 +16,9 @@ type ProductService interface {
 	CreateProduct(ctx context.Context, apctx *appcontext.ContextInfo, req *contract.CreateProductRequest) *contract.Response
 	UpdateProduct(ctx context.Context, id uuid.UUID, req *contract.UpdateProductRequest) *contract.Response
 	DeleteProduct(ctx context.Context, id uuid.UUID) *contract.Response
-	GetProductByID(ctx context.Context, id uuid.UUID) *contract.Response
+	GetProductByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) *contract.Response
 	ListProducts(ctx context.Context, req *contract.ListProductsRequest) *contract.Response
+	ListProductsAll(ctx context.Context, req *contract.ListProductsRequest) *contract.Response
 }

 type ProductServiceImpl struct {
@@ -68,8 +69,8 @@ func (s *ProductServiceImpl) DeleteProduct(ctx context.Context, id uuid.UUID) *c
 	})
 }

-func (s *ProductServiceImpl) GetProductByID(ctx context.Context, id uuid.UUID) *contract.Response {
-	productResponse, err := s.productProcessor.GetProductByID(ctx, id)
+func (s *ProductServiceImpl) GetProductByID(ctx context.Context, id uuid.UUID, outletID uuid.UUID) *contract.Response {
+	productResponse, err := s.productProcessor.GetProductByID(ctx, id, outletID)
 	if err != nil {
 		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductServiceEntity, err.Error())
 		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
@@ -85,6 +86,63 @@ func (s *ProductServiceImpl) ListProducts(ctx context.Context, req *contract.Lis
 	if req.OrganizationID != nil {
 		filters["organization_id"] = *req.OrganizationID
 	}
+	if req.OutletID != nil {
+		filters["outlet_id"] = *req.OutletID
+	}
+	if req.CategoryID != nil {
+		filters["category_id"] = *req.CategoryID
+	}
+	if req.BusinessType != "" {
+		filters["business_type"] = req.BusinessType
+	}
+	if req.IsActive != nil {
+		filters["is_active"] = *req.IsActive
+	}
+	if req.Search != "" {
+		filters["search"] = req.Search
+	}
+	if req.MinPrice != nil {
+		filters["price_min"] = *req.MinPrice
+	}
+	if req.MaxPrice != nil {
+		filters["price_max"] = *req.MaxPrice
+	}
+
+	products, totalCount, err := s.productProcessor.ListProducts(ctx, filters, req.Page, req.Limit)
+	if err != nil {
+		errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductServiceEntity, err.Error())
+		return contract.BuildErrorResponse([]*contract.ResponseError{errorResp})
+	}
+
+	// Convert to contract responses
+	contractResponses := transformer.ProductsToResponses(products)
+
+	// Calculate total pages
+	totalPages := totalCount / req.Limit
+	if totalCount%req.Limit > 0 {
+		totalPages++
+	}
+
+	listResponse := &contract.ListProductsResponse{
+		Products:   contractResponses,
+		TotalCount: totalCount,
+		Page:       req.Page,
+		Limit:      req.Limit,
+		TotalPages: totalPages,
+	}
+
+	return contract.BuildSuccessResponse(listResponse)
+}
+
+func (s *ProductServiceImpl) ListProductsAll(ctx context.Context, req *contract.ListProductsRequest) *contract.Response {
+	// Build filters
+	filters := make(map[string]interface{})
+	if req.OrganizationID != nil {
+		filters["organization_id"] = *req.OrganizationID
+	}
+	if req.OutletID != nil {
+		filters["outlet_id"] = *req.OutletID
+	}
 	if req.CategoryID != nil {
 		filters["category_id"] = *req.CategoryID
 	}
@@ -0,0 +1,55 @@
+package transformer
+
+import (
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/models"
+)
+
+func CreateProductOutletPriceRequestToModel(req *contract.CreateProductOutletPriceRequest) *models.CreateProductOutletPriceRequest {
+	if req == nil {
+		return nil
+	}
+
+	return &models.CreateProductOutletPriceRequest{
+		ProductID: req.ProductID,
+		OutletID:  req.OutletID,
+		Price:     req.Price,
+	}
+}
+
+func UpdateProductOutletPriceRequestToModel(req *contract.UpdateProductOutletPriceRequest) *models.UpdateProductOutletPriceRequest {
+	if req == nil {
+		return nil
+	}
+
+	return &models.UpdateProductOutletPriceRequest{
+		Price: &req.Price,
+	}
+}
+
+func ProductOutletPriceModelToResponse(m *models.ProductOutletPrice) *contract.ProductOutletPriceResponse {
+	if m == nil {
+		return nil
+	}
+
+	return &contract.ProductOutletPriceResponse{
+		ID:        m.ID,
+		ProductID: m.ProductID,
+		OutletID:  m.OutletID,
+		Price:     m.Price,
+		CreatedAt: m.CreatedAt,
+		UpdatedAt: m.UpdatedAt,
+	}
+}
+
+func ProductOutletPriceModelsToResponses(ms []*models.ProductOutletPrice) []contract.ProductOutletPriceResponse {
+	if ms == nil {
+		return nil
+	}
+
+	responses := make([]contract.ProductOutletPriceResponse, len(ms))
+	for i, m := range ms {
+		responses[i] = *ProductOutletPriceModelToResponse(m)
+	}
+	return responses
+}
@@ -97,6 +97,19 @@ func ProductModelResponseToResponse(prod *models.ProductResponse) *contract.Prod
 		}
 	}

+	// Convert outlet prices
+	var outletPriceResponses []contract.ProductOutletPriceResponse
+	if len(prod.OutletPrices) > 0 {
+		outletPriceResponses = make([]contract.ProductOutletPriceResponse, len(prod.OutletPrices))
+		for i, op := range prod.OutletPrices {
+			outletPriceResponses[i] = contract.ProductOutletPriceResponse{
+				OutletID:   op.OutletID,
+				OutletName: op.OutletName,
+				Price:      op.Price,
+			}
+		}
+	}
+
 	return &contract.ProductResponse{
 		ID:             prod.ID,
 		OrganizationID: prod.OrganizationID,
@@ -106,6 +119,8 @@ func ProductModelResponseToResponse(prod *models.ProductResponse) *contract.Prod
 		Name:           prod.Name,
 		Description:    prod.Description,
 		Price:          prod.Price,
+		OutletPrice:    prod.OutletPrice,
+		OutletPrices:   outletPriceResponses,
 		Cost:           prod.Cost,
 		BusinessType:   string(prod.BusinessType),
 		ImageURL:       prod.ImageURL,
@@ -0,0 +1,80 @@
+package validator
+
+import (
+	"errors"
+	"fmt"
+
+	"apskel-pos-be/internal/constants"
+	"apskel-pos-be/internal/contract"
+
+	"github.com/google/uuid"
+)
+
+type ProductOutletPriceValidator interface {
+	ValidateCreateRequest(req *contract.CreateProductOutletPriceRequest) (error, string)
+	ValidateUpdateRequest(req *contract.UpdateProductOutletPriceRequest) (error, string)
+	ValidateBulkCreateRequest(req *contract.BulkCreateProductOutletPriceRequest) (error, string)
+}
+
+type ProductOutletPriceValidatorImpl struct{}
+
+func NewProductOutletPriceValidator() *ProductOutletPriceValidatorImpl {
+	return &ProductOutletPriceValidatorImpl{}
+}
+
+func (v *ProductOutletPriceValidatorImpl) ValidateCreateRequest(req *contract.CreateProductOutletPriceRequest) (error, string) {
+	if req == nil {
+		return errors.New("request body is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.ProductID == uuid.Nil {
+		return errors.New("product_id is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.OutletID == uuid.Nil {
+		return errors.New("outlet_id is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.Price < 0 {
+		return errors.New("price must be non-negative"), constants.MalformedFieldErrorCode
+	}
+
+	return nil, ""
+}
+
+func (v *ProductOutletPriceValidatorImpl) ValidateUpdateRequest(req *contract.UpdateProductOutletPriceRequest) (error, string) {
+	if req == nil {
+		return errors.New("request body is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.Price < 0 {
+		return errors.New("price must be non-negative"), constants.MalformedFieldErrorCode
+	}
+
+	return nil, ""
+}
+
+func (v *ProductOutletPriceValidatorImpl) ValidateBulkCreateRequest(req *contract.BulkCreateProductOutletPriceRequest) (error, string) {
+	if req == nil {
+		return errors.New("request body is required"), constants.MissingFieldErrorCode
+	}
+
+	if req.ProductID == uuid.Nil {
+		return errors.New("product_id is required"), constants.MissingFieldErrorCode
+	}
+
+	if len(req.Prices) == 0 {
+		return errors.New("at least one price entry is required"), constants.MissingFieldErrorCode
+	}
+
+	for i, p := range req.Prices {
+		if p.OutletID == uuid.Nil {
+			return errors.New("outlet_id is required for each price entry"), constants.MissingFieldErrorCode
+		}
+		if p.Price < 0 {
+			return fmt.Errorf("price at index %d must be non-negative", i), constants.MalformedFieldErrorCode
+		}
+	}
+
+	return nil, ""
+}
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS product_outlet_prices;
@@ -0,0 +1,12 @@
+CREATE TABLE product_outlet_prices (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    product_id UUID NOT NULL REFERENCES products(id) ON DELETE CASCADE,
+    outlet_id UUID NOT NULL REFERENCES outlets(id) ON DELETE CASCADE,
+    price DECIMAL(10,2) NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
+);
+
+CREATE UNIQUE INDEX idx_product_outlet_prices_product_outlet ON product_outlet_prices(product_id, outlet_id);
+CREATE INDEX idx_product_outlet_prices_product_id ON product_outlet_prices(product_id);
+CREATE INDEX idx_product_outlet_prices_outlet_id ON product_outlet_prices(outlet_id);
Author	SHA1	Message	Date
ryan	a89ff00d94	add filter order by outlet id	2026-05-14 15:15:32 +07:00
ryan	227f11359c	Revert "add list order by outlet id" This reverts commit `7a737d7f83`.	2026-05-14 14:46:32 +07:00
ryan	7a737d7f83	add list order by outlet id	2026-05-14 14:41:50 +07:00
ryan	312ea94e62	fix scheduler counting void and refund	2026-05-14 14:22:07 +07:00
Efril	cb8a830345	fix pointer	2026-05-14 13:54:15 +07:00
Efril	222cadd8df	table and order grouping by outlet	2026-05-14 01:40:17 +07:00
Efril	50d633ee3a	fix products	2026-05-14 01:19:45 +07:00
Efril	21fa21d089	get products all	2026-05-14 00:15:28 +07:00
ryan	5f379faf17	change product list to retrieve its data from product outlets	2026-05-13 23:15:09 +07:00
ryan	3b62504798	fix	2026-05-13 22:30:55 +07:00
ryan	4130cb66df	refactor and add outlet product table	2026-05-13 21:58:54 +07:00
				`@@ -0,0 +1 @@`
				`DROP TABLE IF EXISTS product_outlet_prices;`