TempFile.php

<?php
 
namespace Bitrix\UI\FileUploader;
 
use Bitrix\Main\Loader;
use Bitrix\Main\Security;
use Bitrix\Main\IO;
use Bitrix\Main\Result;
 
final class TempFile extends EO_TempFile
{
    private ?\CCloudStorageBucket $bucket = null;
 
    public static function create(Chunk $chunk, UploaderController $controller): Result
    {
        $result = new Result();
        $file = $chunk->getFile();
        if (!$file->isExists())
        {
            return $result->addError(new UploaderError(UploaderError::CHUNK_NOT_FOUND));
        }
 
        if (mb_strpos($file->getPhysicalPath(), \CTempFile::getAbsoluteRoot()) !== 0)
        {
            // A chunk file could be saved in any folder.
            // Copy it to the temporary directory. We need to normalize the absolute path.
            $tempFilePath = self::generateLocalTempFile();
            if (!copy($chunk->getFile()->getPhysicalPath(), $tempFilePath))
            {
                return $result->addError(new UploaderError(UploaderError::CHUNK_COPY_FAILED));
            }
 
            $newFile = new IO\File($tempFilePath);
            if (!$newFile->isExists())
            {
                return $result->addError(new UploaderError(UploaderError::CHUNK_COPY_FAILED));
            }
 
            $chunk->setFile($newFile);
        }
 
        $tempFile = null;
        if ($chunk->isOnlyOne())
        {
            // Cloud and local files are processed by CFile::SaveFile.
            $tempFile = self::createTempFile($chunk, $controller);
        }
        else
        {
            // Multipart upload
            $bucket = self::findBucketForFile($chunk, $controller);
            if ($bucket)
            {
                // cloud file
                $tempFile = self::createTempFile($chunk, $controller, $bucket);
                $appendResult = $tempFile->appendToCloud($chunk);
                if (!$appendResult->isSuccess())
                {
                    $chunk->getFile()->delete();
                    $tempFile->delete();
 
                    return $result->addErrors($appendResult->getErrors());
                }
            }
            else
            {
                // local file
                $localTempDir = self::generateLocalTempDir();
                if (!$file->rename($localTempDir))
                {
                    return $result->addError(new UploaderError(UploaderError::FILE_MOVE_FAILED));
                }
 
                $tempFile = self::createTempFile($chunk, $controller);
            }
        }
 
        $result->setData(['tempFile' => $tempFile]);
 
        return $result;
    }
 
    protected static function createTempFile(Chunk $chunk, UploaderController $controller, $bucket = null): TempFile
    {
        $tempFile = new TempFile();
        $tempFile->setFilename($chunk->getName());
        $tempFile->setMimetype($chunk->getType());
        $tempFile->setSize($chunk->getFileSize());
        $tempFile->setReceivedSize($chunk->getSize());
        $tempFile->setWidth($chunk->getWidth());
        $tempFile->setHeight($chunk->getHeight());
        $tempFile->setModuleId($controller->getModuleId());
        $tempFile->setController($controller->getName());
 
        if ($bucket)
        {
            $path = self::generateCloudTempDir($bucket);
        }
        else
        {
            $path = $chunk->getFile()->getPhysicalPath();
            $tempRoot = \CTempFile::getAbsoluteRoot();
            $path = mb_substr($path, mb_strlen($tempRoot));
        }
 
        $tempFile->setPath($path);
 
        if ($bucket)
        {
            $tempFile->setCloud(true);
            $tempFile->setBucketId($bucket->ID);
        }
 
        $tempFile->save();
 
        return $tempFile;
    }
 
    public function append(Chunk $chunk): Result
    {
        $result = new Result();
 
        if ($chunk->getEndRange() < $this->getReceivedSize())
        {
            // We already have this part of the file
            return $result;
        }
 
        if ($this->getReceivedSize() !== $chunk->getStartRange())
        {
            return $result->addError(new UploaderError(UploaderError::INVALID_CHUNK_OFFSET));
        }
 
        if ($this->getReceivedSize() + $chunk->getSize() > $this->getSize())
        {
            return $result->addError(new UploaderError(UploaderError::CHUNK_TOO_BIG));
        }
 
        $result = $this->isCloud() ? $this->appendToCloud($chunk) : $this->appendToFile($chunk);
        if ($result->isSuccess())
        {
            $this->increaseReceivedSize($chunk->getSize());
        }
 
        // Remove a temporary chunk file immediately
        $chunk->getFile()->delete();
 
        return $result;
    }
 
