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
* @ param string $user User user to whom the item was shared
* @ return array Return list of items with file_target , permissions and expiration
*/
public static function getItemSharedWithUser ( $itemType , $itemSource , $user ) {
$shares = array ();
// first check if there is a db entry for the specific user
$query = \OC_DB :: prepare (
' SELECT `file_target` , `permissions` , `expiration`
FROM
`*PREFIX*share`
WHERE
`item_source` = ? AND `item_type` = ? AND `share_with` = ? '
);
$result = \OC_DB :: executeAudited ( $query , array ( $itemSource , $itemType , $user ));
while ( $row = $result -> fetchRow ()) {
$shares [] = $row ;
}
//if didn't found a result than let's look for a group share.
if ( empty ( $shares )) {
$groups = \OC_Group :: getUserGroups ( $user );
$query = \OC_DB :: prepare (
' SELECT `file_target` , `permissions` , `expiration`
FROM
`*PREFIX*share`
WHERE
`item_source` = ? AND `item_type` = ? AND `share_with` in ( ? ) '
);
$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-04-15 19:46:11 +04:00
* @ return mixed Return depends on format
2014-02-18 15:37:32 +04:00
*/
public static function getItemSharedWithBySource ( $itemType , $itemSource , $format = self :: FORMAT_NONE ,
$parameters = null , $includeCollections = false ) {
return self :: getItems ( $itemType , $itemSource , self :: $shareTypeUserAndGroups , \OC_User :: getUser (), null , $format ,
$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-04-05 21:23:12 +04:00
$l = \OC_L10N :: get ( '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' ) {
$permissions = ( int ) $permissions & ~ \OCP\PERMISSION_DELETE ;
}
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-02-18 15:37:32 +04:00
$forcePortable = ( CRYPT_BLOWFISH != 1 );
$hasher = new \PasswordHash ( 8 , $forcePortable );
$shareWith = $hasher -> HashPassword ( $shareWith . \OC_Config :: getValue ( 'passwordsalt' , '' ));
} 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 {
$token = \OC_Util :: generateRandomBytes ( self :: TOKEN_LENGTH );
}
$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
return false ;
} 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
* @ return boolean true on success or false on failure
2014-02-18 15:37:32 +04:00
*/
public static function unshare ( $itemType , $itemSource , $shareType , $shareWith ) {
2014-03-07 18:38:14 +04:00
$item = self :: getItems ( $itemType , $itemSource , $shareType , $shareWith , \OC_User :: getUser (), self :: FORMAT_NONE , null , 1 );
if ( ! empty ( $item )) {
2014-02-18 15:37:32 +04:00
self :: unshareItem ( $item );
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
* @ param string $itemTarget
* @ 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
*/
public static function unshareFromSelf ( $itemType , $itemTarget ) {
2014-06-04 20:41:47 +04:00
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' ) {
$statement = 'SELECT * FROM `*PREFIX*share` WHERE `item_type` = ? and `file_target` = ?' ;
} else {
$statement = 'SELECT * FROM `*PREFIX*share` WHERE `item_type` = ? and `item_target` = ?' ;
}
$query = \OCP\DB :: prepare ( $statement );
$result = $query -> execute ( array ( $itemType , $itemTarget ));
$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 ;
}
}
if ( ! $itemUnshared && isset ( $groupShare )) {
$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-04-05 21:23:12 +04:00
$l = \OC_L10N :: get ( '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
if (( $item [ 'permissions' ] & \OCP\PERMISSION_SHARE ) && ( ~ $permissions & \OCP\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 ) {
$l = \OC_L10N :: get ( 'lib' );
$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 )
* @ return null
*/
protected static function unshareItem ( array $item ) {
// 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 );
$deletedShares = Helper :: delete ( $item [ 'id' ]);
$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-04-05 21:23:12 +04:00
$l = \OC_L10N :: get ( '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...
if ( ! self :: getBackend ( $itemType ) instanceof \OCP\Share_Backend_Collection || $itemType != 'folder' ) {
unset ( $collectionTypes [ 0 ]);
}
// Return array if collections were found or the item type is a
// collection itself - collections can be inside collections
if ( count ( $collectionTypes ) > 0 ) {
return $collectionTypes ;
}
return false ;
}
/**
* Get shared items from the database
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 )) {
$where .= ' AND `share_type` IN (?,?,?)' ;
$queryArgs [] = self :: SHARE_TYPE_USER ;
$queryArgs [] = self :: SHARE_TYPE_GROUP ;
$queryArgs [] = self :: $shareTypeGroupUserUnique ;
$userAndGroups = array_merge ( array ( $shareWith ), \OC_Group :: getUserGroups ( $shareWith ));
$placeholders = join ( ',' , array_fill ( 0 , count ( $userAndGroups ), '?' ));
$where .= ' AND `share_with` IN (' . $placeholders . ')' ;
$queryArgs = array_merge ( $queryArgs , $userAndGroups );
// 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 );
if ( $includeCollections && $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 ;
if ( $includeCollections && $collectionTypes ) {
$placeholders = join ( ',' , array_fill ( 0 , count ( $collectionTypes ), '?' ));
$where .= ' OR `item_type` IN (' . $placeholders . '))' ;
$queryArgs = array_merge ( $queryArgs , $collectionTypes );
}
}
if ( $limit != - 1 && ! $includeCollections ) {
if ( $shareType == self :: $shareTypeUserAndGroups ) {
// 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' ;
}
// 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-06-11 16:28:30 +04:00
$where .= ' ORDER BY `*PREFIX*share`.`id` ASC' ;
2014-02-18 15:37:32 +04:00
}
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' ,
\OC_DB :: getErrorMessage ( $result ) . ', select=' . $select . ' where=' . $where ,
\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' ];
// 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
if ( isset ( $targets [ $row [ $column ]])) {
// Check if the same owner shared with the user twice
// through a group and user share - this is allowed
$id = $targets [ $row [ $column ]];
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
if ( ~ ( int ) $items [ $id ][ 'permissions' ] & \OCP\PERMISSION_SHARE
&& ( int ) $row [ 'permissions' ] & \OCP\PERMISSION_SHARE ) {
$items [ $row [ 'id' ]] = $items [ $id ];
$switchedItems [ $id ] = $row [ 'id' ];
unset ( $items [ $id ]);
$id = $row [ 'id' ];
}
// Combine the permissions for the item
$items [ $id ][ 'permissions' ] |= ( int ) $row [ 'permissions' ];
continue ;
}
} else {
$targets [ $row [ $column ]] = $row [ 'id' ];
}
}
// Remove root from file source paths if retrieving own shared items
if ( isset ( $uidOwner ) && isset ( $row [ 'path' ])) {
if ( isset ( $row [ 'parent' ])) {
$query = \OC_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 );
}
}
if ( $mounts [ $row [ 'storage' ]]) {
$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
}
}
}
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-02-18 15:37:32 +04:00
$row [ 'permissions' ] &= ~ \OCP\PERMISSION_SHARE ;
}
// Add display names to result
if ( isset ( $row [ 'share_with' ]) && $row [ 'share_with' ] != '' ) {
$row [ 'share_with_displayname' ] = \OCP\User :: getDisplayName ( $row [ 'share_with' ]);
}
if ( isset ( $row [ 'uid_owner' ]) && $row [ 'uid_owner' ] != '' ) {
$row [ 'displayname_owner' ] = \OCP\User :: getDisplayName ( $row [ 'uid_owner' ]);
}
$items [ $row [ 'id' ]] = $row ;
}
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
if ( $includeCollections && $collectionTypes && in_array ( $row [ 'item_type' ], $collectionTypes )) {
if (( $collectionBackend = self :: getBackend ( $row [ 'item_type' ]))
&& $collectionBackend instanceof \OCP\Share_Backend_Collection ) {
// Collections can be inside collections, check if the item is a collection
if ( isset ( $item ) && $row [ 'item_type' ] == $itemType && $row [ $column ] == $item ) {
$collectionItems [] = $row ;
} else {
$collection = 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 ]);
}
}
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-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 ();
}
/**
* 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-02-18 15:37:32 +04:00
$backend = self :: getBackend ( $itemType );
2014-04-05 21:23:12 +04:00
$l = \OC_L10N :: get ( 'lib' );
2014-02-18 15:37:32 +04:00
// Check if this is a reshare
if ( $checkReshare = self :: getItemSharedWithBySource ( $itemType , $itemSource , self :: FORMAT_NONE , null , true )) {
// Check if attempting to share back to owner
if ( $checkReshare [ 'uid_owner' ] == $shareWith && $shareType == self :: SHARE_TYPE_USER ) {
2014-04-05 21:23:12 +04:00
$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
}
// Check if share permissions is granted
if ( self :: isResharingAllowed () && ( int ) $checkReshare [ 'permissions' ] & \OCP\PERMISSION_SHARE ) {
if ( ~ ( int ) $checkReshare [ 'permissions' ] & $permissions ) {
2014-04-05 21:23:12 +04:00
$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 {
// TODO Don't check if inside folder
$parent = $checkReshare [ 'id' ];
$itemSource = $checkReshare [ 'item_source' ];
$fileSource = $checkReshare [ 'file_source' ];
$suggestedItemTarget = $checkReshare [ 'item_target' ];
$suggestedFileTarget = $checkReshare [ 'file_target' ];
$filePath = $checkReshare [ 'file_target' ];
2014-05-07 13:23:50 +04:00
$expirationDate = min ( $expirationDate , $checkReshare [ 'expiration' ]);
2014-02-18 15:37:32 +04:00
}
} else {
2014-04-05 21:23:12 +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 ));
\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 {
$parent = null ;
$suggestedItemTarget = null ;
$suggestedFileTarget = null ;
if ( ! $backend -> isValidSource ( $itemSource , $uidOwner )) {
2014-04-05 21:23:12 +04:00
$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 );
2014-02-18 15:37:32 +04:00
}
if ( $backend instanceof \OCP\Share_Backend_File_Dependent ) {
$filePath = $backend -> getFilePath ( $itemSource , $uidOwner );
if ( $itemType == 'file' || $itemType == 'folder' ) {
$fileSource = $itemSource ;
} else {
$meta = \OC\Files\Filesystem :: getFileInfo ( $filePath );
$fileSource = $meta [ 'fileid' ];
}
if ( $fileSource == - 1 ) {
2014-04-05 21:23:12 +04:00
$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 ));
\OC_Log :: write ( 'OCP\Share' , sprintf ( $message , $itemSource ), \OC_Log :: ERROR );
throw new \Exception ( $message_t );
2014-02-18 15:37:32 +04:00
}
} else {
$filePath = null ;
$fileSource = null ;
}
}
2014-05-07 13:23:50 +04:00
2014-02-18 15:37:32 +04:00
// Share with a group
if ( $shareType == self :: SHARE_TYPE_GROUP ) {
2014-02-18 18:07:03 +04:00
$groupItemTarget = Helper :: generateTarget ( $itemType , $itemSource , $shareType , $shareWith [ 'group' ],
2014-02-18 15:37:32 +04:00
$uidOwner , $suggestedItemTarget );
$run = true ;
$error = '' ;
\OC_Hook :: emit ( 'OCP\Share' , 'pre_shared' , array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'itemTarget' => $groupItemTarget ,
'shareType' => $shareType ,
'shareWith' => $shareWith [ 'group' ],
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'fileSource' => $fileSource ,
2014-05-07 13:23:50 +04:00
'expiration' => $expirationDate ,
2014-02-18 15:37:32 +04:00
'token' => $token ,
'run' => & $run ,
'error' => & $error
));
if ( $run === false ) {
throw new \Exception ( $error );
}
if ( isset ( $fileSource )) {
if ( $parentFolder ) {
if ( $parentFolder === true ) {
2014-02-18 18:07:03 +04:00
$groupFileTarget = Helper :: generateTarget ( 'file' , $filePath , $shareType ,
2014-02-18 15:37:32 +04:00
$shareWith [ 'group' ], $uidOwner , $suggestedFileTarget );
// Set group default file target for future use
$parentFolders [ 0 ][ 'folder' ] = $groupFileTarget ;
} else {
// Get group default file target
$groupFileTarget = $parentFolder [ 0 ][ 'folder' ] . $itemSource ;
$parent = $parentFolder [ 0 ][ 'id' ];
}
} else {
2014-02-18 18:07:03 +04:00
$groupFileTarget = Helper :: generateTarget ( 'file' , $filePath , $shareType , $shareWith [ 'group' ],
2014-02-18 15:37:32 +04:00
$uidOwner , $suggestedFileTarget );
}
} else {
$groupFileTarget = null ;
}
2014-04-09 19:51:54 +04:00
$queriesToExecute = array ();
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 ,
'fileTarget' => $groupFileTarget ,
'token' => $token ,
'parent' => $parent ,
'expiration' => $expirationDate ,
);
2014-02-18 15:37:32 +04:00
// Loop through all users of this group in case we need to add an extra row
foreach ( $shareWith [ 'users' ] as $uid ) {
2014-02-18 18:07:03 +04:00
$itemTarget = Helper :: generateTarget ( $itemType , $itemSource , self :: SHARE_TYPE_USER , $uid ,
2014-02-18 15:37:32 +04:00
$uidOwner , $suggestedItemTarget , $parent );
if ( isset ( $fileSource )) {
if ( $parentFolder ) {
if ( $parentFolder === true ) {
2014-02-18 18:07:03 +04:00
$fileTarget = Helper :: generateTarget ( 'file' , $filePath , self :: SHARE_TYPE_USER , $uid ,
2014-02-18 15:37:32 +04:00
$uidOwner , $suggestedFileTarget , $parent );
if ( $fileTarget != $groupFileTarget ) {
$parentFolders [ $uid ][ 'folder' ] = $fileTarget ;
}
} else if ( isset ( $parentFolder [ $uid ])) {
$fileTarget = $parentFolder [ $uid ][ 'folder' ] . $itemSource ;
$parent = $parentFolder [ $uid ][ 'id' ];
}
} else {
2014-02-18 18:07:03 +04:00
$fileTarget = Helper :: generateTarget ( 'file' , $filePath , self :: SHARE_TYPE_USER ,
2014-02-18 15:37:32 +04:00
$uid , $uidOwner , $suggestedFileTarget , $parent );
}
} else {
$fileTarget = null ;
}
// Insert an extra row for the group share if the item or file target is unique for this user
if ( $itemTarget != $groupItemTarget || ( isset ( $fileSource ) && $fileTarget != $groupFileTarget )) {
2014-05-07 13:23:50 +04:00
$queriesToExecute [] = array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'itemTarget' => $itemTarget ,
'shareType' => self :: $shareTypeGroupUserUnique ,
'shareWith' => $uid ,
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'shareTime' => time (),
'fileSource' => $fileSource ,
'fileTarget' => $fileTarget ,
'token' => $token ,
//'parent' => $parent,
'expiration' => $expirationDate ,
);
2014-02-18 15:37:32 +04:00
}
}
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-05-07 13:23:50 +04:00
foreach ( $queriesToExecute as $shareQuery ) {
$shareQuery [ 'parent' ] = $parent ;
self :: insertShare ( $shareQuery );
2014-04-09 19:51:54 +04:00
}
2014-02-18 15:37:32 +04:00
\OC_Hook :: emit ( 'OCP\Share' , 'post_shared' , array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'itemTarget' => $groupItemTarget ,
'parent' => $parent ,
'shareType' => $shareType ,
'shareWith' => $shareWith [ 'group' ],
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'fileSource' => $fileSource ,
'fileTarget' => $groupFileTarget ,
'id' => $parent ,
2014-05-07 13:23:50 +04:00
'token' => $token ,
'expirationDate' => $expirationDate ,
2014-02-18 15:37:32 +04:00
));
if ( $parentFolder === true ) {
// Return parent folders to preserve file target paths for potential children
return $parentFolders ;
}
} else {
2014-02-18 18:07:03 +04:00
$itemTarget = Helper :: generateTarget ( $itemType , $itemSource , $shareType , $shareWith , $uidOwner ,
2014-02-18 15:37:32 +04:00
$suggestedItemTarget );
$run = true ;
$error = '' ;
\OC_Hook :: emit ( 'OCP\Share' , 'pre_shared' , array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'itemTarget' => $itemTarget ,
'shareType' => $shareType ,
'shareWith' => $shareWith ,
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'fileSource' => $fileSource ,
'token' => $token ,
2014-05-07 13:23:50 +04:00
'expirationDate' => $expirationDate ,
2014-02-18 15:37:32 +04:00
'run' => & $run ,
2014-05-07 13:23:50 +04:00
'error' => & $error ,
2014-02-18 15:37:32 +04:00
));
if ( $run === false ) {
throw new \Exception ( $error );
}
if ( isset ( $fileSource )) {
if ( $parentFolder ) {
if ( $parentFolder === true ) {
2014-02-18 18:07:03 +04:00
$fileTarget = Helper :: generateTarget ( 'file' , $filePath , $shareType , $shareWith ,
2014-02-18 15:37:32 +04:00
$uidOwner , $suggestedFileTarget );
$parentFolders [ 'folder' ] = $fileTarget ;
} else {
$fileTarget = $parentFolder [ 'folder' ] . $itemSource ;
$parent = $parentFolder [ 'id' ];
}
} else {
2014-02-18 18:07:03 +04:00
$fileTarget = Helper :: generateTarget ( 'file' , $filePath , $shareType , $shareWith , $uidOwner ,
2014-02-18 15:37:32 +04:00
$suggestedFileTarget );
}
} else {
$fileTarget = null ;
}
2014-05-07 13:23:50 +04:00
self :: insertShare ( array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'itemTarget' => $itemTarget ,
'shareType' => $shareType ,
'shareWith' => $shareWith ,
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'shareTime' => time (),
'fileSource' => $fileSource ,
'fileTarget' => $fileTarget ,
'token' => $token ,
'parent' => $parent ,
'expiration' => $expirationDate ,
));
2014-02-18 15:37:32 +04:00
$id = \OC_DB :: insertid ( '*PREFIX*share' );
\OC_Hook :: emit ( 'OCP\Share' , 'post_shared' , array (
'itemType' => $itemType ,
'itemSource' => $itemSource ,
'itemTarget' => $itemTarget ,
'parent' => $parent ,
'shareType' => $shareType ,
'shareWith' => $shareWith ,
'uidOwner' => $uidOwner ,
'permissions' => $permissions ,
'fileSource' => $fileSource ,
'fileTarget' => $fileTarget ,
'id' => $id ,
2014-05-07 13:23:50 +04:00
'token' => $token ,
'expirationDate' => $expirationDate ,
2014-02-18 15:37:32 +04:00
));
if ( $parentFolder === true ) {
$parentFolders [ 'id' ] = $id ;
// Return parent folder to preserve file target paths for potential children
return $parentFolders ;
}
}
return true ;
}
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 ;
}
if ( \OC :: $session -> exists ( 'public_link_authenticated' )
&& \OC :: $session -> get ( 'public_link_authenticated' ) === $linkItem [ 'id' ] ) {
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-04-24 17:13:34 +04:00
$select = '`*PREFIX*share`.`id`, `*PREFIX*share`.`parent`, `share_type`, `path`, `storage`, `share_with`, `uid_owner` , `file_source`, `stime`' ;
2014-03-03 20:06:45 +04:00
} else {
2014-04-24 17:13:34 +04:00
$select = '`id`, `parent`, `share_type`, `share_with`, `uid_owner`, `item_source`, `stime`' ;
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
}