uploader.php

<?
namespace Bitrix\Main\UI\Uploader;
use Bitrix\Main\AccessDeniedException;
use Bitrix\Main\ArgumentOutOfRangeException;
use Bitrix\Main\HttpRequest;
use Bitrix\Main\NotImplementedException;
use \Bitrix\Main\UI\FileInputUtility;
use \Bitrix\Main\Web\Json;
use \Bitrix\Main\Context;
use \Bitrix\Main\Loader;
use \Bitrix\Main\Localization\Loc;
use \Bitrix\Main;
Loc::loadMessages(__FILE__);
Loader::registerAutoLoadClasses(
    "main",
    array(
        "bitrix\\main\\ui\\uploader\\storage" => "lib/ui/uploader/storage.php",
        "bitrix\\main\\ui\\uploader\\cloudstorage" => "lib/ui/uploader/storage.php"
    ));
 
class Log implements \ArrayAccess
{
    /*
     * @var \CBXVirtualFileFileSystem $file
     */
    protected $file = null;
    var $data = array();
 
    function __construct($path)
    {
        try
        {
            $this->file = \CBXVirtualIo::GetInstance()->GetFile($path);
 
            if ($this->file->IsExists())
            {
                $data = unserialize($this->file->GetContents(), ["allowed_classes" => false]);
                foreach($data as $key => $val)
                {
                    if (array_key_exists($key , $this->data) && is_array($this->data[$key]) && is_array($val))
                        $this->data[$key] = array_merge($this->data[$key], $val);
                    else
                        $this->data[$key] = $val;
                }
            }
        }
        catch (\Throwable $e)
        {
            throw new Main\SystemException("Temporary file has wrong structure.", "BXU351.01");
        }
    }
 
    public function setLog($key, $value)
    {
        if (array_key_exists($key, $this->data) && is_array($this->data) && is_array($value))
            $this->data[$key] = array_merge($this->data[$key], $value);
        else
            $this->data[$key] = $value;
        $this->save();
 
        return $this;
    }
 
    public function getValue($key)
    {
        return $this->data[$key];
    }
 
    public function save()
    {
        try
        {
            $this->file->PutContents(serialize($this->data));
        }
        catch (\Throwable $e)
        {
            throw new Main\SystemException("Temporary file was not saved.", "BXU351.02");
        }
    }
 
    public function getLog()
    {
        return $this->data;
    }
 
    public function unlink()
    {
        try
        {
            if ($this->file instanceof \CBXVirtualFileFileSystem && $this->file->IsExists())
                $this->file->unlink();
        }
        catch (\Throwable $e)
        {
            throw new Main\SystemException("Temporary file was not deleted.", "BXU351.03");
        }
    }
 
    public function offsetExists($offset): bool
    {
        return array_key_exists($offset, $this->data);
    }
 
    #[\ReturnTypeWillChange]
    public function offsetGet($offset)
    {
        if (array_key_exists($offset, $this->data))
            return $this->data[$offset];
        return null;
    }
 
    public function offsetSet($offset, $value): void
    {
        $this->setLog($offset, $value);
    }
 
    public function offsetUnset($offset): void
    {
        if (array_key_exists($offset, $this->data))
        {
            unset($this->data[$offset]);
            $this->save();
        }
    }
}
 
class Uploader
{
    public $files = array();
    public $controlId = "fileUploader";
    public $params = array(
        "allowUpload" => "A",
        "allowUploadExt" => "",
        "copies" => array(
            "default" => array(
                "width" => null,
                "height" => null
            ),
        /*  "copyName" => array(
                "width" => 100,
                "height" => 100
            )*/
        ),
        "storage" => array(
            "moduleId" => "main",
            "cloud" => false
        )
    );
/*
 * @var string $script Url to uploading page for forming url to view
 * @var string $path Path to temp directory
 * @var string $CID Controller ID
 * @var string $mode
 * @var array $processTime Time limits
 * @var HttpClient $http
*/
    public $script;
    protected $path = "";
    protected $CID = null;
    protected int $version = 0;
    protected $mode = "view";
    protected $param = array();
    protected $requestMethods = array(
        "get" => true,
        "post" => true
    );
    /* @var HttpRequest $request */
    protected $request;
    protected $http;
 
    const FILE_NAME = "bxu_files";
    const INFO_NAME = "bxu_info";
    const EVENT_NAME = "main_bxu";
    const SESSION_LIST = "MFI_SESSIONS";
    const SESSION_TTL = 86400;
 
