exportaction.php

<?php
namespace Bitrix\Translate\Controller\Export;
 
use Bitrix\Main;
use Bitrix\Translate;
use Bitrix\Main\Localization\Loc;
use Bitrix\Translate\Index;
 
abstract class ExportAction extends Translate\Controller\Action
{
    protected static string $documentRoot = '';
 
    protected static bool $useTranslationRepository = false;
    protected static array $translationRepositoryLanguages = [];
 
    protected int $tabId = 0;
 
    protected string $exportFilePath = '';
    protected string $exportFileName = '';
    protected string $exportFileType = 'application/csv';
    protected int $exportFileSize = 0;
 
    protected bool $convertEncoding;
 
    protected string $encodingOut;
 
    protected bool $collectUntranslated;
 
    /* Look for translation samples */
    protected bool $appendSamples = false;
    protected int $samplesCount = 10;
    protected array $samplesRestriction = [];
    protected string $samplesFilePath = '';
    protected string $samplesFileName = '';
    protected int $samplesFileSize = 0;
 
    /* Don't look for samples for a long text */
    protected int $maxSampleSourceLength = 500;
 
    protected array $languages = [];
 
    protected int $exportedPhraseCount = 0;
 
    protected int $exportedSamplesCount = 0;
 
    protected Translate\Filter $filter;
 
    protected array $fullPathCache = [];
 
 
    public function __construct($name, Main\Engine\Controller $controller, array $config = [])
    {
        $this->filter = new Translate\Filter();
 
        Loc::loadLanguageFile(__FILE__);
 
        if ($this instanceof Translate\Controller\IProcessParameters)
        {
            $this->keepField([
                'tabId',
                'exportFileName',
                'exportFilePath',
                'exportFileSize',
                'exportedPhraseCount',
                'collectUntranslated',
                'appendSamples',
                'samplesCount',
                'samplesRestriction',
                'samplesFileName',
                'samplesFilePath',
                'samplesFileSize',
                'exportedSamplesCount',
                'convertEncoding',
                'encodingOut',
                'languages'
            ]);
        }
 
        $fields = [
            'collectUntranslated',
            'appendSamples',
            'samplesCount',
            'samplesRestriction',
            'convertEncoding',
            'encodingOut',
            'languages',
            'filter'
        ];
        foreach ($fields as $key)
        {
            if (isset($config[$key]))
            {
                if ($key == 'filter')
                {
                    if (!$config[$key] instanceof Translate\Filter)
                    {
                        continue;
                    }
                }
                $this->{$key} = $config[$key];
            }
        }
 
        self::$documentRoot = \rtrim(Translate\IO\Path::tidy(Main\Application::getDocumentRoot()), '/');
 
        self::$useTranslationRepository = Main\Localization\Translation::useTranslationRepository();
        if (self::$useTranslationRepository)
        {
            self::$translationRepositoryLanguages = Translate\Config::getTranslationRepositoryLanguages();
        }
 
        if (in_array('all', $this->languages) || empty($this->languages))
        {
            $this->languages = Translate\Config::getEnabledLanguages();
        }
 
        parent::__construct($name, $controller, $config);
    }
 
 
    protected function createExportTempFile(string $exportFileName): Translate\IO\CsvFile
    {
        $exportFolder = Translate\Config::getExportFolder();
        if (!empty($exportFolder))
        {
            $tempDir = new Translate\IO\Directory($exportFolder);
            if ($tempDir->isExists())
            {
                $tempDir->wipe(function(Main\IO\FileSystemEntry $entry){
                    // clear .csv files older than 3 hours
                    return (
                        $entry->isFile() &&
                        \preg_match("#.+_([0-9]+)\.csv$#", $entry->getName(), $matches) &&
                        (\time() - (int)$matches[1] > 3 * 3600)
                    );
                });
            }
            else
            {
                $tempDir->create();
            }
 
            $fileName = \preg_replace("#(.+)\.csv$#", "$1_".\time().'.csv',  $exportFileName);
 
            $csvFile = new Translate\IO\CsvFile($tempDir->getPhysicalPath() .'/'. $fileName);
        }
        else
        {
            $csvFile = Translate\IO\CsvFile::generateTemporalFile('translate', '.csv', 3);
        }
 
        $this->configureExportCsvFile($csvFile);
 
        $csvFile->openWrite();
 
        $row = ['file', 'key'];
        foreach ($this->languages as $langId)
        {
            $row[] = $langId;
        }
        $csvFile->put($row);
        $csvFile->close();
 
        return $csvFile;
    }
 