    public function commit(CommitOptions $commitOptions): Result
    {
        $fileAbsolutePath = $this->getAbsolutePath();
 
        $fileId = \CFile::saveFile(
            [
                'name' => $this->getFilename(),
                'tmp_name' => $fileAbsolutePath,
                'type' => $this->getMimetype(),
                'MODULE_ID' => $commitOptions->getModuleId(),
                'width' => $this->getWidth(),
                'height' => $this->getHeight(),
                'size' => $this->getSize(),
            ],
            $commitOptions->getSavePath(),
            $commitOptions->isForceRandom(),
            $commitOptions->isSkipExtension(),
            $commitOptions->getAddDirectory()
        );
 
        $result = new Result();
        if (!$fileId)
        {
            $this->delete();
 
            return $result->addError(new UploaderError(UploaderError::SAVE_FILE_FAILED));
        }
 
        $this->setFileId($fileId);
        $this->setUploaded(true);
        $this->save();
        $this->fillFile();
 
        $this->removeActualTempFile();
 
        return $result;
    }
 
    public function isCloud(): bool
    {
        return $this->getCloud() && $this->getBucketId() > 0;
    }
 
    public function makePersistent(): void
    {
        $this->customData->set('deleteBFile', false);
        $this->delete();
    }
 
    public function deleteContent($deleteBFile = true): void
    {
        $this->removeActualTempFile();
        if ($deleteBFile)
        {
            \CFile::delete($this->getFileId());
        }
    }
 
    private function removeActualTempFile(): bool
    {
        if ($this->getDeleted())
        {
            return true;
        }
 
        $success = false;
        if ($this->isCloud())
        {
            $bucket = $this->getBucket();
            if ($bucket)
            {
                $success = $bucket->deleteFile($this->getPath());
            }
        }
        else
        {
            $success = IO\File::deleteFile($this->getAbsolutePath());
        }
 
        if ($success)
        {
            $this->setDeleted(true);
            $this->save();
        }
 
        return $success;
    }
 
    private function getAbsoluteCloudPath(): ?string
    {
        $bucket = $this->getBucket();
        if (!$bucket)
        {
            return null;
        }
 
        return $bucket->getFileSRC($this->getPath());
    }
 
    private function getAbsoluteLocalPath(): string
    {
        return \CTempFile::getAbsoluteRoot() . $this->getPath();
    }
 
    private function getAbsolutePath(): ?string
    {
        if ($this->isCloud())
        {
            return $this->getAbsoluteCloudPath();
        }
 
        return $this->getAbsoluteLocalPath();
    }
 
    private function appendToFile(Chunk $chunk): Result
    {
        $result = new Result();
        $file = new IO\File($this->getAbsoluteLocalPath());
 
        if ($chunk->isFirst() || !$file->isExists())
        {
            return $result->addError(new UploaderError(UploaderError::FILE_APPEND_NOT_FOUND));
        }
 
        if ($chunk->getEndRange() < $file->getSize())
        {
            // We already have this part of the file
            return $result;
        }
 
        if (!$chunk->getFile()->isExists())
        {
            return $result->addError(new UploaderError(UploaderError::CHUNK_APPEND_NOT_FOUND));
        }
 
        if ($file->putContents($chunk->getFile()->getContents(), IO\File::APPEND) === false)
        {
            return $result->addError(new UploaderError(UploaderError::CHUNK_APPEND_FAILED));
        }
 
        return $result;
    }
 
