2014-02-18 15:37:32 +04:00
< ? php
/**
* ownCloud
*
* @ author Bjoern Schiessle , Michael Gapczynski
* @ copyright 2012 Michael Gapczynski < mtgap @ owncloud . com >
* 2014 Bjoern Schiessle < schiessle @ owncloud . com >
*
* This library is free software ; you can redistribute it and / or
* modify it under the terms of the GNU AFFERO GENERAL PUBLIC LICENSE
* License as published by the Free Software Foundation ; either
* version 3 of the License , or any later version .
*
* This library 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 along with this library . If not , see < http :// www . gnu . org / licenses />.
*/
namespace OC\Share ;
/**
* This class provides the ability for apps to share their content between users .
* Apps must create a backend class that implements OCP\Share_Backend and register it with this class .
*
* It provides the following hooks :
* - post_shared
*/
2014-02-18 18:07:03 +04:00
class Share extends \OC\Share\Constants {
2014-02-18 15:37:32 +04:00
/** CRUDS permissions ( Create , Read , Update , Delete , Share ) using a bitmask
* Construct permissions for share () and setPermissions with Or ( | ) e . g .
* Give user read and update permissions : PERMISSION_READ | PERMISSION_UPDATE
*
* Check if permission is granted with And ( & ) e . g . Check if delete is
* granted : if ( $permissions & PERMISSION_DELETE )
*
* Remove permissions with And ( & ) and Not ( ~ ) e . g . Remove the update
* permission : $permissions &= ~ PERMISSION_UPDATE
*
* Apps are required to handle permissions on their own , this class only
* stores and manages the permissions of shares
* @ see lib / public / constants . php
*/
/**
* Register a sharing backend class that implements OCP\Share_Backend for an item type
2014-04-15 19:46:11 +04:00
* @ param string $itemType Item type
* @ param string $class Backend class
* @ param string $collectionOf ( optional ) Depends on item type
* @ param array $supportedFileExtensions ( optional ) List of supported file extensions if this item type depends on files
* @ return boolean true if backend is registered or false if error
2014-02-18 15:37:32 +04:00
*/
public static function registerBackend ( $itemType , $class , $collectionOf = null , $supportedFileExtensions = null ) {
if ( self :: isEnabled ()) {
if ( ! isset ( self :: $backendTypes [ $itemType ])) {
self :: $backendTypes [ $itemType ] = array (
'class' => $class ,
'collectionOf' => $collectionOf ,
'supportedFileExtensions' => $supportedFileExtensions
);
if ( count ( self :: $backendTypes ) === 1 ) {
\OC_Util :: addScript ( 'core' , 'share' );
\OC_Util :: addStyle ( 'core' , 'share' );
}
return true ;
}
\OC_Log :: write ( 'OCP\Share' ,
'Sharing backend ' . $class . ' not registered, ' . self :: $backendTypes [ $itemType ][ 'class' ]
. ' is already registered for ' . $itemType ,
\OC_Log :: WARN );
}
return false ;
}
/**
* Check if the Share API is enabled
2014-04-15 19:46:11 +04:00
* @ return boolean true if enabled or false
2014-02-18 15:37:32 +04:00
*
* The Share API is enabled by default if not configured
*/
public static function isEnabled () {
if ( \OC_Appconfig :: getValue ( 'core' , 'shareapi_enabled' , 'yes' ) == 'yes' ) {
return true ;
}
return false ;
}
/**
* Find which users can access a shared item
2014-04-02 14:54:41 +04:00
* @ param string $path to the file
* @ param string $ownerUser owner of the file
2014-05-07 22:46:08 +04:00
* @ param boolean $includeOwner include owner to the list of users with access to the file
* @ param boolean $returnUserPaths Return an array with the user => path map
2014-02-18 15:37:32 +04:00
* @ return array
* @ note $path needs to be relative to user data dir , e . g . 'file.txt'
* not '/admin/data/file.txt'
*/
2014-04-02 14:54:41 +04:00
public static function getUsersSharingFile ( $path , $ownerUser , $includeOwner = false , $returnUserPaths = false ) {
2014-02-18 15:37:32 +04:00
2014-04-02 14:54:41 +04:00
$shares = $sharePaths = $fileTargets = array ();
2014-02-18 15:37:32 +04:00
$publicShare = false ;
$source = - 1 ;
$cache = false ;
2014-04-02 14:54:41 +04:00
$view = new \OC\Files\View ( '/' . $ownerUser . '/files' );
2014-02-18 15:37:32 +04:00
if ( $view -> file_exists ( $path )) {
$meta = $view -> getFileInfo ( $path );
2014-04-02 14:54:41 +04:00
$path = substr ( $meta -> getPath (), strlen ( '/' . $ownerUser . '/files' ));
2014-02-18 15:37:32 +04:00
} else {
// if the file doesn't exists yet we start with the parent folder
$meta = $view -> getFileInfo ( dirname ( $path ));
}
if ( $meta !== false ) {
$source = $meta [ 'fileid' ];
$cache = new \OC\Files\Cache\Cache ( $meta [ 'storage' ]);
}
while ( $source !== - 1 ) {
// Fetch all shares with another user
$query = \OC_DB :: prepare (
2014-04-02 14:54:41 +04:00
' SELECT `share_with` , `file_source` , `file_target`
2014-02-18 15:37:32 +04:00
FROM
`*PREFIX*share`
WHERE
`item_source` = ? AND `share_type` = ? AND `item_type` IN ( \ 'file\', \'folder\')'
);
$result = $query -> execute ( array ( $source , self :: SHARE_TYPE_USER ));
if ( \OCP\DB :: isError ( $result )) {
\OCP\Util :: writeLog ( 'OCP\Share' , \OC_DB :: getErrorMessage ( $result ), \OC_Log :: ERROR );
} else {
while ( $row = $result -> fetchRow ()) {
$shares [] = $row [ 'share_with' ];
2014-04-02 14:54:41 +04:00
if ( $returnUserPaths ) {
$fileTargets [( int ) $row [ 'file_source' ]][ $row [ 'share_with' ]] = $row ;
}
2014-02-18 15:37:32 +04:00
}
}
2014-04-02 14:54:41 +04:00
// We also need to take group shares into account
2014-02-18 15:37:32 +04:00
$query = \OC_DB :: prepare (
2014-04-02 14:54:41 +04:00
' SELECT `share_with` , `file_source` , `file_target`
2014-02-18 15:37:32 +04:00
FROM
`*PREFIX*share`
WHERE
`item_source` = ? AND `share_type` = ? AND `item_type` IN ( \ 'file\', \'folder\')'
);
$result = $query -> execute ( array ( $source , self :: SHARE_TYPE_GROUP ));
if ( \OCP\DB :: isError ( $result )) {
\OCP\Util :: writeLog ( 'OCP\Share' , \OC_DB :: getErrorMessage ( $result ), \OC_Log :: ERROR );
} else {
while ( $row = $result -> fetchRow ()) {
$usersInGroup = \OC_Group :: usersInGroup ( $row [ 'share_with' ]);
$shares = array_merge ( $shares , $usersInGroup );
2014-04-02 14:54:41 +04:00
if ( $returnUserPaths ) {
foreach ( $usersInGroup as $user ) {
$fileTargets [( int ) $row [ 'file_source' ]][ $user ] = $row ;
}
}
2014-02-18 15:37:32 +04:00
}
}
//check for public link shares
if ( ! $publicShare ) {
$query = \OC_DB :: prepare (
' SELECT `share_with`
FROM
`*PREFIX*share`
WHERE
`item_source` = ? AND `share_type` = ? AND `item_type` IN ( \ 'file\', \'folder\')'
);
$result = $query -> execute ( array ( $source , self :: SHARE_TYPE_LINK ));
if ( \OCP\DB :: isError ( $result )) {
\OCP\Util :: writeLog ( 'OCP\Share' , \OC_DB :: getErrorMessage ( $result ), \OC_Log :: ERROR );
} else {
if ( $result -> fetchRow ()) {
$publicShare = true ;
}
}
}
// let's get the parent for the next round
$meta = $cache -> get (( int ) $source );
if ( $meta !== false ) {
$source = ( int ) $meta [ 'parent' ];
} else {
$source = - 1 ;
}
}
2014-04-02 14:54:41 +04:00
2014-02-18 15:37:32 +04:00
// Include owner in list of users, if requested
if ( $includeOwner ) {
2014-04-02 14:54:41 +04:00
$shares [] = $ownerUser ;
if ( $returnUserPaths ) {
$sharePaths [ $ownerUser ] = $path ;
}
}
if ( $returnUserPaths ) {
$fileTargetIDs = array_keys ( $fileTargets );
$fileTargetIDs = array_unique ( $fileTargetIDs );
2014-04-09 17:01:39 +04:00
if ( ! empty ( $fileTargetIDs )) {
$query = \OC_DB :: prepare (
' SELECT `fileid` , `path`
FROM `*PREFIX*filecache`
WHERE `fileid` IN ( ' . implode(' , ', $fileTargetIDs) . ' ) '
);
$result = $query -> execute ();
2014-04-02 14:54:41 +04:00
2014-04-09 17:01:39 +04:00
if ( \OCP\DB :: isError ( $result )) {
\OCP\Util :: writeLog ( 'OCP\Share' , \OC_DB :: getErrorMessage ( $result ), \OC_Log :: ERROR );
} else {
while ( $row = $result -> fetchRow ()) {
foreach ( $fileTargets [ $row [ 'fileid' ]] as $uid => $shareData ) {
2014-04-23 14:59:22 +04:00
$sharedPath = $shareData [ 'file_target' ];
2014-04-09 17:01:39 +04:00
$sharedPath .= substr ( $path , strlen ( $row [ 'path' ]) - 5 );
$sharePaths [ $uid ] = $sharedPath ;
}
2014-04-02 14:54:41 +04:00
}
}
}
return $sharePaths ;
2014-02-18 15:37:32 +04:00
}
return array ( " users " => array_unique ( $shares ), " public " => $publicShare );
}
/**
* Get the items of item type shared with the current user
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param int $format ( optional ) Format type must be defined by the backend
* @ param mixed $parameters ( optional )
* @ param int $limit Number of items to return ( optional ) Returns all by default
2014-05-07 22:46:08 +04:00
* @ param boolean $includeCollections ( optional )
2014-04-15 19:46:11 +04:00
* @ return mixed Return depends on format
2014-02-18 15:37:32 +04:00
*/
public static function getItemsSharedWith ( $itemType , $format = self :: FORMAT_NONE ,
$parameters = null , $limit = - 1 , $includeCollections = false ) {
return self :: getItems ( $itemType , null , self :: $shareTypeUserAndGroups , \OC_User :: getUser (), null , $format ,
$parameters , $limit , $includeCollections );
}
2014-04-08 16:42:15 +04:00
/**
* Get the items of item type shared with a user
2014-05-12 00:51:30 +04:00
* @ param string $itemType
* @ param string $user id for which user we want the shares
* @ param int $format ( optional ) Format type must be defined by the backend
* @ param mixed $parameters ( optional )
* @ param int $limit Number of items to return ( optional ) Returns all by default
* @ param boolean $includeCollections ( optional )
2014-05-13 14:27:35 +04:00
* @ return mixed Return depends on format
2014-04-08 16:42:15 +04:00
*/
public static function getItemsSharedWithUser ( $itemType , $user , $format = self :: FORMAT_NONE ,
$parameters = null , $limit = - 1 , $includeCollections = false ) {
return self :: getItems ( $itemType , null , self :: $shareTypeUserAndGroups , $user , null , $format ,
$parameters , $limit , $includeCollections );
}
2014-02-18 15:37:32 +04:00
/**
* Get the item of item type shared with the current user
* @ param string $itemType
* @ param string $itemTarget
* @ param int $format ( optional ) Format type must be defined by the backend
2014-04-15 19:46:11 +04:00
* @ param mixed $parameters ( optional )
2014-05-07 22:46:08 +04:00
* @ param boolean $includeCollections ( optional )
2014-04-15 19:46:11 +04:00
* @ return mixed Return depends on format
2014-02-18 15:37:32 +04:00
*/
public static function getItemSharedWith ( $itemType , $itemTarget , $format = self :: FORMAT_NONE ,
$parameters = null , $includeCollections = false ) {
return self :: getItems ( $itemType , $itemTarget , self :: $shareTypeUserAndGroups , \OC_User :: getUser (), null , $format ,
$parameters , 1 , $includeCollections );
}
/**
* Get the item of item type shared with a given user by source
* @ param string $itemType
* @ param string $itemSource
2014-11-10 15:08:45 +03:00
* @ param string $user User to whom the item was shared
* @ param string $owner Owner of the share
2014-11-17 20:05:12 +03:00
* @ param int $shareType only look for a specific share type
2014-02-18 15:37:32 +04:00
* @ return array Return list of items with file_target , permissions and expiration
*/
2014-11-10 15:08:45 +03:00
public static function getItemSharedWithUser ( $itemType , $itemSource , $user , $owner = null , $shareType = null ) {
2014-02-18 15:37:32 +04:00
$shares = array ();
2014-10-13 16:49:16 +04:00
$fileDependend = false ;
2014-02-18 15:37:32 +04:00
2014-10-01 17:13:10 +04:00
if ( $itemType === 'file' || $itemType === 'folder' ) {
2014-10-13 16:49:16 +04:00
$fileDependend = true ;
2014-10-01 17:13:10 +04:00
$column = 'file_source' ;
$where = 'INNER JOIN `*PREFIX*filecache` ON `file_source` = `*PREFIX*filecache`.`fileid` WHERE' ;
} else {
$column = 'item_source' ;
$where = 'WHERE' ;
}
2014-10-13 16:49:16 +04:00
$select = self :: createSelectStatement ( self :: FORMAT_NONE , $fileDependend );
2014-09-29 13:23:18 +04:00
2014-10-01 17:13:10 +04:00
$where .= ' `' . $column . '` = ? AND `item_type` = ? ' ;
2014-09-26 18:58:47 +04:00
$arguments = array ( $itemSource , $itemType );
// for link shares $user === null
if ( $user !== null ) {
$where .= ' AND `share_with` = ? ' ;
$arguments [] = $user ;
}
2014-11-17 20:05:12 +03:00
if ( $shareType !== null ) {
$where .= ' AND `share_type` = ? ' ;
$arguments [] = $shareType ;
}
2014-11-10 15:08:45 +03:00
if ( $owner !== null ) {
$where .= ' AND `uid_owner` = ? ' ;
$arguments [] = $owner ;
}
2014-10-01 17:13:10 +04:00
$query = \OC_DB :: prepare ( 'SELECT ' . $select . ' FROM `*PREFIX*share` ' . $where );
2014-02-18 15:37:32 +04:00
2014-09-26 18:58:47 +04:00
$result = \OC_DB :: executeAudited ( $query , $arguments );
2014-02-18 15:37:32 +04:00
while ( $row = $result -> fetchRow ()) {
$shares [] = $row ;
}
//if didn't found a result than let's look for a group share.
2014-09-26 18:58:47 +04:00
if ( empty ( $shares ) && $user !== null ) {
2014-02-18 15:37:32 +04:00
$groups = \OC_Group :: getUserGroups ( $user );
$query = \OC_DB :: prepare (
2014-10-01 17:13:10 +04:00
' SELECT *
2014-02-18 15:37:32 +04:00
FROM
`*PREFIX*share`
WHERE
2014-09-26 18:58:47 +04:00
`' . $column . '` = ? AND `item_type` = ? AND `share_with` in ( ? ) '
2014-02-18 15:37:32 +04:00
);
$result = \OC_DB :: executeAudited ( $query , array ( $itemSource , $itemType , implode ( ',' , $groups )));
while ( $row = $result -> fetchRow ()) {
$shares [] = $row ;
}
}
return $shares ;
}
/**
* Get the item of item type shared with the current user by source
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param string $itemSource
* @ param int $format ( optional ) Format type must be defined by the backend
* @ param mixed $parameters
2014-05-07 22:46:08 +04:00
* @ param boolean $includeCollections
2014-07-31 13:55:59 +04:00
* @ param string $shareWith ( optional ) define against which user should be checked , default : current user
2014-09-25 13:29:57 +04:00
* @ return array
2014-02-18 15:37:32 +04:00
*/
public static function getItemSharedWithBySource ( $itemType , $itemSource , $format = self :: FORMAT_NONE ,
2014-07-31 13:55:59 +04:00
$parameters = null , $includeCollections = false , $shareWith = null ) {
$shareWith = ( $shareWith === null ) ? \OC_User :: getUser () : $shareWith ;
return self :: getItems ( $itemType , $itemSource , self :: $shareTypeUserAndGroups , $shareWith , null , $format ,
2014-02-18 15:37:32 +04:00
$parameters , 1 , $includeCollections , true );
}
/**
* Get the item of item type shared by a link
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param string $itemSource
* @ param string $uidOwner Owner of link
2014-05-13 14:27:35 +04:00
* @ return array
2014-02-18 15:37:32 +04:00
*/
public static function getItemSharedWithByLink ( $itemType , $itemSource , $uidOwner ) {
return self :: getItems ( $itemType , $itemSource , self :: SHARE_TYPE_LINK , null , $uidOwner , self :: FORMAT_NONE ,
null , 1 );
}
/**
* Based on the given token the share information will be returned - password protected shares will be verified
* @ param string $token
2014-05-11 21:28:45 +04:00
* @ return array | boolean false will be returned in case the token is unknown or unauthorized
2014-02-18 15:37:32 +04:00
*/
public static function getShareByToken ( $token , $checkPasswordProtection = true ) {
$query = \OC_DB :: prepare ( 'SELECT * FROM `*PREFIX*share` WHERE `token` = ?' , 1 );
$result = $query -> execute ( array ( $token ));
if ( \OC_DB :: isError ( $result )) {
\OC_Log :: write ( 'OCP\Share' , \OC_DB :: getErrorMessage ( $result ) . ', token=' . $token , \OC_Log :: ERROR );
}
$row = $result -> fetchRow ();
if ( $row === false ) {
return false ;
}
if ( is_array ( $row ) and self :: expireItem ( $row )) {
return false ;
}
// password protected shares need to be authenticated
if ( $checkPasswordProtection && ! \OCP\Share :: checkPasswordProtectedShare ( $row )) {
return false ;
}
return $row ;
}
/**
* resolves reshares down to the last real share
2014-05-12 00:51:30 +04:00
* @ param array $linkItem
* @ return array file owner
2014-02-18 15:37:32 +04:00
*/
public static function resolveReShare ( $linkItem )
{
if ( isset ( $linkItem [ 'parent' ])) {
$parent = $linkItem [ 'parent' ];
while ( isset ( $parent )) {
$query = \OC_DB :: prepare ( 'SELECT * FROM `*PREFIX*share` WHERE `id` = ?' , 1 );
$item = $query -> execute ( array ( $parent )) -> fetchRow ();
if ( isset ( $item [ 'parent' ])) {
$parent = $item [ 'parent' ];
} else {
return $item ;
}
}
}
return $linkItem ;
}
/**
* Get the shared items of item type owned by the current user
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param int $format ( optional ) Format type must be defined by the backend
* @ param mixed $parameters
* @ param int $limit Number of items to return ( optional ) Returns all by default
2014-05-07 22:46:08 +04:00
* @ param boolean $includeCollections
2014-04-15 19:46:11 +04:00
* @ return mixed Return depends on format
2014-02-18 15:37:32 +04:00
*/
public static function getItemsShared ( $itemType , $format = self :: FORMAT_NONE , $parameters = null ,
$limit = - 1 , $includeCollections = false ) {
return self :: getItems ( $itemType , null , null , null , \OC_User :: getUser (), $format ,
$parameters , $limit , $includeCollections );
}
/**
* Get the shared item of item type owned by the current user
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param string $itemSource
* @ param int $format ( optional ) Format type must be defined by the backend
* @ param mixed $parameters
2014-05-07 22:46:08 +04:00
* @ param boolean $includeCollections
2014-04-15 19:46:11 +04:00
* @ return mixed Return depends on format
2014-02-18 15:37:32 +04:00
*/
public static function getItemShared ( $itemType , $itemSource , $format = self :: FORMAT_NONE ,
$parameters = null , $includeCollections = false ) {
return self :: getItems ( $itemType , $itemSource , null , null , \OC_User :: getUser (), $format ,
$parameters , - 1 , $includeCollections );
}
/**
* Get all users an item is shared with
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param string $itemSource
* @ param string $uidOwner
2014-05-07 22:46:08 +04:00
* @ param boolean $includeCollections
* @ param boolean $checkExpireDate
2014-05-12 00:51:30 +04:00
* @ return array Return array of users
2014-02-18 15:37:32 +04:00
*/
public static function getUsersItemShared ( $itemType , $itemSource , $uidOwner , $includeCollections = false , $checkExpireDate = true ) {
$users = array ();
$items = self :: getItems ( $itemType , $itemSource , null , null , $uidOwner , self :: FORMAT_NONE , null , - 1 , $includeCollections , false , $checkExpireDate );
if ( $items ) {
foreach ( $items as $item ) {
if (( int ) $item [ 'share_type' ] === self :: SHARE_TYPE_USER ) {
$users [] = $item [ 'share_with' ];
} else if (( int ) $item [ 'share_type' ] === self :: SHARE_TYPE_GROUP ) {
$users = array_merge ( $users , \OC_Group :: usersInGroup ( $item [ 'share_with' ]));
}
}
}
return $users ;
}
/**
* Share an item with a user , group , or via private link
* @ param string $itemType
* @ param string $itemSource
* @ param int $shareType SHARE_TYPE_USER , SHARE_TYPE_GROUP , or SHARE_TYPE_LINK
* @ param string $shareWith User or group the item is being shared with
* @ param int $permissions CRUDS
2014-05-07 13:23:50 +04:00
* @ param string $itemSourceName
* @ param \DateTime $expirationDate
2014-05-07 22:46:08 +04:00
* @ return boolean | string Returns true on success or false on failure , Returns token on success for links
2014-05-07 13:23:50 +04:00
* @ throws \Exception
2014-02-18 15:37:32 +04:00
*/
2014-05-07 13:23:50 +04:00
public static function shareItem ( $itemType , $itemSource , $shareType , $shareWith , $permissions , $itemSourceName = null , \DateTime $expirationDate = null ) {
2014-02-18 15:37:32 +04:00
$uidOwner = \OC_User :: getUser ();
2014-06-04 13:07:31 +04:00
$shareWithinGroupOnly = self :: shareWithGroupMembersOnly ();
2014-08-31 12:05:59 +04:00
$l = \OC :: $server -> getL10N ( 'lib' );
2014-02-18 15:37:32 +04:00
if ( is_null ( $itemSourceName )) {
$itemSourceName = $itemSource ;
}
2014-05-13 17:22:18 +04:00
// check if file can be shared
2014-03-18 12:25:04 +04:00
if ( $itemType === 'file' or $itemType === 'folder' ) {
$path = \OC\Files\Filesystem :: getPath ( $itemSource );
2014-05-13 17:22:18 +04:00
// verify that the file exists before we try to share it
2014-03-18 12:25:04 +04:00
if ( ! $path ) {
2014-04-24 03:42:18 +04:00
$message = 'Sharing %s failed, because the file does not exist' ;
$message_t = $l -> t ( 'Sharing %s failed, because the file does not exist' , array ( $itemSourceName ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-03-18 12:25:04 +04:00
}
2014-05-13 17:22:18 +04:00
// verify that the user has share permission
if ( ! \OC\Files\Filesystem :: isSharable ( $path )) {
$message = 'You are not allowed to share %s' ;
$message_t = $l -> t ( 'You are not allowed to share %s' , array ( $itemSourceName ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
}
2014-03-18 12:25:04 +04:00
}
2014-04-15 13:19:31 +04:00
//verify that we don't share a folder which already contains a share mount point
if ( $itemType === 'folder' ) {
$path = '/' . $uidOwner . '/files' . \OC\Files\Filesystem :: getPath ( $itemSource ) . '/' ;
$mountManager = \OC\Files\Filesystem :: getMountManager ();
2014-06-10 15:50:52 +04:00
$mounts = $mountManager -> findIn ( $path );
foreach ( $mounts as $mount ) {
if ( $mount -> getStorage () -> instanceOfStorage ( '\OCA\Files_Sharing\ISharedStorage' )) {
2014-04-15 13:19:31 +04:00
$message = 'Sharing "' . $itemSourceName . '" failed, because it contains files shared with you!' ;
\OC_Log :: write ( 'OCP\Share' , $message , \OC_Log :: ERROR );
throw new \Exception ( $message );
}
}
}
2014-05-27 13:05:31 +04:00
// single file shares should never have delete permissions
if ( $itemType === 'file' ) {
2014-11-25 18:28:41 +03:00
$permissions = ( int ) $permissions & ~ \OCP\Constants :: PERMISSION_DELETE ;
2014-05-27 13:05:31 +04:00
}
2014-02-18 15:37:32 +04:00
// Verify share type and sharing conditions are met
if ( $shareType === self :: SHARE_TYPE_USER ) {
if ( $shareWith == $uidOwner ) {
2014-04-05 21:23:12 +04:00
$message = 'Sharing %s failed, because the user %s is the item owner' ;
$message_t = $l -> t ( 'Sharing %s failed, because the user %s is the item owner' , array ( $itemSourceName , $shareWith ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
if ( ! \OC_User :: userExists ( $shareWith )) {
2014-04-05 21:23:12 +04:00
$message = 'Sharing %s failed, because the user %s does not exist' ;
$message_t = $l -> t ( 'Sharing %s failed, because the user %s does not exist' , array ( $itemSourceName , $shareWith ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
2014-06-04 13:07:31 +04:00
if ( $shareWithinGroupOnly ) {
2014-02-18 15:37:32 +04:00
$inGroup = array_intersect ( \OC_Group :: getUserGroups ( $uidOwner ), \OC_Group :: getUserGroups ( $shareWith ));
if ( empty ( $inGroup )) {
2014-04-05 21:23:12 +04:00
$message = 'Sharing %s failed, because the user '
. '%s is not a member of any groups that %s is a member of' ;
$message_t = $l -> t ( 'Sharing %s failed, because the user %s is not a member of any groups that %s is a member of' , array ( $itemSourceName , $shareWith , $uidOwner ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith , $uidOwner ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
}
// Check if the item source is already shared with the user, either from the same owner or a different user
if ( $checkExists = self :: getItems ( $itemType , $itemSource , self :: $shareTypeUserAndGroups ,
$shareWith , null , self :: FORMAT_NONE , null , 1 , true , true )) {
// Only allow the same share to occur again if it is the same
// owner and is not a user share, this use case is for increasing
// permissions for a specific user
if ( $checkExists [ 'uid_owner' ] != $uidOwner || $checkExists [ 'share_type' ] == $shareType ) {
2014-04-05 21:23:12 +04:00
$message = 'Sharing %s failed, because this item is already shared with %s' ;
$message_t = $l -> t ( 'Sharing %s failed, because this item is already shared with %s' , array ( $itemSourceName , $shareWith ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
}
} else if ( $shareType === self :: SHARE_TYPE_GROUP ) {
if ( ! \OC_Group :: groupExists ( $shareWith )) {
2014-04-05 21:23:12 +04:00
$message = 'Sharing %s failed, because the group %s does not exist' ;
$message_t = $l -> t ( 'Sharing %s failed, because the group %s does not exist' , array ( $itemSourceName , $shareWith ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
2014-06-04 13:07:31 +04:00
if ( $shareWithinGroupOnly && ! \OC_Group :: inGroup ( $uidOwner , $shareWith )) {
2014-04-05 21:23:12 +04:00
$message = 'Sharing %s failed, because '
. '%s is not a member of the group %s' ;
$message_t = $l -> t ( 'Sharing %s failed, because %s is not a member of the group %s' , array ( $itemSourceName , $uidOwner , $shareWith ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $uidOwner , $shareWith ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
// Check if the item source is already shared with the group, either from the same owner or a different user
// The check for each user in the group is done inside the put() function
if ( $checkExists = self :: getItems ( $itemType , $itemSource , self :: SHARE_TYPE_GROUP , $shareWith ,
null , self :: FORMAT_NONE , null , 1 , true , true )) {
// Only allow the same share to occur again if it is the same
// owner and is not a group share, this use case is for increasing
// permissions for a specific user
if ( $checkExists [ 'uid_owner' ] != $uidOwner || $checkExists [ 'share_type' ] == $shareType ) {
2014-04-05 21:23:12 +04:00
$message = 'Sharing %s failed, because this item is already shared with %s' ;
$message_t = $l -> t ( 'Sharing %s failed, because this item is already shared with %s' , array ( $itemSourceName , $shareWith ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
}
// Convert share with into an array with the keys group and users
$group = $shareWith ;
$shareWith = array ();
$shareWith [ 'group' ] = $group ;
$shareWith [ 'users' ] = array_diff ( \OC_Group :: usersInGroup ( $group ), array ( $uidOwner ));
} else if ( $shareType === self :: SHARE_TYPE_LINK ) {
2014-07-28 19:13:17 +04:00
$updateExistingShare = false ;
2014-02-18 15:37:32 +04:00
if ( \OC_Appconfig :: getValue ( 'core' , 'shareapi_allow_links' , 'yes' ) == 'yes' ) {
2014-05-12 14:19:07 +04:00
2014-02-18 15:37:32 +04:00
// when updating a link share
2014-05-12 14:19:07 +04:00
// FIXME Don't delete link if we update it
2014-02-18 15:37:32 +04:00
if ( $checkExists = self :: getItems ( $itemType , $itemSource , self :: SHARE_TYPE_LINK , null ,
$uidOwner , self :: FORMAT_NONE , null , 1 )) {
// remember old token
$oldToken = $checkExists [ 'token' ];
$oldPermissions = $checkExists [ 'permissions' ];
//delete the old share
2014-02-18 18:07:03 +04:00
Helper :: delete ( $checkExists [ 'id' ]);
2014-06-03 17:15:04 +04:00
$updateExistingShare = true ;
2014-02-18 15:37:32 +04:00
}
// Generate hash of password - same method as user passwords
2014-05-12 14:19:07 +04:00
if ( ! empty ( $shareWith )) {
2014-11-17 15:10:15 +03:00
$shareWith = \OC :: $server -> getHasher () -> hash ( $shareWith );
2014-02-18 15:37:32 +04:00
} else {
// reuse the already set password, but only if we change permissions
// otherwise the user disabled the password protection
if ( $checkExists && ( int ) $permissions !== ( int ) $oldPermissions ) {
$shareWith = $checkExists [ 'share_with' ];
}
}
2014-05-12 14:19:07 +04:00
if ( \OCP\Util :: isPublicLinkPasswordRequired () && empty ( $shareWith )) {
$message = 'You need to provide a password to create a public link, only protected links are allowed' ;
$message_t = $l -> t ( 'You need to provide a password to create a public link, only protected links are allowed' );
\OC_Log :: write ( 'OCP\Share' , $message , \OC_Log :: ERROR );
throw new \Exception ( $message_t );
}
2014-07-28 19:13:17 +04:00
if ( $updateExistingShare === false &&
2014-06-03 17:15:04 +04:00
self :: isDefaultExpireDateEnabled () &&
empty ( $expirationDate )) {
$expirationDate = Helper :: calcExpireDate ();
}
2014-02-18 15:37:32 +04:00
// Generate token
if ( isset ( $oldToken )) {
$token = $oldToken ;
} else {
2014-09-04 18:46:20 +04:00
$token = \OC :: $server -> getSecureRandom () -> getMediumStrengthGenerator () -> generate ( self :: TOKEN_LENGTH ,
2014-09-04 18:20:20 +04:00
\OCP\Security\ISecureRandom :: CHAR_LOWER . \OCP\Security\ISecureRandom :: CHAR_UPPER .
\OCP\Security\ISecureRandom :: CHAR_DIGITS
2014-08-03 13:31:28 +04:00
);
2014-02-18 15:37:32 +04:00
}
$result = self :: put ( $itemType , $itemSource , $shareType , $shareWith , $uidOwner , $permissions ,
2014-05-07 13:23:50 +04:00
null , $token , $itemSourceName , $expirationDate );
2014-02-18 15:37:32 +04:00
if ( $result ) {
return $token ;
} else {
return false ;
}
}
2014-04-05 21:23:12 +04:00
$message = 'Sharing %s failed, because sharing with links is not allowed' ;
$message_t = $l -> t ( 'Sharing %s failed, because sharing with links is not allowed' , array ( $itemSourceName ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
} else {
// Future share types need to include their own conditions
2014-04-05 21:23:12 +04:00
$message = 'Share type %s is not valid for %s' ;
$message_t = $l -> t ( 'Share type %s is not valid for %s' , array ( $shareType , $itemSource ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $shareType , $itemSource ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
2014-05-07 13:23:50 +04:00
// Put the item into the database
return self :: put ( $itemType , $itemSource , $shareType , $shareWith , $uidOwner , $permissions , null , null , $itemSourceName , $expirationDate );
2014-02-18 15:37:32 +04:00
}
/**
* Unshare an item from a user , group , or delete a private link
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param string $itemSource
* @ param int $shareType SHARE_TYPE_USER , SHARE_TYPE_GROUP , or SHARE_TYPE_LINK
* @ param string $shareWith User or group the item is being shared with
2014-11-24 17:31:52 +03:00
* @ param string $owner owner of the share , if null the current user is used
2014-04-15 19:46:11 +04:00
* @ return boolean true on success or false on failure
2014-02-18 15:37:32 +04:00
*/
2014-11-24 17:31:52 +03:00
public static function unshare ( $itemType , $itemSource , $shareType , $shareWith , $owner = null ) {
2014-09-26 18:58:47 +04:00
// check if it is a valid itemType
self :: getBackend ( $itemType );
2014-11-24 17:31:52 +03:00
$items = self :: getItemSharedWithUser ( $itemType , $itemSource , $shareWith , $owner , $shareType );
2014-09-26 18:58:47 +04:00
$toDelete = array ();
$newParent = null ;
2014-11-24 17:31:52 +03:00
$currentUser = $owner ? $owner : \OC_User :: getUser ();
2014-09-26 18:58:47 +04:00
foreach ( $items as $item ) {
// delete the item with the expected share_type and owner
if (( int ) $item [ 'share_type' ] === ( int ) $shareType && $item [ 'uid_owner' ] === $currentUser ) {
$toDelete = $item ;
// if there is more then one result we don't have to delete the children
// but update their parent. For group shares the new parent should always be
// the original group share and not the db entry with the unique name
2014-09-29 13:23:18 +04:00
} else if (( int ) $item [ 'share_type' ] === self :: $shareTypeGroupUserUnique ) {
2014-09-26 18:58:47 +04:00
$newParent = $item [ 'parent' ];
} else {
$newParent = $item [ 'id' ];
}
}
if ( ! empty ( $toDelete )) {
self :: unshareItem ( $toDelete , $newParent );
2014-02-18 15:37:32 +04:00
return true ;
}
return false ;
}
/**
* Unshare an item from all users , groups , and remove all links
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param string $itemSource
* @ return boolean true on success or false on failure
2014-02-18 15:37:32 +04:00
*/
public static function unshareAll ( $itemType , $itemSource ) {
// Get all of the owners of shares of this item.
$query = \OC_DB :: prepare ( 'SELECT `uid_owner` from `*PREFIX*share` WHERE `item_type`=? AND `item_source`=?' );
$result = $query -> execute ( array ( $itemType , $itemSource ));
$shares = array ();
// Add each owner's shares to the array of all shares for this item.
while ( $row = $result -> fetchRow ()) {
$shares = array_merge ( $shares , self :: getItems ( $itemType , $itemSource , null , null , $row [ 'uid_owner' ]));
}
if ( ! empty ( $shares )) {
// Pass all the vars we have for now, they may be useful
$hookParams = array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'shares' => $shares ,
);
\OC_Hook :: emit ( 'OCP\Share' , 'pre_unshareAll' , $hookParams );
foreach ( $shares as $share ) {
self :: unshareItem ( $share );
}
\OC_Hook :: emit ( 'OCP\Share' , 'post_unshareAll' , $hookParams );
return true ;
}
return false ;
}
/**
* Unshare an item shared with the current user
2014-04-15 19:46:11 +04:00
* @ param string $itemType
2014-07-26 04:00:49 +04:00
* @ param string $itemOrigin Item target or source
* @ param boolean $originIsSource true if $itemOrigin is the source , false if $itemOrigin is the target ( optional )
2014-04-15 19:46:11 +04:00
* @ return boolean true on success or false on failure
2014-02-18 15:37:32 +04:00
*
* Unsharing from self is not allowed for items inside collections
*/
2014-07-26 04:00:49 +04:00
public static function unshareFromSelf ( $itemType , $itemOrigin , $originIsSource = false ) {
$originType = ( $originIsSource ) ? 'source' : 'target' ;
2014-06-05 02:37:41 +04:00
$uid = \OCP\User :: getUser ();
2014-06-04 20:41:47 +04:00
if ( $itemType === 'file' || $itemType === 'folder' ) {
2014-07-26 04:00:49 +04:00
$statement = 'SELECT * FROM `*PREFIX*share` WHERE `item_type` = ? and `file_' . $originType . '` = ?' ;
2014-06-04 20:41:47 +04:00
} else {
2014-07-26 04:00:49 +04:00
$statement = 'SELECT * FROM `*PREFIX*share` WHERE `item_type` = ? and `item_' . $originType . '` = ?' ;
2014-06-04 20:41:47 +04:00
}
$query = \OCP\DB :: prepare ( $statement );
2014-07-26 04:00:49 +04:00
$result = $query -> execute ( array ( $itemType , $itemOrigin ));
2014-06-04 20:41:47 +04:00
$shares = $result -> fetchAll ();
2014-06-24 19:04:27 +04:00
$listOfUnsharedItems = array ();
2014-06-04 20:41:47 +04:00
$itemUnshared = false ;
foreach ( $shares as $share ) {
2014-06-04 21:45:10 +04:00
if (( int ) $share [ 'share_type' ] === \OCP\Share :: SHARE_TYPE_USER &&
2014-06-05 02:37:41 +04:00
$share [ 'share_with' ] === $uid ) {
2014-06-24 19:04:27 +04:00
$deletedShares = Helper :: delete ( $share [ 'id' ]);
$shareTmp = array (
'id' => $share [ 'id' ],
'shareWith' => $share [ 'share_with' ],
'itemTarget' => $share [ 'item_target' ],
'itemType' => $share [ 'item_type' ],
'shareType' => ( int ) $share [ 'share_type' ],
);
if ( isset ( $share [ 'file_target' ])) {
$shareTmp [ 'fileTarget' ] = $share [ 'file_target' ];
}
$listOfUnsharedItems = array_merge ( $listOfUnsharedItems , $deletedShares , array ( $shareTmp ));
2014-06-04 20:41:47 +04:00
$itemUnshared = true ;
break ;
} elseif (( int ) $share [ 'share_type' ] === \OCP\Share :: SHARE_TYPE_GROUP ) {
2014-06-05 02:37:41 +04:00
if ( \OC_Group :: inGroup ( $uid , $share [ 'share_with' ])) {
$groupShare = $share ;
}
} elseif (( int ) $share [ 'share_type' ] === self :: $shareTypeGroupUserUnique &&
$share [ 'share_with' ] === $uid ) {
2014-06-04 20:41:47 +04:00
$uniqueGroupShare = $share ;
}
}
2014-09-18 16:46:11 +04:00
if ( ! $itemUnshared && isset ( $groupShare ) && ! isset ( $uniqueGroupShare )) {
2014-06-04 20:41:47 +04:00
$query = \OC_DB :: prepare ( 'INSERT INTO `*PREFIX*share`'
2014-02-18 15:37:32 +04:00
. ' (`item_type`, `item_source`, `item_target`, `parent`, `share_type`,'
. ' `share_with`, `uid_owner`, `permissions`, `stime`, `file_source`, `file_target`)'
. ' VALUES (?,?,?,?,?,?,?,?,?,?,?)' );
2014-06-04 20:41:47 +04:00
$query -> execute ( array ( $groupShare [ 'item_type' ], $groupShare [ 'item_source' ], $groupShare [ 'item_target' ],
$groupShare [ 'id' ], self :: $shareTypeGroupUserUnique ,
\OC_User :: getUser (), $groupShare [ 'uid_owner' ], 0 , $groupShare [ 'stime' ], $groupShare [ 'file_source' ],
$groupShare [ 'file_target' ]));
2014-06-24 19:04:27 +04:00
$shareTmp = array (
'id' => $groupShare [ 'id' ],
'shareWith' => $groupShare [ 'share_with' ],
'itemTarget' => $groupShare [ 'item_target' ],
'itemType' => $groupShare [ 'item_type' ],
'shareType' => ( int ) $groupShare [ 'share_type' ],
);
if ( isset ( $groupShare [ 'file_target' ])) {
$shareTmp [ 'fileTarget' ] = $groupShare [ 'file_target' ];
}
$listOfUnsharedItems = array_merge ( $listOfUnsharedItems , array ( $groupShare ));
2014-06-04 20:41:47 +04:00
$itemUnshared = true ;
} elseif ( ! $itemUnshared && isset ( $uniqueGroupShare )) {
$query = \OC_DB :: prepare ( 'UPDATE `*PREFIX*share` SET `permissions` = ? WHERE `id` = ?' );
$query -> execute ( array ( 0 , $uniqueGroupShare [ 'id' ]));
2014-06-24 19:04:27 +04:00
$shareTmp = array (
'id' => $uniqueGroupShare [ 'id' ],
'shareWith' => $uniqueGroupShare [ 'share_with' ],
'itemTarget' => $uniqueGroupShare [ 'item_target' ],
'itemType' => $uniqueGroupShare [ 'item_type' ],
'shareType' => ( int ) $uniqueGroupShare [ 'share_type' ],
);
if ( isset ( $uniqueGroupShare [ 'file_target' ])) {
$shareTmp [ 'fileTarget' ] = $uniqueGroupShare [ 'file_target' ];
}
$listOfUnsharedItems = array_merge ( $listOfUnsharedItems , array ( $uniqueGroupShare ));
2014-06-04 20:41:47 +04:00
$itemUnshared = true ;
2014-02-18 15:37:32 +04:00
}
2014-06-04 20:41:47 +04:00
2014-06-24 19:04:27 +04:00
if ( $itemUnshared ) {
\OC_Hook :: emit ( 'OCP\Share' , 'post_unshareFromSelf' ,
array ( 'unsharedItems' => $listOfUnsharedItems , 'itemType' => $itemType ));
}
2014-06-04 20:41:47 +04:00
return $itemUnshared ;
2014-02-18 15:37:32 +04:00
}
2014-04-15 19:46:11 +04:00
2014-02-18 15:37:32 +04:00
/**
* sent status if users got informed by mail about share
* @ param string $itemType
* @ param string $itemSource
* @ param int $shareType SHARE_TYPE_USER , SHARE_TYPE_GROUP , or SHARE_TYPE_LINK
2014-08-13 19:02:51 +04:00
* @ param string $recipient with whom was the file shared
2014-05-07 22:46:08 +04:00
* @ param boolean $status
2014-02-18 15:37:32 +04:00
*/
2014-08-13 19:02:51 +04:00
public static function setSendMailStatus ( $itemType , $itemSource , $shareType , $recipient , $status ) {
2014-02-18 15:37:32 +04:00
$status = $status ? 1 : 0 ;
$query = \OC_DB :: prepare (
' UPDATE `*PREFIX*share`
SET `mail_send` = ?
2014-08-13 19:02:51 +04:00
WHERE `item_type` = ? AND `item_source` = ? AND `share_type` = ? AND `share_with` = ? ' );
2014-02-18 15:37:32 +04:00
2014-08-13 19:02:51 +04:00
$result = $query -> execute ( array ( $status , $itemType , $itemSource , $shareType , $recipient ));
2014-02-18 15:37:32 +04:00
if ( $result === false ) {
\OC_Log :: write ( 'OCP\Share' , 'Couldn\'t set send mail status' , \OC_Log :: ERROR );
}
}
/**
* Set the permissions of an item for a specific user or group
2014-04-15 19:46:11 +04:00
* @ param string $itemType
* @ param string $itemSource
* @ param int $shareType SHARE_TYPE_USER , SHARE_TYPE_GROUP , or SHARE_TYPE_LINK
* @ param string $shareWith User or group the item is being shared with
* @ param int $permissions CRUDS permissions
* @ return boolean true on success or false on failure
2014-02-18 15:37:32 +04:00
*/
public static function setPermissions ( $itemType , $itemSource , $shareType , $shareWith , $permissions ) {
2014-08-31 12:05:59 +04:00
$l = \OC :: $server -> getL10N ( 'lib' );
2014-02-18 15:37:32 +04:00
if ( $item = self :: getItems ( $itemType , $itemSource , $shareType , $shareWith ,
\OC_User :: getUser (), self :: FORMAT_NONE , null , 1 , false )) {
// Check if this item is a reshare and verify that the permissions
// granted don't exceed the parent shared item
if ( isset ( $item [ 'parent' ])) {
$query = \OC_DB :: prepare ( 'SELECT `permissions` FROM `*PREFIX*share` WHERE `id` = ?' , 1 );
$result = $query -> execute ( array ( $item [ 'parent' ])) -> fetchRow ();
if ( ~ ( int ) $result [ 'permissions' ] & $permissions ) {
2014-04-05 21:23:12 +04:00
$message = 'Setting permissions for %s failed,'
. ' because the permissions exceed permissions granted to %s' ;
$message_t = $l -> t ( 'Setting permissions for %s failed, because the permissions exceed permissions granted to %s' , array ( $itemSource , \OC_User :: getUser ()));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSource , \OC_User :: getUser ()), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
}
$query = \OC_DB :: prepare ( 'UPDATE `*PREFIX*share` SET `permissions` = ? WHERE `id` = ?' );
$query -> execute ( array ( $permissions , $item [ 'id' ]));
if ( $itemType === 'file' || $itemType === 'folder' ) {
\OC_Hook :: emit ( 'OCP\Share' , 'post_update_permissions' , array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'shareType' => $shareType ,
'shareWith' => $shareWith ,
'uidOwner' => \OC_User :: getUser (),
'permissions' => $permissions ,
'path' => $item [ 'path' ],
));
}
// Check if permissions were removed
if ( $item [ 'permissions' ] & ~ $permissions ) {
// If share permission is removed all reshares must be deleted
2014-11-25 18:28:41 +03:00
if (( $item [ 'permissions' ] & \OCP\Constants :: PERMISSION_SHARE ) && ( ~ $permissions & \OCP\Constants :: PERMISSION_SHARE )) {
2014-02-18 18:07:03 +04:00
Helper :: delete ( $item [ 'id' ], true );
2014-02-18 15:37:32 +04:00
} else {
$ids = array ();
$parents = array ( $item [ 'id' ]);
while ( ! empty ( $parents )) {
$parents = " ' " . implode ( " ',' " , $parents ) . " ' " ;
$query = \OC_DB :: prepare ( 'SELECT `id`, `permissions` FROM `*PREFIX*share`'
. ' WHERE `parent` IN (' . $parents . ')' );
$result = $query -> execute ();
// Reset parents array, only go through loop again if
// items are found that need permissions removed
$parents = array ();
while ( $item = $result -> fetchRow ()) {
// Check if permissions need to be removed
if ( $item [ 'permissions' ] & ~ $permissions ) {
// Add to list of items that need permissions removed
$ids [] = $item [ 'id' ];
$parents [] = $item [ 'id' ];
}
}
}
// Remove the permissions for all reshares of this item
if ( ! empty ( $ids )) {
$ids = " ' " . implode ( " ',' " , $ids ) . " ' " ;
// TODO this should be done with Doctrine platform objects
if ( \OC_Config :: getValue ( " dbtype " ) === 'oci' ) {
$andOp = 'BITAND(`permissions`, ?)' ;
} else {
$andOp = '`permissions` & ?' ;
}
$query = \OC_DB :: prepare ( 'UPDATE `*PREFIX*share` SET `permissions` = ' . $andOp
. ' WHERE `id` IN (' . $ids . ')' );
$query -> execute ( array ( $permissions ));
}
}
}
return true ;
}
2014-04-05 21:23:12 +04:00
$message = 'Setting permissions for %s failed, because the item was not found' ;
$message_t = $l -> t ( 'Setting permissions for %s failed, because the item was not found' , array ( $itemSource ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSource ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
2014-07-23 18:42:33 +04:00
/**
2014-08-02 06:02:39 +04:00
* validate expiration date if it meets all constraints
2014-07-23 18:42:33 +04:00
*
* @ param string $expireDate well formate date string , e . g . " DD-MM-YYYY "
* @ param string $shareTime timestamp when the file was shared
* @ param string $itemType
* @ param string $itemSource
* @ return DateTime validated date
* @ throws \Exception
*/
private static function validateExpireDate ( $expireDate , $shareTime , $itemType , $itemSource ) {
2014-08-31 12:05:59 +04:00
$l = \OC :: $server -> getL10N ( 'lib' );
2014-07-23 18:42:33 +04:00
$date = new \DateTime ( $expireDate );
$today = new \DateTime ( 'now' );
// if the user doesn't provide a share time we need to get it from the database
// fall-back mode to keep API stable, because the $shareTime parameter was added later
$defaultExpireDateEnforced = \OCP\Util :: isDefaultExpireDateEnforced ();
if ( $defaultExpireDateEnforced && $shareTime === null ) {
$items = self :: getItemShared ( $itemType , $itemSource );
$firstItem = reset ( $items );
$shareTime = ( int ) $firstItem [ 'stime' ];
}
if ( $defaultExpireDateEnforced ) {
// initialize max date with share time
$maxDate = new \DateTime ();
$maxDate -> setTimestamp ( $shareTime );
$maxDays = \OCP\Config :: getAppValue ( 'core' , 'shareapi_expire_after_n_days' , '7' );
$maxDate -> add ( new \DateInterval ( 'P' . $maxDays . 'D' ));
if ( $date > $maxDate ) {
2014-08-06 22:48:26 +04:00
$warning = 'Cannot set expiration date. Shares cannot expire later than ' . $maxDays . ' after they have been shared' ;
$warning_t = $l -> t ( 'Cannot set expiration date. Shares cannot expire later than %s after they have been shared' , array ( $maxDays ));
2014-07-23 18:42:33 +04:00
\OCP\Util :: writeLog ( 'OCP\Share' , $warning , \OCP\Util :: WARN );
throw new \Exception ( $warning_t );
}
}
if ( $date < $today ) {
2014-08-02 06:02:39 +04:00
$message = 'Cannot set expiration date. Expiration date is in the past' ;
$message_t = $l -> t ( 'Cannot set expiration date. Expiration date is in the past' );
2014-07-23 18:42:33 +04:00
\OCP\Util :: writeLog ( 'OCP\Share' , $message , \OCP\Util :: WARN );
throw new \Exception ( $message_t );
}
return $date ;
}
2014-02-18 15:37:32 +04:00
/**
* Set expiration date for a share
* @ param string $itemType
* @ param string $itemSource
* @ param string $date expiration date
2014-07-23 18:42:33 +04:00
* @ param int $shareTime timestamp from when the file was shared
* @ throws \Exception
2014-04-15 19:46:11 +04:00
* @ return boolean
2014-02-18 15:37:32 +04:00
*/
2014-07-23 18:42:33 +04:00
public static function setExpirationDate ( $itemType , $itemSource , $date , $shareTime = null ) {
2014-03-28 18:00:13 +04:00
$user = \OC_User :: getUser ();
2014-06-03 17:15:04 +04:00
if ( $date == '' ) {
$date = null ;
} else {
2014-07-23 18:42:33 +04:00
$date = self :: validateExpireDate ( $date , $shareTime , $itemType , $itemSource );
2014-02-18 15:37:32 +04:00
}
2014-06-03 17:15:04 +04:00
$query = \OC_DB :: prepare ( 'UPDATE `*PREFIX*share` SET `expiration` = ? WHERE `item_type` = ? AND `item_source` = ? AND `uid_owner` = ? AND `share_type` = ?' );
$query -> bindValue ( 1 , $date , 'datetime' );
$query -> bindValue ( 2 , $itemType );
$query -> bindValue ( 3 , $itemSource );
$query -> bindValue ( 4 , $user );
$query -> bindValue ( 5 , \OCP\Share :: SHARE_TYPE_LINK );
2014-07-09 16:40:05 +04:00
$query -> execute ();
\OC_Hook :: emit ( 'OCP\Share' , 'post_set_expiration_date' , array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'date' => $date ,
'uidOwner' => $user
));
2014-07-23 18:42:33 +04:00
2014-07-09 16:40:05 +04:00
return true ;
2014-07-23 18:42:33 +04:00
}
2014-07-09 16:40:05 +04:00
2014-02-18 15:37:32 +04:00
/**
* Checks whether a share has expired , calls unshareItem () if yes .
* @ param array $item Share data ( usually database row )
2014-05-07 22:46:08 +04:00
* @ return boolean True if item was expired , false otherwise .
2014-02-18 15:37:32 +04:00
*/
protected static function expireItem ( array $item ) {
2014-04-23 14:50:24 +04:00
2014-06-03 17:15:04 +04:00
$result = false ;
2014-05-12 18:15:13 +04:00
2014-08-02 06:02:39 +04:00
// only use default expiration date for link shares
2014-06-03 17:15:04 +04:00
if (( int ) $item [ 'share_type' ] === self :: SHARE_TYPE_LINK ) {
2014-08-02 06:02:39 +04:00
// calculate expiration date
2014-06-03 17:15:04 +04:00
if ( ! empty ( $item [ 'expiration' ])) {
$userDefinedExpire = new \DateTime ( $item [ 'expiration' ]);
$expires = $userDefinedExpire -> getTimestamp ();
} else {
$expires = null ;
}
2014-08-02 06:02:39 +04:00
// get default expiration settings
2014-05-12 18:15:13 +04:00
$defaultSettings = Helper :: getDefaultExpireSetting ();
$expires = Helper :: calculateExpireDate ( $defaultSettings , $item [ 'stime' ], $expires );
2014-04-23 14:50:24 +04:00
2014-06-03 17:15:04 +04:00
if ( is_int ( $expires )) {
$now = time ();
if ( $now > $expires ) {
self :: unshareItem ( $item );
$result = true ;
}
2014-02-18 15:37:32 +04:00
}
}
2014-06-03 17:15:04 +04:00
return $result ;
2014-02-18 15:37:32 +04:00
}
/**
* Unshares a share given a share data array
* @ param array $item Share data ( usually database row )
2014-09-26 18:58:47 +04:00
* @ param int new parent ID
2014-02-18 15:37:32 +04:00
* @ return null
*/
2014-09-26 18:58:47 +04:00
protected static function unshareItem ( array $item , $newParent = null ) {
2014-02-18 15:37:32 +04:00
// Pass all the vars we have for now, they may be useful
$hookParams = array (
2014-06-24 19:04:27 +04:00
'id' => $item [ 'id' ],
2014-02-18 15:37:32 +04:00
'itemType' => $item [ 'item_type' ],
'itemSource' => $item [ 'item_source' ],
2014-06-24 19:04:27 +04:00
'shareType' => ( int ) $item [ 'share_type' ],
2014-02-18 15:37:32 +04:00
'shareWith' => $item [ 'share_with' ],
'itemParent' => $item [ 'parent' ],
'uidOwner' => $item [ 'uid_owner' ],
);
2014-06-24 19:04:27 +04:00
if ( $item [ 'item_type' ] === 'file' || $item [ 'item_type' ] === 'folder' ) {
$hookParams [ 'fileSource' ] = $item [ 'file_source' ];
$hookParams [ 'fileTarget' ] = $item [ 'file_target' ];
}
2014-02-18 15:37:32 +04:00
2014-06-24 19:04:27 +04:00
\OC_Hook :: emit ( 'OCP\Share' , 'pre_unshare' , $hookParams );
2014-09-26 18:58:47 +04:00
$deletedShares = Helper :: delete ( $item [ 'id' ], false , null , $newParent );
2014-06-24 19:04:27 +04:00
$deletedShares [] = $hookParams ;
$hookParams [ 'deletedShares' ] = $deletedShares ;
2014-02-18 15:37:32 +04:00
\OC_Hook :: emit ( 'OCP\Share' , 'post_unshare' , $hookParams );
}
/**
* Get the backend class for the specified item type
* @ param string $itemType
2014-05-13 14:27:35 +04:00
* @ throws \Exception
2014-02-18 15:37:32 +04:00
* @ return \OCP\Share_Backend
*/
public static function getBackend ( $itemType ) {
2014-08-31 12:05:59 +04:00
$l = \OC :: $server -> getL10N ( 'lib' );
2014-02-18 15:37:32 +04:00
if ( isset ( self :: $backends [ $itemType ])) {
return self :: $backends [ $itemType ];
} else if ( isset ( self :: $backendTypes [ $itemType ][ 'class' ])) {
$class = self :: $backendTypes [ $itemType ][ 'class' ];
if ( class_exists ( $class )) {
self :: $backends [ $itemType ] = new $class ;
if ( ! ( self :: $backends [ $itemType ] instanceof \OCP\Share_Backend )) {
2014-04-05 21:23:12 +04:00
$message = 'Sharing backend %s must implement the interface OCP\Share_Backend' ;
$message_t = $l -> t ( 'Sharing backend %s must implement the interface OCP\Share_Backend' , array ( $class ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $class ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
return self :: $backends [ $itemType ];
} else {
2014-04-05 21:23:12 +04:00
$message = 'Sharing backend %s not found' ;
$message_t = $l -> t ( 'Sharing backend %s not found' , array ( $class ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $class ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
}
2014-04-05 21:23:12 +04:00
$message = 'Sharing backend for %s not found' ;
$message_t = $l -> t ( 'Sharing backend for %s not found' , array ( $itemType ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemType ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
/**
* Check if resharing is allowed
2014-04-15 19:46:11 +04:00
* @ return boolean true if allowed or false
2014-02-18 15:37:32 +04:00
*
* Resharing is allowed by default if not configured
*/
2014-08-05 12:57:13 +04:00
public static function isResharingAllowed () {
2014-02-18 15:37:32 +04:00
if ( ! isset ( self :: $isResharingAllowed )) {
if ( \OC_Appconfig :: getValue ( 'core' , 'shareapi_allow_resharing' , 'yes' ) == 'yes' ) {
self :: $isResharingAllowed = true ;
} else {
self :: $isResharingAllowed = false ;
}
}
return self :: $isResharingAllowed ;
}
/**
* Get a list of collection item types for the specified item type
2014-04-15 19:46:11 +04:00
* @ param string $itemType
2014-02-18 15:37:32 +04:00
* @ return array
*/
private static function getCollectionItemTypes ( $itemType ) {
$collectionTypes = array ( $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...
2014-09-16 02:20:52 +04:00
if ( isset ( self :: $backendTypes [ $itemType ]) && ( ! self :: getBackend ( $itemType ) instanceof \OCP\Share_Backend_Collection || $itemType != 'folder' )) {
2014-02-18 15:37:32 +04:00
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 ;
}
2014-09-16 02:20:52 +04:00
/**
* Get the owners of items shared with a user .
*
* @ param string $user The user the items are shared with .
* @ param string $type The type of the items shared with the user .
* @ param boolean $includeCollections Include collection item types ( optional )
* @ param boolean $includeOwner include owner in the list of users the item is shared with ( optional )
* @ return array
*/
public static function getSharedItemsOwners ( $user , $type , $includeCollections = false , $includeOwner = false ) {
// First, we find out if $type is part of a collection (and if that collection is part of
// another one and so on).
$collectionTypes = array ();
if ( ! $includeCollections || ! $collectionTypes = self :: getCollectionItemTypes ( $type )) {
$collectionTypes [] = $type ;
}
// Of these collection types, along with our original $type, we make a
// list of the ones for which a sharing backend has been registered.
// FIXME: Ideally, we wouldn't need to nest getItemsSharedWith in this loop but just call it
// with its $includeCollections parameter set to true. Unfortunately, this fails currently.
$allMaybeSharedItems = array ();
foreach ( $collectionTypes as $collectionType ) {
if ( isset ( self :: $backends [ $collectionType ])) {
$allMaybeSharedItems [ $collectionType ] = self :: getItemsSharedWithUser (
$collectionType ,
$user ,
self :: FORMAT_NONE
);
}
}
$owners = array ();
if ( $includeOwner ) {
$owners [] = $user ;
}
// We take a look at all shared items of the given $type (or of the collections it is part of)
// and find out their owners. Then, we gather the tags for the original $type from all owners,
// and return them as elements of a list that look like "Tag (owner)".
foreach ( $allMaybeSharedItems as $collectionType => $maybeSharedItems ) {
foreach ( $maybeSharedItems as $sharedItem ) {
if ( isset ( $sharedItem [ 'id' ])) { //workaround for https://github.com/owncloud/core/issues/2814
$owners [] = $sharedItem [ 'uid_owner' ];
}
}
}
return $owners ;
}
2014-02-18 15:37:32 +04:00
/**
* Get shared items from the database
2014-04-15 19:46:11 +04:00
* @ param string $itemType
2014-05-12 00:51:30 +04:00
* @ param string $item Item source or target ( optional )
2014-04-15 19:46:11 +04:00
* @ 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
2014-05-12 00:51:30 +04:00
* @ param string $uidOwner User that is the owner of shared items ( optional )
2014-05-01 20:11:30 +04:00
* @ param int $format Format to convert items to with formatItems () ( optional )
* @ param mixed $parameters to pass to formatItems () ( optional )
2014-05-06 20:05:06 +04:00
* @ param int $limit Number of items to return , - 1 to return all matches ( optional )
2014-05-07 22:46:08 +04:00
* @ param boolean $includeCollections Include collection item types ( optional )
* @ param boolean $itemShareWithBySource ( optional )
* @ param boolean $checkExpireDate
2014-03-06 17:00:12 +04:00
* @ return array
2014-02-18 15:37:32 +04:00
*
* See public functions getItem ( s ) ... for parameter usage
*
*/
2014-02-18 18:07:03 +04:00
public static function getItems ( $itemType , $item = null , $shareType = null , $shareWith = null ,
2014-02-18 15:37:32 +04:00
$uidOwner = null , $format = self :: FORMAT_NONE , $parameters = null , $limit = - 1 ,
$includeCollections = false , $itemShareWithBySource = false , $checkExpireDate = true ) {
if ( ! self :: isEnabled ()) {
2014-03-06 17:00:12 +04:00
return array ();
2014-02-18 15:37:32 +04:00
}
$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 ( $itemType == 'file' || $itemType == 'folder' ) {
if ( ! is_null ( $uidOwner )) {
$root = \OC\Files\Filesystem :: getRoot ();
} else {
$root = '' ;
}
$where = 'INNER JOIN `*PREFIX*filecache` ON `file_source` = `*PREFIX*filecache`.`fileid`' ;
if ( ! isset ( $item )) {
$where .= ' WHERE `file_target` IS NOT NULL' ;
}
$fileDependent = true ;
$queryArgs = array ();
} else {
$fileDependent = false ;
$root = '' ;
2014-03-03 20:27:26 +04:00
$collectionTypes = self :: getCollectionItemTypes ( $itemType );
if ( $includeCollections && ! isset ( $item ) && $collectionTypes ) {
2014-02-18 15:37:32 +04:00
// 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 ( array ( $itemType ), $collectionTypes );
} else {
$itemTypes = $collectionTypes ;
}
$placeholders = join ( ',' , array_fill ( 0 , count ( $itemTypes ), '?' ));
$where = ' WHERE `item_type` IN (' . $placeholders . '))' ;
$queryArgs = $itemTypes ;
} else {
$where = ' WHERE `item_type` = ?' ;
$queryArgs = array ( $itemType );
}
}
if ( \OC_Appconfig :: getValue ( 'core' , 'shareapi_allow_links' , 'yes' ) !== 'yes' ) {
$where .= ' AND `share_type` != ?' ;
$queryArgs [] = self :: SHARE_TYPE_LINK ;
}
if ( isset ( $shareType )) {
// Include all user and group items
if ( $shareType == self :: $shareTypeUserAndGroups && isset ( $shareWith )) {
2014-11-17 15:09:13 +03:00
$where .= ' AND ((`share_type` in (?, ?) AND `share_with` = ?) ' ;
2014-02-18 15:37:32 +04:00
$queryArgs [] = self :: SHARE_TYPE_USER ;
$queryArgs [] = self :: $shareTypeGroupUserUnique ;
2014-11-17 15:09:13 +03:00
$queryArgs [] = $shareWith ;
$groups = \OC_Group :: getUserGroups ( $shareWith );
if ( ! empty ( $groups )) {
$placeholders = join ( ',' , array_fill ( 0 , count ( $groups ), '?' ));
$where .= ' OR (`share_type` = ? AND `share_with` IN (' . $placeholders . ')) ' ;
$queryArgs [] = self :: SHARE_TYPE_GROUP ;
$queryArgs = array_merge ( $queryArgs , $groups );
}
$where .= ')' ;
2014-02-18 15:37:32 +04:00
// Don't include own group shares
$where .= ' AND `uid_owner` != ?' ;
$queryArgs [] = $shareWith ;
} else {
$where .= ' AND `share_type` = ?' ;
$queryArgs [] = $shareType ;
if ( isset ( $shareWith )) {
$where .= ' AND `share_with` = ?' ;
$queryArgs [] = $shareWith ;
}
}
}
if ( isset ( $uidOwner )) {
$where .= ' AND `uid_owner` = ?' ;
$queryArgs [] = $uidOwner ;
if ( ! isset ( $shareType )) {
// Prevent unique user targets for group shares from being selected
$where .= ' AND `share_type` != ?' ;
$queryArgs [] = self :: $shareTypeGroupUserUnique ;
}
2014-03-03 20:24:31 +04:00
if ( $fileDependent ) {
2014-02-18 15:37:32 +04:00
$column = 'file_source' ;
} else {
$column = 'item_source' ;
}
} else {
2014-03-03 20:24:31 +04:00
if ( $fileDependent ) {
2014-02-18 15:37:32 +04:00
$column = 'file_target' ;
} else {
$column = 'item_target' ;
}
}
if ( isset ( $item )) {
2014-03-03 20:27:26 +04:00
$collectionTypes = self :: getCollectionItemTypes ( $itemType );
2014-10-01 17:13:10 +04:00
if ( $includeCollections && $collectionTypes && ! in_array ( 'folder' , $collectionTypes )) {
2014-02-18 15:37:32 +04:00
$where .= ' AND (' ;
} else {
$where .= ' AND' ;
}
// If looking for own shared items, check item_source else check item_target
if ( isset ( $uidOwner ) || $itemShareWithBySource ) {
// If item type is a file, file source needs to be checked in case the item was converted
2014-03-03 20:24:31 +04:00
if ( $fileDependent ) {
2014-02-18 15:37:32 +04:00
$where .= ' `file_source` = ?' ;
$column = 'file_source' ;
} else {
$where .= ' `item_source` = ?' ;
$column = 'item_source' ;
}
} else {
2014-03-03 20:24:31 +04:00
if ( $fileDependent ) {
2014-02-18 15:37:32 +04:00
$where .= ' `file_target` = ?' ;
$item = \OC\Files\Filesystem :: normalizePath ( $item );
} else {
$where .= ' `item_target` = ?' ;
}
}
$queryArgs [] = $item ;
2014-10-01 17:13:10 +04:00
if ( $includeCollections && $collectionTypes && ! in_array ( 'folder' , $collectionTypes )) {
2014-02-18 15:37:32 +04:00
$placeholders = join ( ',' , array_fill ( 0 , count ( $collectionTypes ), '?' ));
$where .= ' OR `item_type` IN (' . $placeholders . '))' ;
$queryArgs = array_merge ( $queryArgs , $collectionTypes );
}
}
2014-08-22 17:59:44 +04:00
2014-09-26 15:01:54 +04:00
if ( $shareType == self :: $shareTypeUserAndGroups && $limit === 1 ) {
2014-08-22 17:59:44 +04:00
// Make sure the unique user target is returned if it exists,
// unique targets should follow the group share in the database
// If the limit is not 1, the filtering can be done later
$where .= ' ORDER BY `*PREFIX*share`.`id` DESC' ;
} else {
$where .= ' ORDER BY `*PREFIX*share`.`id` ASC' ;
}
2014-02-18 15:37:32 +04:00
if ( $limit != - 1 && ! $includeCollections ) {
// The limit must be at least 3, because filtering needs to be done
if ( $limit < 3 ) {
$queryLimit = 3 ;
} else {
$queryLimit = $limit ;
}
} else {
$queryLimit = null ;
}
2014-03-03 20:06:45 +04:00
$select = self :: createSelectStatement ( $format , $fileDependent , $uidOwner );
2014-02-18 15:37:32 +04:00
$root = strlen ( $root );
$query = \OC_DB :: prepare ( 'SELECT ' . $select . ' FROM `*PREFIX*share` ' . $where , $queryLimit );
$result = $query -> execute ( $queryArgs );
if ( \OC_DB :: isError ( $result )) {
\OC_Log :: write ( 'OCP\Share' ,
2014-07-31 13:55:59 +04:00
\OC_DB :: getErrorMessage ( $result ) . ', select=' . $select . ' where=' ,
2014-02-18 15:37:32 +04:00
\OC_Log :: ERROR );
}
$items = array ();
$targets = array ();
$switchedItems = array ();
$mounts = array ();
while ( $row = $result -> fetchRow ()) {
2014-03-03 20:20:09 +04:00
self :: transformDBResults ( $row );
2014-02-18 15:37:32 +04:00
// Filter out duplicate group shares for users with unique targets
if ( $row [ 'share_type' ] == self :: $shareTypeGroupUserUnique && isset ( $items [ $row [ 'parent' ]])) {
$row [ 'share_type' ] = self :: SHARE_TYPE_GROUP ;
2014-04-14 14:04:12 +04:00
$row [ 'unique_name' ] = true ; // remember that we use a unique name for this user
2014-02-18 15:37:32 +04:00
$row [ 'share_with' ] = $items [ $row [ 'parent' ]][ 'share_with' ];
2014-09-26 15:01:54 +04:00
// 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' ];
}
2014-02-18 15:37:32 +04:00
// Remove the parent group share
unset ( $items [ $row [ 'parent' ]]);
if ( $row [ 'permissions' ] == 0 ) {
continue ;
}
} else if ( ! isset ( $uidOwner )) {
// Check if the same target already exists
2014-08-22 17:59:44 +04:00
if ( isset ( $targets [ $row [ 'id' ]])) {
2014-02-18 15:37:32 +04:00
// Check if the same owner shared with the user twice
// through a group and user share - this is allowed
2014-08-22 17:59:44 +04:00
$id = $targets [ $row [ 'id' ]];
2014-02-18 15:37:32 +04:00
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' ] != self :: SHARE_TYPE_GROUP ) {
$items [ $id ][ 'share_type' ] = self :: SHARE_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
2014-11-25 18:28:41 +03:00
if ( ~ ( int ) $items [ $id ][ 'permissions' ] & \OCP\Constants :: PERMISSION_SHARE
&& ( int ) $row [ 'permissions' ] & \OCP\Constants :: PERMISSION_SHARE ) {
2014-02-18 15:37:32 +04:00
$items [ $row [ 'id' ]] = $items [ $id ];
$switchedItems [ $id ] = $row [ 'id' ];
unset ( $items [ $id ]);
$id = $row [ 'id' ];
}
$items [ $id ][ 'permissions' ] |= ( int ) $row [ 'permissions' ];
2014-08-22 17:59:44 +04:00
2014-02-18 15:37:32 +04:00
}
2014-08-22 17:59:44 +04:00
continue ;
} elseif ( ! empty ( $row [ 'parent' ])) {
$targets [ $row [ 'parent' ]] = $row [ 'id' ];
2014-02-18 15:37:32 +04:00
}
}
// Remove root from file source paths if retrieving own shared items
if ( isset ( $uidOwner ) && isset ( $row [ 'path' ])) {
if ( isset ( $row [ 'parent' ])) {
$query = \OC_DB :: prepare ( 'SELECT `file_target` FROM `*PREFIX*share` WHERE `id` = ?' );
$parentResult = $query -> execute ( array ( $row [ 'parent' ]));
if ( \OC_DB :: isError ( $result )) {
\OC_Log :: write ( 'OCP\Share' , 'Can\'t select parent: ' .
\OC_DB :: getErrorMessage ( $result ) . ', select=' . $select . ' where=' . $where ,
\OC_Log :: ERROR );
} else {
$parentRow = $parentResult -> fetchRow ();
2014-04-08 21:57:07 +04:00
$tmpPath = $parentRow [ 'file_target' ];
2014-03-11 15:58:46 +04:00
// 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 );
2014-02-18 15:37:32 +04:00
foreach ( array_slice ( $splitPath , 2 ) as $pathPart ) {
$tmpPath = $tmpPath . '/' . $pathPart ;
}
2014-03-11 15:58:46 +04:00
$row [ 'path' ] = $tmpPath ;
2014-02-18 15:37:32 +04:00
}
} else {
if ( ! isset ( $mounts [ $row [ 'storage' ]])) {
$mountPoints = \OC\Files\Filesystem :: getMountByNumericId ( $row [ 'storage' ]);
2014-04-21 14:35:52 +04:00
if ( is_array ( $mountPoints ) && ! empty ( $mountPoints )) {
2014-02-18 15:37:32 +04:00
$mounts [ $row [ 'storage' ]] = current ( $mountPoints );
}
}
2014-10-01 17:13:10 +04:00
if ( ! empty ( $mounts [ $row [ 'storage' ]])) {
2014-02-18 15:37:32 +04:00
$path = $mounts [ $row [ 'storage' ]] -> getMountPoint () . $row [ 'path' ];
2014-08-05 22:34:32 +04:00
$relPath = substr ( $path , $root ); // path relative to data/user
$row [ 'path' ] = rtrim ( $relPath , '/' );
2014-02-18 15:37:32 +04:00
}
}
}
2014-09-25 14:35:11 +04:00
2014-02-18 15:37:32 +04:00
if ( $checkExpireDate ) {
if ( self :: expireItem ( $row )) {
continue ;
}
}
// Check if resharing is allowed, if not remove share permission
2014-07-29 00:35:11 +04:00
if ( isset ( $row [ 'permissions' ]) && ( ! self :: isResharingAllowed () | \OC_Util :: isSharingDisabledForUser ())) {
2014-11-25 18:28:41 +03:00
$row [ 'permissions' ] &= ~ \OCP\Constants :: PERMISSION_SHARE ;
2014-02-18 15:37:32 +04:00
}
// Add display names to result
2014-11-18 13:41:45 +03:00
if ( isset ( $row [ 'share_with' ]) && $row [ 'share_with' ] != '' &&
isset ( $row [ 'share_with' ]) && $row [ 'share_type' ] === self :: SHARE_TYPE_USER ) {
2014-02-18 15:37:32 +04:00
$row [ 'share_with_displayname' ] = \OCP\User :: getDisplayName ( $row [ 'share_with' ]);
2014-11-18 13:41:45 +03:00
} else {
$row [ 'share_with_displayname' ] = $row [ 'share_with' ];
2014-02-18 15:37:32 +04:00
}
if ( isset ( $row [ 'uid_owner' ]) && $row [ 'uid_owner' ] != '' ) {
$row [ 'displayname_owner' ] = \OCP\User :: getDisplayName ( $row [ 'uid_owner' ]);
}
2014-08-22 17:59:44 +04:00
if ( $row [ 'permissions' ] > 0 ) {
$items [ $row [ 'id' ]] = $row ;
}
2014-07-31 13:55:59 +04:00
}
2014-08-22 17:59:44 +04:00
// group items if we are looking for items shared with the current user
2014-07-31 13:55:59 +04:00
if ( isset ( $shareWith ) && $shareWith === \OCP\User :: getUser ()) {
$items = self :: groupItems ( $items , $itemType );
2014-02-18 15:37:32 +04:00
}
2014-07-31 13:55:59 +04:00
2014-02-18 15:37:32 +04:00
if ( ! empty ( $items )) {
$collectionItems = array ();
foreach ( $items as & $row ) {
// Return only the item instead of a 2-dimensional array
if ( $limit == 1 && $row [ $column ] == $item && ( $row [ 'item_type' ] == $itemType || $itemType == 'file' )) {
if ( $format == self :: FORMAT_NONE ) {
return $row ;
} else {
break ;
}
}
// Check if this is a collection of the requested item type
2014-10-01 17:13:10 +04:00
if ( $includeCollections && $collectionTypes && $row [ 'item_type' ] !== 'folder' && in_array ( $row [ 'item_type' ], $collectionTypes )) {
2014-02-18 15:37:32 +04:00
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 = array ();
$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 of 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' ];
2014-03-06 18:30:01 +04:00
} else { // TODO is this really needed if we already know that we use the file backend?
2014-02-18 15:37:32 +04:00
$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 ) {
// Return only the item instead of a 2-dimensional array
if ( $limit == 1 ) {
if ( $format == self :: FORMAT_NONE ) {
return $childItem ;
} else {
// Unset the items array and break out of both loops
$items = array ();
$items [] = $childItem ;
break 2 ;
}
} else {
$collectionItems [] = $childItem ;
}
}
} else {
$collectionItems [] = $childItem ;
}
}
}
}
// Remove collection item
$toRemove = $row [ 'id' ];
if ( array_key_exists ( $toRemove , $switchedItems )) {
$toRemove = $switchedItems [ $toRemove ];
}
unset ( $items [ $toRemove ]);
2014-10-01 17:13:10 +04:00
} 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 ;
}
2014-02-18 15:37:32 +04:00
}
}
if ( ! empty ( $collectionItems )) {
$items = array_merge ( $items , $collectionItems );
}
2014-03-06 17:00:12 +04:00
2014-03-03 20:30:16 +04:00
return self :: formatResult ( $items , $column , $backend , $format , $parameters );
2014-10-01 17:13:10 +04:00
} 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 = array ();
$collectionBackend = self :: getBackend ( 'folder' );
2014-11-10 15:08:45 +03:00
$sharedParents = $collectionBackend -> getParents ( $item , $shareWith , $uidOwner );
2014-10-01 17:13:10 +04:00
foreach ( $sharedParents as $parent ) {
$collectionItems [] = $parent ;
}
if ( $limit === 1 ) {
return reset ( $collectionItems );
}
return self :: formatResult ( $collectionItems , $column , $backend , $format , $parameters );
2014-02-18 15:37:32 +04:00
}
2014-03-06 17:00:12 +04:00
2014-02-18 15:37:32 +04:00
return array ();
}
/**
2014-07-31 13:55:59 +04:00
* group items with link to the same source
*
* @ param array $items
* @ param string $itemType
* @ return array of grouped items
*/
2014-08-01 18:24:19 +04:00
protected static function groupItems ( $items , $itemType ) {
2014-07-31 13:55:59 +04:00
$fileSharing = ( $itemType === 'file' || $itemType === 'folder' ) ? true : false ;
$result = array ();
foreach ( $items as $item ) {
$grouped = false ;
foreach ( $result as $key => $r ) {
// for file/folder shares we need to compare file_source, otherwise we compare item_source
// only group shares if they already point to the same target, otherwise the file where shared
// before grouping of shares was added. In this case we don't group them toi avoid confusions
if (( $fileSharing && $item [ 'file_source' ] === $r [ 'file_source' ] && $item [ 'file_target' ] === $r [ 'file_target' ]) ||
( ! $fileSharing && $item [ 'item_source' ] === $r [ 'item_source' ] && $item [ 'item_target' ] === $r [ 'item_target' ])) {
// add the first item to the list of grouped shares
if ( ! isset ( $result [ $key ][ 'grouped' ])) {
$result [ $key ][ 'grouped' ][] = $result [ $key ];
}
$result [ $key ][ 'permissions' ] = ( int ) $item [ 'permissions' ] | ( int ) $r [ 'permissions' ];
$result [ $key ][ 'grouped' ][] = $item ;
$grouped = true ;
break ;
}
}
if ( ! $grouped ) {
$result [] = $item ;
}
}
return $result ;
}
/**
2014-02-18 15:37:32 +04:00
* Put shared item into the database
2014-04-15 19:46:11 +04:00
* @ param string $itemType Item type
* @ param string $itemSource Item source
* @ param int $shareType SHARE_TYPE_USER , SHARE_TYPE_GROUP , or SHARE_TYPE_LINK
* @ param string $shareWith User or group the item is being shared with
* @ param string $uidOwner User that is the owner of shared item
* @ param int $permissions CRUDS permissions
2014-05-07 22:46:08 +04:00
* @ param boolean | array $parentFolder Parent folder target ( optional )
2014-04-15 19:46:11 +04:00
* @ param string $token ( optional )
* @ param string $itemSourceName name of the source item ( optional )
2014-05-07 13:23:50 +04:00
* @ param \DateTime $expirationDate ( optional )
2014-05-13 14:27:35 +04:00
* @ throws \Exception
2014-05-07 22:46:08 +04:00
* @ return boolean Returns true on success or false on failure
2014-02-18 15:37:32 +04:00
*/
private static function put ( $itemType , $itemSource , $shareType , $shareWith , $uidOwner ,
2014-05-07 13:23:50 +04:00
$permissions , $parentFolder = null , $token = null , $itemSourceName = null , \DateTime $expirationDate = null ) {
2014-04-05 21:23:12 +04:00
2014-07-31 13:55:59 +04:00
$queriesToExecute = array ();
2014-09-29 13:23:18 +04:00
$suggestedItemTarget = null ;
2014-04-05 21:23:12 +04:00
2014-07-31 13:55:59 +04:00
$result = self :: checkReshare ( $itemType , $itemSource , $shareType , $shareWith , $uidOwner , $permissions , $itemSourceName , $expirationDate );
if ( ! empty ( $result )) {
$parent = $result [ 'parent' ];
$itemSource = $result [ 'itemSource' ];
$fileSource = $result [ 'fileSource' ];
$suggestedItemTarget = $result [ 'suggestedItemTarget' ];
$suggestedFileTarget = $result [ 'suggestedFileTarget' ];
$filePath = $result [ 'filePath' ];
$expirationDate = $result [ 'expirationDate' ];
2014-02-18 15:37:32 +04:00
}
2014-05-07 13:23:50 +04:00
2014-07-31 13:55:59 +04:00
$isGroupShare = false ;
2014-02-18 15:37:32 +04:00
if ( $shareType == self :: SHARE_TYPE_GROUP ) {
2014-07-31 13:55:59 +04:00
$isGroupShare = true ;
$users = \OC_Group :: usersInGroup ( $shareWith [ 'group' ]);
// remove current user from list
if ( in_array ( \OCP\User :: getUser (), $users )) {
unset ( $users [ array_search ( \OCP\User :: getUser (), $users )]);
2014-02-18 15:37:32 +04:00
}
2014-07-31 13:55:59 +04:00
$groupItemTarget = Helper :: generateTarget ( $itemType , $itemSource , $shareType , $shareWith [ 'group' ],
$uidOwner , $suggestedItemTarget );
$groupFileTarget = $filePath ;
2014-02-18 15:37:32 +04:00
2014-07-31 13:55:59 +04:00
// add group share to table and remember the id as parent
2014-05-07 13:23:50 +04:00
$queriesToExecute [ 'groupShare' ] = array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'itemTarget' => $groupItemTarget ,
'shareType' => $shareType ,
'shareWith' => $shareWith [ 'group' ],
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'shareTime' => time (),
'fileSource' => $fileSource ,
2014-07-31 13:55:59 +04:00
'fileTarget' => $filePath ,
2014-05-07 13:23:50 +04:00
'token' => $token ,
'parent' => $parent ,
'expiration' => $expirationDate ,
);
2014-07-31 13:55:59 +04:00
} else {
$users = array ( $shareWith );
$itemTarget = Helper :: generateTarget ( $itemType , $itemSource , $shareType , $shareWith , $uidOwner ,
$suggestedItemTarget );
}
$run = true ;
$error = '' ;
$preHookData = array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'shareType' => $shareType ,
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'fileSource' => $fileSource ,
'expiration' => $expirationDate ,
'token' => $token ,
'run' => & $run ,
'error' => & $error
);
$preHookData [ 'itemTarget' ] = ( $isGroupShare ) ? $groupItemTarget : $itemTarget ;
$preHookData [ 'shareWith' ] = ( $isGroupShare ) ? $shareWith [ 'group' ] : $shareWith ;
\OC_Hook :: emit ( 'OCP\Share' , 'pre_shared' , $preHookData );
if ( $run === false ) {
throw new \Exception ( $error );
}
foreach ( $users as $user ) {
2014-08-22 17:59:44 +04:00
$sourceId = ( $itemType === 'file' || $itemType === 'folder' ) ? $fileSource : $itemSource ;
$sourceExists = self :: getItemSharedWithBySource ( $itemType , $sourceId , self :: FORMAT_NONE , null , true , $user );
2014-07-31 13:55:59 +04:00
$shareType = ( $isGroupShare ) ? self :: $shareTypeGroupUserUnique : $shareType ;
if ( $sourceExists ) {
$fileTarget = $sourceExists [ 'file_target' ];
$itemTarget = $sourceExists [ 'item_target' ];
2014-09-26 15:01:54 +04:00
// for group shares we don't need a additional entry if the target is the same
2014-09-26 15:10:31 +04:00
if ( $isGroupShare && $groupItemTarget === $itemTarget ) {
continue ;
}
2014-09-26 15:01:54 +04:00
2014-07-31 13:55:59 +04:00
} elseif ( ! $sourceExists && ! $isGroupShare ) {
2014-10-21 18:19:54 +04:00
$itemTarget = Helper :: generateTarget ( $itemType , $itemSource , $shareType , $user ,
2014-02-18 15:37:32 +04:00
$uidOwner , $suggestedItemTarget , $parent );
if ( isset ( $fileSource )) {
if ( $parentFolder ) {
if ( $parentFolder === true ) {
2014-10-21 18:19:54 +04:00
$fileTarget = Helper :: generateTarget ( 'file' , $filePath , $shareType , $user ,
2014-02-18 15:37:32 +04:00
$uidOwner , $suggestedFileTarget , $parent );
if ( $fileTarget != $groupFileTarget ) {
2014-07-31 13:55:59 +04:00
$parentFolders [ $user ][ 'folder' ] = $fileTarget ;
2014-02-18 15:37:32 +04:00
}
2014-07-31 13:55:59 +04:00
} else if ( isset ( $parentFolder [ $user ])) {
$fileTarget = $parentFolder [ $user ][ 'folder' ] . $itemSource ;
$parent = $parentFolder [ $user ][ 'id' ];
2014-02-18 15:37:32 +04:00
}
} else {
2014-10-21 18:19:54 +04:00
$fileTarget = Helper :: generateTarget ( 'file' , $filePath , $shareType ,
2014-07-31 13:55:59 +04:00
$user , $uidOwner , $suggestedFileTarget , $parent );
2014-02-18 15:37:32 +04:00
}
} else {
$fileTarget = null ;
}
2014-05-07 13:23:50 +04:00
2014-07-31 13:55:59 +04:00
} else {
2014-08-22 17:59:44 +04:00
// group share which doesn't exists until now, check if we need a unique target for this user
$itemTarget = Helper :: generateTarget ( $itemType , $itemSource , self :: SHARE_TYPE_USER , $user ,
$uidOwner , $suggestedItemTarget , $parent );
// do we also need a file target
if ( isset ( $fileSource )) {
$fileTarget = Helper :: generateTarget ( 'file' , $filePath , self :: SHARE_TYPE_USER , $user ,
$uidOwner , $suggestedFileTarget , $parent );
} else {
$fileTarget = null ;
}
2014-09-26 15:19:15 +04:00
if ( $itemTarget === $groupItemTarget && ( isset ( $fileSource ) && $fileTarget === $groupItemTarget )) {
2014-08-22 17:59:44 +04:00
continue ;
}
2014-07-31 13:55:59 +04:00
}
$queriesToExecute [] = array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'itemTarget' => $itemTarget ,
'shareType' => $shareType ,
'shareWith' => $user ,
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'shareTime' => time (),
'fileSource' => $fileSource ,
'fileTarget' => $fileTarget ,
'token' => $token ,
'parent' => $parent ,
'expiration' => $expirationDate ,
);
}
if ( $isGroupShare ) {
2014-05-07 13:23:50 +04:00
self :: insertShare ( $queriesToExecute [ 'groupShare' ]);
2014-04-09 19:51:54 +04:00
// Save this id, any extra rows for this group share will need to reference it
$parent = \OC_DB :: insertid ( '*PREFIX*share' );
unset ( $queriesToExecute [ 'groupShare' ]);
2014-07-31 13:55:59 +04:00
}
2014-05-07 13:23:50 +04:00
2014-07-31 13:55:59 +04:00
foreach ( $queriesToExecute as $shareQuery ) {
$shareQuery [ 'parent' ] = $parent ;
self :: insertShare ( $shareQuery );
}
2014-04-09 19:51:54 +04:00
2014-07-31 13:55:59 +04:00
$postHookData = array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'parent' => $parent ,
'shareType' => $shareType ,
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'fileSource' => $fileSource ,
'id' => $parent ,
'token' => $token ,
'expirationDate' => $expirationDate ,
);
$postHookData [ 'shareWith' ] = ( $isGroupShare ) ? $shareWith [ 'group' ] : $shareWith ;
$postHookData [ 'itemTarget' ] = ( $isGroupShare ) ? $groupItemTarget : $itemTarget ;
$postHookData [ 'fileTarget' ] = ( $isGroupShare ) ? $groupFileTarget : $fileTarget ;
\OC_Hook :: emit ( 'OCP\Share' , 'post_shared' , $postHookData );
return true ;
}
private static function checkReshare ( $itemType , $itemSource , $shareType , $shareWith , $uidOwner , $permissions , $itemSourceName , $expirationDate ) {
$backend = self :: getBackend ( $itemType );
$l = \OC :: $server -> getL10N ( 'lib' );
$result = array ();
2014-10-01 17:13:10 +04:00
$column = ( $itemType === 'file' || $itemType === 'folder' ) ? 'file_source' : 'item_source' ;
2014-07-31 13:55:59 +04:00
$checkReshare = self :: getItemSharedWithBySource ( $itemType , $itemSource , self :: FORMAT_NONE , null , true );
if ( $checkReshare ) {
// Check if attempting to share back to owner
if ( $checkReshare [ 'uid_owner' ] == $shareWith && $shareType == self :: SHARE_TYPE_USER ) {
$message = 'Sharing %s failed, because the user %s is the original sharer' ;
$message_t = $l -> t ( 'Sharing %s failed, because the user %s is the original sharer' , array ( $itemSourceName , $shareWith ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $shareWith ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
2014-07-31 13:55:59 +04:00
// Check if share permissions is granted
2014-11-25 18:28:41 +03:00
if ( self :: isResharingAllowed () && ( int ) $checkReshare [ 'permissions' ] & \OCP\Constants :: PERMISSION_SHARE ) {
2014-07-31 13:55:59 +04:00
if ( ~ ( int ) $checkReshare [ 'permissions' ] & $permissions ) {
$message = 'Sharing %s failed, because the permissions exceed permissions granted to %s' ;
$message_t = $l -> t ( 'Sharing %s failed, because the permissions exceed permissions granted to %s' , array ( $itemSourceName , $uidOwner ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName , $uidOwner ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
} else {
2014-07-31 13:55:59 +04:00
// TODO Don't check if inside folder
$result [ 'parent' ] = $checkReshare [ 'id' ];
$result [ 'expirationDate' ] = min ( $expirationDate , $checkReshare [ 'expiration' ]);
2014-10-01 17:13:10 +04:00
// only suggest the same name as new target if it is a reshare of the
// same file/folder and not the reshare of a child
if ( $checkReshare [ $column ] === $itemSource ) {
$result [ 'filePath' ] = $checkReshare [ 'file_target' ];
$result [ 'itemSource' ] = $checkReshare [ 'item_source' ];
$result [ 'fileSource' ] = $checkReshare [ 'file_source' ];
$result [ 'suggestedItemTarget' ] = $checkReshare [ 'item_target' ];
$result [ 'suggestedFileTarget' ] = $checkReshare [ 'file_target' ];
} else {
$result [ 'filePath' ] = ( $backend instanceof \OCP\Share_Backend_File_Dependent ) ? $backend -> getFilePath ( $itemSource , $uidOwner ) : null ;
$result [ 'suggestedItemTarget' ] = null ;
$result [ 'suggestedFileTarget' ] = null ;
$result [ 'itemSource' ] = $itemSource ;
$result [ 'fileSource' ] = ( $backend instanceof \OCP\Share_Backend_File_Dependent ) ? $itemSource : null ;
}
2014-02-18 15:37:32 +04:00
}
} else {
2014-07-31 13:55:59 +04:00
$message = 'Sharing %s failed, because resharing is not allowed' ;
$message_t = $l -> t ( 'Sharing %s failed, because resharing is not allowed' , array ( $itemSourceName ));
2014-05-07 13:23:50 +04:00
2014-07-31 13:55:59 +04:00
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSourceName ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
}
} else {
$result [ 'parent' ] = null ;
$result [ 'suggestedItemTarget' ] = null ;
$result [ 'suggestedFileTarget' ] = null ;
$result [ 'itemSource' ] = $itemSource ;
$result [ 'expirationDate' ] = $expirationDate ;
if ( ! $backend -> isValidSource ( $itemSource , $uidOwner )) {
$message = 'Sharing %s failed, because the sharing backend for '
. '%s could not find its source' ;
$message_t = $l -> t ( 'Sharing %s failed, because the sharing backend for %s could not find its source' , array ( $itemSource , $itemType ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSource , $itemType ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
}
if ( $backend instanceof \OCP\Share_Backend_File_Dependent ) {
$result [ 'filePath' ] = $backend -> getFilePath ( $itemSource , $uidOwner );
if ( $itemType == 'file' || $itemType == 'folder' ) {
$result [ 'fileSource' ] = $itemSource ;
} else {
$meta = \OC\Files\Filesystem :: getFileInfo ( $result [ 'filePath' ]);
$result [ 'fileSource' ] = $meta [ 'fileid' ];
}
if ( $result [ 'fileSource' ] == - 1 ) {
$message = 'Sharing %s failed, because the file could not be found in the file cache' ;
$message_t = $l -> t ( 'Sharing %s failed, because the file could not be found in the file cache' , array ( $itemSource ));
2014-05-07 13:23:50 +04:00
2014-07-31 13:55:59 +04:00
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSource ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
}
} else {
$result [ 'filePath' ] = null ;
$result [ 'fileSource' ] = null ;
2014-02-18 15:37:32 +04:00
}
}
2014-07-31 13:55:59 +04:00
return $result ;
2014-02-18 15:37:32 +04:00
}
2014-05-07 13:23:50 +04:00
private static function insertShare ( array $shareData )
{
$query = \OC_DB :: prepare ( 'INSERT INTO `*PREFIX*share` ('
. ' `item_type`, `item_source`, `item_target`, `share_type`,'
. ' `share_with`, `uid_owner`, `permissions`, `stime`, `file_source`,'
. ' `file_target`, `token`, `parent`, `expiration`) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)' );
$query -> bindValue ( 1 , $shareData [ 'itemType' ]);
$query -> bindValue ( 2 , $shareData [ 'itemSource' ]);
$query -> bindValue ( 3 , $shareData [ 'itemTarget' ]);
$query -> bindValue ( 4 , $shareData [ 'shareType' ]);
$query -> bindValue ( 5 , $shareData [ 'shareWith' ]);
$query -> bindValue ( 6 , $shareData [ 'uidOwner' ]);
$query -> bindValue ( 7 , $shareData [ 'permissions' ]);
$query -> bindValue ( 8 , $shareData [ 'shareTime' ]);
$query -> bindValue ( 9 , $shareData [ 'fileSource' ]);
$query -> bindValue ( 10 , $shareData [ 'fileTarget' ]);
$query -> bindValue ( 11 , $shareData [ 'token' ]);
$query -> bindValue ( 12 , $shareData [ 'parent' ]);
$query -> bindValue ( 13 , $shareData [ 'expiration' ], 'datetime' );
$query -> execute ();
}
2014-02-18 15:37:32 +04:00
/**
* Delete all shares with type SHARE_TYPE_LINK
*/
public static function removeAllLinkShares () {
// Delete any link shares
$query = \OC_DB :: prepare ( 'SELECT `id` FROM `*PREFIX*share` WHERE `share_type` = ?' );
$result = $query -> execute ( array ( self :: SHARE_TYPE_LINK ));
while ( $item = $result -> fetchRow ()) {
2014-02-18 18:07:03 +04:00
Helper :: delete ( $item [ 'id' ]);
2014-02-18 15:37:32 +04:00
}
}
/**
* In case a password protected link is not yet authenticated this function will return false
*
* @ param array $linkItem
2014-05-07 22:46:08 +04:00
* @ return boolean
2014-02-18 15:37:32 +04:00
*/
public static function checkPasswordProtectedShare ( array $linkItem ) {
if ( ! isset ( $linkItem [ 'share_with' ])) {
return true ;
}
if ( ! isset ( $linkItem [ 'share_type' ])) {
return true ;
}
if ( ! isset ( $linkItem [ 'id' ])) {
return true ;
}
if ( $linkItem [ 'share_type' ] != \OCP\Share :: SHARE_TYPE_LINK ) {
return true ;
}
2014-07-16 21:40:22 +04:00
if ( \OC :: $server -> getSession () -> exists ( 'public_link_authenticated' )
&& \OC :: $server -> getSession () -> get ( 'public_link_authenticated' ) === $linkItem [ 'id' ] ) {
2014-02-18 15:37:32 +04:00
return true ;
}
return false ;
}
2014-03-03 20:06:45 +04:00
/**
2014-05-19 19:50:53 +04:00
* construct select statement
2014-03-03 20:06:45 +04:00
* @ param int $format
2014-05-07 22:46:08 +04:00
* @ param boolean $fileDependent ist it a file / folder share or a generla share
2014-03-03 20:06:45 +04:00
* @ param string $uidOwner
* @ return string select statement
*/
private static function createSelectStatement ( $format , $fileDependent , $uidOwner = null ) {
$select = '*' ;
if ( $format == self :: FORMAT_STATUSES ) {
if ( $fileDependent ) {
2014-09-25 14:35:11 +04:00
$select = '`*PREFIX*share`.`id`, `*PREFIX*share`.`parent`, `share_type`, `path`, `storage`, `share_with`, `uid_owner` , `file_source`, `stime`, `*PREFIX*share`.`permissions`' ;
2014-03-03 20:06:45 +04:00
} else {
2014-09-25 14:35:11 +04:00
$select = '`id`, `parent`, `share_type`, `share_with`, `uid_owner`, `item_source`, `stime`, `*PREFIX*share`.`permissions`' ;
2014-03-03 20:06:45 +04:00
}
} else {
if ( isset ( $uidOwner )) {
if ( $fileDependent ) {
$select = '`*PREFIX*share`.`id`, `item_type`, `item_source`, `*PREFIX*share`.`parent`,'
2014-06-24 19:04:27 +04:00
. ' `share_type`, `share_with`, `file_source`, `file_target`, `path`, `*PREFIX*share`.`permissions`, `stime`,'
2014-03-03 20:06:45 +04:00
. ' `expiration`, `token`, `storage`, `mail_send`, `uid_owner`' ;
} else {
2014-06-03 19:57:56 +04:00
$select = '`id`, `item_type`, `item_source`, `parent`, `share_type`, `share_with`, `*PREFIX*share`.`permissions`,'
2014-03-03 20:06:45 +04:00
. ' `stime`, `file_source`, `expiration`, `token`, `mail_send`, `uid_owner`' ;
}
} else {
if ( $fileDependent ) {
if ( $format == \OC_Share_Backend_File :: FORMAT_GET_FOLDER_CONTENTS || $format == \OC_Share_Backend_File :: FORMAT_FILE_APP_ROOT ) {
$select = '`*PREFIX*share`.`id`, `item_type`, `item_source`, `*PREFIX*share`.`parent`, `uid_owner`, '
2014-04-24 17:13:34 +04:00
. '`share_type`, `share_with`, `file_source`, `path`, `file_target`, `stime`, '
2014-06-03 19:57:56 +04:00
. '`*PREFIX*share`.`permissions`, `expiration`, `storage`, `*PREFIX*filecache`.`parent` as `file_parent`, '
2014-03-03 20:06:45 +04:00
. '`name`, `mtime`, `mimetype`, `mimepart`, `size`, `unencrypted_size`, `encrypted`, `etag`, `mail_send`' ;
} else {
$select = ' `*PREFIX*share` . `id` , `item_type` , `item_source` , `item_target` ,
`*PREFIX*share` . `parent` , `share_type` , `share_with` , `uid_owner` ,
2014-06-03 19:57:56 +04:00
`file_source` , `path` , `file_target` , `*PREFIX*share` . `permissions` , `stime` , `expiration` , `token` , `storage` , `mail_send` ' ;
2014-03-03 20:06:45 +04:00
}
}
}
}
return $select ;
}
2014-03-03 20:20:09 +04:00
/**
2014-05-19 19:50:53 +04:00
* transform db results
2014-03-03 20:20:09 +04:00
* @ param array $row result
*/
private static function transformDBResults ( & $row ) {
if ( isset ( $row [ 'id' ])) {
$row [ 'id' ] = ( int ) $row [ 'id' ];
}
if ( isset ( $row [ 'share_type' ])) {
$row [ 'share_type' ] = ( int ) $row [ 'share_type' ];
}
if ( isset ( $row [ 'parent' ])) {
$row [ 'parent' ] = ( int ) $row [ 'parent' ];
}
if ( isset ( $row [ 'file_parent' ])) {
$row [ 'file_parent' ] = ( int ) $row [ 'file_parent' ];
}
if ( isset ( $row [ 'file_source' ])) {
$row [ 'file_source' ] = ( int ) $row [ 'file_source' ];
}
if ( isset ( $row [ 'permissions' ])) {
$row [ 'permissions' ] = ( int ) $row [ 'permissions' ];
}
if ( isset ( $row [ 'storage' ])) {
$row [ 'storage' ] = ( int ) $row [ 'storage' ];
}
if ( isset ( $row [ 'stime' ])) {
$row [ 'stime' ] = ( int ) $row [ 'stime' ];
}
}
2014-03-03 20:30:16 +04:00
/**
2014-05-19 19:50:53 +04:00
* format result
2014-03-03 20:30:16 +04:00
* @ param array $items result
2014-04-15 19:46:11 +04:00
* @ param string $column is it a file share or a general share ( 'file_target' or 'item_target' )
* @ param \OCP\Share_Backend $backend sharing backend
2014-03-03 20:30:16 +04:00
* @ param int $format
2014-04-15 19:46:11 +04:00
* @ param array $parameters additional format parameters
* @ return array format result
2014-03-03 20:30:16 +04:00
*/
private static function formatResult ( $items , $column , $backend , $format = self :: FORMAT_NONE , $parameters = null ) {
if ( $format === self :: FORMAT_NONE ) {
return $items ;
} else if ( $format === self :: FORMAT_STATUSES ) {
$statuses = array ();
foreach ( $items as $item ) {
if ( $item [ 'share_type' ] === self :: SHARE_TYPE_LINK ) {
$statuses [ $item [ $column ]][ 'link' ] = true ;
} else if ( ! isset ( $statuses [ $item [ $column ]])) {
$statuses [ $item [ $column ]][ 'link' ] = false ;
}
2014-07-10 15:19:35 +04:00
if ( ! empty ( $item [ 'file_target' ])) {
2014-03-03 20:30:16 +04:00
$statuses [ $item [ $column ]][ 'path' ] = $item [ 'path' ];
}
}
return $statuses ;
} else {
return $backend -> formatItems ( $items , $format , $parameters );
}
}
2014-06-04 13:07:31 +04:00
/**
* check if user can only share with group members
* @ return bool
*/
public static function shareWithGroupMembersOnly () {
$value = \OC_Appconfig :: getValue ( 'core' , 'shareapi_only_share_with_group_members' , 'no' );
return ( $value === 'yes' ) ? true : false ;
}
2014-06-03 17:15:04 +04:00
public static function isDefaultExpireDateEnabled () {
$defaultExpireDateEnabled = \OCP\Config :: getAppValue ( 'core' , 'shareapi_default_expire_date' , 'no' );
return ( $defaultExpireDateEnabled === " yes " ) ? true : false ;
}
public static function enforceDefaultExpireDate () {
$enforceDefaultExpireDate = \OCP\Config :: getAppValue ( 'core' , 'shareapi_enforce_expire_date' , 'no' );
return ( $enforceDefaultExpireDate === " yes " ) ? true : false ;
}
public static function getExpireInterval () {
return ( int ) \OCP\Config :: getAppValue ( 'core' , 'shareapi_expire_after_n_days' , '7' );
}
2014-02-18 15:37:32 +04:00
}