Class luya\testsuite\components\DummyFileSystem

                public function __call($name, $params)
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $object) {
        if ($object->hasMethod($name)) {
            return call_user_func_array([$object, $name], $params);
        }
    }
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __clone()
{
    $this->_events = [];
    $this->_eventWildcards = [];
    $this->_behaviors = null;
}

            

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

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        // read property, e.g. getName()
        return $this->$getter();
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name;
        }
    }
    if (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canGetProperty($name)) {
            return $behavior->$name !== null;
        }
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        // set property
        $this->$setter($value);
        return;
    } elseif (strncmp($name, 'on ', 3) === 0) {
        // on event: attach event handler
        $this->on(trim(substr($name, 3)), $value);
        return;
    } elseif (strncmp($name, 'as ', 3) === 0) {
        // as behavior: attach behavior
        $name = trim(substr($name, 3));
        $this->attachBehavior($name, $value instanceof Behavior ? $value : Yii::createObject($value));
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = $value;
            return;
        }
    }
    if (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
        return;
    }
    // behavior property
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $behavior) {
        if ($behavior->canSetProperty($name)) {
            $behavior->$name = null;
            return;
        }
    }
    throw new InvalidCallException('Unsetting an unknown or read-only property: ' . get_class($this) . '::' . $name);
}

            

                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 attachBehavior($name, $behavior)
{
    $this->ensureBehaviors();
    return $this->attachBehaviorInternal($name, $behavior);
}

            

                public function attachBehaviors($behaviors)
{
    $this->ensureBehaviors();
    foreach ($behaviors as $name => $behavior) {
        $this->attachBehaviorInternal($name, $behavior);
    }
}

            

                public function behaviors()
{
    return [];
}

            

                public function canGetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canGetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function canSetProperty($name, $checkVars = true, $checkBehaviors = true)
{
    if (method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->canSetProperty($name, $checkVars)) {
                return true;
            }
        }
    }
    return false;
}

            

                public static function className()
{
    return get_called_class();
}

            

                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 deleteHasCache($key)
{
    if ($this->isCachable()) {
        return Yii::$app->cache->delete($key);
    }
    
    return false;
}

            

                public function detachBehavior($name)
{
    $this->ensureBehaviors();
    if (isset($this->_behaviors[$name])) {
        $behavior = $this->_behaviors[$name];
        unset($this->_behaviors[$name]);
        $behavior->detach();
        return $behavior;
    }
    return null;
}

            

                public function detachBehaviors()
{
    $this->ensureBehaviors();
    foreach ($this->_behaviors as $name => $behavior) {
        $this->detachBehavior($name);
    }
}

            

                public function ensureBehaviors()
{
    if ($this->_behaviors === null) {
        $this->_behaviors = [];
        foreach ($this->behaviors() as $name => $behavior) {
            $this->attachBehaviorInternal($name, $behavior);
        }
    }
}

            

                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),
    ];
}

            

                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 flushHasCache()
{
    if ($this->isCachable()) {
        return Yii::$app->cache->flush();
    }
    
    return false;
}

            

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

            

                public function getBehavior($name)
{
    $this->ensureBehaviors();
    return isset($this->_behaviors[$name]) ? $this->_behaviors[$name] : null;
}

            

                public function getBehaviors()
{
    $this->ensureBehaviors();
    return $this->_behaviors;
}

            

                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 getHasCache($key)
{
    if ($this->isCachable()) {
        $data = Yii::$app->cache->get($key);
        
        $enumKey = (is_array($key)) ? implode(",", $key) : $key;
        
        if ($data) {
            Yii::debug("Cacheable trait key '$enumKey' successfully loaded from cache.", __METHOD__);
            return $data;
        }
        Yii::debug("Cacheable trait key '$enumKey' has not been found in cache.", __METHOD__);
    }

    return 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 getOrSetHasCache($key, \Closure $closure, $duration = null, $dependency = null)
{
    if (($value = $this->getHasCache($key)) !== false) {
        return $value;
    }
    
    $value = call_user_func($closure, $this);
    
    $this->setHasCache($key, $value, $dependency, $duration);
    
    return $value;
}

            

                public function hasEventHandlers($name)
{
    $this->ensureBehaviors();
    if (!empty($this->_events[$name])) {
        return true;
    }
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (!empty($handlers) && StringHelper::matchWildcard($wildcard, $name)) {
            return true;
        }
    }
    return Event::hasHandlers($this, $name);
}

            

                public function hasMethod($name, $checkBehaviors = true)
{
    if (method_exists($this, $name)) {
        return true;
    } elseif ($checkBehaviors) {
        $this->ensureBehaviors();
        foreach ($this->_behaviors as $behavior) {
            if ($behavior->hasMethod($name)) {
                return true;
            }
        }
    }
    return false;
}

            

                public function hasProperty($name, $checkVars = true, $checkBehaviors = true)
{
    return $this->canGetProperty($name, $checkVars, $checkBehaviors) || $this->canSetProperty($name, false, $checkBehaviors);
}

            

                public function init()
{
}

            

                public function isCachable()
{
    if ($this->_cachable === null) {
        $this->_cachable = Yii::$app->has('cache') ? true : false;
    }

    return $this->_cachable;
}

            

                public function off($name, $handler = null)
{
    $this->ensureBehaviors();
    if (empty($this->_events[$name]) && empty($this->_eventWildcards[$name])) {
        return false;
    }
    if ($handler === null) {
        unset($this->_events[$name], $this->_eventWildcards[$name]);
        return true;
    }
    $removed = false;
    // plain event names
    if (isset($this->_events[$name])) {
        foreach ($this->_events[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_events[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_events[$name] = array_values($this->_events[$name]);
            return true;
        }
    }
    // wildcard event names
    if (isset($this->_eventWildcards[$name])) {
        foreach ($this->_eventWildcards[$name] as $i => $event) {
            if ($event[0] === $handler) {
                unset($this->_eventWildcards[$name][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            $this->_eventWildcards[$name] = array_values($this->_eventWildcards[$name]);
            // remove empty wildcards to save future redundant regex checks:
            if (empty($this->_eventWildcards[$name])) {
                unset($this->_eventWildcards[$name]);
            }
        }
    }
    return $removed;
}

            

                public function on($name, $handler, $data = null, $append = true)
{
    $this->ensureBehaviors();
    if (strpos($name, '*') !== false) {
        if ($append || empty($this->_eventWildcards[$name])) {
            $this->_eventWildcards[$name][] = [$handler, $data];
        } else {
            array_unshift($this->_eventWildcards[$name], [$handler, $data]);
        }
        return;
    }
    if ($append || empty($this->_events[$name])) {
        $this->_events[$name][] = [$handler, $data];
    } else {
        array_unshift($this->_events[$name], [$handler, $data]);
    }
}

            

                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 setHasCache($key, $value, $dependency = null, $cacheExpiration = null)
{
    if ($this->isCachable()) {
        if (is_array($dependency)) {
            $dependency = Yii::createObject($dependency);
        }
        
        return Yii::$app->cache->set($key, $value, is_null($cacheExpiration) ? $this->_cacheExpiration : $cacheExpiration, $dependency);
    }
    
    return false;
}

            

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

            

                public function trigger($name, Event $event = null)
{
    $this->ensureBehaviors();
    $eventHandlers = [];
    foreach ($this->_eventWildcards as $wildcard => $handlers) {
        if (StringHelper::matchWildcard($wildcard, $name)) {
            $eventHandlers[] = $handlers;
        }
    }
    if (!empty($this->_events[$name])) {
        $eventHandlers[] = $this->_events[$name];
    }
    if (!empty($eventHandlers)) {
        $eventHandlers = call_user_func_array('array_merge', $eventHandlers);
        if ($event === null) {
            $event = new Event();
        }
        if ($event->sender === null) {
            $event->sender = $this;
        }
        $event->handled = false;
        $event->name = $name;
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            // stop further handling if the event is handled
            if ($event->handled) {
                return;
            }
        }
    }
    // invoke class-level attached handlers
    Event::trigger($this, $name, $event);
}