archiveentry.php

<?php
namespace Bitrix\Main\Engine\Response\Zip;
 
use Bitrix\Main\Application;
use Bitrix\Main\Text\Encoding;
use Bitrix\Main\Config\Option;
use Bitrix\Main\Web\Uri;
use CFile;
 
class ArchiveEntry
{
    protected $name;
 
    protected $path;
 
    protected $size;
 
    protected $crc32;
 
    protected function __construct()
    {}
 
    public function getName()
    {
        return $this->name;
    }
 
    public function setName($name)
    {
        $this->name = $name;
 
        return $this;
    }
 
    public function getPath()
    {
        return $this->path;
    }
 
    public function getSize()
    {
        return $this->size;
    }
 
    public function getCrc32()
    {
        return $this->crc32;
    }
 
    public static function createFromFilePath($filePath, $name = null)
    {
        $fileArray = CFile::MakeFileArray($filePath);
 
        if (\is_array($fileArray))
        {
            return self::createFromFile([
                'ID' => 0,
                'ORIGINAL_NAME' => $fileArray['name'],
                'FILE_SIZE' => $fileArray['size'],
                'SRC' => mb_substr($fileArray['tmp_name'], mb_strlen(self::getDocRoot())),
            ], $name);
        }
 
        return null;
    }
 
    public static function createFromFileId($fileId, $moduleId = null)
    {
        $fileArray = CFile::getFileArray($fileId);
 
        // check file exists
        if (!\is_array($fileArray) || empty($fileArray['SRC']))
        {
            return null;
        }
 
        // check module restriction
        if (
            $moduleId !== null &&
            (
                !isset($fileArray['MODULE_ID']) ||
                $fileArray['MODULE_ID'] !== $moduleId
            )
        )
        {
            return null;
        }
 
        return self::createFromFile($fileArray);
    }
 
    protected static function createFromFile(array $fileArray, $name = null)
    {
        $zipEntry = new static();
        $zipEntry->setName($name?: $fileArray['ORIGINAL_NAME']);
        $zipEntry->size = (int)$fileArray['FILE_SIZE'];
 
        if (empty($fileArray['SRC']))
        {
            $fileArray['SRC'] = CFile::getFileSrc($fileArray);
        }
 
        $fromClouds = false;
        $filename = $fileArray['SRC'];
        if (isset($fileArray['HANDLER_ID']) && !empty($fileArray['HANDLER_ID']))
        {
            $fromClouds = true;
        }
 
        if ($fromClouds)
        {
            $filename = preg_replace('~^(http[s]?)(\://)~i', '\\1.' , $filename);
            $cloudUploadPath = Option::get(
                'main',
                'bx_cloud_upload',
                '/upload/bx_cloud_upload/'
            );
            $zipEntry->path = $cloudUploadPath . $filename;
        }
        else
        {
            $zipEntry->path = $filename;
        }
        $zipEntry->path = Uri::urnEncode($zipEntry->path, 'UTF-8');
 
        return $zipEntry;
    }
 
    protected static function getDocRoot()
    {
        static $docRoot = null;
 
        if ($docRoot === null)
        {
            $context = Application::getInstance()->getContext();
            $server = $context->getServer();
            $docRoot = $server->getDocumentRoot();
        }
 
        return $docRoot;
    }
 
    public function __toString()
    {
        $crc32 = $this->getCrc32()?: '-';
        $name = Encoding::convertEncoding(
            $this->getName(),
            LANG_CHARSET,
            'UTF-8'
        );
 
        return "{$crc32} {$this->getSize()} {$this->getPath()} {$name}";
    }
}