    private function appendToCloud(Chunk $chunk): Result
    {
        $result = new Result();
        $bucket = $this->getBucket();
        if (!$bucket)
        {
            return $result->addError(new UploaderError(UploaderError::CLOUD_EMPTY_BUCKET));
        }
 
        $minUploadSize = $bucket->getService()->getMinUploadPartSize();
        if ($chunk->getSize() < $minUploadSize && !$chunk->isLast())
        {
            $postMaxSize = \CUtil::unformat(ini_get('post_max_size'));
            $uploadMaxFileSize = \CUtil::unformat(ini_get('upload_max_filesize'));
 
            return $result->addError(
                new UploaderError(
                    UploaderError::CLOUD_INVALID_CHUNK_SIZE,
                    [
                        'chunkSize' => $chunk->getSize(),
                        'minUploadSize' => $minUploadSize,
                        'postMaxSize' => $postMaxSize,
                        'uploadMaxFileSize' => $uploadMaxFileSize,
                    ]
                )
            );
        }
 
        $cloudUpload = new \CCloudStorageUpload($this->getPath());
        if (!$cloudUpload->isStarted() && !$cloudUpload->start($bucket->ID, $chunk->getFileSize(), $chunk->getType()))
        {
            return $result->addError(new UploaderError(UploaderError::CLOUD_START_UPLOAD_FAILED));
        }
 
        if ($cloudUpload->getPos() === doubleval($chunk->getEndRange() + 1))
        {
            // We already have this part of the file.
            if ($chunk->isLast() && !$cloudUpload->finish())
            {
                return $result->addError(new UploaderError(UploaderError::CLOUD_FINISH_UPLOAD_FAILED));
            }
 
            return $result;
        }
 
        $fileContent = $chunk->getFile()->isExists() ? $chunk->getFile()->getContents() : false;
        if ($fileContent === false)
        {
            return $result->addError(new UploaderError(UploaderError::CLOUD_GET_CONTENTS_FAILED));
        }
 
        $fails = 0;
        $success = false;
        while ($cloudUpload->hasRetries())
        {
            if ($cloudUpload->next($fileContent))
            {
                $success = true;
                break;
            }
 
            $fails++;
        }
 
        if (!$success)
        {
            // TODO: CCloudStorageUpload::CleanUp
            return $result->addError(new UploaderError(UploaderError::CLOUD_UPLOAD_FAILED, ['fails' => $fails]));
        }
 
        if ($chunk->isLast() && !$cloudUpload->finish())
        {
            // TODO: CCloudStorageUpload::CleanUp
            return $result->addError(new UploaderError(UploaderError::CLOUD_FINISH_UPLOAD_FAILED));
        }
 
        return $result;
    }
 
    private function increaseReceivedSize(int $bytes): void
    {
        $receivedSize = $this->getReceivedSize();
        $this->setReceivedSize($receivedSize + $bytes);
        $this->save();
    }
 
    private static function findBucketForFile(Chunk $chunk, UploaderController $controller): ?\CCloudStorageBucket
    {
        if (!Loader::includeModule('clouds'))
        {
            return null;
        }
 
        $bucket = \CCloudStorage::findBucketForFile(
            [
                'FILE_SIZE' => $chunk->getFileSize(),
                'MODULE_ID' => $controller->getCommitOptions()->getModuleId(),
            ],
            $chunk->getName()
        );
 
        if (!$bucket || !$bucket->init())
        {
            return null;
        }
 
        return $bucket;
    }
 
    public static function generateLocalTempDir(int $hoursToKeepFile = 12): string
    {
        $directory = \CTempFile::getDirectoryName(
            $hoursToKeepFile,
            [
                'file-uploader',
                Security\Random::getString(32),
            ]
        );
 
        if (!IO\Directory::isDirectoryExists($directory))
        {
            IO\Directory::createDirectory($directory);
        }
 
        $tempName = md5(mt_rand() . mt_rand());
 
        return $directory . $tempName;
    }
 
    public static function generateLocalTempFile(): string
    {
        $tmpFilePath = \CTempFile::getFileName('file-uploader' . uniqid(md5(mt_rand() . mt_rand()), true));
        $directory = IO\Path::getDirectory($tmpFilePath);
        if (!IO\Directory::isDirectoryExists($directory))
        {
            IO\Directory::createDirectory($directory);
        }
 
        return $tmpFilePath;
    }
 
    public static function generateCloudTempDir(\CCloudStorageBucket $bucket, int $hoursToKeepFile = 12): string
    {
        $directory = \CCloudTempFile::getDirectoryName(
            $bucket,
            $hoursToKeepFile,
            [
                'file-uploader',
                Security\Random::getString(32),
            ]
        );
 
        $tempName = md5(mt_rand() . mt_rand());
 
        return $directory . $tempName;
    }
 
    private function getBucket(): ?\CCloudStorageBucket
    {
        if ($this->bucket !== null)
        {
            return $this->bucket;
        }
 
        if (!$this->getBucketId() || !Loader::includeModule('clouds'))
        {
            return null;
        }
 
        $bucket = new \CCloudStorageBucket($this->getBucketId());
        if ($bucket->init())
        {
            $this->bucket = $bucket;
        }
 
        return $this->bucket;
    }
}