config.php

<?php
 
namespace Bitrix\Translate;
 
use Bitrix\Main;
use Bitrix\Translate;
use Bitrix\Main\Localization\Loc;
 
final class Config
{
    public const OPTION_INIT_FOLDERS = 'INIT_FOLDERS';
    public const OPTION_BUTTON_LANG_FILES = 'BUTTON_LANG_FILES';
    public const OPTION_BACKUP_FILES = 'BACKUP_FILES';
    public const OPTION_SORT_PHRASES = 'SORT_PHRASES';
    public const OPTION_DONT_SORT_LANGUAGES = 'DONT_SORT_LANGUAGES';
    public const OPTION_BACKUP_FOLDER = 'BACKUP_FOLDER';
    public const OPTION_EXPORT_CSV_DELIMITER = 'EXPORT_CSV_DELIMITER';
    public const OPTION_EXPORT_FOLDER = 'EXPORT_FOLDER';
 
    private const CACHE_TTL = 3600;
 
    public static function getOption(string $optionName): ?string
    {
        static $options = [];
        if (!isset($options[$optionName]))
        {
            $options[$optionName] = (string)Main\Config\Option::get(
                'translate',
                $optionName,
                self::getModuleDefault($optionName)
            );
        }
 
        return $options[$optionName] ?: null;
    }
 
    public static function getModuleDefault(string $optionName): ?string 
    {
        static $defs;
        if ($defs === null)
        {
            $defs = Main\Config\Option::getDefaults('translate');
        }
 
        return $defs[$optionName] ?: null;
    }
 
    public static function getDefaultLanguages(): array
    {
        return ['ru', 'en', 'de'];
    }
 
    public static function isUtfMode(): bool 
    {
        static $flag;
        if ($flag === null)
        {
            $flag = Main\Application::isUtfMode() || defined('BX_UTF');
        }
        
        return $flag;
    }
 
    public static function getAllowedEncodings(): array 
    {
        return Translate\ENCODINGS;
    }
 
    public static function getEncodingName(string $encoding): string 
    {
        static $mess;
        if ($mess === null)
        {
            $mess = Loc::loadLanguageFile(__FILE__);
            if (empty($mess))
            {
                $mess = Loc::loadLanguageFile(__FILE__, 'en');
            }
        }
        $encTitle = Loc::getMessage('TRANSLATE_ENCODING_'.\mb_strtoupper(\str_replace('-', '_', $encoding)));
        if (!empty($encTitle))
        {
            $encTitle .= " ($encoding)";
        }
        else
        {
            $encTitle = $encoding;
            $encAlias = self::getAliasEncoding($encoding);
            if ($encAlias)
            {
                $encTitle .= " ($encAlias)";
            }
        }
 
        return $encTitle;
    }
 
    public static function getAliasEncoding(string $encoding): ?string 
    {
        static $aliasEncoding = [
            'windows-1250' => 'iso-8859-2',
            'windows-1252' => 'iso-8859-1',
        ];
        if (isset($aliasEncoding[$encoding]))
        {
            return $aliasEncoding[$encoding];
        }
 
        $alias = array_search($encoding, $aliasEncoding);
        if ($alias !== false)
        {
            return $alias;
        }
 
        return null;
    }
 
    public static function getCultureEncoding(string $languageId): ?string
    {
        static $cultureEncoding;
        if ($cultureEncoding === null)
        {
            $cultureEncoding = [];
            $iterator = Main\Localization\CultureTable::getList([
                'select' => ['ID', 'CODE', 'CHARSET'],
                'cache' => ['ttl' => self::CACHE_TTL],
            ]);
            while ($row = $iterator->fetch())
            {
                $cultureEncoding[\mb_strtolower($row['CODE'])] = \mb_strtolower($row['CHARSET']);
            }
        }
 
        return ($cultureEncoding[$languageId] ?? null) ?: null;
    }
 
    public static function getLanguages(): array 
    {
        static $languages;
        if ($languages === null)
        {
            $languages = [];
            $iterator = Main\Localization\LanguageTable::getList([
                'select' => ['ID', 'SORT'],
                'order' => ['SORT' => 'ASC'],
                'cache' => ['ttl' => self::CACHE_TTL],
            ]);
            while ($row = $iterator->fetch())
            {
                $languages[] = mb_strtolower($row['ID']);
            }
        }
 
        return $languages;
    }
 
    public static function getEnabledLanguages(): array 
    {
        static $languages;
        if ($languages === null)
        {
            $languages = [];
            $iterator = Main\Localization\LanguageTable::getList([
                'select' => ['ID', 'SORT'],
                'filter' => ['=ACTIVE' => 'Y'],
                'order' => ['SORT' => 'ASC'],
                'cache' => ['ttl' => self::CACHE_TTL],
            ]);
            while ($row = $iterator->fetch())
            {
                $languages[] = mb_strtolower($row['ID']);
            }
        }
 
        return $languages;
    }
 
    public static function getLanguagesTitle(array $languageIds): array
    {
        static $cache = [];
        
        $cacheId = \implode('-', $languageIds);
        if (!isset($cache[$cacheId]))
        {
            $cache[$cacheId] = [];
 
            $iterator = Main\Localization\LanguageTable::getList([
                'select' => ['ID', 'NAME'],
                'filter' => [
                    '=ID' => $languageIds,
                    '=ACTIVE' => 'Y'
                ],
                'order' => ['SORT' => 'ASC'],
                'cache' => ['ttl' => self::CACHE_TTL],
            ]);
            while ($row = $iterator->fetch())
            {
                $cache[$cacheId][mb_strtolower($row['ID'])] = $row['NAME'];
            }
        }
 
        return $cache[$cacheId];
    }
 
