grabber.php

<?php
namespace Bitrix\Translate\Controller\Asset;
 
use Bitrix\Main;
use Bitrix\Main\Error;
use Bitrix\Main\Localization\Loc;
use Bitrix\Translate;
 
 
class Grabber
    extends Translate\Controller\Controller
    implements Translate\Controller\IProcessParameters
{
    use Translate\Controller\ProcessParams;
 
    const START_PATH = '/bitrix/modules';
 
    const SETTING_ID = 'TRANSLATE_LANGPACK';
 
    const ACTION_COLLECT = 'collect';
    const ACTION_PACK = 'pack';
    const ACTION_DOWNLOAD = 'download';
    const ACTION_UPLOAD = 'upload';
    const ACTION_EXTRACT = 'extract';
    const ACTION_APPLY = 'apply';
    const ACTION_APPLY_PUBLIC = 'apply_public';
    const ACTION_FINALIZE = 'finalize';
    const ACTION_PURGE = 'purge';
    const ACTION_CANCEL = 'cancel';
    const ACTION_CLEAR = 'clear';
 
    private $archiveFilePath;
    private $archiveFileType;
 
 
 
    public function configureActions()
    {
        $configureActions = parent::configureActions();
        $permission = new Translate\Controller\CheckPermission(Translate\Permission::WRITE);
        $permissionSource = new Translate\Controller\CheckPermission(Translate\Permission::SOURCE);
 
        $configureActions[self::ACTION_COLLECT] = [
            'class' => Translate\Controller\Asset\Collect::class,
            '+prefilters' => [
                $permission
            ],
        ];
        $configureActions[self::ACTION_EXTRACT] = [
            'class' => Translate\Controller\Asset\Extract::class,
            '+prefilters' => [
                $permission,
                $permissionSource
            ],
        ];
        $configureActions[self::ACTION_APPLY] = [
            'class' => Translate\Controller\Asset\Apply::class,
            '+prefilters' => [
                $permission,
                $permissionSource
            ],
        ];
        $configureActions[self::ACTION_APPLY_PUBLIC] = [
            'class' => Translate\Controller\Asset\ApplyPublic::class,
            '+prefilters' => [
                $permission,
                $permissionSource
            ],
        ];
        $configureActions[self::ACTION_PACK] = [
            'class' => Translate\Controller\Asset\Pack::class,
            '+prefilters' => [
                $permission
            ],
        ];
        $configureActions[self::ACTION_UPLOAD] = [
            '+prefilters' => [
                $permission
            ],
        ];
        $configureActions[self::ACTION_DOWNLOAD] = [
            '-prefilters' => [
                Main\Engine\ActionFilter\Csrf::class,
            ],
            '+prefilters' => [
                $permission
            ],
        ];
        $configureActions[self::ACTION_PURGE] = [
            '+prefilters' => [
                $permission
            ],
        ];
        $configureActions[self::ACTION_CANCEL] = [
            '+prefilters' => [
                $permission
            ],
        ];
        $configureActions[self::ACTION_CLEAR] = [
            '+prefilters' => [
                $permission
            ],
        ];
        $configureActions[self::ACTION_FINALIZE] = [
            '+prefilters' => [
                $permission
            ],
        ];
 
        return $configureActions;
    }
 
    protected function init()
    {
        parent::init();
        $this->keepField(['archiveFilePath', 'archiveFileType']);
    }
 
    public function uploadAction(): array
    {
        $result = [];
        $success = false;
        if (
            isset($_FILES, $_FILES['tarFile'], $_FILES['tarFile']['tmp_name']) &&
            ($_FILES['tarFile']['error'] == \UPLOAD_ERR_OK) &&
            \file_exists($_FILES['tarFile']['tmp_name'])
        )
        {
            if (
                (\filesize($_FILES['tarFile']['tmp_name']) > 0) &&
                (
                    \mb_substr($_FILES['tarFile']['name'], -7) === '.tar.gz' ||
                    \mb_substr($_FILES['tarFile']['name'], -4) === '.tar'
                )
            )
            {
                if (\mb_substr($_FILES['tarFile']['name'], -7) === '.tar.gz')
                {
                    $suffix = '.tar.gz';
                }
                else
                {
                    $suffix = '.tar';
                }
 
                if ($this->moveUploadedFile($_FILES['tarFile'], $suffix))
                {
                    $this->saveProgressParameters();
                    $success = ($this->hasErrors() === false);
                }
            }
            else
            {
                $this->addError(new Main\Error(Loc::getMessage('TR_ERROR_TARFILE_EXTENTION')));
            }
        }
        else
        {
            if ($_FILES['tarFile']['error'] == UPLOAD_ERR_INI_SIZE)
            {
                $this->addError(
                    new Main\Error(Loc::getMessage('TR_ERROR_UPLOAD_SIZE', [
                        '#SIZE#' => \CFile::formatSize(self::getMaxUploadSize())
                    ]))
                );
            }
            else
            {
                $this->addError(new Main\Error(Loc::getMessage('TR_ERROR_TARFILE')));
            }
        }
 
        if ($success)
        {
            $result['SUMMARY'] = Loc::getMessage('TR_IMPORT_UPLOAD_OK');
        }
 
        $result['STATUS'] = Translate\Controller\STATUS_COMPLETED;
 
        return $result;
    }
 
 
 
    private function moveUploadedFile($postedFile, $suffix = '.tar', $timeToLive = 3): bool
    {
        if (
            isset($postedFile['tmp_name']) &&
            \file_exists($postedFile['tmp_name'])
        )
        {
            $tmpFile = Translate\IO\File::generateTemporalFile('translate', $suffix, $timeToLive);
            if (@\copy($postedFile['tmp_name'], $tmpFile->getPhysicalPath()))
            {
                $this->archiveFileType = $suffix;
                $this->archiveFilePath = $tmpFile->getPhysicalPath();
                return true;
            }
        }
 
        $this->addError(new Main\Error(Loc::getMessage('TR_IMPORT_EMPTY_FILE_ERROR')));
 
        return false;
    }
 
 
    public function finalizeAction(): array
    {
        $settings = $this->getProgressParameters();
 
        // delete tmp files
        if (!empty($settings['tmpFolderPath']))
        {
            $tempLanguageDir = new Translate\IO\Directory($settings['tmpFolderPath']);
            if ($tempLanguageDir->isExists())
            {
                if ($tempLanguageDir->delete() !== true)
                {
                    $this->addError(new Main\Error(Loc::getMessage('TR_ERROR_DELETE_TEMP_FOLDER')));
                }
            }
        }
 
        return [
            'STATUS' => Translate\Controller\STATUS_COMPLETED
        ];
    }
 
 
    public function clearAction(): array
    {
        return $this->purgeAction();
    }
 
 
    public function purgeAction(): array
    {
        $settings = $this->getProgressParameters();
 
        if (!empty($settings['archiveFilePath']))
        {
            $path = new Main\IO\File($settings['archiveFilePath']);
            if ($path->isExists())
            {
                $path->delete();
            }
        }
 
        return [
            'SUMMARY' => Loc::getMessage('TR_EXPORT_FILE_DROPPED'),
            'STATUS' => Translate\Controller\STATUS_COMPLETED
        ];
    }
 
 
    public function cancelAction(): array
    {
        $this->finalizeAction();
        $this->purgeAction();
        $this->clearProgressParameters();
 
        $cancelingAction = $this->request->get('cancelingAction');
        $summary =
            \in_array($cancelingAction, [self::ACTION_COLLECT, self::ACTION_PACK]) ?
                Loc::getMessage('TR_EXPORT_ACTION_CANCELED') :
                Loc::getMessage('TR_IMPORT_ACTION_CANCELED')
        ;
 
        return [
            'SUMMARY' => $summary,
            'STATUS' => Translate\Controller\STATUS_COMPLETED
        ];
    }
 
 
    public function downloadAction()
    {
        $settings = $this->getProgressParameters();
 
        if (!empty($settings['downloadParams']['filePath']) && !empty($settings['downloadParams']['fileName']))
        {
            $file = new Main\IO\File($settings['downloadParams']['filePath']);
            if ($file->isExists())
            {
                $response = new Main\Engine\Response\File(
                    $file->getPath(),
                    $settings['downloadParams']['fileName'],
                    $settings['downloadParams']['fileType']
                );
 
                return $response;
            }
        }
 
        $this->addError(new Error('File not found'));
    }
 
 
    public function getProgressParameterOptionName()
    {
        return self::SETTING_ID;
    }
 
 
    public static function getMaxUploadSize()
    {
        static $maxUploadSize = -1;
        if ($maxUploadSize < 0)
        {
            $maxUploadSize = \min(
                \CUtil::unformat('32M'),
                \CUtil::unformat(\ini_get('post_max_size')),
                \CUtil::unformat(\ini_get('upload_max_filesize'))
            );
        }
 
        return $maxUploadSize;
    }
}