Abstract Class luya\admin\storage\BaseFileSystemStorage

                public function __construct(Request $request, array $config = [])
{
    $this->request = $request;
    parent::__construct($config);
}

            

                public function addFile($fileSource, $fileName, $folderId = 0, $isHidden = false)
{
    $fileData = $this->ensureFileUpload($fileSource, $fileName);
    $fileHash = FileHelper::md5sum($fileSource);
    $newName = implode('.', [$fileData['secureFileName'].'_'.$fileData['hashName'], $fileData['extension']]);
    if (!$this->fileSystemSaveFile($fileSource, $newName)) {
        return false;
    }
    $model = new StorageFile();
    $model->setAttributes([
        'name_original' => $fileName,
        'name_new' => $fileData['secureFileName'],
        'name_new_compound' => $newName,
        'mime_type' => $fileData['mimeType'],
        'extension' => $fileData['extension'],
        'folder_id' => (int) $folderId,
        'hash_file' => $fileHash,
        'hash_name' => $fileData['hashName'],
        'is_hidden' => $isHidden ? true : false,
        'is_deleted' => false,
        'file_size' => $fileData['fileSize'],
        'caption' => null,
        'inline_disposition' => (int) Module::getInstance()->fileDefaultInlineDisposition,
    ]);
    if ($model->validate()) {
        if ($model->save()) {
            if ($model->isImage && $this->queueFilters) {
                $this->queueJobIds[] = Yii::$app->adminqueue->push(new ImageFilterJob(['fileId' => $model->id, 'filterIdentifiers' => $this->queueFiltersList]));
            }
            $this->trigger(self::FILE_SAVE_EVENT, new FileEvent(['file' => $model]));
            $this->deleteHasCache(self::CACHE_KEY_FILE);
            $this->_filesArray[$model->id] = $model->toArray();
            return $this->getFile($model->id);
        }
    }
    return false;
}

            

                public function addFolder($folderName, $parentFolderId = 0)
{
    $model = new StorageFolder();
    $model->name = $folderName;
    $model->parent_id = $parentFolderId;
    $model->timestamp_create = time();
    $this->deleteHasCache(self::CACHE_KEY_FOLDER);
    if ($model->save(false)) {
        return $model->id;
    }
    return false;
}

            

                public function addImage($fileId, $filterId = 0, $throwException = false)
{
    try {
        // if the filterId is provded as a string the filter will be looked up by its name in the get filters array list.
        if (is_string($filterId) && !is_numeric($filterId)) {
            $filterLookup = $this->getFiltersArrayItem($filterId);
            if (!$filterLookup) {
                throw new Exception("The provided filter name " . $filterId . " does not exist.");
            }
            $filterId = $filterLookup['id'];
        }
        $query = (new \luya\admin\image\Query())->where(['file_id' => $fileId, 'filter_id' => $filterId])->one();
        if ($query && $query->fileExists) {
            return $query;
        }
        $fileQuery = $this->getFile($fileId);
        if (!$fileQuery || !$fileQuery->fileExists) {
            if ($fileQuery !== false) {
                throw new Exception("Unable to create image, the base file server source '{$fileQuery->serverSource}' does not exist.");
            }
            throw new Exception("Unable to find the file with id '{$fileId}', image can not be created.");
        }
        $model = $this->createImage($fileId, $filterId);
        if (!$model) {
            throw new Exception("Unable to create the image on the filesystem.");
        }
        $this->_imagesArray[$model->id] = $model->toArray();
        $this->deleteHasCache(self::CACHE_KEY_IMAGE);
        return $this->getImage($model->id);
    } catch (\Exception $err) {
        if ($throwException) {
            throw $err;
        }
    }
    return false;
}

            

                public function createImage($fileId, $filterId)
{
    gc_collect_cycles();
    $image = StorageImage::find()->where(['file_id' => $fileId, 'filter_id' => $filterId])->one();
    // the image exists already in the database and the file system
    if ($image && $image->fileExists) {
        return $image;
    }
    $file = StorageFile::findOne($fileId);
    // https://github.com/luyadev/luya-module-admin/issues/415
    if (!$file && !$file->isImage) {
        return false;
    }
    // create the new image name
    $fileName = $filterId.'_'.$file->name_new_compound;
    $fromTempFile = @tempnam(sys_get_temp_dir(), 'fromFile'); // @see https://www.php.net/manual/de/function.tempnam.php#120451 & https://github.com/luyadev/luya-module-admin/issues/316
    $fromTempFile.= $fileName;
    $content = $file->getContent();
    // it seems the content can not be found.
    if ($content === false) {
        return false;
    }
    $writeFile = FileHelper::writeFile($fromTempFile, $content);
    // unable to write the temp file
    if (!$writeFile) {
        return false;
    }
    // create a temp file
    $tempFile = @tempnam(sys_get_temp_dir(), 'destFile'); // @see https://www.php.net/manual/de/function.tempnam.php#120451 & https://github.com/luyadev/luya-module-admin/issues/316
    $tempFile.= $fileName;
    // there is no filter, which means we create an image version for a given file.
    if (empty($filterId)) {
        @copy($fromTempFile, $tempFile);
    } else {
        $filter = StorageFilter::findOne($filterId);
        if (!$filter || !$filter->applyFilterChain($fromTempFile, $tempFile)) {
            return false;
        }
    }
    $resolution = Storage::getImageResolution($tempFile);
    // now copy the file to the storage system
    $this->fileSystemSaveFile($tempFile, $fileName);
    FileHelper::unlink($tempFile);
    FileHelper::unlink($fromTempFile);
    $this->flushImageArray();
    // ensure the existing of the model
    if ($image) {
        $image->resolution_height = $resolution['height'];
        $image->resolution_width = $resolution['width'];
        $image->save();
        return $image;
    }
    $image = new StorageImage();
    $image->file_id = $fileId;
    $image->filter_id = $filterId;
    $image->resolution_height = $resolution['height'];
    $image->resolution_width = $resolution['width'];
    if (!$image->save()) {
        return false;
    }
    return $image;
}

            

                public function ensureFileUpload($fileSource, $fileName)
{
    // throw exception if source or name is empty
    if (empty($fileSource) || empty($fileName)) {
        throw new Exception("Filename and source can not be empty.");
    }
    // if filename is blob, its a paste event from the browser, therefore generate the filename from the file source.
    // @TODO: move out of ensureFileUpload
    if ($fileName == 'blob') {
        $ext = FileHelper::getExtensionsByMimeType(FileHelper::getMimeType($fileSource));
        $fileName = 'paste-'.date("Y-m-d-H-i").'.'.$ext[0];
    }
    // get file informations from the name
    $fileInfo = FileHelper::getFileInfo($fileName);
    // get the mimeType from the fileSource, if $secureFileUpload is disabled, the mime type will be extracted from the file extensions
    // instead of using the fileinfo extension, therefore this is not recommend.
    $mimeType = FileHelper::getMimeType($fileSource, null, !$this->secureFileUpload);
    // empty mime type indicates a wrong file upload.
    if (empty($mimeType)) {
        throw new Exception("Unable to find mimeType for the given file, make sure the php extension 'fileinfo' is installed.");
    }
    $extensionsFromMimeType = FileHelper::getExtensionsByMimeType($mimeType);
    if (empty($extensionsFromMimeType) && empty($this->whitelistExtensions)) {
        throw new Exception("Unable to find extension for given mimeType \"{$mimeType}\" or it contains insecure data.");
    }
    if (!empty($this->whitelistExtensions)) {
        $extensionsFromMimeType = array_merge($extensionsFromMimeType, $this->whitelistExtensions);
    }
    // check if the file extension is matching the entries from FileHelper::getExtensionsByMimeType array.
    if (!in_array($fileInfo->extension, $extensionsFromMimeType) && !in_array($mimeType, $this->whitelistMimeTypes)) {
        throw new Exception("The given file extension \"{$fileInfo->extension}\" for file with mimeType \"{$mimeType}\" is not matching any valid extension: ".VarDumper::dumpAsString($extensionsFromMimeType).".");
    }
    foreach ($extensionsFromMimeType as $extension) {
        if (in_array($extension, $this->dangerousExtensions)) {
            throw new Exception("The file extension '{$extension}' seems to be dangerous and can not be stored.");
        }
    }
    // check whether a mimetype is in the dangerousMimeTypes list and not whitelisted in whitelistMimeTypes.
    if (in_array($mimeType, $this->dangerousMimeTypes) && !in_array($mimeType, $this->whitelistMimeTypes)) {
        throw new Exception("The file mimeType '{$mimeType}' seems to be dangerous and can not be stored.");
    }
    return [
        'fileInfo' => $fileInfo,
        'mimeType' => $mimeType,
        'fileName' => $fileName,
        'secureFileName' => Inflector::slug(str_replace('_', '-', $fileInfo->name), '-'),
        'fileSource' => $fileSource,
        'fileSize' => filesize($fileSource),
        'extension' => $fileInfo->extension,
        'hashName' => FileHelper::hashName($fileName),
    ];
}

            

                abstract public function fileAbsoluteHttpPath($fileName);

            

                abstract public function fileHttpPath($fileName);

            

                abstract public function fileServerPath($fileName);

            

                abstract public function fileSystemContent($fileName);

            

                abstract public function fileSystemDeleteFile($fileName);

            

                abstract public function fileSystemExists($fileName);

            

                abstract public function fileSystemReplaceFile($fileName, $newSource);

            

                abstract public function fileSystemSaveFile($source, $fileName);

            

                abstract public function fileSystemStream($fileName);

            

                public function findFile(array $args)
{
    return (new \luya\admin\file\Query())->where($args)->one();
}

            

                public function findFiles(array $args = [])
{
    return (new \luya\admin\file\Query())->where($args)->all();
}

            

                public function findFolder(array $args = [])
{
    return (new \luya\admin\folder\Query())->where($args)->one();
}

            

                public function findFolders(array $args = [])
{
    return (new \luya\admin\folder\Query())->where($args)->all();
}

            

                public function findImage(array $args = [])
{
    return (new \luya\admin\image\Query())->where($args)->one();
}

            

                public function findImages(array $args = [])
{
    return (new \luya\admin\image\Query())->where($args)->all();
}

            

                public function flushArrays()
{
    $this->_filesArray = null;
    $this->_imagesArray = null;
    $this->_foldersArray = null;
    $this->_filtersArray = null;
    $this->deleteHasCache(self::CACHE_KEY_FILE);
    $this->deleteHasCache(self::CACHE_KEY_IMAGE);
    $this->deleteHasCache(self::CACHE_KEY_FOLDER);
    $this->deleteHasCache(self::CACHE_KEY_FILTER);
}

            

                public function flushImageArray()
{
    $this->deleteHasCache(self::CACHE_KEY_IMAGE);
}

            

                public function getFile($fileId)
{
    return (new \luya\admin\file\Query())->findOne($fileId);
}

            

                public function getFilesArray()
{
    if ($this->_filesArray === null) {
        $this->_filesArray = $this->getQueryCacheHelper((new Query())->from('{{%admin_storage_file}}')->select(['id', 'is_hidden', 'is_deleted', 'folder_id', 'name_original', 'name_new', 'name_new_compound', 'mime_type', 'extension', 'hash_name', 'hash_file', 'upload_timestamp', 'file_size', 'upload_user_id', 'caption'])->indexBy('id'), self::CACHE_KEY_FILE);
    }
    return $this->_filesArray;
}

            

                public function getFilesArrayItem($fileId)
{
    return $this->filesArray[$fileId] ?? false;
}

            

                public function getFilterId($identifier)
{
    $filter = $this->getFiltersArrayItem($identifier);
    return $filter ? (int) $filter['id'] : false;
}

            

                public function getFiltersArray()
{
    if ($this->_filtersArray === null) {
        $this->_filtersArray = $this->getQueryCacheHelper((new Query())->from('{{%admin_storage_filter}}')->select(['id', 'identifier', 'name'])->indexBy('identifier')->orderBy(['name' => SORT_ASC]), self::CACHE_KEY_FILTER);
    }
    return $this->_filtersArray;
}

            

                public function getFiltersArrayItem($filterIdentifier)
{
    return $this->filtersArray[$filterIdentifier] ?? false;
}

            

                public function getFolder($folderId)
{
    return (new \luya\admin\folder\Query())->where(['id' => $folderId])->one();
}

            

                public function getFoldersArray()
{
    if ($this->_foldersArray === null) {
        $query = (new Query())
            ->from('{{%admin_storage_folder}} as folder')
            ->select(['folder.id', 'name', 'parent_id', 'timestamp_create', 'COUNT(file.id) filesCount'])
            ->where(['folder.is_deleted' => false])
            ->orderBy(['name' => SORT_ASC, 'parent_id' => SORT_ASC])
            ->leftJoin('{{%admin_storage_file}} as file', 'folder.id=file.folder_id AND file.is_deleted = :deleted', [':deleted' => false])
            ->groupBy(['folder.id'])
            ->indexBy(['id']);
        $this->_foldersArray = $this->getQueryCacheHelper($query, self::CACHE_KEY_FOLDER);
    }
    return $this->_foldersArray;
}

            

                public function getFoldersArrayItem($folderId)
{
    return $this->foldersArray[$folderId] ?? false;
}

            

                public function getImage($imageId)
{
    return (new \luya\admin\image\Query())->findOne($imageId);
}

            

                public function getImagesArray()
{
    if ($this->_imagesArray === null) {
        $this->_imagesArray = $this->getQueryCacheHelper((new Query())->from('{{%admin_storage_image}}')->select(['id', 'file_id', 'filter_id', 'resolution_width', 'resolution_height'])->indexBy('id'), self::CACHE_KEY_IMAGE);
    }
    return $this->_imagesArray;
}

            

                public function getImagesArrayItem($imageId)
{
    return $this->imagesArray[$imageId] ?? false;
}

            

                public function processThumbnails()
{
    foreach ($this->findFiles(['is_hidden' => false, 'is_deleted' => false]) as $file) {
        if ($file->isImage) {
            // create tiny thumbnail
            $this->createImage($file->id, $this->getFilterId(TinyCrop::identifier()));
            $this->createImage($file->id, $this->getFilterId(MediumThumbnail::identifier()));
        }
    }
    // force auto fix
    $this->autoFixMissingImageSources = true;
    foreach ($this->findImages() as $image) {
        if (!empty($image->file) && !$image->file->isHidden && !$image->file->isDeleted) {
            $image->source; // which forces to recreate missing sources.
        }
    }
    return true;
}

            

                public function setFilesArray(array $files)
{
    $this->_filesArray = $files;
}

            

                public function setFiltersArray(array $filters)
{
    $this->_filtersArray = $filters;
}

            

                public function setImagesArray(array $images)
{
    $this->_imagesArray = $images;
}