    public function __construct($params = array())
    {
        global $APPLICATION;
 
        $this->script = $APPLICATION->GetCurPageParam();
 
        $params = is_array($params) ? $params : array($params);
        $params["copies"] = (isset($params["copies"]) && is_array($params["copies"]) ? $params["copies"] : array()) + $this->params["copies"];
        $params["storage"] = (isset($params["storage"]) && is_array($params["storage"]) ? $params["storage"] : array()) + $this->params["storage"];
        $params["storage"]["moduleId"] = preg_replace("/[^a-z_-]/i", "_", $params["storage"]["moduleId"]);
        $this->params = $params;
        if (array_key_exists("controlId", $params))
            $this->controlId = $params["controlId"];
        if (array_key_exists("events", $params) && is_array($params["events"]))
        {
            foreach($params["events"] as $key => $val)
            {
                $this->setHandler($key, $val);
            }
        }
        unset($this->params["events"]);
 
        $this->path = \CTempFile::GetDirectoryName(
            12,
            array(
                "bxu",
                $this->params["storage"]["moduleId"],
                md5(serialize(array(
                    $this->controlId,
                    bitrix_sessid(),
                    \CMain::GetServerUniqID()
                    ))
                )
            )
        );
        $this->request = Context::getCurrent()->getRequest();
    }
 
    public function setControlId($controlId)
    {
        $this->controlId = $controlId;
    }
 
    public function setHandler($name, $callback)
    {
        AddEventHandler(self::EVENT_NAME, $name, $callback);
        return $this;
    }
    protected static function removeTmpPath($item)
    {
        if (is_array($item))
        {
            if (array_key_exists("tmp_name", $item))
            {
                unset($item["tmp_name"]);
            }
            foreach ($item as $key => $val)
            {
                if ($key == "chunksInfo")
                {
                    $item[$key]["uploaded"] = count($item[$key]["uploaded"]);
                    $item[$key]["written"] = count($item[$key]["written"]);
                }
                else if (is_array($val))
                {
                    $item[$key] = self::removeTmpPath($val);
                }
            }
        }
        return $item;
    }
 
    public static function prepareData($data)
    {
        array_walk_recursive(
            $data,
            function(&$v, $k) {
                if ($k == "error")
                {
                    $v = preg_replace("/<(.+?)>/is".BX_UTF_PCRE_MODIFIER, "", $v);
                }
            }
        );
        return self::removeTmpPath($data);
    }
 
    protected function fillRequireData()
    {
        $this->mode = $this->getRequest("mode");
        if (!in_array($this->mode, array("upload", "delete", "view")))
            throw new ArgumentOutOfRangeException("mode");
 
        if ($this->mode != "view" && !check_bitrix_sessid())
            throw new AccessDeniedException("Bad sessid.");
 
        $this->version = (int) $this->getRequest("version");
 
        $directory = \CBXVirtualIo::GetInstance()->GetDirectory($this->path);
        $directoryExists = $directory->IsExists();
        if (!$directory->Create())
            throw new NotImplementedException("Mandatory directory has not been created.");
        if (!$directoryExists)
        {
            $access = \CBXVirtualIo::GetInstance()->GetFile($directory->GetPath()."/.access.php");
            $content = '<?$PERM["'.$directory->GetName().'"]["*"]="X";?>';
 
            if (!$access->IsExists() || mb_strpos($access->GetContents(), $content) === false)
            {
                if (($fd = $access->Open('ab')))
                {
                    fwrite($fd, $content);
                }
                fclose($fd);
            }
        }
 
        return false;
    }
 
    protected function showJsonAnswer($result)
    {
        if (!defined("PUBLIC_AJAX_MODE"))
            define("PUBLIC_AJAX_MODE", true);
        if (!defined("NO_KEEP_STATISTIC"))
            define("NO_KEEP_STATISTIC", "Y");
        if (!defined("NO_AGENT_STATISTIC"))
            define("NO_AGENT_STATISTIC", "Y");
        if (!defined("NO_AGENT_CHECK"))
            define("NO_AGENT_CHECK", true);
        if (!defined("DisableEventsCheck"))
            define("DisableEventsCheck", true);
 
        require_once(\Bitrix\Main\Application::getInstance()->getContext()->getServer()->getDocumentRoot()."/bitrix/modules/main/include/prolog_before.php");
        global $APPLICATION;
 
        $APPLICATION->RestartBuffer();
 
        $version = IsIE();
        if ( !(0 < $version && $version < 10) )
            header('Content-Type:application/json; charset=UTF-8');
 
        echo Json::encode($result);
        \CMain::finalActions();
        die;
    }
 
    protected function setRequestMethodToCheck(array $methods)
    {
        foreach ($this->requestMethods as $method => $value)
            $this->requestMethods[$method] = in_array($method, $methods);
        return $this;
    }
    protected function getRequest($key)
    {
        if ($this->requestMethods["post"] &&
            is_array($this->request->getPost(self::INFO_NAME)) &&
            array_key_exists($key, $this->request->getPost(self::INFO_NAME)))
        {
            $res = $this->request->getPost(self::INFO_NAME);
            return $res[$key];
        }
        if ($this->requestMethods["get"] &&
            is_array($this->request->getQuery(self::INFO_NAME)) &&
            array_key_exists($key, $this->request->getQuery(self::INFO_NAME)))
        {
            $res = $this->request->getQuery(self::INFO_NAME);
            return $res[$key];
        }
 
        return null;
    }
 
