add purchasing in analytics endpoint

Merge pull request 'fix pointer' (#9 ) from feature/outlet-table into main
Reviewed-on: #9
2026-05-19 14:45:26 +07:00 · 2026-05-14 06:54:51 +00:00 · 2026-05-14 13:54:15 +07:00 · 2026-05-13 18:40:34 +00:00 · 2026-05-14 01:40:17 +07:00 · 2026-05-13 18:22:44 +00:00
30 changed files with 1189 additions and 37 deletions
@@ -1,5 +1,5 @@
 # 1) Build stage
-FROM golang:1.21-alpine AS build
+FROM golang:1.24-alpine AS build
 RUN apk --no-cache add ca-certificates tzdata git curl
 WORKDIR /src
 COPY go.mod go.sum ./
@@ -347,7 +347,7 @@ 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, repos.productOutletPriceRepo),
@@ -382,7 +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),
+		productOutletPriceProcessor:         processor.NewProductOutletPriceProcessorImpl(repos.productOutletPriceRepo, repos.productRepo, repos.outletRepo),
 	}
 }

@@ -83,6 +83,63 @@ type SalesAnalyticsData struct {
 	NetSales float64   `json:"net_sales"`
 }

+type PurchasingAnalyticsRequest struct {
+	OrganizationID uuid.UUID
+	OutletID       *string `form:"outlet_id,omitempty"`
+	DateFrom       string  `form:"date_from" validate:"required"`
+	DateTo         string  `form:"date_to" validate:"required"`
+	GroupBy        string  `form:"group_by,default=day" validate:"omitempty,oneof=day hour week month"`
+}
+
+type PurchasingAnalyticsResponse struct {
+	OrganizationID uuid.UUID                  `json:"organization_id"`
+	OutletID       *uuid.UUID                 `json:"outlet_id,omitempty"`
+	OutletName     *string                    `json:"outlet_name,omitempty"`
+	DateFrom       time.Time                  `json:"date_from"`
+	DateTo         time.Time                  `json:"date_to"`
+	GroupBy        string                     `json:"group_by"`
+	Summary        PurchasingSummary          `json:"summary"`
+	Data           []PurchasingAnalyticsData  `json:"data"`
+	IngredientData []PurchasingIngredientData `json:"ingredient_data"`
+	VendorData     []PurchasingVendorData     `json:"vendor_data"`
+}
+
+type PurchasingSummary struct {
+	TotalPurchases            float64 `json:"total_purchases"`
+	TotalPurchaseOrders       int64   `json:"total_purchase_orders"`
+	TotalQuantity             float64 `json:"total_quantity"`
+	AveragePurchaseOrderValue float64 `json:"average_purchase_order_value"`
+	TotalIngredients          int64   `json:"total_ingredients"`
+	TotalVendors              int64   `json:"total_vendors"`
+}
+
+type PurchasingAnalyticsData struct {
+	Date           time.Time `json:"date"`
+	Purchases      float64   `json:"purchases"`
+	PurchaseOrders int64     `json:"purchase_orders"`
+	Quantity       float64   `json:"quantity"`
+	Ingredients    int64     `json:"ingredients"`
+	Vendors        int64     `json:"vendors"`
+}
+
+type PurchasingIngredientData struct {
+	IngredientID       uuid.UUID `json:"ingredient_id"`
+	IngredientName     string    `json:"ingredient_name"`
+	Quantity           float64   `json:"quantity"`
+	TotalCost          float64   `json:"total_cost"`
+	AverageUnitCost    float64   `json:"average_unit_cost"`
+	PurchaseOrderCount int64     `json:"purchase_order_count"`
+}
+
+type PurchasingVendorData struct {
+	VendorID           uuid.UUID `json:"vendor_id"`
+	VendorName         string    `json:"vendor_name"`
+	TotalCost          float64   `json:"total_cost"`
+	PurchaseOrderCount int64     `json:"purchase_order_count"`
+	IngredientCount    int64     `json:"ingredient_count"`
+	Quantity           float64   `json:"quantity"`
+}
+
 // ProductAnalyticsRequest represents the request for product analytics
 type ProductAnalyticsRequest struct {
 	OrganizationID uuid.UUID
@@ -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"`
@@ -17,12 +17,13 @@ type UpdateProductOutletPriceRequest struct {
 }

 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"`
+	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 {
@@ -27,6 +27,51 @@ type SalesAnalytics struct {
 	NetSales float64   `json:"net_sales"`
 }

+// PurchasingAnalytics represents purchasing analytics data
+type PurchasingAnalytics struct {
+	OutletName     *string                    `json:"outlet_name,omitempty"`
+	Summary        PurchasingSummary          `json:"summary"`
+	Data           []PurchasingAnalyticsData  `json:"data"`
+	IngredientData []PurchasingIngredientData `json:"ingredient_data"`
+	VendorData     []PurchasingVendorData     `json:"vendor_data"`
+}
+
+type PurchasingSummary struct {
+	TotalPurchases            float64 `json:"total_purchases"`
+	TotalPurchaseOrders       int64   `json:"total_purchase_orders"`
+	TotalQuantity             float64 `json:"total_quantity"`
+	AveragePurchaseOrderValue float64 `json:"average_purchase_order_value"`
+	TotalIngredients          int64   `json:"total_ingredients"`
+	TotalVendors              int64   `json:"total_vendors"`
+}
+
+type PurchasingAnalyticsData struct {
+	Date           time.Time `json:"date"`
+	Purchases      float64   `json:"purchases"`
+	PurchaseOrders int64     `json:"purchase_orders"`
+	Quantity       float64   `json:"quantity"`
+	Ingredients    int64     `json:"ingredients"`
+	Vendors        int64     `json:"vendors"`
+}
+
+type PurchasingIngredientData struct {
+	IngredientID       uuid.UUID `json:"ingredient_id"`
+	IngredientName     string    `json:"ingredient_name"`
+	Quantity           float64   `json:"quantity"`
+	TotalCost          float64   `json:"total_cost"`
+	AverageUnitCost    float64   `json:"average_unit_cost"`
+	PurchaseOrderCount int64     `json:"purchase_order_count"`
+}
+
+type PurchasingVendorData struct {
+	VendorID           uuid.UUID `json:"vendor_id"`
+	VendorName         string    `json:"vendor_name"`
+	TotalCost          float64   `json:"total_cost"`
+	PurchaseOrderCount int64     `json:"purchase_order_count"`
+	IngredientCount    int64     `json:"ingredient_count"`
+	Quantity           float64   `json:"quantity"`
+}
+
 type ProductAnalytics struct {
 	ProductID               uuid.UUID `json:"product_id"`
 	ProductName             string    `json:"product_name"`
@@ -85,6 +85,30 @@ func (h *AnalyticsHandler) GetSalesAnalytics(c *gin.Context) {
 	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(contractResp), "AnalyticsHandler::GetSalesAnalytics")
 }

+func (h *AnalyticsHandler) GetPurchasingAnalytics(c *gin.Context) {
+	ctx := c.Request.Context()
+	contextInfo := appcontext.FromGinContext(ctx)
+
+	var req contract.PurchasingAnalyticsRequest
+	if err := c.ShouldBindQuery(&req); err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("invalid_request", "AnalyticsHandler::GetPurchasingAnalytics", err.Error())}), "AnalyticsHandler::GetPurchasingAnalytics")
+		return
+	}
+
+	req.OrganizationID = contextInfo.OrganizationID
+	req.OutletID = h.resolveOutletID(c, contextInfo.OutletID)
+	modelReq := transformer.PurchasingAnalyticsContractToModel(&req)
+
+	response, err := h.analyticsService.GetPurchasingAnalytics(ctx, modelReq)
+	if err != nil {
+		util.HandleResponse(c.Writer, c.Request, contract.BuildErrorResponse([]*contract.ResponseError{contract.NewResponseError("internal_error", "AnalyticsHandler::GetPurchasingAnalytics", err.Error())}), "AnalyticsHandler::GetPurchasingAnalytics")
+		return
+	}
+
+	contractResp := transformer.PurchasingAnalyticsModelToContract(response)
+	util.HandleResponse(c.Writer, c.Request, contract.BuildSuccessResponse(contractResp), "AnalyticsHandler::GetPurchasingAnalytics")
+}
+
 func (h *AnalyticsHandler) GetProductAnalytics(c *gin.Context) {
 	ctx := c.Request.Context()
 	contextInfo := appcontext.FromGinContext(ctx)
@@ -137,6 +137,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")
@@ -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
@@ -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,
@@ -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()
@@ -87,6 +87,69 @@ type SalesAnalyticsData struct {
 	NetSales float64   `json:"net_sales"`
 }

+// PurchasingAnalyticsRequest represents the request for purchasing analytics
+type PurchasingAnalyticsRequest struct {
+	OrganizationID uuid.UUID  `validate:"required"`
+	OutletID       *uuid.UUID `validate:"omitempty"`
+	DateFrom       time.Time  `validate:"required"`
+	DateTo         time.Time  `validate:"required"`
+	GroupBy        string     `validate:"omitempty,oneof=day hour week month"`
+}
+
+// PurchasingAnalyticsResponse represents the response for purchasing analytics
+type PurchasingAnalyticsResponse struct {
+	OrganizationID uuid.UUID                  `json:"organization_id"`
+	OutletID       *uuid.UUID                 `json:"outlet_id,omitempty"`
+	OutletName     *string                    `json:"outlet_name,omitempty"`
+	DateFrom       time.Time                  `json:"date_from"`
+	DateTo         time.Time                  `json:"date_to"`
+	GroupBy        string                     `json:"group_by"`
+	Summary        PurchasingSummary          `json:"summary"`
+	Data           []PurchasingAnalyticsData  `json:"data"`
+	IngredientData []PurchasingIngredientData `json:"ingredient_data"`
+	VendorData     []PurchasingVendorData     `json:"vendor_data"`
+}
+
+// PurchasingSummary represents the summary of purchasing analytics
+type PurchasingSummary struct {
+	TotalPurchases            float64 `json:"total_purchases"`
+	TotalPurchaseOrders       int64   `json:"total_purchase_orders"`
+	TotalQuantity             float64 `json:"total_quantity"`
+	AveragePurchaseOrderValue float64 `json:"average_purchase_order_value"`
+	TotalIngredients          int64   `json:"total_ingredients"`
+	TotalVendors              int64   `json:"total_vendors"`
+}
+
+// PurchasingAnalyticsData represents purchasing analytics by time period
+type PurchasingAnalyticsData struct {
+	Date           time.Time `json:"date"`
+	Purchases      float64   `json:"purchases"`
+	PurchaseOrders int64     `json:"purchase_orders"`
+	Quantity       float64   `json:"quantity"`
+	Ingredients    int64     `json:"ingredients"`
+	Vendors        int64     `json:"vendors"`
+}
+
+// PurchasingIngredientData represents purchasing analytics for an ingredient
+type PurchasingIngredientData struct {
+	IngredientID       uuid.UUID `json:"ingredient_id"`
+	IngredientName     string    `json:"ingredient_name"`
+	Quantity           float64   `json:"quantity"`
+	TotalCost          float64   `json:"total_cost"`
+	AverageUnitCost    float64   `json:"average_unit_cost"`
+	PurchaseOrderCount int64     `json:"purchase_order_count"`
+}
+
+// PurchasingVendorData represents purchasing analytics for a vendor
+type PurchasingVendorData struct {
+	VendorID           uuid.UUID `json:"vendor_id"`
+	VendorName         string    `json:"vendor_name"`
+	TotalCost          float64   `json:"total_cost"`
+	PurchaseOrderCount int64     `json:"purchase_order_count"`
+	IngredientCount    int64     `json:"ingredient_count"`
+	Quantity           float64   `json:"quantity"`
+}
+
 // ProductAnalyticsRequest represents the request for product analytics
 type ProductAnalyticsRequest struct {
 	OrganizationID uuid.UUID  `validate:"required"`
@@ -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
@@ -12,6 +12,7 @@ import (
 type AnalyticsProcessor interface {
 	GetPaymentMethodAnalytics(ctx context.Context, req *models.PaymentMethodAnalyticsRequest) (*models.PaymentMethodAnalyticsResponse, error)
 	GetSalesAnalytics(ctx context.Context, req *models.SalesAnalyticsRequest) (*models.SalesAnalyticsResponse, error)
+	GetPurchasingAnalytics(ctx context.Context, req *models.PurchasingAnalyticsRequest) (*models.PurchasingAnalyticsResponse, error)
 	GetProductAnalytics(ctx context.Context, req *models.ProductAnalyticsRequest) (*models.ProductAnalyticsResponse, error)
 	GetProductAnalyticsPerCategory(ctx context.Context, req *models.ProductAnalyticsPerCategoryRequest) (*models.ProductAnalyticsPerCategoryResponse, error)
 	GetDashboardAnalytics(ctx context.Context, req *models.DashboardAnalyticsRequest) (*models.DashboardAnalyticsResponse, error)
@@ -164,6 +165,77 @@ func (p *AnalyticsProcessorImpl) GetSalesAnalytics(ctx context.Context, req *mod
 	}, nil
 }

+func (p *AnalyticsProcessorImpl) GetPurchasingAnalytics(ctx context.Context, req *models.PurchasingAnalyticsRequest) (*models.PurchasingAnalyticsResponse, error) {
+	if req.DateFrom.After(req.DateTo) {
+		return nil, fmt.Errorf("date_from cannot be after date_to")
+	}
+
+	if req.GroupBy == "" {
+		req.GroupBy = "day"
+	}
+
+	result, err := p.analyticsRepo.GetPurchasingAnalytics(ctx, req.OrganizationID, req.OutletID, req.DateFrom, req.DateTo, req.GroupBy)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get purchasing analytics: %w", err)
+	}
+
+	data := make([]models.PurchasingAnalyticsData, len(result.Data))
+	for i, item := range result.Data {
+		data[i] = models.PurchasingAnalyticsData{
+			Date:           item.Date,
+			Purchases:      item.Purchases,
+			PurchaseOrders: item.PurchaseOrders,
+			Quantity:       item.Quantity,
+			Ingredients:    item.Ingredients,
+			Vendors:        item.Vendors,
+		}
+	}
+
+	ingredientData := make([]models.PurchasingIngredientData, len(result.IngredientData))
+	for i, item := range result.IngredientData {
+		ingredientData[i] = models.PurchasingIngredientData{
+			IngredientID:       item.IngredientID,
+			IngredientName:     item.IngredientName,
+			Quantity:           item.Quantity,
+			TotalCost:          item.TotalCost,
+			AverageUnitCost:    item.AverageUnitCost,
+			PurchaseOrderCount: item.PurchaseOrderCount,
+		}
+	}
+
+	vendorData := make([]models.PurchasingVendorData, len(result.VendorData))
+	for i, item := range result.VendorData {
+		vendorData[i] = models.PurchasingVendorData{
+			VendorID:           item.VendorID,
+			VendorName:         item.VendorName,
+			TotalCost:          item.TotalCost,
+			PurchaseOrderCount: item.PurchaseOrderCount,
+			IngredientCount:    item.IngredientCount,
+			Quantity:           item.Quantity,
+		}
+	}
+
+	return &models.PurchasingAnalyticsResponse{
+		OrganizationID: req.OrganizationID,
+		OutletID:       req.OutletID,
+		OutletName:     result.OutletName,
+		DateFrom:       req.DateFrom,
+		DateTo:         req.DateTo,
+		GroupBy:        req.GroupBy,
+		Summary: models.PurchasingSummary{
+			TotalPurchases:            result.Summary.TotalPurchases,
+			TotalPurchaseOrders:       result.Summary.TotalPurchaseOrders,
+			TotalQuantity:             result.Summary.TotalQuantity,
+			AveragePurchaseOrderValue: result.Summary.AveragePurchaseOrderValue,
+			TotalIngredients:          result.Summary.TotalIngredients,
+			TotalVendors:              result.Summary.TotalVendors,
+		},
+		Data:           data,
+		IngredientData: ingredientData,
+		VendorData:     vendorData,
+	}, nil
+}
+
 func (p *AnalyticsProcessorImpl) GetProductAnalytics(ctx context.Context, req *models.ProductAnalyticsRequest) (*models.ProductAnalyticsResponse, error) {
 	// Validate date range
 	if req.DateFrom.After(req.DateTo) {
@@ -0,0 +1,73 @@
+package processor
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"apskel-pos-be/internal/entities"
+	"apskel-pos-be/internal/models"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+)
+
+type analyticsRepositoryStub struct {
+	purchasingResult *entities.PurchasingAnalytics
+}
+
+func (analyticsRepositoryStub) GetPaymentMethodAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time) ([]*entities.PaymentMethodAnalytics, error) {
+	return nil, nil
+}
+
+func (analyticsRepositoryStub) GetSalesAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time, string) ([]*entities.SalesAnalytics, error) {
+	return nil, nil
+}
+
+func (s analyticsRepositoryStub) GetPurchasingAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time, string) (*entities.PurchasingAnalytics, error) {
+	return s.purchasingResult, nil
+}
+
+func (analyticsRepositoryStub) GetProductAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time, int) ([]*entities.ProductAnalytics, error) {
+	return nil, nil
+}
+
+func (analyticsRepositoryStub) GetProductAnalyticsPerCategory(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time) ([]*entities.ProductAnalyticsPerCategory, error) {
+	return nil, nil
+}
+
+func (analyticsRepositoryStub) GetDashboardOverview(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time) (*entities.DashboardOverview, error) {
+	return nil, nil
+}
+
+func (analyticsRepositoryStub) GetProfitLossAnalytics(context.Context, uuid.UUID, *uuid.UUID, time.Time, time.Time, string) (*entities.ProfitLossAnalytics, error) {
+	return nil, nil
+}
+
+func TestAnalyticsProcessorGetPurchasingAnalyticsPassesOutletName(t *testing.T) {
+	outletID := uuid.New()
+	outletName := "Main Outlet"
+	now := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
+	processor := NewAnalyticsProcessorImpl(analyticsRepositoryStub{
+		purchasingResult: &entities.PurchasingAnalytics{
+			OutletName: &outletName,
+			Summary: entities.PurchasingSummary{
+				TotalPurchases: 125,
+			},
+		},
+	})
+
+	result, err := processor.GetPurchasingAnalytics(context.Background(), &models.PurchasingAnalyticsRequest{
+		OrganizationID: uuid.New(),
+		OutletID:       &outletID,
+		DateFrom:       now,
+		DateTo:         now,
+	})
+
+	require.NoError(t, err)
+	require.NotNil(t, result)
+	require.Equal(t, &outletID, result.OutletID)
+	require.NotNil(t, result.OutletName)
+	require.Equal(t, outletName, *result.OutletName)
+	require.Equal(t, float64(125), result.Summary.TotalPurchases)
+}
@@ -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)
@@ -13,6 +13,7 @@ import (
 type AnalyticsRepository interface {
 	GetPaymentMethodAnalytics(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, dateFrom, dateTo time.Time) ([]*entities.PaymentMethodAnalytics, error)
 	GetSalesAnalytics(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, dateFrom, dateTo time.Time, groupBy string) ([]*entities.SalesAnalytics, error)
+	GetPurchasingAnalytics(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, dateFrom, dateTo time.Time, groupBy string) (*entities.PurchasingAnalytics, error)
 	GetProductAnalytics(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, dateFrom, dateTo time.Time, limit int) ([]*entities.ProductAnalytics, error)
 	GetProductAnalyticsPerCategory(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, dateFrom, dateTo time.Time) ([]*entities.ProductAnalyticsPerCategory, error)
 	GetDashboardOverview(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, dateFrom, dateTo time.Time) (*entities.DashboardOverview, error)
@@ -122,6 +123,159 @@ func (r *AnalyticsRepositoryImpl) GetSalesAnalytics(ctx context.Context, organiz
 	return results, err
 }

+func (r *AnalyticsRepositoryImpl) GetPurchasingAnalytics(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, dateFrom, dateTo time.Time, groupBy string) (*entities.PurchasingAnalytics, error) {
+	var summary entities.PurchasingSummary
+	var outletName *string
+
+	if outletID != nil {
+		var outlet struct {
+			Name string
+		}
+		result := r.db.WithContext(ctx).
+			Table("outlets").
+			Select("name").
+			Where("id = ? AND organization_id = ?", *outletID, organizationID).
+			Limit(1).
+			Scan(&outlet)
+		if result.Error != nil {
+			return nil, result.Error
+		}
+		if result.RowsAffected > 0 {
+			outletName = &outlet.Name
+		}
+	}
+
+	summaryQuery := r.db.WithContext(ctx).
+		Table("inventory_movements im").
+		Select(`
+			COALESCE(SUM(im.total_cost), 0) as total_purchases,
+			COUNT(DISTINCT im.reference_id) as total_purchase_orders,
+			COALESCE(SUM(im.quantity), 0) as total_quantity,
+			CASE
+				WHEN COUNT(DISTINCT im.reference_id) > 0
+				THEN COALESCE(SUM(im.total_cost), 0) / COUNT(DISTINCT im.reference_id)
+				ELSE 0
+			END as average_purchase_order_value,
+			COUNT(DISTINCT im.item_id) as total_ingredients,
+			COUNT(DISTINCT po.vendor_id) as total_vendors
+		`).
+		Joins("LEFT JOIN purchase_orders po ON im.reference_id = po.id").
+		Where("im.organization_id = ?", organizationID).
+		Where("im.movement_type = ?", entities.InventoryMovementTypePurchase).
+		Where("im.item_type = ?", "INGREDIENT").
+		Where("im.reference_type = ?", entities.InventoryMovementReferenceTypePurchaseOrder).
+		Where("im.created_at >= ? AND im.created_at <= ?", dateFrom, dateTo)
+
+	summaryQuery = r.resolveOutletID(summaryQuery, outletID, "im.outlet_id")
+
+	if err := summaryQuery.Scan(&summary).Error; err != nil {
+		return nil, err
+	}
+
+	var dateFormat string
+	switch groupBy {
+	case "hour":
+		dateFormat = "DATE_TRUNC('hour', im.created_at)"
+	case "week":
+		dateFormat = "DATE_TRUNC('week', im.created_at)"
+	case "month":
+		dateFormat = "DATE_TRUNC('month', im.created_at)"
+	default:
+		dateFormat = "DATE_TRUNC('day', im.created_at)"
+	}
+
+	var data []entities.PurchasingAnalyticsData
+	dataQuery := r.db.WithContext(ctx).
+		Table("inventory_movements im").
+		Select(`
+			`+dateFormat+` as date,
+			COALESCE(SUM(im.total_cost), 0) as purchases,
+			COUNT(DISTINCT im.reference_id) as purchase_orders,
+			COALESCE(SUM(im.quantity), 0) as quantity,
+			COUNT(DISTINCT im.item_id) as ingredients,
+			COUNT(DISTINCT po.vendor_id) as vendors
+		`).
+		Joins("LEFT JOIN purchase_orders po ON im.reference_id = po.id").
+		Where("im.organization_id = ?", organizationID).
+		Where("im.movement_type = ?", entities.InventoryMovementTypePurchase).
+		Where("im.item_type = ?", "INGREDIENT").
+		Where("im.reference_type = ?", entities.InventoryMovementReferenceTypePurchaseOrder).
+		Where("im.created_at >= ? AND im.created_at <= ?", dateFrom, dateTo).
+		Group(dateFormat).
+		Order(dateFormat)
+
+	dataQuery = r.resolveOutletID(dataQuery, outletID, "im.outlet_id")
+
+	if err := dataQuery.Scan(&data).Error; err != nil {
+		return nil, err
+	}
+
+	var ingredientData []entities.PurchasingIngredientData
+	ingredientQuery := r.db.WithContext(ctx).
+		Table("inventory_movements im").
+		Select(`
+			i.id as ingredient_id,
+			i.name as ingredient_name,
+			COALESCE(SUM(im.quantity), 0) as quantity,
+			COALESCE(SUM(im.total_cost), 0) as total_cost,
+			CASE
+				WHEN SUM(im.quantity) > 0
+				THEN COALESCE(SUM(im.total_cost), 0) / SUM(im.quantity)
+				ELSE 0
+			END as average_unit_cost,
+			COUNT(DISTINCT im.reference_id) as purchase_order_count
+		`).
+		Joins("JOIN ingredients i ON im.item_id = i.id").
+		Where("im.organization_id = ?", organizationID).
+		Where("im.movement_type = ?", entities.InventoryMovementTypePurchase).
+		Where("im.item_type = ?", "INGREDIENT").
+		Where("im.reference_type = ?", entities.InventoryMovementReferenceTypePurchaseOrder).
+		Where("im.created_at >= ? AND im.created_at <= ?", dateFrom, dateTo).
+		Group("i.id, i.name").
+		Order("total_cost DESC")
+
+	ingredientQuery = r.resolveOutletID(ingredientQuery, outletID, "im.outlet_id")
+
+	if err := ingredientQuery.Scan(&ingredientData).Error; err != nil {
+		return nil, err
+	}
+
+	var vendorData []entities.PurchasingVendorData
+	vendorQuery := r.db.WithContext(ctx).
+		Table("inventory_movements im").
+		Select(`
+			v.id as vendor_id,
+			v.name as vendor_name,
+			COALESCE(SUM(im.total_cost), 0) as total_cost,
+			COUNT(DISTINCT im.reference_id) as purchase_order_count,
+			COUNT(DISTINCT im.item_id) as ingredient_count,
+			COALESCE(SUM(im.quantity), 0) as quantity
+		`).
+		Joins("JOIN purchase_orders po ON im.reference_id = po.id").
+		Joins("JOIN vendors v ON po.vendor_id = v.id").
+		Where("im.organization_id = ?", organizationID).
+		Where("im.movement_type = ?", entities.InventoryMovementTypePurchase).
+		Where("im.item_type = ?", "INGREDIENT").
+		Where("im.reference_type = ?", entities.InventoryMovementReferenceTypePurchaseOrder).
+		Where("im.created_at >= ? AND im.created_at <= ?", dateFrom, dateTo).
+		Group("v.id, v.name").
+		Order("total_cost DESC")
+
+	vendorQuery = r.resolveOutletID(vendorQuery, outletID, "im.outlet_id")
+
+	if err := vendorQuery.Scan(&vendorData).Error; err != nil {
+		return nil, err
+	}
+
+	return &entities.PurchasingAnalytics{
+		OutletName:     outletName,
+		Summary:        summary,
+		Data:           data,
+		IngredientData: ingredientData,
+		VendorData:     vendorData,
+	}, nil
+}
+
 func (r *AnalyticsRepositoryImpl) GetProductAnalytics(ctx context.Context, organizationID uuid.UUID, outletID *uuid.UUID, dateFrom, dateTo time.Time, limit int) ([]*entities.ProductAnalytics, error) {
 	var results []*entities.ProductAnalytics

@@ -13,7 +13,9 @@ import (
 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)
@@ -69,3 +71,15 @@ func (r *ProductOutletPriceRepositoryImpl) GetByID(ctx context.Context, id uuid.
 	}
 	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
+}
@@ -28,6 +28,10 @@ func NewTxManager(db *gorm.DB) *TxManager { return &TxManager{db: db} }

 // WithTransaction runs fn inside a DB transaction, injecting the *gorm.DB tx into ctx.
 func (m *TxManager) WithTransaction(ctx context.Context, fn func(ctx context.Context) error) error {
+	if m == nil || m.db == nil {
+		return fn(ctx)
+	}
+
 	return m.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
 		ctxTx := context.WithValue(ctx, txKey, tx)
 		return fn(ctxTx)
@@ -225,6 +225,7 @@ 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)
@@ -324,6 +325,7 @@ func (r *Router) addAppRoutes(rg *gin.Engine) {
 			{
 				analytics.GET("/payment-methods", r.analyticsHandler.GetPaymentMethodAnalytics)
 				analytics.GET("/sales", r.analyticsHandler.GetSalesAnalytics)
+				analytics.GET("/purchasing", r.analyticsHandler.GetPurchasingAnalytics)
 				analytics.GET("/products", r.analyticsHandler.GetProductAnalytics)
 				analytics.GET("/categories", r.analyticsHandler.GetProductAnalyticsPerCategory)
 				analytics.GET("/dashboard", r.analyticsHandler.GetDashboardAnalytics)
@@ -13,6 +13,7 @@ import (
 type AnalyticsService interface {
 	GetPaymentMethodAnalytics(ctx context.Context, req *models.PaymentMethodAnalyticsRequest) (*models.PaymentMethodAnalyticsResponse, error)
 	GetSalesAnalytics(ctx context.Context, req *models.SalesAnalyticsRequest) (*models.SalesAnalyticsResponse, error)
+	GetPurchasingAnalytics(ctx context.Context, req *models.PurchasingAnalyticsRequest) (*models.PurchasingAnalyticsResponse, error)
 	GetProductAnalytics(ctx context.Context, req *models.ProductAnalyticsRequest) (*models.ProductAnalyticsResponse, error)
 	GetProductAnalyticsPerCategory(ctx context.Context, req *models.ProductAnalyticsPerCategoryRequest) (*models.ProductAnalyticsPerCategoryResponse, error)
 	GetDashboardAnalytics(ctx context.Context, req *models.DashboardAnalyticsRequest) (*models.DashboardAnalyticsResponse, error)
@@ -57,6 +58,19 @@ func (s *AnalyticsServiceImpl) GetSalesAnalytics(ctx context.Context, req *model
 	return response, nil
 }

+func (s *AnalyticsServiceImpl) GetPurchasingAnalytics(ctx context.Context, req *models.PurchasingAnalyticsRequest) (*models.PurchasingAnalyticsResponse, error) {
+	if err := s.validatePurchasingAnalyticsRequest(req); err != nil {
+		return nil, fmt.Errorf("validation error: %w", err)
+	}
+
+	response, err := s.analyticsProcessor.GetPurchasingAnalytics(ctx, req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get purchasing analytics: %w", err)
+	}
+
+	return response, nil
+}
+
 func (s *AnalyticsServiceImpl) GetProductAnalytics(ctx context.Context, req *models.ProductAnalyticsRequest) (*models.ProductAnalyticsResponse, error) {
 	// Validate request
 	if err := s.validateProductAnalyticsRequest(req); err != nil {
@@ -168,6 +182,42 @@ func (s *AnalyticsServiceImpl) validateSalesAnalyticsRequest(req *models.SalesAn
 	return nil
 }

+func (s *AnalyticsServiceImpl) validatePurchasingAnalyticsRequest(req *models.PurchasingAnalyticsRequest) error {
+	if req == nil {
+		return fmt.Errorf("request cannot be nil")
+	}
+
+	if req.OrganizationID == uuid.Nil {
+		return fmt.Errorf("organization ID is required")
+	}
+
+	if req.DateFrom.IsZero() {
+		return fmt.Errorf("date_from is required")
+	}
+
+	if req.DateTo.IsZero() {
+		return fmt.Errorf("date_to is required")
+	}
+
+	if req.DateFrom.After(req.DateTo) {
+		return fmt.Errorf("date_from cannot be after date_to")
+	}
+
+	if req.GroupBy != "" {
+		validGroupBy := map[string]bool{
+			"day":   true,
+			"hour":  true,
+			"week":  true,
+			"month": true,
+		}
+		if !validGroupBy[req.GroupBy] {
+			return fmt.Errorf("invalid group_by value: %s", req.GroupBy)
+		}
+	}
+
+	return nil
+}
+
 func (s *AnalyticsServiceImpl) validateProductAnalyticsRequest(req *models.ProductAnalyticsRequest) error {
 	if req.OrganizationID == uuid.Nil {
 		return fmt.Errorf("organization ID is required")
@@ -0,0 +1,121 @@
+package service
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"apskel-pos-be/internal/models"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+)
+
+type analyticsProcessorStub struct{}
+
+func (analyticsProcessorStub) GetPaymentMethodAnalytics(context.Context, *models.PaymentMethodAnalyticsRequest) (*models.PaymentMethodAnalyticsResponse, error) {
+	return nil, nil
+}
+
+func (analyticsProcessorStub) GetSalesAnalytics(context.Context, *models.SalesAnalyticsRequest) (*models.SalesAnalyticsResponse, error) {
+	return nil, nil
+}
+
+func (analyticsProcessorStub) GetPurchasingAnalytics(context.Context, *models.PurchasingAnalyticsRequest) (*models.PurchasingAnalyticsResponse, error) {
+	return &models.PurchasingAnalyticsResponse{}, nil
+}
+
+func (analyticsProcessorStub) GetProductAnalytics(context.Context, *models.ProductAnalyticsRequest) (*models.ProductAnalyticsResponse, error) {
+	return nil, nil
+}
+
+func (analyticsProcessorStub) GetProductAnalyticsPerCategory(context.Context, *models.ProductAnalyticsPerCategoryRequest) (*models.ProductAnalyticsPerCategoryResponse, error) {
+	return nil, nil
+}
+
+func (analyticsProcessorStub) GetDashboardAnalytics(context.Context, *models.DashboardAnalyticsRequest) (*models.DashboardAnalyticsResponse, error) {
+	return nil, nil
+}
+
+func (analyticsProcessorStub) GetProfitLossAnalytics(context.Context, *models.ProfitLossAnalyticsRequest) (*models.ProfitLossAnalyticsResponse, error) {
+	return nil, nil
+}
+
+func TestAnalyticsServiceGetPurchasingAnalyticsValidation(t *testing.T) {
+	service := NewAnalyticsServiceImpl(analyticsProcessorStub{})
+	now := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
+
+	tests := []struct {
+		name    string
+		req     *models.PurchasingAnalyticsRequest
+		wantErr string
+	}{
+		{
+			name: "missing organization",
+			req: &models.PurchasingAnalyticsRequest{
+				DateFrom: now,
+				DateTo:   now,
+			},
+			wantErr: "organization ID is required",
+		},
+		{
+			name: "missing date_from",
+			req: &models.PurchasingAnalyticsRequest{
+				OrganizationID: uuid.New(),
+				DateTo:         now,
+			},
+			wantErr: "date_from is required",
+		},
+		{
+			name: "missing date_to",
+			req: &models.PurchasingAnalyticsRequest{
+				OrganizationID: uuid.New(),
+				DateFrom:       now,
+			},
+			wantErr: "date_to is required",
+		},
+		{
+			name: "reversed dates",
+			req: &models.PurchasingAnalyticsRequest{
+				OrganizationID: uuid.New(),
+				DateFrom:       now.AddDate(0, 0, 1),
+				DateTo:         now,
+			},
+			wantErr: "date_from cannot be after date_to",
+		},
+		{
+			name: "invalid group_by",
+			req: &models.PurchasingAnalyticsRequest{
+				OrganizationID: uuid.New(),
+				DateFrom:       now,
+				DateTo:         now,
+				GroupBy:        "quarter",
+			},
+			wantErr: "invalid group_by value: quarter",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			resp, err := service.GetPurchasingAnalytics(context.Background(), tt.req)
+
+			require.Nil(t, resp)
+			require.Error(t, err)
+			require.Contains(t, err.Error(), tt.wantErr)
+		})
+	}
+}
+
+func TestAnalyticsServiceGetPurchasingAnalyticsAllowsEmptyGroupBy(t *testing.T) {
+	service := NewAnalyticsServiceImpl(analyticsProcessorStub{})
+	now := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
+
+	resp, err := service.GetPurchasingAnalytics(context.Background(), &models.PurchasingAnalyticsRequest{
+		OrganizationID: uuid.New(),
+		DateFrom:       now,
+		DateTo:         now,
+	})
+
+	require.NoError(t, err)
+	require.NotNil(t, resp)
+}
@@ -199,7 +199,7 @@ func (s *OrderServiceImpl) createIngredientTransactions(ctx context.Context, ord
 		// Calculate waste quantities
 		transactions, err := s.calculateWasteQuantities(productRecipes, float64(orderItem.Quantity))
 		if err != nil {
-			return nil, fmt.Errorf("failed to calculate waste quantities for product %s: %w", err)
+			return nil, fmt.Errorf("failed to calculate waste quantities for product %s: %w", orderItem.ProductID, err)
 		}

 		// Set common fields for all transactions
@@ -114,6 +114,14 @@ func (m *MockTableRepository) GetByID(ctx context.Context, id uuid.UUID) (*entit
 	return args.Get(0).(*entities.Table), args.Error(1)
 }

+func (m *MockTableRepository) GetByToken(ctx context.Context, token string) (*entities.Table, error) {
+	args := m.Called(ctx, token)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*entities.Table), args.Error(1)
+}
+
 func (m *MockTableRepository) GetByOutletID(ctx context.Context, outletID uuid.UUID) ([]entities.Table, error) {
 	args := m.Called(ctx, outletID)
 	if args.Get(0) == nil {
@@ -182,6 +190,11 @@ func (m *MockTableRepository) GetByOrderID(ctx context.Context, orderID uuid.UUI
 	return args.Get(0).(*entities.Table), args.Error(1)
 }

+func (m *MockTableRepository) UpdateToken(ctx context.Context, tableID uuid.UUID, token string) error {
+	args := m.Called(ctx, tableID, token)
+	return args.Error(0)
+}
+
 func TestCreateOrderWithTableOccupation(t *testing.T) {
 	// Setup
 	ctx := context.Background()
@@ -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
 	}
@@ -138,6 +138,91 @@ func SalesAnalyticsModelToContract(resp *models.SalesAnalyticsResponse) *contrac
 	}
 }

+// PurchasingAnalyticsContractToModel converts contract request to model
+func PurchasingAnalyticsContractToModel(req *contract.PurchasingAnalyticsRequest) *models.PurchasingAnalyticsRequest {
+	var dateFrom, dateTo time.Time
+
+	if fromTime, toTime, err := util.ParseDateRangeToJakartaTime(req.DateFrom, req.DateTo); err == nil {
+		if fromTime != nil {
+			dateFrom = *fromTime
+		}
+		if toTime != nil {
+			dateTo = *toTime
+		}
+	}
+
+	return &models.PurchasingAnalyticsRequest{
+		OrganizationID: req.OrganizationID,
+		OutletID:       parseOutletID(req.OutletID),
+		DateFrom:       dateFrom,
+		DateTo:         dateTo,
+		GroupBy:        req.GroupBy,
+	}
+}
+
+// PurchasingAnalyticsModelToContract converts model response to contract
+func PurchasingAnalyticsModelToContract(resp *models.PurchasingAnalyticsResponse) *contract.PurchasingAnalyticsResponse {
+	if resp == nil {
+		return nil
+	}
+
+	data := make([]contract.PurchasingAnalyticsData, len(resp.Data))
+	for i, item := range resp.Data {
+		data[i] = contract.PurchasingAnalyticsData{
+			Date:           item.Date,
+			Purchases:      item.Purchases,
+			PurchaseOrders: item.PurchaseOrders,
+			Quantity:       item.Quantity,
+			Ingredients:    item.Ingredients,
+			Vendors:        item.Vendors,
+		}
+	}
+
+	ingredientData := make([]contract.PurchasingIngredientData, len(resp.IngredientData))
+	for i, item := range resp.IngredientData {
+		ingredientData[i] = contract.PurchasingIngredientData{
+			IngredientID:       item.IngredientID,
+			IngredientName:     item.IngredientName,
+			Quantity:           item.Quantity,
+			TotalCost:          item.TotalCost,
+			AverageUnitCost:    item.AverageUnitCost,
+			PurchaseOrderCount: item.PurchaseOrderCount,
+		}
+	}
+
+	vendorData := make([]contract.PurchasingVendorData, len(resp.VendorData))
+	for i, item := range resp.VendorData {
+		vendorData[i] = contract.PurchasingVendorData{
+			VendorID:           item.VendorID,
+			VendorName:         item.VendorName,
+			TotalCost:          item.TotalCost,
+			PurchaseOrderCount: item.PurchaseOrderCount,
+			IngredientCount:    item.IngredientCount,
+			Quantity:           item.Quantity,
+		}
+	}
+
+	return &contract.PurchasingAnalyticsResponse{
+		OrganizationID: resp.OrganizationID,
+		OutletID:       resp.OutletID,
+		OutletName:     resp.OutletName,
+		DateFrom:       resp.DateFrom,
+		DateTo:         resp.DateTo,
+		GroupBy:        resp.GroupBy,
+		Summary: contract.PurchasingSummary{
+			TotalPurchases:            resp.Summary.TotalPurchases,
+			TotalPurchaseOrders:       resp.Summary.TotalPurchaseOrders,
+			TotalQuantity:             resp.Summary.TotalQuantity,
+			AveragePurchaseOrderValue: resp.Summary.AveragePurchaseOrderValue,
+			TotalIngredients:          resp.Summary.TotalIngredients,
+			TotalVendors:              resp.Summary.TotalVendors,
+		},
+		Data:           data,
+		IngredientData: ingredientData,
+		VendorData:     vendorData,
+	}
+}
+
 // ProductAnalyticsContractToModel converts contract request to model
 func ProductAnalyticsContractToModel(req *contract.ProductAnalyticsRequest) *models.ProductAnalyticsRequest {
 	var dateFrom, dateTo time.Time
@@ -0,0 +1,76 @@
+package transformer
+
+import (
+	"encoding/json"
+	"testing"
+	"time"
+
+	"apskel-pos-be/internal/contract"
+	"apskel-pos-be/internal/models"
+
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPurchasingAnalyticsContractToModelParsesDateRangeAndOutlet(t *testing.T) {
+	orgID := uuid.New()
+	outletID := uuid.New().String()
+
+	req := &contract.PurchasingAnalyticsRequest{
+		OrganizationID: orgID,
+		OutletID:       &outletID,
+		DateFrom:       "01-05-2026",
+		DateTo:         "02-05-2026",
+		GroupBy:        "week",
+	}
+
+	result := PurchasingAnalyticsContractToModel(req)
+
+	require.Equal(t, orgID, result.OrganizationID)
+	require.NotNil(t, result.OutletID)
+	require.Equal(t, outletID, result.OutletID.String())
+	require.Equal(t, "week", result.GroupBy)
+
+	location, err := time.LoadLocation("Asia/Jakarta")
+	require.NoError(t, err)
+	require.Equal(t, time.Date(2026, 5, 1, 0, 0, 0, 0, location), result.DateFrom)
+	require.Equal(t, time.Date(2026, 5, 2, 23, 59, 59, int(time.Second-time.Nanosecond), location), result.DateTo)
+}
+
+func TestPurchasingAnalyticsContractToModelIgnoresInvalidOutlet(t *testing.T) {
+	outletID := "not-a-uuid"
+
+	result := PurchasingAnalyticsContractToModel(&contract.PurchasingAnalyticsRequest{
+		OutletID: &outletID,
+		DateFrom: "01-05-2026",
+		DateTo:   "02-05-2026",
+	})
+
+	require.Nil(t, result.OutletID)
+}
+
+func TestPurchasingAnalyticsModelToContractCopiesOutletName(t *testing.T) {
+	outletID := uuid.New()
+	outletName := "Main Outlet"
+
+	result := PurchasingAnalyticsModelToContract(&models.PurchasingAnalyticsResponse{
+		OrganizationID: uuid.New(),
+		OutletID:       &outletID,
+		OutletName:     &outletName,
+	})
+
+	require.NotNil(t, result)
+	require.Equal(t, &outletID, result.OutletID)
+	require.NotNil(t, result.OutletName)
+	require.Equal(t, outletName, *result.OutletName)
+}
+
+func TestPurchasingAnalyticsModelToContractOmitsNilOutletName(t *testing.T) {
+	result := PurchasingAnalyticsModelToContract(&models.PurchasingAnalyticsResponse{
+		OrganizationID: uuid.New(),
+	})
+
+	payload, err := json.Marshal(result)
+	require.NoError(t, err)
+	require.NotContains(t, string(payload), "outlet_name")
+}
@@ -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,
Author	SHA1	Message	Date
ryan	35e7152abb	add purchasing in analytics endpoint	2026-05-19 14:45:26 +07:00
aefril	6d735c20cb	Merge pull request 'fix pointer' (#9 ) from feature/outlet-table into main Reviewed-on: #9	2026-05-14 06:54:51 +00:00
Efril	cb8a830345	fix pointer	2026-05-14 13:54:15 +07:00
aefril	9c143a43aa	Merge pull request 'table and order grouping by outlet' (#8 ) from feature/outlet-table into main Reviewed-on: #8	2026-05-13 18:40:34 +00:00
Efril	222cadd8df	table and order grouping by outlet	2026-05-14 01:40:17 +07:00
aefril	cad4e6c816	Merge pull request 'feature/outlet-table' (#7 ) from feature/outlet-table into main Reviewed-on: #7	2026-05-13 18:22:44 +00: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
aefril	30dff17272	Merge pull request 'self-order+notification' (#6 ) from self-order+notification into main Reviewed-on: #6	2026-05-13 07:27:05 +00:00
efrilm	f8c732f0ff	update dockerfile	2026-05-12 18:46:12 +07:00
aefril	e92c487815	Merge pull request 'self-order+notification' (#5 ) from self-order+notification into main Reviewed-on: #5	2026-05-12 11:41:03 +00:00