    protected function configureExportCsvFile(Translate\IO\CsvFile $csvFile): void
    {
        $csvFile
            ->setRowDelimiter(Translate\IO\CsvFile::LINE_DELIMITER_WIN)
            ->prefaceWithUtf8Bom($this->encodingOut === 'utf-8')
        ;
 
        switch (Translate\Config::getOption(Translate\Config::OPTION_EXPORT_CSV_DELIMITER))
        {
            case 'TAB':
                $csvFile->setFieldDelimiter(Translate\IO\CsvFile::DELIMITER_TAB);
                break;
            case 'ZPT':
                $csvFile->setFieldDelimiter(Translate\IO\CsvFile::DELIMITER_ZPT);
                break;
            case 'TZP':
            default:
                $csvFile->setFieldDelimiter(Translate\IO\CsvFile::DELIMITER_TZP);
        }
    }
 
    protected function generateExportFileName(string $path, array $languages): string
    {
        return \trim(\str_replace(['.php', '/'], ['', '_'], $path), '_').'_'.\implode('_', $languages).'.csv';
    }
 
    public function getDownloadingParameters(): array
    {
        return [
            'fileName' => $this->exportFileName,
            'filePath' => $this->exportFilePath,
            'fileType' => $this->exportFileType,
            'fileSize' => $this->exportFileSize,
        ];
    }
 
    public function getDownloadingSamplesParameters(): array
    {
        return [
            'fileName' => $this->samplesFileName,
            'filePath' => $this->samplesFilePath,
            'fileType' => $this->exportFileType,
            'fileSize' => $this->samplesFileSize,
        ];
    }
 
    public function mergeLangFiles(
        string $langFilePath,
        array $fullLangFilePaths,
        bool $collectUntranslated = false,
        array $filterByCodeList = []
    ): array
    {
        $mergedContent = [];
 
        $rowLang0 = [];
        foreach ($this->languages as $langId)
        {
            $rowLang0[$langId] = '';
        }
 
        $filterByCode = !empty($filterByCodeList);
 
        foreach ($this->languages as $langId)
        {
            if (empty($fullLangFilePaths[$langId]))
            {
                continue;
            }
 
            $fullPath = $fullLangFilePaths[$langId];
            $file = new Translate\File($fullPath);
            $file->setLangId($langId);
 
            if ($this->convertEncoding)
            {
                $file->setOperatingEncoding($this->encodingOut);
            }
            else
            {
                $file->setOperatingEncoding(Main\Localization\Translation::getSourceEncoding($langId));
            }
 
            if (!$file->loadTokens())
            {
                if (!$file->load())
                {
                    continue;
                }
            }
 
            foreach ($file as $code => $phrase)
            {
                if ($filterByCode)
                {
                    if (!\in_array($code, $filterByCodeList))
                    {
                        continue;
                    }
                }
                if (!isset($mergedContent[$code]))
                {
                    $mergedContent[$code] = \array_merge(['file' => $langFilePath, 'key' => $code], $rowLang0);
                }
                $mergedContent[$code][$langId] = $phrase;
            }
        }
 
        if ($collectUntranslated)
        {
            // settings
            $hasObligatorySetting = false;
            if ($settingsFile = Translate\Settings::instantiateByPath(self::$documentRoot. '/'. $langFilePath))
            {
                if ($settingsFile->load())
                {
                    $langSettings = $settingsFile->getOptions($langFilePath);
                    $hasObligatorySetting = !empty($langSettings[Translate\Settings::OPTION_LANGUAGES]);
                }
            }
 
            foreach ($mergedContent as $code => $row)
            {
                foreach ($row as $langId => $phr)
                {
                    if ($langId == 'file' || $langId == 'key')
                    {
                        continue;
                    }
                    $isObligatory = true;
                    if ($hasObligatorySetting)
                    {
                        $isObligatory = \in_array($langId, $langSettings[Translate\Settings::OPTION_LANGUAGES]);
                    }
                    if (empty($phr) && ($phr !== '0') && $isObligatory)
                    {
                        continue 2;
                    }
                }
                unset($mergedContent[$code]);
            }
        }
 
        return $mergedContent;
    }
 
 
    public function lookThroughLangFolder(string $langPath): iterable
    {
        $files = [];
        $folders = [];
 
        foreach ($this->languages as $langId)
        {
            $langFolderRelPath = Translate\IO\Path::replaceLangId($langPath, $langId);
            $langFolderFullPath = Translate\IO\Path::tidy(self::$documentRoot.'/'.$langFolderRelPath);
 
            if (self::$useTranslationRepository && \in_array($langId, self::$translationRepositoryLanguages))
            {
                $langFolderFullPath = Main\Localization\Translation::convertLangPath($langFolderFullPath, $langId);
            }
 
            $childrenList = Translate\IO\FileSystemHelper::getFileList($langFolderFullPath);
            if (!empty($childrenList))
            {
                foreach ($childrenList as $fullPath)
                {
                    $name = \basename($fullPath);
                    if (\in_array($name, Translate\IGNORE_FS_NAMES))
                    {
                        continue;
                    }
 
                    if (Translate\IO\Path::isPhpFile($fullPath, true))
                    {
                        $files[$langPath.'/'.$name][$langId] = $fullPath;
                    }
                }
            }
 
            // dir only
            $childrenList = Translate\IO\FileSystemHelper::getFolderList($langFolderFullPath);
            if (!empty($childrenList))
            {
                $ignoreDev = \implode('|', Translate\IGNORE_MODULE_NAMES);
                foreach ($childrenList as $fullPath)
                {
                    $name = \basename($fullPath);
                    if (\in_array($name, Translate\IGNORE_FS_NAMES))
                    {
                        continue;
                    }
 
                    $relPath = $langFolderRelPath.'/'.$name;
 
                    if (!\is_dir($fullPath))
                    {
                        continue;
                    }
 
                    if (\in_array($relPath, Translate\IGNORE_BX_NAMES))
                    {
                        continue;
                    }
 
                    // /bitrix/modules/[smth]/dev/
                    if (\preg_match("#^bitrix/modules/[^/]+/({$ignoreDev})$#", \trim($relPath, '/')))
                    {
                        continue;
                    }
 
                    if (\in_array($name, Translate\IGNORE_LANG_NAMES))
                    {
                        continue;
                    }
 
                    $folders[$langPath.'/'.$name] = $langPath.'/'.$name;
                }
            }
        }
 
        if (\count($files) > 0)
        {
            yield $files;
        }
 
        if (\count($folders) > 0)
        {
            foreach ($folders as $subFolderPath)
            {
                foreach ($this->lookThroughLangFolder($subFolderPath) as $subFiles)// go deeper
                {
                    yield $subFiles;
                }
            }
        }
    }
 