    public static function getAvailableLanguages(): array 
    {
        static $languages;
        if ($languages === null)
        {
            $languages = \array_unique(\array_merge(
                self::getAvailableDefaultLanguages(),
                self::getTranslationRepositoryLanguages()
            ));
        }
 
        return $languages;
    }
 
    public static function getAvailableDefaultLanguages(): array 
    {
        static $languages;
        if ($languages === null)
        {
            $languages = [];
            $langDirList = new Main\IO\Directory(Main\Application::getDocumentRoot(). '/bitrix/modules/main/lang/');
            foreach ($langDirList->getChildren() as $langDir)
            {
                $langId = $langDir->getName();
                if (\in_array($langId, Translate\IGNORE_FS_NAMES, true) || !$langDir->isDirectory())
                {
                    continue;
                }
                $languages[] = $langId;
            }
        }
 
        return $languages;
    }
 
    public static function getTranslationRepositoryLanguages(): array
    {
        static $languages;
        if ($languages === null)
        {
            $languages = [];
            if (Main\Localization\Translation::useTranslationRepository())
            {
                $langDirList = new Main\IO\Directory(Main\Localization\Translation::getTranslationRepositoryPath());
                foreach ($langDirList->getChildren() as $langDir)
                {
                    $langId = $langDir->getName();
                    if (\in_array($langId, Translate\IGNORE_FS_NAMES, true) || !$langDir->isDirectory())
                    {
                        continue;
                    }
                    $languages[] = $langId;
                }
            }
        }
 
        return $languages;
    }
 
    public static function getInitPath(): array
    {
        static $initFolders;
        if ($initFolders === null)
        {
            $initFolders = [];
            $folders = (string)Main\Config\Option::get(
                'translate',
                self::OPTION_INIT_FOLDERS,
                Translate\Config::getModuleDefault(Translate\Config::OPTION_INIT_FOLDERS)
            );
            $folders = \explode(',', \trim($folders));
            foreach ($folders as $oneFolder)
            {
                if (!empty($oneFolder))
                {
                    $oneFolder = Translate\IO\Path::normalize($oneFolder);
                    $initFolders[] = '/'.\ltrim($oneFolder, '/');
                }
            }
        }
 
        return $initFolders;
    }
 
    public static function getDefaultPath(): string
    {
        static $defaultPath;
        if ($defaultPath === null)
        {
            $folders = \explode(',', self::getModuleDefault(self::OPTION_INIT_FOLDERS));
            $defaultPath = $folders[0];
        }
 
        return $defaultPath;
    }
 
 
    public static function needToBackUpFiles(): bool
    {
        static $needToBackUpFiles;
        if ($needToBackUpFiles === null)
        {
            $def = self::getModuleDefault(self::OPTION_BACKUP_FILES);
            $needToBackUpFiles = (bool)(Main\Config\Option::get('translate', self::OPTION_BACKUP_FILES, $def) === 'Y');
        }
 
        return $needToBackUpFiles;
    }
 
    public static function getBackupFolder(): string
    {
        static $backupFolder;
        if ($backupFolder === null)
        {
            $confOption = Main\Config\Option::get('translate', self::OPTION_BACKUP_FOLDER, '');
            if (!empty($confOption))
            {
                if (\mb_strpos($confOption, '/') === 0)
                {
                    $backupFolder = $confOption;
                }
                elseif (\strncasecmp(\PHP_OS, 'WIN', 3) === 0 && \preg_match("#^[a-z]{1}:/#i", $confOption))
                {
                    $backupFolder = $confOption;
                }
                else
                {
                    $backupFolder = Main\Application::getDocumentRoot(). '/'. $confOption;
                }
            }
            else
            {
                $defOption = self::getModuleDefault(self::OPTION_BACKUP_FOLDER);
                if (empty($defOption))
                {
                    $defOption = 'bitrix/backup/translate/';
                }
                $backupFolder = Main\Application::getDocumentRoot(). '/'. $defOption;
            }
        }
 
        return $backupFolder;
    }
 
    public static function needToSortPhrases(): bool
    {
        static $needToSortPhrases;
        if ($needToSortPhrases === null)
        {
            $def = self::getModuleDefault(self::OPTION_SORT_PHRASES);
            $needToSortPhrases = (bool)(Main\Config\Option::get('translate', self::OPTION_SORT_PHRASES, $def) === 'Y');
        }
 
        return $needToSortPhrases;
    }
 
    public static function getNonSortPhraseLanguages(): array
    {
        static $nonSortPhraseLanguages;
        if ($nonSortPhraseLanguages === null)
        {
            $nonSortPhraseLanguages = [];
            $def = self::getModuleDefault(self::OPTION_DONT_SORT_LANGUAGES);
            $nonSortPhraseLanguages = Main\Config\Option::get('translate', self::OPTION_DONT_SORT_LANGUAGES, $def);
            if (!is_array($nonSortPhraseLanguages))
            {
                $nonSortPhraseLanguages = \explode(',', $nonSortPhraseLanguages);
            }
        }
 
        return $nonSortPhraseLanguages;
    }
 
    public static function getExportFolder(): ?string
    {
        static $exportFolder = -1;
        if ($exportFolder === -1)
        {
            $exportFolder = null;// '/bitrix/updates/_langs/';
            $confOption = Main\Config\Option::get('translate', self::OPTION_EXPORT_FOLDER, '');
            if (!empty($confOption))
            {
                if (\mb_strpos($confOption, Main\Application::getDocumentRoot()) === 0)
                {
                    $exportFolder = $confOption;
                }
                else
                {
                    $exportFolder = Main\Application::getDocumentRoot(). '/'. $confOption;
                }
            }
        }
 
        return $exportFolder;
    }
}