translation.php

<?php
namespace Bitrix\Main\Localization;
 
use Bitrix\Main;
use Bitrix\Main\IO\Path;
use Bitrix\Main\Context;
use Bitrix\Main\Config\Configuration;
 
class Translation
{
    private static $allowConvertEncoding = null;
    private static $useTranslationRepository = null;
    private static $translationRepositoryPath = null;
    private static $currentEncoding = null;
    private static $needConvertEncoding = array();
    private static $map = array();
 
    const CACHE_ID = 'TranslationLoadMapCache';
    const CACHE_TTL = 3600;
 
    public static function isDefaultTranslationLang($lang)
    {
        return
            ($lang === 'ru') ||
            ($lang === 'en') ||
            ($lang === 'de');
    }
 
    public static function getDefaultTranslationEncoding($lang)
    {
        static $sourceEncoding = [
            'ru' => 'windows-1251',
            'en' => 'iso-8859-1',
            'de' => 'iso-8859-15',
        ];
        if (isset($sourceEncoding[$lang]))
        {
            return $sourceEncoding[$lang];
        }
 
        return 'utf-8';
    }
 
 
    public static function getSourceEncoding($lang)
    {
        $encoding = '';
        if (self::useTranslationRepository() || self::allowConvertEncoding())
        {
            if (self::isDefaultTranslationLang($lang))
            {
                $encoding = self::getDefaultTranslationEncoding($lang);
            }
            else
            {
                $encoding = 'utf-8';
            }
        }
        elseif (Main\Application::isUtfMode() || defined('BX_UTF'))
        {
            $encoding = 'utf-8';
        }
 
        if (empty($encoding))
        {
            $culture = Main\Localization\CultureTable::getRow(array('filter' => array('=CODE' => $lang)));
            if ($culture)
            {
                $encoding = $culture['CHARSET'];
            }
        }
 
        if (empty($encoding))
        {
            $encoding = self::getCurrentEncoding();
        }
 
        return $encoding;
    }
 
 
    public static function setCurrentEncoding($encoding)
    {
        self::$currentEncoding = $encoding;
    }
 
    public static function getCurrentEncoding()
    {
        if (self::$currentEncoding === null)
        {
            $encoding = null;
            // site settings
            if (Main\Application::isUtfMode() || defined('BX_UTF'))
            {
                $encoding = 'utf-8';
            }
            elseif (defined('SITE_CHARSET') && (SITE_CHARSET <> ''))
            {
                $encoding = SITE_CHARSET;
            }
            elseif (defined('LANG_CHARSET') && (LANG_CHARSET <> ''))
            {
                $encoding = LANG_CHARSET;
            }
            else
            {
                $context = Context::getCurrent();
                if ($context instanceof Main\Context)
                {
                    $culture = $context->getCulture();
                    if ($culture instanceof Context\Culture)
                    {
                        $encoding = $culture->getCharset();
                    }
                }
            }
            // default settings
            if ($encoding === null)
            {
                if (Configuration::getValue('default_charset') !== null)
                {
                    $encoding = Configuration::getValue('default_charset');
                }
                elseif (defined('BX_DEFAULT_CHARSET') && (BX_DEFAULT_CHARSET <> ''))
                {
                    $encoding = BX_DEFAULT_CHARSET;
                }
                else
                {
                    $encoding = 'windows-1251';
                }
            }
 
            self::$currentEncoding = mb_strtolower($encoding);
        }
 
        return self::$currentEncoding;
    }
 
    public static function needConvertEncoding($language, $targetEncoding = null)
    {
        if (!isset(self::$needConvertEncoding[$language]) || self::$needConvertEncoding[$language] === null)
        {
            self::$needConvertEncoding[$language] = false;
 
            if (self::allowConvertEncoding())
            {
                if ($targetEncoding === null)
                {
                    $targetEncoding = self::getCurrentEncoding();
                }
                $sourceEncoding = self::getSourceEncoding($language);
                self::$needConvertEncoding[$language] = ($targetEncoding != $sourceEncoding);
            }
        }
 
        return self::$needConvertEncoding[$language];
    }
 
 
    public static function checkPathRestrictionConvertEncoding($langFile)
    {
        $needConvert = false;
        if (self::allowConvertEncoding())
        {
            if (self::getDeveloperRepositoryPath() !== null)
            {
                $needConvert = (stripos($langFile, self::getDeveloperRepositoryPath()) === 0);
            }
            if (!$needConvert && self::useTranslationRepository())
            {
                $needConvert = (stripos($langFile, self::getTranslationRepositoryPath()) === 0);
            }
        }
 
        return $needConvert;
    }
 
