initial working version

supports grammar discovery, schema discovery and search

src/DAV/SearchPlugin.php

@@ -0,0 +1,215 @@
+<?php
+/**
+ * @copyright Copyright (c) 2017 Robin Appelman <robin@icewind.nl>
+ *
+ * @license GNU AGPL version 3 or any later version
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+namespace SearchDAV\DAV;
+
+use Sabre\DAV\Exception\BadRequest;
+use Sabre\DAV\INode;
+use Sabre\DAV\Node;
+use Sabre\DAV\PropFind;
+use Sabre\DAV\Server;
+use Sabre\DAV\ServerPlugin;
+use Sabre\DAV\Xml\Element\Response;
+use Sabre\DAV\Xml\Response\MultiStatus;
+use Sabre\HTTP\RequestInterface;
+use Sabre\HTTP\ResponseInterface;
+use Sabre\Xml\Writer;
+use SearchDAV\Backend\ISearchBackend;
+use SearchDAV\Backend\SearchPropertyDefinition;
+use SearchDAV\Backend\SearchResult;
+use SearchDAV\XML\BasicSearch;
+use SearchDAV\XML\BasicSearchSchema;
+use SearchDAV\XML\PropDesc;
+use SearchDAV\XML\QueryDiscoverResponse;
+use SearchDAV\XML\Scope;
+use SearchDAV\XML\SupportedQueryGrammar;
+
+class SearchPlugin extends ServerPlugin {
+	/** @var Server */
+	private $server;
+
+	/** @var ISearchBackend */
+	private $searchBackend;
+
+	/** @var QueryParser */
+	private $queryParser;
+
+	public function __construct(ISearchBackend $searchBackend) {
+		$this->searchBackend = $searchBackend;
+	}
+
+	public function initialize(Server $server) {
+		$this->server = $server;
+		$this->queryParser = new QueryParser($this->server->xml);
+		$server->on('method:SEARCH', [$this, 'searchHandler']);
+		$server->on('afterMethod:OPTIONS', [$this, 'optionHandler']);
+		$server->on('propFind', [$this, 'propFindHandler']);
+	}
+
+	public function propFindHandler(PropFind $propFind, INode $node) {
+		if ($propFind->getPath() === $this->searchBackend->getArbiterPath()) {
+			$propFind->handle('{DAV:}supported-query-grammar-set', new SupportedQueryGrammar());
+		}
+	}
+
+	/**
+	 * SEARCH is allowed for users files
+	 *
+	 * @param string $uri
+	 * @return array
+	 */
+	public function getHTTPMethods($uri) {
+		$path = ($uri === '' && $this->server->getBaseUri() === '/') ? '' : $this->server->calculateUri($uri);
+		if ($this->searchBackend->getArbiterPath() === $path) {
+			return ['SEARCH'];
+		} else {
+			return [];
+		}
+	}
+
+	public function optionHandler(RequestInterface $request, ResponseInterface $response) {
+		if ($request->getPath() === '') {
+			$response->addHeader('DASL', '<DAV:basicsearch>');
+		}
+	}
+
+	public function searchHandler(RequestInterface $request, ResponseInterface $response) {
+		$contentType = $request->getHeader('Content-Type');
+
+		// Currently we only support xml search queries
+		if ((strpos($contentType, 'text/xml') === false) && (strpos($contentType, 'application/xml') === false)) {
+			return;
+		}
+
+		$xml = $this->queryParser->parse(
+			$request->getBody(),
+			$request->getUrl(),
+			$documentType
+		);
+
+		switch ($documentType) {
+			case '{DAV:}searchrequest':
+				if (!$xml['{DAV:}basicsearch']) {
+					throw new BadRequest('Unexpected xml content for searchrequest, expected basicsearch');
+				}
+				/** @var BasicSearch $query */
+				$query = $xml['{DAV:}basicsearch'];
+				$node = $this->server->tree->getNodeForPath($request->getPath());
+				$response->setStatus(207);
+				$response->setHeader('Content-Type', 'application/xml; charset="utf-8"');
+				$results = $this->searchBackend->search($node, $query);
+				$data = $this->server->generateMultiStatus($this->getPropertiesIteratorResults($results, $query->select), false);
+				$response->setBody($data);
+				return false;
+			case '{DAV:}query-schema-discovery':
+				if (!$xml['{DAV:}basicsearch']) {
+					throw new BadRequest('Unexpected xml content for query-schema-discovery, expected basicsearch');
+				}
+				/** @var BasicSearch $query */
+				$query = $xml['{DAV:}basicsearch'];
+				$scopes = $query->from;
+				$results = array_map(function(Scope $scope) {
+					if ($this->searchBackend->isValidScope($scope->href, $scope->depth)) {
+						$searchProperties = $this->searchBackend->getPropertyDefinitionsForScope($scope->href);
+						$searchSchema = $this->getBasicSearchForProperties($searchProperties);
+						return new QueryDiscoverResponse($scope->href, $searchSchema , 200);
+					} else {
+						return new QueryDiscoverResponse($scope->href, null, 404); // TODO something other than 404? 403 maybe
+					}
+				}, $scopes);
+				$multiStatus = new MultiStatus($results);
+				$response->setStatus(207);
+				$response->setHeader('Content-Type', 'application/xml; charset="utf-8"');
+				$response->setBody($this->queryParser->write('{DAV:}multistatus', $multiStatus, $request->getUrl()));
+				return false;
+			default:
+				throw new BadRequest('Unexpected document type: ' . $documentType . ' for this Content-Type');
+		}
+	}
+
+	/**
+	 * Returns a list of properties for a given path
+	 *
+	 * The path that should be supplied should have the baseUrl stripped out
+	 * The list of properties should be supplied in Clark notation. If the list is empty
+	 * 'allprops' is assumed.
+	 *
+	 * If a depth of 1 is requested child elements will also be returned.
+	 *
+	 * @param SearchResult[] $results
+	 * @param array $propertyNames
+	 * @param int $depth
+	 * @return \Iterator
+	 */
+	function getPropertiesIteratorResults(array $results, $propertyNames = [], $depth = 0) {
+		$propFindType = $propertyNames ? PropFind::NORMAL : PropFind::ALLPROPS;
+
+		foreach ($results as $result) {
+			$node = $result->node;
+			$propFind = new PropFind($result->href, (array)$propertyNames, $depth, $propFindType);
+			$r = $this->server->getPropertiesByNode($propFind, $node);
+			if ($r) {
+				$result = $propFind->getResultForMultiStatus();
+				$result['href'] = $propFind->getPath();
+
+				// WebDAV recommends adding a slash to the path, if the path is
+				// a collection.
+				// Furthermore, iCal also demands this to be the case for
+				// principals. This is non-standard, but we support it.
+				$resourceType = $this->server->getResourceTypeForNode($node);
+				if (in_array('{DAV:}collection', $resourceType) || in_array('{DAV:}principal', $resourceType)) {
+					$result['href'] .= '/';
+				}
+				yield $result;
+			}
+		}
+	}
+
+	private function hashDefinition(SearchPropertyDefinition $definition) {
+		return $definition->dataType
+		. (($definition->searchable) ? '1' : '0')
+		. (($definition->sortable) ? '1' : '0')
+		. (($definition->selectable) ? '1' : '0');
+	}
+
+	/**
+	 * @param SearchPropertyDefinition[] $propertyDefinitions
+	 * @return BasicSearchSchema
+	 */
+	private function getBasicSearchForProperties(array $propertyDefinitions) {
+		/** @var PropDesc[] $groups */
+		$groups = [];
+		foreach ($propertyDefinitions as $propertyDefinition) {
+			$key = $this->hashDefinition($propertyDefinition);
+			if (!isset($groups[$key])) {
+				$desc = new PropDesc();
+				$desc->dataType = $propertyDefinition->dataType;
+				$desc->sortable = $propertyDefinition->sortable;
+				$desc->selectable = $propertyDefinition->selectable;
+				$desc->searchable = $propertyDefinition->searchable;
+				$groups[$key] = $desc;
+			}
+			$groups[$key]->properties[] = $propertyDefinition->name;
+		}
+
+		return new BasicSearchSchema(array_values($groups));
+	}
+}