/** * PropFind * * This method handler is invoked before any after properties for a * resource are fetched. This allows us to add in any CalDAV specific * properties. * * @param DAV\PropFind $propFind * @param DAV\INode $node * @return void */ function propFind(DAV\PropFind $propFind, DAV\INode $node) { $ns = '{' . self::NS_CALDAV . '}'; if ($node instanceof ICalendarObjectContainer) { $propFind->handle($ns . 'max-resource-size', $this->maxResourceSize); $propFind->handle($ns . 'supported-calendar-data', function () { return new Xml\Property\SupportedCalendarData(); }); $propFind->handle($ns . 'supported-collation-set', function () { return new Xml\Property\SupportedCollationSet(); }); } if ($node instanceof DAVACL\IPrincipal) { $principalUrl = $node->getPrincipalUrl(); $propFind->handle('{' . self::NS_CALDAV . '}calendar-home-set', function () use($principalUrl) { $calendarHomePath = $this->getCalendarHomeForPrincipal($principalUrl) . '/'; return new Href($calendarHomePath); }); // The calendar-user-address-set property is basically mapped to // the {DAV:}alternate-URI-set property. $propFind->handle('{' . self::NS_CALDAV . '}calendar-user-address-set', function () use($node) { $addresses = $node->getAlternateUriSet(); $addresses[] = $this->server->getBaseUri() . $node->getPrincipalUrl() . '/'; return new Href($addresses, false); }); // For some reason somebody thought it was a good idea to add // another one of these properties. We're supporting it too. $propFind->handle('{' . self::NS_CALENDARSERVER . '}email-address-set', function () use($node) { $addresses = $node->getAlternateUriSet(); $emails = []; foreach ($addresses as $address) { if (substr($address, 0, 7) === 'mailto:') { $emails[] = substr($address, 7); } } return new Xml\Property\EmailAddressSet($emails); }); // These two properties are shortcuts for ical to easily find // other principals this principal has access to. $propRead = '{' . self::NS_CALENDARSERVER . '}calendar-proxy-read-for'; $propWrite = '{' . self::NS_CALENDARSERVER . '}calendar-proxy-write-for'; if ($propFind->getStatus($propRead) === 404 || $propFind->getStatus($propWrite) === 404) { $aclPlugin = $this->server->getPlugin('acl'); $membership = $aclPlugin->getPrincipalMembership($propFind->getPath()); $readList = []; $writeList = []; foreach ($membership as $group) { $groupNode = $this->server->tree->getNodeForPath($group); $listItem = Uri\split($group)[0] . '/'; // If the node is either ap proxy-read or proxy-write // group, we grab the parent principal and add it to the // list. if ($groupNode instanceof Principal\IProxyRead) { $readList[] = $listItem; } if ($groupNode instanceof Principal\IProxyWrite) { $writeList[] = $listItem; } } $propFind->set($propRead, new Href($readList)); $propFind->set($propWrite, new Href($writeList)); } } // instanceof IPrincipal if ($node instanceof ICalendarObject) { // The calendar-data property is not supposed to be a 'real' // property, but in large chunks of the spec it does act as such. // Therefore we simply expose it as a property. $propFind->handle('{' . self::NS_CALDAV . '}calendar-data', function () use($node) { $val = $node->get(); if (is_resource($val)) { $val = stream_get_contents($val); } // Taking out \r to not screw up the xml output return str_replace("\r", "", $val); }); } }
/** * Fetches properties for a path. * * This method received a PropFind object, which contains all the * information about the properties that need to be fetched. * * Ususually you would just want to call 'get404Properties' on this object, * as this will give you the _exact_ list of properties that need to be * fetched, and haven't yet. * * However, you can also support the 'allprops' property here. In that * case, you should check for $propFind->isAllProps(). * * @param string $path * @param PropFind $propFind * @return void */ function propFind($path, PropFind $propFind) { if (!$propFind->isAllProps() && count($propFind->get404Properties()) === 0) { return; } $query = 'SELECT name, value, valuetype FROM ' . $this->tableName . ' WHERE path = ?'; $stmt = $this->pdo->prepare($query); $stmt->execute([$path]); while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) { if (gettype($row['value']) === 'resource') { $row['value'] = stream_get_contents($row['value']); } switch ($row['valuetype']) { case null: case self::VT_STRING: $propFind->set($row['name'], $row['value']); break; case self::VT_XML: $propFind->set($row['name'], new Complex($row['value'])); break; case self::VT_OBJECT: $propFind->set($row['name'], unserialize($row['value'])); break; } } }
/** * Fetches properties for a path. * * @param string $path * @param PropFind $propFind * @return void */ public function propFind($path, PropFind $propFind) { try { $node = $this->tree->getNodeForPath($path); if (!$node instanceof Node) { return; } } catch (ServiceUnavailable $e) { // might happen for unavailable mount points, skip return; } catch (NotFound $e) { // in some rare (buggy) cases the node might not be found, // we catch the exception to prevent breaking the whole list with a 404 // (soft fail) \OC::$server->getLogger()->warning('Could not get node for path: \\"' . $path . '\\" : ' . $e->getMessage(), array('app' => 'files')); return; } $requestedProps = $propFind->get404Properties(); // these might appear $requestedProps = array_diff($requestedProps, $this->ignoredProperties); if (empty($requestedProps)) { return; } if ($node instanceof Directory && $propFind->getDepth() !== 0) { // note: pre-fetching only supported for depth <= 1 $this->loadChildrenProperties($node, $requestedProps); } $props = $this->getProperties($node, $requestedProps); foreach ($props as $propName => $propValue) { $propFind->set($propName, $propValue); } }
/** * Our PROPFIND handler * * Here we set a contenttype, if the node didn't already have one. * * @param PropFind $propFind * @param INode $node * @return void */ function propFind(PropFind $propFind, INode $node) { $propFind->handle('{DAV:}getcontenttype', function () use($propFind) { list(, $fileName) = URLUtil::splitPath($propFind->getPath()); return $this->getContentType($fileName); }); }
/** * Fetches properties for a path. * * This method received a PropFind object, which contains all the * information about the properties that need to be fetched. * * Ususually you would just want to call 'get404Properties' on this object, * as this will give you the _exact_ list of properties that need to be * fetched, and haven't yet. * * @param string $path * @param PropFind $propFind * @return void */ public function propFind($path, PropFind $propFind) { $propertyNames = $propFind->get404Properties(); if (!$propertyNames) { return; } // error_log("propFind: path($path), " . print_r($propertyNames, true)); $cachedNodes = \CB\Cache::get('DAVNodes'); // error_log("propFind: " . print_r($cachedNodes, true)); $path = trim($path, '/'); $path = str_replace('\\', '/', $path); // Node with $path is not in cached nodes, return if (!array_key_exists($path, $cachedNodes)) { return; } $node = $cachedNodes[$path]; // while($row = $stmt->fetch(\PDO::FETCH_ASSOC)) { // $propFind->set($row['name'], $row['value']); // } foreach ($propertyNames as $prop) { if ($prop == '{DAV:}creationdate') { $dttm = new \DateTime($node['cdate']); // $dttm->getTimestamp() $propFind->set($prop, \Sabre\HTTP\Util::toHTTPDate($dttm)); } elseif ($prop == '{urn:schemas-microsoft-com:office:office}modifiedby' or $prop == '{DAV:}getmodifiedby') { // This has to be revised, because the User.login differs from User.DisplayName // moreover, during an edit, Word will check for File Properties and we // tell Word that the file is modified by another user // $propFind->set($prop, \CB\User::getDisplayName($node['uid'])); } } }
function testPropFindNothingToDo() { $backend = $this->getBackend(); $propFind = new PropFind('dir', ['{DAV:}displayname']); $propFind->set('{DAV:}displayname', 'foo'); $backend->propFind('dir', $propFind); $this->assertEquals('foo', $propFind->get('{DAV:}displayname')); }
function testDontTouchOtherMimeTypes() { $this->server->httpRequest = new HTTP\Request('GET', '/addressbooks/user1/book1/card1.vcf', ['User-Agent' => 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.6; rv:10.0.2) Gecko/20120216 Thunderbird/10.0.2 Lightning/1.2.1']); $propFind = new PropFind('hello', ['{DAV:}getcontenttype']); $propFind->set('{DAV:}getcontenttype', 'text/plain'); $this->carddavPlugin->propFindLate($propFind, new \Sabre\DAV\SimpleCollection('foo')); $this->assertEquals('text/plain', $propFind->get('{DAV:}getcontenttype')); }
/** * Called during PROPFIND operations. * * If there's any requested properties that don't have a value yet, this * plugin will look in the property storage backend to find them. * * @param PropFind $propFind * @param INode $node * @return void */ function propFind(PropFind $propFind, INode $node) { $path = $propFind->getPath(); $pathFilter = $this->pathFilter; if ($pathFilter && !$pathFilter($path)) { return; } $this->backend->propFind($propFind->getPath(), $propFind); }
public function testPropFind() { $propName = '{http://calendarserver.org/ns/}subscribed-strip-alarms'; $propFind = new PropFind('foo', [$propName]); $propFind->set($propName, null, 200); $plugin = new Plugin(); $plugin->propFind($propFind, new \Sabre\DAV\SimpleCollection('hi')); $this->assertFalse(is_null($propFind->get($propName))); }
/** * This method is called after most properties have been found * it allows us to add in any Lock-related properties * * @param DAV\PropFind $propFind * @param DAV\INode $node * @return void */ function propFind(DAV\PropFind $propFind, DAV\INode $node) { $propFind->handle('{DAV:}supportedlock', function () { return new DAV\Property\SupportedLock(!!$this->locksBackend); }); $propFind->handle('{DAV:}lockdiscovery', function () use($propFind) { return new DAV\Property\LockDiscovery($this->getLocks($propFind->getPath())); }); }
/** * Adds all CardDAV-specific properties * * @param PropFind $propFind * @param INode $node * @return void */ function propFind(PropFind $propFind, INode $node) { $ns = '{http://owncloud.org/ns}'; if ($node instanceof AddressBook) { $propFind->handle($ns . 'groups', function () use($node) { return new Groups($node->getContactsGroups()); }); } }
/** * Fetches properties for a path. * * This method received a PropFind object, which contains all the * information about the properties that need to be fetched. * * Ususually you would just want to call 'get404Properties' on this object, * as this will give you the _exact_ list of properties that need to be * fetched, and haven't yet. * * @param string $path * @param PropFind $propFind * @return void */ function propFind($path, PropFind $propFind) { if (!isset($this->data[$path])) { return; } foreach ($this->data[$path] as $name => $value) { $propFind->set($name, $value); } }
/** * Triggered after properties have been fetched. * * @param PropFind $propFind * @param INode $node * @return void */ function propFind(PropFind $propFind, INode $node) { // There's a bunch of properties that must appear as a self-closing // xml-element. This event handler ensures that this will be the case. $props = ['{http://calendarserver.org/ns/}subscribed-strip-alarms', '{http://calendarserver.org/ns/}subscribed-strip-attachments', '{http://calendarserver.org/ns/}subscribed-strip-todos']; foreach ($props as $prop) { if ($propFind->getStatus($prop) === 200) { $propFind->set($prop, '', 200); } } }
function propFind(PropFind $propFind, INode $node) { /* Overload current-user-principal */ $propFind->handle('{DAV:}current-user-principal', function () { if ($url = parent::getCurrentUserPrincipal()) { return new Principal(Principal::HREF, $url . '/'); } else { return new Principal(Principal::UNAUTHENTICATED); } }); parent::propFind($propFind, $node); }
public function propFind(DAV\PropFind $propFind, DAV\INode $node) { // Add extra Windows properties to the node: if (method_exists($node, 'getIsHidden')) { $propFind->set('{DAV:}ishidden', $node->getIsHidden() ? '1' : '0'); } if (method_exists($node, 'getIsReadonly')) { $propFind->set('{DAV:}isreadonly', $node->getIsReadonly() ? '1' : '0'); } if (method_exists($node, 'getWin32Props')) { $propFind->set('{urn:schemas-microsoft-com:}Win32FileAttributes', $node->getWin32Props()); } }
/** * Fetches properties for a path. * * This method received a PropFind object, which contains all the * information about the properties that need to be fetched. * * Ususually you would just want to call 'get404Properties' on this object, * as this will give you the _exact_ list of properties that need to be * fetched, and haven't yet. * * @param string $path * @param PropFind $propFind * @return void */ function propFind($path, PropFind $propFind) { $propertyNames = $propFind->get404Properties(); if (!$propertyNames) { return; } $query = 'SELECT name, value FROM propertystorage WHERE path = ?'; $stmt = $this->pdo->prepare($query); $stmt->execute([$path]); while ($row = $stmt->fetch(\PDO::FETCH_ASSOC)) { $propFind->set($row['name'], $row['value']); } }
/** * Fetches properties for a path. * * @param string $path * @param PropFind $propFind * @return void */ public function propFind($path, PropFind $propFind) { $requestedProps = $propFind->get404Properties(); // these might appear $requestedProps = array_diff($requestedProps, $this->ignoredProperties); if (empty($requestedProps)) { return; } $props = $this->getProperties($path, $requestedProps); foreach ($props as $propName => $propValue) { $propFind->set($propName, $propValue); } }
/** * PropFind * * @param PropFind $propFind * @param BaseINode $node * @return void */ function propFind(PropFind $propFind, BaseINode $node) { $caldavPlugin = $this->server->getPlugin('caldav'); if ($node instanceof DAVACL\IPrincipal) { $principalUrl = $node->getPrincipalUrl(); // notification-URL property $propFind->handle('{' . self::NS_CALENDARSERVER . '}notification-URL', function () use($principalUrl, $caldavPlugin) { $notificationPath = $caldavPlugin->getCalendarHomeForPrincipal($principalUrl) . '/notifications/'; return new DAV\Xml\Property\Href($notificationPath); }); } if ($node instanceof INode) { $propFind->handle('{' . self::NS_CALENDARSERVER . '}notificationtype', [$node, 'getNotificationType']); } }
/** * Adds tags and favorites properties to the response, * if requested. * * @param PropFind $propFind * @param \Sabre\DAV\INode $node * @return void */ public function handleGetProperties(PropFind $propFind, \Sabre\DAV\INode $node) { if (!$node instanceof File && !$node instanceof Directory) { return; } $propFind->handle(self::PROPERTY_NAME_COUNT, function () use($node) { return $this->commentsManager->getNumberOfCommentsForObject('files', strval($node->getId())); }); $propFind->handle(self::PROPERTY_NAME_HREF, function () use($node) { return $this->getCommentsLink($node); }); $propFind->handle(self::PROPERTY_NAME_UNREAD, function () use($node) { return $this->getUnreadCount($node); }); }
/** * Return some dummy response for PROPFIND requests with regard to locking * * @param PropFind $propFind * @param INode $node * @return void */ function propFind(PropFind $propFind, INode $node) { $propFind->handle('{DAV:}supportedlock', function () { return new SupportedLock(true); }); $propFind->handle('{DAV:}lockdiscovery', function () use($propFind) { return new LockDiscovery([]); }); }
/** * Adds all ownCloud-specific properties * * @param PropFind $propFind * @param \Sabre\DAV\INode $node * @return void */ public function handleGetProperties(PropFind $propFind, \Sabre\DAV\INode $node) { if ($node instanceof \OC\Connector\Sabre\Node) { $propFind->handle(self::FILEID_PROPERTYNAME, function () use($node) { return $node->getFileId(); }); $propFind->handle(self::PERMISSIONS_PROPERTYNAME, function () use($node) { return $node->getDavPermissions(); }); $propFind->handle(self::GETETAG_PROPERTYNAME, function () use($node) { return $node->getEtag(); }); } if ($node instanceof \OC\Connector\Sabre\File) { $propFind->handle(self::DOWNLOADURL_PROPERTYNAME, function () use($node) { /** @var $node \OC\Connector\Sabre\File */ $directDownloadUrl = $node->getDirectDownload(); if (isset($directDownloadUrl['url'])) { return $directDownloadUrl['url']; } return false; }); } if ($node instanceof \OC\Connector\Sabre\Directory) { $propFind->handle(self::SIZE_PROPERTYNAME, function () use($node) { return $node->getSize(); }); } }
/** * Small helper to support PROPFIND with DEPTH_INFINITY. */ private function addPathNodesRecursively(&$propFindRequests, PropFind $propFind) { $newDepth = $propFind->getDepth(); $path = $propFind->getPath(); if ($newDepth !== self::DEPTH_INFINITY) { $newDepth--; } foreach ($this->tree->getChildren($path) as $childNode) { $subPropFind = clone $propFind; $subPropFind->setDepth($newDepth); $subPath = $path ? $path . '/' . $childNode->getName() : $childNode->getName(); $subPropFind->setPath($subPath); $propFindRequests[] = [ $subPropFind, $childNode ]; if (($newDepth === self::DEPTH_INFINITY || $newDepth >= 1) && $childNode instanceof ICollection) { $this->addPathNodesRecursively($propFindRequests, $subPropFind); } } }
/** * This method is called when properties are retrieved. * * This specific handler is called very late in the process, because we * want other systems to first have a chance to handle the properties. * * @param PropFind $propFind * @param INode $node * @return void */ function propFindLate(PropFind $propFind, INode $node) { $propFind->handle('{http://calendarserver.org/ns/}getctag', function () use($propFind) { // If we already have a sync-token from the current propFind // request, we can re-use that. $val = $propFind->get('{http://sabredav.org/ns}sync-token'); if ($val) { return $val; } $val = $propFind->get('{DAV:}sync-token'); if ($val && is_scalar($val)) { return $val; } if ($val && $val instanceof Property\IHref) { return substr($val->getHref(), strlen(Sync\Plugin::SYNCTOKEN_PREFIX)); } // If we got here, the earlier two properties may simply not have // been part of the earlier request. We're going to fetch them. $result = $this->server->getProperties($propFind->getPath(), ['{http://sabredav.org/ns}sync-token', '{DAV:}sync-token']); if (isset($result['{http://sabredav.org/ns}sync-token'])) { return $result['{http://sabredav.org/ns}sync-token']; } if (isset($result['{DAV:}sync-token'])) { $val = $result['{DAV:}sync-token']; if (is_scalar($val)) { return $val; } elseif ($val instanceof Property\IHref) { return substr($val->getHref(), strlen(Sync\Plugin::SYNCTOKEN_PREFIX)); } } }); }
/** * Adds shares to propfind response * * @param PropFind $propFind propfind object * @param \Sabre\DAV\INode $sabreNode sabre node */ public function handleGetProperties(PropFind $propFind, \Sabre\DAV\INode $sabreNode) { if (!$sabreNode instanceof \OCA\DAV\Connector\Sabre\Node) { return; } // need prefetch ? if ($sabreNode instanceof \OCA\DAV\Connector\Sabre\Directory && $propFind->getDepth() !== 0 && !is_null($propFind->getStatus(self::SHARETYPES_PROPERTYNAME))) { $folderNode = $this->userFolder->get($propFind->getPath()); $children = $folderNode->getDirectoryListing(); $this->cachedShareTypes[$folderNode->getId()] = $this->getShareTypes($folderNode); foreach ($children as $childNode) { $this->cachedShareTypes[$childNode->getId()] = $this->getShareTypes($childNode); } } $propFind->handle(self::SHARETYPES_PROPERTYNAME, function () use($sabreNode) { if (isset($this->cachedShareTypes[$sabreNode->getId()])) { $shareTypes = $this->cachedShareTypes[$sabreNode->getId()]; } else { $node = $this->userFolder->get($sabreNode->getPath()); $shareTypes = $this->getShareTypes($node); } return new ShareTypeList($shareTypes); }); }
/** * Adds tags and favorites properties to the response, * if requested. * * @param PropFind $propFind * @param \Sabre\DAV\INode $node * @return void */ public function handleGetProperties(PropFind $propFind, \Sabre\DAV\INode $node) { if (!$node instanceof \OCA\DAV\Connector\Sabre\Node) { return; } // need prefetch ? if ($node instanceof \OCA\DAV\Connector\Sabre\Directory && $propFind->getDepth() !== 0 && (!is_null($propFind->getStatus(self::TAGS_PROPERTYNAME)) || !is_null($propFind->getStatus(self::FAVORITE_PROPERTYNAME)))) { // note: pre-fetching only supported for depth <= 1 $folderContent = $node->getChildren(); $fileIds[] = (int) $node->getId(); foreach ($folderContent as $info) { $fileIds[] = (int) $info->getId(); } $tags = $this->getTagger()->getTagsForObjects($fileIds); if ($tags === false) { // the tags API returns false on error... $tags = array(); } $this->cachedTags = $this->cachedTags + $tags; $emptyFileIds = array_diff($fileIds, array_keys($tags)); // also cache the ones that were not found foreach ($emptyFileIds as $fileId) { $this->cachedTags[$fileId] = []; } } $tags = null; $isFav = null; $propFind->handle(self::TAGS_PROPERTYNAME, function () use($tags, &$isFav, $node) { list($tags, $isFav) = $this->getTagsAndFav($node->getId()); return new TagList($tags); }); $propFind->handle(self::FAVORITE_PROPERTYNAME, function () use($isFav, $node) { if (is_null($isFav)) { list(, $isFav) = $this->getTagsAndFav($node->getId()); } return $isFav; }); }
/** * This method is triggered whenever properties are requested for a node. * We intercept this to see if we must return a {DAV:}sync-token. * * @param DAV\PropFind $propFind * @param DAV\INode $node * @return void */ function propFind(DAV\PropFind $propFind, DAV\INode $node) { $propFind->handle('{DAV:}sync-token', function () use($node) { if (!$node instanceof ISyncCollection || !($token = $node->getSyncToken())) { return; } return self::SYNCTOKEN_PREFIX . $token; }); }
/** * Triggered before properties are looked up in specific nodes. * * @param DAV\PropFind $propFind * @param DAV\INode $node * @param array $requestedProperties * @param array $returnedProperties * @TODO really should be broken into multiple methods, or even a class. * @return bool */ function propFind(DAV\PropFind $propFind, DAV\INode $node) { $path = $propFind->getPath(); // Checking the read permission if (!$this->checkPrivileges($path, '{DAV:}read', self::R_PARENT, false)) { // User is not allowed to read properties // Returning false causes the property-fetching system to pretend // that the node does not exist, and will cause it to be hidden // from listings such as PROPFIND or the browser plugin. if ($this->hideNodesFromListings) { return false; } // Otherwise we simply mark every property as 403. foreach ($propFind->getRequestedProperties() as $requestedProperty) { $propFind->set($requestedProperty, null, 403); } return; } /* Adding principal properties */ if ($node instanceof IPrincipal) { $propFind->handle('{DAV:}alternate-URI-set', function () use($node) { return new DAV\Property\HrefList($node->getAlternateUriSet()); }); $propFind->handle('{DAV:}principal-URL', function () use($node) { return new DAV\Property\Href($node->getPrincipalUrl() . '/'); }); $propFind->handle('{DAV:}group-member-set', function () use($node) { $members = $node->getGroupMemberSet(); foreach ($members as $k => $member) { $members[$k] = rtrim($member, '/') . '/'; } return new DAV\Property\HrefList($members); }); $propFind->handle('{DAV:}group-membership', function () use($node) { $members = $node->getGroupMembership(); foreach ($members as $k => $member) { $members[$k] = rtrim($member, '/') . '/'; } return new DAV\Property\HrefList($members); }); $propFind->handle('{DAV:}displayname', [$node, 'getDisplayName']); } $propFind->handle('{DAV:}principal-collection-set', function () { $val = $this->principalCollectionSet; // Ensuring all collections end with a slash foreach ($val as $k => $v) { $val[$k] = $v . '/'; } return new DAV\Property\HrefList($val); }); $propFind->handle('{DAV:}current-user-principal', function () { if ($url = $this->getCurrentUserPrincipal()) { return new Property\Principal(Property\Principal::HREF, $url . '/'); } else { return new Property\Principal(Property\Principal::UNAUTHENTICATED); } }); $propFind->handle('{DAV:}supported-privilege-set', function () use($node) { return new Property\SupportedPrivilegeSet($this->getSupportedPrivilegeSet($node)); }); $propFind->handle('{DAV:}current-user-privilege-set', function () use($node, $propFind, $path) { if (!$this->checkPrivileges($path, '{DAV:}read-current-user-privilege-set', self::R_PARENT, false)) { $propFind->set('{DAV:}current-user-privilege-set', null, 403); } else { $val = $this->getCurrentUserPrivilegeSet($node); if (!is_null($val)) { return new Property\CurrentUserPrivilegeSet($val); } } }); $propFind->handle('{DAV:}acl', function () use($node, $propFind, $path) { /* The ACL property contains all the permissions */ if (!$this->checkPrivileges($path, '{DAV:}read-acl', self::R_PARENT, false)) { $propFind->set('{DAV:}acl', null, 403); } else { $acl = $this->getACL($node); if (!is_null($acl)) { return new Property\Acl($this->getACL($node)); } } }); $propFind->handle('{DAV:}acl-restrictions', function () { return new Property\AclRestrictions(); }); /* Adding ACL properties */ if ($node instanceof IACL) { $propFind->handle('{DAV:}owner', function () use($node) { return new DAV\Property\Href($node->getOwner() . '/'); }); } }
/** * This event is triggered when fetching properties. * * This event is scheduled late in the process, after most work for * propfind has been done. */ function propFindLate(DAV\PropFind $propFind, DAV\INode $node) { // If the request was made using the SOGO connector, we must rewrite // the content-type property. By default SabreDAV will send back // text/x-vcard; charset=utf-8, but for SOGO we must strip that last // part. if (strpos($this->server->httpRequest->getHeader('User-Agent'), 'Thunderbird') === false) { return; } $contentType = $propFind->get('{DAV:}getcontenttype'); list($part) = explode(';', $contentType); if ($part === 'text/x-vcard' || $part === 'text/vcard') { $propFind->set('{DAV:}getcontenttype', 'text/x-vcard'); } }
/** * Creates the PROPFIND object * * @param string $path */ function __construct($path) { parent::__construct($path, []); }
/** * This method handler is invoked during fetching of properties. * * We use this event to add calendar-auto-schedule-specific properties. * * @param PropFind $propFind * @param INode $node * @return void */ function propFind(PropFind $propFind, INode $node) { if (!$node instanceof DAVACL\IPrincipal) { return; } $caldavPlugin = $this->server->getPlugin('caldav'); $principalUrl = $node->getPrincipalUrl(); // schedule-outbox-URL property $propFind->handle('{' . self::NS_CALDAV . '}schedule-outbox-URL', function () use($principalUrl, $caldavPlugin) { $calendarHomePath = $caldavPlugin->getCalendarHomeForPrincipal($principalUrl); $outboxPath = $calendarHomePath . '/outbox/'; return new Href($outboxPath); }); // schedule-inbox-URL property $propFind->handle('{' . self::NS_CALDAV . '}schedule-inbox-URL', function () use($principalUrl, $caldavPlugin) { $calendarHomePath = $caldavPlugin->getCalendarHomeForPrincipal($principalUrl); $inboxPath = $calendarHomePath . '/inbox/'; return new Href($inboxPath); }); $propFind->handle('{' . self::NS_CALDAV . '}schedule-default-calendar-URL', function () use($principalUrl, $caldavPlugin) { // We don't support customizing this property yet, so in the // meantime we just grab the first calendar in the home-set. $calendarHomePath = $caldavPlugin->getCalendarHomeForPrincipal($principalUrl); $sccs = '{' . self::NS_CALDAV . '}supported-calendar-component-set'; $result = $this->server->getPropertiesForPath($calendarHomePath, ['{DAV:}resourcetype', $sccs], 1); foreach ($result as $child) { if (!isset($child[200]['{DAV:}resourcetype']) || !$child[200]['{DAV:}resourcetype']->is('{' . self::NS_CALDAV . '}calendar') || $child[200]['{DAV:}resourcetype']->is('{http://calendarserver.org/ns/}shared')) { // Node is either not a calendar or a shared instance. continue; } if (!isset($child[200][$sccs]) || in_array('VEVENT', $child[200][$sccs]->getValue())) { // Either there is no supported-calendar-component-set // (which is fine) or we found one that supports VEVENT. return new Href($child['href']); } } }); // The server currently reports every principal to be of type // 'INDIVIDUAL' $propFind->handle('{' . self::NS_CALDAV . '}calendar-user-type', function () { return 'INDIVIDUAL'; }); }