mirror of
https://github.com/nextcloud/server.git
synced 2026-06-09 08:44:07 -04:00
fix: update "move into share" check to share manager
Signed-off-by: Robin Appelman <robin@icewind.nl>
This commit is contained in:
Robin Appelman
parent
d0ebe36906
commit
96942e436b
3 changed files with 30 additions and 459 deletions
|
|
@ -65,10 +65,12 @@ use OCP\Files\InvalidPathException;
|
|||
use OCP\Files\Mount\IMountPoint;
|
||||
use OCP\Files\NotFoundException;
|
||||
use OCP\Files\ReservedWordException;
|
||||
use OCP\Files\Storage\IStorage;
|
||||
use OCP\IUser;
|
||||
use OCP\Lock\ILockingProvider;
|
||||
use OCP\Lock\LockedException;
|
||||
use OCP\Server;
|
||||
use OCP\Share\IManager;
|
||||
use OCP\Share\IShare;
|
||||
use Psr\Log\LoggerInterface;
|
||||
|
||||
/**
|
||||
|
|
@ -731,6 +733,8 @@ class View {
|
|||
public function rename($source, $target) {
|
||||
$absolutePath1 = Filesystem::normalizePath($this->getAbsolutePath($source));
|
||||
$absolutePath2 = Filesystem::normalizePath($this->getAbsolutePath($target));
|
||||
$targetParts = explode('/', $absolutePath2);
|
||||
$targetUser = $targetParts[1] ?? null;
|
||||
$result = false;
|
||||
if (
|
||||
Filesystem::isValidPath($target)
|
||||
|
|
@ -785,7 +789,7 @@ class View {
|
|||
if ($internalPath1 === '') {
|
||||
if ($mount1 instanceof MoveableMount) {
|
||||
$sourceParentMount = $this->getMount(dirname($source));
|
||||
if ($sourceParentMount === $mount2 && $this->targetIsNotShared($storage2, $internalPath2)) {
|
||||
if ($sourceParentMount === $mount2 && $this->targetIsNotShared($targetUser, $absolutePath2)) {
|
||||
/**
|
||||
* @var \OC\Files\Mount\MountPoint | \OC\Files\Mount\MoveableMount $mount1
|
||||
*/
|
||||
|
|
@ -1781,28 +1785,29 @@ class View {
|
|||
* It is not allowed to move a mount point into a different mount point or
|
||||
* into an already shared folder
|
||||
*/
|
||||
private function targetIsNotShared(IStorage $targetStorage, string $targetInternalPath): bool {
|
||||
// note: cannot use the view because the target is already locked
|
||||
$fileId = $targetStorage->getCache()->getId($targetInternalPath);
|
||||
if ($fileId === -1) {
|
||||
// target might not exist, need to check parent instead
|
||||
$fileId = $targetStorage->getCache()->getId(dirname($targetInternalPath));
|
||||
}
|
||||
private function targetIsNotShared(string $user, string $targetPath): bool {
|
||||
$providers = [
|
||||
IShare::TYPE_USER,
|
||||
IShare::TYPE_GROUP,
|
||||
IShare::TYPE_EMAIL,
|
||||
IShare::TYPE_CIRCLE,
|
||||
IShare::TYPE_ROOM,
|
||||
IShare::TYPE_DECK,
|
||||
IShare::TYPE_SCIENCEMESH
|
||||
];
|
||||
$shareManager = Server::get(IManager::class);
|
||||
/** @var IShare[] $shares */
|
||||
$shares = array_merge(...array_map(function (int $type) use ($shareManager, $user) {
|
||||
return $shareManager->getSharesBy($user, $type);
|
||||
}, $providers));
|
||||
|
||||
// check if any of the parents were shared by the current owner (include collections)
|
||||
$shares = Share::getItemShared(
|
||||
'folder',
|
||||
(string)$fileId,
|
||||
\OC\Share\Constants::FORMAT_NONE,
|
||||
null,
|
||||
true
|
||||
);
|
||||
|
||||
if (count($shares) > 0) {
|
||||
$this->logger->debug(
|
||||
'It is not allowed to move one mount point into a shared folder',
|
||||
['app' => 'files']);
|
||||
return false;
|
||||
foreach ($shares as $share) {
|
||||
if (str_starts_with($targetPath, $share->getNode()->getPath())) {
|
||||
$this->logger->debug(
|
||||
'It is not allowed to move one mount point into a shared folder',
|
||||
['app' => 'files']);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
|
|
|
|||
|
|
@ -194,25 +194,6 @@ class Share extends Constants {
|
|||
return $shares;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the shared item of item type owned by the current user
|
||||
*
|
||||
* @param string $itemType
|
||||
* @param string $itemSource
|
||||
* @param int $format (optional) Format type must be defined by the backend
|
||||
* @param mixed $parameters
|
||||
* @param boolean $includeCollections
|
||||
* @return mixed Return depends on format
|
||||
*
|
||||
* Refactoring notes:
|
||||
* * defacto $parameters and $format is always the default and therefore is removed in the subsequent call
|
||||
*/
|
||||
public static function getItemShared($itemType, $itemSource, $format = self::FORMAT_NONE,
|
||||
$parameters = null, $includeCollections = false) {
|
||||
return self::getItems($itemType, $itemSource, null, null, \OC_User::getUser(), self::FORMAT_NONE,
|
||||
null, -1, $includeCollections);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the backend class for the specified item type
|
||||
*
|
||||
|
|
@ -267,421 +248,6 @@ class Share extends Constants {
|
|||
return self::$isResharingAllowed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a list of collection item types for the specified item type
|
||||
*
|
||||
* @param string $itemType
|
||||
* @return array|false
|
||||
*/
|
||||
private static function getCollectionItemTypes(string $itemType) {
|
||||
$collectionTypes = [$itemType];
|
||||
foreach (self::$backendTypes as $type => $backend) {
|
||||
if (in_array($backend['collectionOf'], $collectionTypes)) {
|
||||
$collectionTypes[] = $type;
|
||||
}
|
||||
}
|
||||
// TODO Add option for collections to be collection of themselves, only 'folder' does it now...
|
||||
if (isset(self::$backendTypes[$itemType]) && (!self::getBackend($itemType) instanceof \OCP\Share_Backend_Collection || $itemType != 'folder')) {
|
||||
unset($collectionTypes[0]);
|
||||
}
|
||||
// Return array if collections were found or the item type is a
|
||||
// collection itself - collections can be inside collections
|
||||
if (count($collectionTypes) > 0) {
|
||||
return $collectionTypes;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get shared items from the database
|
||||
*
|
||||
* @param string $itemType
|
||||
* @param string $item Item source or target (optional)
|
||||
* @param int $shareType SHARE_TYPE_USER, SHARE_TYPE_GROUP, SHARE_TYPE_LINK, $shareTypeUserAndGroups, or $shareTypeGroupUserUnique
|
||||
* @param string $shareWith User or group the item is being shared with
|
||||
* @param string $uidOwner User that is the owner of shared items (optional)
|
||||
* @param int $format Format to convert items to with formatItems() (optional)
|
||||
* @param mixed $parameters to pass to formatItems() (optional)
|
||||
* @param int $limit Number of items to return, -1 to return all matches (optional)
|
||||
* @param boolean $includeCollections Include collection item types (optional)
|
||||
* @param boolean $itemShareWithBySource (optional)
|
||||
* @param boolean $checkExpireDate
|
||||
* @return array
|
||||
*
|
||||
* See public functions getItem(s)... for parameter usage
|
||||
*
|
||||
* Refactoring notes:
|
||||
* * defacto $limit, $itemsShareWithBySource, $checkExpireDate, $parameters and $format is always the default and therefore is removed in the subsequent call
|
||||
*/
|
||||
public static function getItems($itemType, ?string $item = null, ?int $shareType = null, $shareWith = null,
|
||||
$uidOwner = null, $format = self::FORMAT_NONE, $parameters = null, $limit = -1,
|
||||
$includeCollections = false, $itemShareWithBySource = false, $checkExpireDate = true) {
|
||||
if (\OC::$server->getConfig()->getAppValue('core', 'shareapi_enabled', 'yes') != 'yes') {
|
||||
return [];
|
||||
}
|
||||
$fileDependent = $itemType == 'file' || $itemType == 'folder';
|
||||
$qb = self::getSelectStatement(self::FORMAT_NONE, $fileDependent, $uidOwner);
|
||||
$qb->from('share', 's');
|
||||
|
||||
$backend = self::getBackend($itemType);
|
||||
$collectionTypes = false;
|
||||
// Get filesystem root to add it to the file target and remove from the
|
||||
// file source, match file_source with the file cache
|
||||
if ($fileDependent) {
|
||||
if (!is_null($uidOwner)) {
|
||||
$root = \OC\Files\Filesystem::getRoot();
|
||||
} else {
|
||||
$root = '';
|
||||
}
|
||||
if (isset($item)) {
|
||||
$qb->innerJoin('s', 'filecache', 'f', $qb->expr()->eq('file_source', 'f.fileid'));
|
||||
} else {
|
||||
$qb->innerJoin('s', 'filecache', 'f', $qb->expr()->andX(
|
||||
$qb->expr()->eq('file_source', 'f.fileid'),
|
||||
$qb->expr()->isNotNull('file_target')
|
||||
));
|
||||
}
|
||||
$qb->innerJoin('s', 'storages', 'st', $qb->expr()->eq('numeric_id', 'f.storage'));
|
||||
} else {
|
||||
$root = '';
|
||||
$collectionTypes = self::getCollectionItemTypes($itemType);
|
||||
if ($includeCollections && !isset($item) && $collectionTypes) {
|
||||
// If includeCollections is true, find collections of this item type, e.g. a music album contains songs
|
||||
if (!in_array($itemType, $collectionTypes)) {
|
||||
$itemTypes = array_merge([$itemType], $collectionTypes);
|
||||
} else {
|
||||
$itemTypes = $collectionTypes;
|
||||
}
|
||||
$qb->where($qb->expr()->in('item_type', $qb->createNamedParameter($itemTypes, IQueryBuilder::PARAM_STR_ARRAY)));
|
||||
} else {
|
||||
$qb->where($qb->expr()->eq('item_type', $qb->createNamedParameter($itemType)));
|
||||
}
|
||||
}
|
||||
if (\OC::$server->getConfig()->getAppValue('core', 'shareapi_allow_links', 'yes') !== 'yes') {
|
||||
$qb->andWhere($qb->expr()->neq('share_type', $qb->createNamedParameter(IShare::TYPE_LINK, IQueryBuilder::PARAM_INT)));
|
||||
}
|
||||
if (isset($shareType)) {
|
||||
// Include all user and group items
|
||||
if ($shareType === self::$shareTypeUserAndGroups && isset($shareWith)) {
|
||||
$qb->andWhere($qb->expr()->andX(
|
||||
$qb->expr()->in('share_type', $qb->createNamedParameter([IShare::TYPE_USER, self::$shareTypeGroupUserUnique], IQueryBuilder::PARAM_INT_ARRAY)),
|
||||
$qb->expr()->eq('share_with', $qb->createNamedParameter($shareWith))
|
||||
));
|
||||
|
||||
$user = \OC::$server->getUserManager()->get($shareWith);
|
||||
$groups = [];
|
||||
if ($user) {
|
||||
$groups = \OC::$server->getGroupManager()->getUserGroupIds($user);
|
||||
}
|
||||
if (!empty($groups)) {
|
||||
$qb->orWhere($qb->expr()->andX(
|
||||
$qb->expr()->eq('share_type', $qb->createNamedParameter(IShare::TYPE_GROUP, IQueryBuilder::PARAM_INT)),
|
||||
$qb->expr()->in('share_with', $qb->createNamedParameter($groups, IQueryBuilder::PARAM_STR_ARRAY))
|
||||
));
|
||||
}
|
||||
|
||||
// Don't include own group shares
|
||||
$qb->andWhere($qb->expr()->neq('uid_owner', $qb->createNamedParameter($shareWith)));
|
||||
} else {
|
||||
$qb->andWhere($qb->expr()->eq('share_type', $qb->createNamedParameter($shareType, IQueryBuilder::PARAM_INT)));
|
||||
if (isset($shareWith)) {
|
||||
$qb->andWhere($qb->expr()->eq('share_with', $qb->createNamedParameter($shareWith, IQueryBuilder::PARAM_STR)));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isset($uidOwner)) {
|
||||
$qb->andWhere($qb->expr()->eq('uid_owner', $qb->createNamedParameter($uidOwner)));
|
||||
if (!isset($shareType)) {
|
||||
// Prevent unique user targets for group shares from being selected
|
||||
$qb->andWhere($qb->expr()->neq('share_type', $qb->createNamedParameter(self::$shareTypeGroupUserUnique, IQueryBuilder::PARAM_INT)));
|
||||
}
|
||||
if ($fileDependent) {
|
||||
$column = 'file_source';
|
||||
} else {
|
||||
$column = 'item_source';
|
||||
}
|
||||
} else {
|
||||
if ($fileDependent) {
|
||||
$column = 'file_target';
|
||||
} else {
|
||||
$column = 'item_target';
|
||||
}
|
||||
}
|
||||
if (isset($item)) {
|
||||
$collectionTypes = self::getCollectionItemTypes($itemType);
|
||||
// If looking for own shared items, check item_source else check item_target
|
||||
if (isset($uidOwner)) {
|
||||
// If item type is a file, file source needs to be checked in case the item was converted
|
||||
if ($fileDependent) {
|
||||
$expr = $qb->expr()->eq('file_source', $qb->createNamedParameter($item));
|
||||
$column = 'file_source';
|
||||
} else {
|
||||
$expr = $qb->expr()->eq('item_source', $qb->createNamedParameter($item));
|
||||
$column = 'item_source';
|
||||
}
|
||||
} else {
|
||||
if ($fileDependent) {
|
||||
$item = \OC\Files\Filesystem::normalizePath($item);
|
||||
$expr = $qb->expr()->eq('file_target', $qb->createNamedParameter($item));
|
||||
} else {
|
||||
$expr = $qb->expr()->eq('item_target', $qb->createNamedParameter($item));
|
||||
}
|
||||
}
|
||||
if ($includeCollections && $collectionTypes && !in_array('folder', $collectionTypes)) {
|
||||
$qb->andWhere($qb->expr()->orX(
|
||||
$expr,
|
||||
$qb->expr()->in('item_type', $qb->createNamedParameter($collectionTypes, IQueryBuilder::PARAM_STR_ARRAY))
|
||||
));
|
||||
} else {
|
||||
$qb->andWhere($expr);
|
||||
}
|
||||
}
|
||||
$qb->orderBy('s.id', 'ASC');
|
||||
try {
|
||||
$result = $qb->executeQuery();
|
||||
} catch (\Exception $e) {
|
||||
\OCP\Server::get(LoggerInterface::class)->error(
|
||||
'Error while selecting shares: ' . $qb->getSQL(),
|
||||
[
|
||||
'app' => 'files_sharing',
|
||||
'exception' => $e
|
||||
]);
|
||||
throw new \RuntimeException('Wrong SQL query', 500, $e);
|
||||
}
|
||||
|
||||
$root = strlen($root);
|
||||
$items = [];
|
||||
$targets = [];
|
||||
$switchedItems = [];
|
||||
$mounts = [];
|
||||
while ($row = $result->fetch()) {
|
||||
//var_dump($row);
|
||||
self::transformDBResults($row);
|
||||
// Filter out duplicate group shares for users with unique targets
|
||||
if ($fileDependent && !self::isFileReachable($row['path'], $row['storage_id'])) {
|
||||
continue;
|
||||
}
|
||||
if ($row['share_type'] == self::$shareTypeGroupUserUnique && isset($items[$row['parent']])) {
|
||||
$row['share_type'] = IShare::TYPE_GROUP;
|
||||
$row['unique_name'] = true; // remember that we use a unique name for this user
|
||||
$row['share_with'] = $items[$row['parent']]['share_with'];
|
||||
// if the group share was unshared from the user we keep the permission, otherwise
|
||||
// we take the permission from the parent because this is always the up-to-date
|
||||
// permission for the group share
|
||||
if ($row['permissions'] > 0) {
|
||||
$row['permissions'] = $items[$row['parent']]['permissions'];
|
||||
}
|
||||
// Remove the parent group share
|
||||
unset($items[$row['parent']]);
|
||||
if ($row['permissions'] == 0) {
|
||||
continue;
|
||||
}
|
||||
} elseif (!isset($uidOwner)) {
|
||||
// Check if the same target already exists
|
||||
if (isset($targets[$row['id']])) {
|
||||
// Check if the same owner shared with the user twice
|
||||
// through a group and user share - this is allowed
|
||||
$id = $targets[$row['id']];
|
||||
if (isset($items[$id]) && $items[$id]['uid_owner'] == $row['uid_owner']) {
|
||||
// Switch to group share type to ensure resharing conditions aren't bypassed
|
||||
if ($items[$id]['share_type'] != IShare::TYPE_GROUP) {
|
||||
$items[$id]['share_type'] = IShare::TYPE_GROUP;
|
||||
$items[$id]['share_with'] = $row['share_with'];
|
||||
}
|
||||
// Switch ids if sharing permission is granted on only
|
||||
// one share to ensure correct parent is used if resharing
|
||||
if (~(int)$items[$id]['permissions'] & \OCP\Constants::PERMISSION_SHARE
|
||||
&& (int)$row['permissions'] & \OCP\Constants::PERMISSION_SHARE) {
|
||||
$items[$row['id']] = $items[$id];
|
||||
$switchedItems[$id] = $row['id'];
|
||||
unset($items[$id]);
|
||||
$id = $row['id'];
|
||||
}
|
||||
$items[$id]['permissions'] |= (int)$row['permissions'];
|
||||
}
|
||||
continue;
|
||||
} elseif (!empty($row['parent'])) {
|
||||
$targets[$row['parent']] = $row['id'];
|
||||
}
|
||||
}
|
||||
// Remove root from file source paths if retrieving own shared items
|
||||
if (isset($uidOwner) && isset($row['path'])) {
|
||||
if (isset($row['parent'])) {
|
||||
$query = \OC::$server->getDatabaseConnection()->getQueryBuilder();
|
||||
$query->select('file_target')
|
||||
->from('share')
|
||||
->where($query->expr()->eq('id', $query->createNamedParameter($row['parent'])));
|
||||
|
||||
$parentRow = false;
|
||||
try {
|
||||
$parentResult = $query->executeQuery();
|
||||
$parentRow = $parentResult->fetchOne();
|
||||
$parentResult->closeCursor();
|
||||
|
||||
$tmpPath = $parentRow['file_target'];
|
||||
// find the right position where the row path continues from the target path
|
||||
$pos = strrpos($row['path'], $parentRow['file_target']);
|
||||
$subPath = substr($row['path'], $pos);
|
||||
$splitPath = explode('/', $subPath);
|
||||
foreach (array_slice($splitPath, 2) as $pathPart) {
|
||||
$tmpPath = $tmpPath . '/' . $pathPart;
|
||||
}
|
||||
$row['path'] = $tmpPath;
|
||||
} catch (Exception $e) {
|
||||
\OCP\Server::get(LoggerInterface::class)
|
||||
->error('Can\'t select parent :' . $e->getMessage() . ' query=' . $query->getSQL(), [
|
||||
'exception' => $e,
|
||||
'app' => 'core'
|
||||
]);
|
||||
}
|
||||
} else {
|
||||
if (!isset($mounts[$row['storage']])) {
|
||||
$mountPoints = \OC\Files\Filesystem::getMountByNumericId($row['storage']);
|
||||
if (is_array($mountPoints) && !empty($mountPoints)) {
|
||||
$mounts[$row['storage']] = current($mountPoints);
|
||||
}
|
||||
}
|
||||
if (!empty($mounts[$row['storage']])) {
|
||||
$path = $mounts[$row['storage']]->getMountPoint() . $row['path'];
|
||||
$relPath = substr($path, $root); // path relative to data/user
|
||||
$row['path'] = rtrim($relPath, '/');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Check if resharing is allowed, if not remove share permission
|
||||
if (isset($row['permissions']) && (!self::isResharingAllowed() | \OCP\Util::isSharingDisabledForUser())) {
|
||||
$row['permissions'] &= ~\OCP\Constants::PERMISSION_SHARE;
|
||||
}
|
||||
// Add display names to result
|
||||
$row['share_with_displayname'] = $row['share_with'];
|
||||
if (isset($row['share_with']) && $row['share_with'] != '' &&
|
||||
$row['share_type'] === IShare::TYPE_USER) {
|
||||
$shareWithUser = \OC::$server->getUserManager()->get($row['share_with']);
|
||||
$row['share_with_displayname'] = $shareWithUser === null ? $row['share_with'] : $shareWithUser->getDisplayName();
|
||||
} elseif (isset($row['share_with']) && $row['share_with'] != '' &&
|
||||
$row['share_type'] === IShare::TYPE_REMOTE) {
|
||||
$addressBookEntries = \OC::$server->getContactsManager()->search($row['share_with'], ['CLOUD'], [
|
||||
'limit' => 1,
|
||||
'enumeration' => false,
|
||||
'fullmatch' => false,
|
||||
'strict_search' => true,
|
||||
]);
|
||||
foreach ($addressBookEntries as $entry) {
|
||||
foreach ($entry['CLOUD'] as $cloudID) {
|
||||
if ($cloudID === $row['share_with']) {
|
||||
$row['share_with_displayname'] = $entry['FN'];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isset($row['uid_owner']) && $row['uid_owner'] != '') {
|
||||
$ownerUser = \OC::$server->getUserManager()->get($row['uid_owner']);
|
||||
$row['displayname_owner'] = $ownerUser === null ? $row['uid_owner'] : $ownerUser->getDisplayName();
|
||||
}
|
||||
|
||||
if ($row['permissions'] > 0) {
|
||||
$items[$row['id']] = $row;
|
||||
}
|
||||
}
|
||||
$result->closeCursor();
|
||||
|
||||
// group items if we are looking for items shared with the current user
|
||||
if (isset($shareWith) && $shareWith === \OC_User::getUser()) {
|
||||
$items = self::groupItems($items, $itemType);
|
||||
}
|
||||
|
||||
if (!empty($items)) {
|
||||
$collectionItems = [];
|
||||
foreach ($items as &$row) {
|
||||
// Check if this is a collection of the requested item type
|
||||
if ($includeCollections && $collectionTypes && $row['item_type'] !== 'folder' && in_array($row['item_type'], $collectionTypes)) {
|
||||
if (($collectionBackend = self::getBackend($row['item_type']))
|
||||
&& $collectionBackend instanceof \OCP\Share_Backend_Collection) {
|
||||
// Collections can be inside collections, check if the item is a collection
|
||||
if (isset($item) && $row['item_type'] == $itemType && $row[$column] == $item) {
|
||||
$collectionItems[] = $row;
|
||||
} else {
|
||||
$collection = [];
|
||||
$collection['item_type'] = $row['item_type'];
|
||||
if ($row['item_type'] == 'file' || $row['item_type'] == 'folder') {
|
||||
$collection['path'] = basename($row['path']);
|
||||
}
|
||||
$row['collection'] = $collection;
|
||||
// Fetch all the children sources
|
||||
$children = $collectionBackend->getChildren($row[$column]);
|
||||
foreach ($children as $child) {
|
||||
$childItem = $row;
|
||||
$childItem['item_type'] = $itemType;
|
||||
if ($row['item_type'] != 'file' && $row['item_type'] != 'folder') {
|
||||
$childItem['item_source'] = $child['source'];
|
||||
$childItem['item_target'] = $child['target'];
|
||||
}
|
||||
if ($backend instanceof \OCP\Share_Backend_File_Dependent) {
|
||||
if ($row['item_type'] == 'file' || $row['item_type'] == 'folder') {
|
||||
$childItem['file_source'] = $child['source'];
|
||||
} else { // TODO is this really needed if we already know that we use the file backend?
|
||||
$meta = \OC\Files\Filesystem::getFileInfo($child['file_path']);
|
||||
$childItem['file_source'] = $meta['fileid'];
|
||||
}
|
||||
$childItem['file_target'] =
|
||||
\OC\Files\Filesystem::normalizePath($child['file_path']);
|
||||
}
|
||||
if (isset($item)) {
|
||||
if ($childItem[$column] == $item) {
|
||||
$collectionItems[] = $childItem;
|
||||
}
|
||||
} else {
|
||||
$collectionItems[] = $childItem;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
// Remove collection item
|
||||
$toRemove = $row['id'];
|
||||
if (array_key_exists($toRemove, $switchedItems)) {
|
||||
$toRemove = $switchedItems[$toRemove];
|
||||
}
|
||||
unset($items[$toRemove]);
|
||||
} elseif ($includeCollections && $collectionTypes && in_array($row['item_type'], $collectionTypes)) {
|
||||
// FIXME: Thats a dirty hack to improve file sharing performance,
|
||||
// see github issue #10588 for more details
|
||||
// Need to find a solution which works for all back-ends
|
||||
$collectionBackend = self::getBackend($row['item_type']);
|
||||
$sharedParents = $collectionBackend->getParents($row['item_source']);
|
||||
foreach ($sharedParents as $parent) {
|
||||
$collectionItems[] = $parent;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!empty($collectionItems)) {
|
||||
$collectionItems = array_unique($collectionItems, SORT_REGULAR);
|
||||
$items = array_merge($items, $collectionItems);
|
||||
}
|
||||
|
||||
// filter out invalid items, these can appear when subshare entries exist
|
||||
// for a group in which the requested user isn't a member any more
|
||||
$items = array_filter($items, function ($item) {
|
||||
return $item['share_type'] !== self::$shareTypeGroupUserUnique;
|
||||
});
|
||||
|
||||
return self::formatResult($items, $column, $backend);
|
||||
} elseif ($includeCollections && $collectionTypes && in_array('folder', $collectionTypes)) {
|
||||
// FIXME: Thats a dirty hack to improve file sharing performance,
|
||||
// see github issue #10588 for more details
|
||||
// Need to find a solution which works for all back-ends
|
||||
$collectionItems = [];
|
||||
$collectionBackend = self::getBackend('folder');
|
||||
$sharedParents = $collectionBackend->getParents($item, $shareWith, $uidOwner);
|
||||
foreach ($sharedParents as $parent) {
|
||||
$collectionItems[] = $parent;
|
||||
}
|
||||
return self::formatResult($collectionItems, $column, $backend);
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
/**
|
||||
* group items with link to the same source
|
||||
*
|
||||
|
|
|
|||
|
|
@ -108,7 +108,7 @@ class Share extends \OC\Share\Constants {
|
|||
* @param int $format (optional) Format type must be defined by the backend
|
||||
* @param mixed $parameters
|
||||
* @param bool $includeCollections
|
||||
* @return mixed Return depends on format
|
||||
* @return void
|
||||
* @since 5.0.0
|
||||
* @deprecated 17.0.0
|
||||
*
|
||||
|
|
@ -117,7 +117,7 @@ class Share extends \OC\Share\Constants {
|
|||
*/
|
||||
public static function getItemShared($itemType, $itemSource, $format = self::FORMAT_NONE,
|
||||
$parameters = null, $includeCollections = false) {
|
||||
return \OC\Share\Share::getItemShared($itemType, $itemSource, self::FORMAT_NONE, null, $includeCollections);
|
||||
// not used by any app - only here to not break apps syntax
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
|
|||
Loading…
Reference in a new issue