    public function getParam($key)
    {
        return $this->params[$key];
    }
    public function checkPost($checkPost = true)
    {
        if ($checkPost === false && !is_array($this->request->getQuery(self::INFO_NAME)) ||
            $checkPost !== false && !is_array($this->request->getPost(self::INFO_NAME)))
            return false;
 
        if ($checkPost === false)
            $this->setRequestMethodToCheck(array("get"));
 
        try
        {
            $this->fillRequireData();
            $cid = FileInputUtility::instance()->registerControl($this->getRequest("CID"), $this->controlId);
 
            if ($this->mode == "upload")
            {
                $package = new Package(
                    $this->path,
                    $cid,
                    $this->getRequest("packageIndex")
                );
                $package
                    ->setStorage($this->params["storage"])
                    ->setCopies($this->params["copies"]);
 
                $response = $package->checkPost($this->params);
 
                if ($this->version <= 1)
                {
                    $response2 = array();
                    foreach ($response as $k => $r)
                    {
                        $response2[$k] = array(
                            "hash" => $r["hash"],
                            "status" => $r["status"],
                            "file" => $r
                        );
                        if (isset($r["error"]))
                            $response2[$k]["error"] = $r["error"];
                    }
                    $result = array(
                        "status" => $package->getLog("uploadStatus") == "uploaded" ? "done" : "inprogress",
                        "package" => array(
                            $package->getIndex() => array_merge(
                                $package->getLog(),
                                array(
                                    "executed" => $package->getLog("executeStatus") == "executed",
                                    "filesCount" => $package->getLog("filesCount")
                                )
                            )
                        ),
                        "report" => array(
                            "uploading" => array(
                                $package->getCid() => $package->getCidLog()
                            )
                        ),
                        "files" => self::prepareData($response2)
                    );
                    $this->showJsonAnswer($result);
                }
            }
            else if ($this->mode == "delete")
            {
                $cid = FileInputUtility::instance()->registerControl($this->getRequest("CID"), $this->controlId);
                File::deleteFile($cid, $this->getRequest("hash"), $this->path);
            }
            else
            {
                File::viewFile($cid, $this->getRequest("hash"), $this->path);
            }
            return true;
        }
        catch (Main\IO\IoException $e)
        {
            $this->showJsonAnswer(array(
                "status" => "error",
                "error" => "Something went wrong with the temporary file."
            ));
        }
        catch (\Exception $e)
        {
            $this->showJsonAnswer(array(
                "status" => "error",
                "error" => $e->getMessage()
            ));
        }
        return false;
    }
 
    public function checkCanvases($hash, &$file, $canvases = array(), $watermark = array())
    {
        if (!empty($watermark))
        {
            $file["files"]["default"] = File::createCanvas(
                $file["files"]["default"],
                $file["files"]["default"],
                array(),
                $watermark
            );
        }
        if (is_array($canvases))
        {
            foreach ($canvases as $canvas => $canvasParams)
            {
                if (!array_key_exists($canvas, $file["files"]))
                {
                    $source = $file["files"]["default"]; // TODO pick up more appropriate copy by params
                    $file["files"][$canvas] = File::createCanvas($source,
                        array(
                            "code" => $canvas,
                            "tmp_name" => mb_substr($source["tmp_name"], 0, -7).$canvas,
                            "url" => mb_substr($source["url"], 0, -7).$canvas
                        ), $canvasParams, $watermark);
                }
            }
        }
        return $file;
    }
    public function deleteFile($hash) {
        $cid = FileInputUtility::instance()->registerControl($this->getRequest("CID"), $this->controlId);
        File::deleteFile($cid, $hash, $this->path);
    }
 
    public static function getPaths($tmpName)
    {
        $docRoot = null;
        $io = \CBXVirtualIo::GetInstance();
        if (($tempRoot = \CTempFile::GetAbsoluteRoot()) && ($strFilePath = $tempRoot.$tmpName) &&
            $io->FileExists($strFilePath) && ($url = File::getUrlFromRelativePath($tmpName)))
        {
            return array(
                "tmp_url" => $url,
                "tmp_name" => $strFilePath
            );
        }
        else if ((($docRoot = \Bitrix\Main\Application::getInstance()->getContext()->getServer()->getDocumentRoot()) && $strFilePath = $docRoot.$tmpName) && $io->FileExists($strFilePath))
        {
            return array(
                "tmp_url" => $tmpName,
                "tmp_name" => $strFilePath
            );
        }
        else if ($io->FileExists($tmpName) && ($docRoot = \Bitrix\Main\Application::getInstance()->getContext()->getServer()->getDocumentRoot()) &&
            mb_strpos($tmpName, $docRoot) === 0)
        {
            return array(
                "tmp_url" => str_replace("//", "/", "/".mb_substr($tmpName, mb_strlen($docRoot))),
                "tmp_name" => $tmpName
            );
        }
        return false;
    }
 
}