2013-09-01 21:47:48 +04:00
|
|
|
<?php
|
|
|
|
/**
|
2016-07-21 18:07:57 +03:00
|
|
|
* @copyright Copyright (c) 2016, ownCloud, Inc.
|
|
|
|
*
|
|
|
|
* @author Joas Schilling <coding@schilljs.com>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Morris Jobke <hey@morrisjobke.de>
|
2016-07-21 19:13:36 +03:00
|
|
|
* @author Robin Appelman <robin@icewind.nl>
|
2016-01-12 17:02:16 +03:00
|
|
|
* @author Robin McCorkell <robin@mccorkell.me.uk>
|
2015-03-26 13:44:34 +03:00
|
|
|
* @author Vincent Petry <pvince81@owncloud.com>
|
|
|
|
*
|
|
|
|
* @license AGPL-3.0
|
|
|
|
*
|
|
|
|
* This code is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU Affero General Public License, version 3,
|
|
|
|
* as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU Affero General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Affero General Public License, version 3,
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
|
|
*
|
2013-09-01 21:47:48 +04:00
|
|
|
*/
|
2015-02-26 13:37:37 +03:00
|
|
|
|
2013-09-01 21:47:48 +04:00
|
|
|
namespace OC\Files\Node;
|
|
|
|
|
2016-07-22 15:37:37 +03:00
|
|
|
use OC\DB\QueryBuilder\Literal;
|
|
|
|
use OCP\DB\QueryBuilder\IQueryBuilder;
|
2015-09-08 23:38:50 +03:00
|
|
|
use OCP\Files\FileInfo;
|
2016-07-22 15:37:37 +03:00
|
|
|
use OCP\Files\Mount\IMountPoint;
|
2013-09-10 21:44:23 +04:00
|
|
|
use OCP\Files\NotFoundException;
|
|
|
|
use OCP\Files\NotPermittedException;
|
2013-09-01 21:47:48 +04:00
|
|
|
|
2013-09-10 21:44:23 +04:00
|
|
|
class Folder extends Node implements \OCP\Files\Folder {
|
2013-09-01 21:47:48 +04:00
|
|
|
/**
|
|
|
|
* @param string $path path relative to the folder
|
|
|
|
* @return string
|
2013-09-10 21:44:23 +04:00
|
|
|
* @throws \OCP\Files\NotPermittedException
|
2013-09-01 21:47:48 +04:00
|
|
|
*/
|
|
|
|
public function getFullPath($path) {
|
|
|
|
if (!$this->isValidPath($path)) {
|
|
|
|
throw new NotPermittedException();
|
|
|
|
}
|
|
|
|
return $this->path . $this->normalizePath($path);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $path
|
|
|
|
* @return string
|
|
|
|
*/
|
|
|
|
public function getRelativePath($path) {
|
|
|
|
if ($this->path === '' or $this->path === '/') {
|
|
|
|
return $this->normalizePath($path);
|
|
|
|
}
|
2014-08-05 18:58:10 +04:00
|
|
|
if ($path === $this->path) {
|
|
|
|
return '/';
|
|
|
|
} else if (strpos($path, $this->path . '/') !== 0) {
|
2014-08-06 14:06:41 +04:00
|
|
|
return null;
|
2013-09-01 21:47:48 +04:00
|
|
|
} else {
|
|
|
|
$path = substr($path, strlen($this->path));
|
2014-08-05 18:58:10 +04:00
|
|
|
return $this->normalizePath($path);
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* check if a node is a (grand-)child of the folder
|
|
|
|
*
|
|
|
|
* @param \OC\Files\Node\Node $node
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function isSubNode($node) {
|
|
|
|
return strpos($node->getPath(), $this->path . '/') === 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get the content of this directory
|
|
|
|
*
|
2013-09-10 21:44:23 +04:00
|
|
|
* @throws \OCP\Files\NotFoundException
|
2013-09-01 21:47:48 +04:00
|
|
|
* @return Node[]
|
|
|
|
*/
|
|
|
|
public function getDirectoryListing() {
|
2015-09-08 23:38:50 +03:00
|
|
|
$folderContent = $this->view->getDirectoryContent($this->path);
|
2013-09-01 21:47:48 +04:00
|
|
|
|
2015-09-08 23:38:50 +03:00
|
|
|
return array_map(function(FileInfo $info) {
|
|
|
|
if ($info->getMimetype() === 'httpd/unix-directory') {
|
|
|
|
return new Folder($this->root, $this->view, $info->getPath(), $info);
|
|
|
|
} else {
|
|
|
|
return new File($this->root, $this->view, $info->getPath(), $info);
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
2015-09-08 23:38:50 +03:00
|
|
|
}, $folderContent);
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $path
|
2016-03-21 16:20:33 +03:00
|
|
|
* @param FileInfo $info
|
2013-09-01 21:47:48 +04:00
|
|
|
* @return File|Folder
|
|
|
|
*/
|
2016-03-21 16:20:33 +03:00
|
|
|
protected function createNode($path, FileInfo $info = null) {
|
|
|
|
if (is_null($info)) {
|
2013-09-01 21:47:48 +04:00
|
|
|
$isDir = $this->view->is_dir($path);
|
|
|
|
} else {
|
2016-03-21 16:20:33 +03:00
|
|
|
$isDir = $info->getType() === FileInfo::TYPE_FOLDER;
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
if ($isDir) {
|
2016-02-18 17:41:10 +03:00
|
|
|
return new Folder($this->root, $this->view, $path, $info);
|
2013-09-01 21:47:48 +04:00
|
|
|
} else {
|
2016-02-18 17:41:10 +03:00
|
|
|
return new File($this->root, $this->view, $path, $info);
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get the node at $path
|
|
|
|
*
|
|
|
|
* @param string $path
|
|
|
|
* @return \OC\Files\Node\Node
|
2013-09-10 21:44:23 +04:00
|
|
|
* @throws \OCP\Files\NotFoundException
|
2013-09-01 21:47:48 +04:00
|
|
|
*/
|
|
|
|
public function get($path) {
|
|
|
|
return $this->root->get($this->getFullPath($path));
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $path
|
|
|
|
* @return bool
|
|
|
|
*/
|
|
|
|
public function nodeExists($path) {
|
|
|
|
try {
|
|
|
|
$this->get($path);
|
|
|
|
return true;
|
|
|
|
} catch (NotFoundException $e) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $path
|
2013-09-10 21:44:23 +04:00
|
|
|
* @return \OC\Files\Node\Folder
|
|
|
|
* @throws \OCP\Files\NotPermittedException
|
2013-09-01 21:47:48 +04:00
|
|
|
*/
|
|
|
|
public function newFolder($path) {
|
2014-11-25 18:28:41 +03:00
|
|
|
if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
|
2013-09-01 21:47:48 +04:00
|
|
|
$fullPath = $this->getFullPath($path);
|
|
|
|
$nonExisting = new NonExistingFolder($this->root, $this->view, $fullPath);
|
|
|
|
$this->root->emit('\OC\Files', 'preWrite', array($nonExisting));
|
|
|
|
$this->root->emit('\OC\Files', 'preCreate', array($nonExisting));
|
|
|
|
$this->view->mkdir($fullPath);
|
|
|
|
$node = new Folder($this->root, $this->view, $fullPath);
|
|
|
|
$this->root->emit('\OC\Files', 'postWrite', array($node));
|
|
|
|
$this->root->emit('\OC\Files', 'postCreate', array($node));
|
|
|
|
return $node;
|
|
|
|
} else {
|
|
|
|
throw new NotPermittedException();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $path
|
2013-09-10 21:44:23 +04:00
|
|
|
* @return \OC\Files\Node\File
|
|
|
|
* @throws \OCP\Files\NotPermittedException
|
2013-09-01 21:47:48 +04:00
|
|
|
*/
|
|
|
|
public function newFile($path) {
|
2014-11-25 18:28:41 +03:00
|
|
|
if ($this->checkPermissions(\OCP\Constants::PERMISSION_CREATE)) {
|
2013-09-01 21:47:48 +04:00
|
|
|
$fullPath = $this->getFullPath($path);
|
|
|
|
$nonExisting = new NonExistingFile($this->root, $this->view, $fullPath);
|
|
|
|
$this->root->emit('\OC\Files', 'preWrite', array($nonExisting));
|
|
|
|
$this->root->emit('\OC\Files', 'preCreate', array($nonExisting));
|
|
|
|
$this->view->touch($fullPath);
|
|
|
|
$node = new File($this->root, $this->view, $fullPath);
|
|
|
|
$this->root->emit('\OC\Files', 'postWrite', array($node));
|
|
|
|
$this->root->emit('\OC\Files', 'postCreate', array($node));
|
|
|
|
return $node;
|
|
|
|
} else {
|
|
|
|
throw new NotPermittedException();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* search for files with the name matching $query
|
|
|
|
*
|
|
|
|
* @param string $query
|
2013-09-10 21:44:23 +04:00
|
|
|
* @return \OC\Files\Node\Node[]
|
2013-09-01 21:47:48 +04:00
|
|
|
*/
|
|
|
|
public function search($query) {
|
2014-12-12 13:18:35 +03:00
|
|
|
return $this->searchCommon('search', array('%' . $query . '%'));
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* search for files by mimetype
|
|
|
|
*
|
|
|
|
* @param string $mimetype
|
|
|
|
* @return Node[]
|
|
|
|
*/
|
|
|
|
public function searchByMime($mimetype) {
|
2014-12-12 13:18:35 +03:00
|
|
|
return $this->searchCommon('searchByMime', array($mimetype));
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
|
2014-12-04 16:01:15 +03:00
|
|
|
/**
|
|
|
|
* search for files by tag
|
|
|
|
*
|
2014-12-12 13:18:35 +03:00
|
|
|
* @param string|int $tag name or tag id
|
|
|
|
* @param string $userId owner of the tags
|
2014-12-04 16:01:15 +03:00
|
|
|
* @return Node[]
|
|
|
|
*/
|
2014-12-12 13:18:35 +03:00
|
|
|
public function searchByTag($tag, $userId) {
|
|
|
|
return $this->searchCommon('searchByTag', array($tag, $userId));
|
2014-12-04 16:01:15 +03:00
|
|
|
}
|
|
|
|
|
2013-09-01 21:47:48 +04:00
|
|
|
/**
|
2014-12-12 13:18:35 +03:00
|
|
|
* @param string $method cache method
|
|
|
|
* @param array $args call args
|
2013-09-10 21:44:23 +04:00
|
|
|
* @return \OC\Files\Node\Node[]
|
2013-09-01 21:47:48 +04:00
|
|
|
*/
|
2014-12-12 13:18:35 +03:00
|
|
|
private function searchCommon($method, $args) {
|
2013-09-01 21:47:48 +04:00
|
|
|
$files = array();
|
|
|
|
$rootLength = strlen($this->path);
|
2016-03-21 16:20:33 +03:00
|
|
|
$mount = $this->root->getMount($this->path);
|
|
|
|
$storage = $mount->getStorage();
|
|
|
|
$internalPath = $mount->getInternalPath($this->path);
|
2015-10-06 16:02:47 +03:00
|
|
|
$internalPath = rtrim($internalPath, '/');
|
|
|
|
if ($internalPath !== '') {
|
|
|
|
$internalPath = $internalPath . '/';
|
|
|
|
}
|
2013-09-01 21:47:48 +04:00
|
|
|
$internalRootLength = strlen($internalPath);
|
|
|
|
|
|
|
|
$cache = $storage->getCache('');
|
|
|
|
|
2014-12-12 13:18:35 +03:00
|
|
|
$results = call_user_func_array(array($cache, $method), $args);
|
2013-09-01 21:47:48 +04:00
|
|
|
foreach ($results as $result) {
|
2015-10-06 16:02:47 +03:00
|
|
|
if ($internalRootLength === 0 or substr($result['path'], 0, $internalRootLength) === $internalPath) {
|
2013-09-01 21:47:48 +04:00
|
|
|
$result['internalPath'] = $result['path'];
|
|
|
|
$result['path'] = substr($result['path'], $internalRootLength);
|
|
|
|
$result['storage'] = $storage;
|
2016-03-21 16:20:33 +03:00
|
|
|
$files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
$mounts = $this->root->getMountsIn($this->path);
|
|
|
|
foreach ($mounts as $mount) {
|
|
|
|
$storage = $mount->getStorage();
|
|
|
|
if ($storage) {
|
|
|
|
$cache = $storage->getCache('');
|
|
|
|
|
|
|
|
$relativeMountPoint = substr($mount->getMountPoint(), $rootLength);
|
2014-12-12 13:18:35 +03:00
|
|
|
$results = call_user_func_array(array($cache, $method), $args);
|
2013-09-01 21:47:48 +04:00
|
|
|
foreach ($results as $result) {
|
|
|
|
$result['internalPath'] = $result['path'];
|
|
|
|
$result['path'] = $relativeMountPoint . $result['path'];
|
|
|
|
$result['storage'] = $storage;
|
2016-03-21 16:20:33 +03:00
|
|
|
$files[] = new \OC\Files\FileInfo($this->path . '/' . $result['path'], $storage, $result['internalPath'], $result, $mount);
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-21 16:20:33 +03:00
|
|
|
return array_map(function(FileInfo $file) {
|
|
|
|
return $this->createNode($file->getPath(), $file);
|
|
|
|
}, $files);
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-05-12 00:51:30 +04:00
|
|
|
* @param int $id
|
2013-09-10 21:44:23 +04:00
|
|
|
* @return \OC\Files\Node\Node[]
|
2013-09-01 21:47:48 +04:00
|
|
|
*/
|
|
|
|
public function getById($id) {
|
2014-08-05 18:58:10 +04:00
|
|
|
$mounts = $this->root->getMountsIn($this->path);
|
|
|
|
$mounts[] = $this->root->getMount($this->path);
|
|
|
|
// reverse the array so we start with the storage this view is in
|
|
|
|
// which is the most likely to contain the file we're looking for
|
|
|
|
$mounts = array_reverse($mounts);
|
|
|
|
|
|
|
|
$nodes = array();
|
|
|
|
foreach ($mounts as $mount) {
|
|
|
|
/**
|
2014-11-24 17:54:42 +03:00
|
|
|
* @var \OC\Files\Mount\MountPoint $mount
|
2014-08-05 18:58:10 +04:00
|
|
|
*/
|
|
|
|
if ($mount->getStorage()) {
|
|
|
|
$cache = $mount->getStorage()->getCache();
|
|
|
|
$internalPath = $cache->getPathById($id);
|
|
|
|
if (is_string($internalPath)) {
|
|
|
|
$fullPath = $mount->getMountPoint() . $internalPath;
|
|
|
|
if (!is_null($path = $this->getRelativePath($fullPath))) {
|
|
|
|
$nodes[] = $this->get($path);
|
|
|
|
}
|
|
|
|
}
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
}
|
2014-08-05 18:58:10 +04:00
|
|
|
return $nodes;
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
public function getFreeSpace() {
|
|
|
|
return $this->view->free_space($this->path);
|
|
|
|
}
|
|
|
|
|
|
|
|
public function delete() {
|
2014-11-25 18:28:41 +03:00
|
|
|
if ($this->checkPermissions(\OCP\Constants::PERMISSION_DELETE)) {
|
2013-09-01 21:47:48 +04:00
|
|
|
$this->sendHooks(array('preDelete'));
|
2015-12-01 15:22:58 +03:00
|
|
|
$fileInfo = $this->getFileInfo();
|
2013-09-01 21:47:48 +04:00
|
|
|
$this->view->rmdir($this->path);
|
2015-12-01 15:22:58 +03:00
|
|
|
$nonExisting = new NonExistingFolder($this->root, $this->view, $this->path, $fileInfo);
|
2013-09-01 21:47:48 +04:00
|
|
|
$this->root->emit('\OC\Files', 'postDelete', array($nonExisting));
|
|
|
|
$this->exists = false;
|
|
|
|
} else {
|
|
|
|
throw new NotPermittedException();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $targetPath
|
2013-09-10 21:44:23 +04:00
|
|
|
* @throws \OCP\Files\NotPermittedException
|
2013-09-01 21:47:48 +04:00
|
|
|
* @return \OC\Files\Node\Node
|
|
|
|
*/
|
|
|
|
public function copy($targetPath) {
|
|
|
|
$targetPath = $this->normalizePath($targetPath);
|
|
|
|
$parent = $this->root->get(dirname($targetPath));
|
|
|
|
if ($parent instanceof Folder and $this->isValidPath($targetPath) and $parent->isCreatable()) {
|
|
|
|
$nonExisting = new NonExistingFolder($this->root, $this->view, $targetPath);
|
|
|
|
$this->root->emit('\OC\Files', 'preCopy', array($this, $nonExisting));
|
|
|
|
$this->root->emit('\OC\Files', 'preWrite', array($nonExisting));
|
|
|
|
$this->view->copy($this->path, $targetPath);
|
|
|
|
$targetNode = $this->root->get($targetPath);
|
|
|
|
$this->root->emit('\OC\Files', 'postCopy', array($this, $targetNode));
|
|
|
|
$this->root->emit('\OC\Files', 'postWrite', array($targetNode));
|
|
|
|
return $targetNode;
|
|
|
|
} else {
|
|
|
|
throw new NotPermittedException();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @param string $targetPath
|
2013-09-10 21:44:23 +04:00
|
|
|
* @throws \OCP\Files\NotPermittedException
|
2013-09-01 21:47:48 +04:00
|
|
|
* @return \OC\Files\Node\Node
|
|
|
|
*/
|
|
|
|
public function move($targetPath) {
|
|
|
|
$targetPath = $this->normalizePath($targetPath);
|
|
|
|
$parent = $this->root->get(dirname($targetPath));
|
|
|
|
if ($parent instanceof Folder and $this->isValidPath($targetPath) and $parent->isCreatable()) {
|
|
|
|
$nonExisting = new NonExistingFolder($this->root, $this->view, $targetPath);
|
|
|
|
$this->root->emit('\OC\Files', 'preRename', array($this, $nonExisting));
|
|
|
|
$this->root->emit('\OC\Files', 'preWrite', array($nonExisting));
|
|
|
|
$this->view->rename($this->path, $targetPath);
|
|
|
|
$targetNode = $this->root->get($targetPath);
|
|
|
|
$this->root->emit('\OC\Files', 'postRename', array($this, $targetNode));
|
|
|
|
$this->root->emit('\OC\Files', 'postWrite', array($targetNode));
|
|
|
|
$this->path = $targetPath;
|
|
|
|
return $targetNode;
|
|
|
|
} else {
|
|
|
|
throw new NotPermittedException();
|
|
|
|
}
|
|
|
|
}
|
2015-03-24 17:00:36 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Add a suffix to the name in case the file exists
|
|
|
|
*
|
|
|
|
* @param string $name
|
|
|
|
* @return string
|
|
|
|
* @throws NotPermittedException
|
|
|
|
*/
|
|
|
|
public function getNonExistingName($name) {
|
|
|
|
$uniqueName = \OC_Helper::buildNotExistingFileNameForView($this->getPath(), $name, $this->view);
|
|
|
|
return trim($this->getRelativePath($uniqueName), '/');
|
|
|
|
}
|
2016-07-22 15:37:37 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @param int $since
|
|
|
|
* @return \OCP\Files\Node[]
|
|
|
|
*/
|
|
|
|
public function getRecent($since) {
|
|
|
|
$mimetypeLoader = \OC::$server->getMimeTypeLoader();
|
|
|
|
$mounts = $this->root->getMountsIn($this->path);
|
|
|
|
$mounts[] = $this->getMountPoint();
|
|
|
|
|
|
|
|
$mounts = array_filter($mounts, function (IMountPoint $mount) {
|
|
|
|
return $mount->getStorage();
|
|
|
|
});
|
|
|
|
$storageIds = array_map(function (IMountPoint $mount) {
|
|
|
|
return $mount->getStorage()->getCache()->getNumericStorageId();
|
|
|
|
}, $mounts);
|
|
|
|
/** @var IMountPoint[] $mountMap */
|
|
|
|
$mountMap = array_combine($storageIds, $mounts);
|
|
|
|
$folderMimetype = $mimetypeLoader->getId(FileInfo::MIMETYPE_FOLDER);
|
|
|
|
|
|
|
|
//todo look into options of filtering path based on storage id (only search in files/ for home storage, filter by share root for shared, etc)
|
|
|
|
|
|
|
|
$builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
|
|
|
|
$query = $builder
|
|
|
|
->select('f.*')
|
|
|
|
->from('filecache', 'f')
|
|
|
|
->where($builder->expr()->gt('f.storage_mtime', $builder->createNamedParameter($since, IQueryBuilder::PARAM_INT)))
|
|
|
|
->andWhere($builder->expr()->in('f.storage', $builder->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)))
|
|
|
|
->andWhere($builder->expr()->orX(
|
|
|
|
// handle non empty folders separate
|
|
|
|
$builder->expr()->neq('f.mimetype', $builder->createNamedParameter($folderMimetype, IQueryBuilder::PARAM_INT)),
|
|
|
|
$builder->expr()->eq('f.size', new Literal(0))
|
|
|
|
))
|
|
|
|
->orderBy('f.mtime', 'DESC');
|
|
|
|
|
|
|
|
$result = $query->execute()->fetchAll();
|
|
|
|
|
|
|
|
// select folders with their mtime being the mtime of the oldest file in the folder
|
|
|
|
// this way we still show new folders but dont bumb the folder every time a file in it is changed
|
|
|
|
$builder = \OC::$server->getDatabaseConnection()->getQueryBuilder();
|
|
|
|
$query = $builder
|
|
|
|
->select('p.fileid', 'p.storage', 'p.mimetype', 'p.mimepart', 'p.size', 'p.path', 'p.etag', 'f1.storage_mtime', 'f1.mtime', 'p.permissions')
|
|
|
|
->from('filecache', 'f1')
|
|
|
|
->leftJoin('f1', 'filecache', 'f2', $builder->expr()->andX( // find the f1 with lowest mtime in the folder
|
|
|
|
$builder->expr()->eq('f1.parent', 'f2.parent'),
|
|
|
|
$builder->expr()->gt('f1.storage_mtime', 'f2.storage_mtime')
|
|
|
|
))
|
|
|
|
->innerJoin('f1', 'filecache', 'p', $builder->expr()->eq('f1.parent', 'p.fileid'))
|
|
|
|
->where($builder->expr()->isNull('f2.fileid'))
|
|
|
|
->andWhere($builder->expr()->gt('f1.storage_mtime', $builder->createNamedParameter($since, IQueryBuilder::PARAM_INT)))
|
|
|
|
->andWhere($builder->expr()->in('f1.storage', $builder->createNamedParameter($storageIds, IQueryBuilder::PARAM_INT_ARRAY)))
|
|
|
|
->andWhere($builder->expr()->neq('f1.size', new Literal(0)))
|
|
|
|
->orderBy('f1.storage_mtime', 'DESC');
|
|
|
|
|
|
|
|
$folderResults = $query->execute()->fetchAll();
|
|
|
|
|
|
|
|
$found = []; // we sometimes get duplicate folders
|
|
|
|
$folderResults = array_filter($folderResults, function ($item) use (&$found) {
|
|
|
|
$isFound = isset($found[$item['fileid']]);
|
|
|
|
$found[$item['fileid']] = true;
|
|
|
|
return !$isFound;
|
|
|
|
});
|
|
|
|
|
|
|
|
$result = array_merge($folderResults, $result);
|
|
|
|
|
|
|
|
usort($result, function ($a, $b) use ($folderMimetype) {
|
|
|
|
$diff = $b['mtime'] - $a['mtime'];
|
|
|
|
if ($diff === 0) {
|
|
|
|
return $a['mimetype'] === $folderMimetype ? -1 : 1;
|
|
|
|
} else {
|
|
|
|
return $diff;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
$files = array_filter(array_map(function (array $entry) use ($mountMap, $mimetypeLoader) {
|
|
|
|
$mount = $mountMap[$entry['storage']];
|
|
|
|
$entry['internalPath'] = $entry['path'];
|
|
|
|
$entry['mimetype'] = $mimetypeLoader->getMimetypeById($entry['mimetype']);
|
|
|
|
$entry['mimepart'] = $mimetypeLoader->getMimetypeById($entry['mimepart']);
|
|
|
|
$path = $this->getAbsolutePath($mount, $entry['path']);
|
|
|
|
if (is_null($path)) {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
$fileInfo = new \OC\Files\FileInfo($path, $mount->getStorage(), $entry['internalPath'], $entry, $mount);
|
|
|
|
return $this->root->createNode($fileInfo->getPath(), $fileInfo);
|
|
|
|
}, $result));
|
|
|
|
|
|
|
|
return array_values(array_filter($files, function (Node $node) {
|
|
|
|
$relative = $this->getRelativePath($node->getPath());
|
|
|
|
return $relative !== null && $relative !== '/';
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
|
|
|
private function getAbsolutePath(IMountPoint $mount, $path) {
|
|
|
|
$storage = $mount->getStorage();
|
|
|
|
if ($storage->instanceOfStorage('\OC\Files\Storage\Wrapper\Jail')) {
|
|
|
|
/** @var \OC\Files\Storage\Wrapper\Jail $storage */
|
|
|
|
$jailRoot = $storage->getSourcePath('');
|
|
|
|
$rootLength = strlen($jailRoot) + 1;
|
|
|
|
if ($path === $jailRoot) {
|
|
|
|
return $mount->getMountPoint();
|
|
|
|
} else if (substr($path, 0, $rootLength) === $jailRoot . '/') {
|
|
|
|
return $mount->getMountPoint() . substr($path, $rootLength);
|
|
|
|
} else {
|
|
|
|
return null;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return $mount->getMountPoint() . $path;
|
|
|
|
}
|
|
|
|
}
|
2013-09-01 21:47:48 +04:00
|
|
|
}
|