feat: create specific price system and adapt product queries

2026-04-10 14:49:05 +02:00
parent 75af44b0df
commit 54608410ea
34 changed files with 1449 additions and 939 deletions
--- a/app/delivery/web/api/restricted/product.go
+++ b/app/delivery/web/api/restricted/product.go
@@ -70,7 +70,7 @@ func (h *ProductsHandler) GetProductJson(c fiber.Ctx) error {
 		return c.Status(responseErrors.GetErrorStatus(responseErrors.ErrBadAttribute)).
 			JSON(response.Make(nullable.GetNil(""), 0, responseErrors.GetErrorCode(c, responseErrors.ErrBadAttribute)))
 	}
-	productJson, err := h.productService.GetJSON(p_id_product, int(customer.LangID), int(customer.ID), b2b_id_country, p_quantity)
+	productJson, err := h.productService.Get(uint(p_id_product), customer.LangID, customer.ID, uint(b2b_id_country), uint(p_quantity))
 	if err != nil {
 		return c.Status(responseErrors.GetErrorStatus(err)).
 			JSON(response.Make(nullable.GetNil(""), 0, responseErrors.GetErrorCode(c, err)))
--- a/app/delivery/web/api/restricted/specificPrice.go
+++ b/app/delivery/web/api/restricted/specificPrice.go
@@ -0,0 +1,187 @@
+package restricted
+
+import (
+	"strconv"
+	"time"
+
+	"git.ma-al.com/goc_daniel/b2b/app/config"
+	"git.ma-al.com/goc_daniel/b2b/app/model"
+	"git.ma-al.com/goc_daniel/b2b/app/service/specificPriceService"
+	"git.ma-al.com/goc_daniel/b2b/app/utils/responseErrors"
+	"github.com/gofiber/fiber/v3"
+)
+
+type SpecificPriceHandler struct {
+	SpecificPriceService *specificPriceService.SpecificPriceService
+	config               *config.Config
+}
+
+func NewSpecificPriceHandler() *SpecificPriceHandler {
+	SpecificPriceService := specificPriceService.New()
+	return &SpecificPriceHandler{
+		SpecificPriceService: SpecificPriceService,
+		config:               config.Get(),
+	}
+}
+
+func SpecificPriceHandlerRoutes(r fiber.Router) fiber.Router {
+	handler := NewSpecificPriceHandler()
+
+	r.Post("/", handler.Create)
+	r.Put("/:id", handler.Update)
+	r.Delete("/:id", handler.Delete)
+	r.Get("/", handler.List)
+	r.Get("/:id", handler.GetByID)
+	r.Patch("/:id/activate", handler.Activate)
+	r.Patch("/:id/deactivate", handler.Deactivate)
+
+	return r
+}
+
+func (h *SpecificPriceHandler) Create(c fiber.Ctx) error {
+	var pr model.SpecificPrice
+	if err := c.Bind().Body(&pr); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
+		})
+	}
+
+	result, err := h.SpecificPriceService.Create(c.Context(), &pr)
+	if err != nil {
+		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, err),
+		})
+	}
+
+	return c.Status(fiber.StatusCreated).JSON(result)
+}
+
+func (h *SpecificPriceHandler) Update(c fiber.Ctx) error {
+	idStr := c.Params("id")
+	id, err := strconv.ParseUint(idStr, 10, 64)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
+		})
+	}
+
+	var pr model.SpecificPrice
+	if err := c.Bind().Body(&pr); err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
+		})
+	}
+
+	result, err := h.SpecificPriceService.Update(c.Context(), id, &pr)
+	if err != nil {
+		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, err),
+		})
+	}
+
+	return c.JSON(result)
+}
+
+func (h *SpecificPriceHandler) List(c fiber.Ctx) error {
+	result, err := h.SpecificPriceService.List(c.Context())
+	if err != nil {
+		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, err),
+		})
+	}
+
+	return c.JSON(result)
+}
+
+func (h *SpecificPriceHandler) GetByID(c fiber.Ctx) error {
+	idStr := c.Params("id")
+	id, err := strconv.ParseUint(idStr, 10, 64)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
+		})
+	}
+
+	result, err := h.SpecificPriceService.GetByID(c.Context(), id)
+	if err != nil {
+		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, err),
+		})
+	}
+
+	return c.JSON(result)
+}
+
+func (h *SpecificPriceHandler) Activate(c fiber.Ctx) error {
+	idStr := c.Params("id")
+	id, err := strconv.ParseUint(idStr, 10, 64)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
+		})
+	}
+
+	err = h.SpecificPriceService.SetActive(c.Context(), id, true)
+	if err != nil {
+		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, err),
+		})
+	}
+
+	return c.JSON(fiber.Map{
+		"message": "price reduction activated",
+	})
+}
+
+func (h *SpecificPriceHandler) Deactivate(c fiber.Ctx) error {
+	idStr := c.Params("id")
+	id, err := strconv.ParseUint(idStr, 10, 64)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
+		})
+	}
+
+	err = h.SpecificPriceService.SetActive(c.Context(), id, false)
+	if err != nil {
+		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, err),
+		})
+	}
+
+	return c.JSON(fiber.Map{
+		"message": "price reduction deactivated",
+	})
+}
+
+func (h *SpecificPriceHandler) Delete(c fiber.Ctx) error {
+	idStr := c.Params("id")
+	id, err := strconv.ParseUint(idStr, 10, 64)
+	if err != nil {
+		return c.Status(fiber.StatusBadRequest).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, responseErrors.ErrInvalidBody),
+		})
+	}
+
+	err = h.SpecificPriceService.Delete(c.Context(), id)
+	if err != nil {
+		return c.Status(responseErrors.GetErrorStatus(err)).JSON(fiber.Map{
+			"error": responseErrors.GetErrorCode(c, err),
+		})
+	}
+
+	return c.JSON(fiber.Map{
+		"message": "specific price deleted",
+	})
+}
+
+func parseTime(s *string) *time.Time {
+	if s == nil {
+		return nil
+	}
+	t, err := time.Parse(time.RFC3339, *s)
+	if err != nil {
+		return nil
+	}
+	return &t
+}
--- a/app/delivery/web/init.go
+++ b/app/delivery/web/init.go
@@ -117,6 +117,9 @@ func (s *Server) Setup() error {
 	carts := s.restricted.Group("/carts")
 	restricted.CartsHandlerRoutes(carts)

+	specificPrice := s.restricted.Group("/specific-price")
+	restricted.SpecificPriceHandlerRoutes(specificPrice)
+
 	restricted.CurrencyHandlerRoutes(s.restricted)
 	s.api.All("*", func(c fiber.Ctx) error {
 		return c.SendStatus(fiber.StatusNotFound)
--- a/app/model/specificPrice.go
+++ b/app/model/specificPrice.go
@@ -0,0 +1,30 @@
+package model
+
+import "time"
+
+type SpecificPrice struct {
+	ID                  uint64     `gorm:"primaryKey;autoIncrement" json:"id"`
+	Name                string     `gorm:"type:varchar(255);not null" json:"name"`
+	Scope               string     `gorm:"type:varchar(20);not null" json:"scope"`
+	ValidFrom           *time.Time `gorm:"null" json:"valid_from"`
+	ValidTill           *time.Time `gorm:"null" json:"valid_till"`
+	HasExpirationDate   bool       `gorm:"default:false" json:"has_expiration_date"`
+	ReductionType       string     `gorm:"type:enum('amount','percentage');not null" json:"reduction_type"`
+	Price               *float64   `gorm:"type:decimal(10,2);null" json:"price"`
+	CurrencyID          *uint64    `gorm:"column:b2b_id_currency;null" json:"currency_id"`
+	PercentageReduction *float64   `gorm:"type:decimal(5,2);null" json:"percentage_reduction"`
+	FromQuantity        uint32     `gorm:"default:1" json:"from_quantity"`
+	IsActive            bool       `gorm:"default:true" json:"is_active"`
+	CreatedAt           *time.Time `gorm:"null" json:"created_at"`
+	UpdatedAt           *time.Time `gorm:"null" json:"updated_at"`
+
+	ProductIDs          []uint64 `gorm:"-" json:"product_ids"`
+	CategoryIDs         []uint64 `gorm:"-" json:"category_ids"`
+	ProductAttributeIDs []uint64 `gorm:"-" json:"product_attribute_ids"`
+	CountryIDs          []uint64 `gorm:"-" json:"country_ids"`
+	CustomerIDs         []uint64 `gorm:"-" json:"customer_ids"`
+}
+
+func (SpecificPrice) TableName() string {
+	return "b2b_specific_price"
+}
--- a/app/repos/productsRepo/productsRepo.go
+++ b/app/repos/productsRepo/productsRepo.go
@@ -2,7 +2,6 @@ package productsRepo

 import (
 	"encoding/json"
-	"fmt"

 	"git.ma-al.com/goc_daniel/b2b/app/config"
 	"git.ma-al.com/goc_daniel/b2b/app/db"
@@ -16,9 +15,12 @@ import (
 )

 type UIProductsRepo interface {
-	GetJSON(p_id_product, p_id_shop, p_id_lang, p_id_customer, b2b_id_country, p_quantity int) (*json.RawMessage, error)
+	// GetJSON(p_id_product, p_id_shop, p_id_lang, p_id_customer, b2b_id_country, p_quantity int) (*json.RawMessage, error)
 	Find(id_lang uint, p find.Paging, filt *filters.FiltersList) (*find.Found[model.ProductInList], error)
 	GetProductVariants(langID uint, productID uint, shopID uint, customerID uint, countryID uint, quantity uint) ([]view.ProductAttribute, error)
+	GetBase(p_id_product, p_id_shop, p_id_lang uint) (view.Product, error)
+	GetPrice(p_id_product uint, productAttributeID *uint, p_id_shop uint, p_id_customer uint, p_id_country uint, p_quantity uint) (view.Price, error)
+	GetVariants(p_id_product, p_id_shop, p_id_lang, p_id_customer, p_id_country, p_quantity uint) ([]view.ProductAttribute, error)
 }

 type ProductsRepo struct{}
@@ -27,25 +29,75 @@ func New() UIProductsRepo {
 	return &ProductsRepo{}
 }

-func (repo *ProductsRepo) GetJSON(p_id_product, p_id_shop, p_id_lang, p_id_customer, b2b_id_country, p_quantity int) (*json.RawMessage, error) {
-	var productStr string // ← Scan as string first
+func (repo *ProductsRepo) GetBase(p_id_product, p_id_shop, p_id_lang uint) (view.Product, error) {
+	var result view.Product

-	err := db.DB.Raw(`CALL get_full_product(?,?,?,?,?,?)`,
-		p_id_product, p_id_shop, p_id_lang, p_id_customer, b2b_id_country, p_quantity).
-		Scan(&productStr).
-		Error
+	err := db.DB.Raw(`CALL get_product_base(?,?,?)`,
+		p_id_product, p_id_shop, p_id_lang).
+		Scan(&result).Error
+
+	return result, err
+}
+
+func (repo *ProductsRepo) GetPrice(
+	p_id_product uint, productAttributeID *uint, p_id_shop uint, p_id_customer uint, p_id_country uint, p_quantity uint,
+) (view.Price, error) {
+
+	type row struct {
+		Price json.RawMessage `gorm:"column:price"`
+	}
+
+	var r row
+	err := db.DB.Raw(`
+        SELECT fn_product_price(?,?,?,?,?,?) AS price`,
+		p_id_product, p_id_shop, p_id_customer, p_id_country, p_quantity, productAttributeID).
+		Scan(&r).Error

 	if err != nil {
-		return nil, err
+		return view.Price{}, err
 	}

-	// Optional: validate it's valid JSON
-	if !json.Valid([]byte(productStr)) {
-		return nil, fmt.Errorf("invalid json returned from stored procedure")
+	var temp struct {
+		Base         json.Number `json:"base"`
+		FinalTaxExcl json.Number `json:"final_tax_excl"`
+		FinalTaxIncl json.Number `json:"final_tax_incl"`
+		TaxRate      json.Number `json:"tax_rate"`
+		Priority     json.Number `json:"priority"`
 	}

-	raw := json.RawMessage(productStr)
-	return &raw, nil
+	if err := json.Unmarshal(r.Price, &temp); err != nil {
+		return view.Price{}, err
+	}
+
+	price := view.Price{
+		Base:         mustParseFloat(temp.Base),
+		FinalTaxExcl: mustParseFloat(temp.FinalTaxExcl),
+		FinalTaxIncl: mustParseFloat(temp.FinalTaxIncl),
+		TaxRate:      mustParseFloat(temp.TaxRate),
+		Priority:     mustParseInt(temp.Priority),
+	}
+
+	return price, nil
+}
+func mustParseFloat(n json.Number) float64 {
+	f, _ := n.Float64()
+	return f
+}
+
+func mustParseInt(n json.Number) int {
+	i, _ := n.Int64()
+	return int(i)
+}
+func (repo *ProductsRepo) GetVariants(p_id_product, p_id_shop, p_id_lang, p_id_customer, p_id_country, p_quantity uint) ([]view.ProductAttribute, error) {
+
+	var results []view.ProductAttribute
+
+	err := db.DB.Raw(`
+		CALL get_product_variants(?,?,?,?,?,?)`,
+		p_id_product, p_id_shop, p_id_lang, p_id_customer, p_id_country, p_quantity).
+		Scan(&results).Error
+
+	return results, err
 }

 func (repo *ProductsRepo) Find(langID uint, p find.Paging, filt *filters.FiltersList) (*find.Found[model.ProductInList], error) {
--- a/app/repos/specificPriceRepo/specificPriceRepo.go
+++ b/app/repos/specificPriceRepo/specificPriceRepo.go
@@ -0,0 +1,247 @@
+package specificPriceRepo
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"git.ma-al.com/goc_daniel/b2b/app/db"
+	"git.ma-al.com/goc_daniel/b2b/app/model"
+	"gorm.io/gorm"
+)
+
+type UISpecificPriceRepo interface {
+	Create(ctx context.Context, pr *model.SpecificPrice) error
+	Update(ctx context.Context, pr *model.SpecificPrice) error
+	Delete(ctx context.Context, id uint64) error
+	GetByID(ctx context.Context, id uint64) (*model.SpecificPrice, error)
+	List(ctx context.Context) ([]*model.SpecificPrice, error)
+	SetActive(ctx context.Context, id uint64, active bool) error
+}
+
+type SpecificPriceRepo struct{}
+
+func New() UISpecificPriceRepo {
+	return &SpecificPriceRepo{}
+}
+
+func (repo *SpecificPriceRepo) Create(ctx context.Context, pr *model.SpecificPrice) error {
+	return db.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		now := time.Now()
+		pr.CreatedAt = &now
+
+		if err := tx.Create(pr).Error; err != nil {
+			return err
+		}
+
+		return repo.insertRelations(tx, pr)
+	})
+}
+
+func (repo *SpecificPriceRepo) Update(ctx context.Context, pr *model.SpecificPrice) error {
+	return db.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		now := time.Now()
+		pr.UpdatedAt = &now
+
+		if err := tx.Save(pr).Error; err != nil {
+			return err
+		}
+
+		if err := repo.clearRelations(tx, pr.ID); err != nil {
+			return err
+		}
+
+		return repo.insertRelations(tx, pr)
+	})
+}
+
+func (repo *SpecificPriceRepo) GetByID(ctx context.Context, id uint64) (*model.SpecificPrice, error) {
+	var pr model.SpecificPrice
+	err := db.DB.WithContext(ctx).Where("id = ?", id).First(&pr).Error
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, nil
+		}
+		return nil, err
+	}
+
+	if err := repo.loadRelations(ctx, &pr); err != nil {
+		return nil, err
+	}
+
+	return &pr, nil
+}
+
+func (repo *SpecificPriceRepo) List(ctx context.Context) ([]*model.SpecificPrice, error) {
+	var specificPrices []*model.SpecificPrice
+	err := db.DB.WithContext(ctx).Find(&specificPrices).Error
+	if err != nil {
+		return nil, err
+	}
+
+	for i := range specificPrices {
+		if err := repo.loadRelations(ctx, specificPrices[i]); err != nil {
+			return nil, err
+		}
+	}
+
+	return specificPrices, nil
+}
+
+func (repo *SpecificPriceRepo) SetActive(ctx context.Context, id uint64, active bool) error {
+	return db.DB.WithContext(ctx).Model(&model.SpecificPrice{}).Where("id = ?", id).Update("is_active", active).Error
+}
+
+func (repo *SpecificPriceRepo) Delete(ctx context.Context, id uint64) error {
+	return db.DB.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
+		if err := tx.Exec("DELETE FROM b2b_specific_price_product WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+			return err
+		}
+		if err := tx.Exec("DELETE FROM b2b_specific_price_category WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+			return err
+		}
+		if err := tx.Exec("DELETE FROM b2b_specific_price_product_attribute WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+			return err
+		}
+		if err := tx.Exec("DELETE FROM b2b_specific_price_country WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+			return err
+		}
+		if err := tx.Exec("DELETE FROM b2b_specific_price_customer WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+			return err
+		}
+		if err := tx.Delete(&model.SpecificPrice{}, "id = ?", id).Error; err != nil {
+			return err
+		}
+		return nil
+	})
+}
+
+func (repo *SpecificPriceRepo) insertRelations(tx *gorm.DB, pr *model.SpecificPrice) error {
+	if len(pr.ProductIDs) > 0 {
+		for _, productID := range pr.ProductIDs {
+			if err := tx.Exec(`
+				INSERT INTO b2b_specific_price_product (b2b_specific_price_id, id_product) VALUES (?, ?)
+			`, pr.ID, productID).Error; err != nil {
+				return err
+			}
+		}
+	}
+
+	if len(pr.CategoryIDs) > 0 {
+		for _, categoryID := range pr.CategoryIDs {
+			if err := tx.Exec(`
+				INSERT INTO b2b_specific_price_category (b2b_specific_price_id, id_category) VALUES (?, ?)
+			`, pr.ID, categoryID).Error; err != nil {
+				return err
+			}
+		}
+	}
+
+	if len(pr.ProductAttributeIDs) > 0 {
+		for _, attrID := range pr.ProductAttributeIDs {
+			if err := tx.Exec(`
+				INSERT INTO b2b_specific_price_product_attribute (b2b_specific_price_id, id_product_attribute) VALUES (?, ?)
+			`, pr.ID, attrID).Error; err != nil {
+				return err
+			}
+		}
+	}
+
+	if len(pr.CountryIDs) > 0 {
+		for _, countryID := range pr.CountryIDs {
+			if err := tx.Exec(`
+				INSERT INTO b2b_specific_price_country (b2b_specific_price_id, b2b_id_country) VALUES (?, ?)
+			`, pr.ID, countryID).Error; err != nil {
+				return err
+			}
+		}
+	}
+
+	if len(pr.CustomerIDs) > 0 {
+		for _, customerID := range pr.CustomerIDs {
+			if err := tx.Exec(`
+				INSERT INTO b2b_specific_price_customer (b2b_specific_price_id, b2b_id_customer) VALUES (?, ?)
+			`, pr.ID, customerID).Error; err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (repo *SpecificPriceRepo) clearRelations(tx *gorm.DB, id uint64) error {
+	if err := tx.Exec("DELETE FROM b2b_specific_price_product WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+		return err
+	}
+	if err := tx.Exec("DELETE FROM b2b_specific_price_category WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+		return err
+	}
+	if err := tx.Exec("DELETE FROM b2b_specific_price_product_attribute WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+		return err
+	}
+	if err := tx.Exec("DELETE FROM b2b_specific_price_country WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+		return err
+	}
+	if err := tx.Exec("DELETE FROM b2b_specific_price_customer WHERE b2b_specific_price_id = ?", id).Error; err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (repo *SpecificPriceRepo) loadRelations(ctx context.Context, pr *model.SpecificPrice) error {
+	var err error
+
+	var productIDs []struct {
+		IDProduct uint64 `gorm:"column:id_product"`
+	}
+	if err = db.DB.WithContext(ctx).Table("b2b_specific_price_product").Where("b2b_specific_price_id = ?", pr.ID).Select("id_product").Scan(&productIDs).Error; err != nil {
+		return err
+	}
+	for _, p := range productIDs {
+		pr.ProductIDs = append(pr.ProductIDs, p.IDProduct)
+	}
+
+	var categoryIDs []struct {
+		IDCategory uint64 `gorm:"column:id_category"`
+	}
+	if err = db.DB.WithContext(ctx).Table("b2b_specific_price_category").Where("b2b_specific_price_id = ?", pr.ID).Select("id_category").Scan(&categoryIDs).Error; err != nil {
+		return err
+	}
+	for _, c := range categoryIDs {
+		pr.CategoryIDs = append(pr.CategoryIDs, c.IDCategory)
+	}
+
+	var attrIDs []struct {
+		IDAttr uint64 `gorm:"column:id_product_attribute"`
+	}
+	if err = db.DB.WithContext(ctx).Table("b2b_specific_price_product_attribute").Where("b2b_specific_price_id = ?", pr.ID).Select("id_product_attribute").Scan(&attrIDs).Error; err != nil {
+		return err
+	}
+	for _, a := range attrIDs {
+		pr.ProductAttributeIDs = append(pr.ProductAttributeIDs, a.IDAttr)
+	}
+
+	var countryIDs []struct {
+		IDCountry uint64 `gorm:"column:b2b_id_country"`
+	}
+	if err = db.DB.WithContext(ctx).Table("b2b_specific_price_country").Where("b2b_specific_price_id = ?", pr.ID).Select("b2b_id_country").Scan(&countryIDs).Error; err != nil {
+		return err
+	}
+	for _, c := range countryIDs {
+		pr.CountryIDs = append(pr.CountryIDs, c.IDCountry)
+	}
+
+	var customerIDs []struct {
+		IDCustomer uint64 `gorm:"column:b2b_id_customer"`
+	}
+	if err = db.DB.WithContext(ctx).Table("b2b_specific_price_customer").Where("b2b_specific_price_id = ?", pr.ID).Select("b2b_id_customer").Scan(&customerIDs).Error; err != nil {
+		return err
+	}
+	for _, c := range customerIDs {
+		pr.CustomerIDs = append(pr.CustomerIDs, c.IDCustomer)
+	}
+
+	return nil
+}
--- a/app/service/productService/productService.go
+++ b/app/service/productService/productService.go
@@ -4,7 +4,6 @@ import (
 	"encoding/json"
 	"errors"

-	"git.ma-al.com/goc_daniel/b2b/app/db"
 	"git.ma-al.com/goc_daniel/b2b/app/model"
 	"git.ma-al.com/goc_daniel/b2b/app/repos/productsRepo"
 	constdata "git.ma-al.com/goc_daniel/b2b/app/utils/const_data"
@@ -23,64 +22,90 @@ func New() *ProductService {
 	}
 }

-func (s *ProductService) GetJSON(p_id_product, p_id_lang, p_id_customer, b2b_id_country, p_quantity int) (*json.RawMessage, error) {
-	products, err := s.productsRepo.GetJSON(p_id_product, constdata.SHOP_ID, p_id_lang, p_id_customer, b2b_id_country, p_quantity)
-	if err != nil {
-		return products, err
-	}
+func (s *ProductService) Get(
+	p_id_product, p_id_lang, p_id_customer, b2b_id_country, p_quantity uint,
+) (*json.RawMessage, error) {

-	return products, nil
-}
-
-func (s *ProductService) Find(id_lang uint, p find.Paging, filters *filters.FiltersList, customer *model.Customer, quantity int, shopID uint) (*find.Found[model.ProductInList], error) {
-	if customer == nil || customer.Country == nil {
-		return nil, errors.New("customer is nil or is missing fields")
-	}
-	// customer.ID, customer.CountryID, uint(customer.Country.CurrencyID), quantity, shopID
-
-	found, err := s.productsRepo.Find(id_lang, p, filters)
+	product, err := s.productsRepo.GetBase(p_id_product, constdata.SHOP_ID, p_id_lang)
 	if err != nil {
 		return nil, err
 	}
+
+	price, err := s.productsRepo.GetPrice(p_id_product, nil, constdata.SHOP_ID, p_id_customer, b2b_id_country, p_quantity)
+	if err != nil {
+		return nil, err
+	}
+
+	variants, err := s.productsRepo.GetVariants(p_id_product, constdata.SHOP_ID, p_id_lang, p_id_customer, b2b_id_country, p_quantity)
+	if err != nil {
+		return nil, err
+	}
+
+	result := view.ProductFull{
+		Product:  product,
+		Price:    price,
+		Variants: variants,
+	}
+
+	if len(variants) > 0 {
+		result.Variants = variants
+	}
+
+	jsonBytes, err := json.Marshal(result)
+	if err != nil {
+		return nil, err
+	}
+
+	raw := json.RawMessage(jsonBytes)
+	return &raw, nil
+}
+
+func (s *ProductService) Find(
+	idLang uint,
+	p find.Paging,
+	filters *filters.FiltersList,
+	customer *model.Customer,
+	quantity uint,
+	shopID uint,
+) (*find.Found[model.ProductInList], error) {
+
+	if customer == nil || customer.Country == nil {
+		return nil, errors.New("customer is nil or missing fields")
+	}
+
+	found, err := s.productsRepo.Find(idLang, p, filters)
+	if err != nil {
+		return nil, err
+	}
+
+	// 1. collect simple products (no variants)
+	simpleProductIndexes := make([]int, 0, len(found.Items))
+
 	for i := range found.Items {
 		if found.Items[i].VariantsNumber <= 0 {
-			err := s.PopulateProductPrice(&found.Items[i], customer, quantity, shopID)
-			if err != nil {
-				return nil, err
-			}
+			simpleProductIndexes = append(simpleProductIndexes, i)
 		}
 	}

-	return found, err
-}
+	// 2. resolve prices ONLY for simple products
+	for _, i := range simpleProductIndexes {
+		price, err := s.productsRepo.GetPrice(
+			found.Items[i].ProductID,
+			nil,
+			shopID,
+			customer.ID,
+			customer.CountryID,
+			quantity,
+		)
+		if err != nil {
+			return nil, err
+		}

-func (s *ProductService) PopulateProductPrice(product *model.ProductInList, targetCustomer *model.Customer, quantity int, shopID uint) error {
-	row := db.Get().Raw(
-		"CALL get_product_price(?, ?, ?, ?, ?)",
-		product.ProductID,
-		shopID,
-		targetCustomer.ID,
-		targetCustomer.CountryID,
-		quantity,
-	).Row()
-
-	var (
-		id   uint
-		base float64
-		excl float64
-		incl float64
-		tax  float64
-	)
-
-	err := row.Scan(&id, &base, &excl, &incl, &tax)
-	if err != nil {
-		return err
+		found.Items[i].PriceTaxExcl = price.FinalTaxExcl
+		found.Items[i].PriceTaxIncl = price.FinalTaxIncl
 	}

-	product.PriceTaxExcl = excl
-	product.PriceTaxIncl = incl
-	return nil
-
+	return found, nil
 }

 func (s *ProductService) GetProductAttributes(
@@ -91,5 +116,10 @@ func (s *ProductService) GetProductAttributes(
 	countryID uint,
 	quantity uint,
 ) ([]view.ProductAttribute, error) {
-	return s.productsRepo.GetProductVariants(langID, productID, shopID, customerID, countryID, quantity)
+	variants, err := s.productsRepo.GetVariants(productID, constdata.SHOP_ID, langID, customerID, countryID, quantity)
+	if err != nil {
+		return nil, err
+	}
+
+	return variants, nil
 }
--- a/app/service/specificPriceService/specificPriceService.go
+++ b/app/service/specificPriceService/specificPriceService.go
@@ -0,0 +1,136 @@
+package specificPriceService
+
+import (
+	"context"
+
+	"git.ma-al.com/goc_daniel/b2b/app/model"
+	"git.ma-al.com/goc_daniel/b2b/app/repos/specificPriceRepo"
+	"git.ma-al.com/goc_daniel/b2b/app/utils/responseErrors"
+)
+
+type SpecificPriceService struct {
+	specificPriceRepo specificPriceRepo.UISpecificPriceRepo
+}
+
+func New() *SpecificPriceService {
+	return &SpecificPriceService{
+		specificPriceRepo: specificPriceRepo.New(),
+	}
+}
+
+func (s *SpecificPriceService) Create(ctx context.Context, pr *model.SpecificPrice) (*model.SpecificPrice, error) {
+	if err := s.validateRequest(pr); err != nil {
+		return nil, err
+	}
+
+	if pr.Scope == "shop" && len(pr.ProductIDs) == 0 && len(pr.CategoryIDs) == 0 && len(pr.ProductAttributeIDs) == 0 && len(pr.CountryIDs) == 0 && len(pr.CustomerIDs) == 0 {
+		// pr.Scope = "global"
+	} else {
+		// pr.Scope = "scoped"
+	}
+
+	if err := s.specificPriceRepo.Create(ctx, pr); err != nil {
+		return nil, err
+	}
+
+	return pr, nil
+}
+
+func (s *SpecificPriceService) Update(ctx context.Context, id uint64, pr *model.SpecificPrice) (*model.SpecificPrice, error) {
+	existing, err := s.specificPriceRepo.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if existing == nil {
+		return nil, responseErrors.ErrSpecificPriceNotFound
+	}
+
+	if err := s.validateUpdateRequest(pr); err != nil {
+		return nil, err
+	}
+
+	pr.ID = id
+
+	if pr.Scope == "shop" && len(pr.ProductIDs) == 0 && len(pr.CategoryIDs) == 0 && len(pr.ProductAttributeIDs) == 0 && len(pr.CountryIDs) == 0 && len(pr.CustomerIDs) == 0 {
+		// pr.Scope = "global"
+	} else {
+		// pr.Scope = "scoped"
+	}
+
+	if err := s.specificPriceRepo.Update(ctx, pr); err != nil {
+		return nil, err
+	}
+
+	return pr, nil
+}
+
+func (s *SpecificPriceService) GetByID(ctx context.Context, id uint64) (*model.SpecificPrice, error) {
+	pr, err := s.specificPriceRepo.GetByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	if pr == nil {
+		return nil, responseErrors.ErrSpecificPriceNotFound
+	}
+	return pr, nil
+}
+
+func (s *SpecificPriceService) List(ctx context.Context) ([]*model.SpecificPrice, error) {
+	return s.specificPriceRepo.List(ctx)
+}
+
+func (s *SpecificPriceService) SetActive(ctx context.Context, id uint64, active bool) error {
+	pr, err := s.specificPriceRepo.GetByID(ctx, id)
+	if err != nil {
+		return err
+	}
+	if pr == nil {
+		return responseErrors.ErrSpecificPriceNotFound
+	}
+
+	return s.specificPriceRepo.SetActive(ctx, id, active)
+}
+
+func (s *SpecificPriceService) Delete(ctx context.Context, id uint64) error {
+	pr, err := s.specificPriceRepo.GetByID(ctx, id)
+	if err != nil {
+		return err
+	}
+	if pr == nil {
+		return responseErrors.ErrSpecificPriceNotFound
+	}
+
+	return s.specificPriceRepo.Delete(ctx, id)
+}
+
+func (s *SpecificPriceService) validateRequest(pr *model.SpecificPrice) error {
+	if pr.ReductionType != "amount" && pr.ReductionType != "percentage" {
+		return responseErrors.ErrInvalidReductionType
+	}
+
+	if pr.ReductionType == "percentage" && pr.PercentageReduction == nil {
+		return responseErrors.ErrPercentageRequired
+	}
+
+	if pr.ReductionType == "amount" && pr.Price == nil {
+		return responseErrors.ErrPriceRequired
+	}
+
+	return nil
+}
+
+func (s *SpecificPriceService) validateUpdateRequest(pr *model.SpecificPrice) error {
+	if pr.ReductionType != "" && pr.ReductionType != "amount" && pr.ReductionType != "percentage" {
+		return responseErrors.ErrInvalidReductionType
+	}
+
+	if pr.ReductionType == "percentage" && pr.PercentageReduction == nil {
+		return responseErrors.ErrPercentageRequired
+	}
+
+	if pr.ReductionType == "amount" && pr.Price == nil {
+		return responseErrors.ErrPriceRequired
+	}
+
+	return nil
+}
--- a/app/utils/responseErrors/responseErrors.go
+++ b/app/utils/responseErrors/responseErrors.go
@@ -62,6 +62,12 @@ var (
 	ErrUserHasNoSuchCart                 = errors.New("user does not have cart with given id")
 	ErrProductOrItsVariationDoesNotExist = errors.New("product or its variation with given ids does not exist")

+	// Typed errors for price reduction handler
+	ErrInvalidReductionType  = errors.New("invalid reduction type: must be 'amount' or 'percentage'")
+	ErrPercentageRequired    = errors.New("percentage_reduction required when reduction_type is percentage")
+	ErrPriceRequired         = errors.New("price required when reduction_type is amount")
+	ErrSpecificPriceNotFound = errors.New("price reduction not found")
+
 	// Typed errors for data parsing
 	ErrJSONBody = errors.New("invalid JSON body")
 )
@@ -171,6 +177,15 @@ func GetErrorCode(c fiber.Ctx, err error) string {
 	case errors.Is(err, ErrProductOrItsVariationDoesNotExist):
 		return i18n.T_(c, "error.product_or_its_variation_does_not_exist")

+	case errors.Is(err, ErrInvalidReductionType):
+		return i18n.T_(c, "error.invalid_reduction_type")
+	case errors.Is(err, ErrPercentageRequired):
+		return i18n.T_(c, "error.percentage_required")
+	case errors.Is(err, ErrPriceRequired):
+		return i18n.T_(c, "error.price_required")
+	case errors.Is(err, ErrSpecificPriceNotFound):
+		return i18n.T_(c, "error.price_reduction_not_found")
+
 	case errors.Is(err, ErrJSONBody):
 		return i18n.T_(c, "error.err_json_body")

@@ -219,8 +234,13 @@ func GetErrorStatus(err error) int {
 		errors.Is(err, ErrMaxAmtOfCartsReached),
 		errors.Is(err, ErrUserHasNoSuchCart),
 		errors.Is(err, ErrProductOrItsVariationDoesNotExist),
+		errors.Is(err, ErrInvalidReductionType),
+		errors.Is(err, ErrPercentageRequired),
+		errors.Is(err, ErrPriceRequired),
 		errors.Is(err, ErrJSONBody):
 		return fiber.StatusBadRequest
+	case errors.Is(err, ErrSpecificPriceNotFound):
+		return fiber.StatusNotFound
 	case errors.Is(err, ErrEmailExists):
 		return fiber.StatusConflict
 	case errors.Is(err, ErrAIResponseFail),
--- a/app/view/product.go
+++ b/app/view/product.go
@@ -1,9 +1,12 @@
 package view

-import "encoding/json"
+import (
+	"encoding/json"
+	"time"
+)

 type ProductAttribute struct {
-	IDProductAttribute int64           `gorm:"column:id_product_attribute" json:"id_product_attribute"`
+	IDProductAttribute uint            `gorm:"column:id_product_attribute" json:"id_product_attribute"`
 	Reference          string          `gorm:"column:reference" json:"reference"`
 	BasePrice          float64         `gorm:"column:base_price" json:"base_price"`
 	PriceTaxExcl       float64         `gorm:"column:price_tax_excl" json:"price_tax_excl"`
@@ -11,3 +14,83 @@ type ProductAttribute struct {
 	Quantity           int64           `gorm:"column:quantity" json:"quantity"`
 	Attributes         json.RawMessage `gorm:"column:attributes" json:"attributes"`
 }
+
+type Price struct {
+	Base         float64 `json:"base"`
+	FinalTaxExcl float64 `json:"final_tax_excl"`
+	FinalTaxIncl float64 `json:"final_tax_incl"`
+	TaxRate      float64 `json:"tax_rate"`
+	Priority     int     `json:"priority"` // or string
+}
+
+type Variant struct {
+	ID        uint   `json:"id_product_attribute"`
+	Reference string `json:"reference"`
+
+	BasePrice float64 `json:"base_price"`
+	FinalExcl float64 `json:"final_tax_excl"`
+	FinalIncl float64 `json:"final_tax_incl"`
+
+	Stock int `json:"stock"`
+}
+type ProductFull struct {
+	Product  Product            `json:"product"`
+	Price    Price              `json:"price"`
+	Variants []ProductAttribute `json:"variants,omitempty"`
+}
+
+type Product struct {
+	ID                uint   `gorm:"column:id" json:"id"`
+	Reference         string `gorm:"column:reference" json:"reference"`
+	SupplierReference string `gorm:"column:supplier_reference" json:"supplier_reference,omitempty"`
+	EAN13             string `gorm:"column:ean13" json:"ean13,omitempty"`
+	UPC               string `gorm:"column:upc" json:"upc,omitempty"`
+	ISBN              string `gorm:"column:isbn" json:"isbn,omitempty"`
+
+	// Basic Price (from product table)
+	BasePrice      float64 `gorm:"column:base_price" json:"base_price"`
+	WholesalePrice float64 `gorm:"column:wholesale_price" json:"wholesale_price,omitempty"`
+	Unity          string  `gorm:"column:unity" json:"unity,omitempty"`
+	UnitPriceRatio float64 `gorm:"column:unit_price_ratio" json:"unit_price_ratio,omitempty"`
+
+	// Stock & Availability
+	Quantity           int    `gorm:"column:quantity" json:"quantity"`
+	MinimalQuantity    int    `gorm:"column:minimal_quantity" json:"minimal_quantity"`
+	AvailableForOrder  bool   `gorm:"column:available_for_order" json:"available_for_order"`
+	AvailableDate      string `gorm:"column:available_date" json:"available_date,omitempty"`
+	OutOfStockBehavior int    `gorm:"column:out_of_stock_behavior" json:"out_of_stock_behavior"`
+
+	// Flags
+	OnSale    bool   `gorm:"column:on_sale" json:"on_sale"`
+	ShowPrice bool   `gorm:"column:show_price" json:"show_price"`
+	Condition string `gorm:"column:condition" json:"condition"`
+	IsVirtual bool   `gorm:"column:is_virtual" json:"is_virtual"`
+
+	// Physical
+	Weight                 float64 `gorm:"column:weight" json:"weight"`
+	Width                  float64 `gorm:"column:width" json:"width"`
+	Height                 float64 `gorm:"column:height" json:"height"`
+	Depth                  float64 `gorm:"column:depth" json:"depth"`
+	AdditionalShippingCost float64 `gorm:"column:additional_shipping_cost" json:"additional_shipping_cost,omitempty"`
+
+	// Delivery
+	DeliveryDays int `gorm:"column:delivery_days" json:"delivery_days,omitempty"`
+
+	// Status
+	Active     bool   `gorm:"column:active" json:"active"`
+	Visibility string `gorm:"column:visibility" json:"visibility"`
+	Indexed    bool   `gorm:"column:indexed" json:"indexed"`
+
+	// Timestamps
+	DateAdd time.Time `gorm:"column:date_add" json:"date_add"`
+	DateUpd time.Time `gorm:"column:date_upd" json:"date_upd"`
+
+	// Language fields
+	Name             string `gorm:"column:name" json:"name"`
+	Description      string `gorm:"column:description" json:"description"`
+	DescriptionShort string `gorm:"column:description_short" json:"description_short"`
+
+	// Relations
+	Manufacturer string `gorm:"column:manufacturer" json:"manufacturer"`
+	Category     string `gorm:"column:category" json:"category"`
+}