    public function findSamples(string $searchPhrase, string $searchLangId, $stripPath, int $limit = 50, array $restrictByPathId = []): array
    {
        $select = [
            'PATH_ID' => 'PATH_ID',
            'PHRASE_CODE' => 'CODE',
            'FILE_PATH' => 'PATH.PATH',
        ];
 
        $phraseFilter = [];
 
        if (!Index\PhraseIndexSearch::disallowFtsIndex($searchLangId))
        {
            $minLengthFulltextWorld = Index\PhraseIndexSearch::getFullTextMinLength();
            $fulltextIndexSearchStr = Index\PhraseIndexSearch::prepareTextForFulltextSearch($searchPhrase);
            if (\mb_strlen($fulltextIndexSearchStr) > $minLengthFulltextWorld)
            {
                $phraseFilter['*=PHRASE'] = $fulltextIndexSearchStr;
            }
        }
 
        $phraseFilter['=PHRASE'] = $searchPhrase;
        if (is_numeric($stripPath))
        {
            $phraseFilter['!=PATH_ID'] = $stripPath;
        }
        else
        {
            $phraseFilter['!=PATH.PATH'] = $stripPath;
        }
 
        if (!empty($restrictByPathId))
        {
            $phraseFilter['=PATH.DESCENDANTS.PARENT_ID'] = $restrictByPathId; //ancestor
        }
 
        $ftsClass = Index\Internals\PhraseFts::getFtsEntityClass($searchLangId);
 
        $phraseInxRes = $ftsClass::getList([
            'filter' => $phraseFilter,
            'select' => $select,
            'limit' => $limit,
        ]);
 
        $samples = [];
        $fileInxCache = [];
        while ($phraseInx = $phraseInxRes->fetch())
        {
            $pathId = (int)$phraseInx['PATH_ID'];
            $phraseCode = $phraseInx['PHRASE_CODE'];
 
            if (!isset($fileInxCache[$pathId]))
            {
                $fullPaths = $this->getFullPath($pathId);
                $fileInxCache[$pathId] = $this->mergeLangFiles($phraseInx['FILE_PATH'], $fullPaths);
            }
 
            if (
                isset($fileInxCache[$pathId][$phraseCode])
                && $fileInxCache[$pathId][$phraseCode][$searchLangId] == $searchPhrase
            )
            {
                $samples[] = $fileInxCache[$pathId][$phraseCode];
            }
        }
 
        return $samples;
    }
 
    protected function getFullPath(int $pathId): array
    {
        if (!isset($this->fullPathCache[$pathId]))
        {
            $this->fullPathCache[$pathId] = [];
            $fileInxRes = Translate\Index\Internals\FileIndexTable::getList([
                'filter' => ['=PATH_ID' => $pathId],
                'order' => ['ID' => 'ASC'],
                'select' => ['LANG_ID', 'FULL_PATH'],
            ]);
            while ($fileInx = $fileInxRes->fetch())
            {
                $this->fullPathCache[$pathId][$fileInx['LANG_ID']] = $fileInx['FULL_PATH'];
            }
        }
 
        return $this->fullPathCache[$pathId];
    }
}