From 4130cb66df74d8e61e76299c8417ff73dadaf728 Mon Sep 17 00:00:00 2001 From: ryan Date: Wed, 13 May 2026 21:58:54 +0700 Subject: [PATCH 1/5] refactor and add outlet product table --- internal/app/app.go | 13 +- internal/constants/error.go | 31 ++-- .../contract/product_outlet_price_contract.go | 41 ++++++ internal/entities/entities.go | 1 + internal/entities/product.go | 14 +- internal/entities/product_outlet_price.go | 31 ++++ .../handler/product_outlet_price_handler.go | 135 ++++++++++++++++++ internal/handler/self_order_handler.go | 56 +++++--- .../mappers/product_outlet_price_mapper.go | 48 +++++++ internal/models/product_outlet_price.go | 35 +++++ internal/processor/order_processor.go | 15 ++ .../product_outlet_price_processor.go | 104 ++++++++++++++ .../product_outlet_price_repository.go | 71 +++++++++ internal/router/router.go | 15 +- .../service/product_outlet_price_service.go | 119 +++++++++++++++ .../product_outlet_price_transformer.go | 55 +++++++ .../product_outlet_price_validator.go | 80 +++++++++++ ...reate_product_outlet_prices_table.down.sql | 1 + ..._create_product_outlet_prices_table.up.sql | 12 ++ 19 files changed, 835 insertions(+), 42 deletions(-) create mode 100644 internal/contract/product_outlet_price_contract.go create mode 100644 internal/entities/product_outlet_price.go create mode 100644 internal/handler/product_outlet_price_handler.go create mode 100644 internal/mappers/product_outlet_price_mapper.go create mode 100644 internal/models/product_outlet_price.go create mode 100644 internal/processor/product_outlet_price_processor.go create mode 100644 internal/repository/product_outlet_price_repository.go create mode 100644 internal/service/product_outlet_price_service.go create mode 100644 internal/transformer/product_outlet_price_transformer.go create mode 100644 internal/validator/product_outlet_price_validator.go create mode 100644 migrations/000068_create_product_outlet_prices_table.down.sql create mode 100644 migrations/000068_create_product_outlet_prices_table.up.sql diff --git a/internal/app/app.go b/internal/app/app.go index d680b42..9948da4 100644 --- a/internal/app/app.go +++ b/internal/app/app.go @@ -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 { @@ -344,7 +350,7 @@ func (a *App) initProcessors(cfg *config.Config, repos *repositories) *processor productProcessor: processor.NewProductProcessorImpl(repos.productRepo, repos.categoryRepo, repos.productVariantRepo, repos.inventoryRepo, repos.outletRepo), 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), } } @@ -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(), } } diff --git a/internal/constants/error.go b/internal/constants/error.go index a1e1ade..4eb6366 100644 --- a/internal/constants/error.go +++ b/internal/constants/error.go @@ -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{ diff --git a/internal/contract/product_outlet_price_contract.go b/internal/contract/product_outlet_price_contract.go new file mode 100644 index 0000000..27be75d --- /dev/null +++ b/internal/contract/product_outlet_price_contract.go @@ -0,0 +1,41 @@ +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"` + 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"` +} + +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"` +} diff --git a/internal/entities/entities.go b/internal/entities/entities.go index c8b5b38..dd2b914 100644 --- a/internal/entities/entities.go +++ b/internal/entities/entities.go @@ -41,6 +41,7 @@ func GetAllEntities() []interface{} { &Notification{}, &NotificationReceiver{}, &NotificationDelivery{}, + &ProductOutletPrice{}, } } diff --git a/internal/entities/product.go b/internal/entities/product.go index b76d5f2..3aba21e 100644 --- a/internal/entities/product.go +++ b/internal/entities/product.go @@ -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 { diff --git a/internal/entities/product_outlet_price.go b/internal/entities/product_outlet_price.go new file mode 100644 index 0000000..16f623a --- /dev/null +++ b/internal/entities/product_outlet_price.go @@ -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" +} diff --git a/internal/handler/product_outlet_price_handler.go b/internal/handler/product_outlet_price_handler.go new file mode 100644 index 0000000..91c431f --- /dev/null +++ b/internal/handler/product_outlet_price_handler.go @@ -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") +} diff --git a/internal/handler/self_order_handler.go b/internal/handler/self_order_handler.go index c5517c3..ebbfdcb 100644 --- a/internal/handler/self_order_handler.go +++ b/internal/handler/self_order_handler.go @@ -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 { diff --git a/internal/mappers/product_outlet_price_mapper.go b/internal/mappers/product_outlet_price_mapper.go new file mode 100644 index 0000000..12556be --- /dev/null +++ b/internal/mappers/product_outlet_price_mapper.go @@ -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 +} diff --git a/internal/models/product_outlet_price.go b/internal/models/product_outlet_price.go new file mode 100644 index 0000000..2a192da --- /dev/null +++ b/internal/models/product_outlet_price.go @@ -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"` +} diff --git a/internal/processor/order_processor.go b/internal/processor/order_processor.go index 0d13688..26ee447 100644 --- a/internal/processor/order_processor.go +++ b/internal/processor/order_processor.go @@ -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 { @@ -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) diff --git a/internal/processor/product_outlet_price_processor.go b/internal/processor/product_outlet_price_processor.go new file mode 100644 index 0000000..973eb20 --- /dev/null +++ b/internal/processor/product_outlet_price_processor.go @@ -0,0 +1,104 @@ +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 +} + +func NewProductOutletPriceProcessorImpl(repo repository.ProductOutletPriceRepository) *ProductOutletPriceProcessorImpl { + return &ProductOutletPriceProcessorImpl{ + repo: repo, + } +} + +func (p *ProductOutletPriceProcessorImpl) Upsert(ctx context.Context, req *models.CreateProductOutletPriceRequest) (*models.ProductOutletPrice, error) { + 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) + } + + return mappers.ProductOutletPriceEntityToModel(entity), 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 +} diff --git a/internal/repository/product_outlet_price_repository.go b/internal/repository/product_outlet_price_repository.go new file mode 100644 index 0000000..86c5035 --- /dev/null +++ b/internal/repository/product_outlet_price_repository.go @@ -0,0 +1,71 @@ +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) + GetByOutlet(ctx context.Context, 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 +} diff --git a/internal/router/router.go b/internal/router/router.go index 544d0ed..a67d60b 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -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), } } @@ -228,6 +230,17 @@ func (r *Router) addAppRoutes(rg *gin.Engine) { 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) diff --git a/internal/service/product_outlet_price_service.go b/internal/service/product_outlet_price_service.go new file mode 100644 index 0000000..89fbed8 --- /dev/null +++ b/internal/service/product_outlet_price_service.go @@ -0,0 +1,119 @@ +package service + +import ( + "context" + + "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" +) + +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 { + 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) 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), + }) +} diff --git a/internal/transformer/product_outlet_price_transformer.go b/internal/transformer/product_outlet_price_transformer.go new file mode 100644 index 0000000..593f93e --- /dev/null +++ b/internal/transformer/product_outlet_price_transformer.go @@ -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 +} diff --git a/internal/validator/product_outlet_price_validator.go b/internal/validator/product_outlet_price_validator.go new file mode 100644 index 0000000..d476919 --- /dev/null +++ b/internal/validator/product_outlet_price_validator.go @@ -0,0 +1,80 @@ +package validator + +import ( + "errors" + + "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 { + _ = i + return errors.New("price must be non-negative for each price entry"), constants.MalformedFieldErrorCode + } + } + + return nil, "" +} diff --git a/migrations/000068_create_product_outlet_prices_table.down.sql b/migrations/000068_create_product_outlet_prices_table.down.sql new file mode 100644 index 0000000..26a85b7 --- /dev/null +++ b/migrations/000068_create_product_outlet_prices_table.down.sql @@ -0,0 +1 @@ +DROP TABLE IF EXISTS product_outlet_prices; diff --git a/migrations/000068_create_product_outlet_prices_table.up.sql b/migrations/000068_create_product_outlet_prices_table.up.sql new file mode 100644 index 0000000..7f023f1 --- /dev/null +++ b/migrations/000068_create_product_outlet_prices_table.up.sql @@ -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); From 3b625047987c2a2dbdd2355f3c960f0c92a6fbc4 Mon Sep 17 00:00:00 2001 From: ryan Date: Wed, 13 May 2026 22:30:55 +0700 Subject: [PATCH 2/5] fix --- .../product_outlet_price_processor.go | 25 ++++++++++++++++--- .../service/product_outlet_price_service.go | 8 +++++- .../product_outlet_price_validator.go | 4 +-- 3 files changed, 30 insertions(+), 7 deletions(-) diff --git a/internal/processor/product_outlet_price_processor.go b/internal/processor/product_outlet_price_processor.go index 973eb20..97e00e0 100644 --- a/internal/processor/product_outlet_price_processor.go +++ b/internal/processor/product_outlet_price_processor.go @@ -23,16 +23,28 @@ type ProductOutletPriceProcessor interface { } type ProductOutletPriceProcessorImpl struct { - repo repository.ProductOutletPriceRepository + repo repository.ProductOutletPriceRepository + productRepo ProductRepository + outletRepo OutletRepository } -func NewProductOutletPriceProcessorImpl(repo repository.ProductOutletPriceRepository) *ProductOutletPriceProcessorImpl { +func NewProductOutletPriceProcessorImpl(repo repository.ProductOutletPriceRepository, productRepo ProductRepository, outletRepo OutletRepository) *ProductOutletPriceProcessorImpl { return &ProductOutletPriceProcessorImpl{ - repo: repo, + 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, @@ -43,7 +55,12 @@ func (p *ProductOutletPriceProcessorImpl) Upsert(ctx context.Context, req *model return nil, fmt.Errorf("failed to upsert product outlet price: %w", err) } - return mappers.ProductOutletPriceEntityToModel(entity), nil + 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) { diff --git a/internal/service/product_outlet_price_service.go b/internal/service/product_outlet_price_service.go index 89fbed8..dc35f68 100644 --- a/internal/service/product_outlet_price_service.go +++ b/internal/service/product_outlet_price_service.go @@ -2,6 +2,7 @@ package service import ( "context" + "errors" "apskel-pos-be/internal/constants" "apskel-pos-be/internal/contract" @@ -10,6 +11,7 @@ import ( "apskel-pos-be/internal/transformer" "github.com/google/uuid" + "gorm.io/gorm" ) type ProductOutletPriceService interface { @@ -47,7 +49,11 @@ func (s *ProductOutletPriceServiceImpl) Upsert(ctx context.Context, req *contrac func (s *ProductOutletPriceServiceImpl) GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) *contract.Response { result, err := s.processor.GetByProductAndOutlet(ctx, productID, outletID) if err != nil { - errorResp := contract.NewResponseError(constants.InternalServerErrorCode, constants.ProductOutletPriceServiceEntity, err.Error()) + 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}) } diff --git a/internal/validator/product_outlet_price_validator.go b/internal/validator/product_outlet_price_validator.go index d476919..7f78964 100644 --- a/internal/validator/product_outlet_price_validator.go +++ b/internal/validator/product_outlet_price_validator.go @@ -2,6 +2,7 @@ package validator import ( "errors" + "fmt" "apskel-pos-be/internal/constants" "apskel-pos-be/internal/contract" @@ -71,8 +72,7 @@ func (v *ProductOutletPriceValidatorImpl) ValidateBulkCreateRequest(req *contrac return errors.New("outlet_id is required for each price entry"), constants.MissingFieldErrorCode } if p.Price < 0 { - _ = i - return errors.New("price must be non-negative for each price entry"), constants.MalformedFieldErrorCode + return fmt.Errorf("price at index %d must be non-negative", i), constants.MalformedFieldErrorCode } } From 5f379faf17965232283bc340d21da76391f30c87 Mon Sep 17 00:00:00 2001 From: ryan Date: Wed, 13 May 2026 23:15:09 +0700 Subject: [PATCH 3/5] change product list to retrieve its data from product outlets --- internal/app/app.go | 4 +-- internal/contract/product_contract.go | 1 + internal/handler/product_handler.go | 8 +++++ internal/processor/product_processor.go | 29 ++++++++++++++++++- .../product_outlet_price_repository.go | 7 +++++ internal/service/product_service.go | 3 ++ 6 files changed, 49 insertions(+), 3 deletions(-) diff --git a/internal/app/app.go b/internal/app/app.go index 9948da4..3f57cd5 100644 --- a/internal/app/app.go +++ b/internal/app/app.go @@ -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), } } diff --git a/internal/contract/product_contract.go b/internal/contract/product_contract.go index 084a769..979400f 100644 --- a/internal/contract/product_contract.go +++ b/internal/contract/product_contract.go @@ -89,6 +89,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"` diff --git a/internal/handler/product_handler.go b/internal/handler/product_handler.go index bdbe54f..b4957d0 100644 --- a/internal/handler/product_handler.go +++ b/internal/handler/product_handler.go @@ -184,6 +184,14 @@ 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 diff --git a/internal/processor/product_processor.go b/internal/processor/product_processor.go index ef522d4..846e74b 100644 --- a/internal/processor/product_processor.go +++ b/internal/processor/product_processor.go @@ -47,15 +47,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, } } @@ -227,11 +229,36 @@ func (p *ProductProcessorImpl) GetProductByID(ctx context.Context, id uuid.UUID) func (p *ProductProcessorImpl) ListProducts(ctx context.Context, filters map[string]interface{}, page, limit int) ([]models.ProductResponse, int, error) { offset := (page - 1) * limit + var outletID uuid.UUID + if oid, ok := filters["outlet_id"]; ok { + outletID = oid.(uuid.UUID) + delete(filters, "outlet_id") + } + productEntities, total, err := p.productRepo.List(ctx, filters, limit, offset) if err != nil { return nil, 0, fmt.Errorf("failed to list products: %w", err) } + if outletID != uuid.Nil && len(productEntities) > 0 { + productIDs := make([]uuid.UUID, len(productEntities)) + for i, pe := range productEntities { + productIDs[i] = pe.ID + } + outletPrices, err := p.outletPriceRepo.GetByProductsAndOutlet(ctx, productIDs, outletID) + if err == nil { + priceMap := make(map[uuid.UUID]float64, len(outletPrices)) + for _, op := range outletPrices { + priceMap[op.ProductID] = op.Price + } + for _, pe := range productEntities { + if price, ok := priceMap[pe.ID]; ok { + pe.Price = price + } + } + } + } + responses := make([]models.ProductResponse, len(productEntities)) for i, entity := range productEntities { response := mappers.ProductEntityToResponse(entity) diff --git a/internal/repository/product_outlet_price_repository.go b/internal/repository/product_outlet_price_repository.go index 86c5035..6c90a17 100644 --- a/internal/repository/product_outlet_price_repository.go +++ b/internal/repository/product_outlet_price_repository.go @@ -14,6 +14,7 @@ type ProductOutletPriceRepository interface { GetByProductAndOutlet(ctx context.Context, productID, outletID uuid.UUID) (*entities.ProductOutletPrice, error) GetByProduct(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 +70,9 @@ 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 +} diff --git a/internal/service/product_service.go b/internal/service/product_service.go index 61eed11..de05f5e 100644 --- a/internal/service/product_service.go +++ b/internal/service/product_service.go @@ -85,6 +85,9 @@ 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 } From 21fa21d08949203d289683912ab2703053235e48 Mon Sep 17 00:00:00 2001 From: Efril Date: Thu, 14 May 2026 00:15:28 +0700 Subject: [PATCH 4/5] get products all --- internal/handler/product_handler.go | 83 +++++++++++++++++++++++++ internal/processor/product_processor.go | 20 ++++++ internal/router/router.go | 1 + internal/service/product_service.go | 55 ++++++++++++++++ 4 files changed, 159 insertions(+) diff --git a/internal/handler/product_handler.go b/internal/handler/product_handler.go index b4957d0..9b18f27 100644 --- a/internal/handler/product_handler.go +++ b/internal/handler/product_handler.go @@ -220,3 +220,86 @@ func (h *ProductHandler) ListProducts(c *gin.Context) { 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 + } + } + + 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") +} diff --git a/internal/processor/product_processor.go b/internal/processor/product_processor.go index 846e74b..2d7e568 100644 --- a/internal/processor/product_processor.go +++ b/internal/processor/product_processor.go @@ -18,6 +18,7 @@ type ProductProcessor interface { DeleteProduct(ctx context.Context, id uuid.UUID) error GetProductByID(ctx context.Context, id 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 { @@ -270,6 +271,25 @@ func (p *ProductProcessorImpl) ListProducts(ctx context.Context, filters map[str 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) + } + + 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 +} + // Helper methods for inventory management // createInventoryForAllOutlets creates inventory records for all outlets of an organization diff --git a/internal/router/router.go b/internal/router/router.go index a67d60b..bebbb89 100644 --- a/internal/router/router.go +++ b/internal/router/router.go @@ -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) diff --git a/internal/service/product_service.go b/internal/service/product_service.go index de05f5e..38cd1e6 100644 --- a/internal/service/product_service.go +++ b/internal/service/product_service.go @@ -18,6 +18,7 @@ type ProductService interface { DeleteProduct(ctx context.Context, id uuid.UUID) *contract.Response GetProductByID(ctx context.Context, id 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 { @@ -132,3 +133,57 @@ func (s *ProductServiceImpl) ListProducts(ctx context.Context, req *contract.Lis 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 + } + 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) +} From 50d633ee3aefa92b6d3cc477750abe9fb537b893 Mon Sep 17 00:00:00 2001 From: Efril Date: Thu, 14 May 2026 01:19:45 +0700 Subject: [PATCH 5/5] fix products --- internal/contract/product_contract.go | 38 ++++++------ .../contract/product_outlet_price_contract.go | 13 ++-- internal/handler/product_handler.go | 3 +- internal/mappers/product_mapper.go | 1 + internal/models/product.go | 8 +++ internal/processor/product_processor.go | 61 ++++++++++++------- .../product_outlet_price_repository.go | 7 +++ internal/repository/product_repository.go | 44 +++++++++++++ internal/service/product_service.go | 6 +- internal/transformer/product_transformer.go | 15 +++++ 10 files changed, 146 insertions(+), 50 deletions(-) diff --git a/internal/contract/product_contract.go b/internal/contract/product_contract.go index 979400f..afc2e7b 100644 --- a/internal/contract/product_contract.go +++ b/internal/contract/product_contract.go @@ -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 { diff --git a/internal/contract/product_outlet_price_contract.go b/internal/contract/product_outlet_price_contract.go index 27be75d..ed66de7 100644 --- a/internal/contract/product_outlet_price_contract.go +++ b/internal/contract/product_outlet_price_contract.go @@ -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 { diff --git a/internal/handler/product_handler.go b/internal/handler/product_handler.go index 9b18f27..ad389d9 100644 --- a/internal/handler/product_handler.go +++ b/internal/handler/product_handler.go @@ -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") diff --git a/internal/mappers/product_mapper.go b/internal/mappers/product_mapper.go index fb6c8ac..e91c3ef 100644 --- a/internal/mappers/product_mapper.go +++ b/internal/mappers/product_mapper.go @@ -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, diff --git a/internal/models/product.go b/internal/models/product.go index 43e47d2..beda4c3 100644 --- a/internal/models/product.go +++ b/internal/models/product.go @@ -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 diff --git a/internal/processor/product_processor.go b/internal/processor/product_processor.go index 2d7e568..3a9c9ea 100644 --- a/internal/processor/product_processor.go +++ b/internal/processor/product_processor.go @@ -16,7 +16,7 @@ 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) } @@ -33,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) @@ -217,49 +218,65 @@ 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") } - productEntities, total, err := p.productRepo.List(ctx, filters, limit, offset) + // 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) } - if outletID != uuid.Nil && len(productEntities) > 0 { - productIDs := make([]uuid.UUID, len(productEntities)) - for i, pe := range productEntities { - productIDs[i] = pe.ID - } - outletPrices, err := p.outletPriceRepo.GetByProductsAndOutlet(ctx, productIDs, outletID) - if err == nil { - priceMap := make(map[uuid.UUID]float64, len(outletPrices)) - for _, op := range outletPrices { - priceMap[op.ProductID] = op.Price - } - for _, pe := range productEntities { - if price, ok := priceMap[pe.ID]; ok { - pe.Price = price - } - } - } - } - responses := make([]models.ProductResponse, len(productEntities)) for i, entity := range productEntities { response := mappers.ProductEntityToResponse(entity) diff --git a/internal/repository/product_outlet_price_repository.go b/internal/repository/product_outlet_price_repository.go index 6c90a17..6a0f4aa 100644 --- a/internal/repository/product_outlet_price_repository.go +++ b/internal/repository/product_outlet_price_repository.go @@ -13,6 +13,7 @@ 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 @@ -76,3 +77,9 @@ func (r *ProductOutletPriceRepositoryImpl) GetByProductsAndOutlet(ctx context.Co 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 +} diff --git a/internal/repository/product_repository.go b/internal/repository/product_repository.go index e0df5f1..d5fc5f4 100644 --- a/internal/repository/product_repository.go +++ b/internal/repository/product_repository.go @@ -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 +} diff --git a/internal/service/product_service.go b/internal/service/product_service.go index 38cd1e6..fce1eb6 100644 --- a/internal/service/product_service.go +++ b/internal/service/product_service.go @@ -16,7 +16,7 @@ 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 } @@ -69,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}) diff --git a/internal/transformer/product_transformer.go b/internal/transformer/product_transformer.go index 77ec925..be2b9fd 100644 --- a/internal/transformer/product_transformer.go +++ b/internal/transformer/product_transformer.go @@ -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,