This commit is contained in:
2026-09-15 10:35:56 +08:00
commit 782f8ea7aa
4086 changed files with 631288 additions and 0 deletions
@@ -0,0 +1,90 @@
<?php
namespace Esun3d\LanguageUrlStoreResolver\Controller\Switch;
use Esun3d\LanguageUrlStoreResolver\Model\LanguageResolver;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Esun3d\LanguageUrlStoreResolver\Observer\AddHttpContextObserver;
use Magento\Framework\App\Action\Action;
use Magento\Framework\App\Action\Context;
use Magento\Framework\App\Http\Context as HttpContext;
use Magento\Framework\App\ObjectManager;
use Magento\Framework\App\RequestInterface;
use Magento\Framework\Controller\Result\JsonFactory;
use Magento\Store\Model\StoreManagerInterface;
use Psr\Log\LoggerInterface;
class Index extends Action
{
public function __construct(
Context $context,
protected JsonFactory $resultJsonFactory,
protected RequestInterface $request,
protected HttpContext $httpContext,
protected StoreManagerInterface $storeManager,
protected StoreCodeMapper $storeCodeMapper,
protected LanguageResolver $languageResolver
){
parent::__construct($context);
}
private function resolveStoreCode(): string
{
try {
$storeCode = $this->storeManager->getStore()->getCode();
return $this->storeCodeMapper->isRealStoreCodeInScope($storeCode)
? $storeCode
: $this->resolveDefaultStoreCode();
} catch (\Throwable $exception) {
return $this->resolveDefaultStoreCode();
}
}
private function resolveDefaultStoreCode(): string
{
$language = $this->request instanceof \Magento\Framework\App\Request\Http
? $this->languageResolver->resolveFromPath($this->request->getPathInfo())
: null;
if ($language === null) {
return '';
}
return $this->storeCodeMapper->getDefaultStoreCodeForLanguage($language) ?: '';
}
public function execute()
{
$country = $this->getRequest()->getParam('country');
$language = $this->getRequest()->getParam('language');
$success = false;
if (!empty($country) && !empty($language)) {
$market = strtolower($language).'_'.strtoupper($country);
$storeCode = $this->resolveStoreCode();
$logger = ObjectManager::getInstance()->get(LoggerInterface::class);
$logger->info('$market: '.$market);
$this->httpContext->setValue(
AddHttpContextObserver::CONTEXT_MARKET,
$market,
$this->resolveDefaultStoreCode()
);
$this->httpContext->setValue(
AddHttpContextObserver::CONTEXT_STORE_CODE,
$storeCode,
$this->resolveDefaultStoreCode()
);
$success = true;
}
return $this->resultJsonFactory->create()
->setData([
'success'=>$success,
'country'=>$country,
'language'=>$language
]);
}
}
@@ -0,0 +1,79 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Store\Model\ScopeInterface;
class Config
{
private const XML_PATH_ENABLED = 'language_url_store_resolver/general/enabled';
private const XML_PATH_MARKET_COOKIE_NAME = 'language_url_store_resolver/general/market_cookie_name';
private const XML_PATH_MARKET_COOKIE_LIFETIME = 'language_url_store_resolver/general/market_cookie_lifetime';
private const DEFAULT_COOKIE_NAME = 'market';
private const DEFAULT_COOKIE_LIFETIME = 2592000;
/**
* @var string[]
*/
private $skipPrefixes = [
'admin',
'rest',
'graphql',
'soap',
'static',
'media',
'pub',
'stores/store',
];
/**
* @var ScopeConfigInterface
*/
private $scopeConfig;
public function __construct(ScopeConfigInterface $scopeConfig)
{
$this->scopeConfig = $scopeConfig;
}
public function isEnabled(): bool
{
return $this->scopeConfig->isSetFlag(self::XML_PATH_ENABLED, ScopeInterface::SCOPE_STORE);
}
public function getMarketCookieName(): string
{
$cookieName = trim((string)$this->scopeConfig->getValue(
self::XML_PATH_MARKET_COOKIE_NAME,
ScopeInterface::SCOPE_STORE
));
return $cookieName !== '' ? $cookieName : self::DEFAULT_COOKIE_NAME;
}
public function getMarketCookieLifetime(): int
{
$lifetime = (int)$this->scopeConfig->getValue(
self::XML_PATH_MARKET_COOKIE_LIFETIME,
ScopeInterface::SCOPE_STORE
);
return $lifetime > 0 ? $lifetime : self::DEFAULT_COOKIE_LIFETIME;
}
public function shouldSkipPath(string $path): bool
{
$path = strtolower(trim($path, '/'));
foreach ($this->skipPrefixes as $prefix) {
if ($path === $prefix || strpos($path, $prefix . '/') === 0) {
return true;
}
}
return false;
}
}
@@ -0,0 +1,76 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
class HtmlLinkProcessor
{
/**
* @var UrlPathConverter
*/
private $urlPathConverter;
/**
* @param UrlPathConverter $urlPathConverter
*/
public function __construct(UrlPathConverter $urlPathConverter)
{
$this->urlPathConverter = $urlPathConverter;
}
/**
* Convert internal anchor URLs in complete page HTML.
*
* @param string $html
* @param string $language
* @return string
*/
public function process(string $html, string $language): string
{
if (stripos($html, '<a') === false) {
return $html;
}
$result = preg_replace_callback(
'~(<a\b[^>]*\bhref\s*=\s*)(["\'])(.*?)\2~is',
function (array $matches) use ($language): string {
$href = $matches[3];
$normalizedHref = trim($href);
if (!$this->isConvertibleHref($normalizedHref)) {
return $matches[0];
}
$convertedHref = $this->urlPathConverter->toLanguageUrl($normalizedHref, $language);
if ($convertedHref === $normalizedHref) {
return $matches[0];
}
return $matches[1] . $matches[2] . $convertedHref . $matches[2];
},
$html
);
return is_string($result) ? $result : $html;
}
/**
* Check whether an href represents a navigational HTTP URL.
*
* @param string $href
* @return bool
*/
private function isConvertibleHref(string $href): bool
{
if ($href === '' || $href[0] === '#' || $href[0] === '?') {
return false;
}
if (strpos($href, '{{') !== false || strpos($href, '${') !== false) {
return false;
}
return !preg_match('~^[a-z][a-z0-9+.-]*:~i', $href)
|| preg_match('~^https?:~i', $href) === 1;
}
}
@@ -0,0 +1,54 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
use Magento\Store\Model\StoreManagerInterface;
class LanguageResolver
{
/**
* @var StoreViewRegistry
*/
private $storeViewRegistry;
/** @var StoreManagerInterface */
private $storeManager;
public function __construct(StoreViewRegistry $storeViewRegistry, StoreManagerInterface $storeManager)
{
$this->storeViewRegistry = $storeViewRegistry;
$this->storeManager = $storeManager;
}
public function resolveFromPath(string $pathInfo): ?string
{
$firstSegment = $this->getFirstSegment($pathInfo);
if ($firstSegment === null) {
return null;
}
$language = strtolower($firstSegment);
$allowed = $this->storeViewRegistry->isLanguageInWebsite(
$language,
(int)$this->storeManager->getWebsite()->getId()
);
return $allowed ? $language : null;
}
private function getFirstSegment(string $pathInfo): ?string
{
$pathInfo = trim($pathInfo, '/');
if ($pathInfo === '') {
return null;
}
$segments = explode('/', $pathInfo);
return $segments[0] !== '' ? $segments[0] : null;
}
}
@@ -0,0 +1,76 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
use Magento\Framework\Stdlib\Cookie\CookieMetadata;
use Magento\Framework\Stdlib\Cookie\CookieMetadataFactory;
use Magento\Framework\Stdlib\CookieManagerInterface;
class MarketCookie
{
private const STORE_COOKIE_NAME = 'store';
/**
* @var Config
*/
private $config;
/**
* @var CookieManagerInterface
*/
private $cookieManager;
/**
* @var CookieMetadataFactory
*/
private $cookieMetadataFactory;
public function __construct(
Config $config,
CookieManagerInterface $cookieManager,
CookieMetadataFactory $cookieMetadataFactory
) {
$this->config = $config;
$this->cookieManager = $cookieManager;
$this->cookieMetadataFactory = $cookieMetadataFactory;
}
public function get(): ?string
{
$value = $this->cookieManager->getCookie($this->config->getMarketCookieName());
return $value !== null ? trim($value) : null;
}
public function set(string $market): void
{
$metadata = $this->cookieMetadataFactory->createPublicCookieMetadata([
CookieMetadata::KEY_DURATION => $this->config->getMarketCookieLifetime(),
CookieMetadata::KEY_SAME_SITE => 'Lax',
]);
$metadata->setPath('/');
$metadata->setHttpOnly(false);
$this->cookieManager->setPublicCookie(
$this->config->getMarketCookieName(),
$market,
$metadata
);
if ($this->config->getMarketCookieName() !== self::STORE_COOKIE_NAME) {
$storeMetadata = $this->cookieMetadataFactory->createPublicCookieMetadata([
CookieMetadata::KEY_DURATION => 31536000,
CookieMetadata::KEY_SAME_SITE => 'Lax',
]);
$storeMetadata->setPath('/');
$storeMetadata->setHttpOnly(false);
$this->cookieManager->setPublicCookie(
self::STORE_COOKIE_NAME,
$market,
$storeMetadata
);
}
}
}
@@ -0,0 +1,76 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
use Magento\Framework\App\RequestInterface;
class MarketResolver
{
/**
* @var MarketCookie
*/
private $marketCookie;
/**
* @var StoreCodeMapper
*/
private $storeCodeMapper;
public function __construct(MarketCookie $marketCookie, StoreCodeMapper $storeCodeMapper)
{
$this->marketCookie = $marketCookie;
$this->storeCodeMapper = $storeCodeMapper;
}
public function resolve(RequestInterface $request): ?string
{
$requestMarket = $this->normalizeMarket($request->getParam('market'));
if ($requestMarket !== null) {
return $requestMarket;
}
$cookieMarket = $this->normalizeMarket($this->marketCookie->get());
if ($cookieMarket !== null) {
return $cookieMarket;
}
return null;
}
public function resolveForLanguage(RequestInterface $request, string $language): ?string
{
$requestMarket = $this->normalizeMarketForLanguage($request->getParam('market'), $language);
if ($requestMarket !== null) {
return $requestMarket;
}
$cookieMarket = $this->normalizeMarketForLanguage($this->marketCookie->get(), $language);
if ($cookieMarket !== null) {
return $cookieMarket;
}
return $this->storeCodeMapper->getDefaultStoreCodeForLanguage($language);
}
public function normalizeMarket($market): ?string
{
if (!is_scalar($market)) {
return null;
}
$market = trim((string)$market);
return $this->storeCodeMapper->isRealStoreCodeInScope($market) ? $market : null;
}
public function normalizeMarketForLanguage($market, string $language): ?string
{
$market = $this->normalizeMarket($market);
if ($market === null) {
return null;
}
return $this->storeCodeMapper->languageFromStoreCode($market) === strtolower($language) ? $market : null;
}
}
@@ -0,0 +1,56 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
class RequestPathProcessor
{
/**
* @var LanguageResolver
*/
private $languageResolver;
public function __construct(LanguageResolver $languageResolver)
{
$this->languageResolver = $languageResolver;
}
public function stripLanguagePrefix(string $pathInfo): string
{
if ($this->languageResolver->resolveFromPath($pathInfo) === null) {
return $this->normalizePath($pathInfo);
}
$hasTrailingSlash = substr($pathInfo, -1) === '/';
$pathInfo = '/' . ltrim($pathInfo, '/');
$segments = explode('/', trim($pathInfo, '/'), 2);
$remainingPath = $segments[1] ?? '';
if ($remainingPath === '') {
return '/';
}
$path = '/' . ltrim($remainingPath, '/');
return $hasTrailingSlash && substr($path, -1) !== '/' ? $path . '/' : $path;
}
public function replaceLanguagePrefix(string $pathInfo, string $language): string
{
$remainingPath = $this->stripLanguagePrefix($pathInfo);
$language = strtolower(trim($language));
if ($remainingPath === '/') {
return '/' . $language . '/';
}
return '/' . $language . $remainingPath;
}
private function normalizePath(string $pathInfo): string
{
$pathInfo = '/' . ltrim($pathInfo, '/');
return $pathInfo === '' ? '/' : $pathInfo;
}
}
@@ -0,0 +1,81 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
use Magento\Store\Model\StoreManagerInterface;
class StoreCodeMapper
{
/**
* @var StoreViewRegistry
*/
private $storeViewRegistry;
private $storeManager;
public function __construct(StoreViewRegistry $storeViewRegistry, StoreManagerInterface $storeManager)
{
$this->storeViewRegistry = $storeViewRegistry;
$this->storeManager = $storeManager;
}
public function map(string $language, ?string $market = null): ?string
{
$language = strtolower(trim($language));
if ($market !== null
&& $this->isRealStoreCodeInScope($market)
&& $this->languageFromStoreCode($market) === $language
) {
return $market;
}
return $this->getDefaultStoreCodeForLanguage($language);
}
public function languageFromStoreCode(string $storeCode): ?string
{
return $this->storeViewRegistry->getLanguageByStoreCode($storeCode);
}
public function marketFromStoreCode(string $storeCode): ?string
{
return $this->isRealStoreCodeInScope($storeCode) ? $storeCode : null;
}
public function isRealStoreCodeInScope(string $storeCode): bool
{
return $this->storeViewRegistry->isStoreCodeInWebsite($storeCode, $this->getWebsiteId());
}
public function isLanguageAllowed(string $language): bool
{
return $this->storeViewRegistry->isLanguageInWebsite($language, $this->getWebsiteId());
}
public function getDefaultStoreCodeForLanguage(string $language): ?string
{
return $this->storeViewRegistry->getStoreCodeForLanguageInWebsite($language, $this->getWebsiteId());
}
public function getDefaultLanguage(): ?string
{
try {
$defaultStore = $this->storeManager->getWebsite()->getDefaultStore();
return $defaultStore ? $this->languageFromStoreCode((string)$defaultStore->getCode()) : null;
} catch (\Throwable $exception) {
return null;
}
}
public function isDefaultLanguage(string $language): bool
{
return strtolower(trim($language)) === $this->getDefaultLanguage();
}
private function getWebsiteId(): int
{
return (int)$this->storeManager->getWebsite()->getId();
}
}
@@ -0,0 +1,188 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Store\Model\ScopeInterface;
use Magento\Store\Model\ResourceModel\Store\CollectionFactory;
use Psr\Log\LoggerInterface;
class StoreViewRegistry
{
/**
* @var CollectionFactory
*/
private $storeCollectionFactory;
/**
* @var LoggerInterface
*/
private $logger;
/** @var ScopeConfigInterface */
private $scopeConfig;
/**
* @var string[][]|null
*/
private $storesByLanguage;
/**
* @var string[]|null
*/
private $languageByStoreCode;
/** @var string[][][]|null */
private $storesByWebsiteLanguage;
/** @var int[]|null */
private $websiteByStoreCode;
public function __construct(
CollectionFactory $storeCollectionFactory,
LoggerInterface $logger,
ScopeConfigInterface $scopeConfig
) {
$this->storeCollectionFactory = $storeCollectionFactory;
$this->logger = $logger;
$this->scopeConfig = $scopeConfig;
}
/**
* @return string[][]
*/
public function getStoresByLanguage(): array
{
$this->load();
return $this->storesByLanguage;
}
public function getDefaultStoreCodeForLanguage(string $language): ?string
{
$language = strtolower(trim($language));
$stores = $this->getStoresByLanguage();
return isset($stores[$language][0]) ? $stores[$language][0] : null;
}
/** @return string[][] */
public function getStoresByLanguageForWebsite(int $websiteId): array
{
$this->load();
return $this->storesByWebsiteLanguage[$websiteId] ?? [];
}
public function getStoreCodeForLanguageInWebsite(string $language, int $websiteId): ?string
{
$language = strtolower(trim($language));
$stores = $this->getStoresByLanguageForWebsite($websiteId);
return $stores[$language][0] ?? null;
}
public function isLanguageInWebsite(string $language, int $websiteId): bool
{
return $this->getStoreCodeForLanguageInWebsite($language, $websiteId) !== null;
}
public function isStoreCodeInWebsite(string $storeCode, int $websiteId): bool
{
$this->load();
return ($this->websiteByStoreCode[trim($storeCode)] ?? null) === $websiteId;
}
public function getLanguageByStoreCode(string $storeCode): ?string
{
$this->load();
$storeCode = trim($storeCode);
return $this->languageByStoreCode[$storeCode] ?? null;
}
public function isKnownStoreCode(string $storeCode): bool
{
return $this->getLanguageByStoreCode($storeCode) !== null;
}
public function isKnownLanguage(string $language): bool
{
$language = strtolower(trim($language));
$stores = $this->getStoresByLanguage();
return isset($stores[$language]);
}
/**
* @return string[]
*/
public function getAllowedLanguages(): array
{
return array_keys($this->getStoresByLanguage());
}
/**
* @return string[]
*/
public function getAllowedStoreCodes(): array
{
$this->load();
return array_keys($this->languageByStoreCode);
}
private function load(): void
{
if ($this->storesByLanguage !== null
&& $this->languageByStoreCode !== null
&& $this->storesByWebsiteLanguage !== null
&& $this->websiteByStoreCode !== null
) {
return;
}
$this->storesByLanguage = [];
$this->languageByStoreCode = [];
$this->storesByWebsiteLanguage = [];
$this->websiteByStoreCode = [];
$collection = $this->storeCollectionFactory->create();
$collection->setWithoutDefaultFilter();
$collection->addStatusFilter(1);
$collection->setOrder('sort_order', 'ASC');
$collection->setOrder('store_id', 'ASC');
foreach ($collection as $store) {
$storeCode = (string)$store->getCode();
$storeId = (int)$store->getId();
if ($storeId === 0) {
continue;
}
$locale = (string)$this->scopeConfig->getValue(
'general/locale/code',
ScopeInterface::SCOPE_STORE,
$storeCode
);
if (!preg_match('/^([a-z]{2,3})(?:[_-][A-Za-z]{4})?(?:[_-][A-Z]{2})?$/', $locale, $matches)) {
$this->logger->warning(
'[LanguageUrlStoreResolver] Ignored active store view with unsupported locale.',
['store_id' => $storeId, 'store_code' => $storeCode, 'locale' => $locale]
);
continue;
}
$language = strtolower($matches[1]);
$websiteId = (int)$store->getWebsiteId();
$this->storesByLanguage[$language][] = $storeCode;
$this->languageByStoreCode[$storeCode] = $language;
$this->storesByWebsiteLanguage[$websiteId][$language][] = $storeCode;
$this->websiteByStoreCode[$storeCode] = $websiteId;
}
}
}
@@ -0,0 +1,182 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Model;
use Magento\Framework\UrlInterface;
use Magento\Store\Model\StoreManagerInterface;
class UrlPathConverter
{
/**
* @var Config
*/
private $config;
/**
* @var StoreCodeMapper
*/
private $storeCodeMapper;
/**
* @var StoreViewRegistry
*/
private $storeViewRegistry;
/**
* @var StoreManagerInterface
*/
private $storeManager;
public function __construct(
Config $config,
StoreCodeMapper $storeCodeMapper,
StoreViewRegistry $storeViewRegistry,
StoreManagerInterface $storeManager
) {
$this->config = $config;
$this->storeCodeMapper = $storeCodeMapper;
$this->storeViewRegistry = $storeViewRegistry;
$this->storeManager = $storeManager;
}
public function toLanguageUrl(string $url, string $language): string
{
$parts = parse_url($url);
if ($parts === false) {
return $url;
}
if ($this->isExternalUrl($parts)) {
return $url;
}
$path = $parts['path'] ?? '/';
$path = $path === '' ? '/' : $path;
$basePath = $this->getBasePath();
$relativePath = $this->stripBasePath($path, $basePath);
if ($this->config->shouldSkipPath($relativePath)) {
return $url;
}
$parts['path'] = $this->prependBasePath(
$basePath,
$this->convertRelativePath($relativePath, strtolower($language))
);
return $this->buildUrl($parts);
}
/**
* @param mixed[] $parts
*/
private function isExternalUrl(array $parts): bool
{
if (!isset($parts['host'])) {
return false;
}
$baseParts = parse_url($this->storeManager->getStore()->getBaseUrl(UrlInterface::URL_TYPE_WEB));
$baseHost = isset($baseParts['host']) ? strtolower($baseParts['host']) : '';
return strtolower((string)$parts['host']) !== $baseHost;
}
private function convertRelativePath(string $path, string $language): string
{
$path = '/' . ltrim($path, '/');
$segments = explode('/', trim($path, '/'), 2);
$firstSegment = $segments[0] ?? '';
$remainingPath = $segments[1] ?? '';
if ($this->storeCodeMapper->isRealStoreCodeInScope($firstSegment)) {
$language = $this->storeCodeMapper->languageFromStoreCode($firstSegment) ?? $language;
$path = $remainingPath === '' ? '/' : '/' . ltrim($remainingPath, '/');
}
if ($this->storeCodeMapper->isLanguageAllowed(strtolower($firstSegment))) {
$path = $remainingPath === '' ? '/' : '/' . ltrim($remainingPath, '/');
}
if ($this->storeCodeMapper->isDefaultLanguage($language)) {
return $path;
}
return $path === '/' ? '/' . $language . '/' : '/' . $language . $path;
}
private function getBasePath(): string
{
$baseParts = parse_url($this->storeManager->getStore()->getBaseUrl(UrlInterface::URL_TYPE_WEB));
$basePath = isset($baseParts['path']) ? rtrim($baseParts['path'], '/') : '';
return $basePath !== '' ? $basePath : '/';
}
private function stripBasePath(string $path, string $basePath): string
{
if ($basePath === '/' || $basePath === '') {
return '/' . ltrim($path, '/');
}
if ($path === $basePath) {
return '/';
}
if (strpos($path, $basePath . '/') === 0) {
return '/' . ltrim(substr($path, strlen($basePath)), '/');
}
return '/' . ltrim($path, '/');
}
private function prependBasePath(string $basePath, string $path): string
{
$path = '/' . ltrim($path, '/');
if ($basePath === '/' || $basePath === '') {
return $path;
}
return rtrim($basePath, '/') . $path;
}
/**
* @param mixed[] $parts
*/
private function buildUrl(array $parts): string
{
$url = '';
if (isset($parts['host'])) {
$url .= isset($parts['scheme']) ? $parts['scheme'] . '://' : '//';
if (isset($parts['user'])) {
$url .= $parts['user'];
if (isset($parts['pass'])) {
$url .= ':' . $parts['pass'];
}
$url .= '@';
}
$url .= $parts['host'];
if (isset($parts['port'])) {
$url .= ':' . $parts['port'];
}
}
$url .= $parts['path'] ?? '/';
if (isset($parts['query']) && $parts['query'] !== '') {
$url .= '?' . $parts['query'];
}
if (isset($parts['fragment']) && $parts['fragment'] !== '') {
$url .= '#' . $parts['fragment'];
}
return $url;
}
}
@@ -0,0 +1,145 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Observer;
use Magento\Framework\App\Http\Context as HttpContext;
use Magento\Framework\App\RequestInterface;
use Magento\Framework\Event\Observer;
use Magento\Framework\Event\ObserverInterface;
use Magento\Store\Model\StoreManagerInterface;
use Esun3d\LanguageUrlStoreResolver\Model\Config;
use Esun3d\LanguageUrlStoreResolver\Model\LanguageResolver;
use Esun3d\LanguageUrlStoreResolver\Model\MarketResolver;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Psr\Log\LoggerInterface;
class AddHttpContextObserver implements ObserverInterface
{
public const CONTEXT_MARKET = 'language_url_market';
public const CONTEXT_STORE_CODE = 'language_url_store_code';
/**
* @var Config
*/
private $config;
/**
* @var MarketResolver
*/
private $marketResolver;
/**
* @var HttpContext
*/
private $httpContext;
/**
* @var RequestInterface
*/
private $request;
/**
* @var StoreManagerInterface
*/
private $storeManager;
/**
* @var StoreCodeMapper
*/
private $storeCodeMapper;
/**
* @var LanguageResolver
*/
private $languageResolver;
/**
* @var LoggerInterface
*/
private $logger;
public function __construct(
Config $config,
LoggerInterface $logger,
MarketResolver $marketResolver,
HttpContext $httpContext,
RequestInterface $request,
StoreManagerInterface $storeManager,
StoreCodeMapper $storeCodeMapper,
LanguageResolver $languageResolver
) {
$this->config = $config;
$this->marketResolver = $marketResolver;
$this->httpContext = $httpContext;
$this->request = $request;
$this->storeManager = $storeManager;
$this->storeCodeMapper = $storeCodeMapper;
$this->languageResolver = $languageResolver;
$this->logger = $logger;
}
public function execute(Observer $observer): void
{
if (!$this->config->isEnabled()) {
$this->logger->debug('[LanguageUrlStoreResolver] config not Enabled');
return;
}
$market = $this->resolveMarket();
$storeCode = $this->resolveStoreCode();
$this->httpContext->setValue(
self::CONTEXT_MARKET,
$market,
$this->resolveDefaultStoreCode()
);
$this->httpContext->setValue(
self::CONTEXT_STORE_CODE,
$storeCode,
$this->resolveDefaultStoreCode()
);
}
private function resolveStoreCode(): string
{
try {
$storeCode = $this->storeManager->getStore()->getCode();
return $this->storeCodeMapper->isRealStoreCodeInScope($storeCode)
? $storeCode
: $this->resolveDefaultStoreCode();
} catch (\Throwable $exception) {
return $this->resolveDefaultStoreCode();
}
}
private function resolveMarket(): string
{
try {
$storeCode = $this->storeManager->getStore()->getCode();
$language = $this->storeCodeMapper->languageFromStoreCode($storeCode);
if ($language !== null) {
return $this->marketResolver->resolveForLanguage($this->request, $language) ?: '';
}
} catch (\Throwable $exception) {
return $this->resolveDefaultStoreCode();
}
return $this->marketResolver->resolve($this->request) ?: $this->resolveDefaultStoreCode();
}
private function resolveDefaultStoreCode(): string
{
$language = $this->request instanceof \Magento\Framework\App\Request\Http
? $this->languageResolver->resolveFromPath($this->request->getPathInfo())
: null;
if ($language === null) {
return '';
}
return $this->storeCodeMapper->getDefaultStoreCodeForLanguage($language) ?: '';
}
}
@@ -0,0 +1,100 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Observer;
use Esun3d\LanguageUrlStoreResolver\Model\Config;
use Esun3d\LanguageUrlStoreResolver\Model\HtmlLinkProcessor;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Magento\Framework\App\Response\Http as HttpResponse;
use Magento\Framework\Event\Observer;
use Magento\Framework\Event\ObserverInterface;
use Magento\Store\Model\StoreManagerInterface;
use Psr\Log\LoggerInterface;
class RewritePageLinksObserver implements ObserverInterface
{
/**
* @var Config
*/
private $config;
/**
* @var HtmlLinkProcessor
*/
private $htmlLinkProcessor;
/**
* @var StoreManagerInterface
*/
private $storeManager;
/**
* @var StoreCodeMapper
*/
private $storeCodeMapper;
/**
* @var LoggerInterface
*/
private $logger;
/**
* @param Config $config
* @param HtmlLinkProcessor $htmlLinkProcessor
* @param StoreManagerInterface $storeManager
* @param StoreCodeMapper $storeCodeMapper
* @param LoggerInterface $logger
*/
public function __construct(
Config $config,
HtmlLinkProcessor $htmlLinkProcessor,
StoreManagerInterface $storeManager,
StoreCodeMapper $storeCodeMapper,
LoggerInterface $logger
) {
$this->config = $config;
$this->htmlLinkProcessor = $htmlLinkProcessor;
$this->storeManager = $storeManager;
$this->storeCodeMapper = $storeCodeMapper;
$this->logger = $logger;
}
/**
* Rewrite internal links after the complete frontend page is rendered.
*
* @param Observer $observer
* @return void
*/
public function execute(Observer $observer): void
{
if (!$this->config->isEnabled()) {
return;
}
$response = $observer->getData('response');
if (!$response instanceof HttpResponse) {
return;
}
$body = (string)$response->getBody();
if (stripos($body, '<html') === false || stripos($body, '<a') === false) {
return;
}
try {
$storeCode = (string)$this->storeManager->getStore()->getCode();
$language = $this->storeCodeMapper->languageFromStoreCode($storeCode);
if ($language === null) {
return;
}
$response->setBody($this->htmlLinkProcessor->process($body, $language));
} catch (\Throwable $exception) {
$this->logger->error(
'[LanguageUrlStoreResolver] Failed to convert links in page HTML.',
['exception' => $exception]
);
}
}
}
@@ -0,0 +1,476 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Plugin;
use Magento\Framework\App\FrontControllerInterface;
use Magento\Framework\App\Request\Http as HttpRequest;
use Magento\Framework\App\RequestInterface;
use Magento\Framework\App\Response\Http as HttpResponse;
use Magento\Store\Model\StoreManagerInterface;
use Psr\Log\LoggerInterface;
use Esun3d\LanguageUrlStoreResolver\Model\Config;
use Esun3d\LanguageUrlStoreResolver\Model\LanguageResolver;
use Esun3d\LanguageUrlStoreResolver\Model\MarketCookie;
use Esun3d\LanguageUrlStoreResolver\Model\MarketResolver;
use Esun3d\LanguageUrlStoreResolver\Model\RequestPathProcessor;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Magento\Framework\Locale\ResolverInterface as LocaleResolverInterface;
use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Store\Model\ScopeInterface;
class LanguageUrlFrontControllerPlugin
{
/**
* @var Config
*/
private $config;
/**
* @var LanguageResolver
*/
private $languageResolver;
/**
* @var MarketResolver
*/
private $marketResolver;
/**
* @var StoreCodeMapper
*/
private $storeCodeMapper;
/**
* @var RequestPathProcessor
*/
private $requestPathProcessor;
/**
* @var StoreManagerInterface
*/
private $storeManager;
/**
* @var MarketCookie
*/
private $marketCookie;
/**
* @var HttpResponse
*/
private $response;
/**
* @var LoggerInterface
*/
private $logger;
/**
* @var LocaleResolverInterface
*/
private $localeResolver;
/**
* @var ScopeConfigInterface
*/
private $scopeConfig;
public function __construct(
Config $config,
LanguageResolver $languageResolver,
MarketResolver $marketResolver,
StoreCodeMapper $storeCodeMapper,
RequestPathProcessor $requestPathProcessor,
StoreManagerInterface $storeManager,
MarketCookie $marketCookie,
HttpResponse $response,
LoggerInterface $logger,
LocaleResolverInterface $localeResolver,
ScopeConfigInterface $scopeConfig
) {
$this->config = $config;
$this->languageResolver = $languageResolver;
$this->marketResolver = $marketResolver;
$this->storeCodeMapper = $storeCodeMapper;
$this->requestPathProcessor = $requestPathProcessor;
$this->storeManager = $storeManager;
$this->marketCookie = $marketCookie;
$this->response = $response;
$this->logger = $logger;
$this->localeResolver = $localeResolver;
$this->scopeConfig = $scopeConfig;
}
/**
* @param callable $proceed
* @return mixed
*/
public function aroundDispatch(
FrontControllerInterface $subject,
callable $proceed,
RequestInterface $request
) {
if (!$this->config->isEnabled() || !$request instanceof HttpRequest) {
return $proceed($request);
}
$pathInfo = $request->getPathInfo();
if ($this->config->shouldSkipPath($pathInfo)) {
$this->resolveStoreForContextOnlyPath($request);
return $proceed($request);
}
$realStoreCodeRedirect = $this->getRealStoreCodeRedirect($request);
if ($realStoreCodeRedirect !== null) {
return $realStoreCodeRedirect;
}
if ($this->hasInvalidMarketParam($request)) {
return $proceed($request);
}
$marketParamRedirect = $this->getMarketParamRedirect($request);
if ($marketParamRedirect !== null) {
return $marketParamRedirect;
}
$language = $this->languageResolver->resolveFromPath($pathInfo);
if ($language === null) {
$this->resolveDefaultStoreForUnprefixedPath($request);
return $proceed($request);
}
if ($this->storeCodeMapper->isDefaultLanguage($language)) {
return $this->redirect(
$this->buildRedirectUrl($request, $this->requestPathProcessor->stripLanguagePrefix($pathInfo)),
301
);
}
$market = null;
$storeCode = null;
try {
$market = $this->marketResolver->resolveForLanguage($request, $language);
$storeCode = $this->storeCodeMapper->map($language, $market);
if ($storeCode === null) {
return $proceed($request);
}
if ($market === null) {
$market = $storeCode;
}
$this->storeManager->setCurrentStore($storeCode);
$this->applyLocaleForStore($request, $storeCode);
$configLocale = (string) $this->scopeConfig->getValue(
'general/locale/code',
ScopeInterface::SCOPE_STORE,
$storeCode
);
#$this->logger->debug('[LanguageUrlStoreResolver] locale check after set store', [
# 'path' => $request->getPathInfo(),
# 'store_code' => $storeCode,
# 'config_locale' => $configLocale,
# 'resolver_locale' => $this->localeResolver->getLocale(),
#]);
// 写入当前 storeCode, 后续恢复 store context。
$this->marketCookie->set($storeCode);
$request->setPathInfo($this->requestPathProcessor->stripLanguagePrefix($pathInfo));
$this->setRequestValue($request, 'language_url_prefix', $language);
$this->setRequestValue($request, 'language_url_market', $market);
$this->setRequestValue($request, 'language_url_store_code', $storeCode);
} catch (\Throwable $exception) {
$this->logger->error(
'[LanguageUrlStoreResolver] Failed to resolve language URL store.',
$this->buildLogContext($request, $market, $storeCode, $exception)
);
}
return $proceed($request);
}
private function getRealStoreCodeRedirect(HttpRequest $request): ?HttpResponse
{
$pathInfo = $request->getPathInfo();
$segments = explode('/', trim($pathInfo, '/'), 2);
$storeCode = $segments[0] ?? '';
if (!$this->storeCodeMapper->isRealStoreCodeInScope($storeCode)) {
return null;
}
$language = $this->storeCodeMapper->languageFromStoreCode($storeCode);
$market = $this->storeCodeMapper->marketFromStoreCode($storeCode);
if ($language === null || $market === null) {
return null;
}
try {
$this->marketCookie->set($market);
$remainingPath = $segments[1] ?? '';
$targetPath = '/' . $language . ($remainingPath !== '' ? '/' . ltrim($remainingPath, '/') : '');
return $this->redirect($this->buildRedirectUrl($request, $targetPath), 301);
} catch (\Throwable $exception) {
$this->logger->error(
'[LanguageUrlStoreResolver] Failed to redirect real store code URL.',
$this->buildLogContext($request, $market, $storeCode, $exception)
);
}
return null;
}
private function getMarketParamRedirect(HttpRequest $request): ?HttpResponse
{
$pathInfo = $request->getPathInfo();
$market = $this->marketResolver->normalizeMarket($request->getParam('market'));
if ($market === null) {
return null;
}
$targetLanguage = $this->storeCodeMapper->languageFromStoreCode($market);
if ($targetLanguage === null) {
return null;
}
try {
$this->marketCookie->set($market);
$language = $this->languageResolver->resolveFromPath($pathInfo);
if ($language === null) {
if (!$this->isRootPath($pathInfo)) {
return null;
}
$targetPath = $this->storeCodeMapper->isDefaultLanguage($targetLanguage)
? '/'
: '/' . $targetLanguage . '/';
} else {
$targetPath = $this->storeCodeMapper->isDefaultLanguage($targetLanguage)
? $this->requestPathProcessor->stripLanguagePrefix($pathInfo)
: $this->requestPathProcessor->replaceLanguagePrefix($pathInfo, $targetLanguage);
}
return $this->redirect($this->buildRedirectUrl($request, $targetPath), 302);
} catch (\Throwable $exception) {
$this->logger->error(
'[LanguageUrlStoreResolver] Failed to redirect market switch URL.',
$this->buildLogContext($request, $market, $market, $exception)
);
}
return null;
}
private function isRootPath(string $pathInfo): bool
{
return trim($pathInfo, '/') === '';
}
private function resolveDefaultStoreForUnprefixedPath(HttpRequest $request): void
{
$storeCode = null;
try {
$defaultStore = $this->storeManager->getWebsite()->getDefaultStore();
if (!$defaultStore || !$defaultStore->isActive()) {
return;
}
$storeCode = (string)$defaultStore->getCode();
$this->storeManager->setCurrentStore($storeCode);
$this->applyLocaleForStore($request, $storeCode);
$this->marketCookie->set($storeCode);
$this->setRequestValue($request, 'language_url_market', $storeCode);
$this->setRequestValue($request, 'language_url_store_code', $storeCode);
} catch (\Throwable $exception) {
$this->logger->error(
'[LanguageUrlStoreResolver] Failed to resolve the default store for the root URL.',
$this->buildLogContext($request, $storeCode, $storeCode, $exception)
);
}
}
private function hasInvalidMarketParam(HttpRequest $request): bool
{
$market = $request->getParam('market');
if ($market === null || $market === '') {
return false;
}
return $this->marketResolver->normalizeMarket($market) === null;
}
private function resolveStoreForContextOnlyPath(HttpRequest $request): void
{
$storeCode = null;
try {
$cookieMarket = $this->marketCookie->get();
if (is_string($cookieMarket) && $cookieMarket !== '') {
$normalizedMarket = $this->marketResolver->normalizeMarket($cookieMarket);
if ($normalizedMarket !== null && $this->storeCodeMapper->isRealStoreCodeInScope($normalizedMarket)) {
$storeCode = $normalizedMarket;
}
}
if ($storeCode === null) {
$storeCode = $this->resolveStoreCodeFromReferer($request);
}
if ($storeCode === null) {
$defaultStore = $this->storeManager->getWebsite()->getDefaultStore();
$storeCode = $defaultStore && $defaultStore->isActive()
? (string)$defaultStore->getCode()
: null;
}
if ($storeCode === null || !$this->storeCodeMapper->isRealStoreCodeInScope($storeCode)) {
return;
}
$this->storeManager->setCurrentStore($storeCode);
$this->applyLocaleForStore($request, $storeCode);
$this->marketCookie->set($storeCode);
$this->setRequestValue($request, 'language_url_market', $storeCode);
$this->setRequestValue($request, 'language_url_store_code', $storeCode);
$this->logger->debug('[LanguageUrlStoreResolver] context-only path store resolved', [
'path' => $request->getPathInfo(),
'request_uri' => $request->getRequestUri(),
'store_code' => $storeCode,
]);
} catch (\Throwable $exception) {
$this->logger->error(
'[LanguageUrlStoreResolver] Failed to resolve context-only path store.',
$this->buildLogContext($request, null, $storeCode, $exception)
);
}
}
private function resolveStoreCodeFromReferer(HttpRequest $request): ?string
{
$referer = (string) $request->getServer('HTTP_REFERER');
if ($referer === '') {
return null;
}
$refererPath = (string) parse_url($referer, PHP_URL_PATH);
if ($refererPath === '') {
return null;
}
$language = $this->languageResolver->resolveFromPath($refererPath);
if ($language === null) {
return null;
}
return $this->storeCodeMapper->getDefaultStoreCodeForLanguage($language);
}
private function applyLocaleForStore(HttpRequest $request, string $storeCode): void
{
$configLocale = (string) $this->scopeConfig->getValue(
'general/locale/code',
ScopeInterface::SCOPE_STORE,
$storeCode
);
if ($configLocale === '') {
$this->logger->debug('[LanguageUrlStoreResolver] empty locale config', [
'path' => $request->getPathInfo(),
'store_code' => $storeCode,
]);
return;
}
$this->localeResolver->setLocale($configLocale);
$this->logger->debug('[LanguageUrlStoreResolver] locale applied after set store', [
'path' => $request->getPathInfo(),
'store_code' => $storeCode,
'config_locale' => $configLocale,
'resolver_locale' => $this->localeResolver->getLocale(),
]);
}
private function redirect(string $url, int $statusCode): HttpResponse
{
$this->response->setRedirect($url, $statusCode);
return $this->response;
}
private function buildRedirectUrl(HttpRequest $request, string $path): string
{
$baseUrl = method_exists($request, 'getBaseUrl') ? rtrim((string) $request->getBaseUrl(), '/') : '';
$queryString = $this->cleanQueryString((string) parse_url($request->getRequestUri(), PHP_URL_QUERY));
$url = $baseUrl . '/' . ltrim($path, '/');
if ($queryString !== '') {
$url .= '?' . $queryString;
}
return $url;
}
private function cleanQueryString(string $queryString): string
{
if ($queryString === '') {
return '';
}
parse_str($queryString, $params);
unset($params['market'], $params['store'], $params['___store']);
return http_build_query($params);
}
private function setRequestValue(HttpRequest $request, string $key, string $value): void
{
$request->setParam($key, $value);
if (method_exists($request, 'setAlias')) {
$request->setAlias($key, $value);
}
}
/**
* @return mixed[]
*/
private function buildLogContext(
HttpRequest $request,
?string $market,
?string $storeCode,
\Throwable $exception
): array {
return [
'path' => $request->getPathInfo(),
'request_uri' => $request->getRequestUri(),
'market' => $market,
'store_code' => $storeCode,
'exception' => $exception,
];
}
}
@@ -0,0 +1,117 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Plugin;
use Magento\Framework\App\Area;
use Magento\Framework\App\Request\Http as HttpRequest;
use Magento\Framework\App\RequestInterface;
use Magento\Framework\App\State;
use Magento\Framework\Url;
use Magento\Store\Model\StoreManagerInterface;
use Psr\Log\LoggerInterface;
use Esun3d\LanguageUrlStoreResolver\Model\Config;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Esun3d\LanguageUrlStoreResolver\Model\UrlPathConverter;
class UrlPlugin
{
/**
* @var Config
*/
private $config;
/**
* @var State
*/
private $appState;
/**
* @var StoreManagerInterface
*/
private $storeManager;
/**
* @var StoreCodeMapper
*/
private $storeCodeMapper;
/**
* @var UrlPathConverter
*/
private $urlPathConverter;
/**
* @var RequestInterface
*/
private $request;
/**
* @var LoggerInterface
*/
private $logger;
public function __construct(
Config $config,
State $appState,
StoreManagerInterface $storeManager,
StoreCodeMapper $storeCodeMapper,
UrlPathConverter $urlPathConverter,
RequestInterface $request,
LoggerInterface $logger
) {
$this->config = $config;
$this->appState = $appState;
$this->storeManager = $storeManager;
$this->storeCodeMapper = $storeCodeMapper;
$this->urlPathConverter = $urlPathConverter;
$this->request = $request;
$this->logger = $logger;
}
/**
* @param mixed|null $routePath
* @param mixed|null $routeParams
*/
public function afterGetUrl(Url $subject, string $result, $routePath = null, $routeParams = null): string
{
if (!$this->config->isEnabled() || !$this->isFrontendArea()) {
return $result;
}
$storeCode = null;
try {
$storeCode = $this->storeManager->getStore()->getCode();
$language = $this->storeCodeMapper->languageFromStoreCode($storeCode);
if ($language === null) {
return $result;
}
return $this->urlPathConverter->toLanguageUrl($result, $language);
} catch (\Throwable $exception) {
$this->logger->error(
'[LanguageUrlStoreResolver] Failed to convert generated URL.',
[
'path' => $this->request instanceof HttpRequest ? $this->request->getPathInfo() : null,
'request_uri' => $this->request instanceof HttpRequest ? $this->request->getRequestUri() : null,
'market' => null,
'store_code' => $storeCode,
'exception' => $exception,
]
);
}
return $result;
}
private function isFrontendArea(): bool
{
try {
return $this->appState->getAreaCode() === Area::AREA_FRONTEND;
} catch (\Throwable $exception) {
return false;
}
}
}
@@ -0,0 +1,79 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Test\Unit\Model;
use Esun3d\LanguageUrlStoreResolver\Model\HtmlLinkProcessor;
use Esun3d\LanguageUrlStoreResolver\Model\UrlPathConverter;
use PHPUnit\Framework\TestCase;
class HtmlLinkProcessorTest extends TestCase
{
public function testConvertsOnlyNavigationalAnchorUrls(): void
{
$converter = $this->createMock(UrlPathConverter::class);
$converter->expects(self::exactly(3))
->method('toLanguageUrl')
->willReturnCallback(static function (string $url, string $language): string {
self::assertSame('ko', $language);
return [
'/news' => '/ko/news',
'https://example.com/about-us?from=footer' =>
'https://example.com/ko/about-us?from=footer',
'https://external.example.net/page' => 'https://external.example.net/page',
][$url];
});
$html = '<html><body>'
. '<a href="/news">News</a>'
. '<a href="https://example.com/about-us?from=footer">About</a>'
. '<a href="https://external.example.net/page">External</a>'
. '<a href="#details">Details</a>'
. '<a href="mailto:hello@example.com">Email</a>'
. '<a href="tel:+123456789">Phone</a>'
. '<a href="javascript:void(0)">Toggle</a>'
. '</body></html>';
$processor = new HtmlLinkProcessor($converter);
$result = $processor->process($html, 'ko');
self::assertStringContainsString('href="/ko/news"', $result);
self::assertStringContainsString(
'href="https://example.com/ko/about-us?from=footer"',
$result
);
self::assertStringContainsString('href="https://external.example.net/page"', $result);
self::assertStringContainsString('href="#details"', $result);
self::assertStringContainsString('href="mailto:hello@example.com"', $result);
self::assertStringContainsString('href="tel:+123456789"', $result);
self::assertStringContainsString('href="javascript:void(0)"', $result);
}
public function testPreservesSingleQuotesAndEscapesQuerySeparator(): void
{
$converter = $this->createMock(UrlPathConverter::class);
$converter->expects(self::once())
->method('toLanguageUrl')
->with('/search?q=resin&amp;size=1kg', 'de')
->willReturn('/de/search?q=resin&amp;size=1kg');
$processor = new HtmlLinkProcessor($converter);
self::assertSame(
"<a href='/de/search?q=resin&amp;size=1kg'>Search</a>",
$processor->process("<a href='/search?q=resin&amp;size=1kg'>Search</a>", 'de')
);
}
public function testReturnsMarkupWithoutAnchorsUnchanged(): void
{
$converter = $this->createMock(UrlPathConverter::class);
$converter->expects(self::never())->method('toLanguageUrl');
$processor = new HtmlLinkProcessor($converter);
$html = '<html><body><p>No links</p></body></html>';
self::assertSame($html, $processor->process($html, 'ko'));
}
}
@@ -0,0 +1,211 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Test\Unit\Model;
use Magento\Store\Model\Store;
use Magento\Store\Model\StoreManagerInterface;
use Magento\Store\Model\Website;
use PHPUnit\Framework\TestCase;
use Esun3d\LanguageUrlStoreResolver\Model\LanguageResolver;
use Esun3d\LanguageUrlStoreResolver\Model\RequestPathProcessor;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Esun3d\LanguageUrlStoreResolver\Model\StoreViewRegistry;
class LanguageAndPathTest extends TestCase
{
/**
* @var StoreViewRegistry|\PHPUnit\Framework\MockObject\MockObject
*/
private $storeViewRegistry;
/** @var StoreManagerInterface|\PHPUnit\Framework\MockObject\MockObject */
private $storeManager;
protected function setUp(): void
{
$this->storeViewRegistry = $this->createMock(StoreViewRegistry::class);
$this->storeViewRegistry->method('isKnownLanguage')->willReturnCallback(static function (string $language): bool {
return in_array($language, ['en', 'de'], true);
});
$this->storeViewRegistry->method('isKnownStoreCode')->willReturnCallback(static function (string $storeCode): bool {
return in_array($storeCode, ['en_US', 'en_DE', 'de_US', 'de_DE'], true);
});
$this->storeViewRegistry->method('getLanguageByStoreCode')->willReturnCallback(static function (string $storeCode): ?string {
$map = [
'en_US' => 'en',
'en_DE' => 'en',
'de_US' => 'de',
'de_DE' => 'de',
];
return $map[$storeCode] ?? null;
});
$this->storeViewRegistry->method('getDefaultStoreCodeForLanguage')->willReturnCallback(
static function (string $language): ?string {
$map = [
'en' => 'en_US',
'de' => 'de_US',
];
return $map[$language] ?? null;
}
);
$this->storeViewRegistry->method('isLanguageInWebsite')->willReturnCallback(
static fn(string $language, int $websiteId): bool =>
$websiteId === 1 && in_array($language, ['en', 'de'], true)
);
$this->storeViewRegistry->method('isStoreCodeInWebsite')->willReturnCallback(
static fn(string $storeCode, int $websiteId): bool =>
$websiteId === 1 && in_array($storeCode, ['en_US', 'en_DE', 'de_US', 'de_DE'], true)
);
$this->storeViewRegistry->method('getStoreCodeForLanguageInWebsite')->willReturnCallback(
static function (string $language, int $websiteId): ?string {
if ($websiteId !== 1) {
return null;
}
return ['en' => 'en_US', 'de' => 'de_US'][$language] ?? null;
}
);
$defaultStore = $this->createMock(Store::class);
$defaultStore->method('getCode')->willReturn('en_US');
$website = $this->createMock(Website::class);
$website->method('getId')->willReturn(1);
$website->method('getDefaultStore')->willReturn($defaultStore);
$this->storeManager = $this->createMock(StoreManagerInterface::class);
$this->storeManager->method('getWebsite')->willReturn($website);
}
/**
* @dataProvider productPathProvider
*/
public function testResolvesLanguageFromProductPath(string $pathInfo, ?string $expectedLanguage): void
{
$resolver = new LanguageResolver($this->storeViewRegistry, $this->storeManager);
self::assertSame($expectedLanguage, $resolver->resolveFromPath($pathInfo));
}
/**
* @return mixed[]
*/
public static function productPathProvider(): array
{
return [
'english product path' => ['/en/product-a', 'en'],
'german product path' => ['/de/product-a', 'de'],
'english language root' => ['/en', 'en'],
'real store code is not language' => ['/en_US/product-a', null],
'unsupported prefix' => ['/fr/product-a', null],
];
}
/**
* @dataProvider stripProductPathProvider
*/
public function testStripsLanguagePrefixBeforeUrlRewrite(string $pathInfo, string $expectedPathInfo): void
{
$processor = new RequestPathProcessor(new LanguageResolver($this->storeViewRegistry, $this->storeManager));
self::assertSame($expectedPathInfo, $processor->stripLanguagePrefix($pathInfo));
}
/**
* @return mixed[]
*/
public static function stripProductPathProvider(): array
{
return [
'english product path' => ['/en/product-a', '/product-a'],
'german product path' => ['/de/product-a', '/product-a'],
'nested product path' => ['/de/category/product-a', '/category/product-a'],
'language root' => ['/en', '/'],
'non language path unchanged' => ['/product-a', '/product-a'],
];
}
/**
* @dataProvider replaceProductPathProvider
*/
public function testReplacesLanguagePrefixForMarketSwitch(string $pathInfo, string $language, string $expectedPathInfo): void
{
$processor = new RequestPathProcessor(new LanguageResolver($this->storeViewRegistry, $this->storeManager));
self::assertSame($expectedPathInfo, $processor->replaceLanguagePrefix($pathInfo, $language));
}
/**
* @return mixed[]
*/
public static function replaceProductPathProvider(): array
{
return [
'german product path switches to english' => [
'/de/privacy-policy-cookie-restriction-mode/',
'en',
'/en/privacy-policy-cookie-restriction-mode/',
],
'english product path switches to german' => [
'/en/product-a',
'de',
'/de/product-a',
],
'language root keeps trailing slash' => [
'/de/',
'en',
'/en/',
],
];
}
/**
* @dataProvider storeMappingProvider
*/
public function testMapsProductPathLanguageAndMarketToRealStoreCode(
string $language,
?string $market,
?string $expectedStoreCode
): void {
$mapper = new StoreCodeMapper($this->storeViewRegistry, $this->storeManager);
self::assertSame($expectedStoreCode, $mapper->map($language, $market));
}
/**
* @return mixed[]
*/
public static function storeMappingProvider(): array
{
return [
'english US product path' => ['en', 'en_US', 'en_US'],
'english DE product path' => ['en', 'en_DE', 'en_DE'],
'german US product path' => ['de', 'de_US', 'de_US'],
'german DE product path' => ['de', 'de_DE', 'de_DE'],
'english path ignores german market and uses default' => ['en', 'de_DE', 'en_US'],
'unknown language has no default' => ['fr', null, null],
];
}
public function testUsesLanguageSpecificDefaultStoreFromRegistry(): void
{
$mapper = new StoreCodeMapper($this->storeViewRegistry, $this->storeManager);
self::assertSame('en_US', $mapper->getDefaultStoreCodeForLanguage('en'));
self::assertSame('de_US', $mapper->getDefaultStoreCodeForLanguage('de'));
}
public function testUsesCurrentWebsiteWhenLanguageExistsInMultipleWebsites(): void
{
$registry = $this->createMock(StoreViewRegistry::class);
$registry->expects(self::once())
->method('getStoreCodeForLanguageInWebsite')
->with('de', 1)
->willReturn('de_EU');
$mapper = new StoreCodeMapper($registry, $this->storeManager);
self::assertSame('de_EU', $mapper->getDefaultStoreCodeForLanguage('de'));
}
}
@@ -0,0 +1,127 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Test\Unit\Model;
use Magento\Framework\App\RequestInterface;
use Magento\Store\Model\StoreManagerInterface;
use Magento\Store\Model\Website;
use PHPUnit\Framework\TestCase;
use Esun3d\LanguageUrlStoreResolver\Model\MarketCookie;
use Esun3d\LanguageUrlStoreResolver\Model\MarketResolver;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Esun3d\LanguageUrlStoreResolver\Model\StoreViewRegistry;
class MarketResolverTest extends TestCase
{
public function testResolvesStoreCodeMarketForProductPathLanguage(): void
{
$resolver = $this->createResolver(null);
$request = $this->createRequest('en_DE');
self::assertSame('en_DE', $resolver->resolveForLanguage($request, 'en'));
}
public function testIgnoresCrossLanguageCookieForProductPath(): void
{
$resolver = $this->createResolver('de_DE');
$request = $this->createRequest(null);
self::assertSame('en_US', $resolver->resolveForLanguage($request, 'en'));
}
public function testUsesGermanDefaultForGermanProductPath(): void
{
$resolver = $this->createResolver(null);
$request = $this->createRequest(null);
self::assertSame('de_US', $resolver->resolveForLanguage($request, 'de'));
}
public function testIgnoresMissingCookieStoreCode(): void
{
$resolver = $this->createResolver('fr_FR');
$request = $this->createRequest(null);
self::assertSame('en_US', $resolver->resolveForLanguage($request, 'en'));
}
public function testNormalizeMarketRejectsUnknownStoreCode(): void
{
$resolver = $this->createResolver(null);
self::assertNull($resolver->normalizeMarket('fr_FR'));
}
private function createResolver(?string $cookieMarket): MarketResolver
{
$cookie = $this->createMock(MarketCookie::class);
$cookie->method('get')->willReturn($cookieMarket);
return new MarketResolver(
$cookie,
new StoreCodeMapper($this->createRegistry(), $this->createStoreManager())
);
}
private function createRegistry(): StoreViewRegistry
{
$registry = $this->createMock(StoreViewRegistry::class);
$registry->method('isKnownStoreCode')->willReturnCallback(static function (string $storeCode): bool {
return in_array($storeCode, ['en_US', 'en_DE', 'de_US', 'de_DE'], true);
});
$registry->method('getLanguageByStoreCode')->willReturnCallback(static function (string $storeCode): ?string {
$map = [
'en_US' => 'en',
'en_DE' => 'en',
'de_US' => 'de',
'de_DE' => 'de',
];
return $map[$storeCode] ?? null;
});
$registry->method('getDefaultStoreCodeForLanguage')->willReturnCallback(
static function (string $language): ?string {
$map = [
'en' => 'en_US',
'de' => 'de_US',
];
return $map[$language] ?? null;
}
);
$registry->method('isStoreCodeInWebsite')->willReturnCallback(
static fn(string $storeCode, int $websiteId): bool =>
$websiteId === 1 && in_array($storeCode, ['en_US', 'en_DE', 'de_US', 'de_DE'], true)
);
$registry->method('getStoreCodeForLanguageInWebsite')->willReturnCallback(
static function (string $language, int $websiteId): ?string {
if ($websiteId !== 1) {
return null;
}
return ['en' => 'en_US', 'de' => 'de_US'][$language] ?? null;
}
);
return $registry;
}
private function createStoreManager(): StoreManagerInterface
{
$website = $this->createMock(Website::class);
$website->method('getId')->willReturn(1);
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->method('getWebsite')->willReturn($website);
return $storeManager;
}
private function createRequest(?string $market): RequestInterface
{
$request = $this->createMock(RequestInterface::class);
$request->method('getParam')->with('market')->willReturn($market);
return $request;
}
}
@@ -0,0 +1,110 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Test\Unit\Model;
use ArrayIterator;
use Magento\Store\Model\ResourceModel\Store\Collection;
use Magento\Store\Model\ResourceModel\Store\CollectionFactory;
use Magento\Store\Model\Store;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Esun3d\LanguageUrlStoreResolver\Model\StoreViewRegistry;
class StoreViewRegistryTest extends TestCase
{
public function testGroupsActiveStoreViewsByLanguageAndUsesSortedDefaults(): void
{
$registry = $this->createRegistry([
$this->createStore(1, 'english_us', 1),
$this->createStore(2, 'english_de', 2),
$this->createStore(3, 'german_us', 1),
$this->createStore(4, 'german_de', 2),
]);
self::assertSame(
[
'en' => ['english_us', 'english_de'],
'de' => ['german_us', 'german_de'],
],
$registry->getStoresByLanguage()
);
self::assertSame('english_us', $registry->getDefaultStoreCodeForLanguage('en'));
self::assertSame('german_us', $registry->getDefaultStoreCodeForLanguage('de'));
self::assertSame('en', $registry->getLanguageByStoreCode('english_de'));
self::assertTrue($registry->isKnownStoreCode('german_de'));
self::assertTrue($registry->isKnownLanguage('de'));
self::assertSame('german_de', $registry->getStoreCodeForLanguageInWebsite('de', 2));
self::assertFalse($registry->isStoreCodeInWebsite('german_de', 1));
}
public function testSkipsUnsupportedStoreCodeFormat(): void
{
$logger = $this->createMock(LoggerInterface::class);
$logger->expects(self::once())->method('warning');
$registry = $this->createRegistry(
[
$this->createStore(1, 'english_us', 1),
$this->createStore(5, 'bad_locale', 1),
],
$logger
);
self::assertSame(['en' => ['english_us']], $registry->getStoresByLanguage());
self::assertFalse($registry->isKnownStoreCode('bad_locale'));
}
/**
* @param Store[] $stores
*/
private function createRegistry(array $stores, ?LoggerInterface $logger = null): StoreViewRegistry
{
$collection = $this->getMockBuilder(Collection::class)
->disableOriginalConstructor()
->onlyMethods(['setWithoutDefaultFilter', 'addStatusFilter', 'setOrder', 'getIterator'])
->getMock();
$collection->method('setWithoutDefaultFilter')->willReturnSelf();
$collection->method('addStatusFilter')->willReturnSelf();
$collection->method('setOrder')->willReturnSelf();
$collection->method('getIterator')->willReturn(new ArrayIterator($stores));
$factory = $this->getMockBuilder(CollectionFactory::class)
->disableOriginalConstructor()
->onlyMethods(['create'])
->getMock();
$factory->method('create')->willReturn($collection);
$scopeConfig = $this->createMock(\Magento\Framework\App\Config\ScopeConfigInterface::class);
$scopeConfig->method('getValue')->willReturnCallback(static function ($path, $scope, $storeCode) {
$locales = [
'english_us' => 'en_US',
'english_de' => 'en_GB',
'german_us' => 'de_DE',
'german_de' => 'de_DE',
'bad_locale' => '',
];
return $locales[$storeCode] ?? '';
});
return new StoreViewRegistry(
$factory,
$logger ?: $this->createMock(LoggerInterface::class),
$scopeConfig
);
}
private function createStore(int $storeId, string $storeCode, int $websiteId): Store
{
$store = $this->getMockBuilder(Store::class)
->disableOriginalConstructor()
->onlyMethods(['getId', 'getCode', 'getWebsiteId'])
->getMock();
$store->method('getId')->willReturn($storeId);
$store->method('getCode')->willReturn($storeCode);
$store->method('getWebsiteId')->willReturn($websiteId);
return $store;
}
}
@@ -0,0 +1,196 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Test\Unit\Model;
use Magento\Store\Model\Store;
use Magento\Store\Model\StoreManagerInterface;
use Magento\Store\Model\Website;
use PHPUnit\Framework\TestCase;
use Esun3d\LanguageUrlStoreResolver\Model\Config;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Esun3d\LanguageUrlStoreResolver\Model\StoreViewRegistry;
use Esun3d\LanguageUrlStoreResolver\Model\UrlPathConverter;
class UrlPathConverterTest extends TestCase
{
/**
* @dataProvider productUrlProvider
*/
public function testConvertsGeneratedProductUrlsToLanguageUrls(
string $url,
string $language,
string $expectedUrl
): void {
$converter = new UrlPathConverter(
$this->createConfig(),
new StoreCodeMapper($this->createRegistry(), $this->createStoreManager('https://example.com/')),
$this->createRegistry(),
$this->createStoreManager('https://example.com/')
);
self::assertSame($expectedUrl, $converter->toLanguageUrl($url, $language));
}
/**
* @return mixed[]
*/
public static function productUrlProvider(): array
{
return [
'real english US store code product url' => [
'https://example.com/en_US/product-a',
'en',
'https://example.com/en/product-a',
],
'real german DE store code product url' => [
'https://example.com/de_DE/product-a',
'de',
'https://example.com/de/product-a',
],
'plain product url gets language prefix' => [
'https://example.com/product-a',
'en',
'https://example.com/en/product-a',
],
'language product url is not duplicated' => [
'https://example.com/en/product-a',
'en',
'https://example.com/en/product-a',
],
'query and fragment survive conversion' => [
'https://example.com/en_US/product-a?q=printer#reviews',
'en',
'https://example.com/en/product-a?q=printer#reviews',
],
];
}
public function testSkipsExternalProductUrl(): void
{
$converter = new UrlPathConverter(
$this->createConfig(),
new StoreCodeMapper($this->createRegistry(), $this->createStoreManager('https://example.com/')),
$this->createRegistry(),
$this->createStoreManager('https://example.com/')
);
self::assertSame(
'https://cdn.example.net/en_US/product-a',
$converter->toLanguageUrl('https://cdn.example.net/en_US/product-a', 'en')
);
}
public function testSkipsStaticProductAssetPath(): void
{
$converter = new UrlPathConverter(
$this->createConfig(),
new StoreCodeMapper($this->createRegistry(), $this->createStoreManager('https://example.com/')),
$this->createRegistry(),
$this->createStoreManager('https://example.com/')
);
self::assertSame(
'https://example.com/static/version123/frontend/product-a.jpg',
$converter->toLanguageUrl('https://example.com/static/version123/frontend/product-a.jpg', 'en')
);
}
public function testOmitsPrefixForWebsiteDefaultLanguage(): void
{
$mapper = $this->createMock(StoreCodeMapper::class);
$mapper->method('isRealStoreCodeInScope')->with('en_US')->willReturn(true);
$mapper->method('languageFromStoreCode')->with('en_US')->willReturn('en');
$mapper->method('isLanguageAllowed')->willReturn(false);
$mapper->method('isDefaultLanguage')->with('en')->willReturn(true);
$converter = new UrlPathConverter(
$this->createConfig(),
$mapper,
$this->createRegistry(),
$this->createStoreManager('https://example.com/')
);
self::assertSame(
'https://example.com/product-a',
$converter->toLanguageUrl('https://example.com/en_US/product-a', 'en')
);
}
private function createConfig(): Config
{
$config = $this->createMock(Config::class);
$config->method('shouldSkipPath')->willReturnCallback(static function (string $path): bool {
$path = strtolower(trim($path, '/'));
$skipPrefixes = [
'admin',
'rest',
'graphql',
'soap',
'static',
'media',
'pub',
'customer/section/load',
];
foreach ($skipPrefixes as $prefix) {
if ($path === $prefix || strpos($path, $prefix . '/') === 0) {
return true;
}
}
return false;
});
return $config;
}
private function createRegistry(): StoreViewRegistry
{
$registry = $this->createMock(StoreViewRegistry::class);
$registry->method('isKnownLanguage')->willReturnCallback(static function (string $language): bool {
return in_array($language, ['en', 'de'], true);
});
$registry->method('isKnownStoreCode')->willReturnCallback(static function (string $storeCode): bool {
return in_array($storeCode, ['en_US', 'en_DE', 'de_US', 'de_DE'], true);
});
$registry->method('getLanguageByStoreCode')->willReturnCallback(static function (string $storeCode): ?string {
$map = [
'en_US' => 'en',
'en_DE' => 'en',
'de_US' => 'de',
'de_DE' => 'de',
];
return $map[$storeCode] ?? null;
});
$registry->method('isStoreCodeInWebsite')->willReturnCallback(
static fn(string $storeCode, int $websiteId): bool =>
$websiteId === 1 && in_array($storeCode, ['en_US', 'en_DE', 'de_US', 'de_DE'], true)
);
$registry->method('isLanguageInWebsite')->willReturnCallback(
static fn(string $language, int $websiteId): bool =>
$websiteId === 1 && in_array($language, ['en', 'de'], true)
);
return $registry;
}
private function createStoreManager(string $baseUrl): StoreManagerInterface
{
$store = $this->getMockBuilder(Store::class)
->disableOriginalConstructor()
->onlyMethods(['getBaseUrl'])
->getMock();
$store->method('getBaseUrl')->willReturn($baseUrl);
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->method('getStore')->willReturn($store);
$website = $this->createMock(Website::class);
$website->method('getId')->willReturn(1);
$website->method('getDefaultStore')->willReturn($store);
$storeManager->method('getWebsite')->willReturn($website);
return $storeManager;
}
}
@@ -0,0 +1,458 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\Test\Unit\Plugin;
use Magento\Framework\App\FrontControllerInterface;
use Magento\Framework\App\Request\Http as HttpRequest;
use Magento\Framework\App\Response\Http as HttpResponse;
use Magento\Store\Model\Store;
use Magento\Store\Model\StoreManagerInterface;
use Magento\Store\Model\Website;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Esun3d\LanguageUrlStoreResolver\Model\Config;
use Esun3d\LanguageUrlStoreResolver\Model\LanguageResolver;
use Esun3d\LanguageUrlStoreResolver\Model\MarketCookie;
use Esun3d\LanguageUrlStoreResolver\Model\MarketResolver;
use Esun3d\LanguageUrlStoreResolver\Model\RequestPathProcessor;
use Esun3d\LanguageUrlStoreResolver\Model\StoreCodeMapper;
use Esun3d\LanguageUrlStoreResolver\Model\StoreViewRegistry;
use Esun3d\LanguageUrlStoreResolver\Plugin\LanguageUrlFrontControllerPlugin;
class LanguageUrlFrontControllerPluginTest extends TestCase
{
/**
* @dataProvider productPathStoreProvider
*/
public function testSetsStoreAndStripsLanguageForProductPage(
string $pathInfo,
?string $market,
string $expectedStoreCode,
string $expectedPath
): void {
$config = $this->createConfig();
$request = $this->createRequest($pathInfo, null);
$request->expects(self::once())->method('setPathInfo')->with($expectedPath);
$request->expects(self::exactly(3))->method('setParam');
$request->expects(self::exactly(3))->method('setAlias');
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->expects(self::once())->method('setCurrentStore')->with($expectedStoreCode);
$plugin = $this->createPlugin($config, $market, $storeManager);
$proceedCalled = false;
$plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
function (HttpRequest $passedRequest) use (&$proceedCalled, $request) {
$proceedCalled = true;
self::assertSame($request, $passedRequest);
return 'proceeded';
},
$request
);
self::assertTrue($proceedCalled);
}
/**
* @return mixed[]
*/
public static function productPathStoreProvider(): array
{
return [
'english product path without cookie uses language default' => ['/en/product-a', null, 'en_US', '/product-a'],
'english product path in DE market cookie' => ['/en/product-a', 'en_DE', 'en_DE', '/product-a'],
'german product path without cookie uses language default' => ['/de/product-a', null, 'de_US', '/product-a'],
'german product path in DE market cookie' => ['/de/product-a', 'de_DE', 'de_DE', '/product-a'],
'german customer path uses the same language resolver' => [
'/de/customer/account/login',
null,
'de_US',
'/customer/account/login',
],
];
}
/**
* @dataProvider realStoreCodeRedirectProvider
*/
public function testRedirectsRealStoreCodeUrl(string $pathInfo, string $expectedUrl): void
{
$config = $this->createConfig();
$request = $this->createRequest($pathInfo, null);
$request->method('getRequestUri')->willReturn($pathInfo);
$request->method('getBaseUrl')->willReturn('');
$response = $this->createResponse($expectedUrl, 301);
$marketCookie = $this->createMock(MarketCookie::class);
$marketCookie->expects(self::once())->method('set');
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->expects(self::never())->method('setCurrentStore');
$plugin = $this->createPlugin($config, null, $storeManager, $marketCookie, $response);
$proceedCalled = false;
$result = $plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
function () use (&$proceedCalled) {
$proceedCalled = true;
},
$request
);
self::assertSame($response, $result);
self::assertFalse($proceedCalled);
}
/**
* @return mixed[]
*/
public static function realStoreCodeRedirectProvider(): array
{
return [
'english DE store code' => ['/en_DE/product-a', '/en/product-a'],
'german DE store code' => ['/de_DE/product-a', '/de/product-a'],
];
}
/**
* @dataProvider marketRedirectProvider
*/
public function testRedirectsMarketSwitchUrl(string $pathInfo, string $market, string $expectedUrl): void
{
$config = $this->createConfig();
$request = $this->createRequest($pathInfo, $market);
$request->method('getRequestUri')->willReturn($pathInfo . '?market=' . $market);
$request->method('getBaseUrl')->willReturn('');
$response = $this->createResponse($expectedUrl, 302);
$marketCookie = $this->createMock(MarketCookie::class);
$marketCookie->expects(self::once())->method('set')->with($market);
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->expects(self::never())->method('setCurrentStore');
$plugin = $this->createPlugin($config, null, $storeManager, $marketCookie, $response);
$proceedCalled = false;
$result = $plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
function () use (&$proceedCalled) {
$proceedCalled = true;
},
$request
);
self::assertSame($response, $result);
self::assertFalse($proceedCalled);
}
/**
* @return mixed[]
*/
public static function marketRedirectProvider(): array
{
return [
'english URL switches to german DE store' => ['/en/', 'de_DE', '/de/'],
'english URL stays english DE store' => ['/en/', 'en_DE', '/en/'],
'german URL stays german US store' => ['/de/', 'de_US', '/de/'],
'root URL switches to german DE store' => ['/', 'de_DE', '/de/'],
'root URL switches to english DE store' => ['/', 'en_DE', '/en/'],
];
}
/**
* @dataProvider skippedPathProvider
*/
public function testSkippedPathsAreNotProcessed(string $pathInfo): void
{
$config = $this->createConfig();
$request = $this->createRequest($pathInfo, null);
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->expects(self::never())->method('setCurrentStore');
$plugin = $this->createPlugin($config, null, $storeManager);
$proceedCalled = false;
$result = $plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
function () use (&$proceedCalled) {
$proceedCalled = true;
return 'skipped';
},
$request
);
self::assertSame('skipped', $result);
self::assertTrue($proceedCalled);
}
public function testInvalidMarketParamDoesNotSetCurrentStore(): void
{
$config = $this->createConfig();
$request = $this->createRequest('/en/product-a', 'fr_FR');
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->expects(self::never())->method('setCurrentStore');
$plugin = $this->createPlugin($config, null, $storeManager);
$result = $plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
static function () {
return 'invalid-market-proceeded';
},
$request
);
self::assertSame('invalid-market-proceeded', $result);
}
public function testRootPathForcesWebsiteDefaultStore(): void
{
$config = $this->createConfig();
$request = $this->createRequest('/', null);
$request->expects(self::exactly(2))->method('setParam');
$request->expects(self::exactly(2))->method('setAlias');
$defaultStore = $this->createMock(Store::class);
$defaultStore->method('isActive')->willReturn(true);
$defaultStore->method('getCode')->willReturn('en_US');
$website = $this->createMock(Website::class);
$website->method('getDefaultStore')->willReturn($defaultStore);
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->method('getWebsite')->willReturn($website);
$storeManager->expects(self::once())->method('setCurrentStore')->with('en_US');
$marketCookie = $this->createMock(MarketCookie::class);
$marketCookie->expects(self::once())->method('set')->with('en_US');
$plugin = $this->createPlugin($config, 'ja_JP', $storeManager, $marketCookie);
$result = $plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
static function () {
return 'root-proceeded';
},
$request
);
self::assertSame('root-proceeded', $result);
}
public function testUnprefixedContentPathForcesWebsiteDefaultStore(): void
{
$config = $this->createConfig();
$request = $this->createRequest('/product-a.html', null);
$request->expects(self::exactly(2))->method('setParam');
$request->expects(self::exactly(2))->method('setAlias');
$defaultStore = $this->createMock(Store::class);
$defaultStore->method('isActive')->willReturn(true);
$defaultStore->method('getCode')->willReturn('en_US');
$website = $this->createMock(Website::class);
$website->method('getDefaultStore')->willReturn($defaultStore);
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->method('getWebsite')->willReturn($website);
$storeManager->expects(self::once())->method('setCurrentStore')->with('en_US');
$marketCookie = $this->createMock(MarketCookie::class);
$marketCookie->expects(self::once())->method('set')->with('en_US');
$plugin = $this->createPlugin($config, 'de_US', $storeManager, $marketCookie);
$result = $plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
static function () {
return 'unprefixed-product-proceeded';
},
$request
);
self::assertSame('unprefixed-product-proceeded', $result);
}
public function testCustomerAccountPathForcesWebsiteDefaultStoreWithoutLanguageContext(): void
{
$config = $this->createConfig();
$request = $this->createRequest('/customer/account/login', null);
$request->expects(self::exactly(2))->method('setParam');
$request->expects(self::exactly(2))->method('setAlias');
$defaultStore = $this->createMock(Store::class);
$defaultStore->method('isActive')->willReturn(true);
$defaultStore->method('getCode')->willReturn('en_US');
$website = $this->createMock(Website::class);
$website->method('getDefaultStore')->willReturn($defaultStore);
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->method('getWebsite')->willReturn($website);
$storeManager->expects(self::once())->method('setCurrentStore')->with('en_US');
$marketCookie = $this->createMock(MarketCookie::class);
$marketCookie->expects(self::once())->method('set')->with('en_US');
$plugin = $this->createPlugin($config, null, $storeManager, $marketCookie);
$result = $plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
static function () {
return 'customer-login-proceeded';
},
$request
);
self::assertSame('customer-login-proceeded', $result);
}
/**
* @return mixed[]
*/
public static function skippedPathProvider(): array
{
return [
'static' => ['/static/version123/frontend/file.css'],
'media' => ['/media/catalog/product/a.jpg'],
'rest' => ['/rest/V1/products'],
'graphql' => ['/graphql'],
];
}
private function createPlugin(
Config $config,
?string $cookieMarket,
StoreManagerInterface $storeManager,
?MarketCookie $marketCookie = null,
?HttpResponse $response = null
): LanguageUrlFrontControllerPlugin {
$registry = $this->createRegistry();
$scopeStoreManager = $this->createScopeStoreManager();
$languageResolver = new LanguageResolver($registry, $scopeStoreManager);
$marketCookie = $marketCookie ?: $this->createMock(MarketCookie::class);
$marketCookie->method('get')->willReturn($cookieMarket);
$storeCodeMapper = new StoreCodeMapper($registry, $scopeStoreManager);
return new LanguageUrlFrontControllerPlugin(
$config,
$languageResolver,
new MarketResolver($marketCookie, $storeCodeMapper),
$storeCodeMapper,
new RequestPathProcessor($languageResolver),
$storeManager,
$marketCookie,
$response ?: $this->createMock(HttpResponse::class),
$this->createMock(LoggerInterface::class),
$this->createMock(\Magento\Framework\Locale\ResolverInterface::class),
$this->createMock(\Magento\Framework\App\Config\ScopeConfigInterface::class)
);
}
private function createConfig(): Config
{
$scopeConfig = $this->createMock(\Magento\Framework\App\Config\ScopeConfigInterface::class);
$scopeConfig->method('isSetFlag')->willReturn(true);
$scopeConfig->method('getValue')->willReturnCallback(static function (string $path, string $scope) {
self::assertSame(\Magento\Store\Model\ScopeInterface::SCOPE_STORE, $scope);
$values = [
'language_url_store_resolver/general/market_cookie_name' => 'market',
'language_url_store_resolver/general/market_cookie_lifetime' => '2592000',
];
return $values[$path] ?? null;
});
return new Config($scopeConfig);
}
private function createRegistry(): StoreViewRegistry
{
$registry = $this->createMock(StoreViewRegistry::class);
$registry->method('isKnownLanguage')->willReturnCallback(static function (string $language): bool {
return in_array($language, ['en', 'de'], true);
});
$registry->method('isKnownStoreCode')->willReturnCallback(static function (string $storeCode): bool {
return in_array($storeCode, ['en_US', 'en_DE', 'de_US', 'de_DE'], true);
});
$registry->method('getLanguageByStoreCode')->willReturnCallback(static function (string $storeCode): ?string {
$map = [
'en_US' => 'en',
'en_DE' => 'en',
'de_US' => 'de',
'de_DE' => 'de',
];
return $map[$storeCode] ?? null;
});
$registry->method('getDefaultStoreCodeForLanguage')->willReturnCallback(
static function (string $language): ?string {
$map = [
'en' => 'en_US',
'de' => 'de_US',
];
return $map[$language] ?? null;
}
);
$registry->method('isLanguageInWebsite')->willReturnCallback(
static fn(string $language, int $websiteId): bool =>
$websiteId === 1 && in_array($language, ['en', 'de'], true)
);
$registry->method('isStoreCodeInWebsite')->willReturnCallback(
static fn(string $storeCode, int $websiteId): bool =>
$websiteId === 1 && in_array($storeCode, ['en_US', 'en_DE', 'de_US', 'de_DE'], true)
);
$registry->method('getStoreCodeForLanguageInWebsite')->willReturnCallback(
static function (string $language, int $websiteId): ?string {
if ($websiteId !== 1) {
return null;
}
return ['en' => 'en_US', 'de' => 'de_US'][$language] ?? null;
}
);
return $registry;
}
private function createScopeStoreManager(): StoreManagerInterface
{
$defaultStore = $this->createMock(Store::class);
$defaultStore->method('getCode')->willReturn('default_store');
$website = $this->createMock(Website::class);
$website->method('getId')->willReturn(1);
$website->method('getDefaultStore')->willReturn($defaultStore);
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->method('getWebsite')->willReturn($website);
return $storeManager;
}
private function createRequest(string $pathInfo, ?string $market): HttpRequest
{
$request = $this->getMockBuilder(HttpRequest::class)
->disableOriginalConstructor()
->onlyMethods(['getPathInfo', 'getRequestUri', 'getBaseUrl', 'getParam', 'setPathInfo', 'setParam', 'setAlias'])
->getMock();
$request->method('getPathInfo')->willReturn($pathInfo);
$request->method('getRequestUri')->willReturn($pathInfo);
$request->method('getBaseUrl')->willReturn('');
$request->method('getParam')->with('market')->willReturn($market);
return $request;
}
private function createResponse(string $expectedUrl, int $expectedStatusCode): HttpResponse
{
$response = $this->getMockBuilder(HttpResponse::class)
->disableOriginalConstructor()
->onlyMethods(['setRedirect'])
->getMock();
$response->expects(self::once())
->method('setRedirect')
->with($expectedUrl, $expectedStatusCode)
->willReturnSelf();
return $response;
}
}
@@ -0,0 +1,167 @@
<?php
declare(strict_types=1);
namespace Esun3d\LanguageUrlStoreResolver\ViewModel;
use Esun3d\LanguageUrlStoreResolver\Model\StoreViewRegistry;
use Magento\Framework\App\Config\ScopeConfigInterface;
use Magento\Framework\UrlInterface;
use Magento\Framework\View\Element\Block\ArgumentInterface;
use Magento\Store\Model\ScopeInterface;
use Magento\Store\Model\StoreManagerInterface;
class LocaleSwitcher implements ArgumentInterface
{
public function __construct(
private StoreManagerInterface $storeManager,
private StoreViewRegistry $storeViewRegistry,
private ScopeConfigInterface $scopeConfig,
private UrlInterface $urlBuilder
) {
}
/**
* @return array{markets:array<string,mixed>,currentMarket:string,currentLanguage:string}
*/
public function getConfig(): array
{
$currentWebsite = $this->storeManager->getWebsite();
$currentWebsiteCode = (string)$currentWebsite->getCode();
$currentStoreCode = (string)$this->storeManager->getStore()->getCode();
$currentLanguage = $this->storeViewRegistry->getLanguageByStoreCode($currentStoreCode) ?: '';
$relativePath = $this->getRelativeContentPath($currentWebsiteCode, $currentLanguage);
$query = $this->getCleanQuery();
$markets = [];
foreach ($this->storeManager->getWebsites(false) as $website) {
$websiteId = (int)$website->getId();
$defaultStore = $website->getDefaultStore();
if (!$defaultStore || !$defaultStore->isActive()) {
continue;
}
$defaultLanguage = $this->storeViewRegistry->getLanguageByStoreCode((string)$defaultStore->getCode());
if ($defaultLanguage === null) {
continue;
}
$languages = [];
foreach ($website->getStores() as $store) {
if (!$store->isActive()) {
continue;
}
$language = $this->storeViewRegistry->getLanguageByStoreCode((string)$store->getCode());
if ($language === null) {
continue;
}
$languages[$language] = [
'label' => (string)$store->getName(),
'storeCode' => (string)$store->getCode(),
'url' => $this->buildUrl(
$this->getWebsiteBaseUrl((string)$website->getCode()),
$language,
$defaultLanguage,
$relativePath,
$query
),
];
}
if (!$languages) {
continue;
}
$targetLanguage = isset($languages[$currentLanguage]) ? $currentLanguage : $defaultLanguage;
$markets[(string)$website->getCode()] = [
'label' => (string)$website->getName(),
'websiteId' => $websiteId,
'defaultLanguage' => $defaultLanguage,
'url' => $languages[$targetLanguage]['url'] ?? reset($languages)['url'],
'languages' => $languages,
];
}
return [
'markets' => $markets,
'currentMarket' => $currentWebsiteCode,
'currentLanguage' => $currentLanguage,
];
}
private function getRelativeContentPath(string $websiteCode, string $currentLanguage): string
{
$currentPath = trim((string)parse_url($this->getRequestUri(), PHP_URL_PATH), '/');
$basePath = trim((string)parse_url($this->getWebsiteBaseUrl($websiteCode), PHP_URL_PATH), '/');
if ($basePath !== '' && ($currentPath === $basePath || str_starts_with($currentPath, $basePath . '/'))) {
$currentPath = ltrim(substr($currentPath, strlen($basePath)), '/');
}
$segments = $currentPath === '' ? [] : explode('/', $currentPath);
if ($segments && strtolower($segments[0]) === strtolower($currentLanguage)) {
array_shift($segments);
}
return implode('/', $segments);
}
/** @return array<string,mixed> */
private function getCleanQuery(): array
{
$query = [];
parse_str((string)parse_url($this->getRequestUri(), PHP_URL_QUERY), $query);
unset($query['market'], $query['store'], $query['___store'], $query['___from_store']);
return $query;
}
private function getRequestUri(): string
{
return isset($_SERVER['REQUEST_URI'])
? (string)$_SERVER['REQUEST_URI']
: $this->urlBuilder->getCurrentUrl();
}
/** @param array<string,mixed> $query */
private function buildUrl(
string $baseUrl,
string $language,
string $defaultLanguage,
string $relativePath,
array $query
): string {
$url = rtrim($baseUrl, '/') . '/';
if ($language !== $defaultLanguage) {
$url .= rawurlencode($language) . '/';
}
if ($relativePath !== '') {
$url .= ltrim($relativePath, '/');
}
if ($query) {
$url .= '?' . http_build_query($query);
}
return $url;
}
private function getWebsiteBaseUrl(string $websiteCode): string
{
$baseUrl = (string)$this->scopeConfig->getValue(
'web/secure/base_url',
ScopeInterface::SCOPE_WEBSITE,
$websiteCode
);
if ($baseUrl === '') {
$baseUrl = (string)$this->scopeConfig->getValue(
'web/unsecure/base_url',
ScopeInterface::SCOPE_WEBSITE,
$websiteCode
);
}
return $baseUrl;
}
}
@@ -0,0 +1,15 @@
{
"name": "esun3d/module-language-url-store-resolver",
"description": "Language URL store resolver for Magento 2 / Adobe Commerce.",
"type": "magento2-module",
"version": "1.0.0",
"license": "proprietary",
"autoload": {
"files": [
"registration.php"
],
"psr-4": {
"Esun3d\\LanguageUrlStoreResolver\\": ""
}
}
}
@@ -0,0 +1,54 @@
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Config:etc/system_file.xsd">
<system>
<section id="language_url_store_resolver"
translate="label"
sortOrder="900"
showInDefault="1"
showInWebsite="1"
showInStore="1">
<label>Language URL Store Resolver</label>
<tab>general</tab>
<resource>Magento_Config::config</resource>
<group id="general"
translate="label"
sortOrder="10"
showInDefault="1"
showInWebsite="1"
showInStore="1">
<label>General</label>
<field id="enabled"
translate="label comment"
type="select"
sortOrder="10"
showInDefault="1"
showInWebsite="1"
showInStore="1">
<label>Enable Language URL Resolution</label>
<comment>Enables frontend store resolution, language-path rewriting, redirects, and URL conversion.</comment>
<source_model>Magento\Config\Model\Config\Source\Yesno</source_model>
</field>
<field id="market_cookie_name"
translate="label"
type="text"
sortOrder="20"
showInDefault="1"
showInWebsite="1"
showInStore="1">
<label>Market Cookie Name</label>
</field>
<field id="market_cookie_lifetime"
translate="label"
type="text"
sortOrder="30"
showInDefault="1"
showInWebsite="1"
showInStore="1">
<label>Market Cookie Lifetime (Seconds)</label>
<validate>validate-number validate-greater-than-zero</validate>
</field>
</group>
</section>
</system>
</config>
@@ -0,0 +1,13 @@
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="urn:magento:module:Magento_Store:etc/config.xsd">
<default>
<language_url_store_resolver>
<general>
<enabled>0</enabled>
<market_cookie_name>market</market_cookie_name>
<market_cookie_lifetime>2592000</market_cookie_lifetime>
</general>
</language_url_store_resolver>
</default>
</config>
@@ -0,0 +1,14 @@
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="urn:magento:framework:ObjectManager/etc/config.xsd">
<type name="Magento\Framework\App\FrontControllerInterface">
<plugin name="esun3d_language_url_front_controller"
type="Esun3d\LanguageUrlStoreResolver\Plugin\LanguageUrlFrontControllerPlugin"
sortOrder="5"/>
</type>
<type name="Magento\Framework\Url">
<plugin name="esun3d_language_url_url_output"
type="Esun3d\LanguageUrlStoreResolver\Plugin\UrlPlugin"
sortOrder="100"/>
</type>
</config>
@@ -0,0 +1,12 @@
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="urn:magento:framework:Event/etc/events.xsd">
<event name="controller_action_predispatch">
<observer name="vendor_language_url_add_http_context"
instance="Esun3d\LanguageUrlStoreResolver\Observer\AddHttpContextObserver"/>
</event>
<event name="controller_front_send_response_before">
<observer name="esun3d_language_url_rewrite_page_links"
instance="Esun3d\LanguageUrlStoreResolver\Observer\RewritePageLinksObserver"/>
</event>
</config>
@@ -0,0 +1,14 @@
<?xml version="1.0"?>
<!--
/**
* Copyright © Magento, Inc. All rights reserved.
* See COPYING.txt for license details.
*/
-->
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="urn:magento:framework:App/etc/routes.xsd">
<router id="standard">
<route id="switch" frontName="switch">
<module name="Esun3d_LanguageUrlStoreResolver" />
</route>
</router>
</config>
@@ -0,0 +1,11 @@
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="urn:magento:framework:Module/etc/module.xsd">
<module name="Esun3d_LanguageUrlStoreResolver">
<sequence>
<module name="Magento_Store"/>
<module name="Magento_UrlRewrite"/>
<module name="Magento_PageCache"/>
</sequence>
</module>
</config>
@@ -0,0 +1,10 @@
<?php
declare(strict_types=1);
use Magento\Framework\Component\ComponentRegistrar;
ComponentRegistrar::register(
ComponentRegistrar::MODULE,
'Esun3d_LanguageUrlStoreResolver',
__DIR__
);
@@ -0,0 +1,9 @@
var config = {
config: {
mixins: {
'mage/url': {
'Esun3d_LanguageUrlStoreResolver/js/mage-url-absolute-mixin': true
}
}
}
};
@@ -0,0 +1,207 @@
define(['jquery'], function ($) {
'use strict';
return function (config, element) {
var data = config.data || {};
var markets = data.markets || {};
var $root = $(element);
var $market = $root.find('[data-role="market"]');
var $language = $root.find('[data-role="language"]');
var $marketPicker = $root.find('[data-role="market-picker"]');
var $marketTrigger = $marketPicker.find('[data-role="market-picker-trigger"]');
var $marketMenu = $marketPicker.find('[data-role="market-picker-menu"]');
var $marketOptions = $marketPicker.find('[data-role="market-picker-option"]');
var $languagePicker = $root.find('[data-role="language-picker"]');
var $languageTrigger = $languagePicker.find('[data-role="language-picker-trigger"]');
var $languageMenu = $languagePicker.find('[data-role="language-picker-menu"]');
function closeMarketPicker() {
$marketTrigger.attr('aria-expanded', 'false');
$marketMenu.attr('hidden', true);
}
function closeLanguagePicker() {
$languageTrigger.attr('aria-expanded', 'false');
$languageMenu.attr('hidden', true);
}
function syncMarketPicker(marketCode) {
var $selected = $marketOptions.filter(function () {
return String($(this).attr('data-market-code')) === String(marketCode);
}).first();
if (!$selected.length) {
return;
}
$marketTrigger.find('[data-role="market-picker-flag"]')
.attr('src', $selected.attr('data-market-flag'));
$marketTrigger.find('[data-role="market-picker-label"]')
.text($.trim($selected.find('.market-picker__option-label').text()));
$marketOptions.attr('aria-selected', 'false');
$selected.attr('aria-selected', 'true');
}
function setStoreCookies(storeCode) {
var attributes = '; path=/; max-age=31536000; SameSite=Lax';
if (!storeCode) {
return;
}
if (window.location.protocol === 'https:') {
attributes += '; Secure';
}
document.cookie = 'market=' + encodeURIComponent(storeCode) + attributes;
document.cookie = 'store=' + encodeURIComponent(storeCode) + attributes;
}
function getLanguage(marketCode, languageCode) {
var market = markets[String(marketCode)];
return market && market.languages[String(languageCode)];
}
function renderLanguages(marketCode, selectedLanguage) {
var market = markets[marketCode];
$language.empty();
$languageMenu.empty();
if (!market) {
return;
}
$.each(market.languages, function (languageCode, language) {
$('<option/>', {
value: languageCode,
text: language.label,
selected: languageCode === selectedLanguage
}).appendTo($language);
$('<button/>', {
'aria-selected': languageCode === selectedLanguage ? 'true' : 'false',
'class': 'market-picker__option',
'data-language-code': languageCode,
'data-role': 'language-picker-option',
'role': 'option',
'type': 'button'
}).append($('<span/>', {
'class': 'market-picker__option-label',
'text': language.label
})).appendTo($languageMenu);
});
syncLanguagePicker(selectedLanguage);
}
function syncLanguagePicker(languageCode) {
var $options = $languageMenu.find('[data-role="language-picker-option"]');
var $selected = $options.filter(function () {
return String($(this).attr('data-language-code')) === String(languageCode);
}).first();
if (!$selected.length) {
return;
}
$languageTrigger.find('[data-role="language-picker-label"]')
.text($.trim($selected.find('.market-picker__option-label').text()));
$options.attr('aria-selected', 'false');
$selected.attr('aria-selected', 'true');
}
$market.val(data.currentMarket || '');
syncMarketPicker(data.currentMarket || '');
renderLanguages(data.currentMarket || '', data.currentLanguage || '');
setStoreCookies(
(getLanguage(data.currentMarket || '', data.currentLanguage || '') || {}).storeCode
);
$market.on('change', function () {
var market = markets[String($(this).val())];
syncMarketPicker($(this).val());
if (market && market.url) {
window.location.assign(market.url);
}
});
$marketTrigger.on('click', function (event) {
var isOpen = $(this).attr('aria-expanded') === 'true';
event.preventDefault();
event.stopPropagation();
closeLanguagePicker();
if (isOpen) {
closeMarketPicker();
} else {
$(this).attr('aria-expanded', 'true');
$marketMenu.removeAttr('hidden');
}
});
$marketOptions.on('click', function (event) {
var marketCode = String($(this).attr('data-market-code') || '');
event.preventDefault();
event.stopPropagation();
closeMarketPicker();
$market.val(marketCode).trigger('change');
});
$languageTrigger.on('click', function (event) {
var isOpen = $(this).attr('aria-expanded') === 'true';
event.preventDefault();
event.stopPropagation();
closeMarketPicker();
if (isOpen) {
closeLanguagePicker();
} else {
$(this).attr('aria-expanded', 'true');
$languageMenu.removeAttr('hidden');
}
});
$languageMenu.on('click', '[data-role="language-picker-option"]', function (event) {
var languageCode = String($(this).attr('data-language-code') || '');
event.preventDefault();
event.stopPropagation();
closeLanguagePicker();
$language.val(languageCode).trigger('change');
});
$(document).on('click.localeSwitcherMarket', function (event) {
if (!$(event.target).closest($marketPicker).length) {
closeMarketPicker();
}
if (!$(event.target).closest($languagePicker).length) {
closeLanguagePicker();
}
});
$marketTrigger.add($marketOptions).on('keydown', function (event) {
if (event.key === 'Escape') {
closeMarketPicker();
$marketTrigger.trigger('focus');
}
});
$languagePicker.on('keydown', '[data-role="language-picker-trigger"], [data-role="language-picker-option"]', function (event) {
if (event.key === 'Escape') {
closeLanguagePicker();
$languageTrigger.trigger('focus');
}
});
$language.on('change', function () {
var language = getLanguage($market.val(), $(this).val());
syncLanguagePicker($(this).val());
if (language && language.url) {
setStoreCookies(language.storeCode);
window.location.assign(language.url);
}
});
};
});
@@ -0,0 +1,24 @@
define([], function () {
'use strict';
return function (url) {
var originalBuild;
if (!url || url._esunAbsoluteUrlBuildGuard || typeof url.build !== 'function') {
return url;
}
originalBuild = url.build;
url._esunAbsoluteUrlBuildGuard = true;
url.build = function (path) {
if (typeof path === 'string' && /^(https?:)?\/\//i.test(path)) {
return path;
}
return originalBuild.apply(this, arguments);
};
return url;
};
});