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,24 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Block\Adminhtml\System\Config;
use Magento\Config\Block\System\Config\Form\Field;
use Magento\Framework\Data\Form\Element\AbstractElement;
class TestIp extends Field
{
protected $_template = 'Esun3d_GeoWebsiteRedirect::system/config/test_ip.phtml';
protected function _getElementHtml(AbstractElement $element): string
{
$this->setData('element', $element);
return $this->_toHtml();
}
public function getResolveUrl(): string
{
return $this->getUrl('geo_website_redirect/test/resolve');
}
}
@@ -0,0 +1,48 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Controller\Adminhtml\Test;
use Esun3d\GeoWebsiteRedirect\Model\TestIpService;
use Magento\Backend\App\Action;
use Magento\Backend\App\Action\Context;
use Magento\Framework\App\Action\HttpPostActionInterface;
use Magento\Framework\Controller\Result\Json;
use Magento\Framework\Controller\Result\JsonFactory;
use Magento\Framework\Exception\LocalizedException;
use Psr\Log\LoggerInterface;
class Resolve extends Action implements HttpPostActionInterface
{
public const ADMIN_RESOURCE = 'Esun3d_GeoWebsiteRedirect::config';
public function __construct(
Context $context,
private JsonFactory $jsonFactory,
private TestIpService $testIpService,
private LoggerInterface $logger
) {
parent::__construct($context);
}
public function execute(): Json
{
$result = $this->jsonFactory->create();
try {
return $result->setData([
'success' => true,
'data' => $this->testIpService->execute((string)$this->getRequest()->getParam('ip')),
]);
} catch (LocalizedException $exception) {
return $result->setData(['success' => false, 'message' => $exception->getMessage()]);
} catch (\Throwable $exception) {
$this->logger->error('[GeoWebsiteRedirect] Admin IP test failed.', ['exception' => $exception]);
return $result->setData([
'success' => false,
'message' => (string)__('The IP test could not be completed. Check the logs and try again.'),
]);
}
}
}
@@ -0,0 +1,26 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
class BotDetector
{
public function __construct(private Config $config)
{
}
public function isBot(string $userAgent): bool
{
if (!$this->config->shouldIgnoreBots() || $userAgent === '') {
return false;
}
foreach ($this->config->getIgnoredUserAgentPatterns() as $pattern) {
if ($pattern !== '' && stripos($userAgent, $pattern) !== false) {
return true;
}
}
return false;
}
}
@@ -0,0 +1,127 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
use Magento\Framework\App\Config\ScopeConfigInterface;
class Config
{
public const COOKIE_NAME = 'geo_website_choice';
public const REDIRECT_SCOPE_HOMEPAGE = 'homepage';
public const REDIRECT_SCOPE_ALL = 'all';
private const XML_PATH_ENABLED = 'geo_website_redirect/general/enabled';
private const XML_PATH_REDIRECT_SCOPE = 'geo_website_redirect/general/redirect_scope';
private const XML_PATH_PRESERVE_PATH = 'geo_website_redirect/general/preserve_path';
private const XML_PATH_COOKIE_LIFETIME = 'geo_website_redirect/general/cookie_lifetime';
private const XML_PATH_COOKIE_DOMAIN = 'geo_website_redirect/general/cookie_domain';
private const XML_PATH_UK_WEBSITE = 'geo_website_redirect/mapping/uk_website';
private const XML_PATH_AU_WEBSITE = 'geo_website_redirect/mapping/au_website';
private const XML_PATH_EU_WEBSITE = 'geo_website_redirect/mapping/eu_website';
private const XML_PATH_DEFAULT_WEBSITE = 'geo_website_redirect/mapping/default_website';
private const XML_PATH_EU_COUNTRIES = 'geo_website_redirect/mapping/eu_countries';
private const XML_PATH_IGNORE_BOTS = 'geo_website_redirect/exclusions/ignore_bots';
private const XML_PATH_USER_AGENTS = 'geo_website_redirect/exclusions/user_agents';
private const XML_PATH_EXCLUDED_PATHS = 'geo_website_redirect/exclusions/paths';
private const DEFAULT_COOKIE_LIFETIME = 2592000;
public function __construct(private ScopeConfigInterface $scopeConfig)
{
}
public function isEnabled(): bool
{
return $this->scopeConfig->isSetFlag(self::XML_PATH_ENABLED);
}
public function getRedirectScope(): string
{
$scope = (string)$this->scopeConfig->getValue(self::XML_PATH_REDIRECT_SCOPE);
return $scope === self::REDIRECT_SCOPE_ALL ? self::REDIRECT_SCOPE_ALL : self::REDIRECT_SCOPE_HOMEPAGE;
}
public function shouldPreservePath(): bool
{
return $this->scopeConfig->isSetFlag(self::XML_PATH_PRESERVE_PATH);
}
public function getCookieLifetime(): int
{
$lifetime = (int)$this->scopeConfig->getValue(self::XML_PATH_COOKIE_LIFETIME);
return $lifetime > 0 ? $lifetime : self::DEFAULT_COOKIE_LIFETIME;
}
public function getCookieDomain(): string
{
return trim((string)$this->scopeConfig->getValue(self::XML_PATH_COOKIE_DOMAIN));
}
public function getUkWebsiteCode(): string
{
return trim((string)$this->scopeConfig->getValue(self::XML_PATH_UK_WEBSITE));
}
public function getAuWebsiteCode(): string
{
return trim((string)$this->scopeConfig->getValue(self::XML_PATH_AU_WEBSITE));
}
public function getEuWebsiteCode(): string
{
return trim((string)$this->scopeConfig->getValue(self::XML_PATH_EU_WEBSITE));
}
public function getDefaultWebsiteCode(): string
{
return trim((string)$this->scopeConfig->getValue(self::XML_PATH_DEFAULT_WEBSITE));
}
/** @return string[] */
public function getEuCountryCodes(): array
{
return $this->parseCodes((string)$this->scopeConfig->getValue(self::XML_PATH_EU_COUNTRIES));
}
public function shouldIgnoreBots(): bool
{
return $this->scopeConfig->isSetFlag(self::XML_PATH_IGNORE_BOTS);
}
/** @return string[] */
public function getIgnoredUserAgentPatterns(): array
{
return $this->parseLines((string)$this->scopeConfig->getValue(self::XML_PATH_USER_AGENTS));
}
/** @return string[] */
public function getExcludedPathPrefixes(): array
{
return array_map(
static fn (string $path): string => strtolower(trim($path, "/ \t\n\r\0\x0B")),
$this->parseLines((string)$this->scopeConfig->getValue(self::XML_PATH_EXCLUDED_PATHS))
);
}
/** @return string[] */
private function parseCodes(string $value): array
{
$codes = preg_split('/[\s,]+/', strtoupper(trim($value)), -1, PREG_SPLIT_NO_EMPTY) ?: [];
return array_values(array_unique(array_filter(
$codes,
static fn (string $code): bool => (bool)preg_match('/^[A-Z]{2}$/', $code)
)));
}
/** @return string[] */
private function parseLines(string $value): array
{
$lines = preg_split('/\R+/', trim($value), -1, PREG_SPLIT_NO_EMPTY) ?: [];
return array_values(array_filter(array_map('trim', $lines), 'strlen'));
}
}
@@ -0,0 +1,18 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model\Config\Source;
use Esun3d\GeoWebsiteRedirect\Model\Config;
use Magento\Framework\Data\OptionSourceInterface;
class RedirectScope implements OptionSourceInterface
{
public function toOptionArray(): array
{
return [
['value' => Config::REDIRECT_SCOPE_HOMEPAGE, 'label' => __('Homepage Only')],
['value' => Config::REDIRECT_SCOPE_ALL, 'label' => __('All Pages')],
];
}
}
@@ -0,0 +1,27 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model\Config\Source;
use Magento\Framework\Data\OptionSourceInterface;
use Magento\Store\Model\StoreManagerInterface;
class Website implements OptionSourceInterface
{
public function __construct(private StoreManagerInterface $storeManager)
{
}
public function toOptionArray(): array
{
$options = [];
foreach ($this->storeManager->getWebsites(false) as $website) {
$options[] = [
'label' => (string)$website->getName(),
'value' => (string)$website->getCode(),
];
}
return $options;
}
}
@@ -0,0 +1,38 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
use Amasty\Geoip\Model\Geolocation;
use Magento\Framework\HTTP\PhpEnvironment\RemoteAddress;
use Psr\Log\LoggerInterface;
class CountryResolver
{
public function __construct(
private Geolocation $geolocation,
private RemoteAddress $remoteAddress,
private LoggerInterface $logger
) {
}
public function resolve(): ?string
{
try {
$ip = (string)$this->remoteAddress->getRemoteAddress();
if ($ip === '') {
return null;
}
$country = strtoupper(trim((string)$this->geolocation->locate($ip)->getData('country')));
return preg_match('/^[A-Z]{2}$/', $country) ? $country : null;
} catch (\Throwable $exception) {
$this->logger->error('[GeoWebsiteRedirect] Failed to resolve the visitor country.', [
'exception' => $exception,
]);
return null;
}
}
}
@@ -0,0 +1,72 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
use Amasty\Geoip\Helper\Data as GeoipHelper;
use Magento\Framework\App\ResourceConnection;
use Magento\Framework\DB\Select;
class ExplicitIpLookup
{
public function __construct(
private GeoipHelper $geoipHelper,
private ResourceConnection $resource
) {
}
/** @return array<string, mixed>|null */
public function lookup(string $ip): ?array
{
$isIpv6 = (bool)filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6);
$maskedIp = $this->maskIp($ip, $isIpv6 ? ':' : '.');
if (!$this->geoipHelper->isDone(false)) {
return null;
}
$longIp = $isIpv6
? $this->geoipHelper->getLongIpV6($maskedIp)
: sprintf('%u', ip2long($maskedIp));
if (empty($longIp)) {
return null;
}
$connection = $this->resource->getConnection('read');
$blockTable = $isIpv6 ? 'amasty_geoip_block_v6' : 'amasty_geoip_block';
$blockSelect = $connection->select()
->from($this->resource->getTableName($blockTable))
->reset(Select::COLUMNS)
->columns(['geoip_loc_id', 'latitude', 'longitude'])
->where('start_ip_num <= ?', $longIp)
->order('start_ip_num DESC')
->limit(1);
$select = $connection->select()
->from(['b' => $blockSelect])
->joinInner(
['l' => $this->resource->getTableName('amasty_geoip_location')],
'l.geoip_loc_id = b.geoip_loc_id',
null
)
->reset(Select::COLUMNS)
->columns(['l.*', 'b.latitude', 'b.longitude']);
$result = $connection->fetchRow($select);
if (!$result) {
return null;
}
$result['masked_ip'] = $maskedIp;
return $result;
}
private function maskIp(string $ip, string $separator): string
{
$parts = explode($separator, $ip);
array_pop($parts);
$parts[] = '0';
return implode($separator, $parts);
}
}
@@ -0,0 +1,45 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
use Magento\Framework\App\RequestInterface;
use Magento\Framework\Stdlib\Cookie\CookieMetadata;
use Magento\Framework\Stdlib\Cookie\CookieMetadataFactory;
use Magento\Framework\Stdlib\CookieManagerInterface;
class RedirectCookie
{
public function __construct(
private Config $config,
private CookieManagerInterface $cookieManager,
private CookieMetadataFactory $cookieMetadataFactory,
private RequestInterface $request
) {
}
public function hasSelection(): bool
{
return trim((string)$this->cookieManager->getCookie(Config::COOKIE_NAME)) !== '';
}
public function set(string $websiteCode): void
{
$metadata = $this->cookieMetadataFactory->createPublicCookieMetadata([
CookieMetadata::KEY_DURATION => $this->config->getCookieLifetime(),
CookieMetadata::KEY_SAME_SITE => 'Lax',
]);
$metadata->setPath('/');
$metadata->setHttpOnly(false);
$domain = $this->config->getCookieDomain();
if ($domain !== '') {
$metadata->setDomain($domain);
}
if (method_exists($this->request, 'isSecure')) {
$metadata->setSecure((bool)$this->request->isSecure());
}
$this->cookieManager->setPublicCookie(Config::COOKIE_NAME, $websiteCode, $metadata);
}
}
@@ -0,0 +1,40 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
use Magento\Framework\App\Request\Http;
class RedirectEligibility
{
public function __construct(
private Config $config,
private BotDetector $botDetector,
private RedirectCookie $redirectCookie
) {
}
public function canRedirect(Http $request): bool
{
if (!$this->config->isEnabled() || $this->redirectCookie->hasSelection()) {
return false;
}
if (!in_array(strtoupper($request->getMethod()), ['GET', 'HEAD'], true) || $request->isAjax()) {
return false;
}
$path = strtolower(trim($request->getPathInfo(), '/'));
if ($this->config->getRedirectScope() === Config::REDIRECT_SCOPE_HOMEPAGE && $path !== '') {
return false;
}
foreach ($this->config->getExcludedPathPrefixes() as $prefix) {
if ($prefix !== '' && ($path === $prefix || str_starts_with($path, $prefix . '/'))) {
return false;
}
}
return !$this->botDetector->isBot((string)$request->getServer('HTTP_USER_AGENT'));
}
}
@@ -0,0 +1,45 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
use Magento\Framework\App\Request\Http;
use Magento\Framework\UrlInterface;
use Magento\Store\Model\StoreManagerInterface;
class TargetUrlBuilder
{
public function __construct(
private Config $config,
private StoreManagerInterface $storeManager
) {
}
public function build(string $websiteCode, Http $request): ?string
{
$website = $this->storeManager->getWebsite($websiteCode);
$defaultStore = $website->getDefaultStore();
if (!$defaultStore || !$defaultStore->isActive()) {
return null;
}
$url = rtrim($defaultStore->getBaseUrl(UrlInterface::URL_TYPE_LINK, $request->isSecure()), '/') . '/';
if (!$this->config->shouldPreservePath()) {
return $url;
}
$path = ltrim($request->getPathInfo(), '/');
if ($path !== '') {
$url .= $path;
}
$query = [];
parse_str((string)$request->getServer('QUERY_STRING'), $query);
unset($query['market'], $query['store'], $query['___store'], $query['___from_store']);
if ($query) {
$url .= '?' . http_build_query($query);
}
return $url;
}
}
@@ -0,0 +1,57 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
use Amasty\Geoip\Helper\Data as GeoipHelper;
use Magento\Framework\Exception\LocalizedException;
use Magento\Framework\UrlInterface;
use Magento\Store\Model\StoreManagerInterface;
class TestIpService
{
public function __construct(
private ExplicitIpLookup $ipLookup,
private WebsiteResolver $websiteResolver,
private StoreManagerInterface $storeManager,
private GeoipHelper $geoipHelper
) {
}
/** @return array<string, mixed> */
public function execute(string $ip): array
{
$ip = trim($ip);
if (!filter_var($ip, FILTER_VALIDATE_IP)) {
throw new LocalizedException(__('Enter a valid IPv4 or IPv6 address.'));
}
$location = $this->ipLookup->lookup($ip);
$country = strtoupper(trim((string)($location['country'] ?? '')));
if (!$location || !preg_match('/^[A-Z]{2}$/', $country)) {
throw new LocalizedException(__('No GeoIP record was found for this IP address.'));
}
$websiteCode = $this->websiteResolver->resolve($country);
if ($websiteCode === null) {
throw new LocalizedException(__('No website is configured for country %1.', $country));
}
$website = $this->storeManager->getWebsite($websiteCode);
$defaultStore = $website->getDefaultStore();
if (!$defaultStore || !$defaultStore->isActive()) {
throw new LocalizedException(__('Website %1 has no active default store.', $websiteCode));
}
return [
'ip' => $ip,
'masked_ip' => (string)$location['masked_ip'],
'country' => $country,
'city' => (string)($location['city'] ?? ''),
'website_code' => $websiteCode,
'website_name' => (string)$website->getName(),
'target_url' => rtrim($defaultStore->getBaseUrl(UrlInterface::URL_TYPE_LINK, true), '/') . '/',
'force_ip_enabled' => $this->geoipHelper->isForcedIpEnabled(),
];
}
}
@@ -0,0 +1,36 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Model;
class WebsiteResolver
{
public function __construct(private Config $config)
{
}
public function resolve(string $countryCode): ?string
{
$countryCode = strtoupper(trim($countryCode));
if (!preg_match('/^[A-Z]{2}$/', $countryCode)) {
return null;
}
if ($countryCode === 'GB') {
return $this->valueOrNull($this->config->getUkWebsiteCode());
}
if ($countryCode === 'AU') {
return $this->valueOrNull($this->config->getAuWebsiteCode());
}
if (in_array($countryCode, $this->config->getEuCountryCodes(), true)) {
return $this->valueOrNull($this->config->getEuWebsiteCode());
}
return $this->valueOrNull($this->config->getDefaultWebsiteCode());
}
private function valueOrNull(string $value): ?string
{
return $value !== '' ? $value : null;
}
}
@@ -0,0 +1,76 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Plugin;
use Esun3d\GeoWebsiteRedirect\Model\CountryResolver;
use Esun3d\GeoWebsiteRedirect\Model\RedirectCookie;
use Esun3d\GeoWebsiteRedirect\Model\RedirectEligibility;
use Esun3d\GeoWebsiteRedirect\Model\TargetUrlBuilder;
use Esun3d\GeoWebsiteRedirect\Model\WebsiteResolver;
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;
class FrontControllerPlugin
{
public function __construct(
private RedirectEligibility $eligibility,
private CountryResolver $countryResolver,
private WebsiteResolver $websiteResolver,
private TargetUrlBuilder $targetUrlBuilder,
private RedirectCookie $redirectCookie,
private StoreManagerInterface $storeManager,
private HttpResponse $response,
private LoggerInterface $logger
) {
}
public function aroundDispatch(
FrontControllerInterface $subject,
callable $proceed,
RequestInterface $request
) {
if (!$request instanceof HttpRequest || !$this->eligibility->canRedirect($request)) {
return $proceed($request);
}
try {
$countryCode = $this->countryResolver->resolve();
if ($countryCode === null) {
return $proceed($request);
}
$targetWebsite = $this->websiteResolver->resolve($countryCode);
if ($targetWebsite === null) {
return $proceed($request);
}
if ((string)$this->storeManager->getWebsite()->getCode() === $targetWebsite) {
$this->redirectCookie->set($targetWebsite);
return $proceed($request);
}
$targetUrl = $this->targetUrlBuilder->build($targetWebsite, $request);
if ($targetUrl === null) {
return $proceed($request);
}
$this->redirectCookie->set($targetWebsite);
$this->response->setRedirect($targetUrl, 302);
$this->response->setHeader('Cache-Control', 'private, no-store, max-age=0', true);
return $this->response;
} catch (\Throwable $exception) {
$this->logger->error('[GeoWebsiteRedirect] Failed to redirect the visitor.', [
'exception' => $exception,
]);
return $proceed($request);
}
}
}
@@ -0,0 +1,26 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Plugin;
use Esun3d\GeoWebsiteRedirect\Model\Config;
use Esun3d\LanguageUrlStoreResolver\ViewModel\LocaleSwitcher;
class LocaleSwitcherConfigPlugin
{
public function __construct(private Config $config)
{
}
public function afterGetConfig(LocaleSwitcher $subject, array $result): array
{
$result['geoRedirect'] = [
'enabled' => $this->config->isEnabled(),
'cookieName' => Config::COOKIE_NAME,
'cookieLifetime' => $this->config->getCookieLifetime(),
'cookieDomain' => $this->config->getCookieDomain(),
];
return $result;
}
}
@@ -0,0 +1,31 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Test\Unit\Model;
use Esun3d\GeoWebsiteRedirect\Model\BotDetector;
use Esun3d\GeoWebsiteRedirect\Model\Config;
use PHPUnit\Framework\TestCase;
class BotDetectorTest extends TestCase
{
public function testMatchesConfiguredPatternCaseInsensitively(): void
{
$config = $this->createMock(Config::class);
$config->method('shouldIgnoreBots')->willReturn(true);
$config->method('getIgnoredUserAgentPatterns')->willReturn(['googlebot', 'spider']);
$detector = new BotDetector($config);
self::assertTrue($detector->isBot('Mozilla/5.0 compatible; GoogleBot/2.1'));
self::assertFalse($detector->isBot('Mozilla/5.0 Chrome/140.0'));
}
public function testDoesNotIgnoreBotsWhenDisabled(): void
{
$config = $this->createMock(Config::class);
$config->method('shouldIgnoreBots')->willReturn(false);
self::assertFalse((new BotDetector($config))->isBot('Googlebot/2.1'));
}
}
@@ -0,0 +1,49 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Test\Unit\Model;
use Esun3d\GeoWebsiteRedirect\Model\Config;
use Magento\Framework\App\Config\ScopeConfigInterface;
use PHPUnit\Framework\TestCase;
class ConfigTest extends TestCase
{
public function testParsesAndValidatesEuCountryCodes(): void
{
$config = $this->createConfig([
'geo_website_redirect/mapping/eu_countries' => "de, FR\ninvalid es DE",
]);
self::assertSame(['DE', 'FR', 'ES'], $config->getEuCountryCodes());
}
public function testNormalizesExcludedPaths(): void
{
$config = $this->createConfig([
'geo_website_redirect/exclusions/paths' => "/Checkout\n REST/ ",
]);
self::assertSame(['checkout', 'rest'], $config->getExcludedPathPrefixes());
}
public function testInvalidCookieLifetimeFallsBackToThirtyDays(): void
{
$config = $this->createConfig([
'geo_website_redirect/general/cookie_lifetime' => '0',
]);
self::assertSame(2592000, $config->getCookieLifetime());
}
/** @param array<string,string> $values */
private function createConfig(array $values): Config
{
$scopeConfig = $this->createMock(ScopeConfigInterface::class);
$scopeConfig->method('getValue')->willReturnCallback(
static fn (string $path): ?string => $values[$path] ?? null
);
return new Config($scopeConfig);
}
}
@@ -0,0 +1,63 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Test\Unit\Model;
use Esun3d\GeoWebsiteRedirect\Model\BotDetector;
use Esun3d\GeoWebsiteRedirect\Model\Config;
use Esun3d\GeoWebsiteRedirect\Model\RedirectCookie;
use Esun3d\GeoWebsiteRedirect\Model\RedirectEligibility;
use Magento\Framework\App\Request\Http;
use PHPUnit\Framework\TestCase;
class RedirectEligibilityTest extends TestCase
{
public function testAllowsFirstNormalHomepageRequest(): void
{
self::assertTrue($this->createEligibility()->canRedirect($this->createRequest('/', 'Mozilla/5.0')));
}
public function testRejectsBotRequest(): void
{
self::assertFalse($this->createEligibility(true)->canRedirect($this->createRequest('/', 'Googlebot/2.1')));
}
public function testRejectsRequestWhenSelectionCookieExists(): void
{
self::assertFalse($this->createEligibility(false, true)->canRedirect($this->createRequest('/', 'Mozilla/5.0')));
}
public function testRejectsDeepPathInHomepageMode(): void
{
self::assertFalse(
$this->createEligibility()->canRedirect($this->createRequest('/pla-filament/product-a', 'Mozilla/5.0'))
);
}
private function createEligibility(bool $isBot = false, bool $hasSelection = false): RedirectEligibility
{
$config = $this->createMock(Config::class);
$config->method('isEnabled')->willReturn(true);
$config->method('getRedirectScope')->willReturn(Config::REDIRECT_SCOPE_HOMEPAGE);
$config->method('getExcludedPathPrefixes')->willReturn(['checkout', 'rest']);
$botDetector = $this->createMock(BotDetector::class);
$botDetector->method('isBot')->willReturn($isBot);
$cookie = $this->createMock(RedirectCookie::class);
$cookie->method('hasSelection')->willReturn($hasSelection);
return new RedirectEligibility($config, $botDetector, $cookie);
}
private function createRequest(string $path, string $userAgent): Http
{
$request = $this->createMock(Http::class);
$request->method('getMethod')->willReturn('GET');
$request->method('isAjax')->willReturn(false);
$request->method('getPathInfo')->willReturn($path);
$request->method('getServer')->with('HTTP_USER_AGENT')->willReturn($userAgent);
return $request;
}
}
@@ -0,0 +1,79 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Test\Unit\Model;
use Amasty\Geoip\Helper\Data as GeoipHelper;
use Esun3d\GeoWebsiteRedirect\Model\ExplicitIpLookup;
use Esun3d\GeoWebsiteRedirect\Model\TestIpService;
use Esun3d\GeoWebsiteRedirect\Model\WebsiteResolver;
use Magento\Framework\Exception\LocalizedException;
use Magento\Store\Model\Store;
use Magento\Store\Model\StoreManagerInterface;
use Magento\Store\Model\Website;
use PHPUnit\Framework\MockObject\MockObject;
use PHPUnit\Framework\TestCase;
class TestIpServiceTest extends TestCase
{
private ExplicitIpLookup&MockObject $ipLookup;
private WebsiteResolver&MockObject $websiteResolver;
private StoreManagerInterface&MockObject $storeManager;
private GeoipHelper&MockObject $geoipHelper;
private TestIpService $service;
protected function setUp(): void
{
$this->ipLookup = $this->createMock(ExplicitIpLookup::class);
$this->websiteResolver = $this->createMock(WebsiteResolver::class);
$this->storeManager = $this->createMock(StoreManagerInterface::class);
$this->geoipHelper = $this->createMock(GeoipHelper::class);
$this->service = new TestIpService(
$this->ipLookup,
$this->websiteResolver,
$this->storeManager,
$this->geoipHelper
);
}
public function testRejectsInvalidIp(): void
{
$this->ipLookup->expects($this->never())->method('lookup');
$this->expectException(LocalizedException::class);
$this->expectExceptionMessage('Enter a valid IPv4 or IPv6 address.');
$this->service->execute('not-an-ip');
}
public function testReturnsResolvedWebsiteDetails(): void
{
$this->ipLookup->expects($this->once())->method('lookup')->with('2.16.34.1')->willReturn([
'country' => 'GB',
'city' => 'London',
'masked_ip' => '2.16.34.0',
]);
$this->websiteResolver->expects($this->once())->method('resolve')->with('GB')->willReturn('uk');
$store = $this->createMock(Store::class);
$store->method('isActive')->willReturn(true);
$store->method('getBaseUrl')->willReturn('https://www.example.co.uk/');
$website = $this->createMock(Website::class);
$website->method('getDefaultStore')->willReturn($store);
$website->method('getName')->willReturn('United Kingdom');
$this->storeManager->expects($this->once())->method('getWebsite')->with('uk')->willReturn($website);
$this->geoipHelper->method('isForcedIpEnabled')->willReturn(true);
$this->assertSame([
'ip' => '2.16.34.1',
'masked_ip' => '2.16.34.0',
'country' => 'GB',
'city' => 'London',
'website_code' => 'uk',
'website_name' => 'United Kingdom',
'target_url' => 'https://www.example.co.uk/',
'force_ip_enabled' => true,
], $this->service->execute('2.16.34.1'));
}
}
@@ -0,0 +1,37 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Test\Unit\Model;
use Esun3d\GeoWebsiteRedirect\Model\Config;
use Esun3d\GeoWebsiteRedirect\Model\WebsiteResolver;
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\TestCase;
class WebsiteResolverTest extends TestCase
{
#[DataProvider('countryProvider')]
public function testResolvesCountryToWebsite(string $country, ?string $expected): void
{
$config = $this->createMock(Config::class);
$config->method('getUkWebsiteCode')->willReturn('uk');
$config->method('getAuWebsiteCode')->willReturn('au');
$config->method('getEuWebsiteCode')->willReturn('eu');
$config->method('getDefaultWebsiteCode')->willReturn('us_site');
$config->method('getEuCountryCodes')->willReturn(['DE', 'FR', 'ES']);
self::assertSame($expected, (new WebsiteResolver($config))->resolve($country));
}
public static function countryProvider(): array
{
return [
'United Kingdom' => ['GB', 'uk'],
'Australia' => ['AU', 'au'],
'EU member' => ['DE', 'eu'],
'default market' => ['US', 'us_site'],
'lowercase input' => ['fr', 'eu'],
'invalid country' => ['', null],
];
}
}
@@ -0,0 +1,66 @@
<?php
declare(strict_types=1);
namespace Esun3d\GeoWebsiteRedirect\Test\Unit\Plugin;
use Esun3d\GeoWebsiteRedirect\Model\CountryResolver;
use Esun3d\GeoWebsiteRedirect\Model\RedirectCookie;
use Esun3d\GeoWebsiteRedirect\Model\RedirectEligibility;
use Esun3d\GeoWebsiteRedirect\Model\TargetUrlBuilder;
use Esun3d\GeoWebsiteRedirect\Model\WebsiteResolver;
use Esun3d\GeoWebsiteRedirect\Plugin\FrontControllerPlugin;
use Magento\Framework\App\FrontControllerInterface;
use Magento\Framework\App\Request\Http as HttpRequest;
use Magento\Framework\App\Response\Http as HttpResponse;
use Magento\Store\Api\Data\WebsiteInterface;
use Magento\Store\Model\StoreManagerInterface;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
class FrontControllerPluginTest extends TestCase
{
public function testRedirectsToResolvedWebsiteWithoutCallingFrontController(): void
{
$request = $this->createMock(HttpRequest::class);
$eligibility = $this->createMock(RedirectEligibility::class);
$eligibility->method('canRedirect')->with($request)->willReturn(true);
$countryResolver = $this->createMock(CountryResolver::class);
$countryResolver->method('resolve')->willReturn('GB');
$websiteResolver = $this->createMock(WebsiteResolver::class);
$websiteResolver->method('resolve')->with('GB')->willReturn('uk');
$targetUrlBuilder = $this->createMock(TargetUrlBuilder::class);
$targetUrlBuilder->method('build')->with('uk', $request)->willReturn('https://en.example.test/');
$cookie = $this->createMock(RedirectCookie::class);
$cookie->expects(self::once())->method('set')->with('uk');
$currentWebsite = $this->createMock(WebsiteInterface::class);
$currentWebsite->method('getCode')->willReturn('us_site');
$storeManager = $this->createMock(StoreManagerInterface::class);
$storeManager->method('getWebsite')->willReturn($currentWebsite);
$response = $this->createMock(HttpResponse::class);
$response->expects(self::once())->method('setRedirect')->with('https://en.example.test/', 302);
$response->expects(self::once())
->method('setHeader')
->with('Cache-Control', 'private, no-store, max-age=0', true);
$plugin = new FrontControllerPlugin(
$eligibility,
$countryResolver,
$websiteResolver,
$targetUrlBuilder,
$cookie,
$storeManager,
$response,
$this->createMock(LoggerInterface::class)
);
$result = $plugin->aroundDispatch(
$this->createMock(FrontControllerInterface::class),
static fn () => throw new \LogicException('Front controller must not be called.'),
$request
);
self::assertSame($response, $result);
}
}
@@ -0,0 +1,19 @@
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="urn:magento:framework:Acl/etc/acl.xsd">
<acl>
<resources>
<resource id="Magento_Backend::admin">
<resource id="Magento_Backend::stores">
<resource id="Magento_Backend::stores_settings">
<resource id="Magento_Config::config">
<resource id="Esun3d_GeoWebsiteRedirect::config"
title="Geo Website Redirect Configuration"
sortOrder="90"/>
</resource>
</resource>
</resource>
</resource>
</resources>
</acl>
</config>
@@ -0,0 +1,9 @@
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="urn:magento:framework:App/etc/routes.xsd">
<router id="admin">
<route id="geo_website_redirect" frontName="geo_website_redirect">
<module name="Esun3d_GeoWebsiteRedirect"/>
</route>
</router>
</config>
@@ -0,0 +1,104 @@
<?xml version="1.0"?>
<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="urn:magento:framework:Config/etc/system_file.xsd">
<system>
<section id="geo_website_redirect"
translate="label"
sortOrder="910"
showInDefault="1"
showInWebsite="0"
showInStore="0">
<label>Geo Website Redirect</label>
<tab>general</tab>
<resource>Esun3d_GeoWebsiteRedirect::config</resource>
<group id="general" translate="label" sortOrder="10" showInDefault="1" showInWebsite="0" showInStore="0">
<label>General</label>
<field id="enabled" translate="label comment" type="select" sortOrder="10" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Enable Geo Website Redirect</label>
<comment>Redirects first-time visitors according to the country resolved from their IP address.</comment>
<source_model>Magento\Config\Model\Config\Source\Yesno</source_model>
</field>
<field id="redirect_scope" translate="label comment" type="select" sortOrder="20" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Redirect Scope</label>
<comment>Homepage Only is recommended to avoid breaking deep links.</comment>
<source_model>Esun3d\GeoWebsiteRedirect\Model\Config\Source\RedirectScope</source_model>
<depends>
<field id="enabled">1</field>
</depends>
</field>
<field id="preserve_path" translate="label comment" type="select" sortOrder="30" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Preserve Request Path</label>
<comment>Enable only when URL keys are consistent across websites.</comment>
<source_model>Magento\Config\Model\Config\Source\Yesno</source_model>
<depends>
<field id="enabled">1</field>
<field id="redirect_scope">all</field>
</depends>
</field>
<field id="cookie_lifetime" translate="label" type="text" sortOrder="40" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Selection Cookie Lifetime (Seconds)</label>
<validate>required-entry validate-number validate-greater-than-zero</validate>
<depends>
<field id="enabled">1</field>
</depends>
</field>
<field id="cookie_domain" translate="label comment" type="text" sortOrder="50" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Selection Cookie Domain</label>
<comment>Use the shared parent domain, for example .esun3d.com. Leave blank for a host-only cookie.</comment>
<depends>
<field id="enabled">1</field>
</depends>
</field>
</group>
<group id="mapping" translate="label" sortOrder="20" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Website Mapping</label>
<field id="uk_website" translate="label" type="select" sortOrder="10" showInDefault="1" showInWebsite="0" showInStore="0">
<label>United Kingdom Website</label>
<source_model>Esun3d\GeoWebsiteRedirect\Model\Config\Source\Website</source_model>
</field>
<field id="au_website" translate="label" type="select" sortOrder="20" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Australia Website</label>
<source_model>Esun3d\GeoWebsiteRedirect\Model\Config\Source\Website</source_model>
</field>
<field id="eu_website" translate="label" type="select" sortOrder="30" showInDefault="1" showInWebsite="0" showInStore="0">
<label>European Union Website</label>
<source_model>Esun3d\GeoWebsiteRedirect\Model\Config\Source\Website</source_model>
</field>
<field id="default_website" translate="label" type="select" sortOrder="40" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Default Website</label>
<source_model>Esun3d\GeoWebsiteRedirect\Model\Config\Source\Website</source_model>
</field>
<field id="eu_countries" translate="label comment" type="textarea" sortOrder="50" showInDefault="1" showInWebsite="0" showInStore="0">
<label>EU Country Codes</label>
<comment>Comma, space, or line separated ISO 3166-1 alpha-2 codes. GB is always handled by the UK mapping.</comment>
</field>
</group>
<group id="exclusions" translate="label" sortOrder="30" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Exclusions</label>
<field id="ignore_bots" translate="label" type="select" sortOrder="10" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Ignore Search Engines and Bots</label>
<source_model>Magento\Config\Model\Config\Source\Yesno</source_model>
</field>
<field id="user_agents" translate="label comment" type="textarea" sortOrder="20" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Ignored User-Agent Patterns</label>
<comment>One case-insensitive text pattern per line.</comment>
<depends>
<field id="ignore_bots">1</field>
</depends>
</field>
<field id="paths" translate="label comment" type="textarea" sortOrder="30" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Excluded Path Prefixes</label>
<comment>One path prefix per line, without the leading slash.</comment>
</field>
</group>
<group id="testing" translate="label" sortOrder="40" showInDefault="1" showInWebsite="0" showInStore="0">
<label>Test IP</label>
<field id="test_ip" translate="label comment" type="text" sortOrder="10" showInDefault="1" showInWebsite="0" showInStore="0">
<label>IP Address</label>
<comment>Tests GeoIP and website mapping without saving configuration or redirecting the browser.</comment>
<frontend_model>Esun3d\GeoWebsiteRedirect\Block\Adminhtml\System\Config\TestIp</frontend_model>
</field>
</group>
</section>
</system>
</config>
@@ -0,0 +1,48 @@
<?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>
<geo_website_redirect>
<general>
<enabled>0</enabled>
<redirect_scope>homepage</redirect_scope>
<preserve_path>0</preserve_path>
<cookie_lifetime>2592000</cookie_lifetime>
<cookie_domain></cookie_domain>
</general>
<mapping>
<uk_website>uk</uk_website>
<au_website>au</au_website>
<eu_website>eu</eu_website>
<default_website>us_site</default_website>
<eu_countries>AT,BE,BG,HR,CY,CZ,DK,EE,FI,FR,DE,GR,HU,IE,IT,LV,LT,LU,MT,NL,PL,PT,RO,SK,SI,ES,SE</eu_countries>
</mapping>
<exclusions>
<ignore_bots>1</ignore_bots>
<user_agents>googlebot
bingbot
slurp
duckduckbot
baiduspider
yandexbot
applebot
facebookexternalhit
twitterbot
crawler
spider
bot</user_agents>
<paths>rest
graphql
soap
static
media
pub
checkout
customer
paypal
payment
webhook</paths>
</exclusions>
</geo_website_redirect>
</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_geo_website_redirect"
type="Esun3d\GeoWebsiteRedirect\Plugin\FrontControllerPlugin"
sortOrder="-10"/>
</type>
<type name="Esun3d\LanguageUrlStoreResolver\ViewModel\LocaleSwitcher">
<plugin name="esun3d_geo_website_redirect_switcher_config"
type="Esun3d\GeoWebsiteRedirect\Plugin\LocaleSwitcherConfigPlugin"
sortOrder="10"/>
</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:Module/etc/module.xsd">
<module name="Esun3d_GeoWebsiteRedirect">
<sequence>
<module name="Magento_Store"/>
<module name="Magento_PageCache"/>
<module name="Amasty_Geoip"/>
<module name="Esun3d_LanguageUrlStoreResolver"/>
</sequence>
</module>
</config>
@@ -0,0 +1,10 @@
<?php
declare(strict_types=1);
use Magento\Framework\Component\ComponentRegistrar;
ComponentRegistrar::register(
ComponentRegistrar::MODULE,
'Esun3d_GeoWebsiteRedirect',
__DIR__
);
@@ -0,0 +1,51 @@
<?php
/** @var \Esun3d\GeoWebsiteRedirect\Block\Adminhtml\System\Config\TestIp $block */
$element = $block->getData('element');
$inputId = $element->getHtmlId();
$config = [
'Esun3d_GeoWebsiteRedirect/js/test-ip' => [
'url' => $block->getResolveUrl(),
],
];
?>
<div class="geo-website-test" data-mage-init='<?= /* @noEscape */ json_encode($config) ?>'>
<div class="admin__field-control">
<input id="<?= $block->escapeHtmlAttr($inputId) ?>"
class="admin__control-text"
type="text"
placeholder="8.8.8.8"
data-role="ip" />
<button type="button" class="action-default scalable" data-role="test">
<span><?= $block->escapeHtml(__('Test IP')) ?></span>
</button>
</div>
<div class="message" data-role="message" hidden></div>
<table class="admin__table-secondary" data-role="result" hidden>
<tbody>
<tr>
<th><?= $block->escapeHtml(__('IP Address')) ?></th>
<td data-field="ip"></td>
</tr>
<tr>
<th><?= $block->escapeHtml(__('Masked IP Used by GeoIP')) ?></th>
<td data-field="masked_ip"></td>
</tr>
<tr>
<th><?= $block->escapeHtml(__('Country')) ?></th>
<td data-field="country"></td>
</tr>
<tr>
<th><?= $block->escapeHtml(__('City')) ?></th>
<td data-field="city"></td>
</tr>
<tr>
<th><?= $block->escapeHtml(__('Website')) ?></th>
<td data-field="website"></td>
</tr>
<tr>
<th><?= $block->escapeHtml(__('Target URL')) ?></th>
<td><a data-field="target_url" target="_blank" rel="noopener"></a></td>
</tr>
</tbody>
</table>
</div>
@@ -0,0 +1,74 @@
define([
'jquery',
'mage/translate'
], function ($, $t) {
'use strict';
return function (config, element) {
var container = $(element),
input = container.find('[data-role="ip"]'),
button = container.find('[data-role="test"]'),
message = container.find('[data-role="message"]'),
result = container.find('[data-role="result"]');
function showMessage(text, isError) {
message
.removeClass('message-error message-warning')
.addClass(isError ? 'message-error' : 'message-warning')
.text(text)
.prop('hidden', !text);
}
function showResult(data) {
result.find('[data-field="ip"]').text(data.ip);
result.find('[data-field="masked_ip"]').text(data.masked_ip);
result.find('[data-field="country"]').text(data.country);
result.find('[data-field="city"]').text(data.city || '-');
result.find('[data-field="website"]').text(data.website_name + ' (' + data.website_code + ')');
result.find('[data-field="target_url"]').text(data.target_url).attr('href', data.target_url);
result.prop('hidden', false);
showMessage(
data.force_ip_enabled
? $t('Amasty Force IP is enabled. The live redirect may use its forced IP; this test always uses the IP entered above.')
: '',
false
);
}
function testIp() {
result.prop('hidden', true);
showMessage('', false);
button.prop('disabled', true);
$.ajax({
url: config.url,
type: 'POST',
dataType: 'json',
data: {
ip: input.val(),
form_key: window.FORM_KEY
}
}).done(function (response) {
if (response.success) {
showResult(response.data);
return;
}
showMessage(response.message || $t('The IP test failed.'), true);
}).fail(function () {
showMessage($t('The IP test request failed.'), true);
}).always(function () {
button.prop('disabled', false);
});
}
button.on('click', testIp);
input.on('keydown', function (event) {
if (event.key === 'Enter') {
event.preventDefault();
testIp();
}
});
};
});
@@ -0,0 +1,9 @@
var config = {
config: {
mixins: {
'Esun3d_LanguageUrlStoreResolver/js/locale-switcher': {
'Esun3d_GeoWebsiteRedirect/js/locale-switcher-mixin': true
}
}
}
};
@@ -0,0 +1,34 @@
define([
'jquery'
], function ($) {
'use strict';
return function (originalWidget) {
return function (config, element) {
var redirectConfig = (config.data || {}).geoRedirect || {};
var $market = $(element).find('[data-role="market"]');
if (redirectConfig.enabled) {
$market.on('change.geoWebsiteRedirect', function () {
var websiteCode = String($(this).val() || '');
var attributes = '; path=/; max-age=' + redirectConfig.cookieLifetime + '; SameSite=Lax';
if (!websiteCode) {
return;
}
if (redirectConfig.cookieDomain) {
attributes += '; domain=' + redirectConfig.cookieDomain;
}
if (window.location.protocol === 'https:') {
attributes += '; Secure';
}
document.cookie = redirectConfig.cookieName
+ '=' + encodeURIComponent(websiteCode) + attributes;
});
}
return originalWidget(config, element);
};
};
});
@@ -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;
};
});