public function execute(Request $request, WorkingFolder $workingFolder, Config $config, CacheManager $cache)
 {
     $fileName = (string) $request->get('fileName');
     if (null === $fileName || !File::isValidName($fileName, $config->get('disallowUnsafeCharacters'))) {
         throw new InvalidRequestException('Invalid file name');
     }
     if (!Image::isSupportedExtension(pathinfo($fileName, PATHINFO_EXTENSION))) {
         throw new InvalidNameException('Invalid source file name');
     }
     if (!$workingFolder->containsFile($fileName)) {
         throw new FileNotFoundException();
     }
     $cachePath = Path::combine($workingFolder->getResourceType()->getName(), $workingFolder->getClientCurrentFolder(), $fileName);
     $imageInfo = array();
     $cachedInfo = $cache->get($cachePath);
     if ($cachedInfo && isset($cachedInfo['width']) && isset($cachedInfo['height'])) {
         $imageInfo = $cachedInfo;
     } else {
         $file = new DownloadedFile($fileName, $this->app);
         if ($file->isValid()) {
             $image = Image::create($file->getContents());
             $imageInfo = $image->getInfo();
             $cache->set($cachePath, $imageInfo);
         }
     }
     return $imageInfo;
 }

 public function execute(Request $request, WorkingFolder $workingFolder, EventDispatcher $dispatcher, CacheManager $cache, ResizedImageRepository $resizedImageRepository, ThumbnailRepository $thumbnailRepository, Acl $acl)
 {
     $fileName = (string) $request->query->get('fileName');
     $editedImage = new EditedImage($fileName, $this->app);
     $saveAsNew = false;
     if (!$editedImage->exists()) {
         $saveAsNew = true;
         $editedImage->saveAsNew(true);
     } else {
         // If file exists check for FILE_DELETE permission
         $resourceTypeName = $workingFolder->getResourceType()->getName();
         $path = $workingFolder->getClientCurrentFolder();
         if (!$acl->isAllowed($resourceTypeName, $path, Permission::FILE_DELETE)) {
             throw new UnauthorizedException(sprintf('Unauthorized: no FILE_DELETE permission in %s:%s', $resourceTypeName, $path));
         }
     }
     if (!Image::isSupportedExtension($editedImage->getExtension())) {
         throw new InvalidExtensionException('Unsupported image type or not image file');
     }
     $imageFormat = Image::mimeTypeFromExtension($editedImage->getExtension());
     $uploadedData = (string) $request->request->get('content');
     if (null === $uploadedData || strpos($uploadedData, 'data:image/png;base64,') !== 0) {
         throw new InvalidUploadException('Invalid upload. Expected base64 encoded PNG image.');
     }
     $data = explode(',', $uploadedData);
     $data = isset($data[1]) ? base64_decode($data[1]) : false;
     if (!$data) {
         throw new InvalidUploadException();
     }
     try {
         $uploadedImage = Image::create($data);
     } catch (\Exception $e) {
         // No need to check if secureImageUploads is enabled - image must be valid here
         throw new InvalidUploadException('Invalid upload: corrupted image', Error::UPLOADED_CORRUPT, array(), $e);
     }
     $editedImage->setNewContents($uploadedImage->getData($imageFormat));
     $editedImage->setNewDimensions($uploadedImage->getWidth(), $uploadedImage->getHeight());
     if (!$editedImage->isValid()) {
         throw new InvalidUploadException('Invalid file provided');
     }
     $editFileEvent = new EditFileEvent($this->app, $editedImage);
     $imageInfo = $uploadedImage->getInfo();
     $cache->set(Path::combine($workingFolder->getResourceType()->getName(), $workingFolder->getClientCurrentFolder(), $fileName), $uploadedImage->getInfo());
     $dispatcher->dispatch(CKFinderEvent::SAVE_IMAGE, $editFileEvent);
     $saved = false;
     if (!$editFileEvent->isPropagationStopped()) {
         $saved = $editedImage->save($editFileEvent->getNewContents());
         if (!$saved) {
             throw new AccessDeniedException("Couldn't save image file");
         }
         //Remove thumbnails and resized images in case if file is overwritten
         if (!$saveAsNew && $saved) {
             $resourceType = $workingFolder->getResourceType();
             $thumbnailRepository->deleteThumbnails($resourceType, $workingFolder->getClientCurrentFolder(), $fileName);
             $resizedImageRepository->deleteResizedImages($resourceType, $workingFolder->getClientCurrentFolder(), $fileName);
         }
     }
     return array('saved' => (int) $saved, 'date' => Utils::formatDate(time()), 'size' => Utils::formatSize($imageInfo['size']));
 }

 /**
  * Main command method.
  *
  * @param Request       $request       Current request object
  * @param WorkingFolder $workingFolder Current working folder object
  *
  * @return array
  *
  * @throws \Exception
  */
 public function execute(Request $request, WorkingFolder $workingFolder)
 {
     $fileName = $request->get('fileName');
     $backend = $workingFolder->getBackend();
     if (!$workingFolder->containsFile($fileName)) {
         throw new \Exception('File not found', Error::FILE_NOT_FOUND);
     }
     $fileMetadada = $backend->getMetadata(Path::combine($workingFolder->getPath(), $fileName));
     return $fileMetadada;
 }

 /**
  * Deletes the current file.
  *
  * @return bool `true` if the file was deleted successfully.
  *
  * @throws \Exception
  */
 public function doDelete()
 {
     if ($this->resourceType->getBackend()->delete($this->getFilePath())) {
         $this->deleteThumbnails();
         $this->deleteResizedImages();
         $this->getCache()->delete(Path::combine($this->resourceType->getName(), $this->folder, $this->getFilename()));
         return true;
     } else {
         $this->addError(Error::ACCESS_DENIED);
         return false;
     }
 }

 public function execute(Request $request, Config $config, WorkingFolder $workingFolder, ResizedImageRepository $resizedImageRepository, CacheManager $cache)
 {
     $fileName = (string) $request->query->get('fileName');
     list($requestedWidth, $requestedHeight) = Image::parseSize((string) $request->get('size'));
     $downloadedFile = new DownloadedFile($fileName, $this->app);
     $downloadedFile->isValid();
     if (!Image::isSupportedExtension(pathinfo($fileName, PATHINFO_EXTENSION), $config->get('thumbnails.bmpSupported'))) {
         throw new InvalidExtensionException('Unsupported image type or not image file');
     }
     Utils::removeSessionCacheHeaders();
     $response = new Response();
     $response->setPublic();
     $response->setEtag(dechex($downloadedFile->getTimestamp()) . "-" . dechex($downloadedFile->getSize()));
     $lastModificationDate = new \DateTime();
     $lastModificationDate->setTimestamp($downloadedFile->getTimestamp());
     $response->setLastModified($lastModificationDate);
     if ($response->isNotModified($request)) {
         return $response;
     }
     $imagePreviewCacheExpires = (int) $config->get('cache.imagePreview');
     if ($imagePreviewCacheExpires > 0) {
         $response->setMaxAge($imagePreviewCacheExpires);
         $expireTime = new \DateTime();
         $expireTime->modify('+' . $imagePreviewCacheExpires . 'seconds');
         $response->setExpires($expireTime);
     }
     $cachedInfoPath = Path::combine($workingFolder->getResourceType()->getName(), $workingFolder->getClientCurrentFolder(), $fileName);
     $cachedInfo = $cache->get($cachedInfoPath);
     $resultImage = null;
     // Try to reuse existing resized image
     if ($cachedInfo && isset($cachedInfo['width']) && isset($cachedInfo['height'])) {
         // Fix received aspect ratio
         $size = Image::calculateAspectRatio($requestedWidth, $requestedHeight, $cachedInfo['width'], $cachedInfo['height']);
         $resizedImage = $resizedImageRepository->getResizedImageBySize($workingFolder->getResourceType(), $workingFolder->getClientCurrentFolder(), $fileName, $size['width'], $size['height']);
         if ($resizedImage) {
             $resultImage = Image::create($resizedImage->getImageData());
         }
     }
     // Fallback - get and resize the original image
     if (null === $resultImage) {
         $resultImage = Image::create($downloadedFile->getContents(), $config->get('thumbnails.bmpSupported'));
         $cache->set($cachedInfoPath, $resultImage->getInfo());
         $resultImage->resize($requestedWidth, $requestedHeight);
     }
     $mimeType = $resultImage->getMimeType();
     if (in_array($mimeType, array('image/bmp', 'image/x-ms-bmp'))) {
         $mimeType = 'image/jpeg';
         // Image::getData() by default converts resized images to JPG
     }
     $response->headers->set('Content-Type', $mimeType . '; name="' . $downloadedFile->getFileName() . '"');
     $response->setContent($resultImage->getData());
     return $response;
 }

 /**
  * Renames current file
  *
  * @return bool true if file was renamed successfully
  *
  * @throws \Exception
  */
 public function doRename()
 {
     $oldPath = Path::combine($this->getPath(), $this->getFilename());
     $newPath = Path::combine($this->getPath(), $this->newFileName);
     $backend = $this->resourceType->getBackend();
     if ($backend->has($newPath)) {
         throw new AlreadyExistsException('Target file already exists');
     }
     $this->deleteThumbnails();
     $this->resourceType->getResizedImageRepository()->renameResizedImages($this->resourceType, $this->folder, $this->getFilename(), $this->newFileName);
     $this->getCache()->move(Path::combine($this->resourceType->getName(), $this->folder, $this->getFilename()), Path::combine($this->resourceType->getName(), $this->folder, $this->newFileName));
     return $backend->rename($oldPath, $newPath);
 }

 /**
  * Moves the current file.
  *
  * @return bool `true` if the file was moved successfully.
  *
  * @throws \Exception
  */
 public function doMove()
 {
     $originalFilePath = $this->getFilePath();
     $originalFileName = $this->getFilename();
     // Save original file name - it may be autorenamed when copied
     if (parent::doCopy()) {
         // Remove source file
         $this->deleteThumbnails();
         $this->resourceType->getResizedImageRepository()->deleteResizedImages($this->resourceType, $this->folder, $originalFileName);
         $this->getCache()->delete(Path::combine($this->resourceType->getName(), $this->folder, $originalFileName));
         return $this->resourceType->getBackend()->delete($originalFilePath);
     }
     return false;
 }

 public function execute(WorkingFolder $workingFolder)
 {
     $directories = $workingFolder->listDirectories();
     $data = new \stdClass();
     $data->folders = array();
     $backend = $workingFolder->getBackend();
     $resourceType = $workingFolder->getResourceType();
     foreach ($directories as $directory) {
         $data->folders[] = array('name' => $directory['basename'], 'hasChildren' => $backend->containsDirectories($resourceType, Path::combine($workingFolder->getClientCurrentFolder(), $directory['basename'])), 'acl' => $directory['acl']);
     }
     // Sort folders
     usort($data->folders, function ($a, $b) {
         return strnatcasecmp($a['name'], $b['name']);
     });
     return $data;
 }

 public function execute(Request $request, WorkingFolder $workingFolder, EventDispatcher $dispatcher, CacheManager $cache, ResizedImageRepository $resizedImageRepository, ThumbnailRepository $thumbnailRepository)
 {
     $fileName = $request->query->get('fileName');
     $editedFile = new EditedFile($fileName, $this->app);
     $saveAsNew = false;
     if (!$editedFile->exists()) {
         $saveAsNew = true;
         $editedFile->saveAsNew(true);
     }
     if (!$editedFile->isValid()) {
         throw new InvalidUploadException('Invalid file provided');
     }
     if (!Image::isSupportedExtension($editedFile->getExtension())) {
         throw new InvalidExtensionException('Unsupported image type or not image file');
     }
     $imageFormat = Image::mimeTypeFromExtension($editedFile->getExtension());
     $uploadedData = $request->get('content');
     if (null === $uploadedData || strpos($uploadedData, 'data:image/png;base64,') !== 0) {
         throw new InvalidUploadException('Invalid upload. Expected base64 encoded PNG image.');
     }
     $data = explode(',', $uploadedData);
     $data = isset($data[1]) ? base64_decode($data[1]) : false;
     if (!$data) {
         throw new InvalidUploadException();
     }
     $uploadedImage = Image::create($data);
     $newContents = $uploadedImage->getData($imageFormat);
     $editFileEvent = new EditFileEvent($this->app, $editedFile, $newContents);
     $cache->set(Path::combine($workingFolder->getResourceType()->getName(), $workingFolder->getClientCurrentFolder(), $fileName), $uploadedImage->getInfo());
     $dispatcher->dispatch(CKFinderEvent::SAVE_IMAGE, $editFileEvent);
     $saved = false;
     if (!$editFileEvent->isPropagationStopped()) {
         $saved = $editedFile->setContents($editFileEvent->getNewContents());
         //Remove thumbnails and resized images in case if file is overwritten
         if (!$saveAsNew && $saved) {
             $resourceType = $workingFolder->getResourceType();
             $thumbnailRepository->deleteThumbnails($resourceType, $workingFolder->getClientCurrentFolder(), $fileName);
             $resizedImageRepository->deleteResizedImages($resourceType, $workingFolder->getClientCurrentFolder(), $fileName);
         }
     }
     return array('saved' => (int) $saved, 'date' => Utils::formatDate(time()));
 }

 public function execute(Request $request, WorkingFolder $workingFolder, ResizedImageRepository $resizedImageRepository, Config $config, CacheManager $cache)
 {
     $fileName = $request->get('fileName');
     $sizes = $request->get('sizes');
     $ext = pathinfo($fileName, PATHINFO_EXTENSION);
     if (!Image::isSupportedExtension($ext)) {
         throw new InvalidRequestException('Invalid file extension');
     }
     if ($sizes) {
         $sizes = explode(',', $sizes);
         if (array_diff($sizes, array_keys($config->get('images.sizes')))) {
             throw new InvalidRequestException(sprintf('Invalid size requested (%s)', $request->get('sizes')));
         }
     }
     $data = array();
     $cachedInfo = $cache->get(Path::combine($workingFolder->getResourceType()->getName(), $workingFolder->getClientCurrentFolder(), $fileName));
     if ($cachedInfo && isset($cachedInfo['width']) && isset($cachedInfo['height'])) {
         $data['originalSize'] = sprintf("%dx%d", $cachedInfo['width'], $cachedInfo['height']);
     }
     $resizedImages = $resizedImageRepository->getResizedImagesList($workingFolder->getResourceType(), $workingFolder->getClientCurrentFolder(), $fileName, $sizes ?: array());
     $data['resized'] = $resizedImages;
     return $data;
 }

 public function execute(WorkingFolder $workingFolder, Request $request, Config $config)
 {
     $fileName = $request->get('fileName');
     $thumbnail = $request->get('thumbnail');
     $fileNames = (array) $request->get('fileNames');
     if (!empty($fileNames)) {
         $urls = array();
         foreach ($fileNames as $fileName) {
             if (!File::isValidName($fileName, $config->get('disallowUnsafeCharacters'))) {
                 throw new InvalidRequestException(sprintf('Invalid file name: %s', $fileName));
             }
             $urls[$fileName] = $workingFolder->getFileUrl($fileName);
         }
         return array('urls' => $urls);
     }
     if (!File::isValidName($fileName, $config->get('disallowUnsafeCharacters')) || $thumbnail && !File::isValidName($thumbnail, $config->get('disallowUnsafeCharacters'))) {
         throw new InvalidRequestException('Invalid file name');
     }
     if (!$workingFolder->containsFile($fileName)) {
         throw new FileNotFoundException();
     }
     return array('url' => $workingFolder->getFileUrl($thumbnail ? Path::combine(ResizedImage::DIR, $fileName, $thumbnail) : $fileName));
 }

 /**
  * Destructor to remove temporary files if operation was started for current request
  */
 public function __destruct()
 {
     if ($this->startedOperationId) {
         $directoryPath = $this->getFilePath($this->startedOperationId, null);
         $toRemove = array($statusFilePath = Path::combine($directoryPath, 'status'), $abortFilePath = Path::combine($directoryPath, 'abort'));
         foreach ($toRemove as $filePath) {
             if (file_exists($filePath)) {
                 unlink($filePath);
             }
         }
         if (is_dir($directoryPath)) {
             rmdir($directoryPath);
         }
     }
 }

 /**
  * Returns backend-relative resized image file path
  *
  * @return string
  */
 public function getFilePath()
 {
     return Path::combine($this->getDirectory(), $this->getFileName());
 }

 /**
  * Checks if directory contains subdirectories
  *
  * @param Backend      $backend
  * @param ResourceType $resourceType
  * @param string       $clientPath
  * @param Acl          $acl
  *
  * @return bool
  */
 public function containsDirectories(Backend $backend, ResourceType $resourceType, $clientPath, Acl $acl)
 {
     $location = rtrim($this->applyPathPrefix(Path::combine($resourceType->getDirectory(), $clientPath)), '/\\') . '/';
     if (!is_dir($location) || false === ($fh = @opendir($location))) {
         return false;
     }
     $hasChildren = false;
     $resourceTypeName = $resourceType->getName();
     $clientPath = rtrim($clientPath, '/\\') . '/';
     while (false !== ($filename = readdir($fh))) {
         if ($filename == '.' || $filename == '..') {
             continue;
         }
         if (is_dir($location . $filename)) {
             if (!$acl->isAllowed($resourceTypeName, $clientPath . $filename, Permission::FOLDER_VIEW)) {
                 continue;
             }
             if ($backend->isHiddenFolder($filename)) {
                 continue;
             }
             $hasChildren = true;
             break;
         }
     }
     closedir($fh);
     return $hasChildren;
 }

 /**
  * Returns backend object for given private directory identifier
  *
  * @param string $privateDirIdentifier
  *
  * @return Backend
  */
 public function getPrivateDirBackend($privateDirIdentifier)
 {
     $privateDirConfig = $this->config->get('privateDir');
     if (!array_key_exists($privateDirIdentifier, $privateDirConfig)) {
         throw new \InvalidArgumentException(sprintf('Private dir with identifier %s not found. Please check configuration file.', $privateDirIdentifier));
     }
     $privateDir = $privateDirConfig[$privateDirIdentifier];
     $backend = null;
     if (is_array($privateDir) && array_key_exists('backend', $privateDir)) {
         $backend = $this->getBackend($privateDir['backend']);
     } else {
         $backend = $this->getBackend($privateDirConfig['backend']);
     }
     // Create a default .htaccess to disable access to current private directory
     $privateDirPath = $this->config->getPrivateDirPath($privateDirIdentifier);
     $htaccessPath = Path::combine($privateDirPath, '.htaccess');
     if (!$backend->has($htaccessPath)) {
         $backend->write($htaccessPath, "Order Deny,Allow\nDeny from all\n");
     }
     return $backend;
 }

 /**
  * Disallows a permission for a given role.
  *
  * @param string $resourceType
  * @param string $folderPath
  * @param int    $permission
  * @param string $role
  *
  * @return $this|Acl
  */
 public function disallow($resourceType, $folderPath, $permission, $role)
 {
     $folderPath = Path::normalize($folderPath);
     if (!isset($this->rules[$folderPath][$role][$resourceType])) {
         $this->rules[$folderPath][$role][$resourceType] = new MaskBuilder();
     }
     /* @var $ruleMask MaskBuilder */
     $ruleMask = $this->rules[$folderPath][$role][$resourceType];
     $ruleMask->disallow($permission);
     return $this;
 }

 /**
  * Deletes all thumbnails under the given path defined by the resource type,
  * path and file name.
  *
  * @param ResourceType $resourceType
  * @param string       $path
  * @param string       $fileName
  *
  * @return bool `true` if deleted successfully
  */
 public function deleteThumbnails(ResourceType $resourceType, $path, $fileName = null)
 {
     $path = Path::combine($this->getThumbnailsPath(), $resourceType->getName(), $path, $fileName);
     if ($this->thumbsBackend->has($path)) {
         return $this->thumbsBackend->deleteDir($path);
     }
     return false;
 }

 /**
  * Returns a URL to a file.
  *
  * If the useProxyCommand option is set for a backend, the returned
  * URL will point to the CKFinder connector Proxy command.
  *
  * @param ResourceType $resourceType      the file resource type
  * @param string       $folderPath        the resource-type relative folder path
  * @param string       $fileName          the file name
  * @param string|null  $thumbnailFileName the thumbnail file name - if the file is a thumbnail
  *
  * @return string|null URL to a file or `null` if the backend does not support it.
  */
 public function getFileUrl(ResourceType $resourceType, $folderPath, $fileName, $thumbnailFileName = null)
 {
     if (isset($this->backendConfig['useProxyCommand'])) {
         $connectorUrl = $this->app->getConnectorUrl();
         $queryParameters = array('command' => 'Proxy', 'type' => $resourceType->getName(), 'currentFolder' => $folderPath, 'fileName' => $fileName);
         if ($thumbnailFileName) {
             $queryParameters['thumbnail'] = $thumbnailFileName;
         }
         $proxyCacheLifetime = (int) $this->ckConfig->get('cache.proxyCommand');
         if ($proxyCacheLifetime > 0) {
             $queryParameters['cache'] = $proxyCacheLifetime;
         }
         return $connectorUrl . '?' . http_build_query($queryParameters, '', '&');
     }
     $path = $thumbnailFileName ? Path::combine($resourceType->getDirectory(), $folderPath, ResizedImage::DIR, $fileName, $thumbnailFileName) : Path::combine($resourceType->getDirectory(), $folderPath, $fileName);
     if (isset($this->backendConfig['baseUrl'])) {
         return Path::combine($this->backendConfig['baseUrl'], Utils::encodeURLParts($path));
     }
     $baseAdapter = $this->getBaseAdapter();
     if (method_exists($baseAdapter, 'getFileUrl')) {
         return $baseAdapter->getFileUrl($path);
     }
     return null;
 }

 /**
  * Returns a direct url to a file
  *
  * @param string $path
  *
  * @return string|null direct url to a file or null if backend
  *                     doesn't support direct access
  */
 public function getFileUrl($path)
 {
     if (method_exists($this->adapter, 'getFileUrl')) {
         return $this->adapter->getFileUrl($path);
     }
     if (isset($this->backendConfig['baseUrl'])) {
         return Path::combine($this->backendConfig['baseUrl'], Utils::encodeURLParts($path));
     }
     return null;
 }

 public function setContents($contents, $filePath = null)
 {
     return parent::setContents($contents, $this->newFileName ? Path::combine($this->getPath(), $this->newFileName) : null);
 }