    public static function useTranslationRepository()
    {
        if (self::$useTranslationRepository === null)
        {
            self::$useTranslationRepository = false;
 
            if(self::getTranslationRepositoryPath() !== null)
            {
                self::$useTranslationRepository = true;
            }
        }
 
        return self::$useTranslationRepository;
    }
 
    public static function getTranslationRepositoryPath()
    {
        if(self::$translationRepositoryPath === null)
        {
            $config = Configuration::getValue('translation');
 
            if ($config !== null && !empty($config['translation_repository']))
            {
                $translationRepositoryPath = realpath($config['translation_repository']);
                if (file_exists($translationRepositoryPath))
                {
                    self::$translationRepositoryPath = Path::normalize($translationRepositoryPath);
                }
            }
        }
 
        return self::$translationRepositoryPath;
    }
 
    public static function allowConvertEncoding()
    {
        if(self::$allowConvertEncoding === null)
        {
            self::$allowConvertEncoding = false;
 
            $config = Configuration::getValue('translation');
 
            if ($config !== null && !empty($config['convert_encoding']))
            {
                self::$allowConvertEncoding = ($config['convert_encoding'] === true);
            }
        }
 
        return self::$allowConvertEncoding;
    }
 
    public static function getDeveloperRepositoryPath()
    {
        static $developerRepositoryPath, $wasChecked;
        if($wasChecked === null)
        {
            $wasChecked = true;
            $config = Configuration::getValue('translation');
 
            if ($config !== null && !empty($config['developer_repository']))
            {
                $developerRepositoryPath = realpath($config['developer_repository']);
                if (file_exists($developerRepositoryPath))
                {
                    $developerRepositoryPath = Path::normalize($developerRepositoryPath);
                }
            }
        }
 
        return $developerRepositoryPath;
    }
 
