Websites and Stores

Website → Store → Store View

  Website (base_url)
    │
    ├── Store (product catalog)
    │     ├── Store View (en_US)
    │     └── Store View (fr_FR)
    │
    └── Store (product catalog)
          ├── Store View (de_DE)
          └── Store View (en_GB)

Entity Relationships

Store Manager

namespace Vendor\MultiStore\Manager;

class StoreManager
{
    private StoreManagerInterface $storeManager;

    public function getAllStores(): array
    {
        return $this->storeManager->getStores();
    }

    public function getStoresByWebsite(int $websiteId): array
    {
        $website = $this->storeManager->getWebsite($websiteId);
        return $website->getStores();
    }

    public function getDefaultStore(): StoreInterface
    {
        return $this->storeManager->getStore(1);
    }

    public function getStoreByUrl(string $url): ?StoreInterface
    {
        foreach ($this->storeManager->getStores() as $store) {
            if (strpos($url, $store->getBaseUrl()) === 0) {
                return $store;
            }
        }
        return null;
    }
}

Store Configuration

namespace Vendor\MultiStore\Setup;

class StoreCreator
{
    private StoreFactoryInterface $storeFactory;
    private StoreManagerInterface $storeManager;
    private GroupFactoryInterface $groupFactory;
    private WebsiteFactoryInterface $websiteFactory;

    public function createStore(array $data): StoreInterface
    {
        // Create website
        $website = $this->websiteFactory->create();
        $website->setName($data['website_name']);
        $website->setCode($data['website_code']);
        $this->storeManager->saveWebsite($website);

        // Create store group
        $group = $this->groupFactory->create();
        $group->setName($data['store_name']);
        $group->setCode($data['store_code']);
        $group->setWebsite($website);
        $this->storeManager->saveStoreGroup($group);

        // Create store views
        foreach ($data['views'] as $viewData) {
            $store = $this->storeFactory->create();
            $store->setName($viewData['name']);
            $store->setCode($viewData['code']);
            $store->setGroupId($group->getId());
            $store->setIsActive($viewData['active'] ?? true);
            $this->storeManager->saveStore($store);
        }

        return $store;
    }
}

Store Code in URL

namespace Vendor\MultiStore\Url;

class StoreCodeResolver
{
    public function resolveFromUrl(string $url): ?string
    {
        $path = parse_url($url, PHP_URL_PATH);

        // Check if store code is in URL
        $parts = explode('/', trim($path, '/'));
        if (!empty($parts[0])) {
            $storeCode = $parts[0];
            if ($this->isValidStoreCode($storeCode)) {
                return $storeCode;
            }
        }

        return null;
    }
}

Localization Configuration

namespace Vendor\MultiStore\Localization;

class LocalizationManager
{
    public function getStoreLocale(int $storeId): string
    {
        $store = $this->storeManager->getStore($storeId);
        return $store->getConfig('general/locale/code');
    }

    public function getStoreCurrency(int $storeId): string
    {
        $store = $this->storeManager->getStore($storeId);
        return $store->getConfig('currency/options/default');
    }

    public function getStoreTimezone(int $storeId): string
    {
        $store = $this->storeManager->getStore($storeId);
        return $store->getConfig('general/locale/timezone');
    }
}

Store-Specific Content

namespace Vendor\MultiStore\Content;

class StoreContentResolver
{
    public function resolve(int $storeId, string $contentKey): ?string
    {
        // Check store view scope first
        $value = $this->config->getValue(
            $contentKey,
            ScopeInterface::SCOPE_STORES,
            $storeId
        );

        if ($value !== null) {
            return $value;
        }

        // Fall back to website scope
        $store = $this->storeManager->getStore($storeId);
        $value = $this->config->getValue(
            $contentKey,
            ScopeInterface::SCOPE_WEBSITES,
            $store->getWebsiteId()
        );

        return $value;
    }
}

Store Resolver Pattern

namespace Vendor\MultiStore\Resolver;

interface StoreResolverInterface
{
    public function resolve(Request $request): int;
}

class UrlStoreResolver implements StoreResolverInterface
{
    public function resolve(Request $request): int
    {
        $storeCode = $this->extractStoreCode($request->getPathInfo());

        if ($storeCode) {
            $store = $this->storeManager->getStore($storeCode);
            return $store->getId();
        }

        return $this->getDefaultStoreId();
    }
}

class DomainStoreResolver implements StoreResolverInterface
{
    public function resolve(Request $request): int
    {
        $host = $request->getServer('HTTP_HOST');

        foreach ($this->domainMap as $domain => $storeId) {
            if ($host === $domain) {
                return $storeId;
            }
        }

        return $this->getDefaultStoreId();
    }
}

Store-Specific Product Pricing

namespace Vendor\MultiStore\Pricing;

class StorePriceResolver
{
    public function getStorePrice(
        ProductInterface $product,
        int $storeId
    ): float {
        $price = $product->getPrice();

        // Check store-specific price override
        $override = $this->config->getValue(
            'catalog/price/' . $product->getId(),
            ScopeInterface::SCOPE_STORES,
            $storeId
        );

        if ($override !== null) {
            return (float) $override;
        }

        return $price;
    }
}