Shared Catalogs

Catalog Types

  ┌─────────────────┐
  │  Public Catalog │  Default for all
  └────────┬────────┘
           │
  ┌────────▼────────┐
  │ Shared Catalog  │  Company-specific
  │  (Custom)       │  pricing & products
  └────────┬────────┘
           │
  ┌────────▼────────┐
  │ Company Assigned│  Linked to companies
  └─────────────────┘

Shared Catalog Repository

namespace Magento\SharedCatalog\Api;

interface SharedCatalogRepositoryInterface
{
    public function get(int $catalogId): SharedCatalogInterface;
    public function getList(SearchCriteriaInterface $searchCriteria): SharedCatalogSearchResultsInterface;
    public function save(SharedCatalogInterface $catalog): SharedCatalogInterface;
    public function delete(SharedCatalogInterface $catalog): bool;
}

Shared Catalog Interface

namespace Magento\SharedCatalog\Api\Data;

interface SharedCatalogInterface
{
    public function getId(): ?int;
    public function getName(): string;
    public function getType(): string;
    public function getCreatedById(): int;
    public function getCreatedAt(): string;
    public function getDescription(): ?string;
    public function getStructureId(): int;
    public function getPricingId(): int;
    public function getCompaniesCount(): int;
}

Pricing Manager

namespace Vendor\B2B\Catalog\Pricing;

class SharedCatalogPricingManager
{
    private PricingReaderInterface $pricingReader;
    private PricingWriterInterface $pricingWriter;

    public function setProductPrice(
        int $catalogId,
        int $productId,
        float $price,
        float $discount = 0
    ): void {
        $pricingData = new PricingData([
            'catalog_id' => $catalogId,
            'product_id' => $productId,
            'price' => $price,
            'discount' => $discount,
            'final_price' => $price - $discount,
        ]);

        $this->pricingWriter->save($pricingData);
    }

    public function getProductPrice(
        int $catalogId,
        int $productId
    ): ?PricingData {
        return $this->pricingReader->getByCatalogAndProduct(
            $catalogId,
            $productId
        );
    }

    public function getCatalogPrices(int $catalogId): array
    {
        return $this->pricingReader->getAllByCatalog($catalogId);
    }
}

Price Tier Configuration

namespace Vendor\B2B\Catalog\Pricing\Tier;

class PriceTierManager
{
    public function setTiers(
        int $catalogId,
        int $productId,
        array $tiers
    ): void {
        foreach ($tiers as $tier) {
            $tierData = new PriceTierData([
                'catalog_id' => $catalogId,
                'product_id' => $productId,
                'qty_from' => $tier['qty_from'],
                'qty_to' => $tier['qty_to'],
                'price' => $tier['price'],
                'discount' => $tier['discount'] ?? 0,
            ]);

            $this->tierRepo->save($tierData);
        }
    }

    public function getTiers(
        int $catalogId,
        int $productId
    ): array {
        return $this->tierRepo->getByCatalogAndProduct(
            $catalogId,
            $productId
        );
    }
}

Company-Catalog Assignment

namespace Vendor\B2B\Catalog\Assignment;

class CatalogAssignment
{
    private CompanyRepositoryInterface $companyRepo;

    public function assignCatalog(
        int $companyId,
        int $catalogId
    ): void {
        $company = $this->companyRepo->get($companyId);
        $company->setSharedCatalogId($catalogId);
        $this->companyRepo->save($company);
    }

    public function unassignCatalog(int $companyId): void
    {
        $company = $this->companyRepo->get($companyId);
        $company->setSharedCatalogId(null);
        $this->companyRepo->save($company);
    }

    public function getCatalogCompanies(int $catalogId): array
    {
        return $this->companyRepo->getList(
            $this->createSearchCriteria($catalogId)
        )->getItems();
    }
}

Catalog Permission Check

namespace Vendor\B2B\Catalog\Permission;

class CatalogPermissionChecker
{
    public function canAccess(
        int $customerId,
        int $productId
    ): bool {
        $customer = $this->customerRepo->getById($customerId);
        $companyId = $customer->getCompanyId();

        if (!$companyId) {
            return false;
        }

        $company = $this->companyRepo->get($companyId);
        $catalogId = $company->getSharedCatalogId();

        if (!$catalogId) {
            return false;
        }

        return $this->catalogProductRepo->exists($catalogId, $productId);
    }
}

Catalog Sync Service

namespace Vendor\B2B\Catalog\Sync;

class CatalogSyncService
{
    private SharedCatalogRepositoryInterface $catalogRepo;
    private ProductRepositoryInterface $productRepo;

    public function syncFromDefault(int $catalogId): SyncResult
    {
        $catalog = $this->catalogRepo->get($catalogId);
        $result = new SyncResult();

        // Get default catalog products
        $defaultProducts = $this->getDefaultProducts();

        foreach ($defaultProducts as $product) {
            $exists = $this->catalogProductRepo->exists(
                $catalogId,
                $product->getId()
            );

            if (!$exists) {
                $this->catalogProductRepo->addProduct(
                    $catalogId,
                    $product->getId()
                );
                $result->addAdded($product->getSku());
            }
        }

        // Remove products not in default
        $catalogProducts = $this->catalogProductRepo->getByCatalog($catalogId);
        foreach ($catalogProducts as $catalogProduct) {
            if (!$this->inDefault($catalogProduct->getProductId())) {
                $this->catalogProductRepo->removeProduct(
                    $catalogId,
                    $catalogProduct->getProductId()
                );
                $result->addRemoved($catalogProduct->getSku());
            }
        }

        return $result;
    }
}

Price Sync

namespace Vendor\B2B\Catalog\Sync;

class PriceSyncService
{
    public function syncPrices(
        int $catalogId,
        string $source
    ): void {
        $prices = $this->priceSource->fetch($source, $catalogId);

        foreach ($prices as $sku => $price) {
            $product = $this->productRepo->get($sku);
            $this->pricingManager->setProductPrice(
                $catalogId,
                $product->getId(),
                $price
            );
        }
    }
}