    public static function convertLangPath($langFile, $language)
    {
        if (empty($language) || !(self::useTranslationRepository() || self::getDeveloperRepositoryPath() !== null))
        {
            return $langFile;
        }
 
        static $documentRoot;
        if ($documentRoot === null)
        {
            $documentRoot = Path::normalize(Main\Application::getDocumentRoot());
        }
 
        if (self::useTranslationRepository() && !self::isDefaultTranslationLang($language))
        {
            $modulePath = self::getTranslationRepositoryPath().'/'.$language.'/';
        }
        elseif (self::getDeveloperRepositoryPath() !== null)
        {
            $modulePath = self::getDeveloperRepositoryPath(). '/';
        }
        elseif (self::isDefaultTranslationLang($language))
        {
            $modulePath = $documentRoot. '/bitrix/modules/';
        }
        else
        {
            return $langFile;
        }
 
        if (strpos($langFile, '\\') !== false)
        {
            $langFile = str_replace('\\', '/', $langFile);
        }
        if (strpos($langFile, '//') !== false)
        {
            $langFile = str_replace('//', '/', $langFile);
        }
 
        // linked
        if (self::getDeveloperRepositoryPath() !== null)
        {
            if (mb_strpos($langFile, self::getDeveloperRepositoryPath()) === 0)
            {
                $langFile = str_replace(
                    self::getDeveloperRepositoryPath(). '/',
                    $modulePath,
                    $langFile
                );
 
                return $langFile;
            }
        }
 
        // module lang
        if (strpos($langFile, $documentRoot. '/bitrix/modules/') === 0)
        {
            $langFile = str_replace(
                $documentRoot.'/bitrix/modules/',
                $modulePath,
                $langFile
            );
 
            return $langFile;
        }
 
        self::loadMap();
 
        $langPathParts = preg_split('#[/]+#', trim(str_replace($documentRoot, '', $langFile), '/'), 6);
        if (
            empty($langPathParts)
            || $langPathParts[0] !== 'bitrix'
            || empty($langPathParts[1])
            || empty($langPathParts[2])
            || empty($langPathParts[3])
        )
        {
            return $langFile;
        }
 
        $testEntry = $langPathParts[1];
        switch ($testEntry)
        {
            // bitrix/mobileapp/[moduleName] -> [moduleName]/install/mobileapp/[moduleName]
            case 'mobileapp':
                $moduleName = $langPathParts[2];
                if (isset(self::$map[$moduleName][$testEntry], self::$map[$moduleName][$testEntry][$moduleName]))
                {
                    $testEntry = 'mobileapp/'. $moduleName;
                    $langFile = str_replace(
                        $documentRoot.'/bitrix/mobileapp/'. $moduleName. '/',
                        $modulePath.''.$moduleName.'/install/mobileapp/'. $moduleName. '/',
                        $langFile
                    );
                }
                break;
 
            // bitrix/templates/[templateName] -> [moduleName]/install/templates/[templateName]
            case 'templates':
                $templateName = $langPathParts[2];
                foreach (self::$map as $moduleName => $moduleEntries)
                {
                    if (isset(self::$map[$moduleName][$testEntry], self::$map[$moduleName][$testEntry][$templateName]))
                    {
                        $langFile = str_replace(
                            $documentRoot.'/bitrix/templates/'.$templateName.'/',
                            $modulePath.''.$moduleName.'/install/templates/'. $templateName .'/',
                            $langFile
                        );
                        break;
                    }
                }
                break;
 
            // bitrix/components/bitrix/[componentName] -> [moduleName]/install/components/bitrix/[componentName]
            // bitrix/activities/bitrix/[activityName] -> [moduleName]/install/activities/bitrix/[activityName]
            // bitrix/wizards/bitrix/[wizardsName] -> [moduleName]/install/wizards/bitrix/[wizardsName]
            // bitrix/gadgets/bitrix/[gadgetName] -> [moduleName]/install/gadgets/bitrix/[gadgetName]
            case 'components':
            case 'activities':
            case 'wizards':
            case 'gadgets':
            case 'blocks':
                if ($langPathParts[2] !== 'bitrix')
                {
                    break;
                }
                $searchEntryName = $langPathParts[3];
                foreach (self::$map as $moduleName => $moduleEntries)
                {
                    if (isset(self::$map[$moduleName][$testEntry], self::$map[$moduleName][$testEntry][$searchEntryName]))
                    {
                        $langFile = str_replace(
                            $documentRoot.'/bitrix/'.$testEntry.'/bitrix/'.$searchEntryName.'/',
                            $modulePath.''.$moduleName.'/install/'.$testEntry.'/bitrix/'. $searchEntryName. '/',
                            $langFile
                        );
                        break;
                    }
                }
                break;
 
            // bitrix/js/[moduleName]/[smth] -> [moduleName]/install/js/[moduleName]/[smth]
            // bitrix/js/[moduleName]/[smth] -> [moduleName]/install/public/js/[moduleName]/[smth]
            case 'js':
                $libraryNamespace = $langPathParts[2]. '/'. $langPathParts[3];
 
                foreach (self::$map as $moduleName => $moduleEntries)
                {
                    if (isset(self::$map[$moduleName][$testEntry], self::$map[$moduleName][$testEntry][$libraryNamespace]))
                    {
                        $langFile = str_replace(
                            $documentRoot.'/bitrix/'.$testEntry.'/'.$libraryNamespace.'/',
                            $modulePath.''.$moduleName.'/install/'.$testEntry.'/'.$libraryNamespace.'/',
                            $langFile
                        );
                        break;
                    }
                    if (isset(self::$map[$moduleName]["public/{$testEntry}"], self::$map[$moduleName]["public/{$testEntry}"][$libraryNamespace]))
                    {
                        $langFile = str_replace(
                            $documentRoot.'/bitrix/'.$testEntry.'/'.$libraryNamespace.'/',
                            $modulePath.''.$moduleName.'/install/public/'.$testEntry.'/'.$libraryNamespace.'/',
                            $langFile
                        );
                        break;
                    }
                }
                break;
 
            // bitrix/[moduleName]/payment/[paymentHandler] -> [moduleName]/payment/[paymentHandler]
            case 'payment':
                $searchEntryName = $langPathParts[3];
                foreach (self::$map as $moduleName => $moduleEntries)
                {
                    if (isset(self::$map[$moduleName][$testEntry], self::$map[$moduleName][$testEntry][$searchEntryName]))
                    {
                        $langFile = str_replace(
                            $documentRoot.'/bitrix/modules/'.$moduleName.'/'.$testEntry.'/',
                            $modulePath.''.$moduleName.'/'.$testEntry.'/',
                            $langFile
                        );
                        break;
                    }
                }
                break;
        }
 
        return $langFile;
    }
 
 
    public static function loadMap()
    {
        if (empty(self::$map))
        {
            $cacheManager = Main\Application::getInstance()->getManagedCache();
            if ($cacheManager->read(static::CACHE_TTL, static::CACHE_ID))
            {
                self::$map = $cacheManager->get(static::CACHE_ID);
            }
        }
 
        if (empty(self::$map))
        {
            $testForExistence = array(
                'templates',
                'components',
                'activities',
                'wizards',
                'gadgets',
                'js',
                'public/js',
                'blocks',
                'payment',
                'mobileapp',
            );
            $bxRoot = Main\Application::getDocumentRoot(). '/bitrix/modules/';
            $modulesList = new Main\IO\Directory($bxRoot);
            foreach ($modulesList->getChildren() as $moduleDirectory)
            {
                if ($moduleDirectory->isDirectory())
                {
                    $moduleName = $moduleDirectory->getName();
                    if (strpos($moduleName, '.') === false || strpos($moduleName, 'bitrix.') === 0)
                    {
                        self::$map[$moduleName] = array();
                        foreach ($testForExistence as $testEntry)
                        {
                            $testPath = $bxRoot. '/'. $moduleName. '/install/'. $testEntry;
                            if ($testEntry === 'templates' || $testEntry === 'mobileapp')
                            {
                                $testPath .= '/';
                            }
                            elseif ($testEntry === 'js' || $testEntry === 'public/js')
                            {
                                $testPath .= '/'. $moduleName. '/';
                            }
                            elseif ($testEntry === 'payment')
                            {
                                $testPath = $bxRoot. '/'. $moduleName. '/'. $testEntry;
                            }
                            else
                            {
                                $testPath .= '/bitrix/';
                            }
 
                            $testDirectory = new Main\IO\Directory($testPath);
                            if ($testDirectory->isExists())
                            {
                                self::$map[$moduleName][$testEntry] = array();
                                foreach ($testDirectory->getChildren() as $testDirectoryEntry)
                                {
                                    if ($testDirectoryEntry->isDirectory())
                                    {
                                        if ($testEntry === 'js' || $testEntry === 'public/js')
                                        {
                                            self::$map[$moduleName][$testEntry][$moduleName.'/'.$testDirectoryEntry->getName()] = 1;
                                        }
                                        else
                                        {
                                            self::$map[$moduleName][$testEntry][$testDirectoryEntry->getName()] = 1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
 
            $cacheManager->set(static::CACHE_ID, static::$map);
        }
 
        return self::$map;
    }
 
    public static function getEncodings($language, $langFile)
    {
        static $encodingCache = array();
 
        if(isset($encodingCache[$language]))
        {
            list($convertEncoding, $targetEncoding, $sourceEncoding) = $encodingCache[$language];
        }
        else
        {
            $convertEncoding = self::needConvertEncoding($language);
            $targetEncoding = $sourceEncoding = '';
            if($convertEncoding)
            {
                $targetEncoding = self::getCurrentEncoding();
                $sourceEncoding = self::getSourceEncoding($language);
            }
 
            $encodingCache[$language] = array($convertEncoding, $targetEncoding, $sourceEncoding);
        }
 
        if($convertEncoding)
        {
            $convertEncoding = self::checkPathRestrictionConvertEncoding($langFile);
        }
 
        return array($convertEncoding, $targetEncoding, $sourceEncoding);
    }
}